diff --git a/unified-runtime/scripts/templates/helper.py b/unified-runtime/scripts/templates/helper.py
index a7688167d89f3..f6a0eec09af73 100644
--- a/unified-runtime/scripts/templates/helper.py
+++ b/unified-runtime/scripts/templates/helper.py
@@ -1890,18 +1890,22 @@ def _get_create_get_retain_release_functions(specs, namespace, tags):
                 funcs.append(make_func_name(namespace, tags, obj))
 
     create_suffixes = r"(Create[A-Za-z]*){1}$"
+    enqueue_prefixes = r"(Enqueue){1}"
     get_suffixes = r"(Get){1}$"
     retain_suffixes = r"(Retain){1}$"
     release_suffixes = r"(Release){1}$"
     common_prefix = r"^" + namespace
 
     create_exp = common_prefix + r"[A-Za-z]+" + create_suffixes
+    enqueue_exp = common_prefix + enqueue_prefixes + r"[A-Za-z]+$"
     get_exp = common_prefix + r"[A-Za-z]+" + get_suffixes
     retain_exp = common_prefix + r"[A-Za-z]+" + retain_suffixes
     release_exp = common_prefix + r"[A-Za-z]+" + release_suffixes
 
     create_funcs, get_funcs, retain_funcs, release_funcs = (
-        list(filter(lambda f: re.match(create_exp, f), funcs)),
+        list(
+            filter(lambda f: re.match(create_exp, f) or re.match(enqueue_exp, f), funcs)
+        ),
         list(filter(lambda f: re.match(get_exp, f), funcs)),
         list(filter(lambda f: re.match(retain_exp, f), funcs)),
         list(filter(lambda f: re.match(release_exp, f), funcs)),
@@ -1934,10 +1938,17 @@ def get_handle_create_get_retain_release_functions(specs, namespace, tags):
             continue
 
         class_type = subt(namespace, tags, h["class"])
-        create_funcs = list(filter(lambda f: class_type in f, funcs["create"]))
-        get_funcs = list(filter(lambda f: class_type in f, funcs["get"]))
-        retain_funcs = list(filter(lambda f: class_type in f, funcs["retain"]))
-        release_funcs = list(filter(lambda f: class_type in f, funcs["release"]))
+
+        prefixes = [class_type]
+        if class_type == namespace + "Event":
+            prefixes.append(namespace + "Enqueue")
+            # Functions prefixed with $xEnqueue are also 'create' functions for event handles
+
+        has_prefix = lambda f: any(p in f for p in prefixes)
+        create_funcs = list(filter(has_prefix, funcs["create"]))
+        get_funcs = list(filter(has_prefix, funcs["get"]))
+        retain_funcs = list(filter(has_prefix, funcs["retain"]))
+        release_funcs = list(filter(has_prefix, funcs["release"]))
 
         record = {}
         record["handle"] = subt(namespace, tags, h["name"])
@@ -1953,7 +1964,7 @@ def get_handle_create_get_retain_release_functions(specs, namespace, tags):
 
 """
 Public:
-    returns a list of objects representing functions that accept $x_queue_handle_t as a first param 
+    returns a list of objects representing functions that accept $x_queue_handle_t as a first param
 """
 
 
diff --git a/unified-runtime/scripts/templates/valddi.cpp.mako b/unified-runtime/scripts/templates/valddi.cpp.mako
index 6ea8510c8c560..574ea09fb9225 100644
--- a/unified-runtime/scripts/templates/valddi.cpp.mako
+++ b/unified-runtime/scripts/templates/valddi.cpp.mako
@@ -11,7 +11,7 @@ from templates import helper as th
     handle_create_get_retain_release_funcs=th.get_handle_create_get_retain_release_functions(specs, n, tags)
 %>/*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
  * Exceptions.
@@ -117,9 +117,14 @@ namespace ur_validation_layer
         <%
             tp_handle_funcs = next((hf for hf in handle_create_get_retain_release_funcs if th.subt(n, tags, tp['type']) in [hf['handle'], hf['handle'] + "*"]), None)
             is_handle_to_adapter = ("_adapter_handle_t" in tp['type'])
+            is_handle_to_event = ("_event_handle_t" in tp['type'])
         %>
         %if func_name in tp_handle_funcs['create']:
-        if( getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS )
+        if( getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS
+        %if is_handle_to_event:
+            && ${tp['name']}
+        %endif
+        )
         {
             getContext()->refCountContext->createRefCount(*${tp['name']});
         }
@@ -236,7 +241,7 @@ namespace ur_validation_layer
         if (enableLeakChecking) {
             getContext()->refCountContext->logInvalidReferences();
         }
-        
+
         return ${X}_RESULT_SUCCESS;
     }
 
diff --git a/unified-runtime/source/loader/layers/validation/ur_valddi.cpp b/unified-runtime/source/loader/layers/validation/ur_valddi.cpp
index 10e630ef1fbbd..7f85aa05048e2 100644
--- a/unified-runtime/source/loader/layers/validation/ur_valddi.cpp
+++ b/unified-runtime/source/loader/layers/validation/ur_valddi.cpp
@@ -1,6 +1,6 @@
 /*
  *
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * Part of the Unified-Runtime Project, under the Apache License v2.0 with LLVM
  * Exceptions.
@@ -4344,7 +4344,8 @@ __urdlllocal ur_result_t UR_APICALL urEventCreateWithNativeHandle(
   ur_result_t result =
       pfnCreateWithNativeHandle(hNativeEvent, hContext, pProperties, phEvent);
 
-  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS) {
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
     getContext()->refCountContext->createRefCount(*phEvent);
   }
 
@@ -4474,6 +4475,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueKernelLaunch(
       hQueue, hKernel, workDim, pGlobalWorkOffset, pGlobalWorkSize,
       pLocalWorkSize, numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -4527,6 +4533,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueEventsWait(
   ur_result_t result =
       pfnEventsWait(hQueue, numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -4581,6 +4592,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueEventsWaitWithBarrier(
   ur_result_t result = pfnEventsWaitWithBarrier(hQueue, numEventsInWaitList,
                                                 phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -4662,6 +4678,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferRead(
       pfnMemBufferRead(hQueue, hBuffer, blockingRead, offset, size, pDst,
                        numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -4743,6 +4764,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferWrite(
       pfnMemBufferWrite(hQueue, hBuffer, blockingWrite, offset, size, pSrc,
                         numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -4867,6 +4893,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferReadRect(
       bufferRowPitch, bufferSlicePitch, hostRowPitch, hostSlicePitch, pDst,
       numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -4992,6 +5023,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferWriteRect(
       bufferRowPitch, bufferSlicePitch, hostRowPitch, hostSlicePitch, pSrc,
       numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -5085,6 +5121,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferCopy(
       pfnMemBufferCopy(hQueue, hBufferSrc, hBufferDst, srcOffset, dstOffset,
                        size, numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -5215,6 +5256,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferCopyRect(
       srcSlicePitch, dstRowPitch, dstSlicePitch, numEventsInWaitList,
       phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -5311,6 +5357,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferFill(
       pfnMemBufferFill(hQueue, hBuffer, pPattern, patternSize, offset, size,
                        numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -5400,6 +5451,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageRead(
       hQueue, hImage, blockingRead, origin, region, rowPitch, slicePitch, pDst,
       numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -5489,6 +5545,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageWrite(
       hQueue, hImage, blockingWrite, origin, region, rowPitch, slicePitch, pSrc,
       numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -5588,6 +5649,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemImageCopy(
       pfnMemImageCopy(hQueue, hImageSrc, hImageDst, srcOrigin, dstOrigin,
                       region, numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -5675,6 +5741,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemBufferMap(
       pfnMemBufferMap(hQueue, hBuffer, blockingMap, mapFlags, offset, size,
                       numEventsInWaitList, phEventWaitList, phEvent, ppRetMap);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -5742,6 +5813,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueMemUnmap(
   ur_result_t result = pfnMemUnmap(
       hQueue, hMem, pMappedPtr, numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -5826,6 +5902,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMFill(
       pfnUSMFill(hQueue, pMem, patternSize, pPattern, size, numEventsInWaitList,
                  phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -5910,6 +5991,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMMemcpy(
       pfnUSMMemcpy(hQueue, blocking, pDst, pSrc, size, numEventsInWaitList,
                    phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -5984,6 +6070,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMPrefetch(
   ur_result_t result = pfnUSMPrefetch(
       hQueue, pMem, size, flags, numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -6035,6 +6126,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMAdvise(
 
   ur_result_t result = pfnUSMAdvise(hQueue, pMem, size, advice, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -6325,6 +6421,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableWrite(
       hQueue, hProgram, name, blockingWrite, count, offset, pSrc,
       numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -6406,6 +6507,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueDeviceGlobalVariableRead(
       hQueue, hProgram, name, blockingRead, count, offset, pDst,
       numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -6488,6 +6594,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueReadHostPipe(
       pfnReadHostPipe(hQueue, hProgram, pipe_symbol, blocking, pDst, size,
                       numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -6571,6 +6682,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueWriteHostPipe(
       pfnWriteHostPipe(hQueue, hProgram, pipe_symbol, blocking, pSrc, size,
                        numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -6637,6 +6753,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMDeviceAllocExp(
                                             numEventsInWaitList,
                                             phEventWaitList, ppMem, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -6703,6 +6824,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMSharedAllocExp(
                                             numEventsInWaitList,
                                             phEventWaitList, ppMem, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -6769,6 +6895,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMHostAllocExp(
       pfnUSMHostAllocExp(hQueue, pPool, size, pProperties, numEventsInWaitList,
                          phEventWaitList, ppMem, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -6825,6 +6956,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueUSMFreeExp(
   ur_result_t result = pfnUSMFreeExp(hQueue, pPool, pMem, numEventsInWaitList,
                                      phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -9501,6 +9637,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueCommandBufferExp(
   ur_result_t result = pfnCommandBufferExp(
       hQueue, hCommandBuffer, numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -9766,6 +9907,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueCooperativeKernelLaunchExp(
       hQueue, hKernel, workDim, pGlobalWorkOffset, pGlobalWorkSize,
       pLocalWorkSize, numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -9890,6 +10036,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueTimestampRecordingExp(
   ur_result_t result = pfnTimestampRecordingExp(
       hQueue, blocking, numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -9978,6 +10129,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueKernelLaunchCustomExp(
       pLocalWorkSize, numPropsInLaunchPropList, launchPropList,
       numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -10364,6 +10520,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueEventsWaitWithBarrierExt(
   ur_result_t result = pfnEventsWaitWithBarrierExt(
       hQueue, pProperties, numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
@@ -10435,6 +10596,11 @@ __urdlllocal ur_result_t UR_APICALL urEnqueueNativeCommandExp(
       hQueue, pfnNativeEnqueue, data, numMemsInMemList, phMemList, pProperties,
       numEventsInWaitList, phEventWaitList, phEvent);
 
+  if (getContext()->enableLeakChecking && result == UR_RESULT_SUCCESS &&
+      phEvent) {
+    getContext()->refCountContext->createRefCount(*phEvent);
+  }
+
   return result;
 }
 
diff --git a/unified-runtime/test/layers/validation/leaks.cpp b/unified-runtime/test/layers/validation/leaks.cpp
index 0d89c50bd3b4e..eeadb5f99dfa5 100644
--- a/unified-runtime/test/layers/validation/leaks.cpp
+++ b/unified-runtime/test/layers/validation/leaks.cpp
@@ -7,6 +7,7 @@
 #include "fixtures.hpp"
 
 #include <ur_mock_helpers.hpp>
+#include <uur/fixtures.h>
 
 // We need a fake handle for the below adapter leak test.
 inline ur_result_t fakeAdapter_urAdapterGet(void *pParams) {
@@ -15,7 +16,7 @@ inline ur_result_t fakeAdapter_urAdapterGet(void *pParams) {
   return UR_RESULT_SUCCESS;
 }
 
-class adapterLeakTest : public urTest {
+struct adapterLeakTest : public urTest {
   void SetUp() override {
     urTest::SetUp();
     mock::getCallbacks().set_replace_callback("urAdapterGet",
@@ -30,6 +31,51 @@ class adapterLeakTest : public urTest {
   }
 };
 
+inline ur_result_t fakeQueue_urQueueCreate(void *pParams) {
+  const auto &params = *static_cast<ur_queue_create_params_t *>(pParams);
+  **params.pphQueue = reinterpret_cast<ur_queue_handle_t>(0x4a);
+  return UR_RESULT_SUCCESS;
+}
+
+inline ur_result_t fakeQueue_urEnqueueEventsWait(void *pParams) {
+  const auto &params = *static_cast<ur_enqueue_events_wait_params_t *>(pParams);
+  **params.pphEvent = reinterpret_cast<ur_event_handle_t>(0x4b);
+  return UR_RESULT_SUCCESS;
+}
+
+struct queueLeakTest : public valDeviceTest {
+  void SetUp() override {
+    valDeviceTest::SetUp();
+    mock::getCallbacks().set_replace_callback("urQueueCreate",
+                                              &fakeQueue_urQueueCreate);
+    mock::getCallbacks().set_replace_callback("urQueueRelease",
+                                              &genericSuccessCallback);
+    mock::getCallbacks().set_replace_callback("urEnqueueEventsWait",
+                                              &fakeQueue_urEnqueueEventsWait);
+    mock::getCallbacks().set_replace_callback("urEventRelease",
+                                              &genericSuccessCallback);
+
+    ASSERT_EQ(urContextCreate(1, &device, nullptr, &context),
+              UR_RESULT_SUCCESS);
+    ASSERT_NE(nullptr, context);
+
+    ASSERT_EQ(urQueueCreate(context, device, nullptr, &queue),
+              UR_RESULT_SUCCESS);
+    ASSERT_NE(nullptr, context);
+  }
+
+  void TearDown() override {
+    ASSERT_EQ(urQueueRelease(queue), UR_RESULT_SUCCESS);
+    ASSERT_EQ(urContextRelease(context), UR_RESULT_SUCCESS);
+
+    mock::getCallbacks().resetCallbacks();
+    valDeviceTest::TearDown();
+  }
+
+  ur_context_handle_t context;
+  ur_queue_handle_t queue;
+};
+
 TEST_F(adapterLeakTest, testUrAdapterGetLeak) {
   ur_adapter_handle_t adapter = nullptr;
   ASSERT_EQ(urAdapterGet(1, &adapter, nullptr), UR_RESULT_SUCCESS);
@@ -95,3 +141,19 @@ TEST_F(valDeviceTest, testUrContextReleaseNonexistent) {
   ur_context_handle_t context = (ur_context_handle_t)0xC0FFEE;
   ASSERT_EQ(urContextRelease(context), UR_RESULT_SUCCESS);
 }
+
+TEST_F(queueLeakTest, testUrEnqueueSuccess) {
+  ur_event_handle_t event = nullptr;
+  ASSERT_EQ(urEnqueueEventsWait(queue, 0, nullptr, &event), UR_RESULT_SUCCESS);
+  ASSERT_EQ(urEventRelease(event), UR_RESULT_SUCCESS);
+}
+
+TEST_F(queueLeakTest, testUrEnqueueLeak) {
+  ur_event_handle_t event = nullptr;
+  ASSERT_EQ(urEnqueueEventsWait(queue, 0, nullptr, &event), UR_RESULT_SUCCESS);
+}
+
+TEST_F(queueLeakTest, testUrEventReleaseNonexistent) {
+  ur_event_handle_t event = (ur_event_handle_t)0xBEEF;
+  ASSERT_EQ(urEventRelease(event), UR_RESULT_SUCCESS);
+}
diff --git a/unified-runtime/test/layers/validation/leaks.out.match b/unified-runtime/test/layers/validation/leaks.out.match
index 431ad52cef225..07c97bed102ce 100644
--- a/unified-runtime/test/layers/validation/leaks.out.match
+++ b/unified-runtime/test/layers/validation/leaks.out.match
@@ -79,3 +79,42 @@
 <VALIDATION>[ERROR]: Retained -1 reference(s) to handle {{[0-9xa-fA-F]+}}
 <VALIDATION>[ERROR]: Handle {{[0-9xa-fA-F]+}} was recorded for first time here:
 {{IGNORE}}
+[ RUN      ] queueLeakTest.testUrEnqueueSuccess
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 1
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 1
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 1
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 1
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 1
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 0
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 0
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 0
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 0
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 0
+{{IGNORE}}
+[ RUN      ] queueLeakTest.testUrEnqueueLeak
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 1
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 1
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 1
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 1
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 1
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 0
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 0
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 0
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 0
+<VALIDATION>[ERROR]: Retained 1 reference(s) to handle {{[0-9xa-fA-F]+}}
+<VALIDATION>[ERROR]: Handle {{[0-9xa-fA-F]+}} was recorded for first time here:
+{{IGNORE}}
+[ RUN      ] queueLeakTest.testUrEventReleaseNonexistent
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 1
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 1
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 1
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 1
+<VALIDATION>[ERROR]: Attempting to release nonexistent handle {{[0-9xa-fA-F]+}}
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to -1
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 0
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 0
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 0
+<VALIDATION>[DEBUG]: Reference count for handle {{[0-9xa-fA-F]+}} changed to 0
+<VALIDATION>[ERROR]: Retained -1 reference(s) to handle {{[0-9xa-fA-F]+}}
+<VALIDATION>[ERROR]: Handle {{[0-9xa-fA-F]+}} was recorded for first time here:
+{{IGNORE}}