diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml
index f76326c1c4..6662f7833d 100644
--- a/.github/workflows/cmake.yml
+++ b/.github/workflows/cmake.yml
@@ -20,7 +20,7 @@ jobs:
         compiler: [{c: gcc, cxx: g++}]
         libbacktrace: ['-DVAL_USE_LIBBACKTRACE_BACKTRACE=OFF']
         pool_tracking: ['-DUMF_ENABLE_POOL_TRACKING=ON', '-DUMF_ENABLE_POOL_TRACKING=OFF']
-        latency_tracking: ['-DUMF_ENABLE_LATENCY_TRACKING=OFF']
+        latency_tracking: ['-DUR_ENABLE_LATENCY_HISTOGRAM=OFF']
         include:
           - os: 'ubuntu-22.04'
             build_type: Release
@@ -40,7 +40,7 @@ jobs:
           - os: 'ubuntu-22.04'
             build_type: Release
             compiler: {c: clang, cxx: clang++}
-            latency_tracking: '-DUMF_ENABLE_LATENCY_TRACKING=ON'
+            latency_tracking: '-DUR_ENABLE_LATENCY_HISTOGRAM=ON'
     runs-on: ${{ (matrix.os == 'ubuntu-22.04' && github.repository_owner == 'oneapi-src') && 'intel-ubuntu-22.04' || matrix.os }}
 
     steps:
diff --git a/source/adapters/level_zero/CMakeLists.txt b/source/adapters/level_zero/CMakeLists.txt
index 653bf4d118..cc05d36084 100644
--- a/source/adapters/level_zero/CMakeLists.txt
+++ b/source/adapters/level_zero/CMakeLists.txt
@@ -118,6 +118,7 @@ if(UR_BUILD_ADAPTER_L0)
         ${CMAKE_CURRENT_SOURCE_DIR}/queue.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/sampler.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/helpers/kernel_helpers.hpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/helpers/memory_helpers.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/ur_level_zero.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/common.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/context.cpp
@@ -136,6 +137,7 @@ if(UR_BUILD_ADAPTER_L0)
         ${CMAKE_CURRENT_SOURCE_DIR}/sampler.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/image.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/helpers/kernel_helpers.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/helpers/memory_helpers.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/../../ur/ur.cpp
     )
 
@@ -199,6 +201,7 @@ if(UR_BUILD_ADAPTER_L0_V2)
         ${CMAKE_CURRENT_SOURCE_DIR}/platform.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/program.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/helpers/kernel_helpers.hpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/helpers/memory_helpers.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/adapter.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/common.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/device.cpp
@@ -206,6 +209,7 @@ if(UR_BUILD_ADAPTER_L0_V2)
         ${CMAKE_CURRENT_SOURCE_DIR}/platform.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/program.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/helpers/kernel_helpers.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/helpers/memory_helpers.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/../../ur/ur.cpp
         # v2-only sources
         ${CMAKE_CURRENT_SOURCE_DIR}/v2/command_list_cache.hpp
@@ -217,6 +221,7 @@ if(UR_BUILD_ADAPTER_L0_V2)
         ${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/memory.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
@@ -229,6 +234,7 @@ if(UR_BUILD_ADAPTER_L0_V2)
         ${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/memory.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
diff --git a/source/adapters/level_zero/helpers/memory_helpers.cpp b/source/adapters/level_zero/helpers/memory_helpers.cpp
new file mode 100644
index 0000000000..aea32795ab
--- /dev/null
+++ b/source/adapters/level_zero/helpers/memory_helpers.cpp
@@ -0,0 +1,33 @@
+//===--------- memory_helpers.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 "memory_helpers.hpp"
+#include "../common.hpp"
+
+ze_memory_type_t getMemoryType(ze_context_handle_t hContext, void *ptr) {
+  // TODO: use UMF once
+  // https://github.com/oneapi-src/unified-memory-framework/issues/687 is
+  // implemented
+  ZeStruct<ze_memory_allocation_properties_t> zeMemoryAllocationProperties;
+  ZE2UR_CALL_THROWS(zeMemGetAllocProperties,
+                    (hContext, ptr, &zeMemoryAllocationProperties, nullptr));
+  return zeMemoryAllocationProperties.type;
+}
+
+bool maybeImportUSM(ze_driver_handle_t hTranslatedDriver,
+                    ze_context_handle_t hContext, void *ptr, size_t size) {
+  if (ZeUSMImport.Enabled && ptr != nullptr &&
+      getMemoryType(hContext, ptr) == ZE_MEMORY_TYPE_UNKNOWN) {
+    // Promote the host ptr to USM host memory
+    ZeUSMImport.doZeUSMImport(hTranslatedDriver, ptr, size);
+    return true;
+  }
+  return false;
+}
diff --git a/source/adapters/level_zero/helpers/memory_helpers.hpp b/source/adapters/level_zero/helpers/memory_helpers.hpp
new file mode 100644
index 0000000000..ad50be992c
--- /dev/null
+++ b/source/adapters/level_zero/helpers/memory_helpers.hpp
@@ -0,0 +1,23 @@
+//===--------- memory_helpers.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 <ur_api.h>
+#include <ze_api.h>
+
+// If USM Import feature is enabled and hostptr is supplied,
+// import the hostptr if not already imported into USM.
+// Data transfer rate is maximized when both source and destination
+// are USM pointers. Promotion of the host pointer to USM thus
+// optimizes data transfer performance.
+bool maybeImportUSM(ze_driver_handle_t hTranslatedDriver,
+                    ze_context_handle_t hContext, void *ptr, size_t size);
+
+ze_memory_type_t getMemoryType(ze_context_handle_t hContext, void *ptr);
diff --git a/source/adapters/level_zero/memory.cpp b/source/adapters/level_zero/memory.cpp
index 9786092073..69edf83a78 100644
--- a/source/adapters/level_zero/memory.cpp
+++ b/source/adapters/level_zero/memory.cpp
@@ -15,6 +15,7 @@
 
 #include "context.hpp"
 #include "event.hpp"
+#include "helpers/memory_helpers.hpp"
 #include "image.hpp"
 #include "logger/ur_logger.hpp"
 #include "queue.hpp"
@@ -1599,30 +1600,11 @@ ur_result_t urMemBufferCreate(
     Host = Properties->pHost;
   }
 
-  // If USM Import feature is enabled and hostptr is supplied,
-  // import the hostptr if not already imported into USM.
-  // Data transfer rate is maximized when both source and destination
-  // are USM pointers. Promotion of the host pointer to USM thus
-  // optimizes data transfer performance.
   bool HostPtrImported = false;
-  if (ZeUSMImport.Enabled && Host != nullptr &&
-      (Flags & UR_MEM_FLAG_USE_HOST_POINTER) != 0) {
-    // Query memory type of the host pointer
-    ze_device_handle_t ZeDeviceHandle;
-    ZeStruct<ze_memory_allocation_properties_t> ZeMemoryAllocationProperties;
-    ZE2UR_CALL(zeMemGetAllocProperties,
-               (Context->ZeContext, Host, &ZeMemoryAllocationProperties,
-                &ZeDeviceHandle));
-
-    // If not shared of any type, we can import the ptr
-    if (ZeMemoryAllocationProperties.type == ZE_MEMORY_TYPE_UNKNOWN) {
-      // Promote the host ptr to USM host memory
-      ze_driver_handle_t driverHandle =
-          Context->getPlatform()->ZeDriverHandleExpTranslated;
-      ZeUSMImport.doZeUSMImport(driverHandle, Host, Size);
-      HostPtrImported = true;
-    }
-  }
+  if (Flags & UR_MEM_FLAG_USE_HOST_POINTER)
+    HostPtrImported =
+        maybeImportUSM(Context->getPlatform()->ZeDriverHandleExpTranslated,
+                       Context->ZeContext, Host, Size);
 
   _ur_buffer *Buffer = nullptr;
   auto HostPtrOrNull = (Flags & UR_MEM_FLAG_USE_HOST_POINTER)
diff --git a/source/adapters/level_zero/v2/api.cpp b/source/adapters/level_zero/v2/api.cpp
index eba7359379..cd25f838fe 100644
--- a/source/adapters/level_zero/v2/api.cpp
+++ b/source/adapters/level_zero/v2/api.cpp
@@ -49,32 +49,6 @@ ur_result_t urMemImageCreate(ur_context_handle_t hContext, ur_mem_flags_t flags,
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t urMemBufferCreate(ur_context_handle_t hContext,
-                              ur_mem_flags_t flags, size_t size,
-                              const ur_buffer_properties_t *pProperties,
-                              ur_mem_handle_t *phBuffer) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t urMemRetain(ur_mem_handle_t hMem) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t urMemRelease(ur_mem_handle_t hMem) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
-ur_result_t urMemBufferPartition(ur_mem_handle_t hBuffer, ur_mem_flags_t flags,
-                                 ur_buffer_create_type_t bufferCreateType,
-                                 const ur_buffer_region_t *pRegion,
-                                 ur_mem_handle_t *phMem) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t urMemGetNativeHandle(ur_mem_handle_t hMem,
                                  ur_device_handle_t hDevice,
                                  ur_native_handle_t *phNativeMem) {
@@ -82,13 +56,6 @@ ur_result_t urMemGetNativeHandle(ur_mem_handle_t hMem,
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t urMemBufferCreateWithNativeHandle(
-    ur_native_handle_t hNativeMem, ur_context_handle_t hContext,
-    const ur_mem_native_properties_t *pProperties, ur_mem_handle_t *phMem) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t urMemImageCreateWithNativeHandle(
     ur_native_handle_t hNativeMem, ur_context_handle_t hContext,
     const ur_image_format_t *pImageFormat, const ur_image_desc_t *pImageDesc,
@@ -217,14 +184,6 @@ ur_result_t urPhysicalMemRelease(ur_physical_mem_handle_t hPhysicalMem) {
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t
-urKernelSetArgLocal(ur_kernel_handle_t hKernel, uint32_t argIndex,
-                    size_t argSize,
-                    const ur_kernel_arg_local_properties_t *pProperties) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t urKernelGetInfo(ur_kernel_handle_t hKernel,
                             ur_kernel_info_t propName, size_t propSize,
                             void *pPropValue, size_t *pPropSizeRet) {
@@ -232,33 +191,6 @@ ur_result_t urKernelGetInfo(ur_kernel_handle_t hKernel,
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t urKernelGetGroupInfo(ur_kernel_handle_t hKernel,
-                                 ur_device_handle_t hDevice,
-                                 ur_kernel_group_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 urKernelGetSubGroupInfo(ur_kernel_handle_t hKernel,
-                                    ur_device_handle_t hDevice,
-                                    ur_kernel_sub_group_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
-urKernelSetExecInfo(ur_kernel_handle_t hKernel, ur_kernel_exec_info_t propName,
-                    size_t propSize,
-                    const ur_kernel_exec_info_properties_t *pProperties,
-                    const void *pPropValue) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t
 urKernelSetArgSampler(ur_kernel_handle_t hKernel, uint32_t argIndex,
                       const ur_kernel_arg_sampler_properties_t *pProperties,
@@ -267,14 +199,6 @@ urKernelSetArgSampler(ur_kernel_handle_t hKernel, uint32_t argIndex,
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t
-urKernelSetArgMemObj(ur_kernel_handle_t hKernel, uint32_t argIndex,
-                     const ur_kernel_arg_mem_obj_properties_t *pProperties,
-                     ur_mem_handle_t hArgValue) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t urKernelSetSpecializationConstants(
     ur_kernel_handle_t hKernel, uint32_t count,
     const ur_specialization_constant_info_t *pSpecConstants) {
@@ -308,13 +232,6 @@ ur_result_t urKernelGetSuggestedLocalWorkSize(ur_kernel_handle_t hKernel,
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t urEventGetInfo(ur_event_handle_t hEvent, ur_event_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 urEventGetProfilingInfo(ur_event_handle_t hEvent,
                                     ur_profiling_info_t propName,
                                     size_t propSize, void *pPropValue,
@@ -323,12 +240,6 @@ ur_result_t urEventGetProfilingInfo(ur_event_handle_t hEvent,
   return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ur_result_t urEventWait(uint32_t numEvents,
-                        const ur_event_handle_t *phEventWaitList) {
-  logger::error("{} function not implemented!", __FUNCTION__);
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
-}
-
 ur_result_t urEventGetNativeHandle(ur_event_handle_t hEvent,
                                    ur_native_handle_t *phNativeEvent) {
   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 fb8cefe176..dedc5aaafb 100644
--- a/source/adapters/level_zero/v2/command_list_cache.cpp
+++ b/source/adapters/level_zero/v2/command_list_cache.cpp
@@ -43,7 +43,7 @@ inline size_t command_list_descriptor_hash_t::operator()(
 command_list_cache_t::command_list_cache_t(ze_context_handle_t ZeContext)
     : ZeContext{ZeContext} {}
 
-raii::ze_command_list_t
+raii::ze_command_list_handle_t
 command_list_cache_t::createCommandList(const command_list_descriptor_t &desc) {
   if (auto ImmCmdDesc =
           std::get_if<immediate_command_list_descriptor_t>(&desc)) {
@@ -61,7 +61,7 @@ command_list_cache_t::createCommandList(const command_list_descriptor_t &desc) {
     ZE2UR_CALL_THROWS(
         zeCommandListCreateImmediate,
         (ZeContext, ImmCmdDesc->ZeDevice, &QueueDesc, &ZeCommandList));
-    return raii::ze_command_list_t(ZeCommandList, &zeCommandListDestroy);
+    return raii::ze_command_list_handle_t(ZeCommandList);
   } else {
     auto RegCmdDesc = std::get<regular_command_list_descriptor_t>(desc);
     ZeStruct<ze_command_list_desc_t> CmdListDesc;
@@ -72,7 +72,7 @@ command_list_cache_t::createCommandList(const command_list_descriptor_t &desc) {
     ze_command_list_handle_t ZeCommandList;
     ZE2UR_CALL_THROWS(zeCommandListCreate, (ZeContext, RegCmdDesc.ZeDevice,
                                             &CmdListDesc, &ZeCommandList));
-    return raii::ze_command_list_t(ZeCommandList, &zeCommandListDestroy);
+    return raii::ze_command_list_handle_t(ZeCommandList);
   }
 }
 
@@ -94,8 +94,7 @@ command_list_cache_t::getImmediateCommandList(
   auto CommandList = getCommandList(Desc).release();
   return raii::cache_borrowed_command_list_t(
       CommandList, [Cache = this, Desc](ze_command_list_handle_t CmdList) {
-        Cache->addCommandList(
-            Desc, raii::ze_command_list_t(CmdList, &zeCommandListDestroy));
+        Cache->addCommandList(Desc, raii::ze_command_list_handle_t(CmdList));
       });
 }
 
@@ -113,12 +112,11 @@ command_list_cache_t::getRegularCommandList(ze_device_handle_t ZeDevice,
 
   return raii::cache_borrowed_command_list_t(
       CommandList, [Cache = this, Desc](ze_command_list_handle_t CmdList) {
-        Cache->addCommandList(
-            Desc, raii::ze_command_list_t(CmdList, &zeCommandListDestroy));
+        Cache->addCommandList(Desc, raii::ze_command_list_handle_t(CmdList));
       });
 }
 
-raii::ze_command_list_t
+raii::ze_command_list_handle_t
 command_list_cache_t::getCommandList(const command_list_descriptor_t &desc) {
   std::unique_lock<ur_mutex> Lock(ZeCommandListCacheMutex);
   auto it = ZeCommandListCache.find(desc);
@@ -129,7 +127,8 @@ command_list_cache_t::getCommandList(const command_list_descriptor_t &desc) {
 
   assert(!it->second.empty());
 
-  raii::ze_command_list_t CommandListHandle = std::move(it->second.top());
+  raii::ze_command_list_handle_t CommandListHandle =
+      std::move(it->second.top());
   it->second.pop();
 
   if (it->second.empty())
@@ -138,8 +137,9 @@ command_list_cache_t::getCommandList(const command_list_descriptor_t &desc) {
   return CommandListHandle;
 }
 
-void command_list_cache_t::addCommandList(const command_list_descriptor_t &desc,
-                                          raii::ze_command_list_t cmdList) {
+void command_list_cache_t::addCommandList(
+    const command_list_descriptor_t &desc,
+    raii::ze_command_list_handle_t cmdList) {
   // TODO: add a limit?
   std::unique_lock<ur_mutex> Lock(ZeCommandListCacheMutex);
   auto it = ZeCommandListCache.try_emplace(desc).first;
diff --git a/source/adapters/level_zero/v2/command_list_cache.hpp b/source/adapters/level_zero/v2/command_list_cache.hpp
index bb32e0e64a..9884e16dc4 100644
--- a/source/adapters/level_zero/v2/command_list_cache.hpp
+++ b/source/adapters/level_zero/v2/command_list_cache.hpp
@@ -17,15 +17,13 @@
 #include <ur_ddi.h>
 #include <ze_api.h>
 
-#include "../common.hpp"
+#include "common.hpp"
 
 namespace v2 {
 namespace raii {
-using ze_command_list_t = std::unique_ptr<::_ze_command_list_handle_t,
-                                          decltype(&zeCommandListDestroy)>;
 using cache_borrowed_command_list_t =
     std::unique_ptr<::_ze_command_list_handle_t,
-                    std::function<void(ze_command_list_handle_t)>>;
+                    std::function<void(::ze_command_list_handle_t)>>;
 } // namespace raii
 
 struct immediate_command_list_descriptor_t {
@@ -72,15 +70,16 @@ struct command_list_cache_t {
 private:
   ze_context_handle_t ZeContext;
   std::unordered_map<command_list_descriptor_t,
-                     std::stack<raii::ze_command_list_t>,
+                     std::stack<raii::ze_command_list_handle_t>,
                      command_list_descriptor_hash_t>
       ZeCommandListCache;
   ur_mutex ZeCommandListCacheMutex;
 
-  raii::ze_command_list_t getCommandList(const command_list_descriptor_t &desc);
+  raii::ze_command_list_handle_t
+  getCommandList(const command_list_descriptor_t &desc);
   void addCommandList(const command_list_descriptor_t &desc,
-                      raii::ze_command_list_t cmdList);
-  raii::ze_command_list_t
+                      raii::ze_command_list_handle_t cmdList);
+  raii::ze_command_list_handle_t
   createCommandList(const command_list_descriptor_t &desc);
 };
 } // namespace v2
diff --git a/source/adapters/level_zero/v2/common.hpp b/source/adapters/level_zero/v2/common.hpp
index ffef317ae8..4fb851bad8 100644
--- a/source/adapters/level_zero/v2/common.hpp
+++ b/source/adapters/level_zero/v2/common.hpp
@@ -54,6 +54,8 @@ struct ze_handle_wrapper {
     try {
       reset();
     } catch (...) {
+      // TODO: add appropriate logging or pass the error
+      // to the caller (make the dtor noexcept(false) or use tls?)
     }
   }
 
@@ -94,5 +96,11 @@ using ze_event_handle_t =
 using ze_event_pool_handle_t =
     ze_handle_wrapper<::ze_event_pool_handle_t, zeEventPoolDestroy>;
 
+using ze_context_handle_t =
+    ze_handle_wrapper<::ze_context_handle_t, zeContextDestroy>;
+
+using ze_command_list_handle_t =
+    ze_handle_wrapper<::ze_command_list_handle_t, zeCommandListDestroy>;
+
 } // namespace raii
 } // namespace v2
diff --git a/source/adapters/level_zero/v2/context.cpp b/source/adapters/level_zero/v2/context.cpp
index 84e3d96b88..abb8a13538 100644
--- a/source/adapters/level_zero/v2/context.cpp
+++ b/source/adapters/level_zero/v2/context.cpp
@@ -17,8 +17,8 @@ ur_context_handle_t_::ur_context_handle_t_(ze_context_handle_t hContext,
                                            uint32_t numDevices,
                                            const ur_device_handle_t *phDevices,
                                            bool ownZeContext)
-    : hContext(hContext), hDevices(phDevices, phDevices + numDevices),
-      commandListCache(hContext),
+    : hContext(hContext, ownZeContext),
+      hDevices(phDevices, phDevices + numDevices), commandListCache(hContext),
       eventPoolCache(phDevices[0]->Platform->getNumDevices(),
                      [context = this,
                       platform = phDevices[0]->Platform](DeviceId deviceId) {
@@ -27,19 +27,7 @@ ur_context_handle_t_::ur_context_handle_t_(ze_context_handle_t hContext,
                        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
-  // and urContextRelease so it's safe to throw here
-  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();
@@ -115,6 +103,12 @@ ur_result_t urContextGetInfo(ur_context_handle_t hContext,
     return ReturnValue(uint32_t(hContext->getDevices().size()));
   case UR_CONTEXT_INFO_REFERENCE_COUNT:
     return ReturnValue(uint32_t{hContext->RefCount.load()});
+  case UR_CONTEXT_INFO_USM_MEMCPY2D_SUPPORT:
+    // TODO: this is currently not implemented
+    return ReturnValue(uint8_t{false});
+  case UR_CONTEXT_INFO_USM_FILL2D_SUPPORT:
+    // 2D USM fill is not supported.
+    return ReturnValue(uint8_t{false});
   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 69bf406594..0ed701400d 100644
--- a/source/adapters/level_zero/v2/context.hpp
+++ b/source/adapters/level_zero/v2/context.hpp
@@ -13,17 +13,17 @@
 #include <ur_api.h>
 
 #include "command_list_cache.hpp"
+#include "common.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,
                        const ur_device_handle_t *phDevices, bool ownZeContext);
-  ~ur_context_handle_t_() noexcept(false);
 
   ur_result_t retain();
   ur_result_t release();
 
-  ze_context_handle_t getZeHandle() const;
+  inline ze_context_handle_t getZeHandle() const { return hContext.get(); }
   ur_platform_handle_t getPlatform() const;
   const std::vector<ur_device_handle_t> &getDevices() const;
 
@@ -31,7 +31,7 @@ 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;
 
-  const ze_context_handle_t hContext;
+  const v2::raii::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 8654e0b25a..df99c83b53 100644
--- a/source/adapters/level_zero/v2/event.cpp
+++ b/source/adapters/level_zero/v2/event.cpp
@@ -51,4 +51,41 @@ ur_result_t urEventRetain(ur_event_handle_t hEvent) { return hEvent->retain(); }
 ur_result_t urEventRelease(ur_event_handle_t hEvent) {
   return hEvent->release();
 }
+
+ur_result_t urEventWait(uint32_t numEvents,
+                        const ur_event_handle_t *phEventWaitList) {
+  for (uint32_t i = 0; i < numEvents; ++i) {
+    ZE2UR_CALL(zeEventHostSynchronize,
+               (phEventWaitList[i]->getZeEvent(), UINT64_MAX));
+  }
+  return UR_RESULT_SUCCESS;
+}
+
+ur_result_t urEventGetInfo(ur_event_handle_t hEvent, ur_event_info_t propName,
+                           size_t propValueSize, void *pPropValue,
+                           size_t *pPropValueSizeRet) {
+  UrReturnHelper returnValue(propValueSize, pPropValue, pPropValueSizeRet);
+
+  switch (propName) {
+  case UR_EVENT_INFO_COMMAND_EXECUTION_STATUS: {
+    auto zeStatus = ZE_CALL_NOCHECK(zeEventQueryStatus, (hEvent->getZeEvent()));
+
+    if (zeStatus == ZE_RESULT_NOT_READY) {
+      return returnValue(UR_EVENT_STATUS_SUBMITTED);
+    } else {
+      return returnValue(UR_EVENT_STATUS_COMPLETE);
+    }
+  }
+  case UR_EVENT_INFO_REFERENCE_COUNT: {
+    return returnValue(hEvent->RefCount.load());
+  }
+  default:
+    logger::error(
+        "Unsupported ParamName in urEventGetInfo: ParamName=ParamName={}(0x{})",
+        propName, logger::toHex(propName));
+    return UR_RESULT_ERROR_INVALID_VALUE;
+  }
+
+  return UR_RESULT_SUCCESS;
+}
 } // namespace ur::level_zero
diff --git a/source/adapters/level_zero/v2/event_provider_counter.cpp b/source/adapters/level_zero/v2/event_provider_counter.cpp
index 5334b2f888..76caea4c58 100644
--- a/source/adapters/level_zero/v2/event_provider_counter.cpp
+++ b/source/adapters/level_zero/v2/event_provider_counter.cpp
@@ -27,9 +27,9 @@ provider_counter::provider_counter(ur_platform_handle_t platform,
   ZE2UR_CALL_THROWS(zeDriverGetExtensionFunctionAddress,
                     (platform->ZeDriver, "zexCounterBasedEventCreate",
                      (void **)&this->eventCreateFunc));
-  ZE2UR_CALL_THROWS(
-      zelLoaderTranslateHandle,
-      (ZEL_HANDLE_CONTEXT, context->hContext, (void **)&translatedContext));
+  ZE2UR_CALL_THROWS(zelLoaderTranslateHandle,
+                    (ZEL_HANDLE_CONTEXT, context->getZeHandle(),
+                     (void **)&translatedContext));
   ZE2UR_CALL_THROWS(
       zelLoaderTranslateHandle,
       (ZEL_HANDLE_DEVICE, device->ZeDevice, (void **)&translatedDevice));
@@ -39,7 +39,7 @@ event_allocation provider_counter::allocate() {
   if (freelist.empty()) {
     ZeStruct<ze_event_desc_t> desc;
     desc.index = 0;
-    desc.signal = 0;
+    desc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
     desc.wait = 0;
     ze_event_handle_t handle;
 
diff --git a/source/adapters/level_zero/v2/event_provider_normal.cpp b/source/adapters/level_zero/v2/event_provider_normal.cpp
index f5a1c940c6..114d283c94 100644
--- a/source/adapters/level_zero/v2/event_provider_normal.cpp
+++ b/source/adapters/level_zero/v2/event_provider_normal.cpp
@@ -43,7 +43,7 @@ provider_pool::provider_pool(ur_context_handle_t context,
   }
 
   ZE2UR_CALL_THROWS(zeEventPoolCreate,
-                    (context->hContext, &desc, 1,
+                    (context->getZeHandle(), &desc, 1,
                      const_cast<ze_device_handle_t *>(&device->ZeDevice),
                      pool.ptr()));
 
@@ -51,7 +51,7 @@ provider_pool::provider_pool(ur_context_handle_t context,
   for (int i = 0; i < EVENTS_BURST; ++i) {
     ZeStruct<ze_event_desc_t> desc;
     desc.index = i;
-    desc.signal = 0;
+    desc.signal = ZE_EVENT_SCOPE_FLAG_HOST;
     desc.wait = 0;
     ZE2UR_CALL_THROWS(zeEventCreate, (pool.get(), &desc, freelist[i].ptr()));
   }
diff --git a/source/adapters/level_zero/v2/kernel.cpp b/source/adapters/level_zero/v2/kernel.cpp
index e6a37af814..8bfad2d2ad 100644
--- a/source/adapters/level_zero/v2/kernel.cpp
+++ b/source/adapters/level_zero/v2/kernel.cpp
@@ -12,13 +12,14 @@
 
 #include "context.hpp"
 #include "kernel.hpp"
+#include "memory.hpp"
 
 #include "../device.hpp"
 #include "../platform.hpp"
 #include "../program.hpp"
 #include "../ur_interface_loader.hpp"
 
-ur_single_device_kernel_t::ur_single_device_kernel_t(ze_device_handle_t hDevice,
+ur_single_device_kernel_t::ur_single_device_kernel_t(ur_device_handle_t hDevice,
                                                      ze_kernel_handle_t hKernel,
                                                      bool ownZeHandle)
     : hDevice(hDevice), hKernel(hKernel, ownZeHandle) {
@@ -54,7 +55,7 @@ ur_kernel_handle_t_::ur_kernel_handle_t_(ur_program_handle_t hProgram,
     assert(urDevice != hProgram->Context->getDevices().end());
     auto deviceId = (*urDevice)->Id.value();
 
-    deviceKernels[deviceId].emplace(zeDevice, zeKernel, true);
+    deviceKernels[deviceId].emplace(*urDevice, zeKernel, true);
   }
   completeInitialization();
 }
@@ -118,7 +119,7 @@ ur_kernel_handle_t_::getZeHandle(ur_device_handle_t hDevice) {
     auto &kernel = deviceKernels[0].value();
 
     // hDevice is nullptr for native handle
-    if ((kernel.hDevice != nullptr && kernel.hDevice != hDevice->ZeDevice)) {
+    if ((kernel.hDevice != nullptr && kernel.hDevice != hDevice)) {
       throw UR_RESULT_ERROR_INVALID_DEVICE;
     }
 
@@ -197,6 +198,58 @@ ur_program_handle_t ur_kernel_handle_t_::getProgramHandle() const {
   return hProgram;
 }
 
+ur_result_t ur_kernel_handle_t_::setExecInfo(ur_kernel_exec_info_t propName,
+                                             const void *pPropValue) {
+  std::scoped_lock<ur_shared_mutex> Guard(Mutex);
+
+  for (auto &kernel : deviceKernels) {
+    if (!kernel.has_value())
+      continue;
+    if (propName == UR_KERNEL_EXEC_INFO_USM_INDIRECT_ACCESS &&
+        *(static_cast<const ur_bool_t *>(pPropValue)) == true) {
+      // The whole point for users really was to not need to know anything
+      // about the types of allocations kernel uses. So in DPC++ we always
+      // just set all 3 modes for each kernel.
+      ze_kernel_indirect_access_flags_t indirectFlags =
+          ZE_KERNEL_INDIRECT_ACCESS_FLAG_HOST |
+          ZE_KERNEL_INDIRECT_ACCESS_FLAG_DEVICE |
+          ZE_KERNEL_INDIRECT_ACCESS_FLAG_SHARED;
+      ZE2UR_CALL(zeKernelSetIndirectAccess,
+                 (kernel->hKernel.get(), indirectFlags));
+    } else if (propName == UR_KERNEL_EXEC_INFO_CACHE_CONFIG) {
+      ze_cache_config_flag_t zeCacheConfig{};
+      auto cacheConfig =
+          *(static_cast<const ur_kernel_cache_config_t *>(pPropValue));
+      if (cacheConfig == UR_KERNEL_CACHE_CONFIG_LARGE_SLM)
+        zeCacheConfig = ZE_CACHE_CONFIG_FLAG_LARGE_SLM;
+      else if (cacheConfig == UR_KERNEL_CACHE_CONFIG_LARGE_DATA)
+        zeCacheConfig = ZE_CACHE_CONFIG_FLAG_LARGE_DATA;
+      else if (cacheConfig == UR_KERNEL_CACHE_CONFIG_DEFAULT)
+        zeCacheConfig = static_cast<ze_cache_config_flag_t>(0);
+      else
+        // Unexpected cache configuration value.
+        return UR_RESULT_ERROR_INVALID_VALUE;
+      ZE2UR_CALL(zeKernelSetCacheConfig,
+                 (kernel->hKernel.get(), zeCacheConfig););
+    } else {
+      logger::error("urKernelSetExecInfo: unsupported ParamName");
+      return UR_RESULT_ERROR_INVALID_VALUE;
+    }
+  }
+
+  return UR_RESULT_SUCCESS;
+}
+
+std::vector<ur_device_handle_t> ur_kernel_handle_t_::getDevices() const {
+  std::vector<ur_device_handle_t> devices;
+  for (size_t i = 0; i < deviceKernels.size(); ++i) {
+    if (deviceKernels[i].has_value()) {
+      devices.push_back(deviceKernels[i].value().hDevice);
+    }
+  }
+  return devices;
+}
+
 namespace ur::level_zero {
 ur_result_t urKernelCreate(ur_program_handle_t hProgram,
                            const char *pKernelName,
@@ -248,4 +301,162 @@ ur_result_t urKernelSetArgPointer(
   TRACK_SCOPE_LATENCY("ur_kernel_handle_t_::setArgPointer");
   return hKernel->setArgPointer(argIndex, pProperties, pArgValue);
 }
+
+ur_result_t
+urKernelSetArgMemObj(ur_kernel_handle_t hKernel, uint32_t argIndex,
+                     const ur_kernel_arg_mem_obj_properties_t *pProperties,
+                     ur_mem_handle_t hArgValue) {
+  TRACK_SCOPE_LATENCY("ur_kernel_handle_t_::setArgMemObj");
+
+  // TODO: support properties
+  std::ignore = pProperties;
+
+  auto kernelDevices = hKernel->getDevices();
+  if (kernelDevices.size() == 1) {
+    auto zePtr = hArgValue->getPtr(kernelDevices.front());
+    return hKernel->setArgPointer(argIndex, nullptr, zePtr);
+  } else {
+    // TODO: Implement this for multi-device kernels.
+    // Do this the same way as in legacy (keep a pending Args vector and
+    // do actual allocation on kernel submission) or allocate the memory
+    // immediately (only for small allocations?)
+    return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  }
+}
+
+ur_result_t
+urKernelSetArgLocal(ur_kernel_handle_t hKernel, uint32_t argIndex,
+                    size_t argSize,
+                    const ur_kernel_arg_local_properties_t *pProperties) {
+  TRACK_SCOPE_LATENCY("ur_kernel_handle_t_::setArgLocal");
+
+  std::ignore = pProperties;
+
+  return hKernel->setArgValue(argIndex, argSize, nullptr, nullptr);
+}
+
+ur_result_t urKernelSetExecInfo(
+    ur_kernel_handle_t hKernel,     ///< [in] handle of the kernel object
+    ur_kernel_exec_info_t propName, ///< [in] name of the execution attribute
+    size_t propSize,                ///< [in] size in byte the attribute value
+    const ur_kernel_exec_info_properties_t
+        *pProperties, ///< [in][optional] pointer to execution info properties
+    const void *pPropValue ///< [in][range(0, propSize)] pointer to memory
+                           ///< location holding the property value.
+) {
+  std::ignore = propSize;
+  std::ignore = pProperties;
+
+  return hKernel->setExecInfo(propName, pPropValue);
+}
+
+ur_result_t urKernelGetGroupInfo(
+    ur_kernel_handle_t hKernel, ///< [in] handle of the Kernel object
+    ur_device_handle_t hDevice, ///< [in] handle of the Device object
+    ur_kernel_group_info_t
+        paramName, ///< [in] name of the work Group property to query
+    size_t
+        paramValueSize, ///< [in] size of the Kernel Work Group property value
+    void *pParamValue,  ///< [in,out][optional][range(0, propSize)] value of the
+                        ///< Kernel Work Group property.
+    size_t *pParamValueSizeRet ///< [out][optional] pointer to the actual size
+                               ///< in bytes of data being queried by propName.
+) {
+  UrReturnHelper returnValue(paramValueSize, pParamValue, pParamValueSizeRet);
+
+  std::shared_lock<ur_shared_mutex> Guard(hKernel->Mutex);
+  switch (paramName) {
+  case UR_KERNEL_GROUP_INFO_GLOBAL_WORK_SIZE: {
+    // TODO: To revisit after level_zero/issues/262 is resolved
+    struct {
+      size_t Arr[3];
+    } GlobalWorkSize = {{(hDevice->ZeDeviceComputeProperties->maxGroupSizeX *
+                          hDevice->ZeDeviceComputeProperties->maxGroupCountX),
+                         (hDevice->ZeDeviceComputeProperties->maxGroupSizeY *
+                          hDevice->ZeDeviceComputeProperties->maxGroupCountY),
+                         (hDevice->ZeDeviceComputeProperties->maxGroupSizeZ *
+                          hDevice->ZeDeviceComputeProperties->maxGroupCountZ)}};
+    return returnValue(GlobalWorkSize);
+  }
+  case UR_KERNEL_GROUP_INFO_WORK_GROUP_SIZE: {
+    ZeStruct<ze_kernel_max_group_size_properties_ext_t> workGroupProperties;
+    workGroupProperties.maxGroupSize = 0;
+
+    ZeStruct<ze_kernel_properties_t> kernelProperties;
+    kernelProperties.pNext = &workGroupProperties;
+
+    auto zeDevice = hKernel->getZeHandle(hDevice);
+    if (zeDevice) {
+      auto zeResult =
+          ZE_CALL_NOCHECK(zeKernelGetProperties, (zeDevice, &kernelProperties));
+      if (zeResult == ZE_RESULT_SUCCESS &&
+          workGroupProperties.maxGroupSize != 0) {
+        return returnValue(workGroupProperties.maxGroupSize);
+      }
+      return returnValue(
+          uint64_t{hDevice->ZeDeviceComputeProperties->maxTotalGroupSize});
+    }
+  }
+  case UR_KERNEL_GROUP_INFO_COMPILE_WORK_GROUP_SIZE: {
+    auto props = hKernel->getProperties(hDevice);
+    struct {
+      size_t Arr[3];
+    } WgSize = {{props.requiredGroupSizeX, props.requiredGroupSizeY,
+                 props.requiredGroupSizeZ}};
+    return returnValue(WgSize);
+  }
+  case UR_KERNEL_GROUP_INFO_LOCAL_MEM_SIZE: {
+    auto props = hKernel->getProperties(hDevice);
+    return returnValue(uint32_t{props.localMemSize});
+  }
+  case UR_KERNEL_GROUP_INFO_PREFERRED_WORK_GROUP_SIZE_MULTIPLE: {
+    return returnValue(
+        size_t{hDevice->ZeDeviceProperties->physicalEUSimdWidth});
+  }
+  case UR_KERNEL_GROUP_INFO_PRIVATE_MEM_SIZE: {
+    auto props = hKernel->getProperties(hDevice);
+    return returnValue(uint32_t{props.privateMemSize});
+  }
+  default: {
+    logger::error(
+        "Unknown ParamName in urKernelGetGroupInfo: ParamName={}(0x{})",
+        paramName, logger::toHex(paramName));
+    return UR_RESULT_ERROR_INVALID_VALUE;
+  }
+  }
+  return UR_RESULT_SUCCESS;
+}
+
+ur_result_t urKernelGetSubGroupInfo(
+    ur_kernel_handle_t hKernel, ///< [in] handle of the Kernel object
+    ur_device_handle_t hDevice, ///< [in] handle of the Device object
+    ur_kernel_sub_group_info_t
+        propName,     ///< [in] name of the SubGroup property to query
+    size_t propSize,  ///< [in] size of the Kernel SubGroup property value
+    void *pPropValue, ///< [in,out][range(0, propSize)][optional] value of the
+                      ///< Kernel SubGroup property.
+    size_t *pPropSizeRet ///< [out][optional] pointer to the actual size in
+                         ///< bytes of data being queried by propName.
+) {
+  std::ignore = hDevice;
+
+  UrReturnHelper returnValue(propSize, pPropValue, pPropSizeRet);
+
+  auto props = hKernel->getProperties(hDevice);
+
+  std::shared_lock<ur_shared_mutex> Guard(hKernel->Mutex);
+  if (propName == UR_KERNEL_SUB_GROUP_INFO_MAX_SUB_GROUP_SIZE) {
+    returnValue(uint32_t{props.maxSubgroupSize});
+  } else if (propName == UR_KERNEL_SUB_GROUP_INFO_MAX_NUM_SUB_GROUPS) {
+    returnValue(uint32_t{props.maxNumSubgroups});
+  } else if (propName == UR_KERNEL_SUB_GROUP_INFO_COMPILE_NUM_SUB_GROUPS) {
+    returnValue(uint32_t{props.requiredNumSubGroups});
+  } else if (propName == UR_KERNEL_SUB_GROUP_INFO_SUB_GROUP_SIZE_INTEL) {
+    returnValue(uint32_t{props.requiredSubgroupSize});
+  } else {
+    die("urKernelGetSubGroupInfo: parameter not implemented");
+    return {};
+  }
+  return UR_RESULT_SUCCESS;
+}
 } // namespace ur::level_zero
diff --git a/source/adapters/level_zero/v2/kernel.hpp b/source/adapters/level_zero/v2/kernel.hpp
index d4765ae9fc..2d3a891826 100644
--- a/source/adapters/level_zero/v2/kernel.hpp
+++ b/source/adapters/level_zero/v2/kernel.hpp
@@ -15,11 +15,11 @@
 #include "common.hpp"
 
 struct ur_single_device_kernel_t {
-  ur_single_device_kernel_t(ze_device_handle_t hDevice,
+  ur_single_device_kernel_t(ur_device_handle_t hDevice,
                             ze_kernel_handle_t hKernel, bool ownZeHandle);
   ur_result_t release();
 
-  ze_device_handle_t hDevice;
+  ur_device_handle_t hDevice;
   v2::raii::ze_kernel_handle_t hKernel;
   mutable ZeCache<ZeStruct<ze_kernel_properties_t>> zeKernelProperties;
 };
@@ -40,6 +40,9 @@ struct ur_kernel_handle_t_ : _ur_object {
   // Get program handle of the kernel.
   ur_program_handle_t getProgramHandle() const;
 
+  // Get devices the kernel is built for.
+  std::vector<ur_device_handle_t> getDevices() const;
+
   // Get name of the kernel.
   const std::string &getName() const;
 
@@ -57,6 +60,10 @@ struct ur_kernel_handle_t_ : _ur_object {
                 const ur_kernel_arg_pointer_properties_t *pProperties,
                 const void *pArgValue);
 
+  // Implementation of urKernelSetExecInfo.
+  ur_result_t setExecInfo(ur_kernel_exec_info_t propName,
+                          const void *pPropValue);
+
   // Perform cleanup.
   ur_result_t release();
 
diff --git a/source/adapters/level_zero/v2/memory.cpp b/source/adapters/level_zero/v2/memory.cpp
new file mode 100644
index 0000000000..fc9a7522a4
--- /dev/null
+++ b/source/adapters/level_zero/v2/memory.cpp
@@ -0,0 +1,180 @@
+//===--------- memory.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 "memory.hpp"
+#include "context.hpp"
+
+#include "../helpers/memory_helpers.hpp"
+
+ur_mem_handle_t_::ur_mem_handle_t_(ur_context_handle_t hContext, size_t size)
+    : hContext(hContext), size(size) {}
+
+ur_host_mem_handle_t::ur_host_mem_handle_t(ur_context_handle_t hContext,
+                                           void *hostPtr, size_t size,
+                                           host_ptr_action_t hostPtrAction)
+    : ur_mem_handle_t_(hContext, size) {
+  bool hostPtrImported = false;
+  if (hostPtrAction == host_ptr_action_t::import) {
+    hostPtrImported =
+        maybeImportUSM(hContext->getPlatform()->ZeDriverHandleExpTranslated,
+                       hContext->getZeHandle(), hostPtr, size);
+  }
+
+  if (!hostPtrImported) {
+    // TODO: use UMF
+    ZeStruct<ze_host_mem_alloc_desc_t> hostDesc;
+    ZE2UR_CALL_THROWS(zeMemAllocHost, (hContext->getZeHandle(), &hostDesc, size,
+                                       0, &this->ptr));
+
+    if (hostPtr) {
+      std::memcpy(this->ptr, hostPtr, size);
+    }
+  }
+}
+
+ur_host_mem_handle_t::~ur_host_mem_handle_t() {
+  // TODO: use UMF API here
+  if (ptr) {
+    ZE_CALL_NOCHECK(zeMemFree, (hContext->getZeHandle(), ptr));
+  }
+}
+
+void *ur_host_mem_handle_t::getPtr(ur_device_handle_t hDevice) {
+  std::ignore = hDevice;
+  return ptr;
+}
+
+ur_device_mem_handle_t::ur_device_mem_handle_t(ur_context_handle_t hContext,
+                                               void *hostPtr, size_t size)
+    : ur_mem_handle_t_(hContext, size),
+      deviceAllocations(hContext->getPlatform()->getNumDevices()) {
+  // Legacy adapter allocated the memory directly on a device (first on the
+  // contxt) and if the buffer is used on another device, memory is migrated
+  // (depending on an env var setting).
+  //
+  // TODO: port this behavior or figure out if it makes sense to keep the memory
+  // in a host buffer (e.g. for smaller sizes).
+  if (hostPtr) {
+    buffer.assign(reinterpret_cast<char *>(hostPtr),
+                  reinterpret_cast<char *>(hostPtr) + size);
+  }
+}
+
+ur_device_mem_handle_t::~ur_device_mem_handle_t() {
+  // TODO: use UMF API here
+  for (auto &ptr : deviceAllocations) {
+    if (ptr) {
+      ZE_CALL_NOCHECK(zeMemFree, (hContext->getZeHandle(), ptr));
+    }
+  }
+}
+
+void *ur_device_mem_handle_t::getPtr(ur_device_handle_t hDevice) {
+  std::lock_guard lock(this->Mutex);
+
+  auto &ptr = deviceAllocations[hDevice->Id.value()];
+  if (!ptr) {
+    ZeStruct<ze_device_mem_alloc_desc_t> deviceDesc;
+    ZE2UR_CALL_THROWS(zeMemAllocDevice, (hContext->getZeHandle(), &deviceDesc,
+                                         size, 0, hDevice->ZeDevice, &ptr));
+
+    if (!buffer.empty()) {
+      auto commandList = hContext->commandListCache.getImmediateCommandList(
+          hDevice->ZeDevice, true,
+          hDevice
+              ->QueueGroup
+                  [ur_device_handle_t_::queue_group_info_t::type::Compute]
+              .ZeOrdinal,
+          ZE_COMMAND_QUEUE_MODE_SYNCHRONOUS, ZE_COMMAND_QUEUE_PRIORITY_NORMAL,
+          std::nullopt);
+      ZE2UR_CALL_THROWS(
+          zeCommandListAppendMemoryCopy,
+          (commandList.get(), ptr, buffer.data(), size, nullptr, 0, nullptr));
+    }
+  }
+  return ptr;
+}
+
+namespace ur::level_zero {
+ur_result_t urMemBufferCreate(ur_context_handle_t hContext,
+                              ur_mem_flags_t flags, size_t size,
+                              const ur_buffer_properties_t *pProperties,
+                              ur_mem_handle_t *phBuffer) {
+  if (flags & UR_MEM_FLAG_ALLOC_HOST_POINTER) {
+    // TODO:
+    // Having PI_MEM_FLAGS_HOST_PTR_ALLOC for buffer requires allocation of
+    // pinned host memory, see:
+    // sycl/doc/extensions/supported/sycl_ext_oneapi_use_pinned_host_memory_property.asciidoc
+    // We are however missing such functionality in Level Zero, so we just
+    // ignore the flag for now.
+  }
+
+  void *hostPtr = pProperties ? pProperties->pHost : nullptr;
+
+  // We treat integrated devices (physical memory shared with the CPU)
+  // differently from discrete devices (those with distinct memories).
+  // For integrated devices, allocating the buffer in the host memory
+  // enables automatic access from the device, and makes copying
+  // unnecessary in the map/unmap operations. This improves performance.
+  bool useHostBuffer = hContext->getDevices().size() == 1 &&
+                       hContext->getDevices()[0]->ZeDeviceProperties->flags &
+                           ZE_DEVICE_PROPERTY_FLAG_INTEGRATED;
+
+  if (useHostBuffer) {
+    // TODO: assert that if hostPtr is set, either UR_MEM_FLAG_USE_HOST_POINTER
+    // or UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER is set?
+    auto hostPtrAction = flags & UR_MEM_FLAG_USE_HOST_POINTER
+                             ? ur_host_mem_handle_t::host_ptr_action_t::import
+                             : ur_host_mem_handle_t::host_ptr_action_t::copy;
+    *phBuffer =
+        new ur_host_mem_handle_t(hContext, hostPtr, size, hostPtrAction);
+  } else {
+    *phBuffer = new ur_device_mem_handle_t(hContext, hostPtr, size);
+  }
+
+  return UR_RESULT_SUCCESS;
+}
+
+ur_result_t urMemBufferPartition(ur_mem_handle_t hBuffer, ur_mem_flags_t flags,
+                                 ur_buffer_create_type_t bufferCreateType,
+                                 const ur_buffer_region_t *pRegion,
+                                 ur_mem_handle_t *phMem) {
+  std::ignore = hBuffer;
+  std::ignore = flags;
+  std::ignore = bufferCreateType;
+  std::ignore = pRegion;
+  std::ignore = phMem;
+  logger::error("{} function not implemented!", __FUNCTION__);
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ur_result_t urMemBufferCreateWithNativeHandle(
+    ur_native_handle_t hNativeMem, ur_context_handle_t hContext,
+    const ur_mem_native_properties_t *pProperties, ur_mem_handle_t *phMem) {
+  std::ignore = hNativeMem;
+  std::ignore = hContext;
+  std::ignore = pProperties;
+  std::ignore = phMem;
+  logger::error("{} function not implemented!", __FUNCTION__);
+  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ur_result_t urMemRetain(ur_mem_handle_t hMem) {
+  hMem->RefCount.increment();
+  return UR_RESULT_SUCCESS;
+}
+
+ur_result_t urMemRelease(ur_mem_handle_t hMem) {
+  if (hMem->RefCount.decrementAndTest()) {
+    delete hMem;
+  }
+  return UR_RESULT_SUCCESS;
+}
+} // namespace ur::level_zero
diff --git a/source/adapters/level_zero/v2/memory.hpp b/source/adapters/level_zero/v2/memory.hpp
new file mode 100644
index 0000000000..be4456d728
--- /dev/null
+++ b/source/adapters/level_zero/v2/memory.hpp
@@ -0,0 +1,55 @@
+//===--------- memory.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 <ur_api.h>
+
+#include "common.hpp"
+
+struct ur_mem_handle_t_ : _ur_object {
+  ur_mem_handle_t_(ur_context_handle_t hContext, size_t size);
+  virtual ~ur_mem_handle_t_() = default;
+
+  virtual void *getPtr(ur_device_handle_t) = 0;
+
+  inline size_t getSize() { return size; }
+
+protected:
+  const ur_context_handle_t hContext;
+  const size_t size;
+};
+
+struct ur_host_mem_handle_t : public ur_mem_handle_t_ {
+  enum class host_ptr_action_t { import, copy };
+
+  ur_host_mem_handle_t(ur_context_handle_t hContext, void *hostPtr, size_t size,
+                       host_ptr_action_t useHostPtr);
+  ~ur_host_mem_handle_t();
+
+  void *getPtr(ur_device_handle_t) override;
+
+private:
+  void *ptr;
+};
+
+struct ur_device_mem_handle_t : public ur_mem_handle_t_ {
+  ur_device_mem_handle_t(ur_context_handle_t hContext, void *hostPtr,
+                         size_t size);
+  ~ur_device_mem_handle_t();
+
+  void *getPtr(ur_device_handle_t) override;
+
+private:
+  std::vector<char> buffer;
+
+  // Vector of per-device allocations indexed by device->Id
+  std::vector<void *> deviceAllocations;
+};
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 d6afd2eef3..eeb31a2e92 100644
--- a/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
+++ b/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
@@ -10,6 +10,7 @@
 
 #include "queue_immediate_in_order.hpp"
 #include "kernel.hpp"
+#include "memory.hpp"
 #include "ur.hpp"
 
 #include "../helpers/kernel_helpers.hpp"
@@ -251,49 +252,59 @@ ur_result_t ur_queue_immediate_in_order_t::enqueueKernelLaunch(
 ur_result_t ur_queue_immediate_in_order_t::enqueueEventsWait(
     uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
     ur_event_handle_t *phEvent) {
-  std::ignore = numEventsInWaitList;
-  std::ignore = phEventWaitList;
-  std::ignore = phEvent;
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  TRACK_SCOPE_LATENCY("ur_queue_immediate_in_order_t::enqueueEventsWait");
+
+  std::unique_lock<ur_shared_mutex> lock(this->Mutex);
+
+  auto handler = getCommandListHandlerForCompute();
+  auto signalEvent = getSignalEvent(handler, phEvent);
+  auto [pWaitEvents, numWaitEvents] =
+      getWaitListView(phEventWaitList, numEventsInWaitList, handler);
+
+  ZE2UR_CALL(zeCommandListAppendWaitOnEvents,
+             (handler->commandList.get(), numWaitEvents, pWaitEvents));
+  ZE2UR_CALL(zeCommandListAppendSignalEvent,
+             (handler->commandList.get(), signalEvent));
+
+  lastHandler = handler;
+
+  return UR_RESULT_SUCCESS;
 }
 
 ur_result_t ur_queue_immediate_in_order_t::enqueueEventsWaitWithBarrier(
     uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
     ur_event_handle_t *phEvent) {
-  std::ignore = numEventsInWaitList;
-  std::ignore = phEventWaitList;
-  std::ignore = phEvent;
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  // For in-order queue we don't need a real barrier, just wait for
+  // requested events in potentially different queues and add a "barrier"
+  // event signal because it is already guaranteed that previous commands
+  // in this queue are completed when the signal is started.
+  return enqueueEventsWait(numEventsInWaitList, phEventWaitList, phEvent);
 }
 
 ur_result_t ur_queue_immediate_in_order_t::enqueueMemBufferRead(
     ur_mem_handle_t hBuffer, bool blockingRead, size_t offset, size_t size,
     void *pDst, uint32_t numEventsInWaitList,
     const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
-  std::ignore = hBuffer;
-  std::ignore = blockingRead;
-  std::ignore = offset;
-  std::ignore = size;
-  std::ignore = pDst;
-  std::ignore = numEventsInWaitList;
-  std::ignore = phEventWaitList;
-  std::ignore = phEvent;
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  TRACK_SCOPE_LATENCY("ur_queue_immediate_in_order_t::enqueueMemBufferRead");
+
+  UR_ASSERT(offset + size <= hBuffer->getSize(), UR_RESULT_ERROR_INVALID_SIZE);
+
+  auto ptr = ur_cast<char *>(hBuffer->getPtr(hDevice));
+  return enqueueUSMMemcpy(blockingRead, pDst, ptr + offset, size,
+                          numEventsInWaitList, phEventWaitList, phEvent);
 }
 
 ur_result_t ur_queue_immediate_in_order_t::enqueueMemBufferWrite(
     ur_mem_handle_t hBuffer, bool blockingWrite, size_t offset, size_t size,
     const void *pSrc, uint32_t numEventsInWaitList,
     const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
-  std::ignore = hBuffer;
-  std::ignore = blockingWrite;
-  std::ignore = offset;
-  std::ignore = size;
-  std::ignore = pSrc;
-  std::ignore = numEventsInWaitList;
-  std::ignore = phEventWaitList;
-  std::ignore = phEvent;
-  return UR_RESULT_ERROR_UNSUPPORTED_FEATURE;
+  TRACK_SCOPE_LATENCY("ur_queue_immediate_in_order_t::enqueueMemBufferWrite");
+
+  UR_ASSERT(offset + size <= hBuffer->getSize(), UR_RESULT_ERROR_INVALID_SIZE);
+
+  auto ptr = ur_cast<char *>(hBuffer->getPtr(hDevice));
+  return enqueueUSMMemcpy(blockingWrite, ptr + offset, pSrc, size,
+                          numEventsInWaitList, phEventWaitList, phEvent);
 }
 
 ur_result_t ur_queue_immediate_in_order_t::enqueueMemBufferReadRect(
@@ -344,15 +355,18 @@ ur_result_t ur_queue_immediate_in_order_t::enqueueMemBufferCopy(
     ur_mem_handle_t hBufferSrc, ur_mem_handle_t hBufferDst, size_t srcOffset,
     size_t dstOffset, size_t size, uint32_t numEventsInWaitList,
     const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
-  std::ignore = hBufferSrc;
-  std::ignore = hBufferDst;
-  std::ignore = srcOffset;
-  std::ignore = dstOffset;
-  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::enqueueMemBufferCopy");
+
+  UR_ASSERT(srcOffset + size <= hBufferSrc->getSize(),
+            UR_RESULT_ERROR_INVALID_SIZE);
+  UR_ASSERT(dstOffset + size <= hBufferDst->getSize(),
+            UR_RESULT_ERROR_INVALID_SIZE);
+
+  auto srcPtr = ur_cast<char *>(hBufferSrc->getPtr(hDevice));
+  auto dstPtr = ur_cast<char *>(hBufferDst->getPtr(hDevice));
+
+  return enqueueUSMMemcpy(false, dstPtr + dstOffset, srcPtr + srcOffset, size,
+                          numEventsInWaitList, phEventWaitList, phEvent);
 }
 
 ur_result_t ur_queue_immediate_in_order_t::enqueueMemBufferCopyRect(
@@ -380,15 +394,13 @@ ur_result_t ur_queue_immediate_in_order_t::enqueueMemBufferFill(
     ur_mem_handle_t hBuffer, const void *pPattern, size_t patternSize,
     size_t offset, size_t size, uint32_t numEventsInWaitList,
     const ur_event_handle_t *phEventWaitList, ur_event_handle_t *phEvent) {
-  std::ignore = hBuffer;
-  std::ignore = pPattern;
-  std::ignore = patternSize;
-  std::ignore = offset;
-  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::enqueueMemBufferFill");
+
+  UR_ASSERT(offset + size <= hBuffer->getSize(), UR_RESULT_ERROR_INVALID_SIZE);
+
+  auto ptr = ur_cast<char *>(hBuffer->getPtr(hDevice));
+  return enqueueUSMFill(ptr + offset, patternSize, pPattern, size,
+                        numEventsInWaitList, phEventWaitList, phEvent);
 }
 
 ur_result_t ur_queue_immediate_in_order_t::enqueueMemImageRead(
diff --git a/test/adapters/level_zero/v2/command_list_cache_test.cpp b/test/adapters/level_zero/v2/command_list_cache_test.cpp
index 74bcbf4634..44755b699e 100644
--- a/test/adapters/level_zero/v2/command_list_cache_test.cpp
+++ b/test/adapters/level_zero/v2/command_list_cache_test.cpp
@@ -23,7 +23,7 @@ struct CommandListCacheTest : public uur::urContextTest {};
 UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(CommandListCacheTest);
 
 TEST_P(CommandListCacheTest, CanStoreAndRetriveImmediateAndRegularCmdLists) {
-    v2::command_list_cache_t cache(context->hContext);
+    v2::command_list_cache_t cache(context->getZeHandle());
 
     bool IsInOrder = false;
     uint32_t Ordinal = 0;
@@ -75,7 +75,7 @@ TEST_P(CommandListCacheTest, CanStoreAndRetriveImmediateAndRegularCmdLists) {
 }
 
 TEST_P(CommandListCacheTest, ImmediateCommandListsHaveProperAttributes) {
-    v2::command_list_cache_t cache(context->hContext);
+    v2::command_list_cache_t cache(context->getZeHandle());
 
     uint32_t numQueueGroups = 0;
     ASSERT_EQ(zeDeviceGetCommandQueueGroupProperties(device->ZeDevice,
diff --git a/test/conformance/context/context_adapter_level_zero_v2.match b/test/conformance/context/context_adapter_level_zero_v2.match
index fc2d1b8324..3dea8da6e5 100644
--- a/test/conformance/context/context_adapter_level_zero_v2.match
+++ b/test/conformance/context/context_adapter_level_zero_v2.match
@@ -1,5 +1,3 @@
 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/device_code/CMakeLists.txt b/test/conformance/device_code/CMakeLists.txt
index af0bc83d8a..5445531961 100644
--- a/test/conformance/device_code/CMakeLists.txt
+++ b/test/conformance/device_code/CMakeLists.txt
@@ -144,6 +144,7 @@ add_device_binary(${CMAKE_CURRENT_SOURCE_DIR}/fill_usm.cpp)
 add_device_binary(${CMAKE_CURRENT_SOURCE_DIR}/foo.cpp)
 add_device_binary(${CMAKE_CURRENT_SOURCE_DIR}/image_copy.cpp)
 add_device_binary(${CMAKE_CURRENT_SOURCE_DIR}/inc.cpp)
+add_device_binary(${CMAKE_CURRENT_SOURCE_DIR}/increment.cpp)
 add_device_binary(${CMAKE_CURRENT_SOURCE_DIR}/mean.cpp)
 add_device_binary(${CMAKE_CURRENT_SOURCE_DIR}/cpy_and_mult.cpp)
 add_device_binary(${CMAKE_CURRENT_SOURCE_DIR}/cpy_and_mult_usm.cpp)
diff --git a/test/conformance/device_code/increment.cpp b/test/conformance/device_code/increment.cpp
new file mode 100644
index 0000000000..14094c4963
--- /dev/null
+++ b/test/conformance/device_code/increment.cpp
@@ -0,0 +1,20 @@
+// 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 <sycl/sycl.hpp>
+
+int main() {
+
+    const size_t inputSize = 1;
+    sycl::queue sycl_queue;
+    uint32_t *inputArray = sycl::malloc_shared<uint32_t>(inputSize, sycl_queue);
+
+    sycl_queue.submit([&](sycl::handler &cgh) {
+        cgh.parallel_for<class IncrementBy1>(
+            sycl::range<1>(inputSize),
+            [=](sycl::id<1> itemID) { inputArray[itemID] += 1; });
+    });
+    return 0;
+}
diff --git a/test/conformance/enqueue/CMakeLists.txt b/test/conformance/enqueue/CMakeLists.txt
index 7cc68203a0..1e19658dac 100644
--- a/test/conformance/enqueue/CMakeLists.txt
+++ b/test/conformance/enqueue/CMakeLists.txt
@@ -9,6 +9,7 @@ add_conformance_test_with_kernels_environment(enqueue
     urEnqueueEventsWait.cpp
     urEnqueueEventsWaitWithBarrier.cpp
     urEnqueueKernelLaunch.cpp
+    urEnqueueKernelLaunchAndMemcpyInOrder.cpp
     urEnqueueMemBufferCopyRect.cpp
     urEnqueueMemBufferCopy.cpp
     urEnqueueMemBufferFill.cpp
diff --git a/test/conformance/enqueue/enqueue_adapter_level_zero_v2.match b/test/conformance/enqueue/enqueue_adapter_level_zero_v2.match
index bf20fe2e0f..e48c5175b4 100644
--- a/test/conformance/enqueue/enqueue_adapter_level_zero_v2.match
+++ b/test/conformance/enqueue/enqueue_adapter_level_zero_v2.match
@@ -1,37 +1,14 @@
 urEnqueueDeviceGetGlobalVariableReadTest.Success/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___{{.*}}_
-urEnqueueEventsWaitWithBarrierTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-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.InvalidNullPtrEventWaitList/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___{{.*}}_
-{{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
-urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1D_31
-urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1D_1027
-urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1D_32
-urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1D_256
-urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2D_1_1
-urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2D_31_7
-urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2D_1027_1
-urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2D_1_32
-urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2D_256_79
-urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___3D_1_1_1
-urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___3D_31_7_1
-urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___3D_1027_1_19
-urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___3D_1_53_19
-urEnqueueKernelLaunchTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___3D_256_79_8
 urEnqueueKernelLaunchWithVirtualMemory.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueKernelLaunchMultiDeviceTest.KernelLaunchReadDifferentQueues/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueKernelLaunchUSMLinkedList.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolEnabled
 urEnqueueKernelLaunchUSMLinkedList.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UsePoolDisabled
+{{OPT}}urEnqueueKernelLaunchIncrementTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UseEventsEnabled
+{{OPT}}urEnqueueKernelLaunchIncrementTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UseEventsDisabled
+{{OPT}}urEnqueueKernelLaunchIncrementMultiDeviceMultiThreadTest.Success/UseEventsNoQueuePerThread
+{{OPT}}urEnqueueKernelLaunchIncrementMultiDeviceMultiThreadTest.Success/NoUseEventsNoQueuePerThread
 urEnqueueMemBufferCopyRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___copy_whole_buffer_2D
 urEnqueueMemBufferCopyRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___copy_non_zero_offsets_2D
 urEnqueueMemBufferCopyRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___copy_different_buffer_sizes_2D
@@ -41,61 +18,7 @@ urEnqueueMemBufferCopyRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_
 urEnqueueMemBufferCopyRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___copy_3d_with_offsets
 urEnqueueMemBufferCopyRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___copy_2d_3d
 urEnqueueMemBufferCopyRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___copy_3d_2d
-urEnqueueMemBufferCopyRectTest.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferCopyRectTest.InvalidNullHandleBufferSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferCopyRectTest.InvalidNullHandleBufferDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferCopyRectTest.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueMemBufferCopyRectTest.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferCopyTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024
-urEnqueueMemBufferCopyTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500
-urEnqueueMemBufferCopyTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096
-urEnqueueMemBufferCopyTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000
-urEnqueueMemBufferCopyTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024
-urEnqueueMemBufferCopyTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500
-urEnqueueMemBufferCopyTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096
-urEnqueueMemBufferCopyTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000
-urEnqueueMemBufferCopyTestWithParam.InvalidNullHandleBufferSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024
-urEnqueueMemBufferCopyTestWithParam.InvalidNullHandleBufferSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500
-urEnqueueMemBufferCopyTestWithParam.InvalidNullHandleBufferSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096
-urEnqueueMemBufferCopyTestWithParam.InvalidNullHandleBufferSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000
-urEnqueueMemBufferCopyTestWithParam.InvalidNullHandleBufferDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024
-urEnqueueMemBufferCopyTestWithParam.InvalidNullHandleBufferDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500
-urEnqueueMemBufferCopyTestWithParam.InvalidNullHandleBufferDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096
-urEnqueueMemBufferCopyTestWithParam.InvalidNullHandleBufferDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000
-urEnqueueMemBufferCopyTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024
-urEnqueueMemBufferCopyTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500
-urEnqueueMemBufferCopyTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096
-urEnqueueMemBufferCopyTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000
-urEnqueueMemBufferCopyTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024
-urEnqueueMemBufferCopyTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500
-urEnqueueMemBufferCopyTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096
-urEnqueueMemBufferCopyTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000
-urEnqueueMemBufferFillTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__1__patternSize__1
-urEnqueueMemBufferFillTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__256
-urEnqueueMemBufferFillTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__1024__patternSize__256
-urEnqueueMemBufferFillTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__4
-urEnqueueMemBufferFillTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__8
-urEnqueueMemBufferFillTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__16
-urEnqueueMemBufferFillTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__32
-urEnqueueMemBufferFillTest.SuccessPartialFill/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__1__patternSize__1
-urEnqueueMemBufferFillTest.SuccessPartialFill/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__256
-urEnqueueMemBufferFillTest.SuccessPartialFill/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__1024__patternSize__256
-urEnqueueMemBufferFillTest.SuccessPartialFill/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__4
-urEnqueueMemBufferFillTest.SuccessPartialFill/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__8
-urEnqueueMemBufferFillTest.SuccessPartialFill/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__16
-urEnqueueMemBufferFillTest.SuccessPartialFill/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__32
-urEnqueueMemBufferFillTest.SuccessOffset/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__1__patternSize__1
-urEnqueueMemBufferFillTest.SuccessOffset/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__256
-urEnqueueMemBufferFillTest.SuccessOffset/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__1024__patternSize__256
-urEnqueueMemBufferFillTest.SuccessOffset/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__4
-urEnqueueMemBufferFillTest.SuccessOffset/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__8
-urEnqueueMemBufferFillTest.SuccessOffset/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__16
-urEnqueueMemBufferFillTest.SuccessOffset/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__32
-urEnqueueMemBufferFillNegativeTest.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferFillNegativeTest.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferFillNegativeTest.InvalidNullHandlePointerPattern/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferFillNegativeTest.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferFillNegativeTest.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueMemBufferMapTestWithParam.SuccessRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
 urEnqueueMemBufferMapTestWithParam.SuccessRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
 urEnqueueMemBufferMapTestWithParam.SuccessRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
@@ -192,86 +115,6 @@ urEnqueueMemBufferMapTestWithParam.SuccessMultiMaps/Intel_R__oneAPI_Unified_Runt
 urEnqueueMemBufferMapTestWithParam.SuccessMultiMaps/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
 urEnqueueMemBufferMapTestWithParam.SuccessMultiMaps/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
 urEnqueueMemBufferMapTestWithParam.SuccessMultiMaps/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidEnumerationMapFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullPointerRetMap/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferMapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
 urEnqueueMemBufferMapTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
 urEnqueueMemBufferMapTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
 urEnqueueMemBufferMapTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
@@ -290,134 +133,6 @@ urEnqueueMemBufferMapTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_o
 urEnqueueMemBufferMapTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
 urEnqueueMemBufferMapTestWithWriteFlagParam.SuccessWrite/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MAP_FLAG_WRITE
 urEnqueueMemBufferMapTestWithWriteFlagParam.SuccessWrite/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MAP_FLAG_WRITE_INVALIDATE_REGION
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.Blocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferReadTestWithParam.NonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
 urEnqueueMemBufferReadRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___write_whole_buffer_2D
 urEnqueueMemBufferReadRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___write_non_zero_offsets_2D
 urEnqueueMemBufferReadRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___write_different_buffer_sizes_2D
@@ -427,123 +142,7 @@ urEnqueueMemBufferReadRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_
 urEnqueueMemBufferReadRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___write_3d_with_offsets
 urEnqueueMemBufferReadRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___write_2d_3d
 urEnqueueMemBufferReadRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___write_3d_2d
-urEnqueueMemBufferReadRectTest.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferReadRectTest.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferReadRectTest.InvalidNullPointerDst/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferReadRectTest.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueMemBufferReadRectTest.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.SuccessWriteRead/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_WRITE
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_WRITE_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_READ_ONLY
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1024_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueMemBufferWriteTestWithParam.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
 urEnqueueMemBufferWriteRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___write_whole_buffer_2D
 urEnqueueMemBufferWriteRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___write_non_zero_offsets_2D
 urEnqueueMemBufferWriteRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___write_different_buffer_sizes_2D
@@ -553,10 +152,6 @@ urEnqueueMemBufferWriteRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime
 urEnqueueMemBufferWriteRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___write_3d_with_offsets
 urEnqueueMemBufferWriteRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___write_2d_3d
 urEnqueueMemBufferWriteRectTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___write_3d_2d
-urEnqueueMemBufferWriteRectTest.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferWriteRectTest.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferWriteRectTest.InvalidNullPointerSrc/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueMemBufferWriteRectTest.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueMemBufferWriteRectTest.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueMemImageCopyTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___1D
 urEnqueueMemImageCopyTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2D
@@ -691,159 +286,11 @@ urEnqueueMemUnmapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unifi
 urEnqueueMemUnmapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___2500_UR_MEM_FLAG_ALLOC_HOST_POINTER
 urEnqueueMemUnmapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___4096_UR_MEM_FLAG_ALLOC_HOST_POINTER
 urEnqueueMemUnmapTestWithParam.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___6000_UR_MEM_FLAG_ALLOC_HOST_POINTER
-urEnqueueUSMFillTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__1__patternSize__1
-urEnqueueUSMFillTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__256
-urEnqueueUSMFillTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__1024__patternSize__256
-urEnqueueUSMFillTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___size__256__patternSize__4
-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.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
-urEnqueueUSMFill2DTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__patternSize__4
-urEnqueueUSMFill2DTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__57__height__1__patternSize__1
-urEnqueueUSMFill2DTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__patternSize__256
-urEnqueueUSMFill2DTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__patternSize__1024
-urEnqueueUSMFill2DTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__patternSize__1
-urEnqueueUSMFill2DTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__patternSize__256
-urEnqueueUSMFill2DTestWithParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__patternSize__65536
-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.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___{{.*}}_
-urEnqueueUSMAdviseTest.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMAdviseTest.InvalidNullPointerMem/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMAdviseTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMAdviseTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMAdviseTest.InvalidSizeTooLarge/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueUSMAdviseTest.NonCoherentDeviceMemorySuccessOrWarning/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-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___{{.*}}_
-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
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_HOST__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_HOST__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_HOST__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_SHARED__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_SHARED__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_SHARED__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/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.SuccessNonBlocking/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.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__1024__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1024__width__256__height__256__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__23__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_HOST__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_HOST
-urEnqueueUSMMemcpy2DTestWithParam.SuccessNonBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__234__width__233__height__1__src__UR_USM_TYPE_SHARED__dst__UR_USM_TYPE_SHARED
-urEnqueueUSMMemcpy2DNegativeTest.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DNegativeTest.InvalidNullPointer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DNegativeTest.InvalidSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
-urEnqueueUSMMemcpy2DNegativeTest.InvalidEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___pitch__1__width__1__height__1__src__UR_USM_TYPE_DEVICE__dst__UR_USM_TYPE_DEVICE
 urEnqueueUSMPrefetchWithParamTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_USM_MIGRATION_FLAG_DEFAULT
 urEnqueueUSMPrefetchWithParamTest.CheckWaitEvent/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_USM_MIGRATION_FLAG_DEFAULT
-urEnqueueUSMPrefetchTest.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMPrefetchTest.InvalidNullPointerMem/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMPrefetchTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMPrefetchTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMPrefetchTest.InvalidSizeTooLarge/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueUSMPrefetchTest.InvalidEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueReadHostPipeTest.InvalidNullHandleQueue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueReadHostPipeTest.InvalidNullHandleProgram/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueReadHostPipeTest.InvalidNullPointerPipeSymbol/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
@@ -856,4 +303,3 @@ urEnqueueWriteHostPipeTest.InvalidNullPointerBuffer/Intel_R__oneAPI_Unified_Runt
 urEnqueueWriteHostPipeTest.InvalidEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueTimestampRecordingExpTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEnqueueTimestampRecordingExpTest.SuccessBlocking/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEnqueueTimestampRecordingExpTest.InvalidNullPtrEventWaitList/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
diff --git a/test/conformance/enqueue/enqueue_adapter_native_cpu.match b/test/conformance/enqueue/enqueue_adapter_native_cpu.match
index 83e9f2391e..fc3cf2d975 100644
--- a/test/conformance/enqueue/enqueue_adapter_native_cpu.match
+++ b/test/conformance/enqueue/enqueue_adapter_native_cpu.match
@@ -45,6 +45,7 @@
 {{OPT}}urEnqueueKernelLaunchTestWithParam.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__3D_1_53_19
 {{OPT}}urEnqueueKernelLaunchTestWithParam.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__3D_256_79_8
 {{OPT}}urEnqueueKernelLaunchWithVirtualMemory.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}
+{{OPT}}urEnqueueKernelLaunchWithUSM.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}
 {{OPT}}urEnqueueKernelLaunchMultiDeviceTest.KernelLaunchReadDifferentQueues/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}
 {{OPT}}urEnqueueKernelLaunchUSMLinkedList.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__UsePoolEnabled
 {{OPT}}urEnqueueKernelLaunchUSMLinkedList.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU__{{.*}}__UsePoolDisabled
diff --git a/test/conformance/enqueue/urEnqueueKernelLaunchAndMemcpyInOrder.cpp b/test/conformance/enqueue/urEnqueueKernelLaunchAndMemcpyInOrder.cpp
new file mode 100644
index 0000000000..2aee087c73
--- /dev/null
+++ b/test/conformance/enqueue/urEnqueueKernelLaunchAndMemcpyInOrder.cpp
@@ -0,0 +1,392 @@
+// 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 <uur/fixtures.h>
+#include <uur/raii.h>
+
+#include <thread>
+#include <utility>
+
+// There was a bug in previous L0 drivers that caused the test to fail
+std::tuple<size_t, size_t, size_t> minL0DriverVersion = {1, 3, 29534};
+
+template <typename T>
+struct urMultiQueueLaunchMemcpyTest : uur::urMultiDeviceContextTestTemplate<1>,
+                                      testing::WithParamInterface<T> {
+    std::string KernelName;
+    std::vector<ur_program_handle_t> programs;
+    std::vector<ur_kernel_handle_t> kernels;
+    std::vector<void *> SharedMem;
+
+    std::vector<ur_queue_handle_t> queues;
+    std::vector<ur_device_handle_t> devices;
+
+    std::function<void(void)> createQueues;
+
+    static constexpr char ProgramName[] = "increment";
+    static constexpr size_t ArraySize = 100;
+    static constexpr size_t InitialValue = 1;
+
+    void SetUp() override {
+        UUR_RETURN_ON_FATAL_FAILURE(
+            uur::urMultiDeviceContextTestTemplate<1>::SetUp());
+
+        createQueues();
+
+        for (auto &device : devices) {
+            SKIP_IF_DRIVER_TOO_OLD("Level-Zero", minL0DriverVersion, platform,
+                                   device);
+        }
+
+        programs.resize(devices.size());
+        kernels.resize(devices.size());
+        SharedMem.resize(devices.size());
+
+        KernelName = uur::KernelsEnvironment::instance->GetEntryPointNames(
+            ProgramName)[0];
+
+        std::shared_ptr<std::vector<char>> il_binary;
+        std::vector<ur_program_metadata_t> metadatas{};
+
+        uur::KernelsEnvironment::instance->LoadSource(ProgramName, il_binary);
+
+        for (size_t i = 0; i < devices.size(); i++) {
+            const ur_program_properties_t properties = {
+                UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES, nullptr,
+                static_cast<uint32_t>(metadatas.size()),
+                metadatas.empty() ? nullptr : metadatas.data()};
+
+            uur::raii::Program program;
+            ASSERT_SUCCESS(uur::KernelsEnvironment::instance->CreateProgram(
+                platform, context, devices[i], *il_binary, &properties,
+                &programs[i]));
+
+            UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
+                urProgramBuild(context, programs[i], nullptr));
+            ASSERT_SUCCESS(
+                urKernelCreate(programs[i], KernelName.data(), &kernels[i]));
+
+            ASSERT_SUCCESS(
+                urUSMSharedAlloc(context, devices[i], nullptr, nullptr,
+                                 ArraySize * sizeof(uint32_t), &SharedMem[i]));
+
+            ASSERT_SUCCESS(urEnqueueUSMFill(queues[i], SharedMem[i],
+                                            sizeof(uint32_t), &InitialValue,
+                                            ArraySize * sizeof(uint32_t), 0,
+                                            nullptr, nullptr /* &Event */));
+            ASSERT_SUCCESS(urQueueFinish(queues[i]));
+
+            ASSERT_SUCCESS(
+                urKernelSetArgPointer(kernels[i], 0, nullptr, SharedMem[i]));
+        }
+    }
+
+    void TearDown() override {
+        for (auto &Ptr : SharedMem) {
+            urUSMFree(context, Ptr);
+        }
+        for (const auto &queue : queues) {
+            EXPECT_SUCCESS(urQueueRelease(queue));
+        }
+        for (const auto &kernel : kernels) {
+            urKernelRelease(kernel);
+        }
+        for (const auto &program : programs) {
+            urProgramRelease(program);
+        }
+        UUR_RETURN_ON_FATAL_FAILURE(
+            uur::urMultiDeviceContextTestTemplate<1>::TearDown());
+    }
+};
+
+template <typename Param>
+struct urEnqueueKernelLaunchIncrementMultiDeviceTestWithParam
+    : public urMultiQueueLaunchMemcpyTest<Param> {
+    static constexpr size_t duplicateDevices = 8;
+
+    using urMultiQueueLaunchMemcpyTest<Param>::context;
+    using urMultiQueueLaunchMemcpyTest<Param>::queues;
+    using urMultiQueueLaunchMemcpyTest<Param>::devices;
+    using urMultiQueueLaunchMemcpyTest<Param>::kernels;
+    using urMultiQueueLaunchMemcpyTest<Param>::SharedMem;
+
+    void SetUp() override {
+        this->createQueues = [&] {
+            for (size_t i = 0; i < duplicateDevices; i++) {
+                devices.insert(
+                    devices.end(),
+                    uur::KernelsEnvironment::instance->devices.begin(),
+                    uur::KernelsEnvironment::instance->devices.end());
+            }
+
+            for (auto &device : devices) {
+                ur_queue_handle_t queue = nullptr;
+                ASSERT_SUCCESS(urQueueCreate(context, device, 0, &queue));
+                queues.push_back(queue);
+            }
+        };
+
+        UUR_RETURN_ON_FATAL_FAILURE(
+            urMultiQueueLaunchMemcpyTest<Param>::SetUp());
+    }
+
+    void TearDown() override {
+        UUR_RETURN_ON_FATAL_FAILURE(
+            urMultiQueueLaunchMemcpyTest<Param>::TearDown());
+    }
+};
+
+struct urEnqueueKernelLaunchIncrementTest
+    : urMultiQueueLaunchMemcpyTest<
+          std::tuple<ur_device_handle_t, uur::BoolTestParam>> {
+    static constexpr size_t numOps = 50;
+
+    ur_queue_handle_t queue;
+
+    using Param = std::tuple<ur_device_handle_t, uur::BoolTestParam>;
+    using urMultiQueueLaunchMemcpyTest<Param>::context;
+    using urMultiQueueLaunchMemcpyTest<Param>::queues;
+    using urMultiQueueLaunchMemcpyTest<Param>::devices;
+    using urMultiQueueLaunchMemcpyTest<Param>::kernels;
+    using urMultiQueueLaunchMemcpyTest<Param>::SharedMem;
+
+    void SetUp() override {
+        auto device = std::get<0>(GetParam());
+
+        this->createQueues = [&] {
+            ASSERT_SUCCESS(urQueueCreate(context, device, 0, &queue));
+
+            // use the same queue and device for all operations
+            for (size_t i = 0; i < numOps; i++) {
+                urQueueRetain(queue);
+
+                queues.push_back(queue);
+                devices.push_back(device);
+            }
+        };
+
+        UUR_RETURN_ON_FATAL_FAILURE(
+            urMultiQueueLaunchMemcpyTest<Param>::SetUp());
+    }
+
+    void TearDown() override {
+        urQueueRelease(queue);
+        UUR_RETURN_ON_FATAL_FAILURE(
+            urMultiQueueLaunchMemcpyTest<Param>::TearDown());
+    }
+};
+
+UUR_TEST_SUITE_P(
+    urEnqueueKernelLaunchIncrementTest,
+    testing::ValuesIn(uur::BoolTestParam::makeBoolParam("UseEvents")),
+    uur::deviceTestWithParamPrinter<uur::BoolTestParam>);
+
+TEST_P(urEnqueueKernelLaunchIncrementTest, Success) {
+    constexpr size_t global_offset = 0;
+    constexpr size_t n_dimensions = 1;
+
+    auto useEvents = std::get<1>(GetParam()).value;
+
+    std::vector<uur::raii::Event> Events(numOps * 2);
+    for (size_t i = 0; i < numOps; i++) {
+        size_t waitNum = 0;
+        ur_event_handle_t *lastEvent = nullptr;
+        ur_event_handle_t *kernelEvent = nullptr;
+        ur_event_handle_t *memcpyEvent = nullptr;
+
+        if (useEvents) {
+            // Events are: kernelEvent0, memcpyEvent0, kernelEvent1, ...
+            waitNum = i > 0 ? 1 : 0;
+            lastEvent = i > 0 ? Events[i * 2 - 1].ptr() : nullptr;
+
+            kernelEvent = Events[i * 2].ptr();
+            memcpyEvent = Events[i * 2 + 1].ptr();
+        }
+
+        // execute kernel that increments each element by 1
+        ASSERT_SUCCESS(urEnqueueKernelLaunch(
+            queue, kernels[i], n_dimensions, &global_offset, &ArraySize,
+            nullptr, waitNum, lastEvent, kernelEvent));
+
+        // copy the memory (input for the next kernel)
+        if (i < numOps - 1) {
+            ASSERT_SUCCESS(
+                urEnqueueUSMMemcpy(queue, false, SharedMem[i + 1], SharedMem[i],
+                                   ArraySize * sizeof(uint32_t), useEvents,
+                                   kernelEvent, memcpyEvent));
+        }
+    }
+
+    if (useEvents) {
+        // TODO: just wait on the last event, once urEventWait is implemented
+        // by V2 L0 adapter
+        urQueueFinish(queue);
+    } else {
+        urQueueFinish(queue);
+    }
+
+    size_t ExpectedValue = InitialValue;
+    for (size_t i = 0; i < numOps; i++) {
+        ExpectedValue++;
+        for (uint32_t j = 0; j < ArraySize; ++j) {
+            ASSERT_EQ(reinterpret_cast<uint32_t *>(SharedMem[i])[j],
+                      ExpectedValue);
+        }
+    }
+}
+
+struct VoidParam {};
+using urEnqueueKernelLaunchIncrementMultiDeviceTest =
+    urEnqueueKernelLaunchIncrementMultiDeviceTestWithParam<VoidParam>;
+
+// Do a chain of kernelLaunch(dev0) -> memcpy(dev0, dev1) -> kernelLaunch(dev1) ... ops
+TEST_F(urEnqueueKernelLaunchIncrementMultiDeviceTest, Success) {
+    size_t returned_size;
+    ASSERT_SUCCESS(urDeviceGetInfo(devices[0], UR_DEVICE_INFO_EXTENSIONS, 0,
+                                   nullptr, &returned_size));
+
+    std::unique_ptr<char[]> returned_extensions(new char[returned_size]);
+
+    ASSERT_SUCCESS(urDeviceGetInfo(devices[0], UR_DEVICE_INFO_EXTENSIONS,
+                                   returned_size, returned_extensions.get(),
+                                   nullptr));
+
+    std::string_view extensions_string(returned_extensions.get());
+    const bool usm_p2p_support =
+        extensions_string.find(UR_USM_P2P_EXTENSION_STRING_EXP) !=
+        std::string::npos;
+
+    if (!usm_p2p_support) {
+        GTEST_SKIP() << "EXP usm p2p feature is not supported.";
+    }
+
+    constexpr size_t global_offset = 0;
+    constexpr size_t n_dimensions = 1;
+
+    std::vector<uur::raii::Event> Events(devices.size() * 2);
+    for (size_t i = 0; i < devices.size(); i++) {
+        // Events are: kernelEvent0, memcpyEvent0, kernelEvent1, ...
+        size_t waitNum = i > 0 ? 1 : 0;
+        ur_event_handle_t *lastEvent =
+            i > 0 ? Events[i * 2 - 1].ptr() : nullptr;
+        ur_event_handle_t *kernelEvent = Events[i * 2].ptr();
+        ur_event_handle_t *memcpyEvent = Events[i * 2 + 1].ptr();
+
+        // execute kernel that increments each element by 1
+        ASSERT_SUCCESS(urEnqueueKernelLaunch(
+            queues[i], kernels[i], n_dimensions, &global_offset, &ArraySize,
+            nullptr, waitNum, lastEvent, kernelEvent));
+
+        // copy the memory to next device
+        if (i < devices.size() - 1) {
+            ASSERT_SUCCESS(urEnqueueUSMMemcpy(
+                queues[i], false, SharedMem[i + 1], SharedMem[i],
+                ArraySize * sizeof(uint32_t), 1, kernelEvent, memcpyEvent));
+        }
+    }
+
+    // synchronize on the last queue only, this has to ensure all the operations
+    // are completed
+    urQueueFinish(queues.back());
+
+    size_t ExpectedValue = InitialValue;
+    for (size_t i = 0; i < devices.size(); i++) {
+        ExpectedValue++;
+        for (uint32_t j = 0; j < ArraySize; ++j) {
+            ASSERT_EQ(reinterpret_cast<uint32_t *>(SharedMem[i])[j],
+                      ExpectedValue);
+        }
+    }
+}
+
+template <typename T>
+inline std::string
+printParams(const testing::TestParamInfo<typename T::ParamType> &info) {
+    std::stringstream ss;
+
+    auto param1 = std::get<0>(info.param);
+    auto param2 = std::get<1>(info.param);
+
+    ss << (param1.value ? "" : "No") << param1.name;
+    ss << (param2.value ? "" : "No") << param2.name;
+
+    return ss.str();
+}
+
+using urEnqueueKernelLaunchIncrementMultiDeviceMultiThreadTest =
+    urEnqueueKernelLaunchIncrementMultiDeviceTestWithParam<
+        std::tuple<uur::BoolTestParam, uur::BoolTestParam>>;
+
+INSTANTIATE_TEST_SUITE_P(
+    , urEnqueueKernelLaunchIncrementMultiDeviceMultiThreadTest,
+    testing::Combine(
+        testing::ValuesIn(uur::BoolTestParam::makeBoolParam("UseEvents")),
+        testing::ValuesIn(uur::BoolTestParam::makeBoolParam("QueuePerThread"))),
+    printParams<urEnqueueKernelLaunchIncrementMultiDeviceMultiThreadTest>);
+
+// Enqueue kernelLaunch concurrently from multiple threads
+// With !queuePerThread this becomes a test on a single device
+TEST_P(urEnqueueKernelLaunchIncrementMultiDeviceMultiThreadTest, Success) {
+    size_t numThreads = devices.size();
+    std::vector<std::thread> threads;
+
+    static constexpr size_t numOpsPerThread = 6;
+
+    auto useEvents = std::get<0>(GetParam()).value;
+    auto queuePerThread = std::get<1>(GetParam()).value;
+
+    for (size_t i = 0; i < numThreads; i++) {
+        threads.emplace_back([this, i, queuePerThread, useEvents]() {
+            constexpr size_t global_offset = 0;
+            constexpr size_t n_dimensions = 1;
+
+            auto queue = queuePerThread ? queues[i] : queues.back();
+            auto kernel = kernels[i];
+            auto sharedPtr = SharedMem[i];
+
+            std::vector<uur::raii::Event> Events(numOpsPerThread + 1);
+            for (size_t j = 0; j < numOpsPerThread; j++) {
+                size_t waitNum = 0;
+                ur_event_handle_t *lastEvent = nullptr;
+                ur_event_handle_t *signalEvent = nullptr;
+
+                if (useEvents) {
+                    waitNum = j > 0 ? 1 : 0;
+                    lastEvent = j > 0 ? Events[j - 1].ptr() : nullptr;
+                    signalEvent = Events[j].ptr();
+                }
+
+                // execute kernel that increments each element by 1
+                ASSERT_SUCCESS(urEnqueueKernelLaunch(
+                    queue, kernel, n_dimensions, &global_offset, &ArraySize,
+                    nullptr, waitNum, lastEvent, signalEvent));
+            }
+
+            std::vector<uint32_t> data(ArraySize);
+
+            auto lastEvent =
+                useEvents ? Events[numOpsPerThread - 1].ptr() : nullptr;
+            auto signalEvent = useEvents ? Events.back().ptr() : nullptr;
+            ASSERT_SUCCESS(
+                urEnqueueUSMMemcpy(queue, false, data.data(), sharedPtr,
+                                   ArraySize * sizeof(uint32_t), useEvents,
+                                   lastEvent, signalEvent));
+
+            urQueueFinish(queue);
+            // TODO: when useEvents is implemented for L0 v2 adapter
+            // wait on event instead
+
+            size_t ExpectedValue = InitialValue;
+            ExpectedValue += numOpsPerThread;
+            for (uint32_t j = 0; j < ArraySize; ++j) {
+                ASSERT_EQ(data[j], ExpectedValue);
+            }
+        });
+    }
+
+    for (auto &thread : threads) {
+        thread.join();
+    }
+}
diff --git a/test/conformance/event/event_adapter_level_zero_v2.match b/test/conformance/event/event_adapter_level_zero_v2.match
index a9d97d5044..e3f93c54c3 100644
--- a/test/conformance/event/event_adapter_level_zero_v2.match
+++ b/test/conformance/event/event_adapter_level_zero_v2.match
@@ -1,15 +1,9 @@
-
 urEventGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_EVENT_INFO_COMMAND_QUEUE
 urEventGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_EVENT_INFO_CONTEXT
 urEventGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_EVENT_INFO_COMMAND_TYPE
-urEventGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_EVENT_INFO_COMMAND_EXECUTION_STATUS
-urEventGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_EVENT_INFO_REFERENCE_COUNT
 urEventGetInfoNegativeTest.InvalidNullHandle/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventGetInfoNegativeTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEventGetInfoNegativeTest.InvalidSizePropSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEventGetInfoNegativeTest.InvalidSizePropSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventGetInfoNegativeTest.InvalidNullPointerPropValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventGetInfoNegativeTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEventGetProfilingInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROFILING_INFO_COMMAND_QUEUED
 urEventGetProfilingInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROFILING_INFO_COMMAND_SUBMIT
 urEventGetProfilingInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROFILING_INFO_COMMAND_START
@@ -17,22 +11,8 @@ urEventGetProfilingInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Z
 urEventGetProfilingInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_PROFILING_INFO_COMMAND_COMPLETE
 urEventGetProfilingInfoWithTimingComparisonTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEventGetProfilingInfoNegativeTest.InvalidNullHandle/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventGetProfilingInfoNegativeTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEventGetProfilingInfoNegativeTest.InvalidValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventWaitTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventRetainTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventRetainTest.InvalidNullHandle/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventReleaseTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventReleaseTest.InvalidNullHandle/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventGetNativeHandleTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventGetNativeHandleTest.InvalidNullHandleEvent/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventGetNativeHandleTest.InvalidNullPointerNativeEvent/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventCreateWithNativeHandleTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEventSetCallbackTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEventSetCallbackTest.ValidateParameters/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEventSetCallbackTest.AllStates/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urEventSetCallbackTest.EventAlreadyCompleted/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventSetCallbackNegativeTest.InvalidNullHandleEvent/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventSetCallbackNegativeTest.InvalidNullPointerCallback/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urEventSetCallbackNegativeTest.InvalidEnumeration/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-{{OPT}}{{Segmentation fault|Aborted}}
diff --git a/test/conformance/kernel/kernel_adapter_level_zero_v2.match b/test/conformance/kernel/kernel_adapter_level_zero_v2.match
index dca885cc4d..074a58720a 100644
--- a/test/conformance/kernel/kernel_adapter_level_zero_v2.match
+++ b/test/conformance/kernel/kernel_adapter_level_zero_v2.match
@@ -1,85 +1,63 @@
-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
+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___{{.*}}_
+urKernelSetArgLocalTest.InvalidKernelArgumentIndex/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
+urKernelSetArgMemObjTest.InvalidKernelArgumentIndex/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___{{.*}}_
diff --git a/test/conformance/memory/memory_adapter_level_zero_v2.match b/test/conformance/memory/memory_adapter_level_zero_v2.match
index 7e92763def..e6639680ed 100644
--- a/test/conformance/memory/memory_adapter_level_zero_v2.match
+++ b/test/conformance/memory/memory_adapter_level_zero_v2.match
@@ -1,38 +1,12 @@
-urMemBufferCreateWithFlagsTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_FLAG_READ_WRITE
-urMemBufferCreateWithFlagsTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_FLAG_WRITE_ONLY
-urMemBufferCreateWithFlagsTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_FLAG_READ_ONLY
-urMemBufferCreateWithFlagsTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_FLAG_ALLOC_HOST_POINTER
-urMemBufferCreateWithHostPtrFlagsTest.SUCCESS/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_FLAG_ALLOC_COPY_HOST_POINTER
-urMemBufferCreateWithHostPtrFlagsTest.SUCCESS/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_FLAG_USE_HOST_POINTER
-urMemBufferCreateWithNativeHandleTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urMemBufferPartitionTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urMemBufferPartitionTest.InvalidNullHandleBuffer/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urMemBufferPartitionTest.InvalidEnumerationFlags/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urMemBufferPartitionTest.InvalidEnumerationBufferCreateType/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urMemBufferPartitionTest.InvalidNullPointerBufferCreateInfo/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urMemBufferPartitionTest.InvalidNullPointerMem/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urMemBufferPartitionTest.InvalidBufferSize/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urMemBufferPartitionTest.InvalidValueCreateType/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urMemBufferPartitionTest.InvalidValueBufferCreateInfoOutOfBounds/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urMemGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_SIZE
 urMemGetInfoTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_CONTEXT
-urMemGetInfoTest.InvalidNullHandleMemory/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_SIZE
-urMemGetInfoTest.InvalidNullHandleMemory/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_CONTEXT
-urMemGetInfoTest.InvalidEnumerationMemInfoType/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_SIZE
-urMemGetInfoTest.InvalidEnumerationMemInfoType/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_CONTEXT
-urMemGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_SIZE
-urMemGetInfoTest.InvalidSizeZero/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_CONTEXT
 urMemGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_SIZE
 urMemGetInfoTest.InvalidSizeSmall/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_CONTEXT
-urMemGetInfoTest.InvalidNullPointerParamValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_SIZE
-urMemGetInfoTest.InvalidNullPointerParamValue/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_CONTEXT
-urMemGetInfoTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_SIZE
-urMemGetInfoTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_CONTEXT
 urMemGetInfoImageTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_SIZE
 urMemGetInfoImageTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_MEM_INFO_CONTEXT
-urMemGetNativeHandleTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urMemGetNativeHandleTest.InvalidNullHandleMem/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urMemGetNativeHandleTest.InvalidNullPointerNativeMem/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
 urMemImageCreateTestWithImageFormatParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_IMAGE_CHANNEL_ORDER_A__UR_IMAGE_CHANNEL_TYPE_SNORM_INT8
 urMemImageCreateTestWithImageFormatParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_IMAGE_CHANNEL_ORDER_A__UR_IMAGE_CHANNEL_TYPE_SNORM_INT16
 urMemImageCreateTestWithImageFormatParam.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_IMAGE_CHANNEL_ORDER_A__UR_IMAGE_CHANNEL_TYPE_UNORM_INT8
@@ -307,7 +281,3 @@ urMemImageGetInfoTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runt
 urMemImageGetInfoTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_IMAGE_INFO_WIDTH
 urMemImageGetInfoTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_IMAGE_INFO_HEIGHT
 urMemImageGetInfoTest.InvalidNullPointerPropSizeRet/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}___UR_IMAGE_INFO_DEPTH
-urMemReleaseTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urMemReleaseTest.InvalidNullHandleMem/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urMemRetainTest.Success/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
-urMemRetainTest.InvalidNullHandleMem/Intel_R__oneAPI_Unified_Runtime_over_Level_Zero___{{.*}}_
diff --git a/test/conformance/program/program_adapter_level_zero_v2.match b/test/conformance/program/program_adapter_level_zero_v2.match
index 7c53e24502..70e0a12609 100644
--- a/test/conformance/program/program_adapter_level_zero_v2.match
+++ b/test/conformance/program/program_adapter_level_zero_v2.match
@@ -1,12 +1,8 @@
-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___{{.*}}__
+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 524e04fa1d..e69de29bb2 100644
--- a/test/conformance/queue/queue_adapter_level_zero_v2.match
+++ b/test/conformance/queue/queue_adapter_level_zero_v2.match
@@ -1,2 +0,0 @@
-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/testing/include/uur/fixtures.h b/test/conformance/testing/include/uur/fixtures.h
index e57a31584a..568f700da1 100644
--- a/test/conformance/testing/include/uur/fixtures.h
+++ b/test/conformance/testing/include/uur/fixtures.h
@@ -513,11 +513,12 @@ struct urMultiQueueTest : urContextTest {
     ur_queue_handle_t queue2 = nullptr;
 };
 
-struct urMultiDeviceContextTest : urPlatformTest {
+template <size_t MinDevices = 2>
+struct urMultiDeviceContextTestTemplate : urPlatformTest {
     void SetUp() override {
         UUR_RETURN_ON_FATAL_FAILURE(urPlatformTest::SetUp());
         auto &devices = DevicesEnvironment::instance->devices;
-        if (devices.size() <= 1) {
+        if (devices.size() < MinDevices) {
             GTEST_SKIP();
         }
         ASSERT_SUCCESS(urContextCreate(static_cast<uint32_t>(devices.size()),
@@ -534,6 +535,10 @@ struct urMultiDeviceContextTest : urPlatformTest {
     ur_context_handle_t context = nullptr;
 };
 
+struct urMultiDeviceContextTest : urMultiDeviceContextTestTemplate<> {
+    using urMultiDeviceContextTestTemplate::context;
+};
+
 struct urMultiDeviceMemBufferTest : urMultiDeviceContextTest {
     void SetUp() override {
         UUR_RETURN_ON_FATAL_FAILURE(urMultiDeviceContextTest::SetUp());
diff --git a/test/conformance/testing/include/uur/utils.h b/test/conformance/testing/include/uur/utils.h
index 7e23e55843..a1febf9769 100644
--- a/test/conformance/testing/include/uur/utils.h
+++ b/test/conformance/testing/include/uur/utils.h
@@ -424,6 +424,65 @@ ur_result_t MakeUSMAllocationByType(ur_usm_type_t type,
                                     ur_usm_pool_handle_t hPool, size_t size,
                                     void **ppMem);
 
+inline std::tuple<size_t, size_t, size_t>
+decodeSemVersion(std::string version) {
+    auto posMajor = version.find('.');
+    auto posMinor = version.find('.', posMajor + 1);
+    auto major = std::stoi(version.substr(0, posMajor));
+    auto minor =
+        std::stoi(version.substr(posMajor + 1, posMinor - posMajor - 1));
+    auto patch = std::stoi(version.substr(posMinor + 1));
+    return std::make_tuple(major, minor, patch);
+}
+
+inline bool isGivenAdapter(ur_platform_handle_t hPlatform,
+                           std::string adapterName) {
+    size_t psize;
+    EXPECT_EQ(
+        urPlatformGetInfo(hPlatform, UR_PLATFORM_INFO_NAME, 0, nullptr, &psize),
+        UR_RESULT_SUCCESS);
+    std::string platform(psize, '\0');
+    EXPECT_EQ(urPlatformGetInfo(hPlatform, UR_PLATFORM_INFO_NAME, psize,
+                                platform.data(), nullptr),
+              UR_RESULT_SUCCESS);
+
+    return platform.find(adapterName) != std::string::npos;
+}
+
+inline std::tuple<size_t, size_t, size_t>
+getDriverVersion(ur_device_handle_t hDevice) {
+    size_t driverVersionSize = 0;
+    EXPECT_EQ(urDeviceGetInfo(hDevice, UR_DEVICE_INFO_DRIVER_VERSION, 0,
+                              nullptr, &driverVersionSize),
+              UR_RESULT_SUCCESS);
+    std::string driver(driverVersionSize, '\0');
+    EXPECT_EQ(urDeviceGetInfo(hDevice, UR_DEVICE_INFO_DRIVER_VERSION,
+                              driverVersionSize, driver.data(),
+                              &driverVersionSize),
+              UR_RESULT_SUCCESS);
+
+    return decodeSemVersion(driver);
+}
+
+#define SKIP_IF_DRIVER_TOO_OLD(adapterName, minDriverVersion, hPlatform,       \
+                               hDevice)                                        \
+    do {                                                                       \
+        if (uur::isGivenAdapter(hPlatform, adapterName)) {                     \
+            auto [major, minor, patch] = uur::getDriverVersion(hDevice);       \
+            auto [minMajor, minMinor, minPatch] = minL0DriverVersion;          \
+            if (major < minMajor || (major == minMajor && minor < minMinor) || \
+                (major == minMajor && minor == minMinor &&                     \
+                 patch < minPatch)) {                                          \
+                GTEST_SKIP()                                                   \
+                    << "Skipping test because driver version is too old for "  \
+                    << adapterName << ". "                                     \
+                    << "Driver version: " << major << "." << minor << "."      \
+                    << patch << " Minimum required version: " << minMajor      \
+                    << "." << minMinor << "." << minPatch;                     \
+            }                                                                  \
+        }                                                                      \
+    } while (0)
+
 } // namespace uur
 
 #endif // UR_CONFORMANCE_INCLUDE_UTILS_H_INCLUDED
diff --git a/test/conformance/usm/usm_adapter_level_zero_v2.match b/test/conformance/usm/usm_adapter_level_zero_v2.match
index 88501eea9d..0908da40da 100644
--- a/test/conformance/usm/usm_adapter_level_zero_v2.match
+++ b/test/conformance/usm/usm_adapter_level_zero_v2.match
@@ -1,122 +1,7 @@
-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