diff --git a/source/adapters/level_zero/CMakeLists.txt b/source/adapters/level_zero/CMakeLists.txt
index 3c7b5e55f9..05bf05e0a7 100644
--- a/source/adapters/level_zero/CMakeLists.txt
+++ b/source/adapters/level_zero/CMakeLists.txt
@@ -179,11 +179,15 @@ if(UR_BUILD_ADAPTER_L0_V2)
         ${CMAKE_CURRENT_SOURCE_DIR}/common.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/device.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/platform.hpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/program.hpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/helpers/kernel_helpers.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/adapter.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/common.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/device.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/ur_interface_loader.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/platform.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/program.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/helpers/kernel_helpers.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/../../ur/ur.cpp
         # v2-only sources
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/command_list_cache.hpp
@@ -194,8 +198,10 @@ if(UR_BUILD_ADAPTER_L0_V2)
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/event_provider_normal.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/event_provider.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/event.hpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/v2/kernel.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_api.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_immediate_in_order.hpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/v2/usm.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/api.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/command_list_cache.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/context.cpp
@@ -204,9 +210,11 @@ if(UR_BUILD_ADAPTER_L0_V2)
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/event_provider_counter.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/event_provider_normal.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/event.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/v2/kernel.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_api.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_create.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/queue_immediate_in_order.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/v2/usm.cpp
     )
 
     if(NOT WIN32)
@@ -220,6 +228,8 @@ if(UR_BUILD_ADAPTER_L0_V2)
         )
     endif()
 
+    target_compile_definitions(ur_adapter_level_zero_v2 PUBLIC UR_ADAPTER_LEVEL_ZERO_V2)
+
     # TODO: fix level_zero adapter conversion warnings
     target_compile_options(ur_adapter_level_zero_v2 PRIVATE
         $<$<CXX_COMPILER_ID:MSVC>:/wd4805 /wd4244>
@@ -245,6 +255,7 @@ if(UR_BUILD_ADAPTER_L0_V2)
 
     target_include_directories(ur_adapter_level_zero_v2 PRIVATE
         "${CMAKE_CURRENT_SOURCE_DIR}/../.."
+        "${CMAKE_CURRENT_SOURCE_DIR}/../../ur"
         LevelZeroLoader-Headers
     )
 endif()
diff --git a/source/adapters/level_zero/command_buffer.hpp b/source/adapters/level_zero/command_buffer.hpp
index a514501a5e..c86c6f5ba7 100644
--- a/source/adapters/level_zero/command_buffer.hpp
+++ b/source/adapters/level_zero/command_buffer.hpp
@@ -17,6 +17,7 @@
 #include "common.hpp"
 
 #include "context.hpp"
+#include "kernel.hpp"
 #include "queue.hpp"
 
 struct command_buffer_profiling_t {
diff --git a/source/adapters/level_zero/common.hpp b/source/adapters/level_zero/common.hpp
index 5784d5bf78..b7d0a4a913 100644
--- a/source/adapters/level_zero/common.hpp
+++ b/source/adapters/level_zero/common.hpp
@@ -25,6 +25,8 @@
 
 #include <umf_pools/disjoint_pool_config_parser.hpp>
 
+#include "logger/ur_logger.hpp"
+
 struct _ur_platform_handle_t;
 
 static auto getUrResultString = [](ur_result_t Result) {
@@ -168,7 +170,7 @@ static auto getUrResultString = [](ur_result_t Result) {
   }
 };
 
-// Trace an internal PI call; returns in case of an error.
+// Trace an internal UR call; returns in case of an error.
 #define UR_CALL(Call)                                                          \
   {                                                                            \
     if (PrintTrace)                                                            \
@@ -180,6 +182,18 @@ static auto getUrResultString = [](ur_result_t Result) {
       return Result;                                                           \
   }
 
+// Trace an internal UR call; throw in case of an error.
+#define UR_CALL_THROWS(Call)                                                   \
+  {                                                                            \
+    if (PrintTrace)                                                            \
+      logger::always("UR ---> {}", #Call);                                     \
+    ur_result_t Result = (Call);                                               \
+    if (PrintTrace)                                                            \
+      logger::always("UR <--- {}({})", #Call, getUrResultString(Result));      \
+    if (Result != UR_RESULT_SUCCESS)                                           \
+      throw Result;                                                            \
+  }
+
 // Controls UR L0 calls tracing.
 enum UrDebugLevel {
   UR_L0_DEBUG_NONE = 0x0,
diff --git a/source/adapters/level_zero/context.cpp b/source/adapters/level_zero/context.cpp
index 95d6cd89f3..452189d038 100644
--- a/source/adapters/level_zero/context.cpp
+++ b/source/adapters/level_zero/context.cpp
@@ -829,3 +829,12 @@ bool ur_context_handle_t_::isValidDevice(ur_device_handle_t Device) const {
   }
   return false;
 }
+
+const std::vector<ur_device_handle_t> &
+ur_context_handle_t_::getDevices() const {
+  return Devices;
+}
+
+ze_context_handle_t ur_context_handle_t_::getZeHandle() const {
+  return ZeContext;
+}
diff --git a/source/adapters/level_zero/context.hpp b/source/adapters/level_zero/context.hpp
index dc70a2470c..a1212f0698 100644
--- a/source/adapters/level_zero/context.hpp
+++ b/source/adapters/level_zero/context.hpp
@@ -193,6 +193,9 @@ struct ur_context_handle_t_ : _ur_object {
   // Return the Platform, which is the same for all devices in the context
   ur_platform_handle_t getPlatform() const;
 
+  // Get vector of devices from this context
+  const std::vector<ur_device_handle_t> &getDevices() const;
+
   // Get index of the free slot in the available pool. If there is no available
   // pool then create new one. The HostVisible parameter tells if we need a
   // slot for a host-visible event. The ProfilingEnabled tells is we need a
@@ -303,6 +306,9 @@ struct ur_context_handle_t_ : _ur_object {
   // For that the Device or its root devices need to be in the context.
   bool isValidDevice(ur_device_handle_t Device) const;
 
+  // Get handle to the L0 context
+  ze_context_handle_t getZeHandle() const;
+
 private:
   // Get the cache of events for a provided scope and profiling mode.
   auto getEventCache(bool HostVisible, bool WithProfiling,
diff --git a/source/adapters/level_zero/helpers/kernel_helpers.cpp b/source/adapters/level_zero/helpers/kernel_helpers.cpp
index 9b048bcd7f..e046163c67 100644
--- a/source/adapters/level_zero/helpers/kernel_helpers.cpp
+++ b/source/adapters/level_zero/helpers/kernel_helpers.cpp
@@ -12,9 +12,14 @@
 #include "logger/ur_logger.hpp"
 
 #include "../common.hpp"
-#include "../context.hpp"
 #include "../device.hpp"
 
+#ifdef UR_ADAPTER_LEVEL_ZERO_V2
+#include "../context.hpp"
+#else
+#include "../v2/context.hpp"
+#endif
+
 ur_result_t getSuggestedLocalWorkSize(ur_device_handle_t hDevice,
                                       ze_kernel_handle_t hZeKernel,
                                       size_t GlobalWorkSize3D[3],
diff --git a/source/adapters/level_zero/platform.cpp b/source/adapters/level_zero/platform.cpp
index f51a8f1aa7..68aebf97c7 100644
--- a/source/adapters/level_zero/platform.cpp
+++ b/source/adapters/level_zero/platform.cpp
@@ -503,6 +503,8 @@ ur_result_t ur_platform_handle_t_::populateDeviceCacheIfNeeded() {
   return UR_RESULT_SUCCESS;
 }
 
+size_t ur_platform_handle_t_::getNumDevices() { return URDevicesCache.size(); }
+
 ur_device_handle_t ur_platform_handle_t_::getDeviceById(DeviceId id) {
   for (auto &dev : URDevicesCache) {
     if (dev->Id == id) {
diff --git a/source/adapters/level_zero/platform.hpp b/source/adapters/level_zero/platform.hpp
index fa15c88bdf..b5a4d97aeb 100644
--- a/source/adapters/level_zero/platform.hpp
+++ b/source/adapters/level_zero/platform.hpp
@@ -56,6 +56,8 @@ struct ur_platform_handle_t_ : public _ur_platform {
   // Check the device cache and load it if necessary.
   ur_result_t populateDeviceCacheIfNeeded();
 
+  size_t getNumDevices();
+
   ur_device_handle_t getDeviceById(DeviceId);
 
   // Return the PI device from cache that represents given native device.
diff --git a/source/adapters/level_zero/program.cpp b/source/adapters/level_zero/program.cpp
index 2b40d736c4..f259c69773 100644
--- a/source/adapters/level_zero/program.cpp
+++ b/source/adapters/level_zero/program.cpp
@@ -9,8 +9,14 @@
 //===----------------------------------------------------------------------===//
 
 #include "program.hpp"
+#include "device.hpp"
 #include "logger/ur_logger.hpp"
-#include "ur_level_zero.hpp"
+
+#ifdef UR_ADAPTER_LEVEL_ZERO_V2
+#include "context.hpp"
+#else
+#include "v2/context.hpp"
+#endif
 
 extern "C" {
 // Check to see if a Level Zero module has any unresolved symbols.
@@ -115,8 +121,8 @@ UR_APIEXPORT ur_result_t UR_APICALL urProgramBuild(
     const char *Options          ///< [in][optional] pointer to build options
                                  ///< null-terminated string.
 ) {
-  return urProgramBuildExp(Program, Context->Devices.size(),
-                           Context->Devices.data(), Options);
+  std::vector<ur_device_handle_t> Devices = Context->getDevices();
+  return urProgramBuildExp(Program, Devices.size(), Devices.data(), Options);
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urProgramBuildExp(
@@ -174,7 +180,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urProgramBuildExp(
 
   for (uint32_t i = 0; i < numDevices; i++) {
     ze_device_handle_t ZeDevice = phDevices[i]->ZeDevice;
-    ze_context_handle_t ZeContext = hProgram->Context->ZeContext;
+    ze_context_handle_t ZeContext = hProgram->Context->getZeHandle();
     ze_module_handle_t ZeModuleHandle = nullptr;
     ze_module_build_log_handle_t ZeBuildLog{};
 
@@ -266,7 +272,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urProgramCompile(
     // ze-opt-greater-than-4GB-buffer-required to disable
     // stateful optimizations and be able to use larger than
     // 4GB allocations on these kernels.
-    if (Context->Devices[0]->useRelaxedAllocationLimits()) {
+    if (Context->getDevices()[0]->useRelaxedAllocationLimits()) {
       Program->BuildFlags += " -ze-opt-greater-than-4GB-buffer-required";
     }
   }
@@ -285,9 +291,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urProgramLink(
     ur_program_handle_t
         *Program ///< [out] pointer to handle of program object created.
 ) {
-  return urProgramLinkExp(Context, Context->Devices.size(),
-                          Context->Devices.data(), Count, Programs, Options,
-                          Program);
+  std::vector<ur_device_handle_t> Devices = Context->getDevices();
+  return urProgramLinkExp(Context, Devices.size(), Devices.data(), Count,
+                          Programs, Options, Program);
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urProgramLinkExp(
@@ -426,7 +432,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urProgramLinkExp(
 
       // Call the Level Zero API to compile, link, and create the module.
       ze_device_handle_t ZeDevice = phDevices[i]->ZeDevice;
-      ze_context_handle_t ZeContext = hContext->ZeContext;
+      ze_context_handle_t ZeContext = hContext->getZeHandle();
       ze_module_handle_t ZeModule = nullptr;
       ze_module_build_log_handle_t ZeBuildLog = nullptr;
       ze_result_t ZeResult =
@@ -652,7 +658,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urProgramGetInfo(
       for (auto &ZeModulePair : Program->ZeModuleMap) {
         auto It = Program->ZeModuleMap.find(ZeModulePair.first);
         if (It != Program->ZeModuleMap.end()) {
-          for (auto &Device : Program->Context->Devices) {
+          for (auto &Device : Program->Context->getDevices()) {
             if (Device->ZeDevice == ZeModulePair.first) {
               devices.push_back(Device);
             }
@@ -661,7 +667,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urProgramGetInfo(
       }
       return ReturnValue(devices.data(), devices.size());
     } else {
-      return ReturnValue(Program->Context->Devices[0]);
+      return ReturnValue(Program->Context->getDevices()[0]);
     }
   case UR_PROGRAM_INFO_BINARY_SIZES: {
     std::shared_lock<ur_shared_mutex> Guard(Program->Mutex);
diff --git a/source/adapters/level_zero/v2/api.cpp b/source/adapters/level_zero/v2/api.cpp
index 22ccfbe8d4..dc52874364 100644
--- a/source/adapters/level_zero/v2/api.cpp
+++ b/source/adapters/level_zero/v2/api.cpp
@@ -17,14 +17,6 @@
 
 std::mutex ZeCall::GlobalLock;
 
-ur_result_t UR_APICALL urContextGetInfo(ur_context_handle_t hContext,
-                                        ur_context_info_t propName,
-                                        size_t propSize, void *pPropValue,
-                                        size_t *pPropSizeRet) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t UR_APICALL urContextGetNativeHandle(
     ur_context_handle_t hContext, ur_native_handle_t *phNativeContext) {
   logger::error("{} function not implemented!", __FUNCTION__);
@@ -157,71 +149,6 @@ ur_result_t UR_APICALL urSamplerCreateWithNativeHandle(
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t UR_APICALL urUSMHostAlloc(ur_context_handle_t hContext,
-                                      const ur_usm_desc_t *pUSMDesc,
-                                      ur_usm_pool_handle_t pool, size_t size,
-                                      void **ppMem) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urUSMDeviceAlloc(ur_context_handle_t hContext,
-                                        ur_device_handle_t hDevice,
-                                        const ur_usm_desc_t *pUSMDesc,
-                                        ur_usm_pool_handle_t pool, size_t size,
-                                        void **ppMem) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urUSMSharedAlloc(ur_context_handle_t hContext,
-                                        ur_device_handle_t hDevice,
-                                        const ur_usm_desc_t *pUSMDesc,
-                                        ur_usm_pool_handle_t pool, size_t size,
-                                        void **ppMem) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urUSMFree(ur_context_handle_t hContext, void *pMem) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urUSMGetMemAllocInfo(ur_context_handle_t hContext,
-                                            const void *pMem,
-                                            ur_usm_alloc_info_t propName,
-                                            size_t propSize, void *pPropValue,
-                                            size_t *pPropSizeRet) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urUSMPoolCreate(ur_context_handle_t hContext,
-                                       ur_usm_pool_desc_t *pPoolDesc,
-                                       ur_usm_pool_handle_t *ppPool) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urUSMPoolRetain(ur_usm_pool_handle_t pPool) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urUSMPoolRelease(ur_usm_pool_handle_t pPool) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urUSMPoolGetInfo(ur_usm_pool_handle_t hPool,
-                                        ur_usm_pool_info_t propName,
-                                        size_t propSize, void *pPropValue,
-                                        size_t *pPropSizeRet) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t UR_APICALL urVirtualMemGranularityGetInfo(
     ur_context_handle_t hContext, ur_device_handle_t hDevice,
     ur_virtual_mem_granularity_info_t propName, size_t propSize,
@@ -294,124 +221,6 @@ urPhysicalMemRelease(ur_physical_mem_handle_t hPhysicalMem) {
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t UR_APICALL
-urProgramCreateWithIL(ur_context_handle_t hContext, const void *pIL,
-                      size_t length, const ur_program_properties_t *pProperties,
-                      ur_program_handle_t *phProgram) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramCreateWithBinary(
-    ur_context_handle_t hContext, ur_device_handle_t hDevice, size_t size,
-    const uint8_t *pBinary, const ur_program_properties_t *pProperties,
-    ur_program_handle_t *phProgram) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramBuild(ur_context_handle_t hContext,
-                                      ur_program_handle_t hProgram,
-                                      const char *pOptions) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramCompile(ur_context_handle_t hContext,
-                                        ur_program_handle_t hProgram,
-                                        const char *pOptions) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramLink(ur_context_handle_t hContext,
-                                     uint32_t count,
-                                     const ur_program_handle_t *phPrograms,
-                                     const char *pOptions,
-                                     ur_program_handle_t *phProgram) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramRetain(ur_program_handle_t hProgram) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramRelease(ur_program_handle_t hProgram) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramGetFunctionPointer(ur_device_handle_t hDevice,
-                                                   ur_program_handle_t hProgram,
-                                                   const char *pFunctionName,
-                                                   void **ppFunctionPointer) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramGetGlobalVariablePointer(
-    ur_device_handle_t hDevice, ur_program_handle_t hProgram,
-    const char *pGlobalVariableName, size_t *pGlobalVariableSizeRet,
-    void **ppGlobalVariablePointerRet) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramGetInfo(ur_program_handle_t hProgram,
-                                        ur_program_info_t propName,
-                                        size_t propSize, void *pPropValue,
-                                        size_t *pPropSizeRet) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramGetBuildInfo(ur_program_handle_t hProgram,
-                                             ur_device_handle_t hDevice,
-                                             ur_program_build_info_t propName,
-                                             size_t propSize, void *pPropValue,
-                                             size_t *pPropSizeRet) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramSetSpecializationConstants(
-    ur_program_handle_t hProgram, uint32_t count,
-    const ur_specialization_constant_info_t *pSpecConstants) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramGetNativeHandle(
-    ur_program_handle_t hProgram, ur_native_handle_t *phNativeProgram) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramCreateWithNativeHandle(
-    ur_native_handle_t hNativeProgram, ur_context_handle_t hContext,
-    const ur_program_native_properties_t *pProperties,
-    ur_program_handle_t *phProgram) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urKernelCreate(ur_program_handle_t hProgram,
-                                      const char *pKernelName,
-                                      ur_kernel_handle_t *phKernel) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urKernelSetArgValue(
-    ur_kernel_handle_t hKernel, uint32_t argIndex, size_t argSize,
-    const ur_kernel_arg_value_properties_t *pProperties,
-    const void *pArgValue) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t UR_APICALL urKernelSetArgLocal(
     ur_kernel_handle_t hKernel, uint32_t argIndex, size_t argSize,
     const ur_kernel_arg_local_properties_t *pProperties) {
@@ -444,24 +253,6 @@ urKernelGetSubGroupInfo(ur_kernel_handle_t hKernel, ur_device_handle_t hDevice,
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t UR_APICALL urKernelRetain(ur_kernel_handle_t hKernel) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urKernelRelease(ur_kernel_handle_t hKernel) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL
-urKernelSetArgPointer(ur_kernel_handle_t hKernel, uint32_t argIndex,
-                      const ur_kernel_arg_pointer_properties_t *pProperties,
-                      const void *pArgValue) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t UR_APICALL urKernelSetExecInfo(
     ur_kernel_handle_t hKernel, ur_kernel_exec_info_t propName, size_t propSize,
     const ur_kernel_exec_info_properties_t *pProperties,
@@ -888,33 +679,6 @@ ur_result_t UR_APICALL urKernelSuggestMaxCooperativeGroupCountExp(
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t UR_APICALL urProgramBuildExp(ur_program_handle_t hProgram,
-                                         uint32_t numDevices,
-                                         ur_device_handle_t *phDevices,
-                                         const char *pOptions) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramCompileExp(ur_program_handle_t hProgram,
-                                           uint32_t numDevices,
-                                           ur_device_handle_t *phDevices,
-                                           const char *pOptions) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t UR_APICALL urProgramLinkExp(ur_context_handle_t hContext,
-                                        uint32_t numDevices,
-                                        ur_device_handle_t *phDevices,
-                                        uint32_t count,
-                                        const ur_program_handle_t *phPrograms,
-                                        const char *pOptions,
-                                        ur_program_handle_t *phProgram) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t UR_APICALL urUSMImportExp(ur_context_handle_t hContext, void *pMem,
                                       size_t size) {
   logger::error("{} function not implemented!", __FUNCTION__);
diff --git a/source/adapters/level_zero/v2/command_list_cache.cpp b/source/adapters/level_zero/v2/command_list_cache.cpp
index 0684885391..eee6555f87 100644
--- a/source/adapters/level_zero/v2/command_list_cache.cpp
+++ b/source/adapters/level_zero/v2/command_list_cache.cpp
@@ -9,8 +9,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "command_list_cache.hpp"
+#include "context.hpp"
 
-#include "../context.hpp"
 #include "../device.hpp"
 
 bool v2::immediate_command_list_descriptor_t::operator==(
diff --git a/source/adapters/level_zero/v2/common.hpp b/source/adapters/level_zero/v2/common.hpp
index cec7a4dc97..fdfed0c661 100644
--- a/source/adapters/level_zero/v2/common.hpp
+++ b/source/adapters/level_zero/v2/common.hpp
@@ -14,6 +14,7 @@
 #include <ze_api.h>
 
 #include "../common.hpp"
+#include "logger/ur_logger.hpp"
 
 namespace v2 {
 
@@ -84,6 +85,70 @@ struct ze_handle_wrapper {
   bool ownZeHandle;
 };
 
+template <typename URHandle, ur_result_t (*retain)(URHandle),
+          ur_result_t (*release)(URHandle)>
+struct ur_shared_handle {
+  using handle_t = URHandle;
+
+  ur_shared_handle() : handle(nullptr) {}
+  explicit ur_shared_handle(handle_t handle) : handle(handle) {}
+  ~ur_shared_handle() {
+    try {
+      reset();
+    } catch (...) {
+    }
+  }
+
+  ur_shared_handle(const ur_shared_handle &other) : handle(other.handle) {
+    retain(handle);
+  }
+  ur_shared_handle(ur_shared_handle &&other) : handle(other.handle) {
+    other.handle = nullptr;
+  }
+  ur_shared_handle(std::nullptr_t) : handle(nullptr) {}
+
+  void reset() {
+    if (!handle) {
+      return;
+    }
+
+    UR_CALL_THROWS(release(handle));
+    handle = nullptr;
+  }
+
+  ur_shared_handle &operator=(const ur_shared_handle &other) {
+    if (handle) {
+      release(handle);
+    }
+    handle = other.handle;
+    retain(handle);
+    return *this;
+  }
+  ur_shared_handle &operator=(ur_shared_handle &&other) {
+    if (handle) {
+      release(handle);
+    }
+    handle = other.handle;
+    other.handle = nullptr;
+    return *this;
+  }
+  ur_shared_handle &operator=(std::nullptr_t) {
+    if (handle) {
+      release(handle);
+    }
+    new (this) ur_shared_handle(nullptr);
+    return *this;
+  }
+
+  handle_t *ptr() { return &handle; }
+  handle_t get() const { return handle; }
+  handle_t operator->() { return handle; }
+  operator handle_t() { return handle; }
+
+private:
+  handle_t handle;
+};
+
 using ze_kernel_handle_t =
     ze_handle_wrapper<::ze_kernel_handle_t, zeKernelDestroy>;
 
@@ -93,5 +158,11 @@ using ze_event_handle_t =
 using ze_event_pool_handle_t =
     ze_handle_wrapper<::ze_event_pool_handle_t, zeEventPoolDestroy>;
 
+using ur_queue_shared_handle_t =
+    ur_shared_handle<ur_queue_handle_t, urQueueRetain, urQueueRelease>;
+
+using ur_kernel_shared_handle_t =
+    ur_shared_handle<ur_kernel_handle_t, urKernelRetain, urKernelRelease>;
+
 } // namespace raii
 } // namespace v2
diff --git a/source/adapters/level_zero/v2/context.cpp b/source/adapters/level_zero/v2/context.cpp
index 0a5797f7cd..08032fe85e 100644
--- a/source/adapters/level_zero/v2/context.cpp
+++ b/source/adapters/level_zero/v2/context.cpp
@@ -8,15 +8,28 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "context.hpp"
 #include "../device.hpp"
 
+#include "context.hpp"
+#include "event_provider_normal.hpp"
+
 ur_context_handle_t_::ur_context_handle_t_(ze_context_handle_t hContext,
                                            uint32_t numDevices,
                                            const ur_device_handle_t *phDevices,
-                                           bool)
+                                           bool ownZeContext)
     : hContext(hContext), hDevices(phDevices, phDevices + numDevices),
-      commandListCache(hContext) {}
+      commandListCache(hContext),
+      eventPoolCache(phDevices[0]->Platform->getNumDevices(),
+                     [context = this,
+                      platform = phDevices[0]->Platform](DeviceId deviceId) {
+                       auto device = platform->getDeviceById(deviceId);
+                       // TODO: just use per-context id?
+                       return std::make_unique<v2::provider_normal>(
+                           context, device, v2::EVENT_COUNTER,
+                           v2::QUEUE_IMMEDIATE);
+                     }) {
+  std::ignore = ownZeContext;
+}
 
 ur_context_handle_t_::~ur_context_handle_t_() noexcept(false) {
   // ur_context_handle_t_ is only created/destroyed through urContextCreate
@@ -24,6 +37,10 @@ ur_context_handle_t_::~ur_context_handle_t_() noexcept(false) {
   ZE2UR_CALL_THROWS(zeContextDestroy, (hContext));
 }
 
+ze_context_handle_t ur_context_handle_t_::getZeHandle() const {
+  return hContext;
+}
+
 ur_result_t ur_context_handle_t_::retain() {
   RefCount.increment();
   return UR_RESULT_SUCCESS;
@@ -37,7 +54,25 @@ ur_result_t ur_context_handle_t_::release() {
   return UR_RESULT_SUCCESS;
 }
 
-ur_result_t UR_APICALL
+ur_platform_handle_t ur_context_handle_t_::getPlatform() const {
+  return hDevices[0]->Platform;
+}
+
+const std::vector<ur_device_handle_t> &
+ur_context_handle_t_::getDevices() const {
+  return hDevices;
+}
+
+bool ur_context_handle_t_::isValidDevice(ur_device_handle_t hDevice) const {
+  while (hDevice) {
+    if (std::find(hDevices.begin(), hDevices.end(), hDevice) != hDevices.end())
+      return true;
+    hDevice = hDevice->RootDevice;
+  }
+  return false;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL
 urContextCreate(uint32_t deviceCount, const ur_device_handle_t *phDevices,
                 const ur_context_properties_t *pProperties,
                 ur_context_handle_t *phContext) {
@@ -54,10 +89,35 @@ urContextCreate(uint32_t deviceCount, const ur_device_handle_t *phDevices,
   return UR_RESULT_SUCCESS;
 }
 
-ur_result_t UR_APICALL urContextRetain(ur_context_handle_t hContext) {
+UR_APIEXPORT ur_result_t UR_APICALL
+urContextRetain(ur_context_handle_t hContext) {
   return hContext->retain();
 }
 
-ur_result_t UR_APICALL urContextRelease(ur_context_handle_t hContext) {
+UR_APIEXPORT ur_result_t UR_APICALL
+urContextRelease(ur_context_handle_t hContext) {
   return hContext->release();
 }
+
+UR_APIEXPORT ur_result_t UR_APICALL
+urContextGetInfo(ur_context_handle_t hContext,
+                 ur_context_info_t contextInfoType, size_t propSize,
+
+                 void *pContextInfo,
+
+                 size_t *pPropSizeRet) {
+  std::shared_lock<ur_shared_mutex> Lock(hContext->Mutex);
+  UrReturnHelper ReturnValue(propSize, pContextInfo, pPropSizeRet);
+  switch (
+      (uint32_t)contextInfoType) { // cast to avoid warnings on EXT enum values
+  case UR_CONTEXT_INFO_DEVICES:
+    return ReturnValue(hContext->getDevices().data(),
+                       hContext->getDevices().size());
+  case UR_CONTEXT_INFO_NUM_DEVICES:
+    return ReturnValue(uint32_t(hContext->getDevices().size()));
+  case UR_CONTEXT_INFO_REFERENCE_COUNT:
+    return ReturnValue(uint32_t{hContext->RefCount.load()});
+  default:
+    return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  }
+}
diff --git a/source/adapters/level_zero/v2/context.hpp b/source/adapters/level_zero/v2/context.hpp
index 5a4e98d81b..69bf406594 100644
--- a/source/adapters/level_zero/v2/context.hpp
+++ b/source/adapters/level_zero/v2/context.hpp
@@ -13,6 +13,7 @@
 #include <ur_api.h>
 
 #include "command_list_cache.hpp"
+#include "event_pool_cache.hpp"
 
 struct ur_context_handle_t_ : _ur_object {
   ur_context_handle_t_(ze_context_handle_t hContext, uint32_t numDevices,
@@ -22,7 +23,16 @@ struct ur_context_handle_t_ : _ur_object {
   ur_result_t retain();
   ur_result_t release();
 
+  ze_context_handle_t getZeHandle() const;
+  ur_platform_handle_t getPlatform() const;
+  const std::vector<ur_device_handle_t> &getDevices() const;
+
+  // Checks if Device is covered by this context.
+  // For that the Device or its root devices need to be in the context.
+  bool isValidDevice(ur_device_handle_t Device) const;
+
   const ze_context_handle_t hContext;
   const std::vector<ur_device_handle_t> hDevices;
   v2::command_list_cache_t commandListCache;
+  v2::event_pool_cache eventPoolCache;
 };
diff --git a/source/adapters/level_zero/v2/event.cpp b/source/adapters/level_zero/v2/event.cpp
index 496308b08f..3129e3dd3e 100644
--- a/source/adapters/level_zero/v2/event.cpp
+++ b/source/adapters/level_zero/v2/event.cpp
@@ -41,7 +41,6 @@ ur_result_t ur_event_handle_t_::release() {
     return UR_RESULT_SUCCESS;
 
   pool->free(this);
-  RefCount.increment();
 
   return UR_RESULT_SUCCESS;
 }
diff --git a/source/adapters/level_zero/v2/event.hpp b/source/adapters/level_zero/v2/event.hpp
index e044f88379..a8c886523d 100644
--- a/source/adapters/level_zero/v2/event.hpp
+++ b/source/adapters/level_zero/v2/event.hpp
@@ -22,9 +22,6 @@ namespace v2 {
 class event_pool;
 }
 
-struct ur_event_handle_t_;
-using ur_event_handle_t = ur_event_handle_t_ *;
-
 struct ur_event_handle_t_ : _ur_object {
 public:
   ur_event_handle_t_(v2::event_allocation eventAllocation,
diff --git a/source/adapters/level_zero/v2/event_pool.cpp b/source/adapters/level_zero/v2/event_pool.cpp
index ae63601a27..d02aa1cfde 100644
--- a/source/adapters/level_zero/v2/event_pool.cpp
+++ b/source/adapters/level_zero/v2/event_pool.cpp
@@ -8,6 +8,7 @@
 //
 //===----------------------------------------------------------------------===//
 #include "event_pool.hpp"
+#include "common/latency_tracker.hpp"
 #include "ur_api.h"
 
 namespace v2 {
@@ -15,6 +16,10 @@ namespace v2 {
 static constexpr size_t EVENTS_BURST = 64;
 
 ur_event_handle_t_ *event_pool::allocate() {
+  TRACK_SCOPE_LATENCY("event_pool::allocate");
+
+  std::unique_lock<std::mutex> lock(*mutex);
+
   if (freelist.empty()) {
     auto start = events.size();
     auto end = start + EVENTS_BURST;
@@ -31,8 +36,16 @@ ur_event_handle_t_ *event_pool::allocate() {
 }
 
 void event_pool::free(ur_event_handle_t_ *event) {
+  TRACK_SCOPE_LATENCY("event_pool::free");
+
+  std::unique_lock<std::mutex> lock(*mutex);
+
   event->reset();
   freelist.push_back(event);
+
+  // The event is still in the pool, so we need to increment the refcount
+  assert(event->RefCount.load() == 0);
+  event->RefCount.increment();
 }
 
 event_provider *event_pool::getProvider() { return provider.get(); }
diff --git a/source/adapters/level_zero/v2/event_pool.hpp b/source/adapters/level_zero/v2/event_pool.hpp
index 4262d9ecf8..023ad2612b 100644
--- a/source/adapters/level_zero/v2/event_pool.hpp
+++ b/source/adapters/level_zero/v2/event_pool.hpp
@@ -28,8 +28,9 @@ namespace v2 {
 
 class event_pool {
 public:
+  // store weak reference to the queue as event_pool is part of the queue
   event_pool(std::unique_ptr<event_provider> Provider)
-      : provider(std::move(Provider)){};
+      : provider(std::move(Provider)), mutex(std::make_unique<std::mutex>()){};
 
   event_pool(event_pool &&other) = default;
   event_pool &operator=(event_pool &&other) = default;
@@ -39,7 +40,10 @@ class event_pool {
 
   DeviceId Id() { return provider->device()->Id.value(); };
 
+  // Allocate an event from the pool. Thread safe.
   ur_event_handle_t_ *allocate();
+
+  // Free an event back to the pool. Thread safe.
   void free(ur_event_handle_t_ *event);
 
   event_provider *getProvider();
@@ -49,6 +53,8 @@ class event_pool {
 
   std::deque<ur_event_handle_t_> events;
   std::vector<ur_event_handle_t_ *> freelist;
+
+  std::unique_ptr<std::mutex> mutex;
 };
 
 } // namespace v2
diff --git a/source/adapters/level_zero/v2/event_provider_normal.cpp b/source/adapters/level_zero/v2/event_provider_normal.cpp
index 1cbb80d5f4..f5a1c940c6 100644
--- a/source/adapters/level_zero/v2/event_provider_normal.cpp
+++ b/source/adapters/level_zero/v2/event_provider_normal.cpp
@@ -29,7 +29,7 @@ provider_pool::provider_pool(ur_context_handle_t context,
                              queue_type queue) {
   ZeStruct<ze_event_pool_desc_t> desc;
   desc.count = EVENTS_BURST;
-  desc.flags = 0;
+  desc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;
 
   ze_event_pool_counter_based_exp_desc_t counterBasedExt = {
       ZE_STRUCTURE_TYPE_COUNTER_BASED_EVENT_POOL_EXP_DESC, nullptr};
@@ -79,7 +79,6 @@ event_allocation provider_normal::allocate() {
   TRACK_SCOPE_LATENCY("provider_normal::allocate");
 
   if (pools.empty()) {
-    TRACK_SCOPE_LATENCY("provider_normal::allocate#createProviderPool");
     pools.emplace_back(createProviderPool());
   }
 
@@ -91,7 +90,6 @@ event_allocation provider_normal::allocate() {
     }
   }
 
-  TRACK_SCOPE_LATENCY("provider_normal::allocate#slowPath");
   std::sort(pools.begin(), pools.end(), [](auto &a, auto &b) {
     return a->nfree() < b->nfree(); // asceding
   });
diff --git a/source/adapters/level_zero/v2/kernel.cpp b/source/adapters/level_zero/v2/kernel.cpp
new file mode 100644
index 0000000000..58e1a10ef1
--- /dev/null
+++ b/source/adapters/level_zero/v2/kernel.cpp
@@ -0,0 +1,246 @@
+//===--------- kernel.cpp - Level Zero Adapter ---------------------------===//
+//
+// Copyright (C) 2024 Intel Corporation
+//
+// Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
+// Exceptions. See LICENSE.TXT
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <ur_api.h>
+
+#include "context.hpp"
+#include "kernel.hpp"
+
+#include "../device.hpp"
+#include "../platform.hpp"
+#include "../program.hpp"
+
+ur_single_device_kernel_t::ur_single_device_kernel_t(ze_device_handle_t hDevice,
+                                                     ze_kernel_handle_t hKernel,
+                                                     bool ownZeHandle)
+    : hDevice(hDevice), hKernel(hKernel, ownZeHandle) {
+  zeKernelProperties.Compute =
+      [hKernel = hKernel](ze_kernel_properties_t &properties) {
+        ZE_CALL_NOCHECK(zeKernelGetProperties, (hKernel, &properties));
+      };
+}
+
+ur_result_t ur_single_device_kernel_t::release() {
+  hKernel.reset();
+  return UR_RESULT_SUCCESS;
+}
+
+ur_kernel_handle_t_::ur_kernel_handle_t_(ur_program_shared_handle_t hProgram,
+                                         const char *kernelName)
+    : hProgram(hProgram),
+      deviceKernels(hProgram->Context->getPlatform()->getNumDevices()) {
+  for (auto [zeDevice, zeModule] : hProgram->ZeModuleMap) {
+    ZeStruct<ze_kernel_desc_t> zeKernelDesc;
+    zeKernelDesc.pKernelName = kernelName;
+
+    ze_kernel_handle_t zeKernel;
+    ZE2UR_CALL_THROWS(zeKernelCreate, (zeModule, &zeKernelDesc, &zeKernel));
+
+    auto urDevice = std::find_if(hProgram->Context->getDevices().begin(),
+                                 hProgram->Context->getDevices().end(),
+                                 [zeDevice = zeDevice](const auto &urDevice) {
+                                   return urDevice->ZeDevice == zeDevice;
+                                 });
+    assert(urDevice != hProgram->Context->getDevices().end());
+    auto deviceId = (*urDevice)->Id.value();
+
+    deviceKernels[deviceId].emplace(zeDevice, zeKernel, true);
+  }
+  completeInitialization();
+}
+
+ur_kernel_handle_t_::ur_kernel_handle_t_(
+    ur_native_handle_t hNativeKernel, ur_program_handle_t hProgram,
+    const ur_kernel_native_properties_t *pProperties)
+    : hProgram(hProgram), deviceKernels(1) {
+  ze_kernel_handle_t zeKernel = ur_cast<ze_kernel_handle_t>(hNativeKernel);
+
+  if (!zeKernel) {
+    throw UR_RESULT_ERROR_INVALID_KERNEL;
+  }
+
+  deviceKernels.back().emplace(nullptr, zeKernel,
+                               pProperties->isNativeHandleOwned);
+  completeInitialization();
+}
+
+ur_result_t ur_kernel_handle_t_::release() {
+  // manually release kernels to allow errors to be propagated
+  for (auto &singleDeviceKernelOpt : deviceKernels) {
+    if (singleDeviceKernelOpt.has_value()) {
+      singleDeviceKernelOpt.value().hKernel.reset();
+    }
+  }
+  hProgram.reset();
+
+  return UR_RESULT_SUCCESS;
+}
+
+void ur_kernel_handle_t_::completeInitialization() {
+  // Cache kernel name. Should be the same for all devices
+  assert(deviceKernels.size() > 0);
+  auto nonEmptyKernel =
+      std::find_if(deviceKernels.begin(), deviceKernels.end(),
+                   [](const auto &kernel) { return kernel.has_value(); });
+
+  zeKernelName.Compute = [kernel =
+                              &nonEmptyKernel->value()](std::string &name) {
+    size_t size = 0;
+    ZE_CALL_NOCHECK(zeKernelGetName, (kernel->hKernel.get(), &size, nullptr));
+    name.resize(size);
+    ZE_CALL_NOCHECK(zeKernelGetName,
+                    (kernel->hKernel.get(), &size, name.data()));
+  };
+}
+
+ze_kernel_handle_t
+ur_kernel_handle_t_::getZeHandle(ur_device_handle_t hDevice) {
+  // root-device's kernel can be submitted to a sub-device's queue
+  if (hDevice->isSubDevice()) {
+    hDevice = hDevice->RootDevice;
+  }
+
+  if (deviceKernels.size() == 1) {
+    assert(deviceKernels[0].has_value());
+    assert(deviceKernels[0].value().hKernel.get());
+
+    auto &kernel = deviceKernels[0].value();
+
+    // hDevice is nullptr for native handle
+    if ((kernel.hDevice != nullptr && kernel.hDevice != hDevice->ZeDevice)) {
+      throw UR_RESULT_ERROR_INVALID_DEVICE;
+    }
+
+    return kernel.hKernel.get();
+  }
+
+  if (!deviceKernels[hDevice->Id.value()].has_value()) {
+    throw UR_RESULT_ERROR_INVALID_DEVICE;
+  }
+
+  assert(deviceKernels[hDevice->Id.value()].value().hKernel.get());
+
+  return deviceKernels[hDevice->Id.value()].value().hKernel.get();
+}
+
+const std::string &ur_kernel_handle_t_::getName() const {
+  return *zeKernelName.operator->();
+}
+
+const ze_kernel_properties_t &
+ur_kernel_handle_t_::getProperties(ur_device_handle_t hDevice) const {
+  if (!deviceKernels[hDevice->Id.value()].has_value()) {
+    throw UR_RESULT_ERROR_INVALID_DEVICE;
+  }
+
+  assert(deviceKernels[hDevice->Id.value()].value().hKernel.get());
+
+  return *deviceKernels[hDevice->Id.value()]
+              .value()
+              .zeKernelProperties.
+              operator->();
+}
+
+ur_result_t ur_kernel_handle_t_::setArgValue(
+    uint32_t argIndex, size_t argSize,
+    const ur_kernel_arg_value_properties_t *pProperties,
+    const void *pArgValue) {
+  std::ignore = pProperties;
+
+  // OpenCL: "the arg_value pointer can be NULL or point to a NULL value
+  // in which case a NULL value will be used as the value for the argument
+  // declared as a pointer to global or constant memory in the kernel"
+  //
+  // We don't know the type of the argument but it seems that the only time
+  // SYCL RT would send a pointer to NULL in 'arg_value' is when the argument
+  // is a NULL pointer. Treat a pointer to NULL in 'arg_value' as a NULL.
+  if (argSize == sizeof(void *) && pArgValue &&
+      *(void **)(const_cast<void *>(pArgValue)) == nullptr) {
+    pArgValue = nullptr;
+  }
+
+  std::scoped_lock<ur_shared_mutex> guard(Mutex);
+
+  for (auto &singleDeviceKernel : deviceKernels) {
+    if (!singleDeviceKernel.has_value()) {
+      continue;
+    }
+
+    ZE2UR_CALL(zeKernelSetArgumentValue,
+               (singleDeviceKernel.value().hKernel.get(), argIndex, argSize,
+                pArgValue));
+  }
+  return UR_RESULT_SUCCESS;
+}
+
+ur_result_t ur_kernel_handle_t_::setArgPointer(
+    uint32_t argIndex, const ur_kernel_arg_pointer_properties_t *pProperties,
+    const void *pArgValue) {
+  std::ignore = pProperties;
+
+  // KernelSetArgValue is expecting a pointer to the argument
+  return setArgValue(argIndex, sizeof(const void *), nullptr, &pArgValue);
+}
+
+ur_program_handle_t ur_kernel_handle_t_::getProgramHandle() const {
+  return hProgram.get();
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL
+urKernelCreate(ur_program_handle_t hProgram, const char *pKernelName,
+               ur_kernel_handle_t *phKernel) {
+  *phKernel = new ur_kernel_handle_t_(
+      ur_kernel_handle_t_::ur_program_shared_handle_t(hProgram), pKernelName);
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urKernelRetain(
+    ur_kernel_handle_t hKernel ///< [in] handle for the Kernel to retain
+) {
+  hKernel->RefCount.increment();
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urKernelRelease(
+    ur_kernel_handle_t hKernel ///< [in] handle for the Kernel to release
+) {
+  if (!hKernel->RefCount.decrementAndTest())
+    return UR_RESULT_SUCCESS;
+
+  hKernel->release();
+  delete hKernel;
+
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urKernelSetArgValue(
+    ur_kernel_handle_t hKernel, ///< [in] handle of the kernel object
+    uint32_t argIndex, ///< [in] argument index in range [0, num args - 1]
+    size_t argSize,    ///< [in] size of argument type
+    const ur_kernel_arg_value_properties_t
+        *pProperties, ///< [in][optional] argument properties
+    const void
+        *pArgValue ///< [in] argument value represented as matching arg type.
+) {
+  TRACK_SCOPE_LATENCY("ur_kernel_handle_t_::setArgValue");
+  return hKernel->setArgValue(argIndex, argSize, pProperties, pArgValue);
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urKernelSetArgPointer(
+    ur_kernel_handle_t hKernel, ///< [in] handle of the kernel object
+    uint32_t argIndex, ///< [in] argument index in range [0, num args - 1]
+    const ur_kernel_arg_pointer_properties_t
+        *pProperties, ///< [in][optional] argument properties
+    const void
+        *pArgValue ///< [in] argument value represented as matching arg type.
+) {
+  TRACK_SCOPE_LATENCY("ur_kernel_handle_t_::setArgPointer");
+  return hKernel->setArgPointer(argIndex, pProperties, pArgValue);
+}
diff --git a/source/adapters/level_zero/v2/kernel.hpp b/source/adapters/level_zero/v2/kernel.hpp
new file mode 100644
index 0000000000..b6309ab20f
--- /dev/null
+++ b/source/adapters/level_zero/v2/kernel.hpp
@@ -0,0 +1,87 @@
+//===--------- kernel.hpp - Level Zero Adapter ---------------------------===//
+//
+// Copyright (C) 2024 Intel Corporation
+//
+// Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
+// Exceptions. See LICENSE.TXT
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "../program.hpp"
+
+#include "common.hpp"
+
+struct ur_single_device_kernel_t {
+  ur_single_device_kernel_t(ze_device_handle_t hDevice,
+                            ze_kernel_handle_t hKernel, bool ownZeHandle);
+  ur_result_t release();
+
+  ze_device_handle_t hDevice;
+  v2::raii::ze_kernel_handle_t hKernel;
+  mutable ZeCache<ZeStruct<ze_kernel_properties_t>> zeKernelProperties;
+};
+
+struct ur_kernel_handle_t_ : _ur_object {
+private:
+  static inline ur_result_t
+  internalProgramRelease(ur_program_handle_t hProgram) {
+    // do a release on the program this kernel was part of without delete of the
+    // program handle.
+    hProgram->ur_release_program_resources(false);
+    return UR_RESULT_SUCCESS;
+  }
+
+public:
+  using ur_program_shared_handle_t =
+      v2::raii::ur_shared_handle<ur_program_handle_t, urProgramRetain,
+                                 internalProgramRelease>;
+
+  ur_kernel_handle_t_(ur_program_shared_handle_t hProgram,
+                      const char *kernelName);
+
+  // From native handle
+  ur_kernel_handle_t_(ur_native_handle_t hNativeKernel,
+                      ur_program_handle_t hProgram,
+                      const ur_kernel_native_properties_t *pProperties);
+
+  // Get L0 kernel handle for a given device
+  ze_kernel_handle_t getZeHandle(ur_device_handle_t hDevice);
+
+  // Get program handle of the kernel.
+  ur_program_handle_t getProgramHandle() const;
+
+  // Get name of the kernel.
+  const std::string &getName() const;
+
+  // Get properties of the kernel.
+  const ze_kernel_properties_t &getProperties(ur_device_handle_t hDevice) const;
+
+  // Implementation of urKernelSetArgValue.
+  ur_result_t setArgValue(uint32_t argIndex, size_t argSize,
+                          const ur_kernel_arg_value_properties_t *pProperties,
+                          const void *pArgValue);
+
+  // Implementation of urKernelSetArgPointer.
+  ur_result_t
+  setArgPointer(uint32_t argIndex,
+                const ur_kernel_arg_pointer_properties_t *pProperties,
+                const void *pArgValue);
+
+  // Perform cleanup.
+  ur_result_t release();
+
+private:
+  // Keep the program of the kernel.
+  ur_program_shared_handle_t hProgram;
+
+  // Vector of ur_single_device_kernel_t indexed by device->Id
+  std::vector<std::optional<ur_single_device_kernel_t>> deviceKernels;
+
+  // Cache of the kernel name.
+  mutable ZeCache<std::string> zeKernelName;
+
+  void completeInitialization();
+};
diff --git a/source/adapters/level_zero/v2/queue_immediate_in_order.cpp b/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
index 58435d14cc..d6afd2eef3 100644
--- a/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
+++ b/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
@@ -9,9 +9,38 @@
 //===----------------------------------------------------------------------===//
 
 #include "queue_immediate_in_order.hpp"
+#include "kernel.hpp"
+#include "ur.hpp"
+
+#include "../helpers/kernel_helpers.hpp"
+#include "../program.hpp"
+
+#include "../common/latency_tracker.hpp"
 
 namespace v2 {
 
+std::pair<ze_event_handle_t *, uint32_t>
+ur_queue_immediate_in_order_t::getWaitListView(
+    const ur_event_handle_t *phWaitEvents, uint32_t numWaitEvents,
+    ur_command_list_handler_t *pHandler) {
+  auto extraWaitEvent = (lastHandler && pHandler != lastHandler)
+                            ? lastHandler->lastEvent
+                            : nullptr;
+
+  auto totalEvents = numWaitEvents + (extraWaitEvent != nullptr);
+  waitList.reserve(totalEvents);
+
+  for (uint32_t i = 0; i < numWaitEvents; i++) {
+    waitList[i] = phWaitEvents[i]->getZeEvent();
+  }
+
+  if (extraWaitEvent) {
+    waitList[numWaitEvents] = extraWaitEvent;
+  }
+
+  return {waitList.data(), static_cast<uint32_t>(totalEvents)};
+}
+
 static int32_t getZeOrdinal(ur_device_handle_t hDevice, queue_group_type type) {
   if (type == queue_group_type::MainCopy && hDevice->hasMainCopyEngine()) {
     return hDevice->QueueGroup[queue_group_type::MainCopy].ZeOrdinal;
@@ -42,28 +71,90 @@ static ze_command_queue_priority_t getZePriority(ur_queue_flags_t flags) {
 
 ur_command_list_handler_t::ur_command_list_handler_t(
     ur_context_handle_t hContext, ur_device_handle_t hDevice,
-    const ur_queue_properties_t *pProps, queue_group_type type)
+    const ur_queue_properties_t *pProps, queue_group_type type,
+    event_pool *eventPool)
     : commandList(hContext->commandListCache.getImmediateCommandList(
           hDevice->ZeDevice, true, getZeOrdinal(hDevice, type),
           ZE_COMMAND_QUEUE_MODE_ASYNCHRONOUS,
           getZePriority(pProps ? pProps->flags : ur_queue_flags_t{}),
-          getZeIndex(pProps))) {}
+          getZeIndex(pProps))),
+      internalEvent(std::move(eventPool->getProvider()->allocate().borrow)) {}
 
 ur_queue_immediate_in_order_t::ur_queue_immediate_in_order_t(
     ur_context_handle_t hContext, ur_device_handle_t hDevice,
     const ur_queue_properties_t *pProps)
-    : copyHandler(hContext, hDevice, pProps, queue_group_type::MainCopy),
-      computeHandler(hContext, hDevice, pProps, queue_group_type::Compute) {}
+    : hContext(hContext), hDevice(hDevice), flags(pProps ? pProps->flags : 0),
+      eventPool(hContext->eventPoolCache.borrow(hDevice->Id.value())),
+      copyHandler(hContext, hDevice, pProps, queue_group_type::MainCopy,
+                  eventPool.get()),
+      computeHandler(hContext, hDevice, pProps, queue_group_type::Compute,
+                     eventPool.get()) {}
+
+ur_command_list_handler_t *
+ur_queue_immediate_in_order_t::getCommandListHandlerForCompute() {
+  return &computeHandler;
+}
+
+ur_command_list_handler_t *
+ur_queue_immediate_in_order_t::getCommandListHandlerForCopy() {
+  // TODO: optimize for specific devices, see ../memory.cpp
+  return &copyHandler;
+}
+
+ur_command_list_handler_t *
+ur_queue_immediate_in_order_t::getCommandListHandlerForFill(
+    size_t patternSize) {
+  if (patternSize <= hDevice->QueueGroup[queue_group_type::MainCopy]
+                         .ZeProperties.maxMemoryFillPatternSize)
+    return &copyHandler;
+  else
+    return &computeHandler;
+}
+
+ze_event_handle_t ur_queue_immediate_in_order_t::getSignalEvent(
+    ur_command_list_handler_t *handler, ur_event_handle_t *hUserEvent) {
+  if (!hUserEvent) {
+    handler->lastEvent = handler->internalEvent.get();
+  } else {
+    *hUserEvent = eventPool->allocate();
+    handler->lastEvent = (*hUserEvent)->getZeEvent();
+  }
+
+  return handler->lastEvent;
+}
 
 ur_result_t
 ur_queue_immediate_in_order_t::queueGetInfo(ur_queue_info_t propName,
                                             size_t propSize, void *pPropValue,
                                             size_t *pPropSizeRet) {
-  std::ignore = propName;
-  std::ignore = propSize;
-  std::ignore = pPropValue;
-  std::ignore = pPropSizeRet;
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  std::shared_lock<ur_shared_mutex> Lock(Mutex);
+  UrReturnHelper ReturnValue(propSize, pPropValue, pPropSizeRet);
+  // TODO: consider support for queue properties and size
+  switch ((uint32_t)propName) { // cast to avoid warnings on EXT enum values
+  case UR_QUEUE_INFO_CONTEXT:
+    return ReturnValue(hContext);
+  case UR_QUEUE_INFO_DEVICE:
+    return ReturnValue(hDevice);
+  case UR_QUEUE_INFO_REFERENCE_COUNT:
+    return ReturnValue(uint32_t{RefCount.load()});
+  case UR_QUEUE_INFO_FLAGS:
+    return ReturnValue(flags);
+  case UR_QUEUE_INFO_SIZE:
+  case UR_QUEUE_INFO_DEVICE_DEFAULT:
+    return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
+  case UR_QUEUE_INFO_EMPTY: {
+    // We can exit early if we have in-order queue.
+    if (!lastHandler)
+      return ReturnValue(true);
+  }
+  default:
+    logger::error(
+        "Unsupported ParamName in urQueueGetInfo: ParamName=ParamName={}(0x{})",
+        propName, logger::toHex(propName));
+    return UR_RESULT_ERROR_INVALID_VALUE;
+  }
+
+  return UR_RESULT_SUCCESS;
 }
 
 ur_result_t ur_queue_immediate_in_order_t::queueRetain() {
@@ -87,11 +178,27 @@ ur_result_t ur_queue_immediate_in_order_t::queueGetNativeHandle(
 }
 
 ur_result_t ur_queue_immediate_in_order_t::queueFinish() {
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  TRACK_SCOPE_LATENCY("ur_queue_immediate_in_order_t::queueFinish");
+  std::unique_lock<ur_shared_mutex> lock(this->Mutex);
+
+  if (!lastHandler) {
+    return UR_RESULT_SUCCESS;
+  }
+
+  auto lastCmdList = lastHandler->commandList.get();
+  lastHandler = nullptr;
+  lock.unlock();
+
+  // TODO: use zeEventHostSynchronize instead?
+  TRACK_SCOPE_LATENCY(
+      "ur_queue_immediate_in_order_t::zeCommandListHostSynchronize");
+  ZE2UR_CALL(zeCommandListHostSynchronize, (lastCmdList, UINT64_MAX));
+
+  return UR_RESULT_SUCCESS;
 }
 
 ur_result_t ur_queue_immediate_in_order_t::queueFlush() {
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  return UR_RESULT_SUCCESS;
 }
 
 ur_result_t ur_queue_immediate_in_order_t::enqueueKernelLaunch(
@@ -99,15 +206,46 @@ ur_result_t ur_queue_immediate_in_order_t::enqueueKernelLaunch(
     const size_t *pGlobalWorkOffset, const size_t *pGlobalWorkSize,
     const size_t *pLocalWorkSize, uint32_t numEventsInWaitList,
     const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
-  std::ignore = hKernel;
-  std::ignore = workDim;
-  std::ignore = pGlobalWorkOffset;
-  std::ignore = pGlobalWorkSize;
-  std::ignore = pLocalWorkSize;
-  std::ignore = numEventsInWaitList;
-  std::ignore = phEventWaitList;
-  std::ignore = phEvent;
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  TRACK_SCOPE_LATENCY("ur_queue_immediate_in_order_t::enqueueKernelLaunch");
+
+  UR_ASSERT(hKernel, UR_RESULT_ERROR_INVALID_NULL_HANDLE);
+  UR_ASSERT(hKernel->getProgramHandle(), UR_RESULT_ERROR_INVALID_NULL_POINTER);
+
+  UR_ASSERT(workDim > 0, UR_RESULT_ERROR_INVALID_WORK_DIMENSION);
+  UR_ASSERT(workDim < 4, UR_RESULT_ERROR_INVALID_WORK_DIMENSION);
+
+  ze_kernel_handle_t hZeKernel = hKernel->getZeHandle(hDevice);
+
+  std::scoped_lock<ur_shared_mutex, ur_shared_mutex, ur_shared_mutex> Lock(
+      hKernel->Mutex, hKernel->getProgramHandle()->Mutex, this->Mutex);
+
+  if (pGlobalWorkOffset != NULL) {
+    UR_CALL(setKernelGlobalOffset(hContext, hZeKernel, pGlobalWorkOffset));
+  }
+
+  ze_group_count_t zeThreadGroupDimensions{1, 1, 1};
+  uint32_t WG[3];
+  UR_CALL(calculateKernelWorkDimensions(hZeKernel, hDevice,
+                                        zeThreadGroupDimensions, WG, workDim,
+                                        pGlobalWorkSize, pLocalWorkSize));
+
+  ZE2UR_CALL(zeKernelSetGroupSize, (hZeKernel, WG[0], WG[1], WG[2]));
+
+  auto handler = getCommandListHandlerForCompute();
+  auto signalEvent = getSignalEvent(handler, phEvent);
+
+  auto [pWaitEvents, numWaitEvents] =
+      getWaitListView(phEventWaitList, numEventsInWaitList, handler);
+
+  TRACK_SCOPE_LATENCY(
+      "ur_queue_immediate_in_order_t::zeCommandListAppendLaunchKernel");
+  ZE2UR_CALL(zeCommandListAppendLaunchKernel,
+             (handler->commandList.get(), hZeKernel, &zeThreadGroupDimensions,
+              signalEvent, numWaitEvents, pWaitEvents));
+
+  lastHandler = handler;
+
+  return UR_RESULT_SUCCESS;
 }
 
 ur_result_t ur_queue_immediate_in_order_t::enqueueEventsWait(
@@ -337,28 +475,57 @@ ur_result_t ur_queue_immediate_in_order_t::enqueueUSMFill(
     void *pMem, size_t patternSize, const void *pPattern, size_t size,
     uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
     ur_event_handle_t *phEvent) {
-  std::ignore = pMem;
-  std::ignore = patternSize;
-  std::ignore = pPattern;
-  std::ignore = size;
-  std::ignore = numEventsInWaitList;
-  std::ignore = phEventWaitList;
-  std::ignore = phEvent;
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  TRACK_SCOPE_LATENCY("ur_queue_immediate_in_order_t::enqueueUSMFill");
+
+  std::scoped_lock<ur_shared_mutex> Lock(this->Mutex);
+
+  auto handler = getCommandListHandlerForFill(patternSize);
+  auto signalEvent = getSignalEvent(handler, phEvent);
+
+  auto [pWaitEvents, numWaitEvents] =
+      getWaitListView(phEventWaitList, numEventsInWaitList, handler);
+
+  // TODO: support non-power-of-two pattern sizes
+
+  // PatternSize must be a power of two for zeCommandListAppendMemoryFill.
+  // When it's not, the fill is emulated with zeCommandListAppendMemoryCopy.
+  ZE2UR_CALL(zeCommandListAppendMemoryFill,
+             (handler->commandList.get(), pMem, pPattern, patternSize, size,
+              signalEvent, numWaitEvents, pWaitEvents));
+
+  lastHandler = handler;
+
+  return UR_RESULT_SUCCESS;
 }
 
 ur_result_t ur_queue_immediate_in_order_t::enqueueUSMMemcpy(
     bool blocking, void *pDst, const void *pSrc, size_t size,
     uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
     ur_event_handle_t *phEvent) {
-  std::ignore = blocking;
-  std::ignore = pDst;
-  std::ignore = pSrc;
-  std::ignore = size;
-  std::ignore = numEventsInWaitList;
-  std::ignore = phEventWaitList;
-  std::ignore = phEvent;
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  // TODO: parametrize latency tracking with 'blocking'
+  TRACK_SCOPE_LATENCY("ur_queue_immediate_in_order_t::enqueueUSMMemcpy");
+
+  std::scoped_lock<ur_shared_mutex> Lock(this->Mutex);
+
+  auto handler = getCommandListHandlerForCopy();
+  auto signalEvent = getSignalEvent(handler, phEvent);
+
+  auto [pWaitEvents, numWaitEvents] =
+      getWaitListView(phEventWaitList, numEventsInWaitList, handler);
+
+  ZE2UR_CALL(zeCommandListAppendMemoryCopy,
+             (handler->commandList.get(), pDst, pSrc, size, signalEvent,
+              numWaitEvents, pWaitEvents));
+
+  if (blocking) {
+    ZE2UR_CALL(zeCommandListHostSynchronize,
+               (handler->commandList.get(), UINT64_MAX));
+    lastHandler = nullptr;
+  } else {
+    lastHandler = handler;
+  }
+
+  return UR_RESULT_SUCCESS;
 }
 
 ur_result_t ur_queue_immediate_in_order_t::enqueueUSMPrefetch(
diff --git a/source/adapters/level_zero/v2/queue_immediate_in_order.hpp b/source/adapters/level_zero/v2/queue_immediate_in_order.hpp
index 2ee0482bf7..1dc4cc9d92 100644
--- a/source/adapters/level_zero/v2/queue_immediate_in_order.hpp
+++ b/source/adapters/level_zero/v2/queue_immediate_in_order.hpp
@@ -11,7 +11,10 @@
 
 #include "../common.hpp"
 #include "../device.hpp"
+
 #include "context.hpp"
+#include "event.hpp"
+#include "event_pool_cache.hpp"
 #include "queue_api.hpp"
 
 #include "ur/ur.hpp"
@@ -24,19 +27,46 @@ struct ur_command_list_handler_t {
   ur_command_list_handler_t(ur_context_handle_t hContext,
                             ur_device_handle_t hDevice,
                             const ur_queue_properties_t *pProps,
-                            queue_group_type type);
+                            queue_group_type type, event_pool *eventPool);
 
   raii::cache_borrowed_command_list_t commandList;
+  raii::cache_borrowed_event internalEvent;
+
+  // TODO: do we need to keep ref count of this for user events?
+  // For counter based events, we can reuse them safely and l0 event pool
+  // cannot be destroyed before the queue is released.
+  ze_event_handle_t lastEvent = nullptr;
 };
 
 struct ur_queue_immediate_in_order_t : _ur_object, public ur_queue_handle_t_ {
 private:
+  ur_context_handle_t hContext;
+  ur_device_handle_t hDevice;
+  ur_queue_flags_t flags;
+
+  raii::cache_borrowed_event_pool eventPool;
+
   ur_command_list_handler_t copyHandler;
   ur_command_list_handler_t computeHandler;
+  ur_command_list_handler_t *lastHandler = nullptr;
+
+  std::vector<ze_event_handle_t> waitList;
+
+  std::pair<ze_event_handle_t *, uint32_t>
+  getWaitListView(const ur_event_handle_t *phWaitEvents, uint32_t numWaitEvents,
+                  ur_command_list_handler_t *pHandler);
+
+  ur_command_list_handler_t *getCommandListHandlerForCompute();
+  ur_command_list_handler_t *getCommandListHandlerForCopy();
+  ur_command_list_handler_t *getCommandListHandlerForFill(size_t patternSize);
+
+  ze_event_handle_t getSignalEvent(ur_command_list_handler_t *handler,
+                                   ur_event_handle_t *hUserEvent);
 
 public:
   ur_queue_immediate_in_order_t(ur_context_handle_t, ur_device_handle_t,
                                 const ur_queue_properties_t *);
+  ~ur_queue_immediate_in_order_t() {}
 
   ur_result_t queueGetInfo(ur_queue_info_t propName, size_t propSize,
                            void *pPropValue, size_t *pPropSizeRet) override;
diff --git a/source/adapters/level_zero/v2/usm.cpp b/source/adapters/level_zero/v2/usm.cpp
new file mode 100644
index 0000000000..6ac5f0f3b6
--- /dev/null
+++ b/source/adapters/level_zero/v2/usm.cpp
@@ -0,0 +1,225 @@
+//===--------- usm.cpp - Level Zero Adapter ------------------------------===//
+//
+// Copyright (C) 2024 Intel Corporation
+//
+// Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
+// Exceptions. See LICENSE.TXT
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "ur_api.h"
+
+#include "../device.hpp"
+#include "context.hpp"
+#include "usm.hpp"
+
+ur_usm_pool_handle_t_::ur_usm_pool_handle_t_(ur_context_handle_t hContext,
+                                             ur_usm_pool_desc_t *)
+    : hContext(hContext) {}
+
+ur_context_handle_t ur_usm_pool_handle_t_::getContextHandle() const {
+  return hContext;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urUSMPoolCreate(
+    ur_context_handle_t hContext, ///< [in] handle of the context object
+    ur_usm_pool_desc_t *
+        pPoolDesc, ///< [in] pointer to USM pool descriptor. Can be chained with
+                   ///< ::ur_usm_pool_limits_desc_t
+    ur_usm_pool_handle_t *hPool ///< [out] pointer to USM memory pool
+) {
+
+  *hPool = new ur_usm_pool_handle_t_(hContext, pPoolDesc);
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urUSMPoolRetain(
+    ur_usm_pool_handle_t hPool ///< [in] pointer to USM memory pool
+) {
+  hPool->RefCount.increment();
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urUSMPoolRelease(
+    ur_usm_pool_handle_t hPool ///< [in] pointer to USM memory pool
+) {
+  if (hPool->RefCount.decrementAndTest()) {
+    delete hPool;
+  }
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urUSMPoolGetInfo(
+    ur_usm_pool_handle_t hPool,  ///< [in] handle of the USM memory pool
+    ur_usm_pool_info_t propName, ///< [in] name of the pool property to query
+    size_t propSize, ///< [in] size in bytes of the pool property value provided
+    void *pPropValue, ///< [out][typename(propName, propSize)] value of the pool
+                      ///< property
+    size_t
+        *pPropSizeRet ///< [out] size in bytes returned in pool property value
+) {
+  UrReturnHelper ReturnValue(propSize, pPropValue, pPropSizeRet);
+
+  switch (propName) {
+  case UR_USM_POOL_INFO_REFERENCE_COUNT: {
+    return ReturnValue(hPool->RefCount.load());
+  }
+  case UR_USM_POOL_INFO_CONTEXT: {
+    return ReturnValue(hPool->getContextHandle());
+  }
+  default: {
+    return UR_RESULT_ERROR_UNSUPPORTED_ENUMERATION;
+  }
+  }
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urUSMDeviceAlloc(
+    ur_context_handle_t hContext, ///< [in] handle of the context object
+    ur_device_handle_t hDevice,   ///< [in] handle of the device object
+    const ur_usm_desc_t
+        *pUSMDesc, ///< [in][optional] USM memory allocation descriptor
+    ur_usm_pool_handle_t hPool, ///< [in][optional] Pointer to a pool created
+                                ///< using urUSMPoolCreate
+    size_t
+        size, ///< [in] size in bytes of the USM memory object to be allocated
+    void **ppRetMem ///< [out] pointer to USM device memory object
+) {
+  std::ignore = pUSMDesc;
+  std::ignore = hPool;
+
+  ZeStruct<ze_device_mem_alloc_desc_t> devDesc;
+  devDesc.ordinal = 0;
+  ZE2UR_CALL(zeMemAllocDevice, (hContext->getZeHandle(), &devDesc, size, 0,
+                                hDevice->ZeDevice, ppRetMem));
+
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urUSMSharedAlloc(
+    ur_context_handle_t hContext, ///< [in] handle of the context object
+    ur_device_handle_t hDevice,   ///< [in] handle of the device object
+    const ur_usm_desc_t
+        *pUSMDesc, ///< [in][optional] USM memory allocation descriptor
+    ur_usm_pool_handle_t hPool, ///< [in][optional] Pointer to a pool created
+                                ///< using urUSMPoolCreate
+    size_t
+        size, ///< [in] size in bytes of the USM memory object to be allocated
+    void **ppRetMem ///< [out] pointer to USM shared memory object
+) {
+  std::ignore = pUSMDesc;
+  std::ignore = hPool;
+
+  ZeStruct<ze_host_mem_alloc_desc_t> hostDesc;
+
+  ZeStruct<ze_device_mem_alloc_desc_t> devDesc;
+  devDesc.ordinal = 0;
+
+  ZE2UR_CALL(zeMemAllocShared, (hContext->getZeHandle(), &devDesc, &hostDesc,
+                                size, 0, hDevice->ZeDevice, ppRetMem));
+
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urUSMHostAlloc(
+    ur_context_handle_t hContext, ///< [in] handle of the context object
+    const ur_usm_desc_t
+        *pUSMDesc, ///< [in][optional] USM memory allocation descriptor
+    ur_usm_pool_handle_t hPool, ///< [in][optional] Pointer to a pool created
+                                ///< using urUSMPoolCreate
+    size_t
+        size, ///< [in] size in bytes of the USM memory object to be allocated
+    void **ppRetMem ///< [out] pointer to USM host memory object
+) {
+  std::ignore = pUSMDesc;
+  std::ignore = hPool;
+
+  ZeStruct<ze_host_mem_alloc_desc_t> hostDesc;
+
+  ZE2UR_CALL(zeMemAllocHost,
+             (hContext->getZeHandle(), &hostDesc, size, 0, ppRetMem));
+
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urUSMFree(
+    ur_context_handle_t hContext, ///< [in] handle of the context object
+    void *pMem                    ///< [in] pointer to USM memory object
+) {
+  std::ignore = hContext;
+
+  ZE2UR_CALL(zeMemFree, (hContext->getZeHandle(), pMem));
+  return UR_RESULT_SUCCESS;
+}
+
+UR_APIEXPORT ur_result_t UR_APICALL urUSMGetMemAllocInfo(
+    ur_context_handle_t hContext, ///< [in] handle of the context object
+    const void *ptr,              ///< [in] pointer to USM memory object
+    ur_usm_alloc_info_t
+        propName, ///< [in] the name of the USM allocation property to query
+    size_t propValueSize, ///< [in] size in bytes of the USM allocation property
+                          ///< value
+    void *pPropValue, ///< [out][optional] value of the USM allocation property
+    size_t *pPropValueSizeRet ///< [out][optional] bytes returned in USM
+                              ///< allocation property
+) {
+  ze_device_handle_t zeDeviceHandle;
+  ZeStruct<ze_memory_allocation_properties_t> zeMemoryAllocationProperties;
+
+  ZE2UR_CALL(zeMemGetAllocProperties,
+             (hContext->getZeHandle(), ptr, &zeMemoryAllocationProperties,
+              &zeDeviceHandle));
+
+  UrReturnHelper ReturnValue(propValueSize, pPropValue, pPropValueSizeRet);
+  switch (propName) {
+  case UR_USM_ALLOC_INFO_TYPE: {
+    ur_usm_type_t memAllocType;
+    switch (zeMemoryAllocationProperties.type) {
+    case ZE_MEMORY_TYPE_UNKNOWN:
+      memAllocType = UR_USM_TYPE_UNKNOWN;
+      break;
+    case ZE_MEMORY_TYPE_HOST:
+      memAllocType = UR_USM_TYPE_HOST;
+      break;
+    case ZE_MEMORY_TYPE_DEVICE:
+      memAllocType = UR_USM_TYPE_DEVICE;
+      break;
+    case ZE_MEMORY_TYPE_SHARED:
+      memAllocType = UR_USM_TYPE_SHARED;
+      break;
+    default:
+      logger::error("urUSMGetMemAllocInfo: unexpected usm memory type");
+      return UR_RESULT_ERROR_INVALID_VALUE;
+    }
+    return ReturnValue(memAllocType);
+  }
+  case UR_USM_ALLOC_INFO_DEVICE:
+    if (zeDeviceHandle) {
+      auto Platform = hContext->getPlatform();
+      auto Device = Platform->getDeviceFromNativeHandle(zeDeviceHandle);
+      return Device ? ReturnValue(Device) : UR_RESULT_ERROR_INVALID_VALUE;
+    } else {
+      return UR_RESULT_ERROR_INVALID_VALUE;
+    }
+  case UR_USM_ALLOC_INFO_BASE_PTR: {
+    void *base;
+    ZE2UR_CALL(zeMemGetAddressRange,
+               (hContext->getZeHandle(), ptr, &base, nullptr));
+    return ReturnValue(base);
+  }
+  case UR_USM_ALLOC_INFO_SIZE: {
+    size_t size;
+    ZE2UR_CALL(zeMemGetAddressRange,
+               (hContext->getZeHandle(), ptr, nullptr, &size));
+    return ReturnValue(size);
+  }
+  case UR_USM_ALLOC_INFO_POOL: {
+    // TODO
+    return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  default:
+    logger::error("urUSMGetMemAllocInfo: unsupported ParamName");
+    return UR_RESULT_ERROR_INVALID_VALUE;
+  }
+  }
+  return UR_RESULT_SUCCESS;
+}
diff --git a/source/adapters/level_zero/v2/usm.hpp b/source/adapters/level_zero/v2/usm.hpp
new file mode 100644
index 0000000000..95be779968
--- /dev/null
+++ b/source/adapters/level_zero/v2/usm.hpp
@@ -0,0 +1,26 @@
+//===--------- usm.cpp - Level Zero Adapter ------------------------------===//
+//
+// Copyright (C) 2024 Intel Corporation
+//
+// Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
+// Exceptions. See LICENSE.TXT
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "ur_api.h"
+
+#include "common.hpp"
+#include "ur_pool_manager.hpp"
+
+struct ur_usm_pool_handle_t_ : _ur_object {
+  ur_usm_pool_handle_t_(ur_context_handle_t hContext,
+                        ur_usm_pool_desc_t *pPoolDes);
+
+  ur_context_handle_t getContextHandle() const;
+
+private:
+  ur_context_handle_t hContext;
+};
diff --git a/test/adapters/level_zero/v2/event_pool_test.cpp b/test/adapters/level_zero/v2/event_pool_test.cpp
index 21df08c6bf..3f0f7c1273 100644
--- a/test/adapters/level_zero/v2/event_pool_test.cpp
+++ b/test/adapters/level_zero/v2/event_pool_test.cpp
@@ -143,7 +143,8 @@ TEST_P(EventPoolTest, Basic) {
 
             first = pool->allocate();
             zeFirst = first->getZeEvent();
-            pool->free(first);
+
+            urEventRelease(first);
         }
         ur_event_handle_t second;
         ze_event_handle_t zeSecond;
@@ -152,7 +153,8 @@ TEST_P(EventPoolTest, Basic) {
 
             second = pool->allocate();
             zeSecond = second->getZeEvent();
-            pool->free(second);
+
+            urEventRelease(second);
         }
         ASSERT_EQ(first, second);
         ASSERT_EQ(zeFirst, zeSecond);
@@ -171,7 +173,7 @@ TEST_P(EventPoolTest, Threaded) {
                     events.push_back(pool->allocate());
                 }
                 for (int i = 0; i < 100; ++i) {
-                    pool->free(events[i]);
+                    urEventRelease(events[i]);
                 }
             });
         }
@@ -190,7 +192,7 @@ TEST_P(EventPoolTest, ProviderNormalUseMostFreePool) {
     }
     auto frontZeHandle = events.front()->getZeEvent();
     for (int i = 0; i < 8; ++i) {
-        pool->free(events.front());
+        urEventRelease(events.front());
         events.pop_front();
     }
     for (int i = 0; i < 8; ++i) {
@@ -202,6 +204,6 @@ TEST_P(EventPoolTest, ProviderNormalUseMostFreePool) {
     ASSERT_EQ(frontZeHandle, events.back()->getZeEvent());
 
     for (auto e : events) {
-        pool->free(e);
+        urEventRelease(e);
     }
 }
diff --git a/test/conformance/CMakeLists.txt b/test/conformance/CMakeLists.txt
index fad65c381c..ff22f32c07 100644
--- a/test/conformance/CMakeLists.txt
+++ b/test/conformance/CMakeLists.txt
@@ -130,7 +130,7 @@ if(UR_DPCXX)
     file(MAKE_DIRECTORY ${UR_CONFORMANCE_DEVICE_BINARIES_DIR})
 
     if("${UR_CONFORMANCE_TARGET_TRIPLES}" STREQUAL "")
-        if(UR_BUILD_ADAPTER_L0 OR UR_BUILD_ADAPTER_OPENCL OR UR_BUILD_ADAPTER_ALL)
+        if(UR_BUILD_ADAPTER_L0 OR UR_BUILD_ADAPTER_L0_V2 OR UR_BUILD_ADAPTER_OPENCL OR UR_BUILD_ADAPTER_ALL)
             list(APPEND TARGET_TRIPLES "spir64")
         endif()
         if(UR_BUILD_ADAPTER_CUDA OR UR_BUILD_ADAPTER_ALL)
diff --git a/test/conformance/context/context_adapter_level_zero_v2.match b/test/conformance/context/context_adapter_level_zero_v2.match
index ad8527e572..fc2d1b8324 100644
--- a/test/conformance/context/context_adapter_level_zero_v2.match
+++ b/test/conformance/context/context_adapter_level_zero_v2.match
@@ -1,12 +1,5 @@
-
-urContextCreateWithNativeHandleTest.InvalidNullHandleAdapter/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urContextCreateWithNativeHandleTest.InvalidNullPointerContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urContextGetInfoTestWithInfoParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_CONTEXT_INFO_NUM_DEVICES
-urContextGetInfoTestWithInfoParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_CONTEXT_INFO_DEVICES
-urContextGetInfoTestWithInfoParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_CONTEXT_INFO_USM_MEMCPY2D_SUPPORT
-urContextGetInfoTestWithInfoParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_CONTEXT_INFO_USM_FILL2D_SUPPORT
-urContextGetInfoTestWithInfoParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_CONTEXT_INFO_REFERENCE_COUNT
-urContextGetInfoTest.InvalidSizePropSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urContextReleaseTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urContextRetainTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urContextSetExtendedDeleterTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
+urContextCreateWithNativeHandleTest.InvalidNullHandleAdapter/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urContextCreateWithNativeHandleTest.InvalidNullPointerContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urContextGetInfoTestWithInfoParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_CONTEXT_INFO_USM_MEMCPY2D_SUPPORT
+urContextGetInfoTestWithInfoParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_CONTEXT_INFO_USM_FILL2D_SUPPORT
+urContextSetExtendedDeleterTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
diff --git a/test/conformance/enqueue/enqueue_adapter_level_zero_v2.match b/test/conformance/enqueue/enqueue_adapter_level_zero_v2.match
index 9c8300a908..bf20fe2e0f 100644
--- a/test/conformance/enqueue/enqueue_adapter_level_zero_v2.match
+++ b/test/conformance/enqueue/enqueue_adapter_level_zero_v2.match
@@ -1,18 +1,4 @@
 urEnqueueDeviceGetGlobalVariableReadTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueDeviceGetGlobalVariableReadTest.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueDeviceGetGlobalVariableReadTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueDeviceGetGlobalVariableReadTest.InvalidNullPointerName/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueDeviceGetGlobalVariableReadTest.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueDeviceGetGlobalVariableReadTest.InvalidEventWaitListNullEvents/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueDeviceGetGlobalVariableReadTest.InvalidEventWaitListZeroSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueDeviceGetGlobalVariableReadTest.InvalidEventWaitInvalidEvent/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueDeviceGetGlobalVariableWriteTest.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueDeviceGetGlobalVariableWriteTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueDeviceGetGlobalVariableWriteTest.InvalidNullPointerName/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueDeviceGetGlobalVariableWriteTest.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueDeviceGetGlobalVariableWriteTest.InvalidEventWaitListNullEvents/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueDeviceGetGlobalVariableWriteTest.InvalidEventWaitListZeroSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueDeviceGetGlobalVariableWriteTest.InvalidEventWaitInvalidEvent/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueEventsWaitTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueEventsWaitTest.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueEventsWaitTest.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
@@ -20,15 +6,11 @@ urEnqueueEventsWaitWithBarrierTest.Success/Intel_R__oneAPI_Unified_Runtime_over_
 urEnqueueEventsWaitWithBarrierTest.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueEventsWaitWithBarrierTest.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueKernelLaunchTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueKernelLaunchTest.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueKernelLaunchTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueKernelLaunchTest.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueKernelLaunchTest.InvalidWorkDimension/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueKernelLaunchTest.InvalidWorkGroupSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueKernelLaunchTest.InvalidKernelArgs/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueKernelLaunchKernelWgSizeTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueKernelLaunchKernelWgSizeTest.SuccessWithExplicitLocalSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueKernelLaunchKernelWgSizeTest.NonMatchingLocalSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
+{{OPT}}urEnqueueKernelLaunchKernelWgSizeTest.SuccessWithExplicitLocalSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueKernelLaunchKernelSubGroupTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueKernelLaunchKernelStandardTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1D_1
@@ -716,11 +698,6 @@ urEnqueueUSMFillTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level
 urEnqueueUSMFillTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__8
 urEnqueueUSMFillTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__16
 urEnqueueUSMFillTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__32
-urEnqueueUSMFillNegativeTest.InvalidNullQueueHandle/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMFillNegativeTest.InvalidNullPtr/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMFillNegativeTest.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMFillNegativeTest.OutOfBounds/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMFillNegativeTest.invalidPatternSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueUSMFillNegativeTest.InvalidEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueUSMFill2DTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__patternSize__1
 urEnqueueUSMFill2DTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__patternSize__256
@@ -734,14 +711,6 @@ urEnqueueUSMFill2DTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Lev
 urEnqueueUSMFill2DTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__patternSize__1
 urEnqueueUSMFill2DTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__35__patternSize__1
 urEnqueueUSMFill2DTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__35__patternSize__128
-urEnqueueUSMFill2DNegativeTest.InvalidNullQueueHandle/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMFill2DNegativeTest.InvalidNullPtr/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMFill2DNegativeTest.InvalidPitch/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMFill2DNegativeTest.InvalidWidth/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMFill2DNegativeTest.InvalidHeight/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMFill2DNegativeTest.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMFill2DNegativeTest.OutOfBounds/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMFill2DNegativeTest.invalidPatternSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueUSMFill2DNegativeTest.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueUSMAdviseWithParamTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_USM_ADVICE_FLAG_DEFAULT
 urEnqueueUSMAdviseTest.MultipleParamsSuccess/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
@@ -755,10 +724,6 @@ urEnqueueUSMMemcpyTest.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero_
 urEnqueueUSMMemcpyTest.BlockingWithEvent/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueUSMMemcpyTest.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueUSMMemcpyTest.WaitForDependencies/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMMemcpyTest.InvalidNullQueueHandle/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMMemcpyTest.InvalidNullDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMMemcpyTest.InvalidNullSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMMemcpyTest.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
 urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_HOST
 urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_SHARED
diff --git a/test/conformance/exp_launch_properties/exp_launch_properties_adapter_level_zero_v2.match b/test/conformance/exp_launch_properties/exp_launch_properties_adapter_level_zero_v2.match
index 563948d98b..e69de29bb2 100644
--- a/test/conformance/exp_launch_properties/exp_launch_properties_adapter_level_zero_v2.match
+++ b/test/conformance/exp_launch_properties/exp_launch_properties_adapter_level_zero_v2.match
@@ -1 +0,0 @@
-urEnqueueKernelLaunchCustomTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
diff --git a/test/conformance/kernel/kernel_adapter_level_zero_v2.match b/test/conformance/kernel/kernel_adapter_level_zero_v2.match
index 52f213cea0..dca885cc4d 100644
--- a/test/conformance/kernel/kernel_adapter_level_zero_v2.match
+++ b/test/conformance/kernel/kernel_adapter_level_zero_v2.match
@@ -1,172 +1,85 @@
-urKernelCreateTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelCreateTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelCreateTest.InvalidNullPointerName/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelCreateTest.InvalidNullPointerKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelCreateTest.InvalidKernelName/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelCreateWithNativeHandleTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelCreateWithNativeHandleTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelCreateWithNativeHandleTest.InvalidNullPointerNativeKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE
-urKernelGetGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE
-urKernelGetGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE
-urKernelGetGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE
-urKernelGetGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_PREFERRED_WORK_GROUP_SIZE_MULTIPLE
-urKernelGetGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE
-urKernelGetGroupInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE
-urKernelGetGroupInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE
-urKernelGetGroupInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE
-urKernelGetGroupInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE
-urKernelGetGroupInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_PREFERRED_WORK_GROUP_SIZE_MULTIPLE
-urKernelGetGroupInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE
-urKernelGetGroupInfoTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE
-urKernelGetGroupInfoTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE
-urKernelGetGroupInfoTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE
-urKernelGetGroupInfoTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE
-urKernelGetGroupInfoTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_PREFERRED_WORK_GROUP_SIZE_MULTIPLE
-urKernelGetGroupInfoTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE
-urKernelGetGroupInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE
-urKernelGetGroupInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE
-urKernelGetGroupInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE
-urKernelGetGroupInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE
-urKernelGetGroupInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_PREFERRED_WORK_GROUP_SIZE_MULTIPLE
-urKernelGetGroupInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE
-urKernelGetGroupInfoSingleTest.CompileWorkGroupSizeEmpty/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetGroupInfoWgSizeTest.CompileWorkGroupSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_FUNCTION_NAME
-urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_ARGS
-urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_REFERENCE_COUNT
-urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_CONTEXT
-urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_PROGRAM
-urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_ATTRIBUTES
-urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_REGS
-urKernelGetInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_FUNCTION_NAME
-urKernelGetInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_ARGS
-urKernelGetInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_REFERENCE_COUNT
-urKernelGetInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_CONTEXT
-urKernelGetInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_PROGRAM
-urKernelGetInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_ATTRIBUTES
-urKernelGetInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_REGS
-urKernelGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_FUNCTION_NAME
-urKernelGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_ARGS
-urKernelGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_REFERENCE_COUNT
-urKernelGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_CONTEXT
-urKernelGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_PROGRAM
-urKernelGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_ATTRIBUTES
-urKernelGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_REGS
-urKernelGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_FUNCTION_NAME
-urKernelGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_ARGS
-urKernelGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_REFERENCE_COUNT
-urKernelGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_CONTEXT
-urKernelGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_PROGRAM
-urKernelGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_ATTRIBUTES
-urKernelGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_REGS
-urKernelGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_FUNCTION_NAME
-urKernelGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_ARGS
-urKernelGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_REFERENCE_COUNT
-urKernelGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_CONTEXT
-urKernelGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_PROGRAM
-urKernelGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_ATTRIBUTES
-urKernelGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_REGS
-urKernelGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_FUNCTION_NAME
-urKernelGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_ARGS
-urKernelGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_REFERENCE_COUNT
-urKernelGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_CONTEXT
-urKernelGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_PROGRAM
-urKernelGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_ATTRIBUTES
-urKernelGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_REGS
-urKernelGetInfoTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_FUNCTION_NAME
-urKernelGetInfoTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_ARGS
-urKernelGetInfoTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_REFERENCE_COUNT
-urKernelGetInfoTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_CONTEXT
-urKernelGetInfoTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_PROGRAM
-urKernelGetInfoTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_ATTRIBUTES
-urKernelGetInfoTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_INFO_NUM_REGS
-urKernelGetInfoSingleTest.KernelNameCorrect/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetInfoSingleTest.KernelContextCorrect/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetNativeHandleTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetNativeHandleTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetNativeHandleTest.InvalidNullPointerNativeKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetSubGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_MAX_SUB_GROUP_SIZE
-urKernelGetSubGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS
-urKernelGetSubGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS
-urKernelGetSubGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL
-urKernelGetSubGroupInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_MAX_SUB_GROUP_SIZE
-urKernelGetSubGroupInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS
-urKernelGetSubGroupInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS
-urKernelGetSubGroupInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL
-urKernelGetSubGroupInfoTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_MAX_SUB_GROUP_SIZE
-urKernelGetSubGroupInfoTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS
-urKernelGetSubGroupInfoTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS
-urKernelGetSubGroupInfoTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL
-urKernelGetSubGroupInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_MAX_SUB_GROUP_SIZE
-urKernelGetSubGroupInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS
-urKernelGetSubGroupInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS
-urKernelGetSubGroupInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL
-urKernelGetSubGroupInfoSingleTest.CompileNumSubgroupsIsZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelReleaseTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelReleaseTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelRetainTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelRetainTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgLocalTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgLocalTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgLocalTest.InvalidKernelArgumentIndex/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgMemObjTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgMemObjTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgMemObjTest.InvalidKernelArgumentIndex/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgPointerTest.SuccessHost/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgPointerTest.SuccessDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgPointerTest.SuccessShared/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgPointerNegativeTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgPointerNegativeTest.InvalidKernelArgumentIndex/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_NONE_UR_SAMPLER_FILTER_MODE_NEAREST
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_NONE_UR_SAMPLER_FILTER_MODE_LINEAR
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE_UR_SAMPLER_FILTER_MODE_NEAREST
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE_UR_SAMPLER_FILTER_MODE_LINEAR
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_UR_SAMPLER_FILTER_MODE_NEAREST
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_UR_SAMPLER_FILTER_MODE_LINEAR
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_REPEAT_UR_SAMPLER_FILTER_MODE_NEAREST
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_REPEAT_UR_SAMPLER_FILTER_MODE_LINEAR
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT_UR_SAMPLER_FILTER_MODE_NEAREST
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT_UR_SAMPLER_FILTER_MODE_LINEAR
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_NONE_UR_SAMPLER_FILTER_MODE_NEAREST
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_NONE_UR_SAMPLER_FILTER_MODE_LINEAR
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE_UR_SAMPLER_FILTER_MODE_NEAREST
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE_UR_SAMPLER_FILTER_MODE_LINEAR
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_UR_SAMPLER_FILTER_MODE_NEAREST
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_UR_SAMPLER_FILTER_MODE_LINEAR
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_REPEAT_UR_SAMPLER_FILTER_MODE_NEAREST
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_REPEAT_UR_SAMPLER_FILTER_MODE_LINEAR
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT_UR_SAMPLER_FILTER_MODE_NEAREST
-urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT_UR_SAMPLER_FILTER_MODE_LINEAR
-urKernelSetArgSamplerTest.SuccessWithProps/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgSamplerTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgSamplerTest.InvalidNullHandleArgValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgSamplerTest.InvalidKernelArgumentIndex/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgValueTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgValueTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgValueTest.InvalidNullPointerArgValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgValueTest.InvalidKernelArgumentIndex/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetArgValueTest.InvalidKernelArgumentSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetExecInfoTest.SuccessIndirectAccess/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetExecInfoTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetExecInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetExecInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetExecInfoUSMPointersTest.SuccessHost/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetExecInfoUSMPointersTest.SuccessDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetExecInfoUSMPointersTest.SuccessShared/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetExecInfoCacheConfigTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_CACHE_CONFIG_DEFAULT
-urKernelSetExecInfoCacheConfigTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_CACHE_CONFIG_LARGE_SLM
-urKernelSetExecInfoCacheConfigTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_KERNEL_CACHE_CONFIG_LARGE_DATA
-urKernelSetSpecializationConstantsTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetSpecializationConstantsTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetSpecializationConstantsTest.InvalidNullPointerSpecConstants/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelSetSpecializationConstantsTest.InvalidSizeCount/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetSuggestedLocalWorkSizeTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetSuggestedLocalWorkSizeTest.Success2D/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetSuggestedLocalWorkSizeTest.Success3D/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetSuggestedLocalWorkSizeTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetSuggestedLocalWorkSizeTest.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetSuggestedLocalWorkSizeTest.InvalidWorkDimension/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetSuggestedLocalWorkSizeTest.InvalidGlobalOffset/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetSuggestedLocalWorkSizeTest.InvalidGlobalSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urKernelGetSuggestedLocalWorkSizeTest.InvalidSuggestedLocalWorkSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
+urKernelGetGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE
+urKernelGetGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE
+urKernelGetGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE
+urKernelGetGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE
+urKernelGetGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_GROUP_INFO_PREFERRED_WORK_GROUP_SIZE_MULTIPLE
+urKernelGetGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE
+urKernelGetGroupInfoSingleTest.CompileWorkGroupSizeEmpty/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelGetGroupInfoWgSizeTest.CompileWorkGroupSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_FUNCTION_NAME
+urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_NUM_ARGS
+urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_REFERENCE_COUNT
+urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_CONTEXT
+urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_PROGRAM
+urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_ATTRIBUTES
+urKernelGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_NUM_REGS
+urKernelGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_FUNCTION_NAME
+urKernelGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_NUM_ARGS
+urKernelGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_REFERENCE_COUNT
+urKernelGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_CONTEXT
+urKernelGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_PROGRAM
+urKernelGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_ATTRIBUTES
+urKernelGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_NUM_REGS
+urKernelGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_FUNCTION_NAME
+urKernelGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_NUM_ARGS
+urKernelGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_REFERENCE_COUNT
+urKernelGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_CONTEXT
+urKernelGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_PROGRAM
+urKernelGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_ATTRIBUTES
+urKernelGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_NUM_REGS
+urKernelGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_FUNCTION_NAME
+urKernelGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_NUM_ARGS
+urKernelGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_REFERENCE_COUNT
+urKernelGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_CONTEXT
+urKernelGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_PROGRAM
+urKernelGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_ATTRIBUTES
+urKernelGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_INFO_NUM_REGS
+urKernelGetInfoSingleTest.KernelNameCorrect/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelGetInfoSingleTest.KernelContextCorrect/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelGetSubGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_SUB_GROUP_INFO_MAX_SUB_GROUP_SIZE
+urKernelGetSubGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS
+urKernelGetSubGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS
+urKernelGetSubGroupInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL
+urKernelGetSubGroupInfoSingleTest.CompileNumSubgroupsIsZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetArgLocalTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetArgLocalTest.InvalidKernelArgumentIndex/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetArgMemObjTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetArgMemObjTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetArgMemObjTest.InvalidKernelArgumentIndex/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+{{OPT}}urKernelSetArgPointerTest.SuccessHost/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+{{OPT}}urKernelSetArgPointerTest.SuccessDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+{{OPT}}urKernelSetArgPointerTest.SuccessShared/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetArgPointerNegativeTest.InvalidKernelArgumentIndex/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_NONE_UR_SAMPLER_FILTER_MODE_NEAREST
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_NONE_UR_SAMPLER_FILTER_MODE_LINEAR
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE_UR_SAMPLER_FILTER_MODE_NEAREST
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE_UR_SAMPLER_FILTER_MODE_LINEAR
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_UR_SAMPLER_FILTER_MODE_NEAREST
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_UR_SAMPLER_FILTER_MODE_LINEAR
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_REPEAT_UR_SAMPLER_FILTER_MODE_NEAREST
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_REPEAT_UR_SAMPLER_FILTER_MODE_LINEAR
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT_UR_SAMPLER_FILTER_MODE_NEAREST
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____NORMALIZED_UR_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT_UR_SAMPLER_FILTER_MODE_LINEAR
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_NONE_UR_SAMPLER_FILTER_MODE_NEAREST
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_NONE_UR_SAMPLER_FILTER_MODE_LINEAR
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE_UR_SAMPLER_FILTER_MODE_NEAREST
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_TO_EDGE_UR_SAMPLER_FILTER_MODE_LINEAR
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_UR_SAMPLER_FILTER_MODE_NEAREST
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_CLAMP_UR_SAMPLER_FILTER_MODE_LINEAR
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_REPEAT_UR_SAMPLER_FILTER_MODE_NEAREST
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_REPEAT_UR_SAMPLER_FILTER_MODE_LINEAR
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT_UR_SAMPLER_FILTER_MODE_NEAREST
+urKernelSetArgSamplerTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UNNORMALIZED_UR_SAMPLER_ADDRESSING_MODE_MIRRORED_REPEAT_UR_SAMPLER_FILTER_MODE_LINEAR
+urKernelSetArgSamplerTest.SuccessWithProps/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetArgSamplerTest.InvalidNullHandleKernel/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetArgSamplerTest.InvalidNullHandleArgValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetArgSamplerTest.InvalidKernelArgumentIndex/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetArgValueTest.InvalidKernelArgumentIndex/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetArgValueTest.InvalidKernelArgumentSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetExecInfoTest.SuccessIndirectAccess/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetExecInfoUSMPointersTest.SuccessHost/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetExecInfoUSMPointersTest.SuccessDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetExecInfoUSMPointersTest.SuccessShared/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urKernelSetExecInfoCacheConfigTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_CACHE_CONFIG_DEFAULT
+urKernelSetExecInfoCacheConfigTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_CACHE_CONFIG_LARGE_SLM
+urKernelSetExecInfoCacheConfigTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_KERNEL_CACHE_CONFIG_LARGE_DATA
diff --git a/test/conformance/program/program_adapter_level_zero_v2.match b/test/conformance/program/program_adapter_level_zero_v2.match
index 74536b2831..7c53e24502 100644
--- a/test/conformance/program/program_adapter_level_zero_v2.match
+++ b/test/conformance/program/program_adapter_level_zero_v2.match
@@ -1,143 +1,12 @@
-urProgramBuildTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramBuildTest.SuccessWithOptions/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramBuildTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramBuildTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramBuildTest.BuildFailure/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCompileTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCompileTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCompileTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCreateWithBinaryTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCreateWithBinaryTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCreateWithBinaryTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCreateWithBinaryTest.InvalidNullPointerBinary/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCreateWithBinaryTest.InvalidNullPointerProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCreateWithBinaryTest.InvalidNullPointerMetadata/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCreateWithBinaryTest.InvalidSizePropertyCount/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCreateWithBinaryTest.BuildInvalidProgramBinary/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCreateWithILTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCreateWithILTest.SuccessWithProperties/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-{{OPT}}urProgramCreateWithILTest.InvalidNullHandle/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-{{OPT}}urProgramCreateWithILTest.InvalidNullPointerSource/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-{{OPT}}urProgramCreateWithILTest.InvalidSizeLength/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-{{OPT}}urProgramCreateWithILTest.InvalidNullPointerProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCreateWithILTest.BuildInvalidProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCreateWithNativeHandleTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCreateWithNativeHandleTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramCreateWithNativeHandleTest.InvalidNullPointerProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetBuildInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_STATUS
-urProgramGetBuildInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_OPTIONS
-urProgramGetBuildInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_LOG
-urProgramGetBuildInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_BINARY_TYPE
-urProgramGetBuildInfoTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_STATUS
-urProgramGetBuildInfoTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_OPTIONS
-urProgramGetBuildInfoTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_LOG
-urProgramGetBuildInfoTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_BINARY_TYPE
-urProgramGetBuildInfoTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_STATUS
-urProgramGetBuildInfoTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_OPTIONS
-urProgramGetBuildInfoTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_LOG
-urProgramGetBuildInfoTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_BINARY_TYPE
-urProgramGetBuildInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_STATUS
-urProgramGetBuildInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_OPTIONS
-urProgramGetBuildInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_LOG
-urProgramGetBuildInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_BUILD_INFO_BINARY_TYPE
-urProgramGetBuildInfoSingleTest.LogIsNullTerminated/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetFunctionPointerTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetFunctionPointerTest.InvalidKernelName/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetFunctionPointerTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetFunctionPointerTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetFunctionPointerTest.InvalidNullPointerFunctionName/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetFunctionPointerTest.InvalidNullPointerFunctionPointer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetGlobalVariablePointerTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetGlobalVariablePointerTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetGlobalVariablePointerTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetGlobalVariablePointerTest.InvalidVariableName/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetGlobalVariablePointerTest.InvalidNullPointerVariableName/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetGlobalVariablePointerTest.InvalidNullPointerVariablePointer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_REFERENCE_COUNT
-urProgramGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_CONTEXT
-urProgramGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_NUM_DEVICES
-urProgramGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_DEVICES
-urProgramGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_SOURCE
-urProgramGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_BINARY_SIZES
-urProgramGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_BINARIES
-urProgramGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_NUM_KERNELS
-urProgramGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_KERNEL_NAMES
-urProgramGetInfoTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_REFERENCE_COUNT
-urProgramGetInfoTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_CONTEXT
-urProgramGetInfoTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_NUM_DEVICES
-urProgramGetInfoTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_DEVICES
-urProgramGetInfoTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_SOURCE
-urProgramGetInfoTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_BINARY_SIZES
-urProgramGetInfoTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_BINARIES
-urProgramGetInfoTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_NUM_KERNELS
-urProgramGetInfoTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_KERNEL_NAMES
-urProgramGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_REFERENCE_COUNT
-urProgramGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_CONTEXT
-urProgramGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_NUM_DEVICES
-urProgramGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_DEVICES
-urProgramGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_SOURCE
-urProgramGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_BINARY_SIZES
-urProgramGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_BINARIES
-urProgramGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_NUM_KERNELS
-urProgramGetInfoTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_KERNEL_NAMES
-urProgramGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_REFERENCE_COUNT
-urProgramGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_CONTEXT
-urProgramGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_NUM_DEVICES
-urProgramGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_DEVICES
-urProgramGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_SOURCE
-urProgramGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_BINARY_SIZES
-urProgramGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_BINARIES
-urProgramGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_NUM_KERNELS
-urProgramGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_KERNEL_NAMES
-urProgramGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_REFERENCE_COUNT
-urProgramGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_CONTEXT
-urProgramGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_NUM_DEVICES
-urProgramGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_DEVICES
-urProgramGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_SOURCE
-urProgramGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_BINARY_SIZES
-urProgramGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_BINARIES
-urProgramGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_NUM_KERNELS
-urProgramGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_KERNEL_NAMES
-urProgramGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_REFERENCE_COUNT
-urProgramGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_CONTEXT
-urProgramGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_NUM_DEVICES
-urProgramGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_DEVICES
-urProgramGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_SOURCE
-urProgramGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_BINARY_SIZES
-urProgramGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_BINARIES
-urProgramGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_NUM_KERNELS
-urProgramGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_KERNEL_NAMES
-urProgramGetInfoTest.InvalidNullPointerPropValueRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_REFERENCE_COUNT
-urProgramGetInfoTest.InvalidNullPointerPropValueRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_CONTEXT
-urProgramGetInfoTest.InvalidNullPointerPropValueRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_NUM_DEVICES
-urProgramGetInfoTest.InvalidNullPointerPropValueRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_DEVICES
-urProgramGetInfoTest.InvalidNullPointerPropValueRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_SOURCE
-urProgramGetInfoTest.InvalidNullPointerPropValueRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_BINARY_SIZES
-urProgramGetInfoTest.InvalidNullPointerPropValueRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_BINARIES
-urProgramGetInfoTest.InvalidNullPointerPropValueRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_NUM_KERNELS
-urProgramGetInfoTest.InvalidNullPointerPropValueRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROGRAM_INFO_KERNEL_NAMES
-urProgramGetInfoSingleTest.NumDevicesIsNonzero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetInfoSingleTest.NumDevicesMatchesDeviceArray/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetInfoSingleTest.NumDevicesMatchesContextNumDevices/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetNativeHandleTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetNativeHandleTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramGetNativeHandleTest.InvalidNullPointerNativeProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramLinkTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramLinkTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramLinkTest.InvalidNullPointerProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramLinkTest.InvalidNullPointerInputPrograms/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramLinkTest.InvalidSizeCount/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramLinkTest.SetOutputOnZeroCount/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramLinkErrorTest.LinkFailure/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramLinkErrorTest.SetOutputOnLinkError/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramReleaseTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramReleaseTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramRetainTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramRetainTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramSetSpecializationConstantsTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramSetSpecializationConstantsTest.UseDefaultValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramSetSpecializationConstantsTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramSetSpecializationConstantsTest.InvalidNullPointerSpecConstants/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramSetSpecializationConstantsTest.InvalidSizeCount/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramSetMultipleSpecializationConstantsTest.MultipleCalls/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urProgramSetMultipleSpecializationConstantsTest.SingleCall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
+urProgramCreateWithNativeHandleTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urProgramCreateWithNativeHandleTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urProgramCreateWithNativeHandleTest.InvalidNullPointerProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urProgramGetBuildInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_PROGRAM_BUILD_INFO_STATUS
+urProgramGetFunctionPointerTest.InvalidKernelName/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urProgramGetNativeHandleTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+{{OPT}}urProgramLinkErrorTest.LinkFailure/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
+{{OPT}}urProgramLinkErrorTest.SetOutputOnLinkError/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
+urProgramSetSpecializationConstantsTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urProgramSetSpecializationConstantsTest.UseDefaultValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urProgramSetMultipleSpecializationConstantsTest.MultipleCalls/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urProgramSetMultipleSpecializationConstantsTest.SingleCall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
diff --git a/test/conformance/queue/queue_adapter_level_zero_v2.match b/test/conformance/queue/queue_adapter_level_zero_v2.match
index 6370cfe9a1..524e04fa1d 100644
--- a/test/conformance/queue/queue_adapter_level_zero_v2.match
+++ b/test/conformance/queue/queue_adapter_level_zero_v2.match
@@ -1,12 +1,2 @@
-urQueueCreateTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urQueueCreateTest.CheckContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urQueueFinishTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urQueueFlushTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urQueueGetInfoTestWithInfoParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_QUEUE_INFO_CONTEXT
-urQueueGetInfoTestWithInfoParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_QUEUE_INFO_DEVICE
-urQueueGetInfoTestWithInfoParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_QUEUE_INFO_FLAGS
-urQueueGetInfoTestWithInfoParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_QUEUE_INFO_REFERENCE_COUNT
-urQueueGetInfoTestWithInfoParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_QUEUE_INFO_EMPTY
-urQueueGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urQueueRetainTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urQueueReleaseTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
+urQueueFinishTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urQueueFlushTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
diff --git a/test/conformance/usm/usm_adapter_level_zero_v2.match b/test/conformance/usm/usm_adapter_level_zero_v2.match
index b669b1a2aa..88501eea9d 100644
--- a/test/conformance/usm/usm_adapter_level_zero_v2.match
+++ b/test/conformance/usm/usm_adapter_level_zero_v2.match
@@ -1,148 +1,122 @@
-
-urUSMDeviceAllocTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMDeviceAllocTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled
-urUSMDeviceAllocTest.SuccessWithDescriptors/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMDeviceAllocTest.SuccessWithDescriptors/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled
-urUSMDeviceAllocTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMDeviceAllocTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMDeviceAllocTest.InvalidNullPtrResult/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMDeviceAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMDeviceAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled
-urUSMDeviceAllocTest.InvalidValueAlignPowerOfTwo/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_4_8
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_4_512
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_4_2048
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_8_8
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_8_512
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_8_2048
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_16_8
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_16_512
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_16_2048
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_32_8
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_32_512
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_32_2048
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_64_8
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_64_512
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_64_2048
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_4_8
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_4_512
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_4_2048
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_8_8
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_8_512
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_8_2048
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_16_8
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_16_512
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_16_2048
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_32_8
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_32_512
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_32_2048
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_64_8
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_64_512
-urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_64_2048
-urUSMFreeTest.SuccessDeviceAlloc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMFreeTest.SuccessHostAlloc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMFreeTest.SuccessSharedAlloc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMGetMemAllocInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_USM_ALLOC_INFO_TYPE
-urUSMGetMemAllocInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_USM_ALLOC_INFO_BASE_PTR
-urUSMGetMemAllocInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_USM_ALLOC_INFO_SIZE
-urUSMGetMemAllocInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_USM_ALLOC_INFO_DEVICE
-urUSMGetMemAllocInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_USM_ALLOC_INFO_POOL
-urUSMGetMemAllocInfoNegativeTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMGetMemAllocInfoNegativeTest.InvalidNullPointerMem/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMGetMemAllocInfoNegativeTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMGetMemAllocInfoNegativeTest.InvalidValuePropSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMHostAllocTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMHostAllocTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled
-urUSMHostAllocTest.SuccessWithDescriptors/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMHostAllocTest.SuccessWithDescriptors/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled
-urUSMHostAllocTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMHostAllocTest.InvalidNullPtrMem/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMHostAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMHostAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled
-urUSMHostAllocTest.InvalidValueAlignPowerOfTwo/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_4_8
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_4_512
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_4_2048
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_8_8
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_8_512
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_8_2048
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_16_8
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_16_512
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_16_2048
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_32_8
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_32_512
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_32_2048
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_64_8
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_64_512
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_64_2048
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_4_8
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_4_512
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_4_2048
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_8_8
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_8_512
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_8_2048
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_16_8
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_16_512
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_16_2048
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_32_8
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_32_512
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_32_2048
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_64_8
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_64_512
-urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_64_2048
-urUSMPoolCreateTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMPoolCreateTest.SuccessWithFlag/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMPoolGetInfoTestWithInfoParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_USM_POOL_INFO_CONTEXT
-urUSMPoolGetInfoTestWithInfoParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_USM_POOL_INFO_REFERENCE_COUNT
-urUSMPoolGetInfoTest.InvalidNullHandlePool/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMPoolGetInfoTest.InvalidEnumerationProperty/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMPoolGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMPoolGetInfoTest.InvalidSizeTooSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMPoolGetInfoTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMPoolGetInfoTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMPoolDestroyTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMPoolDestroyTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMPoolRetainTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMPoolRetainTest.InvalidNullHandlePool/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urUSMSharedAllocTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMSharedAllocTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled
-urUSMSharedAllocTest.SuccessWithDescriptors/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMSharedAllocTest.SuccessWithDescriptors/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled
-urUSMSharedAllocTest.SuccessWithMultipleAdvices/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMSharedAllocTest.SuccessWithMultipleAdvices/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled
-urUSMSharedAllocTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMSharedAllocTest.InvalidNullHandleDevice/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMSharedAllocTest.InvalidNullPtrMem/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMSharedAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMSharedAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled
-urUSMSharedAllocTest.InvalidValueAlignPowerOfTwo/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_4_8
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_4_512
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_4_2048
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_8_8
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_8_512
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_8_2048
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_16_8
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_16_512
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_16_2048
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_32_8
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_32_512
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_32_2048
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_64_8
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_64_512
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled_64_2048
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_4_8
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_4_512
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_4_2048
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_8_8
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_8_512
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_8_2048
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_16_8
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_16_512
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_16_2048
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_32_8
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_32_512
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_32_2048
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_64_8
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_64_512
-urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled_64_2048
+urUSMDeviceAllocTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled
+urUSMDeviceAllocTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled
+urUSMDeviceAllocTest.SuccessWithDescriptors/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled
+urUSMDeviceAllocTest.SuccessWithDescriptors/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled
+urUSMDeviceAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled
+urUSMDeviceAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_4_8
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_4_512
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_4_2048
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_8_8
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_8_512
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_8_2048
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_16_8
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_16_512
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_16_2048
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_32_8
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_32_512
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_32_2048
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_64_8
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_64_512
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_64_2048
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_4_8
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_4_512
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_4_2048
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_8_8
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_8_512
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_8_2048
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_16_8
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_16_512
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_16_2048
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_32_8
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_32_512
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_32_2048
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_64_8
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_64_512
+urUSMDeviceAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_64_2048
+urUSMFreeTest.SuccessDeviceAlloc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urUSMFreeTest.SuccessHostAlloc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urUSMFreeTest.SuccessSharedAlloc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urUSMGetMemAllocInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_USM_ALLOC_INFO_TYPE
+urUSMGetMemAllocInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_USM_ALLOC_INFO_BASE_PTR
+urUSMGetMemAllocInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_USM_ALLOC_INFO_SIZE
+urUSMGetMemAllocInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_USM_ALLOC_INFO_DEVICE
+urUSMGetMemAllocInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UR_USM_ALLOC_INFO_POOL
+urUSMGetMemAllocInfoNegativeTest.InvalidNullHandleContext/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urUSMGetMemAllocInfoNegativeTest.InvalidNullPointerMem/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urUSMGetMemAllocInfoNegativeTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urUSMGetMemAllocInfoNegativeTest.InvalidValuePropSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}__
+urUSMHostAllocTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled
+urUSMHostAllocTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled
+urUSMHostAllocTest.SuccessWithDescriptors/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled
+urUSMHostAllocTest.SuccessWithDescriptors/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled
+urUSMHostAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled
+urUSMHostAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_4_8
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_4_512
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_4_2048
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_8_8
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_8_512
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_8_2048
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_16_8
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_16_512
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_16_2048
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_32_8
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_32_512
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_32_2048
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_64_8
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_64_512
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_64_2048
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_4_8
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_4_512
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_4_2048
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_8_8
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_8_512
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_8_2048
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_16_8
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_16_512
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_16_2048
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_32_8
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_32_512
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_32_2048
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_64_8
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_64_512
+urUSMHostAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_64_2048
+urUSMSharedAllocTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled
+urUSMSharedAllocTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled
+urUSMSharedAllocTest.SuccessWithDescriptors/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled
+urUSMSharedAllocTest.SuccessWithDescriptors/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled
+urUSMSharedAllocTest.SuccessWithMultipleAdvices/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled
+urUSMSharedAllocTest.SuccessWithMultipleAdvices/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled
+urUSMSharedAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled
+urUSMSharedAllocTest.InvalidUSMSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_4_8
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_4_512
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_4_2048
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_8_8
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_8_512
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_8_2048
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_16_8
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_16_512
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_16_2048
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_32_8
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_32_512
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_32_2048
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_64_8
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_64_512
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolEnabled_64_2048
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_4_8
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_4_512
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_4_2048
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_8_8
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_8_512
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_8_2048
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_16_8
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_16_512
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_16_2048
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_32_8
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_32_512
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_32_2048
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_64_8
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_64_512
+urUSMSharedAllocAlignmentTest.SuccessAlignedAllocations/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}____UsePoolDisabled_64_2048