[pstl] Remove the stdlib headers from the PSTL and move them to the tests

[ldionne]

Summary

PSTL should not provide those headers since they belong to the standard
library. Instead, we define a dummy standard library in the tests that
provides those headers.

[rodgert]

I'm not opposed to this change, but I wonder, should we then just remove the extra 'internal' directory, so that we get -

pstl/numeric_impl.h

?

Or should we move/rename the glue_Xxx files to pstl/ and keep everything else in pstl/internal ? Which is arguably now the library API after this change.

for libstdc++ I currently move 'internal' into 'pstl' so if do move/rename the glue files, I'd need to update my script (not an argument against doing this).

[ldionne]

In D60535#1463401, @rodgert wrote:

I'm not opposed to this change, but I wonder, should we then just remove the extra 'internal' directory, so that we get -

pstl/numeric_impl.h

?

Or should we move/rename the glue_Xxx files to pstl/ and keep everything else in pstl/internal ? Which is arguably now the library API after this change.

Yes, doing something like that was the next step I was planning. As a different patch, though. Everything that's not part of the API of the library would stay in internal.

pstl/trunk/include/pstl/algorithm

-// -*- C++ -*-
-//===-- algorithm ---------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_ALGORITHM
-#define _PSTL_ALGORITHM
-
-#include "internal/pstl_config.h"
-
-#if _PSTL_EXECUTION_POLICIES_DEFINED
-// If <execution> has already been included, pull in implementations
-#    include "internal/glue_algorithm_impl.h"
-#else
-// Otherwise just pull in forward declarations
-#    include "internal/glue_algorithm_defs.h"
-#    define _PSTL_ALGORITHM_FORWARD_DECLARED 1
-#endif
-
-#endif /* _PSTL_ALGORITHM */

pstl/trunk/include/pstl/execution

-// -*- C++ -*-
-//===-- execution ---------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_EXECUTION
-#define _PSTL_EXECUTION
-
-#include "internal/pstl_config.h"
-#include "internal/execution_defs.h"
-
-#define _PSTL_EXECUTION_POLICIES_DEFINED 1
-
-#if _PSTL_ALGORITHM_FORWARD_DECLARED
-#    include "internal/glue_algorithm_impl.h"
-#endif
-
-#if _PSTL_MEMORY_FORWARD_DECLARED
-#    include "internal/glue_memory_impl.h"
-#endif
-
-#if _PSTL_NUMERIC_FORWARD_DECLARED
-#    include "internal/glue_numeric_impl.h"
-#endif
-
-#if _PSTL_CPP17_EXECUTION_POLICIES_PRESENT
-_PSTL_PRAGMA_MESSAGE_POLICIES("The <Parallel STL> execution policies are defined in the namespace __pstl::execution")
-#else
-#    include "internal/glue_execution_defs.h"
-_PSTL_PRAGMA_MESSAGE_POLICIES(
-    "The <Parallel STL> execution policies are injected into the standard namespace std::execution")
-#endif
-
-//TODO: __pstl::execution namespace is injected into the pstl::execution namespace when the implementation is not a part of
-// standard C++ library
-namespace pstl
-{
-namespace execution
-{
-using namespace __pstl::execution;
-}
-} // namespace pstl
-
-#endif /* _PSTL_EXECUTION */

pstl/trunk/include/pstl/memory

-// -*- C++ -*-
-//===-- memory ------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_MEMORY
-#define _PSTL_MEMORY
-
-#include "internal/pstl_config.h"
-
-#if _PSTL_EXECUTION_POLICIES_DEFINED
-// If <execution> has already been included, pull in implementations
-#    include "internal/glue_memory_impl.h"
-#else
-// Otherwise just pull in forward declarations
-#    include "internal/glue_memory_defs.h"
-#    define _PSTL_MEMORY_FORWARD_DECLARED 1
-#endif
-
-#endif /* _PSTL_MEMORY */

pstl/trunk/include/pstl/numeric

-// -*- C++ -*-
-//===-- numeric -----------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _PSTL_NUMERIC
-#define _PSTL_NUMERIC
-
-#include "internal/pstl_config.h"
-
-#if _PSTL_EXECUTION_POLICIES_DEFINED
-// If <execution> has already been included, pull in implementations
-#    include "internal/glue_numeric_impl.h"
-#else
-// Otherwise just pull in forward declarations
-#    include "internal/glue_numeric_defs.h"
-#    define _PSTL_NUMERIC_FORWARD_DECLARED 1
-#endif
-
-#endif /* _PSTL_NUMERIC */

pstl/trunk/test/CMakeLists.txt

add_custom_target(pstl-build-tests
     COMMENT "Build all the pstl tests.")
 
 add_custom_target(check-pstl
     COMMAND "${CMAKE_CTEST_COMMAND}" --output-on-failure
     USES_TERMINAL
     DEPENDS pstl-build-tests
     COMMENT "Build and run all the unit tests.")
 
+add_library(test_stdlib INTERFACE)
+target_include_directories(test_stdlib INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/support/stdlib")
+target_link_libraries(test_stdlib INTERFACE pstl::ParallelSTL)
+
 file(GLOB_RECURSE UNIT_TESTS "*.pass.cpp")
 foreach(_file IN LISTS UNIT_TESTS)
     file(RELATIVE_PATH _target "${CMAKE_CURRENT_SOURCE_DIR}" "${_file}")
     string(REPLACE ".cpp" "" _target "${_target}")
     string(REPLACE "/" "-" _target "${_target}")
     set(_target "pstl-${_target}")
 
     add_executable(${_target} EXCLUDE_FROM_ALL "${_file}")
     target_include_directories(${_target} PRIVATE "${CMAKE_CURRENT_LIST_DIR}")
-    target_link_libraries(${_target} PRIVATE pstl::ParallelSTL)
-    target_compile_definitions(${_target} PRIVATE -DPSTL_STANDALONE_TESTS)
+    target_link_libraries(${_target} PRIVATE test_stdlib)
     set_target_properties(${_target} PROPERTIES CXX_EXTENSIONS NO
                                                 RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
     add_test(${_target} "${CMAKE_CURRENT_BINARY_DIR}/${_target}")
     add_dependencies(pstl-build-tests ${_target})
 endforeach()

pstl/trunk/test/pstl/header_inclusion_order_algorithm_0.pass.cpp

 // -*- C++ -*-
 //===-- header_inclusion_order_algorithm_0.pass.cpp -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 int32_t
 main()
 {
     return 0;
 }

pstl/trunk/test/pstl/header_inclusion_order_algorithm_1.pass.cpp

 // -*- C++ -*-
 //===-- header_inclusion_order_algorithm_1.pass.cpp -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/algorithm"
-#include "pstl/execution"
-#else
 #include <algorithm>
 #include <execution>
-#endif // PSTL_STANDALONE_TESTS
 
 int32_t
 main()
 {
     return 0;
 }

pstl/trunk/test/pstl/header_inclusion_order_memory_0.pass.cpp

 // -*- C++ -*-
 //===-- header_inclusion_order_memory_0.pass.cpp --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/memory"
-#else
 #include <execution>
 #include <memory>
-#endif // PSTL_STANDALONE_TESTS
 
 int32_t
 main()
 {
     return 0;
 }

pstl/trunk/test/pstl/header_inclusion_order_memory_1.pass.cpp

 // -*- C++ -*-
 //===-- header_inclusion_order_memory_1.pass.cpp --------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/memory"
-#include "pstl/execution"
-#else
 #include <memory>
 #include <execution>
-#endif // PSTL_STANDALONE_TESTS
 
 int32_t
 main()
 {
     return 0;
 }

pstl/trunk/test/pstl/header_inclusion_order_numeric_0.pass.cpp

 // -*- C++ -*-
 //===-- header_inclusion_order_numeric_0.pass.cpp -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/numeric"
-#else
 #include <execution>
 #include <numeric>
-#endif // PSTL_STANDALONE_TESTS
 
 int32_t
 main()
 {
     return 0;
 }

pstl/trunk/test/pstl/header_inclusion_order_numeric_1.pass.cpp

 // -*- C++ -*-
 //===-- header_inclusion_order_numeric_0.pass.cpp -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/numeric"
-#include "pstl/execution"
-#else
 #include <numeric>
 #include <execution>
-#endif // PSTL_STANDALONE_TESTS
 
 int32_t
 main()
 {
     return 0;
 }

pstl/trunk/test/std/algorithms/alg.merge/inplace_merge.pass.cpp

 // -*- C++ -*-
 //===-- inplace_merge.pass.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include <algorithm>
-#include "pstl/execution"
-#include "pstl/algorithm"
-
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_one_policy
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \

pstl/trunk/test/std/algorithms/alg.merge/merge.pass.cpp

 // -*- C++ -*-
 //===-- merge.pass.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include <algorithm>
-#include <functional>
-#include "pstl/execution"
-#include "pstl/algorithm"
-
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
+#include <functional>
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_merge
 {
     template <typename Policy, typename InputIterator1, typename InputIterator2, typename OutputIterator,

pstl/trunk/test/std/algorithms/alg.modifying.operations/alg.copy/copy_if.pass.cpp

 // -*- C++ -*-
 //===-- copy_if.pass.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Tests for copy_if and remove_copy_if
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct run_copy_if
 {
 #if _PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN // dummy specializations to skip testing in case of broken configuration

pstl/trunk/test/std/algorithms/alg.modifying.operations/alg.partitions/is_partitioned.pass.cpp

 // -*- C++ -*-
 //===-- is_partitioned.pass.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_one_policy
 {
     //dummy specialization by policy type, in case of broken configuration

pstl/trunk/test/std/algorithms/alg.modifying.operations/alg.partitions/partition.pass.cpp

 // -*- C++ -*-
 //===-- partition.pass.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Tests for stable_partition and partition
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
-
-#include "support/utils.h"
-
 #include <iterator>
 #include <type_traits>
 
+#include "support/utils.h"
+
 using namespace TestUtils;
 
 template <typename T>
 struct DataType
 {
     explicit DataType(int32_t k) : my_val(k) {}
     DataType(DataType&& input) { my_val = std::move(input.my_val); }
     DataType&

pstl/trunk/test/std/algorithms/alg.modifying.operations/alg.partitions/partition_copy.pass.cpp

 // -*- C++ -*-
 //===-- partition_copy.pass.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Tests for stable_partition and partition_copy
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
-
-#include "support/utils.h"
-
 #include <cstdlib>
 #include <iterator>
 
+#include "support/utils.h"
+
 using namespace TestUtils;
 
 struct test_partition_copy
 {
     template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2,
               typename UnaryOp>
     void
     operator()(Policy&& exec, InputIterator first, InputIterator last, OutputIterator true_first,

pstl/trunk/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse.pass.cpp

 // -*- C++ -*-
 //===-- reverse.pass.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
 #include <iterator>
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_one_policy
 {
 #if _PSTL_ICC_18_VC141_TEST_SIMD_LAMBDA_RELEASE_BROKEN || _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||     \

pstl/trunk/test/std/algorithms/alg.modifying.operations/alg.reverse/reverse_copy.pass.cpp

 // -*- C++ -*-
 //===-- reverse_copy.pass.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
 #include <iterator>
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct wrapper
 {

pstl/trunk/test/std/algorithms/alg.modifying.operations/copy_move.pass.cpp

 // -*- C++ -*-
 //===-- copy_move.pass.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Tests for copy, move and copy_n
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct run_copy
 {
 

pstl/trunk/test/std/algorithms/alg.modifying.operations/fill.pass.cpp

 // -*- C++ -*-
 //===-- fill.pass.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_fill
 {
     template <typename It, typename T>

pstl/trunk/test/std/algorithms/alg.modifying.operations/generate.pass.cpp

 // -*- C++ -*-
 //===-- generate.pass.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
 #include <atomic>
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct Generator_count
 {

pstl/trunk/test/std/algorithms/alg.modifying.operations/remove.pass.cpp

 // -*- C++ -*-
 //===-- remove.pass.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Test for remove, remove_if
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct run_remove
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \

pstl/trunk/test/std/algorithms/alg.modifying.operations/remove_copy.pass.cpp

 // -*- C++ -*-
 //===-- remove_copy.pass.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct run_remove_copy
 {
     template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,

pstl/trunk/test/std/algorithms/alg.modifying.operations/replace.pass.cpp

 // -*- C++ -*-
 //===-- replace.pass.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 // This class is needed to check the self-copying
 struct copy_int
 {

pstl/trunk/test/std/algorithms/alg.modifying.operations/replace_copy.pass.cpp

 // -*- C++ -*-
 //===-- replace_copy.pass.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Tests for replace_copy and replace_copy_if
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_replace_copy
 {
     template <typename Policy, typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,

pstl/trunk/test/std/algorithms/alg.modifying.operations/rotate.pass.cpp

 // -*- C++ -*-
 //===-- rotate.pass.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
 #include <iterator>
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct wrapper
 {

pstl/trunk/test/std/algorithms/alg.modifying.operations/rotate_copy.pass.cpp

 // -*- C++ -*-
 //===-- rotate_copy.pass.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
 #include <iterator>
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct wrapper;
 

pstl/trunk/test/std/algorithms/alg.modifying.operations/swap_ranges.pass.cpp

 // -*- C++ -*-
 //===-- swap_ranges.pass.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
 #include <iterator>
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct wrapper
 {

pstl/trunk/test/std/algorithms/alg.modifying.operations/transform_binary.pass.cpp

 // -*- C++ -*-
 //===-- transform_binary.pass.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename In1, typename In2, typename Out>
 class TheOperation
 {

pstl/trunk/test/std/algorithms/alg.modifying.operations/transform_unary.pass.cpp

 // -*- C++ -*-
 //===-- transform_unary.pass.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename InputIterator, typename OutputIterator>
 void
 check_and_reset(InputIterator first, InputIterator last, OutputIterator out_first)

pstl/trunk/test/std/algorithms/alg.modifying.operations/unique.pass.cpp

 // -*- C++ -*-
 //===-- unique.pass.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Test for unique
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct run_unique
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \

pstl/trunk/test/std/algorithms/alg.modifying.operations/unique_copy_equal.pass.cpp

 // -*- C++ -*-
 //===-- unique_copy_equal.pass.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Tests for unique_copy
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct run_unique_copy
 {
 #if _PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN // dummy specializations to skip testing in case of broken configuration

pstl/trunk/test/std/algorithms/alg.nonmodifying/adjacent_find.pass.cpp

 // -*- C++ -*-
 //===-- adjacent_find.pass.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_adjacent_find
 {
     template <typename Policy, typename Iterator, typename Pred>

pstl/trunk/test/std/algorithms/alg.nonmodifying/all_of.pass.cpp

 // -*- C++ -*-
 //===-- all_of.pass.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 /*
   TODO: consider implementing the following tests for a better code coverage
   - correctness
   - bad input argument (if applicable)
   - data corruption around/of input and output

pstl/trunk/test/std/algorithms/alg.nonmodifying/any_of.pass.cpp

 // -*- C++ -*-
 //===-- any_of.pass.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 /*
   TODO: consider implementing the following tests for a better code coverage
   - correctness
   - bad input argument (if applicable)
   - data corruption around/of input and output

pstl/trunk/test/std/algorithms/alg.nonmodifying/count.pass.cpp

 // -*- C++ -*-
 //===-- count.pass.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Tests for count and count_if
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_count
 {
     template <typename Policy, typename Iterator, typename T>

pstl/trunk/test/std/algorithms/alg.nonmodifying/equal.pass.cpp

 // -*- C++ -*-
 //===-- equal.pass.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 #define CPP14_ENABLED 0
 
 struct UserType

pstl/trunk/test/std/algorithms/alg.nonmodifying/find.pass.cpp

 // -*- C++ -*-
 //===-- find.pass.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Tests for find
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_find
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \

pstl/trunk/test/std/algorithms/alg.nonmodifying/find_end.pass.cpp

 // -*- C++ -*-
 //===-- find_end.pass.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_one_policy
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \

pstl/trunk/test/std/algorithms/alg.nonmodifying/find_first_of.pass.cpp

 // -*- C++ -*-
 //===-- find_first_of.pass.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_one_policy
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \

pstl/trunk/test/std/algorithms/alg.nonmodifying/find_if.pass.cpp

 // -*- C++ -*-
 //===-- find_if.pass.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Tests for find_if and find_if_not
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_find_if
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \

pstl/trunk/test/std/algorithms/alg.nonmodifying/for_each.pass.cpp

 // -*- C++ -*-
 //===-- for_each.pass.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename Type>
 struct Gen
 {

pstl/trunk/test/std/algorithms/alg.nonmodifying/mismatch.pass.cpp

 // -*- C++ -*-
 //===-- mismatch.pass.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#include "pstl/numeric"
-#include "pstl/memory"
-
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_mismatch
 {
     template <typename Policy, typename Iterator1, typename Iterator2>

pstl/trunk/test/std/algorithms/alg.nonmodifying/none_of.pass.cpp

 // -*- C++ -*-
 //===-- none_of.pass.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 /*
   TODO: consider implementing the following tests for a better code coverage
   - correctness
   - bad input argument (if applicable)
   - data corruption around/of input and output

pstl/trunk/test/std/algorithms/alg.nonmodifying/nth_element.pass.cpp

 // -*- C++ -*-
 //===-- nth_element.pass.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include <algorithm>
 #include <iostream>
-#include "pstl/execution"
-#include "pstl/algorithm"
-
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 // User defined type with minimal requirements
 template <typename T>
 struct DataType

pstl/trunk/test/std/algorithms/alg.nonmodifying/search_n.pass.cpp

 // -*- C++ -*-
 //===-- search_n.pass.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_one_policy
 {
 #if _PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \

pstl/trunk/test/std/algorithms/alg.sorting/alg.heap.operations/is_heap.pass.cpp

 // -*- C++ -*-
 //===-- is_heap.pass.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Tests for is_heap, is_heap_until
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 #include <iostream>
 
 using namespace TestUtils;
 
 struct WithCmpOp
 {

pstl/trunk/test/std/algorithms/alg.sorting/alg.lex.comparison/lexicographical_compare.pass.cpp

 // -*- C++ -*-
 //===-- lexicographical_compare.pass.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
 #include <iostream>
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_one_policy
 {
 

pstl/trunk/test/std/algorithms/alg.sorting/alg.min.max/minmax_element.pass.cpp

 // -*- C++ -*-
 //===-- minmax_element.pass.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
-
-#include "support/utils.h"
-
 #include <set>
 #include <cassert>
 #include <cmath>
 
+#include "support/utils.h"
+
 using namespace TestUtils;
 
 struct check_minelement
 {
     template <typename Policy, typename Iterator>
     void
     operator()(Policy&& exec, Iterator begin, Iterator end)
     {

pstl/trunk/test/std/algorithms/alg.sorting/alg.set.operations/includes.pass.cpp

 // -*- C++ -*-
 //===-- includes.pass.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-
 #include <cmath>
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct Num
 {

pstl/trunk/test/std/algorithms/alg.sorting/alg.set.operations/set.pass.cpp

 // -*- C++ -*-
 //===-- set.pass.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-
 #include <cmath>
 #include <chrono>
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct Num
 {

pstl/trunk/test/std/algorithms/alg.sorting/is_sorted.pass.cpp

 // -*- C++ -*-
 //===-- is_sorted.pass.cpp ------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_is_sorted
 {
     template <typename Policy, typename Iterator>

pstl/trunk/test/std/algorithms/alg.sorting/partial_sort.pass.cpp

 // -*- C++ -*-
 //===-- partial_sort.pass.cpp ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-
 #include <cmath>
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 static std::atomic<int32_t> count_val;
 static std::atomic<int32_t> count_comp;
 

pstl/trunk/test/std/algorithms/alg.sorting/partial_sort_copy.pass.cpp

 // -*- C++ -*-
 //===-- partial_sort_copy.pass.cpp ----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Tests for partial_sort_copy
 
-#include <cmath>
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
+#include <cmath>
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct Num
 {

pstl/trunk/test/std/algorithms/alg.sorting/sort.pass.cpp

 // -*- C++ -*-
 //===-- sort.pass.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#else
 #include <execution>
 #include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 #define _CRT_SECURE_NO_WARNINGS
 
 #include <atomic>
 

pstl/trunk/test/std/numerics/numeric.ops/adjacent_difference.pass.cpp

 // -*- C++ -*-
 //===-- adjacent_difference.pass.cpp --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
 #include <iterator>
-
-#include "pstl/execution"
-#include "pstl/algorithm"
-#include "pstl/numeric"
-#else
 #include <execution>
-#include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
+#include <numeric>
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct wrapper
 {

pstl/trunk/test/std/numerics/numeric.ops/reduce.pass.cpp

 // -*- C++ -*-
 //===-- reduce.pass.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/numeric"
-#else
 #include <execution>
 #include <numeric>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_long_forms_for_one_policy
 {
     template <typename Policy, typename Iterator, typename T, typename BinaryOp>

pstl/trunk/test/std/numerics/numeric.ops/scan.pass.cpp

 // -*- C++ -*-
 //===-- scan.pass.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/numeric"
-#else
 #include <execution>
 #include <numeric>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 // We provide the no execution policy versions of the exclusive_scan and inclusive_scan due checking correctness result of the versions with execution policies.
 //TODO: to add a macro for availability of ver implementations
 template <class InputIterator, class OutputIterator, class T>

pstl/trunk/test/std/numerics/numeric.ops/transform_reduce.pass.cpp

 // -*- C++ -*-
 //===-- transform_reduce.pass.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-
-#include "pstl/execution"
-#include "pstl/numeric"
-#else
 #include <execution>
 #include <numeric>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 // Equal for all types
 template <typename T>
 static bool

pstl/trunk/test/std/numerics/numeric.ops/transform_scan.pass.cpp

 // -*- C++ -*-
 //===-- transform_scan.pass.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/numeric"
-#else
 #include <execution>
 #include <numeric>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 // Most of the framework required for testing inclusive and exclusive transform-scans is identical,
 // so the tests for both are in this file.  Which is being tested is controlled by the global
 // flag inclusive, which is set to each alternative by main().

pstl/trunk/test/std/utilities/memory/specialized.algorithms/uninitialized_construct.pass.cpp

 // -*- C++ -*-
 //===-- uninitialized_construct.pass.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Tests for uninitialized_default_construct, uninitialized_default_construct_n,
 //           uninitialized_value_construct,   uninitialized_value_construct_n
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/memory"
-#else
 #include <execution>
 #include <memory>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 // function of checking correctness for uninitialized.construct.value
 template <typename T, typename Iterator>
 bool

pstl/trunk/test/std/utilities/memory/specialized.algorithms/uninitialized_copy_move.pass.cpp

 // -*- C++ -*-
 //===-- uninitialized_copy_move.pass.cpp ----------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // Tests for uninitialized_copy, uninitialized_copy_n, uninitialized_move, uninitialized_move_n
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-#include "pstl/execution"
-#include "pstl/memory"
-#else
 #include <execution>
 #include <memory>
-#endif // PSTL_STANDALONE_TESTS
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 // function of checking correctness for uninitialized.construct.value
 template <typename InputIterator, typename OutputIterator, typename Size>
 bool

pstl/trunk/test/std/utilities/memory/specialized.algorithms/uninitialized_fill_destroy.pass.cpp

 // -*- C++ -*-
 //===-- uninitialized_fill_destroy.pass.cpp -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "support/pstl_test_config.h"
 
-#ifdef PSTL_STANDALONE_TESTS
-
-#include "pstl/execution"
-#include "pstl/memory"
-#include "pstl/algorithm"
-#else
 #include <execution>
-#include <algorithm>
-#endif // PSTL_STANDALONE_TESTS
+#include <memory>
 
 #include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_uninitialized_fill_destroy
 {
     template <typename Policy, typename Iterator, typename T>

pstl/trunk/test/support/stdlib/algorithm

+// -*- C++ -*-
+//===-- algorithm ---------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _TEST_SUPPORT_STDLIB_ALGORITHM
+#define _TEST_SUPPORT_STDLIB_ALGORITHM
+
+#include_next <algorithm>
+
+#include <pstl/internal/pstl_config.h>
+
+#if _PSTL_EXECUTION_POLICIES_DEFINED
+// If <execution> has already been included, pull in implementations
+#    include <pstl/internal/glue_algorithm_impl.h>
+#else
+// Otherwise just pull in forward declarations
+#    include <pstl/internal/glue_algorithm_defs.h>
+#    define _PSTL_ALGORITHM_FORWARD_DECLARED 1
+#endif
+
+#endif /* _TEST_SUPPORT_STDLIB_ALGORITHM */

pstl/trunk/test/support/stdlib/execution

+// -*- C++ -*-
+//===-- execution ---------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _TEST_SUPPORT_STDLIB_EXECUTION
+#define _TEST_SUPPORT_STDLIB_EXECUTION
+
+// #include_next <execution> // None of the standard libraries PSTL is built on top have the <execution> header yet.
+
+#include <pstl/internal/pstl_config.h>
+#include <pstl/internal/execution_defs.h>
+
+#define _PSTL_EXECUTION_POLICIES_DEFINED 1
+
+#if _PSTL_ALGORITHM_FORWARD_DECLARED
+#    include <pstl/internal/glue_algorithm_impl.h>
+#endif
+
+#if _PSTL_MEMORY_FORWARD_DECLARED
+#    include <pstl/internal/glue_memory_impl.h>
+#endif
+
+#if _PSTL_NUMERIC_FORWARD_DECLARED
+#    include <pstl/internal/glue_numeric_impl.h>
+#endif
+
+#if _PSTL_CPP17_EXECUTION_POLICIES_PRESENT
+_PSTL_PRAGMA_MESSAGE_POLICIES("The <Parallel STL> execution policies are defined in the namespace __pstl::execution")
+#else
+#    include <pstl/internal/glue_execution_defs.h>
+_PSTL_PRAGMA_MESSAGE_POLICIES(
+    "The <Parallel STL> execution policies are injected into the standard namespace std::execution")
+#endif
+
+//TODO: __pstl::execution namespace is injected into the pstl::execution namespace when the implementation is not a part of
+// standard C++ library
+namespace pstl
+{
+namespace execution
+{
+using namespace __pstl::execution;
+}
+} // namespace pstl
+
+#endif /* _TEST_SUPPORT_STDLIB_EXECUTION */

pstl/trunk/test/support/stdlib/memory

+// -*- C++ -*-
+//===-- memory ------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _TEST_SUPPORT_STDLIB_MEMORY
+#define _TEST_SUPPORT_STDLIB_MEMORY
+
+#include_next <memory>
+
+#include <pstl/internal/pstl_config.h>
+
+#if _PSTL_EXECUTION_POLICIES_DEFINED
+// If <execution> has already been included, pull in implementations
+#    include <pstl/internal/glue_memory_impl.h>
+#else
+// Otherwise just pull in forward declarations
+#    include <pstl/internal/glue_memory_defs.h>
+#    define _PSTL_MEMORY_FORWARD_DECLARED 1
+#endif
+
+#endif /* _TEST_SUPPORT_STDLIB_MEMORY */

pstl/trunk/test/support/stdlib/numeric

+// -*- C++ -*-
+//===-- numeric -----------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _TEST_SUPPORT_STDLIB_NUMERIC
+#define _TEST_SUPPORT_STDLIB_NUMERIC
+
+#include_next <numeric>
+
+#include <pstl/internal/pstl_config.h>
+
+#if _PSTL_EXECUTION_POLICIES_DEFINED
+// If <execution> has already been included, pull in implementations
+#    include <pstl/internal/glue_numeric_impl.h>
+#else
+// Otherwise just pull in forward declarations
+#    include <pstl/internal/glue_numeric_defs.h>
+#    define _PSTL_NUMERIC_FORWARD_DECLARED 1
+#endif
+
+#endif /* _TEST_SUPPORT_STDLIB_NUMERIC */