add multiple submission modes in queue gtests (#20969)

Modifications allow for running tests with different queue submission
modes, either specified by the user or provided by default. This is made
possible through the introduced macros:
- `UUR_INSTANTIATE_DEVICE_TEST_SUITE_MULTI_QUEUE(FIXTURE)`: instantiates
the provided `FIXTURE` with the submission modes:
`UR_QUEUE_FLAG_SUBMISSION_BATCHED` and
`UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE`
- `UUR_MULTI_QUEUE_TYPE_TEST_SUITE_WITH_PARAM(FIXTURE, VALUES,
PRINTER)`: similarly instantiates the `FIXTURE` with either batched or
immediate submission modes, but additionally accepts parameters
- `UUR_DEVICE_TEST_SUITE_WITH_QUEUE_TYPES(FIXTURE, MODES)`: instantiates
the provided `FIXTURE` with queue submission modes provided by the user
- `UUR_DEVICE_TEST_SUITE_WITH_DEFAULT_QUEUE(FIXTURE)`: provides only one
default submission mode (specified as 0); the exact mode is chosen by
the device
- `UUR_DEVICE_TEST_SUITE_WITH_QUEUE_TYPES_PRINTER(FIXTURE, MODES,
PRINTER)`: similar to `UUR_DEVICE_TEST_SUITE_WITH_QUEUE_TYPES`, but the
user also provides the `PRINTER` function
- `UUR_DEVICE_TEST_SUITE_WITH_QUEUE_TYPES_AND_PARAM(FIXTURE, VALUES,
MODES, PRINTER)`: similar to
`UUR_MULTI_QUEUE_TYPE_TEST_SUITE_WITH_PARAM`, but the user also provides
queue submission modes

At this moment, `UUR_DEVICE_TEST_SUITE_WITH_QUEUE_TYPES_AND_PARAM` is
not used in any test. As a helper intended for parametrized tests, this
macro is complementary to `UUR_DEVICE_TEST_SUITE_WITH_QUEUE_TYPES`,
which enables the user to specify queue submission modes for
unparametrized tests. Example usage:

```
UUR_DEVICE_TEST_SUITE_WITH_QUEUE_TYPES_AND_PARAM(
    urEnqueueMemBufferFillTest, testing::ValuesIn(test_cases), testing::ValuesIn(UR_QUEUE_FLAG_SUBMISSION_BATCHED,
                                        UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE),
    uur::printFillTestStringMultiQueueType<urEnqueueMemBufferFillTest>);
```

Tests that do not use any queue (like most of the urProgramTests, except
for urProgramSetSpecializationConstantsTest) are instantiated using
`UUR_DEVICE_TEST_SUITE_WITH_DEFAULT_QUEUE`. There might be more tests
that do not need a queue, since the heuristic for determining whether
the given test needs a queue consisted of checking whether the queue
defined in the test class is mentioned in the test file (not checked per
derived test class).

This patch introduces equivalents for `urQueueTest` for unparametrized
tests and `urQueueTestWithParam`, which are `urMultiQueueTypeTest` and
`urMultiQueueTypeTestWithParam`, respectively. Parametrized tests use a
new parameter type: `MultiQueueParam (std::tuple<T, ur_queue_flag_t>)`.
Similarly, the previously "unparametrized" tests, which were eventually
parametrized with the `DeviceTuple`, now use `std::tuple<DeviceTuple,
ur_queue_flag_t>` as their parameter type.

Additionally, urCommandBufferCommandExpTest is removed since it is not
referenced anywhere.

Author: EuphoricThinking

test/adapters/level_zero/enqueue_alloc.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2025 Intel Corporation
+// Copyright (C) 2025-2026 Intel Corporation
 // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
 // Exceptions. See LICENSE.TXT
 //
@@ -160,7 +160,7 @@ struct urL0EnqueueAllocMultiQueueMultiDeviceTest
   std::vector<ur_queue_handle_t> queues;
 };
 
-UUR_DEVICE_TEST_SUITE_WITH_PARAM(
+UUR_MULTI_QUEUE_TYPE_TEST_SUITE_WITH_PARAM(
     urL0EnqueueAllocTest,
     ::testing::ValuesIn({
         EnqueueAllocTestParam{urEnqueueUSMHostAllocExp,
@@ -170,13 +170,11 @@ UUR_DEVICE_TEST_SUITE_WITH_PARAM(
         EnqueueAllocTestParam{urEnqueueUSMDeviceAllocExp,
                               uur::GetDeviceUSMDeviceSupport},
     }),
-    uur::deviceTestWithParamPrinter<EnqueueAllocTestParam>);
+    uur::deviceTestWithParamPrinterMulti<EnqueueAllocTestParam>);
 
 TEST_P(urL0EnqueueAllocTest, Success) {
-  const auto enqueueUSMAllocFunc =
-      std::get<1>(this->GetParam()).enqueueUSMAllocFunc;
-  const auto checkUSMSupportFunc =
-      std::get<1>(this->GetParam()).checkUSMSupportFunc;
+  const auto enqueueUSMAllocFunc = getParam().enqueueUSMAllocFunc;
+  const auto checkUSMSupportFunc = getParam().checkUSMSupportFunc;
 
   ur_device_usm_access_capability_flags_t USMSupport = 0;
   ASSERT_SUCCESS(checkUSMSupportFunc(device, USMSupport));
@@ -200,10 +198,8 @@ TEST_P(urL0EnqueueAllocTest, Success) {
 }
 
 TEST_P(urL0EnqueueAllocTest, SuccessReuse) {
-  const auto enqueueUSMAllocFunc =
-      std::get<1>(this->GetParam()).enqueueUSMAllocFunc;
-  const auto checkUSMSupportFunc =
-      std::get<1>(this->GetParam()).checkUSMSupportFunc;
+  const auto enqueueUSMAllocFunc = getParam().enqueueUSMAllocFunc;
+  const auto checkUSMSupportFunc = getParam().checkUSMSupportFunc;
 
   ur_device_usm_access_capability_flags_t USMSupport = 0;
   ASSERT_SUCCESS(checkUSMSupportFunc(device, USMSupport));
@@ -238,10 +234,8 @@ TEST_P(urL0EnqueueAllocTest, SuccessReuse) {
 }
 
 TEST_P(urL0EnqueueAllocTest, SuccessFromPool) {
-  const auto enqueueUSMAllocFunc =
-      std::get<1>(this->GetParam()).enqueueUSMAllocFunc;
-  const auto checkUSMSupportFunc =
-      std::get<1>(this->GetParam()).checkUSMSupportFunc;
+  const auto enqueueUSMAllocFunc = getParam().enqueueUSMAllocFunc;
+  const auto checkUSMSupportFunc = getParam().checkUSMSupportFunc;
 
   ur_device_usm_access_capability_flags_t USMSupport = 0;
   ASSERT_SUCCESS(checkUSMSupportFunc(device, USMSupport));
@@ -269,10 +263,8 @@ TEST_P(urL0EnqueueAllocTest, SuccessFromPool) {
 }
 
 TEST_P(urL0EnqueueAllocTest, SuccessWithKernel) {
-  const auto enqueueUSMAllocFunc =
-      std::get<1>(this->GetParam()).enqueueUSMAllocFunc;
-  const auto checkUSMSupportFunc =
-      std::get<1>(this->GetParam()).checkUSMSupportFunc;
+  const auto enqueueUSMAllocFunc = getParam().enqueueUSMAllocFunc;
+  const auto checkUSMSupportFunc = getParam().checkUSMSupportFunc;
 
   ur_device_usm_access_capability_flags_t USMSupport = 0;
   ASSERT_SUCCESS(checkUSMSupportFunc(device, USMSupport));
@@ -294,10 +286,8 @@ TEST_P(urL0EnqueueAllocTest, SuccessWithKernel) {
 }
 
 TEST_P(urL0EnqueueAllocTest, SuccessWithKernelRepeat) {
-  const auto enqueueUSMAllocFunc =
-      std::get<1>(this->GetParam()).enqueueUSMAllocFunc;
-  const auto checkUSMSupportFunc =
-      std::get<1>(this->GetParam()).checkUSMSupportFunc;
+  const auto enqueueUSMAllocFunc = getParam().enqueueUSMAllocFunc;
+  const auto checkUSMSupportFunc = getParam().checkUSMSupportFunc;
 
   ur_device_usm_access_capability_flags_t USMSupport = 0;
   ASSERT_SUCCESS(checkUSMSupportFunc(device, USMSupport));

test/adapters/level_zero/urEnqueueMemBufferMapHostPtr.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2023 Intel Corporation
+// Copyright (C) 2023-2026 Intel Corporation
 // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
 // Exceptions. See LICENSE.TXT
 //
@@ -15,7 +15,7 @@
 using urEnqueueMemBufferMapTestWithParamL0 =
     uur::urMemBufferQueueTestWithParam<uur::mem_buffer_test_parameters_t>;
 
-UUR_DEVICE_TEST_SUITE_WITH_PARAM(
+UUR_MULTI_QUEUE_TYPE_TEST_SUITE_WITH_PARAM(
     urEnqueueMemBufferMapTestWithParamL0,
     ::testing::ValuesIn(uur::mem_buffer_test_parameters),
     uur::printMemBufferTestString<urEnqueueMemBufferMapTestWithParamL0>);

test/adapters/level_zero/urEventCreateWithNativeHandle.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2024 Intel Corporation
+// Copyright (C) 2024-2026 Intel Corporation
 // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
 // Exceptions. See LICENSE.TXT
 //
@@ -17,8 +17,8 @@
 #include "ze_helpers.hpp"
 
 using namespace std::chrono_literals;
-using urLevelZeroEventNativeHandleTest = uur::urQueueTest;
-UUR_INSTANTIATE_DEVICE_TEST_SUITE(urLevelZeroEventNativeHandleTest);
+using urLevelZeroEventNativeHandleTest = uur::urMultiQueueTypeTest;
+UUR_INSTANTIATE_DEVICE_TEST_SUITE_MULTI_QUEUE(urLevelZeroEventNativeHandleTest);
 
 #define TEST_MEMCPY_SIZE 4096
 

test/adapters/level_zero/urKernelCreateWithNativeHandle.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2024 Intel Corporation
+// Copyright (C) 2024-2026 Intel Corporation
 // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
 // Exceptions. See LICENSE.TXT
 //
@@ -12,8 +12,9 @@
 #include "ze_api.h"
 #include <uur/fixtures.h>
 
-using urLevelZeroKernelNativeHandleTest = uur::urQueueTest;
-UUR_INSTANTIATE_DEVICE_TEST_SUITE(urLevelZeroKernelNativeHandleTest);
+using urLevelZeroKernelNativeHandleTest = uur::urMultiQueueTypeTest;
+UUR_INSTANTIATE_DEVICE_TEST_SUITE_MULTI_QUEUE(
+    urLevelZeroKernelNativeHandleTest);
 
 TEST_P(urLevelZeroKernelNativeHandleTest, OwnedHandleRelease) {
   ze_context_handle_t native_context;

test/adapters/level_zero/urMemBufferCreateWithNativeHandleShared.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2025 Intel Corporation
+// Copyright (C) 2025-2026 Intel Corporation
 // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
 // Exceptions. See LICENSE.TXT
 //
@@ -13,8 +13,9 @@
 #include "ze_api.h"
 #include <uur/fixtures.h>
 
-using urMemBufferCreateWithNativeHandleTest = uur::urQueueTest;
-UUR_INSTANTIATE_DEVICE_TEST_SUITE(urMemBufferCreateWithNativeHandleTest);
+using urMemBufferCreateWithNativeHandleTest = uur::urMultiQueueTypeTest;
+UUR_INSTANTIATE_DEVICE_TEST_SUITE_MULTI_QUEUE(
+    urMemBufferCreateWithNativeHandleTest);
 
 TEST_P(urMemBufferCreateWithNativeHandleTest, SharedBufferIsUsedDirectly) {
   UUR_KNOWN_FAILURE_ON(uur::LevelZero{});

test/adapters/level_zero/urProgramLink.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2024 Intel Corporation
+// Copyright (C) 2024-2026 Intel Corporation
 // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
 // Exceptions. See LICENSE.TXT
 //
@@ -11,7 +11,7 @@
 #include <uur/fixtures.h>
 
 using urLevelZeroProgramLinkTest = uur::urProgramTest;
-UUR_INSTANTIATE_DEVICE_TEST_SUITE(urLevelZeroProgramLinkTest);
+UUR_DEVICE_TEST_SUITE_WITH_DEFAULT_QUEUE(urLevelZeroProgramLinkTest);
 
 TEST_P(urLevelZeroProgramLinkTest, InvalidLinkOptionsPrintedInLog) {
   ur_program_handle_t linked_program = nullptr;

test/adapters/level_zero/v2/deferred_kernel.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2024 Intel Corporation
+// Copyright (C) 2024-2026 Intel Corporation
 // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
 // Exceptions. See LICENSE.TXT
 //
@@ -29,7 +29,7 @@ struct urEnqueueKernelLaunchTest : uur::urKernelExecutionTest {
   size_t global_offset = 0;
   size_t n_dimensions = 1;
 };
-UUR_INSTANTIATE_DEVICE_TEST_SUITE(urEnqueueKernelLaunchTest);
+UUR_INSTANTIATE_DEVICE_TEST_SUITE_MULTI_QUEUE(urEnqueueKernelLaunchTest);
 
 TEST_P(urEnqueueKernelLaunchTest, DeferredKernelRelease) {
   ur_mem_handle_t buffer = nullptr;

test/conformance/enqueue/helpers.h

@@ -1,4 +1,4 @@
-// Copyright (C) 2023 Intel Corporation
+// Copyright (C) 2023-2026 Intel Corporation
 // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
 // Exceptions. See LICENSE.TXT
 //
@@ -7,7 +7,9 @@
 #ifndef UUR_ENQUEUE_RECT_HELPERS_H_INCLUDED
 #define UUR_ENQUEUE_RECT_HELPERS_H_INCLUDED
 
+#include "ur_api.h"
 #include <cstring>
+#include <sstream>
 #include <uur/fixtures.h>
 
 namespace uur {
@@ -31,8 +33,33 @@ printRectTestString(const testing::TestParamInfo<typename T::ParamType> &info) {
   // ParamType will be std::tuple<ur_device_handle_t, test_parameters_t>
   const auto device_handle = std::get<0>(info.param).device;
   const auto platform_device_name = GetPlatformAndDeviceName(device_handle);
-  const auto &test_name = std::get<1>(info.param).name;
-  return platform_device_name + "__" + test_name;
+
+  std::stringstream ss;
+  auto param_tuple = std::get<1>(info.param);
+  auto test_name = std::get<0>(param_tuple).name;
+  auto queue_mode = std::get<1>(param_tuple);
+
+  ss << platform_device_name << "__" << test_name << "__" << queue_mode;
+
+  return ss.str();
+}
+
+template <typename T>
+inline std::string printRectTestStringMultiQueue(
+    const testing::TestParamInfo<typename T::ParamType> &info) {
+  // ParamType will be std::tuple<ur_device_handle_t, test_parameters_t>
+  const auto device_handle = std::get<0>(info.param).device;
+  const auto platform_device_name = GetPlatformAndDeviceName(device_handle);
+  auto paramTuple = std::get<1>(info.param);
+  auto param = std::get<0>(paramTuple);
+
+  auto queueMode = std::get<1>(paramTuple);
+
+  std::stringstream test_name;
+  test_name << platform_device_name;
+  test_name << param.name << "__" << queueMode;
+
+  return test_name.str();
 }
 
 // Performs host side equivalent of urEnqueueMemBufferReadRect,
@@ -74,13 +101,18 @@ print2DTestString(const testing::TestParamInfo<typename T::ParamType> &info) {
   const auto platform_device_name =
       uur::GetPlatformAndDeviceName(device_handle);
   std::stringstream test_name;
-  const auto src_kind = std::get<1>(std::get<1>(info.param));
-  const auto dst_kind = std::get<2>(std::get<1>(info.param));
-  test_name << platform_device_name << "__pitch__"
-            << std::get<0>(std::get<1>(info.param)).pitch << "__width__"
-            << std::get<0>(std::get<1>(info.param)).width << "__height__"
-            << std::get<0>(std::get<1>(info.param)).height << "__src__"
-            << src_kind << "__dst__" << dst_kind;
+
+  auto paramTuple = std::get<1>(info.param);
+  auto param = std::get<0>(paramTuple);
+  auto queueMode = std::get<1>(paramTuple);
+  const auto src_kind = std::get<1>(param);
+  const auto dst_kind = std::get<2>(param);
+  TestParameters2D testParams = std::get<0>(param);
+  test_name << platform_device_name << "__pitch__" << testParams.pitch
+            << "__width__" << testParams.width << "__height__"
+            << testParams.height << "__src__" << src_kind << "__dst__"
+            << dst_kind << "__" << queueMode;
+
   return test_name.str();
 }
 
@@ -122,10 +154,16 @@ inline std::string printMemBufferTestString(
   const auto device_handle = std::get<0>(info.param).device;
   const auto platform_device_name = GetPlatformAndDeviceName(device_handle);
 
+  auto paramTuple = std::get<1>(info.param);
+  auto param = std::get<0>(paramTuple);
+  auto queueMode = std::get<1>(paramTuple);
+
   std::stringstream ss;
-  ss << std::get<1>(info.param).count;
+  ss << param.count;
   ss << "_";
-  ss << std::get<1>(info.param).mem_flag;
+  ss << param.mem_flag;
+  ss << "__";
+  ss << queueMode;
 
   return platform_device_name + "__" + ss.str();
 }
@@ -138,22 +176,31 @@ inline std::string printMemBufferMapWriteTestString(
   const auto device_handle = std::get<0>(info.param).device;
   const auto platform_device_name = GetPlatformAndDeviceName(device_handle);
 
+  auto paramTuple = std::get<1>(info.param);
+  auto param = std::get<0>(paramTuple);
+  auto queueMode = std::get<1>(paramTuple);
+
   std::stringstream ss;
-  ss << std::get<1>(info.param).map_flag;
+  ss << param.map_flag << "__" << queueMode;
 
   return platform_device_name + "__" + ss.str();
 }
 
 template <typename T>
-inline std::string
-printFillTestString(const testing::TestParamInfo<typename T::ParamType> &info) {
+inline std::string printFillTestStringMultiQueueType(
+    const testing::TestParamInfo<typename T::ParamType> &info) {
   const auto device_handle = std::get<0>(info.param).device;
   const auto platform_device_name =
       uur::GetPlatformAndDeviceName(device_handle);
+  auto paramTuple = std::get<1>(info.param);
+  auto param = std::get<0>(paramTuple);
+
+  auto queueMode = std::get<1>(paramTuple);
+
   std::stringstream test_name;
-  test_name << platform_device_name << "__size__"
-            << std::get<1>(info.param).size << "__patternSize__"
-            << std::get<1>(info.param).pattern_size;
+  test_name << platform_device_name << "__size__" << param.size
+            << "__patternSize__" << param.pattern_size << "__" << queueMode;
+
   return test_name.str();
 }
 

test/conformance/enqueue/urEnqueueDeviceGlobalVariableRead.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2023 Intel Corporation
+// Copyright (C) 2023-2026 Intel Corporation
 // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
 // Exceptions. See LICENSE.TXT
 //
@@ -8,10 +8,10 @@
 using urEnqueueDeviceGetGlobalVariableReadWithParamTest =
     uur::urGlobalVariableWithParamTest<uur::BoolTestParam>;
 
-UUR_DEVICE_TEST_SUITE_WITH_PARAM(
+UUR_MULTI_QUEUE_TYPE_TEST_SUITE_WITH_PARAM(
     urEnqueueDeviceGetGlobalVariableReadWithParamTest,
     testing::ValuesIn(uur::BoolTestParam::makeBoolParam("Blocking")),
-    uur::deviceTestWithParamPrinter<uur::BoolTestParam>);
+    uur::deviceTestWithParamPrinterMulti<uur::BoolTestParam>);
 
 TEST_P(urEnqueueDeviceGetGlobalVariableReadWithParamTest, Success) {
   bool is_blocking = getParam().value;
@@ -44,7 +44,8 @@ TEST_P(urEnqueueDeviceGetGlobalVariableReadWithParamTest, Success) {
 }
 
 using urEnqueueDeviceGetGlobalVariableReadTest = uur::urGlobalVariableTest;
-UUR_INSTANTIATE_DEVICE_TEST_SUITE(urEnqueueDeviceGetGlobalVariableReadTest);
+UUR_INSTANTIATE_DEVICE_TEST_SUITE_MULTI_QUEUE(
+    urEnqueueDeviceGetGlobalVariableReadTest);
 
 TEST_P(urEnqueueDeviceGetGlobalVariableReadTest, InvalidNullHandleQueue) {
   ASSERT_EQ_RESULT(urEnqueueDeviceGlobalVariableRead(

test/conformance/enqueue/urEnqueueDeviceGlobalVariableWrite.cpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2023 Intel Corporation
+// Copyright (C) 2023-2026 Intel Corporation
 // Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
 // Exceptions. See LICENSE.TXT
 //
@@ -8,10 +8,10 @@
 using urEnqueueDeviceGetGlobalVariableWriteWithParamTest =
     uur::urGlobalVariableWithParamTest<uur::BoolTestParam>;
 
-UUR_DEVICE_TEST_SUITE_WITH_PARAM(
+UUR_MULTI_QUEUE_TYPE_TEST_SUITE_WITH_PARAM(
     urEnqueueDeviceGetGlobalVariableWriteWithParamTest,
     testing::ValuesIn(uur::BoolTestParam::makeBoolParam("Blocking")),
-    uur::deviceTestWithParamPrinter<uur::BoolTestParam>);
+    uur::deviceTestWithParamPrinterMulti<uur::BoolTestParam>);
 
 TEST_P(urEnqueueDeviceGetGlobalVariableWriteWithParamTest, Success) {
   bool is_blocking = getParam().value;
@@ -46,7 +46,8 @@ TEST_P(urEnqueueDeviceGetGlobalVariableWriteWithParamTest, Success) {
 }
 
 using urEnqueueDeviceGetGlobalVariableWriteTest = uur::urGlobalVariableTest;
-UUR_INSTANTIATE_DEVICE_TEST_SUITE(urEnqueueDeviceGetGlobalVariableWriteTest);
+UUR_INSTANTIATE_DEVICE_TEST_SUITE_MULTI_QUEUE(
+    urEnqueueDeviceGetGlobalVariableWriteTest);
 
 TEST_P(urEnqueueDeviceGetGlobalVariableWriteTest, InvalidNullHandleQueue) {
   ASSERT_EQ_RESULT(urEnqueueDeviceGlobalVariableWrite(