Extend test coverage for different policy qualifiers

test/general/dpl_namespace.pass.cpp

@@ -53,12 +53,7 @@ int main()
 		TestUtils::make_device_policy<class Scan>(dpl::execution::dpcpp_default),
 		key_first, key_first + n, val_first, res_first);
 
-    if (result - res_first != k){
-        std::cout << "size of keys output is not valid: expected = "<< k <<", got: "<< result - res_first << std::endl;
-    }
-    else{
-        std::cout << "done" << std::endl;
-    }
+    EXPECT_EQ(k, result - res_first, "size of keys output is not valid");
 
 #endif
 

test/general/header_inclusion_order_async_0.pass.cpp

@@ -18,13 +18,11 @@
 
 #include "support/utils.h"
 
-int
-main()
-{
 #if TEST_DPCPP_BACKEND_PRESENT
-
-    auto policy = TestUtils::get_dpcpp_test_policy();
-    sycl::queue q = policy.queue();
+template <typename Policy>
+void test(Policy&& exec)
+{
+    sycl::queue q = exec.queue();
 
     constexpr std::size_t n = 100;
 
@@ -34,8 +32,20 @@ main()
     allocator alloc(q);
     std::vector<T, allocator> data(n, 1, alloc);
 
-    auto f = oneapi::dpl::experimental::reduce_async(policy, data.begin(), data.end());
+    auto f = oneapi::dpl::experimental::reduce_async(std::forward<Policy>(exec), data.begin(), data.end());
     f.wait();
+}
+#endif // TEST_DPCPP_BACKEND_PRESENT
+
+int
+main()
+{
+#if TEST_DPCPP_BACKEND_PRESENT
+
+    auto policy = TestUtils::get_dpcpp_test_policy();
+    test(policy);
+
+    TestUtils::check_compilation(policy, [](auto&& policy) { test(std::forward<decltype(policy)>(policy)); });
 
 #endif // TEST_DPCPP_BACKEND_PRESENT
 

test/general/header_inclusion_order_async_1.pass.cpp

@@ -18,13 +18,11 @@
 
 #include "support/utils.h"
 
-int
-main()
-{
 #if TEST_DPCPP_BACKEND_PRESENT
-
-    auto policy = TestUtils::get_dpcpp_test_policy();
-    sycl::queue q = policy.queue();
+template <typename Policy>
+void test(Policy&& exec)
+{
+    sycl::queue q = exec.queue();
 
     constexpr std::size_t n = 100;
 
@@ -34,8 +32,20 @@ main()
     allocator alloc(q);
     std::vector<T, allocator> data(n, 1, alloc);
 
-    auto f = oneapi::dpl::experimental::reduce_async(policy, data.begin(), data.end());
+    auto f = oneapi::dpl::experimental::reduce_async(std::forward<Policy>(exec), data.begin(), data.end());
     f.wait();
+}
+#endif // TEST_DPCPP_BACKEND_PRESENT
+
+int
+main()
+{
+#if TEST_DPCPP_BACKEND_PRESENT
+
+    auto policy = TestUtils::get_dpcpp_test_policy();
+    test(policy);
+
+    TestUtils::check_compilation(policy, [](auto&& policy) { test(std::forward<decltype(policy)>(policy)); });
 
 #endif // TEST_DPCPP_BACKEND_PRESENT
 

test/general/header_order_ranges_0.pass.cpp

@@ -22,12 +22,25 @@
 
 #include "support/utils.h"
 
+#if _ENABLE_RANGES_TESTING
+template <typename Policy>
+void test(Policy&& exec)
+{
+    using namespace oneapi::dpl::experimental::ranges;
+    all_of(std::forward<Policy>(exec), views::fill(-1, 10), [](auto i) { return i == -1;});
+}
+#endif // _ENABLE_RANGES_TESTING
+
 int
 main()
 {
 #if _ENABLE_RANGES_TESTING
-    using namespace oneapi::dpl::experimental::ranges;
-    all_of(TestUtils::get_dpcpp_test_policy(), views::fill(-1, 10), [](auto i) { return i == -1;});
+
+    auto policy = TestUtils::get_dpcpp_test_policy();
+    test(policy);
+
+    TestUtils::check_compilation(policy, [](auto&& policy) { test(std::forward<decltype(policy)>(policy)); });
+
 #endif
 
     return TestUtils::done(_ENABLE_RANGES_TESTING);

test/general/header_order_ranges_1.pass.cpp

@@ -22,12 +22,25 @@
 
 #include "support/utils.h"
 
+#if _ENABLE_RANGES_TESTING
+template <typename Policy>
+void test(Policy&& exec)
+{
+    using namespace oneapi::dpl::experimental::ranges;
+    all_of(std::forward<Policy>(exec), views::fill(-1, 10), [](auto i) { return i == -1;});
+}
+#endif // _ENABLE_RANGES_TESTING
+
 int
 main()
 {
 #if _ENABLE_RANGES_TESTING
-    using namespace oneapi::dpl::experimental::ranges;
-    all_of(TestUtils::get_dpcpp_test_policy(), views::fill(-1, 10), [](auto i) { return i == -1;});
+
+    auto policy = TestUtils::get_dpcpp_test_policy();
+    test(policy);
+
+    TestUtils::check_compilation(policy, [](auto&& policy) { test(std::forward<decltype(policy)>(policy)); });
+
 #endif
 
     return TestUtils::done(_ENABLE_RANGES_TESTING);

test/general/implementation_details/test_policy_container.pass.cpp

@@ -0,0 +1,116 @@
+// -*- C++ -*-
+//===-- policy container.pass.cpp ------------------------------------------===//
+//
+// Copyright (C) Intel Corporation
+//
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+// This file incorporates work covered by the following copyright and permission
+// notice:
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+//
+//===----------------------------------------------------------------------===//
+
+#include "support/test_config.h"
+
+#include <type_traits>
+#include <utility>
+
+#include "support/utils.h"
+
+#if TEST_DPCPP_BACKEND_PRESENT
+#include "support/utils_invoke.h"
+#include "oneapi/dpl/pstl/hetero/dpcpp/execution_sycl_defs.h"
+#endif
+
+#if TEST_DPCPP_BACKEND_PRESENT
+
+struct PassByValue{};
+struct PassByConstReference{};
+struct PassByMove{};
+
+template <typename SourcePolicyKernelName, typename Policy, typename PassTag>
+void test_policy_container(Policy&& exec, PassTag)
+{
+#if TEST_EXPLICIT_KERNEL_NAMES
+    using ThisPolicyKernelName = oneapi::dpl::__internal::__policy_kernel_name<Policy>;
+    static_assert(!std::is_same_v<SourcePolicyKernelName, ThisPolicyKernelName>, "Temporary test policy should have unique Kernel name");
+#endif
+
+    using DecayedPolicy = std::decay_t<decltype(exec)>;
+
+    if constexpr (std::is_same_v<PassTag, PassByValue>)
+    {
+        using DecayedPolicyRefRef = DecayedPolicy&&;
+
+        static_assert(std::is_same_v<decltype(exec), DecayedPolicyRefRef>, "Invalid test policy value category #0");
+    }
+
+    if constexpr (std::is_same_v<PassTag, PassByConstReference>)
+    {
+        using DecayedPolicyConstRef = const DecayedPolicy&;
+
+        static_assert(std::is_same_v<decltype(exec), DecayedPolicyConstRef>, "Invalid test policy value category #1");
+    }
+
+    if constexpr (std::is_same_v<PassTag, PassByMove>)
+    {
+        using DecayedPolicyConstRef = DecayedPolicy&&;
+
+        static_assert(std::is_same_v<decltype(exec), DecayedPolicyConstRef>, "Invalid test policy value category #2");
+    }
+}
+
+template <typename Policy>
+void test_pass_by_value(Policy policy)
+{
+    using SourcePolicyKernelName = oneapi::dpl::__internal::__policy_kernel_name<Policy>;
+
+    test_policy_container<SourcePolicyKernelName>(CREATE_NEW_POLICY(policy, 0), PassByValue{});
+}
+
+template <typename Policy>
+void test_pass_by_const_ref(const Policy& policy)
+{
+    using SourcePolicyKernelName = oneapi::dpl::__internal::__policy_kernel_name<Policy>;
+
+    test_policy_container<SourcePolicyKernelName>(CREATE_NEW_POLICY(policy, 0), PassByConstReference{});
+}
+
+template <typename Policy>
+void test_pass_by_rval(Policy&& policy)
+{
+    using SourcePolicyKernelName = oneapi::dpl::__internal::__policy_kernel_name<Policy>;
+
+    test_policy_container<SourcePolicyKernelName>(CREATE_NEW_POLICY(policy, 0), PassByMove{});
+}
+
+#endif // TEST_DPCPP_BACKEND_PRESENT
+
+int
+main()
+{
+#if TEST_DPCPP_BACKEND_PRESENT
+
+    {
+        const auto policy = TestUtils::get_dpcpp_test_policy();
+        test_pass_by_value(policy);
+    }
+
+    {
+        // Save the policy in a const reference
+        const auto& policy = TestUtils::get_dpcpp_test_policy();
+        test_pass_by_const_ref(policy);
+    }
+
+    {
+        auto policy = TestUtils::get_dpcpp_test_policy();
+        test_pass_by_rval(std::move(policy));
+    }
+
+#endif // TEST_DPCPP_BACKEND_PRESENT
+
+    return TestUtils::done(TEST_DPCPP_BACKEND_PRESENT);
+}

test/general/lambda_naming.pass.cpp

@@ -22,48 +22,87 @@
 
 #include "support/utils.h"
 
-using namespace TestUtils;
-
-// This is the simple test for compilation only, to check if lambda naming works correctly
-int main() {
 #if TEST_DPCPP_BACKEND_PRESENT
+
+template <typename T>
+struct PostIncrementOp
+{
+    void operator()(T& x) const
+    {
+        x++;
+    }
+};
+
+template <typename T>
+struct Add41Op
+{
+    void operator()(T& x) const
+    {
+        x += 41;
+    }
+};
+
+struct ForEach;
+
+template <typename Policy>
+void
+test_impl(Policy&& policy)
+{
     const int n = 1000;
-    sycl::buffer<int> buf{ sycl::range<1>(n) };
-    sycl::buffer<int> out_buf{ sycl::range<1>(n) };
+    sycl::buffer<int> buf{sycl::range<1>(n)};
+    sycl::buffer<int> out_buf{sycl::range<1>(n)};
     auto buf_begin = oneapi::dpl::begin(buf);
     auto buf_end = buf_begin + n;
 
-    const auto policy = TestUtils::get_dpcpp_test_policy();
     auto buf_begin_discard_write = oneapi::dpl::begin(buf, sycl::write_only, sycl::property::no_init{});
 
-    ::std::fill(policy, buf_begin_discard_write, buf_begin_discard_write + n, 1);
-#if __SYCL_UNNAMED_LAMBDA__
-    ::std::sort(policy, buf_begin, buf_end);
-    ::std::for_each(policy, buf_begin, buf_end, [](int& x) { x += 41; });
+    std::fill(CLONE_NEW_POLICY(policy), buf_begin_discard_write, buf_begin_discard_write + n, 1);
+
+#    if __SYCL_UNNAMED_LAMBDA__
+
+    std::sort(CLONE_NEW_POLICY(policy), buf_begin, buf_end);
+    std::for_each(CLONE_NEW_POLICY(policy), buf_begin, buf_end, Add41Op<int>());
 
-#if !ONEDPL_FPGA_DEVICE
-    sycl::buffer<float> out_buf_2{ sycl::range<1>(n) };
+#        if !ONEDPL_FPGA_DEVICE
+    sycl::buffer<float> out_buf_2{sycl::range<1>(n)};
     auto buf_out_begin_2 = oneapi::dpl::begin(out_buf_2);
-    ::std::copy(policy, buf_begin, buf_end, buf_out_begin_2);
-    ::std::copy(policy, buf_out_begin_2, buf_out_begin_2 + n, buf_begin);
-    ::std::inplace_merge(policy, buf_begin, buf_begin + n / 2, buf_end);
-    auto red_val = ::std::reduce(policy, buf_begin, buf_end, 1);
+    std::copy(CLONE_NEW_POLICY(policy), buf_begin, buf_end, buf_out_begin_2);
+    std::copy(CLONE_NEW_POLICY(policy), buf_out_begin_2, buf_out_begin_2 + n, buf_begin);
+    std::inplace_merge(CLONE_NEW_POLICY(policy), buf_begin, buf_begin + n / 2, buf_end);
+    auto red_val = std::reduce(CLONE_NEW_POLICY(policy), buf_begin, buf_end, 1);
     EXPECT_TRUE(red_val == 42001, "wrong return value from reduce");
+
     auto buf_out_begin = oneapi::dpl::begin(out_buf);
-    ::std::inclusive_scan(policy, buf_begin, buf_end, buf_out_begin);
-    bool is_equal = ::std::equal(policy, buf_begin, buf_end, buf_out_begin);
+    std::inclusive_scan(CLONE_NEW_POLICY(policy), buf_begin, buf_end, buf_out_begin);
+    bool is_equal = std::equal(CLONE_NEW_POLICY(policy), buf_begin, buf_end, buf_out_begin);
     EXPECT_TRUE(!is_equal, "wrong return value from equal");
-    auto does_1_exist = ::std::find(policy, buf_begin, buf_end, 1);
+
+    auto does_1_exist = std::find(CLONE_NEW_POLICY(policy), buf_begin, buf_end, 1);
     EXPECT_TRUE(does_1_exist - buf_begin == 1000, "wrong return value from find");
-#endif // !ONEDPL_FPGA_DEVICE
+#        endif // !ONEDPL_FPGA_DEVICE
 
-#else
-    // ::std::for_each(policy, buf_begin, buf_end, [](int& x) { x++; }); // It's not allowed. Policy with different name is needed
-    ::std::for_each(TestUtils::make_device_policy<class ForEach>(policy), buf_begin, buf_end, [](int& x) { x++; });
-    auto red_val = ::std::reduce(policy, buf_begin, buf_end, 1);
+#    else
+
+    // std::for_each(policy, buf_begin, buf_end, [](int& x) { x++; }); // It's not allowed. Policy with different name is needed
+    std::for_each(CREATE_NEW_POLICY_WITH_NAME(policy, ForEach), buf_begin, buf_end, PostIncrementOp<int>());
+    auto red_val = std::reduce(CLONE_NEW_POLICY(policy), buf_begin, buf_end, 1);
     EXPECT_TRUE(red_val == 2001, "wrong return value from reduce");
-#endif // __SYCL_UNNAMED_LAMBDA__
+
+#    endif // __SYCL_UNNAMED_LAMBDA__
+}
+#endif // TEST_DPCPP_BACKEND_PRESENT
+
+// This is the simple test for compilation only, to check if lambda naming works correctly
+int main()
+{
+#if TEST_DPCPP_BACKEND_PRESENT
+
+    auto policy = TestUtils::get_dpcpp_test_policy();
+    test_impl(policy);
+
+    TestUtils::check_compilation(policy, [](auto&& policy) { test_impl(std::forward<decltype(policy)>(policy)); });
+
 #endif // TEST_DPCPP_BACKEND_PRESENT
 
-    return done(TEST_DPCPP_BACKEND_PRESENT);
+    return TestUtils::done(TEST_DPCPP_BACKEND_PRESENT);
 }