Restructure existing test suite to follow libc++ standard layout

[rodgert]

Summary

Includes basic CMake/CTest driver for restructured tests

remove old test directory, rename testsuite->test

[ldionne]

test/CMakeLists.txt

10

I don't understand why we're changing this file. The previous one works just as well, but it does not require adding CMakeLists.txts all over the place in the tree (which just won't scale to the number of tests that will be in the suite).

The next improvement over this should be to run the tests with lit (but should be tackled separately).

[ldionne]

To be clear about what I'd like: please do not add CMakeLists.txts all over the tree, instead keep relying on GLOB_RECURSE like my current test/CMakeLists.txt does.

[rodgert]

In D59110#1426159, @ldionne wrote:

To be clear about what I'd like: please do not add CMakeLists.txts all over the tree, instead keep relying on GLOB_RECURSE like my current test/CMakeLists.txt does.

Sure, I can make that change. The CMakeLists.txt's were generated by a migration script I wrote to restructure the original test suite. I expected to nuke all of that anyway once lit was tackled.

[rodgert]

• Remove nested CMakeLists.txt in test/std, replace with glob-recurse

[ldionne]

test/CMakeLists.txt

21

Please use target_include_directories("pstl-${target}" PRIVATE "${CMAKE_CURRENT_LIST_DIR}") below instead. "${PROJECT_SOURCE_DIR}/include" shouldn't be necessary at all since the tests link against pstl::ParallelSTL, which has "${PROJECT_SOURCE_DIR}/include" as an INTERFACE include directory.

24

Please use target_compile_definitions("pstl-${target}" PRIVATE -DPSTL_STANDALONE_TESTS) below instead. Setting global flags is frowned upon in modern CMake.

[rodgert]

Applied by "other means"

CMakeLists.txt

if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/../${TBB_DIR_NAME}/cmake")
         get_filename_component(TBB_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../${TBB_DIR_NAME}/cmake" ABSOLUTE)
     endif()
 endif()
 
 add_library(ParallelSTL INTERFACE)
 add_library(pstl::ParallelSTL ALIAS ParallelSTL)
 
 if (PARALLELSTL_USE_PARALLEL_POLICIES)
+    message(STATUS "Using Parallel Policies")
     if (PARALLELSTL_BACKEND STREQUAL "tbb")
         find_package(TBB 2018 REQUIRED tbb OPTIONAL_COMPONENTS tbbmalloc)
         message(STATUS "Parallel STL uses TBB ${TBB_VERSION} (interface version: ${TBB_INTERFACE_VERSION})")
         target_link_libraries(ParallelSTL INTERFACE TBB::tbb)
       else()
+        message(STATUS "Using Parallel Policies, but not tbb")
         if (TARGET ${PARALLELSTL_BACKEND})
             target_link_libraries(ParallelSTL INTERFACE ${PARALLELSTL_BACKEND})
         else()
             find_package(${PARALLELSTL_BACKEND} REQUIRED)
             target_link_libraries(ParallelSTL INTERFACE ${${PARALLELSTL_BACKEND}_IMPORTED_TARGETS})
         endif()
     endif()
 else()

test/CMakeLists.txt

 #===-- CMakeLists.txt ----------------------------------------------------===##
 #
 # 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
 #
 #===----------------------------------------------------------------------===##
 
 # TODO(ldionne): This CMake testing infrastructure should be replaced with a
 #                llvm-lit test suite.
 
 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.")
 
-file(GLOB_RECURSE UNIT_TESTS "test_*.cpp")
+include_directories("${PROJECT_SOURCE_DIR}/include"
+                    ${CMAKE_CURRENT_LIST_DIR})
+
+add_definitions(-DPSTL_STANDALONE_TESTS)
+
+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_link_libraries(${_target} PRIVATE pstl::ParallelSTL)
     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()
+

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

 // -*- C++ -*-
-//===-- test_inplace_merge.cpp --------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include <algorithm>
 #include "pstl/execution"
 #include "pstl/algorithm"
 
-#include "utils.h"
+#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_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
     template <typename BiDirIt1, typename Size, typename Generator1, typename Generator2, typename Compare>

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

 // -*- C++ -*-
-//===-- test_merge.cpp ----------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include <algorithm>
 #include <functional>
 #include "pstl/execution"
 #include "pstl/algorithm"
 
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_merge
 {
     template <typename Policy, typename InputIterator1, typename InputIterator2, typename OutputIterator,
               typename Compare>
     void

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

 // -*- C++ -*-
-//===-- test_copy_if.cpp --------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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
     template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
               typename Predicate, typename T>

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

 // -*- C++ -*-
-//===-- test_is_partitioned.cpp -------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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
 #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN
 

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

 // -*- C++ -*-
-//===-- test_partition.cpp ------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 #include <iterator>
 #include <type_traits>
 
 using namespace TestUtils;
 
 template <typename T>
 struct DataType

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

 // -*- C++ -*-
-//===-- test_partition_copy.cpp -------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 #include <cstdlib>
 #include <iterator>
 
 using namespace TestUtils;
 
 struct test_partition_copy
 {

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

 // -*- C++ -*-
-//===-- test_reverse.cpp --------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include <iterator>
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN // dummy specialization by policy type, in case of broken configuration
     template <typename Iterator1, typename Iterator2>

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

 // -*- C++ -*-
-//===-- test_reverse_copy.cpp ---------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include <iterator>
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct wrapper
 {
     T t;
     wrapper() {}

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

 // -*- C++ -*-
-//===-- test_copy_move.cpp ------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 struct run_copy
 {
 
 #if __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN ||                                                            \
     __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration

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

 // -*- C++ -*-
-//===-- test_fill.cpp -----------------------------------------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-// Tests for fill/fill_n
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_fill
 {
     template <typename It, typename T>
     bool
     check(It first, It last, const T& value)

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

 // -*- C++ -*-
-//===-- test_generate.cpp -------------------------------------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-// Tests for generate
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 #include <atomic>
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct Generator_count
 {
     const T def_val = T(-1);
     T

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

 // -*- C++ -*-
-//===-- test_remove.cpp ---------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename InputIterator, typename OutputIterator, typename Size, typename T>

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

 // -*- C++ -*-
-//===-- test_remove_copy.cpp ----------------------------------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-// Tests for remove_copy
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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,
               typename T>
     void

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

 // -*- C++ -*-
-//===-- test_replace.cpp --------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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
 {
     int32_t value;
     int32_t copied_times = 0;

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

 // -*- C++ -*-
-//===-- test_replace_copy.cpp ---------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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,
               typename Predicate, typename T>
     void

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

 // -*- C++ -*-
-//===-- test_rotate.cpp ---------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include <iterator>
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct wrapper
 {
     T t;
     int move_count;

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

 // -*- C++ -*-
-//===-- test_rotate_copy.cpp ----------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include <iterator>
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct wrapper;
 
 template <typename T>
 bool

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

 // -*- C++ -*-
-//===-- test_swap_ranges.cpp ----------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include <iterator>
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct wrapper
 {
     T t;
     std::size_t number_of_swaps = 0;

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

 // -*- C++ -*-
-//===-- test_transform_binary.cpp -----------------------------------------===//
+//===-- 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 "pstl/execution"
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/algorithm"
-#include "utils.h"
+#include "pstl/execution"
+#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
 {
     Out val;
 

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

 // -*- C++ -*-
-//===-- test_transform_unary.cpp ------------------------------------------===//
+//===-- 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 "pstl/execution"
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/algorithm"
-#include "utils.h"
+#include "pstl/execution"
+#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)
 {
     typedef typename std::iterator_traits<OutputIterator>::value_type Out;

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

 // -*- C++ -*-
-//===-- test_unique.cpp ---------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename ForwardIt, typename Generator>

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

 // -*- C++ -*-
-//===-- test_unique_copy_equal.cpp ----------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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
     template <typename InputIterator, typename OutputIterator, typename OutputIterator2, typename Size,
               typename Predicate, typename T>

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

 // -*- C++ -*-
-//===-- test_adjacent_find.cpp --------------------------------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-// Tests for adjacent_find
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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>
     void
     operator()(Policy&& exec, Iterator first, Iterator last, Pred pred)

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

 // -*- C++ -*-
-//===-- test_all_of.cpp ---------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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
   - correctly work with nested parallelism
   - check that algorithm does not require anything more than is described in its requirements section

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

 // -*- C++ -*-
-//===-- test_any_of.cpp ---------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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
   - correctly work with nested parallelism
   - check that algorithm does not require anything more than is described in its requirements section

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

 // -*- C++ -*-
-//===-- test_count.cpp ----------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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>
     void
     operator()(Policy&& exec, Iterator first, Iterator last, T needle)

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

 // -*- C++ -*-
-//===-- test_equal.cpp ----------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 #define CPP14_ENABLED 0
 
 struct UserType
 {
     float32_t f;

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

 // -*- C++ -*-
-//===-- test_find.cpp -----------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename Iterator, typename Value>

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

 // -*- C++ -*-
-//===-- test_find_end.cpp -------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename Iterator1, typename Iterator2, typename Predicate>

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

 // -*- C++ -*-
-//===-- test_find_first_of.cpp --------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename Iterator1, typename Iterator2, typename Predicate>

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

 // -*- C++ -*-
-//===-- test_find_if.cpp --------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename Iterator, typename Predicate, typename NotPredicate>

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

 // -*- C++ -*-
-//===-- test_for_each.cpp -------------------------------------------------===//
+//===-- 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"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename Type>
 struct Gen
 {
     Type
     operator()(std::size_t k)

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

 // -*- C++ -*-
-//===-- test_mismatch.cpp -------------------------------------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-// Tests for the rest algorithms; temporary approach to check compiling
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 
 #include "pstl/execution"
 #include "pstl/algorithm"
 #include "pstl/numeric"
 #include "pstl/memory"
 
-#include "utils.h"
+#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>
     void
     operator()(Policy&& exec, Iterator1 first1, Iterator1 last1, Iterator2 first2)

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

 // -*- C++ -*-
-//===-- test_none_of.cpp --------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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
   - correctly work with nested parallelism
   - check that algorithm does not require anything more than is described in its requirements section

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

 // -*- C++ -*-
-//===-- test_nth_element.cpp ----------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include <algorithm>
 #include <iostream>
 #include "pstl/execution"
 #include "pstl/algorithm"
 
-#include "utils.h"
+#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
 {
     explicit DataType(int32_t k) : my_val(k) {}

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

 // -*- C++ -*-
-//===-- test_search_n.cpp -------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN //dummy specialization by policy type, in case of broken configuration
     template <typename Iterator, typename Size, typename T, typename Predicate>

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

 // -*- C++ -*-
-//===-- test_is_heap.cpp --------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 #include <iostream>
 
 using namespace TestUtils;
 
 struct WithCmpOp
 {
     int32_t _first;
     int32_t _second;

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

 // -*- C++ -*-
-//===-- test_lexicographical_compare.cpp ----------------------------------===//
+//===-- 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 "pstl_test_config.h"
-#include <string>
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 #include <iostream>
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_one_policy
 {
 
     template <typename ExecutionPolicy, typename Iterator1, typename Iterator2, typename Predicate>
     void

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

 // -*- C++ -*-
-//===-- test_minmax_element.cpp -------------------------------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-// Tests for min_element, max_element, minmax_element
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 #include <set>
 #include <cassert>
 #include <cmath>
 
 using namespace TestUtils;
 
 struct check_minelement

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

 // -*- C++ -*-
-//===-- test_includes.cpp -------------------------------------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-// Tests for partial_sort
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 
 #include <cmath>
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct Num
 {
     T val;
     explicit Num(const T& v) : val(v) {}

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

 // -*- C++ -*-
-//===-- test_set.cpp ------------------------------------------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-// Tests for partial_sort
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 
 #include <cmath>
 #include <chrono>
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct Num
 {
     T val;
 

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

 // -*- C++ -*-
-//===-- test_is_sorted.cpp ------------------------------------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-// Tests for is_sorted, is_sorted_until
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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>
     void
     operator()(Policy&& exec, Iterator first, Iterator last, bool exam)

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

 // -*- C++ -*-
-//===-- test_partial_sort.cpp ---------------------------------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-// Tests for partial_sort
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 
 #include <cmath>
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#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;
 
 template <typename T>
 struct Num

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

 // -*- C++ -*-
-//===-- test_partial_sort_copy.cpp ----------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct Num
 {
     T val;
 

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

 // -*- C++ -*-
-//===-- test_sort.cpp -----------------------------------------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-// Tests for sort and stable_sort
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 
 #include "pstl/execution"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 #define _CRT_SECURE_NO_WARNINGS
 
 #include <atomic>
 
 static bool Stable;
 

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

 // -*- C++ -*-
-//===-- test_adjacent_difference.cpp --------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include <iterator>
 
 #include "pstl/execution"
 #include "pstl/algorithm"
 #include "pstl/numeric"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 template <typename T>
 struct wrapper
 {
     T t;
     explicit wrapper(T t_) : t(t_) {}

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

 // -*- C++ -*-
-//===-- test_reduce.cpp ---------------------------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/numeric"
-#include "utils.h"
+#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>
     void
     operator()(Policy&& exec, Iterator first, Iterator last, T init, BinaryOp binary, T expected)

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

 // -*- C++ -*-
-//===-- test_scan.cpp -----------------------------------------------------===//
+//===-- 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"
-#include "utils.h"
-#include "pstl_test_config.h"
+#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>
 OutputIterator
 exclusive_scan_serial(InputIterator first, InputIterator last, OutputIterator result, T init)

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

 // -*- C++ -*-
-//===-- test_transform_reduce.cpp -----------------------------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-// Tests for inner_product
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 
 #include "pstl/execution"
 #include "pstl/numeric"
-#include "utils.h"
+#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
 Equal(T x, T y)
 {

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

 // -*- C++ -*-
-//===-- test_transform_scan.cpp -------------------------------------------===//
+//===-- 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"
-#include "utils.h"
-#include "pstl_test_config.h"
+#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().
 static bool inclusive;
 

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

 // -*- C++ -*-
-//===-- test_uninitialized_construct.cpp ----------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/memory"
-#include "utils.h"
+#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
 IsCheckValueCorrectness(Iterator begin, Iterator end)
 {

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

 // -*- C++ -*-
-//===-- test_uninitialized_copy_move.cpp ----------------------------------===//
+//===-- 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 "pstl_test_config.h"
+#include "support/pstl_test_config.h"
 
+#ifdef PSTL_STANDALONE_TESTS
 #include "pstl/execution"
 #include "pstl/memory"
-#include "utils.h"
+#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
 IsCheckValueCorrectness(InputIterator first1, OutputIterator first2, Size n)
 {

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

 // -*- C++ -*-
-//===-- test_uninitialized_fill_destroy.cpp -------------------------------===//
+//===-- 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
 //
 //===----------------------------------------------------------------------===//
 
-// Tests for the destroy, destroy_n, uninitialized_fill, uninitialized_fill_n algorithms
+#include "support/pstl_test_config.h"
+
+#ifdef PSTL_STANDALONE_TESTS
 
 #include "pstl/execution"
 #include "pstl/memory"
 #include "pstl/algorithm"
-#include "utils.h"
+#else
+#include <execution>
+#include <algorithm>
+#endif // PSTL_STANDALONE_TESTS
+
+#include "support/utils.h"
 
 using namespace TestUtils;
 
 struct test_uninitialized_fill_destroy
 {
     template <typename Policy, typename Iterator, typename T>
     void
     operator()(Policy&& exec, Iterator first, Iterator last, const T& in, std::size_t n, std::false_type)

test/support/pstl_test_config.h

 // -*- C++ -*-
 //===-- pstl_test_config.h ------------------------------------------------===//
 //
 // 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_TEST_config_H
 #define __PSTL_TEST_config_H
 
 #if defined(_MSC_VER) && defined(_DEBUG)
 #define _SCL_SECURE_NO_WARNINGS //to prevent the compilation warning. Microsoft STL implementation has specific checking of an iterator range in DEBUG mode for the containers from the standard library.
 #endif
 
 #define __PSTL_ICC_16_17_TEST_REDUCTION_BOOL_TYPE_RELEASE_64_BROKEN                                                    \
     (__x86_64 && !_DEBUG && __INTEL_COMPILER && __INTEL_COMPILER <= 1700 && !__APPLE__)
 #define __PSTL_ICC_16_17_TEST_REDUCTION_RELEASE_BROKEN                                                                 \
     (!_DEBUG && __INTEL_COMPILER &&                                                                                    \
      (__INTEL_COMPILER < 1800 || (__INTEL_COMPILER == 1800 && __INTEL_COMPILER_UPDATE < 1)))
 #define __PSTL_ICC_1800_TEST_MONOTONIC_RELEASE_64_BROKEN                                                               \
     (__x86_64 && !_DEBUG && __INTEL_COMPILER && __INTEL_COMPILER == 1800 && __INTEL_COMPILER_UPDATE < 1)
 #define __PSTL_ICC_17_TEST_MAC_RELEASE_32_BROKEN                                                                       \
     (__i386__ && !_DEBUG && __INTEL_COMPILER >= 1700 && __INTEL_COMPILER < 1800 && __APPLE__)
 #define __PSTL_ICC_18_VC141_TEST_SIMD_LAMBDA_RELEASE_BROKEN                                                            \
     (!_DEBUG && __INTEL_COMPILER >= 1800 && __INTEL_COMPILER < 1900 && _MSC_VER == 1910)
 #define __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN                                                           \
     (_M_IX86 && _DEBUG && __INTEL_COMPILER >= 1700 && __INTEL_COMPILER < 1800 && _MSC_VER >= 1900)
 #define __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN                                                            \
     (_M_IX86 && _DEBUG && __INTEL_COMPILER >= 1600 && __INTEL_COMPILER < 1700 && _MSC_VER == 1900)
 #define __PSTL_ICC_16_VC14_TEST_PAR_TBB_RT_RELEASE_64_BROKEN                                                           \
     (__PSTL_USE_PAR_POLICIES && ((_M_X64 && _MSC_VER == 1900) || __x86_64) && !_DEBUG && __INTEL_COMPILER < 1700)
 #define __PSTL_ICC_16_17_TEST_64_TIMEOUT (__x86_64 && __INTEL_COMPILER && __INTEL_COMPILER < 1800 && !__APPLE__)
 #define __PSTL_ICC_18_TEST_EARLY_EXIT_MONOTONIC_RELEASE_BROKEN (!_DEBUG && __INTEL_COMPILER && __INTEL_COMPILER == 1800)
 #define __PSTL_CLANG_TEST_BIG_OBJ_DEBUG_32_BROKEN                                                                      \
     (__i386__ && PSTL_USE_DEBUG && __clang__ && __PSTL_CLANG_VERSION <= 90000)
 #define __PSTL_ICC_16_17_18_TEST_UNIQUE_MASK_RELEASE_BROKEN                                                            \
     (!_DEBUG && __INTEL_COMPILER &&                                                                                    \
      (__INTEL_COMPILER < 1800 || (__INTEL_COMPILER == 1800 && __INTEL_COMPILER_UPDATE < 3)))
 #define __PSTL_ICC_18_TEST_EARLY_EXIT_AVX_RELEASE_BROKEN                                                               \
     (!_DEBUG && __INTEL_COMPILER == 1800 && __AVX__ && !__AVX2__ && !__AVX512__)
 #define __PSTL_ICC_19_TEST_IS_PARTITIONED_RELEASE_BROKEN                                                               \
     (!PSTL_USE_DEBUG && (__linux__ || __APPLE__) && __INTEL_COMPILER == 1900)
 #define __PSTL_ICL_19_VC14_VC141_TEST_SCAN_RELEASE_BROKEN                                                              \
     (__INTEL_COMPILER == 1900 && _MSC_VER >= 1900 && _MSC_VER <= 1910)
 #define __PSTL_ICC_19_TEST_SIMD_UDS_WINDOWS_RELEASE_BROKEN (__INTEL_COMPILER == 1900 && _MSC_VER && !_DEBUG)
 
 #endif /* __PSTL_TEST_config_H */

test/support/utils.h

 // -*- C++ -*-
 //===-- utils.h -----------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // File contains common utilities that tests rely on
 
 // Do not #include <algorithm>, because if we do we will not detect accidental dependencies.
 #include <sstream>
 #include <iostream>
 #include <cstring>
 #include <iterator>
 #include <vector>
 #include <atomic>
 #include <memory>
 #include <cstdint>
 
 #include "pstl_test_config.h"
 
 namespace TestUtils
 {
 
 typedef double float64_t;
 typedef float float32_t;
 
 template <class T, std::size_t N>
 constexpr size_t
 const_size(const T (&array)[N]) noexcept
 {
     return N;
 }
 
 template <typename T>
 class Sequence;
 
 // Handy macros for error reporting
 #define EXPECT_TRUE(condition, message) TestUtils::expect<true>(condition, __FILE__, __LINE__, message)
 #define EXPECT_FALSE(condition, message) TestUtils::expect<false>(condition, __FILE__, __LINE__, message)
 
 // Check that expected and actual are equal and have the same type.
 #define EXPECT_EQ(expected, actual, message) TestUtils::expect_equal(expected, actual, __FILE__, __LINE__, message)
 
 // Check that sequences started with expected and actual and have had size n are equal and have the same type.
 #define EXPECT_EQ_N(expected, actual, n, message)                                                                      \
     TestUtils::expect_equal(expected, actual, n, __FILE__, __LINE__, message)
 
 // Issue error message from outstr, adding a newline.
 // Real purpose of this routine is to have a place to hang a breakpoint.
 static void
 issue_error_message(std::stringstream& outstr)
 {
     outstr << std::endl;
     std::cerr << outstr.str();
 }
 
 template <bool B>
 void
 expect(bool condition, const char* file, int32_t line, const char* message)
 {
     // Templating this function is somewhat silly, but avoids the need to declare it static
     // or have a separate translation unit.
     if (condition != B)
     {
         std::stringstream outstr;
         outstr << "error at " << file << ":" << line << " - " << message;
         issue_error_message(outstr);
     }
 }
 
 // Do not change signature to const T&.
 // Function must be able to detect const differences between expected and actual.
 template <typename T>
 void
 expect_equal(T& expected, T& actual, const char* file, int32_t line, const char* message)
 {
     if (!(expected == actual))
     {
         std::stringstream outstr;
         outstr << "error at " << file << ":" << line << " - " << message << ", expected " << expected << " got "
                << actual;
         issue_error_message(outstr);
     }
 }
 
 template <typename T>
 void
 expect_equal(Sequence<T>& expected, Sequence<T>& actual, const char* file, int32_t line, const char* message)
 {
     size_t n = expected.size();
     size_t m = actual.size();
     if (n != m)
     {
         std::stringstream outstr;
         outstr << "error at " << file << ":" << line << " - " << message << ", expected sequence of size " << n
                << " got sequence of size " << m;
         issue_error_message(outstr);
         return;
     }
     size_t error_count = 0;
     for (size_t k = 0; k < n && error_count < 10; ++k)
     {
         if (!(expected[k] == actual[k]))
         {
             std::stringstream outstr;
             outstr << "error at " << file << ":" << line << " - " << message << ", at index " << k << " expected "
                    << expected[k] << " got " << actual[k];
             issue_error_message(outstr);
             ++error_count;
         }
     }
 }
 
 template <typename Iterator1, typename Iterator2, typename Size>
 void
 expect_equal(Iterator1 expected_first, Iterator2 actual_first, Size n, const char* file, int32_t line,
              const char* message)
 {
     size_t error_count = 0;
     for (size_t k = 0; k < n && error_count < 10; ++k, ++expected_first, ++actual_first)
     {
         if (!(*expected_first == *actual_first))
         {
             std::stringstream outstr;
             outstr << "error at " << file << ":" << line << " - " << message << ", at index " << k;
             issue_error_message(outstr);
             ++error_count;
         }
     }
 }
 
 // ForwardIterator is like type Iterator, but restricted to be a forward iterator.
 // Only the forward iterator signatures that are necessary for tests are present.
 // Post-increment in particular is deliberatly omitted since our templates should avoid using it
 // because of efficiency considerations.
 template <typename Iterator, typename IteratorTag>
 class ForwardIterator
 {
   public:
     typedef IteratorTag iterator_category;
     typedef typename std::iterator_traits<Iterator>::value_type value_type;
     typedef typename std::iterator_traits<Iterator>::difference_type difference_type;
     typedef typename std::iterator_traits<Iterator>::pointer pointer;
     typedef typename std::iterator_traits<Iterator>::reference reference;
 
   protected:
     Iterator my_iterator;
     typedef value_type element_type;
 
   public:
     ForwardIterator() = default;
     explicit ForwardIterator(Iterator i) : my_iterator(i) {}
     reference operator*() const { return *my_iterator; }
     Iterator operator->() const { return my_iterator; }
     ForwardIterator
     operator++()
     {
         ++my_iterator;
         return *this;
     }
     ForwardIterator operator++(int32_t)
     {
         auto retval = *this;
         my_iterator++;
         return retval;
     }
     friend bool
     operator==(const ForwardIterator& i, const ForwardIterator& j)
     {
         return i.my_iterator == j.my_iterator;
     }
     friend bool
     operator!=(const ForwardIterator& i, const ForwardIterator& j)
     {
         return i.my_iterator != j.my_iterator;
     }
 
     Iterator
     iterator() const
     {
         return my_iterator;
     }
 };
 
 template <typename Iterator, typename IteratorTag>
 class BidirectionalIterator : public ForwardIterator<Iterator, IteratorTag>
 {
     typedef ForwardIterator<Iterator, IteratorTag> base_type;
 
   public:
     BidirectionalIterator() = default;
     explicit BidirectionalIterator(Iterator i) : base_type(i) {}
     BidirectionalIterator(const base_type& i) : base_type(i.iterator()) {}
 
     BidirectionalIterator
     operator++()
     {
         ++base_type::my_iterator;
         return *this;
     }
     BidirectionalIterator
     operator--()
     {
         --base_type::my_iterator;
         return *this;
     }
     BidirectionalIterator operator++(int32_t)
     {
         auto retval = *this;
         base_type::my_iterator++;
         return retval;
     }
     BidirectionalIterator operator--(int32_t)
     {
         auto retval = *this;
         base_type::my_iterator--;
         return retval;
     }
 };
 
 template <typename Iterator, typename F>
 void
 fill_data(Iterator first, Iterator last, F f)
 {
     typedef typename std::iterator_traits<Iterator>::value_type T;
     for (std::size_t i = 0; first != last; ++first, ++i)
     {
         *first = T(f(i));
     }
 }
 
 // Sequence<T> is a container of a sequence of T with lots of kinds of iterators.
 // Prefixes on begin/end mean:
 //      c = "const"
 //      f = "forward"
 // No prefix indicates non-const random-access iterator.
 template <typename T>
 class Sequence
 {
     std::vector<T> m_storage;
 
   public:
     typedef typename std::vector<T>::iterator iterator;
     typedef typename std::vector<T>::const_iterator const_iterator;
     typedef ForwardIterator<iterator, std::forward_iterator_tag> forward_iterator;
     typedef ForwardIterator<const_iterator, std::forward_iterator_tag> const_forward_iterator;
 
     typedef BidirectionalIterator<iterator, std::bidirectional_iterator_tag> bidirectional_iterator;
     typedef BidirectionalIterator<const_iterator, std::bidirectional_iterator_tag> const_bidirectional_iterator;
 
     typedef T value_type;
     explicit Sequence(size_t size) : m_storage(size) {}
 
     // Construct sequence [f(0), f(1), ... f(size-1)]
     // f can rely on its invocations being sequential from 0 to size-1.
     template <typename Func>
     Sequence(size_t size, Func f)
     {
         m_storage.reserve(size);
         // Use push_back because T might not have a default constructor
         for (size_t k = 0; k < size; ++k)
             m_storage.push_back(T(f(k)));
     }
     Sequence(const std::initializer_list<T>& data) : m_storage(data) {}
 
     const_iterator
     begin() const
     {
         return m_storage.begin();
     }
     const_iterator
     end() const
     {
         return m_storage.end();
     }
     iterator
     begin()
     {
         return m_storage.begin();
     }
     iterator
     end()
     {
         return m_storage.end();
     }
     const_iterator
     cbegin() const
     {
         return m_storage.cbegin();
     }
     const_iterator
     cend() const
     {
         return m_storage.cend();
     }
     forward_iterator
     fbegin()
     {
         return forward_iterator(m_storage.begin());
     }
     forward_iterator
     fend()
     {
         return forward_iterator(m_storage.end());
     }
     const_forward_iterator
     cfbegin() const
     {
         return const_forward_iterator(m_storage.cbegin());
     }
     const_forward_iterator
     cfend() const
     {
         return const_forward_iterator(m_storage.cend());
     }
     const_forward_iterator
     fbegin() const
     {
         return const_forward_iterator(m_storage.cbegin());
     }
     const_forward_iterator
     fend() const
     {
         return const_forward_iterator(m_storage.cend());
     }
 
     const_bidirectional_iterator
     cbibegin() const
     {
         return const_bidirectional_iterator(m_storage.cbegin());
     }
     const_bidirectional_iterator
     cbiend() const
     {
         return const_bidirectional_iterator(m_storage.cend());
     }
 
     bidirectional_iterator
     bibegin()
     {
         return bidirectional_iterator(m_storage.begin());
     }
     bidirectional_iterator
     biend()
     {
         return bidirectional_iterator(m_storage.end());
     }
 
     std::size_t
     size() const
     {
         return m_storage.size();
     }
     const T*
     data() const
     {
         return m_storage.data();
     }
     typename std::vector<T>::reference operator[](size_t j) { return m_storage[j]; }
     const T& operator[](size_t j) const { return m_storage[j]; }
 
     // Fill with given value
     void
     fill(const T& value)
     {
         for (size_t i = 0; i < m_storage.size(); i++)
             m_storage[i] = value;
     }
 
     void
     print() const;
 
     template <typename Func>
     void
     fill(Func f)
     {
         fill_data(m_storage.begin(), m_storage.end(), f);
     }
 };
 
 template <typename T>
 void
 Sequence<T>::print() const
 {
     std::cout << "size = " << size() << ": { ";
     std::copy(begin(), end(), std::ostream_iterator<T>(std::cout, " "));
     std::cout << " } " << std::endl;
 }
 
 // Predicates for algorithms
 template <typename DataType>
 struct is_equal_to
 {
     is_equal_to(const DataType& expected) : m_expected(expected) {}
     bool
     operator()(const DataType& actual) const
     {
         return actual == m_expected;
     }
 
   private:
     DataType m_expected;
 };
 
 // Low-quality hash function, returns value between 0 and (1<<bits)-1
 // Warning: low-order bits are quite predictable.
 inline size_t
 HashBits(size_t i, size_t bits)
 {
     size_t mask = bits >= 8 * sizeof(size_t) ? ~size_t(0) : (size_t(1) << bits) - 1;
     return (424157 * i ^ 0x24aFa) & mask;
 }
 
 // Stateful unary op
 template <typename T, typename U>
 class Complement
 {
     int32_t val;
 
   public:
     Complement(T v) : val(v) {}
     U
     operator()(const T& x) const
     {
         return U(val - x);
     }
 };
 
 // Tag used to prevent accidental use of converting constructor, even if use is explicit.
 struct OddTag
 {
 };
 
 class Sum;
 
 // Type with limited set of operations.  Not default-constructible.
 // Only available operator is "==".
 // Typically used as value type in tests.
 class Number
 {
     int32_t value;
     friend class Add;
     friend class Sum;
     friend class IsMultiple;
     friend class Congruent;
     friend Sum
     operator+(const Sum& x, const Sum& y);
 
   public:
     Number(int32_t val, OddTag) : value(val) {}
     friend bool
     operator==(const Number& x, const Number& y)
     {
         return x.value == y.value;
     }
     friend std::ostream&
     operator<<(std::ostream& o, const Number& d)
     {
         return o << d.value;
     }
 };
 
 // Stateful predicate for Number.  Not default-constructible.
 class IsMultiple
 {
     long modulus;
 
   public:
     // True if x is multiple of modulus
     bool
     operator()(Number x) const
     {
         return x.value % modulus == 0;
     }
     IsMultiple(long modulus_, OddTag) : modulus(modulus_) {}
 };
 
 // Stateful equivalence-class predicate for Number.  Not default-constructible.
 class Congruent
 {
     long modulus;
 
   public:
     // True if x and y have same remainder for the given modulus.
     // Note: this is not quite the same as "equivalent modulo modulus" when x and y have different
     // sign, but nonetheless AreCongruent is still an equivalence relationship, which is all
     // we need for testing.
     bool
     operator()(Number x, Number y) const
     {
         return x.value % modulus == y.value % modulus;
     }
     Congruent(long modulus_, OddTag) : modulus(modulus_) {}
 };
 
 // Stateful reduction operation for Number
 class Add
 {
     long bias;
 
   public:
     explicit Add(OddTag) : bias(1) {}
     Number
     operator()(Number x, const Number& y)
     {
         return Number(x.value + y.value + (bias - 1), OddTag());
     }
 };
 
 // Class similar to Number, but has default constructor and +.
 class Sum : public Number
 {
   public:
     Sum() : Number(0, OddTag()) {}
     Sum(long x, OddTag) : Number(x, OddTag()) {}
     friend Sum
     operator+(const Sum& x, const Sum& y)
     {
         return Sum(x.value + y.value, OddTag());
     }
 };
 
 // Type with limited set of operations, which includes an associative but not commutative operation.
 // Not default-constructible.
 // Typically used as value type in tests involving "GENERALIZED_NONCOMMUTATIVE_SUM".
 class MonoidElement
 {
     size_t a, b;
 
   public:
     MonoidElement(size_t a_, size_t b_, OddTag) : a(a_), b(b_) {}
     friend bool
     operator==(const MonoidElement& x, const MonoidElement& y)
     {
         return x.a == y.a && x.b == y.b;
     }
     friend std::ostream&
     operator<<(std::ostream& o, const MonoidElement& x)
     {
         return o << "[" << x.a << ".." << x.b << ")";
     }
     friend class AssocOp;
 };
 
 // Stateful associative op for MonoidElement
 // It's not really a monoid since the operation is not allowed for any two elements.
 // But it's good enough for testing.
 class AssocOp
 {
     unsigned c;
 
   public:
     explicit AssocOp(OddTag) : c(5) {}
     MonoidElement
     operator()(const MonoidElement& x, const MonoidElement& y)
     {
         unsigned d = 5;
         EXPECT_EQ(d, c, "state lost");
         EXPECT_EQ(x.b, y.a, "commuted?");
 
         return MonoidElement(x.a, y.b, OddTag());
     }
 };
 
 // Multiplication of matrix is an associative but not commutative operation
 // Typically used as value type in tests involving "GENERALIZED_NONCOMMUTATIVE_SUM".
 template <typename T>
 struct Matrix2x2
 {
     T a[2][2];
     Matrix2x2() : a{{1, 0}, {0, 1}} {}
     Matrix2x2(T x, T y) : a{{0, x}, {x, y}} {}
 #if !__PSTL_ICL_19_VC14_VC141_TEST_SCAN_RELEASE_BROKEN
     Matrix2x2(const Matrix2x2& m) : a{{m.a[0][0], m.a[0][1]}, {m.a[1][0], m.a[1][1]}} {}
     Matrix2x2&
     operator=(const Matrix2x2& m)
     {
         a[0][0] = m.a[0][0], a[0][1] = m.a[0][1], a[1][0] = m.a[1][0], a[1][1] = m.a[1][1];
         return *this;
     }
 #endif
 };
 
 template <typename T>
 bool
 operator==(const Matrix2x2<T>& left, const Matrix2x2<T>& right)
 {
     return left.a[0][0] == right.a[0][0] && left.a[0][1] == right.a[0][1] && left.a[1][0] == right.a[1][0] &&
            left.a[1][1] == right.a[1][1];
 }
 
 template <typename T>
 Matrix2x2<T>
 multiply_matrix(const Matrix2x2<T>& left, const Matrix2x2<T>& right)
 {
     Matrix2x2<T> result;
     for (int32_t i = 0; i < 2; ++i)
     {
         for (int32_t j = 0; j < 2; ++j)
         {
             result.a[i][j] = left.a[i][0] * right.a[0][j] + left.a[i][1] * right.a[1][j];
         }
     }
     return result;
 }
 
 // Check that Intel(R) Threading Building Blocks header files are not used when parallel policies are off
 #if !__PSTL_USE_PAR_POLICIES
 #if defined(TBB_INTERFACE_VERSION)
 #error The parallel backend is used while it should not (__PSTL_USE_PAR_POLICIES==0)
 #endif
 #endif
 
 //============================================================================
 // Adapters for creating different types of iterators.
 //
 // In this block we implemented some adapters for creating differnet types of iterators.
 // It's needed for extending the unit testing of Parallel STL algorithms.
 // We have adapters for iterators with different tags (forward_iterator_tag, bidirectional_iterator_tag), reverse iterators.
 // The input iterator should be const or non-const, non-reverse random access iterator.
 // Iterator creates in "MakeIterator":
 // firstly, iterator is "packed" by "IteratorTypeAdapter" (creating forward or bidirectional iterator)
 // then iterator is "packed" by "ReverseAdapter" (if it's possible)
 // So, from input iterator we may create, for example, reverse bidirectional iterator.
 // "Main" functor for testing iterators is named "invoke_on_all_iterator_types".
 
 // Base adapter
 template <typename Iterator>
 struct BaseAdapter
 {
     typedef Iterator iterator_type;
     iterator_type
     operator()(Iterator it)
     {
         return it;
     }
 };
 
 // Check if the iterator is reverse iterator
 // Note: it works only for iterators that created by std::reverse_iterator
 template <typename NotReverseIterator>
 struct isReverse : std::false_type
 {
 };
 
 template <typename Iterator>
 struct isReverse<std::reverse_iterator<Iterator>> : std::true_type
 {
 };
 
 // Reverse adapter
 template <typename Iterator, typename IsReverse>
 struct ReverseAdapter
 {
     typedef std::reverse_iterator<Iterator> iterator_type;
     iterator_type
     operator()(Iterator it)
     {
 #if __PSTL_CPP14_MAKE_REVERSE_ITERATOR_PRESENT
         return std::make_reverse_iterator(it);
 #else
         return iterator_type(it);
 #endif
     }
 };
 
 // Non-reverse adapter
 template <typename Iterator>
 struct ReverseAdapter<Iterator, std::false_type> : BaseAdapter<Iterator>
 {
 };
 
 // Iterator adapter by type (by default std::random_access_iterator_tag)
 template <typename Iterator, typename IteratorTag>
 struct IteratorTypeAdapter : BaseAdapter<Iterator>
 {
 };
 
 // Iterator adapter for forward iterator
 template <typename Iterator>
 struct IteratorTypeAdapter<Iterator, std::forward_iterator_tag>
 {
     typedef ForwardIterator<Iterator, std::forward_iterator_tag> iterator_type;
     iterator_type
     operator()(Iterator it)
     {
         return iterator_type(it);
     }
 };
 
 // Iterator adapter for bidirectional iterator
 template <typename Iterator>
 struct IteratorTypeAdapter<Iterator, std::bidirectional_iterator_tag>
 {
     typedef BidirectionalIterator<Iterator, std::bidirectional_iterator_tag> iterator_type;
     iterator_type
     operator()(Iterator it)
     {
         return iterator_type(it);
     }
 };
 
 //For creating iterator with new type
 template <typename InputIterator, typename IteratorTag, typename IsReverse>
 struct MakeIterator
 {
     typedef IteratorTypeAdapter<InputIterator, IteratorTag> IterByType;
     typedef ReverseAdapter<typename IterByType::iterator_type, IsReverse> ReverseIter;
 
     typename ReverseIter::iterator_type
     operator()(InputIterator it)
     {
         return ReverseIter()(IterByType()(it));
     }
 };
 
 // Useful constant variables
 constexpr std::size_t GuardSize = 5;
 constexpr std::ptrdiff_t sizeLimit = 1000;
 
 template <typename Iter, typename Void = void> // local iterator_traits for non-iterators
 struct iterator_traits_
 {
 };
 
 template <typename Iter> // For iterators
 struct iterator_traits_<Iter,
                         typename std::enable_if<!std::is_void<typename Iter::iterator_category>::value, void>::type>
 {
     typedef typename Iter::iterator_category iterator_category;
 };
 
 template <typename T> // For pointers
 struct iterator_traits_<T*>
 {
     typedef std::random_access_iterator_tag iterator_category;
 };
 
 // is iterator Iter has tag Tag
 template <typename Iter, typename Tag>
 using is_same_iterator_category = std::is_same<typename iterator_traits_<Iter>::iterator_category, Tag>;
 
 // if we run with reverse or const iterators we shouldn't test the large range
 template <typename IsReverse, typename IsConst>
 struct invoke_if_
 {
     template <typename Op, typename... Rest>
     void
     operator()(bool is_allow, Op op, Rest&&... rest)
     {
         if (is_allow)
             op(std::forward<Rest>(rest)...);
     }
 };
 template <>
 struct invoke_if_<std::false_type, std::false_type>
 {
     template <typename Op, typename... Rest>
     void
     operator()(bool is_allow, Op op, Rest&&... rest)
     {
         op(std::forward<Rest>(rest)...);
     }
 };
 
 // Base non_const_wrapper struct. It is used to distinguish non_const testcases
 // from a regular one. For non_const testcases only compilation is checked.
 struct non_const_wrapper
 {
 };
 
 // Generic wrapper to specify iterator type to execute callable Op on.
 // The condition can be either positive(Op is executed only with IteratorTag)
 // or negative(Op is executed with every type of iterators except IteratorTag)
 template <typename Op, typename IteratorTag, bool IsPositiveCondition = true>
 struct non_const_wrapper_tagged : non_const_wrapper
 {
     template <typename Policy, typename Iterator>
     typename std::enable_if<IsPositiveCondition == is_same_iterator_category<Iterator, IteratorTag>::value, void>::type
     operator()(Policy&& exec, Iterator iter)
     {
         Op()(exec, iter);
     }
 
     template <typename Policy, typename InputIterator, typename OutputIterator>
     typename std::enable_if<IsPositiveCondition == is_same_iterator_category<OutputIterator, IteratorTag>::value,
                             void>::type
     operator()(Policy&& exec, InputIterator input_iter, OutputIterator out_iter)
     {
         Op()(exec, input_iter, out_iter);
     }
 
     template <typename Policy, typename Iterator>
     typename std::enable_if<IsPositiveCondition != is_same_iterator_category<Iterator, IteratorTag>::value, void>::type
     operator()(Policy&& exec, Iterator iter)
     {
     }
 
     template <typename Policy, typename InputIterator, typename OutputIterator>
     typename std::enable_if<IsPositiveCondition != is_same_iterator_category<OutputIterator, IteratorTag>::value,
                             void>::type
     operator()(Policy&& exec, InputIterator input_iter, OutputIterator out_iter)
     {
     }
 };
 
 // These run_for_* structures specify with which types of iterators callable object Op
 // should be executed.
 template <typename Op>
 struct run_for_rnd : non_const_wrapper_tagged<Op, std::random_access_iterator_tag>
 {
 };
 
 template <typename Op>
 struct run_for_rnd_bi : non_const_wrapper_tagged<Op, std::forward_iterator_tag, false>
 {
 };
 
 template <typename Op>
 struct run_for_rnd_fw : non_const_wrapper_tagged<Op, std::bidirectional_iterator_tag, false>
 {
 };
 
 // Invoker for different types of iterators.
 template <typename IteratorTag, typename IsReverse>
 struct iterator_invoker
 {
     template <typename Iterator>
     using make_iterator = MakeIterator<Iterator, IteratorTag, IsReverse>;
     template <typename Iterator>
     using IsConst = typename std::is_const<
         typename std::remove_pointer<typename std::iterator_traits<Iterator>::pointer>::type>::type;
     template <typename Iterator>
     using invoke_if = invoke_if_<IsReverse, IsConst<Iterator>>;
 
     // A single iterator version which is used for non_const testcases
     template <typename Policy, typename Op, typename Iterator>
     typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value &&
                                 std::is_base_of<non_const_wrapper, Op>::value,
                             void>::type
     operator()(Policy&& exec, Op op, Iterator iter)
     {
         op(std::forward<Policy>(exec), make_iterator<Iterator>()(iter));
     }
 
     // A version with 2 iterators which is used for non_const testcases
     template <typename Policy, typename Op, typename InputIterator, typename OutputIterator>
     typename std::enable_if<is_same_iterator_category<OutputIterator, std::random_access_iterator_tag>::value &&
                                 std::is_base_of<non_const_wrapper, Op>::value,
                             void>::type
     operator()(Policy&& exec, Op op, InputIterator input_iter, OutputIterator out_iter)
     {
         op(std::forward<Policy>(exec), make_iterator<InputIterator>()(input_iter),
            make_iterator<OutputIterator>()(out_iter));
     }
 
     template <typename Policy, typename Op, typename Iterator, typename Size, typename... Rest>
     typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type
     operator()(Policy&& exec, Op op, Iterator begin, Size n, Rest&&... rest)
     {
         invoke_if<Iterator>()(n <= sizeLimit, op, exec, make_iterator<Iterator>()(begin), n,
                               std::forward<Rest>(rest)...);
     }
 
     template <typename Policy, typename Op, typename Iterator, typename... Rest>
     typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value &&
                                 !std::is_base_of<non_const_wrapper, Op>::value,
                             void>::type
     operator()(Policy&& exec, Op op, Iterator inputBegin, Iterator inputEnd, Rest&&... rest)
     {
         invoke_if<Iterator>()(std::distance(inputBegin, inputEnd) <= sizeLimit, op, exec,
                               make_iterator<Iterator>()(inputBegin), make_iterator<Iterator>()(inputEnd),
                               std::forward<Rest>(rest)...);
     }
 
     template <typename Policy, typename Op, typename InputIterator, typename OutputIterator, typename... Rest>
     typename std::enable_if<is_same_iterator_category<OutputIterator, std::random_access_iterator_tag>::value,
                             void>::type
     operator()(Policy&& exec, Op op, InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin,
                Rest&&... rest)
     {
         invoke_if<InputIterator>()(std::distance(inputBegin, inputEnd) <= sizeLimit, op, exec,
                                    make_iterator<InputIterator>()(inputBegin), make_iterator<InputIterator>()(inputEnd),
                                    make_iterator<OutputIterator>()(outputBegin), std::forward<Rest>(rest)...);
     }
 
     template <typename Policy, typename Op, typename InputIterator, typename OutputIterator, typename... Rest>
     typename std::enable_if<is_same_iterator_category<OutputIterator, std::random_access_iterator_tag>::value,
                             void>::type
     operator()(Policy&& exec, Op op, InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin,
                OutputIterator outputEnd, Rest&&... rest)
     {
         invoke_if<InputIterator>()(std::distance(inputBegin, inputEnd) <= sizeLimit, op, exec,
                                    make_iterator<InputIterator>()(inputBegin), make_iterator<InputIterator>()(inputEnd),
                                    make_iterator<OutputIterator>()(outputBegin),
                                    make_iterator<OutputIterator>()(outputEnd), std::forward<Rest>(rest)...);
     }
 
     template <typename Policy, typename Op, typename InputIterator1, typename InputIterator2, typename OutputIterator,
               typename... Rest>
     typename std::enable_if<is_same_iterator_category<OutputIterator, std::random_access_iterator_tag>::value,
                             void>::type
     operator()(Policy&& exec, Op op, InputIterator1 inputBegin1, InputIterator1 inputEnd1, InputIterator2 inputBegin2,
                InputIterator2 inputEnd2, OutputIterator outputBegin, OutputIterator outputEnd, Rest&&... rest)
     {
         invoke_if<InputIterator1>()(
             std::distance(inputBegin1, inputEnd1) <= sizeLimit, op, exec, make_iterator<InputIterator1>()(inputBegin1),
             make_iterator<InputIterator1>()(inputEnd1), make_iterator<InputIterator2>()(inputBegin2),
             make_iterator<InputIterator2>()(inputEnd2), make_iterator<OutputIterator>()(outputBegin),
             make_iterator<OutputIterator>()(outputEnd), std::forward<Rest>(rest)...);
     }
 };
 
 // Invoker for reverse iterators only
 // Note: if we run with reverse iterators we shouldn't test the large range
 template <typename IteratorTag>
 struct iterator_invoker<IteratorTag, /* IsReverse = */ std::true_type>
 {
 
     template <typename Iterator>
     using make_iterator = MakeIterator<Iterator, IteratorTag, std::true_type>;
 
     // A single iterator version which is used for non_const testcases
     template <typename Policy, typename Op, typename Iterator>
     typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value &&
                                 std::is_base_of<non_const_wrapper, Op>::value,
                             void>::type
     operator()(Policy&& exec, Op op, Iterator iter)
     {
         op(std::forward<Policy>(exec), make_iterator<Iterator>()(iter));
     }
 
     // A version with 2 iterators which is used for non_const testcases
     template <typename Policy, typename Op, typename InputIterator, typename OutputIterator>
     typename std::enable_if<is_same_iterator_category<OutputIterator, std::random_access_iterator_tag>::value &&
                                 std::is_base_of<non_const_wrapper, Op>::value,
                             void>::type
     operator()(Policy&& exec, Op op, InputIterator input_iter, OutputIterator out_iter)
     {
         op(std::forward<Policy>(exec), make_iterator<InputIterator>()(input_iter),
            make_iterator<OutputIterator>()(out_iter));
     }
 
     template <typename Policy, typename Op, typename Iterator, typename Size, typename... Rest>
     typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value, void>::type
     operator()(Policy&& exec, Op op, Iterator begin, Size n, Rest&&... rest)
     {
         if (n <= sizeLimit)
             op(exec, make_iterator<Iterator>()(begin + n), n, std::forward<Rest>(rest)...);
     }
 
     template <typename Policy, typename Op, typename Iterator, typename... Rest>
     typename std::enable_if<is_same_iterator_category<Iterator, std::random_access_iterator_tag>::value &&
                                 !std::is_base_of<non_const_wrapper, Op>::value,
                             void>::type
     operator()(Policy&& exec, Op op, Iterator inputBegin, Iterator inputEnd, Rest&&... rest)
     {
         if (std::distance(inputBegin, inputEnd) <= sizeLimit)
             op(exec, make_iterator<Iterator>()(inputEnd), make_iterator<Iterator>()(inputBegin),
                std::forward<Rest>(rest)...);
     }
 
     template <typename Policy, typename Op, typename InputIterator, typename OutputIterator, typename... Rest>
     typename std::enable_if<is_same_iterator_category<OutputIterator, std::random_access_iterator_tag>::value,
                             void>::type
     operator()(Policy&& exec, Op op, InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin,
                Rest&&... rest)
     {
         if (std::distance(inputBegin, inputEnd) <= sizeLimit)
             op(exec, make_iterator<InputIterator>()(inputEnd), make_iterator<InputIterator>()(inputBegin),
                make_iterator<OutputIterator>()(outputBegin + (inputEnd - inputBegin)), std::forward<Rest>(rest)...);
     }
 
     template <typename Policy, typename Op, typename InputIterator, typename OutputIterator, typename... Rest>
     typename std::enable_if<is_same_iterator_category<OutputIterator, std::random_access_iterator_tag>::value,
                             void>::type
     operator()(Policy&& exec, Op op, InputIterator inputBegin, InputIterator inputEnd, OutputIterator outputBegin,
                OutputIterator outputEnd, Rest&&... rest)
     {
         if (std::distance(inputBegin, inputEnd) <= sizeLimit)
             op(exec, make_iterator<InputIterator>()(inputEnd), make_iterator<InputIterator>()(inputBegin),
                make_iterator<OutputIterator>()(outputEnd), make_iterator<OutputIterator>()(outputBegin),
                std::forward<Rest>(rest)...);
     }
 
     template <typename Policy, typename Op, typename InputIterator1, typename InputIterator2, typename OutputIterator,
               typename... Rest>
     typename std::enable_if<is_same_iterator_category<OutputIterator, std::random_access_iterator_tag>::value,
                             void>::type
     operator()(Policy&& exec, Op op, InputIterator1 inputBegin1, InputIterator1 inputEnd1, InputIterator2 inputBegin2,
                InputIterator2 inputEnd2, OutputIterator outputBegin, OutputIterator outputEnd, Rest&&... rest)
     {
         if (std::distance(inputBegin1, inputEnd1) <= sizeLimit)
             op(exec, make_iterator<InputIterator1>()(inputEnd1), make_iterator<InputIterator1>()(inputBegin1),
                make_iterator<InputIterator2>()(inputEnd2), make_iterator<InputIterator2>()(inputBegin2),
                make_iterator<OutputIterator>()(outputEnd), make_iterator<OutputIterator>()(outputBegin),
                std::forward<Rest>(rest)...);
     }
 };
 
 // We can't create reverse iterator from forward iterator
 template <>
 struct iterator_invoker<std::forward_iterator_tag, /*isReverse=*/std::true_type>
 {
     template <typename... Rest>
     void
     operator()(Rest&&... rest)
     {
     }
 };
 
 template <typename IsReverse>
 struct reverse_invoker
 {
     template <typename... Rest>
     void
     operator()(Rest&&... rest)
     {
         // Random-access iterator
         iterator_invoker<std::random_access_iterator_tag, IsReverse>()(std::forward<Rest>(rest)...);
 
         // Forward iterator
         iterator_invoker<std::forward_iterator_tag, IsReverse>()(std::forward<Rest>(rest)...);
 
         // Bidirectional iterator
         iterator_invoker<std::bidirectional_iterator_tag, IsReverse>()(std::forward<Rest>(rest)...);
     }
 };
 
 struct invoke_on_all_iterator_types
 {
     template <typename... Rest>
     void
     operator()(Rest&&... rest)
     {
         reverse_invoker</* IsReverse = */ std::false_type>()(std::forward<Rest>(rest)...);
         reverse_invoker</* IsReverse = */ std::true_type>()(std::forward<Rest>(rest)...);
     }
 };
 //============================================================================
 
 // Invoke op(policy,rest...) for each possible policy.
 template <typename Op, typename... T>
 void
 invoke_on_all_policies(Op op, T&&... rest)
 {
     using namespace __pstl::execution;
 
     // Try static execution policies
     invoke_on_all_iterator_types()(seq, op, std::forward<T>(rest)...);
     invoke_on_all_iterator_types()(unseq, op, std::forward<T>(rest)...);
 #if __PSTL_USE_PAR_POLICIES
     invoke_on_all_iterator_types()(par, op, std::forward<T>(rest)...);
     invoke_on_all_iterator_types()(par_unseq, op, std::forward<T>(rest)...);
 #endif
 }
 
 template <typename F>
 struct NonConstAdapter
 {
     F my_f;
     NonConstAdapter(const F& f) : my_f(f) {}
 
     template <typename... Types>
     auto
     operator()(Types&&... args) -> decltype(std::declval<F>().
                                             operator()(std::forward<Types>(args)...))
     {
         return my_f(std::forward<Types>(args)...);
     }
 };
 
 template <typename F>
 NonConstAdapter<F>
 non_const(const F& f)
 {
     return NonConstAdapter<F>(f);
 }
 
 // Wrapper for types. It's need for counting of constructing and destructing objects
 template <typename T>
 class Wrapper
 {
   public:
     Wrapper()
     {
         my_field = std::shared_ptr<T>(new T());
         ++my_count;
     }
     Wrapper(const T& input)
     {
         my_field = std::shared_ptr<T>(new T(input));
         ++my_count;
     }
     Wrapper(const Wrapper& input)
     {
         my_field = input.my_field;
         ++my_count;
     }
     Wrapper(Wrapper&& input)
     {
         my_field = input.my_field;
         input.my_field = nullptr;
         ++move_count;
     }
     Wrapper&
     operator=(const Wrapper& input)
     {
         my_field = input.my_field;
         return *this;
     }
     Wrapper&
     operator=(Wrapper&& input)
     {
         my_field = input.my_field;
         input.my_field = nullptr;
         ++move_count;
         return *this;
     }
     bool
     operator==(const Wrapper& input) const
     {
         return my_field == input.my_field;
     }
     bool
     operator<(const Wrapper& input) const
     {
         return *my_field < *input.my_field;
     }
     bool
     operator>(const Wrapper& input) const
     {
         return *my_field > *input.my_field;
     }
     friend std::ostream&
     operator<<(std::ostream& stream, const Wrapper& input)
     {
         return stream << *(input.my_field);
     }
     ~Wrapper()
     {
         --my_count;
         if (move_count > 0)
         {
             --move_count;
         }
     }
     T*
     get_my_field() const
     {
         return my_field.get();
     };
     static size_t
     Count()
     {
         return my_count;
     }
     static size_t
     MoveCount()
     {
         return move_count;
     }
     static void
     SetCount(const size_t& n)
     {
         my_count = n;
     }
     static void
     SetMoveCount(const size_t& n)
     {
         move_count = n;
     }
 
   private:
     static std::atomic<size_t> my_count;
     static std::atomic<size_t> move_count;
     std::shared_ptr<T> my_field;
 };
 
 template <typename T>
 std::atomic<size_t> Wrapper<T>::my_count = {0};
 
 template <typename T>
 std::atomic<size_t> Wrapper<T>::move_count = {0};
 
 template <typename InputIterator, typename T, typename BinaryOperation, typename UnaryOperation>
 T
 transform_reduce_serial(InputIterator first, InputIterator last, T init, BinaryOperation binary_op,
                         UnaryOperation unary_op) noexcept
 {
     for (; first != last; ++first)
     {
         init = binary_op(init, unary_op(*first));
     }
     return init;
 }
 
 static const char*
 done()
 {
 #if __PSTL_TEST_SUCCESSFUL_KEYWORD
     return "done";
 #else
     return "passed";
 #endif
 }
 
 // test_algo_basic_* functions are used to execute
 // f on a very basic sequence of elements of type T.
 
 // Should be used with unary predicate
 template <typename T, typename F>
 static void
 test_algo_basic_single(F&& f)
 {
     size_t N = 10;
     Sequence<T> in(N, [](size_t v) -> T { return T(v); });
 
     invoke_on_all_policies(f, in.begin());
 }
 
 // Should be used with binary predicate
 template <typename T, typename F>
 static void
 test_algo_basic_double(F&& f)
 {
     size_t N = 10;
     Sequence<T> in(N, [](size_t v) -> T { return T(v); });
     Sequence<T> out(N, [](size_t v) -> T { return T(v); });
 
     invoke_on_all_policies(f, in.begin(), out.begin());
 }
 
 template <typename Policy, typename F>
 static void
 invoke_if(Policy&& p, F f)
 {
 #if __PSTL_ICC_16_VC14_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN || __PSTL_ICC_17_VC141_TEST_SIMD_LAMBDA_DEBUG_32_BROKEN
     __pstl::internal::invoke_if_not(__pstl::internal::allow_unsequenced<Policy>(), f);
 #else
     f();
 #endif
 }
 
 } /* namespace TestUtils */