From 1a2eae4ece5ccd4e0a8aaf5be7978f1088921910 Mon Sep 17 00:00:00 2001
From: Krzysztof Swiecicki <krzysztof.swiecicki@intel.com>
Date: Wed, 1 Apr 2026 14:31:07 +0000
Subject: [PATCH 1/2] [UR][CTS] Replace urEnqueueEventsWait with dummy event in
 waitlist tests

InvalidNullPtrEventWaitList tests used urEnqueueEventsWait as the first
operation on a queue to create a valid event for validation testing.
This triggers a hang in the L0 driver when multiple test shards
concurrently call zeCommandListAppendSignalEvent +
zeCommandListHostSynchronize on immediate command lists.

Replace with urEventCreateWithNativeHandle(0, ...) which creates a
dummy event without enqueuing any work, avoiding the L0 driver
concurrency issue entirely. The validation layer rejects invalid
waitlist arguments before reaching the adapter, so the dummy event
is sufficient for these tests.
---
 .../enqueue/urEnqueueEventsWait.cpp            | 10 +++++-----
 .../enqueue/urEnqueueEventsWaitWithBarrier.cpp | 10 +++++-----
 .../urEnqueueKernelLaunchWithArgsExp.cpp       |  9 +++++----
 .../enqueue/urEnqueueMemBufferCopy.cpp         | 10 +++++-----
 .../enqueue/urEnqueueMemBufferCopyRect.cpp     | 18 +++++++++---------
 .../enqueue/urEnqueueMemBufferFill.cpp         | 10 +++++-----
 .../enqueue/urEnqueueMemBufferMap.cpp          | 10 +++++-----
 .../enqueue/urEnqueueMemBufferRead.cpp         | 10 +++++-----
 .../enqueue/urEnqueueMemBufferReadRect.cpp     | 11 ++++++-----
 .../enqueue/urEnqueueMemBufferWrite.cpp        | 10 +++++-----
 .../enqueue/urEnqueueMemBufferWriteRect.cpp    | 10 +++++-----
 .../enqueue/urEnqueueMemImageCopy.cpp          | 10 +++++-----
 .../enqueue/urEnqueueMemImageRead.cpp          | 12 ++++++------
 .../enqueue/urEnqueueMemImageWrite.cpp         | 10 +++++-----
 .../conformance/enqueue/urEnqueueMemUnmap.cpp  | 10 +++++-----
 .../enqueue/urEnqueueReadHostPipe.cpp          | 10 +++++-----
 .../enqueue/urEnqueueTimestampRecording.cpp    |  9 +++++----
 .../conformance/enqueue/urEnqueueUSMFill.cpp   |  9 +++++----
 .../conformance/enqueue/urEnqueueUSMFill2D.cpp | 11 ++++++-----
 .../enqueue/urEnqueueUSMPrefetch.cpp           | 10 +++++-----
 .../enqueue/urEnqueueWriteHostPipe.cpp         | 10 +++++-----
 21 files changed, 112 insertions(+), 107 deletions(-)

diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueEventsWait.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueEventsWait.cpp
index cd4fe1d3d9b91..42a8bdcf3bd49 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueEventsWait.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueEventsWait.cpp
@@ -6,6 +6,7 @@
 
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 struct urEnqueueEventsWaitTest : uur::urMultiQueueTest {
   void SetUp() override {
@@ -108,15 +109,14 @@ TEST_P(urEnqueueEventsWaitTest, InvalidNullPtrEventWaitList) {
   ASSERT_EQ_RESULT(urEnqueueEventsWait(queue1, 1, nullptr, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue1, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
-  ASSERT_EQ_RESULT(urEnqueueEventsWait(queue1, 0, &validEvent, nullptr),
+  ASSERT_EQ_RESULT(urEnqueueEventsWait(queue1, 0, eventDummy.ptr(), nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
   ur_event_handle_t inv_evt = nullptr;
   ASSERT_EQ_RESULT(urEnqueueEventsWait(queue1, 1, &inv_evt, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueEventsWaitWithBarrier.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueEventsWaitWithBarrier.cpp
index b0c5805227d30..531681c6ef7c2 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueEventsWaitWithBarrier.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueEventsWaitWithBarrier.cpp
@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 enum class BarrierType {
   Normal,
@@ -150,17 +151,16 @@ TEST_P(urEnqueueEventsWaitWithBarrierTest, InvalidNullPtrEventWaitList) {
   ASSERT_EQ_RESULT(EnqueueBarrier(queue1, 1, nullptr, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue1, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
-  ASSERT_EQ_RESULT(EnqueueBarrier(queue1, 0, &validEvent, nullptr),
+  ASSERT_EQ_RESULT(EnqueueBarrier(queue1, 0, eventDummy.ptr(), nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
   ur_event_handle_t inv_evt = nullptr;
   ASSERT_EQ_RESULT(EnqueueBarrier(queue1, 1, &inv_evt, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
 
 TEST_P(urEnqueueEventsWaitWithBarrierOrderingTest,
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueKernelLaunchWithArgsExp.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueKernelLaunchWithArgsExp.cpp
index 4ec7aaf865c1e..2d13cf37bf25a 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueKernelLaunchWithArgsExp.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueKernelLaunchWithArgsExp.cpp
@@ -8,6 +8,7 @@
 #include <memory>
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 struct urEnqueueKernelLaunchNoArgs3DTest : uur::urKernelExecutionTest {
   void SetUp() override {
@@ -187,13 +188,14 @@ TEST_P(urEnqueueKernelLaunchTest, InvalidNullPtrEventWaitList) {
                                        nullptr, nullptr, 1, nullptr, nullptr),
       UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(urEnqueueKernelLaunchWithArgsExp(
                        queue, kernel, n_dimensions, &global_offset,
                        &global_size, nullptr, 0, nullptr, nullptr, 0,
-                       &validEvent, nullptr),
+                       eventDummy.ptr(), nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
   ur_event_handle_t inv_evt = nullptr;
@@ -202,7 +204,6 @@ TEST_P(urEnqueueKernelLaunchTest, InvalidNullPtrEventWaitList) {
                                        &global_offset, &global_size, nullptr, 0,
                                        nullptr, nullptr, 1, &inv_evt, nullptr),
       UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
 
 TEST_P(urEnqueueKernelLaunchTest, InvalidWorkDimension) {
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferCopy.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferCopy.cpp
index 0d78f74c005bb..c2ad2e6c2fa6a 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferCopy.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferCopy.cpp
@@ -8,6 +8,7 @@
 #include "uur/utils.h"
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 struct urEnqueueMemBufferCopyTestWithParam
     : uur::urMultiQueueTypeTestWithParam<size_t> {
@@ -82,19 +83,18 @@ TEST_P(urEnqueueMemBufferCopyTestWithParam, InvalidNullPtrEventWaitList) {
                                           size, 1, nullptr, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(urEnqueueMemBufferCopy(queue, src_buffer, dst_buffer, 0, 0,
-                                          size, 0, &validEvent, nullptr),
+                                          size, 0, eventDummy.ptr(), nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
   ur_event_handle_t inv_evt = nullptr;
   ASSERT_EQ_RESULT(urEnqueueMemBufferCopy(queue, src_buffer, dst_buffer, 0, 0,
                                           size, 1, &inv_evt, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
 
 TEST_P(urEnqueueMemBufferCopyTestWithParam, InvalidSize) {
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferCopyRect.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferCopyRect.cpp
index 10e401d905d1a..20394ee6214ee 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferCopyRect.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferCopyRect.cpp
@@ -7,6 +7,7 @@
 #include "uur/fixtures.h"
 #include "uur/known_failure.h"
 #include <numeric>
+#include <uur/raii.h>
 
 static std::vector<uur::test_parameters_t> generateParameterizations() {
   std::vector<uur::test_parameters_t> parameterizations;
@@ -214,14 +215,15 @@ TEST_P(urEnqueueMemBufferCopyRectTest, InvalidNullPtrEventWaitList) {
                        src_region, size, size, size, size, 1, nullptr, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
-  ASSERT_EQ_RESULT(urEnqueueMemBufferCopyRect(queue, src_buffer, dst_buffer,
-                                              src_origin, dst_origin,
-                                              src_region, size, size, size,
-                                              size, 0, &validEvent, nullptr),
-                   UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
+  ASSERT_EQ_RESULT(
+      urEnqueueMemBufferCopyRect(queue, src_buffer, dst_buffer, src_origin,
+                                 dst_origin, src_region, size, size, size, size,
+                                 0, eventDummy.ptr(), nullptr),
+      UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
   ur_event_handle_t inv_evt = nullptr;
   ASSERT_EQ_RESULT(urEnqueueMemBufferCopyRect(queue, src_buffer, dst_buffer,
@@ -229,8 +231,6 @@ TEST_P(urEnqueueMemBufferCopyRectTest, InvalidNullPtrEventWaitList) {
                                               src_region, size, size, size,
                                               size, 1, &inv_evt, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
 TEST_P(urEnqueueMemBufferCopyRectTest, InvalidSize) {
   UUR_KNOWN_FAILURE_ON(uur::NativeCPU{});
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferFill.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferFill.cpp
index 61c5fa2c6eab9..01342513dda82 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferFill.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferFill.cpp
@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #include "helpers.h"
 #include <uur/fixtures.h>
+#include <uur/raii.h>
 
 struct testParametersFill {
   size_t size;
@@ -184,12 +185,13 @@ TEST_P(urEnqueueMemBufferFillNegativeTest, InvalidNullPtrEventWaitList) {
                                           nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(urEnqueueMemBufferFill(queue, buffer, &pattern,
                                           sizeof(uint32_t), 0, size, 0,
-                                          &validEvent, nullptr),
+                                          eventDummy.ptr(), nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
   ur_event_handle_t inv_evt = nullptr;
@@ -197,8 +199,6 @@ TEST_P(urEnqueueMemBufferFillNegativeTest, InvalidNullPtrEventWaitList) {
                                           sizeof(uint32_t), 0, size, 1,
                                           &inv_evt, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
 
 TEST_P(urEnqueueMemBufferFillNegativeTest, InvalidSize) {
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferMap.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferMap.cpp
index 47314c7e7b5ca..27699ea6ca4de 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferMap.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferMap.cpp
@@ -6,6 +6,7 @@
 #include "helpers.h"
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 using urEnqueueMemBufferMapTestWithParam =
     uur::urMemBufferQueueTestWithParam<uur::mem_buffer_test_parameters_t>;
@@ -280,12 +281,13 @@ TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidNullPtrEventWaitList) {
                                          0, size, 1, nullptr, nullptr, &map),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(urEnqueueMemBufferMap(queue, buffer, true,
                                          UR_MAP_FLAG_READ | UR_MAP_FLAG_WRITE,
-                                         0, size, 0, &validEvent, nullptr,
+                                         0, size, 0, eventDummy.ptr(), nullptr,
                                          &map),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
@@ -294,8 +296,6 @@ TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidNullPtrEventWaitList) {
                                          UR_MAP_FLAG_READ | UR_MAP_FLAG_WRITE,
                                          0, size, 1, &inv_evt, nullptr, &map),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
 
 TEST_P(urEnqueueMemBufferMapTestWithParam, InvalidSize) {
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferRead.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferRead.cpp
index 89ca882344fe9..1969b4956cb9e 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferRead.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferRead.cpp
@@ -6,6 +6,7 @@
 #include "helpers.h"
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 using urEnqueueMemBufferReadTestWithParam =
     uur::urMemBufferQueueTestWithParam<uur::mem_buffer_test_parameters_t>;
@@ -50,11 +51,12 @@ TEST_P(urEnqueueMemBufferReadTestWithParam, InvalidNullPtrEventWaitList) {
                                           output.data(), 1, nullptr, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(urEnqueueMemBufferRead(queue, buffer, true, 0, size,
-                                          output.data(), 0, &validEvent,
+                                          output.data(), 0, eventDummy.ptr(),
                                           nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
@@ -62,8 +64,6 @@ TEST_P(urEnqueueMemBufferReadTestWithParam, InvalidNullPtrEventWaitList) {
   ASSERT_EQ_RESULT(urEnqueueMemBufferRead(queue, buffer, true, 0, size,
                                           output.data(), 1, &inv_evt, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
 
 TEST_P(urEnqueueMemBufferReadTestWithParam, InvalidSize) {
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferReadRect.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferReadRect.cpp
index 64ca651925e7f..496764a6413ad 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferReadRect.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferReadRect.cpp
@@ -7,6 +7,7 @@
 #include "uur/fixtures.h"
 #include <numeric>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 // Choose parameters so that we get good coverage and catch some edge cases.
 static std::vector<uur::test_parameters_t> generateParameterizations() {
@@ -175,13 +176,15 @@ TEST_P(urEnqueueMemBufferReadRectTest, InvalidNullPtrEventWaitList) {
                        host_slice_pitch, dst.data(), 1, nullptr, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(urEnqueueMemBufferReadRect(
                        queue, buffer, true, buffer_offset, host_offset, region,
                        buffer_row_pitch, buffer_slice_pitch, host_row_pitch,
-                       host_slice_pitch, dst.data(), 0, &validEvent, nullptr),
+                       host_slice_pitch, dst.data(), 0, eventDummy.ptr(),
+                       nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
   ur_event_handle_t invalidEvent = nullptr;
@@ -190,8 +193,6 @@ TEST_P(urEnqueueMemBufferReadRectTest, InvalidNullPtrEventWaitList) {
                        buffer_row_pitch, buffer_slice_pitch, host_row_pitch,
                        host_slice_pitch, dst.data(), 1, &invalidEvent, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
 
 TEST_P(urEnqueueMemBufferReadRectTest, InvalidSize) {
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferWrite.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferWrite.cpp
index 0e30771e509b1..592010c4941be 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferWrite.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferWrite.cpp
@@ -6,6 +6,7 @@
 #include "helpers.h"
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 using urEnqueueMemBufferWriteTestWithParam =
     uur::urMemBufferQueueTestWithParam<uur::mem_buffer_test_parameters_t>;
@@ -62,11 +63,12 @@ TEST_P(urEnqueueMemBufferWriteTestWithParam, InvalidNullPtrEventWaitList) {
                                            input.data(), 1, nullptr, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,
-                                           input.data(), 0, &validEvent,
+                                           input.data(), 0, eventDummy.ptr(),
                                            nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
@@ -74,8 +76,6 @@ TEST_P(urEnqueueMemBufferWriteTestWithParam, InvalidNullPtrEventWaitList) {
   ASSERT_EQ_RESULT(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,
                                            input.data(), 1, &inv_evt, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
 
 TEST_P(urEnqueueMemBufferWriteTestWithParam, InvalidSize) {
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferWriteRect.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferWriteRect.cpp
index f845272868a8c..cabcea52755f1 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferWriteRect.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueMemBufferWriteRect.cpp
@@ -7,6 +7,7 @@
 #include "uur/fixtures.h"
 #include <numeric>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 static std::vector<uur::test_parameters_t> generateParameterizations() {
   std::vector<uur::test_parameters_t> parameterizations;
@@ -178,13 +179,14 @@ TEST_P(urEnqueueMemBufferWriteRectTest, InvalidNullPtrEventWaitList) {
                        size, size, size, size, src.data(), 1, nullptr, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(
       urEnqueueMemBufferWriteRect(queue, buffer, true, buffer_offset,
                                   host_offset, region, size, size, size, size,
-                                  src.data(), 0, &validEvent, nullptr),
+                                  src.data(), 0, eventDummy.ptr(), nullptr),
       UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
   ur_event_handle_t inv_evt = nullptr;
@@ -193,8 +195,6 @@ TEST_P(urEnqueueMemBufferWriteRectTest, InvalidNullPtrEventWaitList) {
                                   host_offset, region, size, size, size, size,
                                   src.data(), 1, &inv_evt, nullptr),
       UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
 
 TEST_P(urEnqueueMemBufferWriteRectTest, InvalidSize) {
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueMemImageCopy.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueMemImageCopy.cpp
index 0279dd0e66d15..389d2aa9de447 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueMemImageCopy.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueMemImageCopy.cpp
@@ -6,6 +6,7 @@
 #include <sstream>
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 struct urEnqueueMemImageCopyTest
     : public uur::urMultiQueueTypeTestWithParam<ur_mem_type_t> {
@@ -243,11 +244,12 @@ TEST_P(urEnqueueMemImageCopyTest, InvalidNullPtrEventWaitList) {
                                          {0, 0, 0}, size, 1, nullptr, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(urEnqueueMemImageCopy(queue, srcImage, dstImage, {0, 0, 0},
-                                         {0, 0, 0}, size, 0, &validEvent,
+                                         {0, 0, 0}, size, 0, eventDummy.ptr(),
                                          nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
@@ -255,8 +257,6 @@ TEST_P(urEnqueueMemImageCopyTest, InvalidNullPtrEventWaitList) {
   ASSERT_EQ_RESULT(urEnqueueMemImageCopy(queue, srcImage, dstImage, {0, 0, 0},
                                          {0, 0, 0}, size, 1, &inv_evt, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
 
 TEST_P(urEnqueueMemImageCopyTest, InvalidSize) {
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueMemImageRead.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueMemImageRead.cpp
index ead673705d960..f62cfbab33eea 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueMemImageRead.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueMemImageRead.cpp
@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 struct urEnqueueMemImageReadTest : uur::urMemImageQueueTest {
   void SetUp() override {
@@ -67,12 +68,13 @@ TEST_P(urEnqueueMemImageReadTest, InvalidNullPtrEventWaitList) {
                                          nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(urEnqueueMemImageRead(queue, image1D, true, origin, region1D,
-                                         0, 0, output.data(), 0, &validEvent,
-                                         nullptr),
+                                         0, 0, output.data(), 0,
+                                         eventDummy.ptr(), nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
   ur_event_handle_t inv_evt = nullptr;
@@ -80,8 +82,6 @@ TEST_P(urEnqueueMemImageReadTest, InvalidNullPtrEventWaitList) {
                                          0, 0, output.data(), 1, &inv_evt,
                                          nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
 
 TEST_P(urEnqueueMemImageReadTest, InvalidOrigin1D) {
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueMemImageWrite.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueMemImageWrite.cpp
index d6623b9a9286d..0b9c0e1a7fbc5 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueMemImageWrite.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueMemImageWrite.cpp
@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 struct urEnqueueMemImageWriteTest : uur::urMemImageQueueTest {
   void SetUp() override {
@@ -65,12 +66,13 @@ TEST_P(urEnqueueMemImageWriteTest, InvalidNullPtrEventWaitList) {
                                           nullptr, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(urEnqueueMemImageWrite(queue, image1D, true, origin,
                                           region1D, 0, 0, input.data(), 0,
-                                          &validEvent, nullptr),
+                                          eventDummy.ptr(), nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
   ur_event_handle_t inv_evt = nullptr;
@@ -78,8 +80,6 @@ TEST_P(urEnqueueMemImageWriteTest, InvalidNullPtrEventWaitList) {
                                           region1D, 0, 0, input.data(), 1,
                                           &inv_evt, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
 
 TEST_P(urEnqueueMemImageWriteTest, InvalidOrigin1D) {
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueMemUnmap.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueMemUnmap.cpp
index f864b1213282c..adcc312c2e64c 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueMemUnmap.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueMemUnmap.cpp
@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #include "helpers.h"
 #include <uur/fixtures.h>
+#include <uur/raii.h>
 
 struct urEnqueueMemUnmapTestWithParam
     : uur::urMemBufferQueueTestWithParam<uur::mem_buffer_test_parameters_t> {
@@ -56,16 +57,15 @@ TEST_P(urEnqueueMemUnmapTestWithParam, InvalidNullPtrEventWaitList) {
   ASSERT_EQ_RESULT(urEnqueueMemUnmap(queue, buffer, map, 1, nullptr, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(
-      urEnqueueMemUnmap(queue, buffer, map, 0, &validEvent, nullptr),
+      urEnqueueMemUnmap(queue, buffer, map, 0, eventDummy.ptr(), nullptr),
       UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
   ur_event_handle_t inv_evt = nullptr;
   ASSERT_EQ_RESULT(urEnqueueMemUnmap(queue, buffer, map, 1, &inv_evt, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueReadHostPipe.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueReadHostPipe.cpp
index b7cc42357a31c..8eab8e6e4e2af 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueReadHostPipe.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueReadHostPipe.cpp
@@ -4,6 +4,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #include <uur/fixtures.h>
+#include <uur/raii.h>
 
 using urEnqueueReadHostPipeTest = uur::urHostPipeTest;
 
@@ -70,19 +71,18 @@ TEST_P(urEnqueueReadHostPipeTest, InvalidEventWaitList) {
                                          /*blocking*/ true, &buffer, size, 0,
                                          &phEventWaitList, phEvent));
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST,
                    urEnqueueReadHostPipe(queue, program, pipe_symbol,
                                          /*blocking*/ true, &buffer, size, 0,
-                                         &validEvent, nullptr));
+                                         eventDummy.ptr(), nullptr));
 
   ur_event_handle_t inv_evt = nullptr;
   ASSERT_EQ_RESULT(urEnqueueReadHostPipe(queue, program, pipe_symbol,
                                          /*blocking*/ true, &buffer, size, 1,
                                          &inv_evt, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueTimestampRecording.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueTimestampRecording.cpp
index ea76d38f3c8b5..5ba40f51c1e9c 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueTimestampRecording.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueTimestampRecording.cpp
@@ -9,6 +9,7 @@
 #include <gtest/gtest.h>
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 struct urEnqueueTimestampRecordingExpTest : uur::urMultiQueueTypeTest {
   void SetUp() override {
@@ -152,12 +153,12 @@ TEST_P(urEnqueueTimestampRecordingExpTest, InvalidNullPtrEventWaitList) {
       urEnqueueTimestampRecordingExp(queue, true, 1, nullptr, &event),
       UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
   ASSERT_EQ_RESULT(
-      urEnqueueTimestampRecordingExp(queue, true, 0, &validEvent, &event),
+      urEnqueueTimestampRecordingExp(queue, true, 0, eventDummy.ptr(), &event),
       UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 
   ur_event_handle_t invalidEvent = nullptr;
   ASSERT_EQ_RESULT(
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueUSMFill.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueUSMFill.cpp
index db5c2574101d0..571601b07ac03 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueUSMFill.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueUSMFill.cpp
@@ -6,6 +6,7 @@
 
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 struct testParametersFill {
   size_t size;
@@ -216,16 +217,16 @@ TEST_P(urEnqueueUSMFillNegativeTest, InvalidEventWaitList) {
                                     size, 1, nullptr, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, ptr, pattern_size, pattern.data(),
-                                    size, 0, &validEvent, nullptr),
+                                    size, 0, eventDummy.ptr(), nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
   ur_event_handle_t inv_evt = nullptr;
   ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, ptr, pattern_size, pattern.data(),
                                     size, 1, &inv_evt, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueUSMFill2D.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueUSMFill2D.cpp
index 8522096b7f9eb..13e9fbc4561db 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueUSMFill2D.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueUSMFill2D.cpp
@@ -8,6 +8,7 @@
 
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 struct testParametersFill2D {
   size_t pitch;
@@ -288,12 +289,13 @@ TEST_P(urEnqueueUSMFill2DNegativeTest, InvalidNullPtrEventWaitList) {
                                       nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(urEnqueueUSMFill2D(queue, ptr, pitch, pattern_size,
-                                      pattern.data(), width, 1, 0, &validEvent,
-                                      nullptr),
+                                      pattern.data(), width, 1, 0,
+                                      eventDummy.ptr(), nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
   ur_event_handle_t inv_evt = nullptr;
@@ -301,5 +303,4 @@ TEST_P(urEnqueueUSMFill2DNegativeTest, InvalidNullPtrEventWaitList) {
                                       pattern.data(), width, 1, 1, &inv_evt,
                                       nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp
index 88ef85cd93c4d..245a0a8ae5293 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueUSMPrefetch.cpp
@@ -6,6 +6,7 @@
 
 #include <uur/fixtures.h>
 #include <uur/known_failure.h>
+#include <uur/raii.h>
 
 struct urEnqueueUSMPrefetchWithParamTest
     : uur::urUSMDeviceAllocTestWithParam<ur_usm_migration_flag_t> {
@@ -143,19 +144,18 @@ TEST_P(urEnqueueUSMPrefetchTest, InvalidEventWaitList) {
                                         UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE, 1,
                                         nullptr, nullptr));
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST,
                    urEnqueueUSMPrefetch(queue, ptr, allocation_size,
                                         UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE, 0,
-                                        &validEvent, nullptr));
+                                        eventDummy.ptr(), nullptr));
 
   ur_event_handle_t inv_evt = nullptr;
   ASSERT_EQ_RESULT(urEnqueueUSMPrefetch(queue, ptr, allocation_size,
                                         UR_USM_MIGRATION_FLAG_HOST_TO_DEVICE, 1,
                                         &inv_evt, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }
diff --git a/unified-runtime/test/conformance/enqueue/urEnqueueWriteHostPipe.cpp b/unified-runtime/test/conformance/enqueue/urEnqueueWriteHostPipe.cpp
index d2841e1017c83..dddae78629309 100644
--- a/unified-runtime/test/conformance/enqueue/urEnqueueWriteHostPipe.cpp
+++ b/unified-runtime/test/conformance/enqueue/urEnqueueWriteHostPipe.cpp
@@ -4,6 +4,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #include <uur/fixtures.h>
+#include <uur/raii.h>
 
 using urEnqueueWriteHostPipeTest = uur::urHostPipeTest;
 
@@ -70,19 +71,18 @@ TEST_P(urEnqueueWriteHostPipeTest, InvalidEventWaitList) {
                                           /*blocking*/ true, &buffer, size, 0,
                                           &phEventWaitList, phEvent));
 
-  ur_event_handle_t validEvent;
-  ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
+  uur::raii::Event eventDummy = nullptr;
+  ASSERT_SUCCESS(
+      urEventCreateWithNativeHandle(0, context, nullptr, eventDummy.ptr()));
 
   ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST,
                    urEnqueueWriteHostPipe(queue, program, pipe_symbol,
                                           /*blocking*/ true, &buffer, size, 0,
-                                          &validEvent, nullptr));
+                                          eventDummy.ptr(), nullptr));
 
   ur_event_handle_t inv_evt = nullptr;
   ASSERT_EQ_RESULT(urEnqueueWriteHostPipe(queue, program, pipe_symbol,
                                           /*blocking*/ true, &buffer, size, 1,
                                           &inv_evt, nullptr),
                    UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
-
-  ASSERT_SUCCESS(urEventRelease(validEvent));
 }

From b0f0eca638a09dab63c4db7a040179294aa8dfed Mon Sep 17 00:00:00 2001
From: Krzysztof Swiecicki <krzysztof.swiecicki@intel.com>
Date: Wed, 1 Apr 2026 14:38:52 +0000
Subject: [PATCH 2/2] Re-enable the enqueue mem buffer read tests

---
 unified-runtime/test/conformance/enqueue/CMakeLists.txt | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/unified-runtime/test/conformance/enqueue/CMakeLists.txt b/unified-runtime/test/conformance/enqueue/CMakeLists.txt
index 0ed9c0b62ed31..69df8bdb5844d 100644
--- a/unified-runtime/test/conformance/enqueue/CMakeLists.txt
+++ b/unified-runtime/test/conformance/enqueue/CMakeLists.txt
@@ -15,10 +15,8 @@ add_conformance_kernels_test(enqueue
     urEnqueueMemBufferCopy.cpp
     urEnqueueMemBufferFill.cpp
     urEnqueueMemBufferMap.cpp
-    # Enqueue memory buffer read tests ran simultenously lead to timeouts.
-    # Tracker: https://jira.devtools.intel.com/browse/URT-1026
-    # urEnqueueMemBufferRead.cpp
-    # urEnqueueMemBufferReadRect.cpp
+    urEnqueueMemBufferRead.cpp
+    urEnqueueMemBufferReadRect.cpp
     urEnqueueMemBufferWrite.cpp
     urEnqueueMemBufferWriteRect.cpp
     urEnqueueMemImageCopy.cpp