[SYCL][NFC] Barrier unit tests - extend to queue shortcuts (#20260)

Extend the queue/Barrier unit tests to the single task queue shortcut
function.

Author: slawekptak

sycl/unittests/helpers/CommandSubmitWrappers.hpp

@@ -10,6 +10,7 @@
 
 #include <sycl/event.hpp>
 #include <sycl/handler.hpp>
+#include <sycl/queue.hpp>
 
 namespace sycl {
 

sycl/unittests/queue/Barrier.cpp

@@ -6,6 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include <helpers/CommandSubmitWrappers.hpp>
 #include <helpers/TestKernel.hpp>
 #include <helpers/UrMock.hpp>
 #include <sycl/sycl.hpp>
@@ -15,6 +16,8 @@
 static unsigned NumOfEventsWaitWithBarrierCalls = 0;
 static unsigned NumEventsInWaitList = 0;
 
+class Queue : public testing::TestWithParam<bool> {};
+
 static ur_result_t redefined_urEnqueueEventsWaitWithBarrierExt(void *pParams) {
   NumOfEventsWaitWithBarrierCalls++;
   // Get the number of events in the wait list
@@ -25,92 +28,111 @@ static ur_result_t redefined_urEnqueueEventsWaitWithBarrierExt(void *pParams) {
   return UR_RESULT_SUCCESS;
 }
 
-TEST(Queue, HandlerBarrier) {
+TEST_P(Queue, HandlerBarrier) {
   sycl::unittest::UrMock<> Mock;
   mock::getCallbacks().set_before_callback(
       "urEnqueueEventsWaitWithBarrierExt",
       &redefined_urEnqueueEventsWaitWithBarrierExt);
   NumOfEventsWaitWithBarrierCalls = 0;
+  bool UseShortcutFunction = GetParam();
 
   sycl::queue Q;
 
-  Q.submit([&](sycl::handler &cgh) { cgh.single_task<TestKernel>([=]() {}); });
-  Q.submit([&](sycl::handler &cgh) { cgh.single_task<TestKernel>([=]() {}); });
+  sycl::unittest::single_task_wrapper<TestKernel>(UseShortcutFunction, Q,
+                                                  [=]() {});
+  sycl::unittest::single_task_wrapper<TestKernel>(UseShortcutFunction, Q,
+                                                  [=]() {});
 
   Q.submit([&](sycl::handler &cgh) { cgh.ext_oneapi_barrier(); });
 
   ASSERT_EQ(NumOfEventsWaitWithBarrierCalls, 1u);
 }
 
-TEST(Queue, ExtOneAPISubmitBarrier) {
+TEST_P(Queue, ExtOneAPISubmitBarrier) {
   sycl::unittest::UrMock<> Mock;
   mock::getCallbacks().set_before_callback(
       "urEnqueueEventsWaitWithBarrierExt",
       &redefined_urEnqueueEventsWaitWithBarrierExt);
   NumOfEventsWaitWithBarrierCalls = 0;
+  bool UseShortcutFunction = GetParam();
 
   sycl::queue Q;
 
-  Q.submit([&](sycl::handler &cgh) { cgh.single_task<TestKernel>([=]() {}); });
-  Q.submit([&](sycl::handler &cgh) { cgh.single_task<TestKernel>([=]() {}); });
+  sycl::unittest::single_task_wrapper<TestKernel>(UseShortcutFunction, Q,
+                                                  [=]() {});
+  sycl::unittest::single_task_wrapper<TestKernel>(UseShortcutFunction, Q,
+                                                  [=]() {});
 
   Q.ext_oneapi_submit_barrier();
 
   ASSERT_EQ(NumOfEventsWaitWithBarrierCalls, 1u);
 }
 
-TEST(Queue, HandlerBarrierWithWaitList) {
+TEST_P(Queue, HandlerBarrierWithWaitList) {
   sycl::unittest::UrMock<> Mock;
   mock::getCallbacks().set_before_callback(
       "urEnqueueEventsWaitWithBarrierExt",
       &redefined_urEnqueueEventsWaitWithBarrierExt);
   NumOfEventsWaitWithBarrierCalls = 0;
+  bool UseShortcutFunction = GetParam();
 
   sycl::queue Q1;
   sycl::queue Q2;
   sycl::queue Q3;
 
-  auto E1 = Q1.submit(
-      [&](sycl::handler &cgh) { cgh.single_task<TestKernel>([=]() {}); });
-  auto E2 = Q2.submit(
-      [&](sycl::handler &cgh) { cgh.single_task<TestKernel>([=]() {}); });
+  auto E1 = sycl::unittest::single_task_wrapper<TestKernel>(UseShortcutFunction,
+                                                            Q1, [=]() {});
+  auto E2 = sycl::unittest::single_task_wrapper<TestKernel>(UseShortcutFunction,
+                                                            Q2, [=]() {});
 
   Q3.submit([&](sycl::handler &cgh) { cgh.ext_oneapi_barrier({E1, E2}); });
 
   ASSERT_EQ(NumOfEventsWaitWithBarrierCalls, 1u);
 }
 
-TEST(Queue, ExtOneAPISubmitBarrierWithWaitList) {
+TEST_P(Queue, ExtOneAPISubmitBarrierWithWaitList) {
   sycl::unittest::UrMock<> Mock;
   mock::getCallbacks().set_before_callback(
       "urEnqueueEventsWaitWithBarrierExt",
       &redefined_urEnqueueEventsWaitWithBarrierExt);
   NumOfEventsWaitWithBarrierCalls = 0;
+  bool UseShortcutFunction = GetParam();
 
   sycl::queue Q1;
   sycl::queue Q2;
   sycl::queue Q3;
 
-  auto E1 = Q1.submit(
-      [&](sycl::handler &cgh) { cgh.single_task<TestKernel>([=]() {}); });
-  auto E2 = Q2.submit(
-      [&](sycl::handler &cgh) { cgh.single_task<TestKernel>([=]() {}); });
+  auto E1 = sycl::unittest::single_task_wrapper<TestKernel>(UseShortcutFunction,
+                                                            Q1, [=]() {});
+  auto E2 = sycl::unittest::single_task_wrapper<TestKernel>(UseShortcutFunction,
+                                                            Q2, [=]() {});
 
   Q3.ext_oneapi_submit_barrier({E1, E2});
 
   ASSERT_EQ(NumOfEventsWaitWithBarrierCalls, 1u);
 }
 
-TEST(Queue, BarrierWithBarrierDep) {
+TEST_P(Queue, BarrierWithBarrierDep) {
   sycl::unittest::UrMock<> Mock;
   mock::getCallbacks().set_before_callback(
       "urEnqueueEventsWaitWithBarrierExt",
       &redefined_urEnqueueEventsWaitWithBarrierExt);
+  bool UseShortcutFunction = GetParam();
+
   sycl::queue Q1(sycl::property::queue::in_order{});
   sycl::queue Q2(sycl::property::queue::in_order{});
-  Q1.submit([&](sycl::handler &cgh) { cgh.single_task<TestKernel>([=]() {}); });
+
+  sycl::unittest::single_task_wrapper<TestKernel>(UseShortcutFunction, Q1,
+                                                  [=]() {});
+
   sycl::event Barrier1 = Q1.ext_oneapi_submit_barrier();
   NumEventsInWaitList = 0;
   Q2.ext_oneapi_submit_barrier({Barrier1});
   ASSERT_EQ(NumEventsInWaitList, 1u);
 }
+
+INSTANTIATE_TEST_SUITE_P(
+    QueueTestInstance, Queue,
+    testing::Values(
+        true,
+        false)); /* Whether to use the shortcut command submission function */