diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index cbb6468ab0..aaf50c1c0f 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -42,11 +42,8 @@ function(add_umf_benchmark)
         LIBS ${BENCH_LIBS})
 
     target_include_directories(
-        ${BENCH_NAME}
-        PRIVATE ${UMF_CMAKE_SOURCE_DIR}/include
-                ${UMF_CMAKE_SOURCE_DIR}/src/utils
-                ${UMF_CMAKE_SOURCE_DIR}/test/common
-                ${UMF_CMAKE_SOURCE_DIR}/examples/common)
+        ${BENCH_NAME} PRIVATE ${UMF_CMAKE_SOURCE_DIR}/include
+                              ${UMF_CMAKE_SOURCE_DIR}/src/utils)
 
     target_link_directories(${BENCH_NAME} PRIVATE ${ARG_LIBDIRS})
 
@@ -84,6 +81,9 @@ function(add_umf_benchmark)
     if(UMF_BUILD_LEVEL_ZERO_PROVIDER)
         target_compile_definitions(${BENCH_NAME}
                                    PRIVATE UMF_BUILD_LEVEL_ZERO_PROVIDER=1)
+        target_include_directories(
+            ${BENCH_NAME} PRIVATE ${UMF_CMAKE_SOURCE_DIR}/test/common
+                                  ${LEVEL_ZERO_INCLUDE_DIRS})
     endif()
     if(UMF_BUILD_CUDA_PROVIDER)
         target_compile_definitions(${BENCH_NAME}
@@ -108,6 +108,7 @@ if(LINUX)
     set(LIBS_OPTIONAL ${LIBS_OPTIONAL} m)
 endif()
 if(UMF_BUILD_GPU_TESTS AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
+    set(SRCS_OPTIONAL ${SRCS_OPTIONAL} ../src/utils/utils_level_zero.cpp)
     set(LIBS_OPTIONAL ${LIBS_OPTIONAL} ze_loader)
     # TODO add CUDA
 endif()
@@ -116,7 +117,7 @@ endif()
 
 add_umf_benchmark(
     NAME ubench
-    SRCS ubench.c
+    SRCS ubench.c ${SRCS_OPTIONAL}
     LIBS ${LIBS_OPTIONAL}
     LIBDIRS ${LIB_DIRS})
 
diff --git a/benchmark/ubench.c b/benchmark/ubench.c
index 1deabde0c6..142112e83a 100644
--- a/benchmark/ubench.c
+++ b/benchmark/ubench.c
@@ -450,28 +450,28 @@ int create_level_zero_params(ze_context_handle_t *context,
     uint32_t driver_idx = 0;
     ze_driver_handle_t driver = NULL;
 
-    int ret = init_level_zero();
+    int ret = utils_ze_init_level_zero();
     if (ret != 0) {
         fprintf(stderr, "Failed to init Level 0!\n");
         return ret;
     }
 
-    ret = find_driver_with_gpu(&driver_idx, &driver);
+    ret = utils_ze_find_driver_with_gpu(&driver_idx, &driver);
     if (ret || driver == NULL) {
         fprintf(stderr, "Cannot find L0 driver with GPU device!\n");
         return ret;
     }
 
-    ret = create_context(driver, context);
+    ret = utils_ze_create_context(driver, context);
     if (ret != 0) {
         fprintf(stderr, "Failed to create L0 context!\n");
         return ret;
     }
 
-    ret = find_gpu_device(driver, device);
+    ret = utils_ze_find_gpu_device(driver, device);
     if (ret) {
         fprintf(stderr, "Cannot find GPU device!\n");
-        destroy_context(*context);
+        utils_ze_destroy_context(*context);
         return ret;
     }
 
@@ -628,7 +628,7 @@ UBENCH_EX(ipc, disjoint_pool_with_level_zero_provider) {
     umfLevelZeroMemoryProviderParamsDestroy(level_zero_params);
 
 err_destroy_context:
-    destroy_context(context);
+    utils_ze_destroy_context(context);
 }
 #endif /* (defined UMF_BUILD_LIBUMF_POOL_DISJOINT && defined UMF_BUILD_LEVEL_ZERO_PROVIDER && defined UMF_BUILD_GPU_TESTS) */
 
diff --git a/examples/common/utils_level_zero.h b/examples/common/examples_level_zero.h
similarity index 100%
rename from examples/common/utils_level_zero.h
rename to examples/common/examples_level_zero.h
diff --git a/examples/common/utils_examples.h b/examples/common/examples_utils.h
similarity index 100%
rename from examples/common/utils_examples.h
rename to examples/common/examples_utils.h
diff --git a/examples/ipc_level_zero/ipc_level_zero.c b/examples/ipc_level_zero/ipc_level_zero.c
index fc93eb9305..c7b74171fe 100644
--- a/examples/ipc_level_zero/ipc_level_zero.c
+++ b/examples/ipc_level_zero/ipc_level_zero.c
@@ -14,7 +14,7 @@
 #include "umf/pools/pool_disjoint.h"
 #include "umf/providers/provider_level_zero.h"
 
-#include "utils_level_zero.h"
+#include "examples_level_zero.h"
 
 int create_level_zero_pool(ze_context_handle_t context,
                            ze_device_handle_t device,
diff --git a/examples/level_zero_shared_memory/level_zero_shared_memory.c b/examples/level_zero_shared_memory/level_zero_shared_memory.c
index d7f68168d8..725941f6e7 100644
--- a/examples/level_zero_shared_memory/level_zero_shared_memory.c
+++ b/examples/level_zero_shared_memory/level_zero_shared_memory.c
@@ -11,7 +11,7 @@
 #include <umf/pools/pool_disjoint.h>
 #include <umf/providers/provider_level_zero.h>
 
-#include "utils_level_zero.h"
+#include "examples_level_zero.h"
 
 int main(void) {
     // A result object for storing UMF API result status
diff --git a/examples/memspace_hmat/memspace_hmat.c b/examples/memspace_hmat/memspace_hmat.c
index 1a4cf154eb..9f3f8d17e9 100644
--- a/examples/memspace_hmat/memspace_hmat.c
+++ b/examples/memspace_hmat/memspace_hmat.c
@@ -15,7 +15,7 @@
 #include <stdio.h>
 #include <string.h>
 
-#include "utils_examples.h"
+#include "examples_utils.h"
 
 // Function to create a memory provider which allocates memory from the specified NUMA node
 int createMemoryProvider(umf_memory_provider_handle_t *hProvider,
diff --git a/examples/memspace_numa/memspace_numa.c b/examples/memspace_numa/memspace_numa.c
index e2c460f702..4f225cd694 100644
--- a/examples/memspace_numa/memspace_numa.c
+++ b/examples/memspace_numa/memspace_numa.c
@@ -15,7 +15,7 @@
 #include <stdio.h>
 #include <string.h>
 
-#include "utils_examples.h"
+#include "examples_utils.h"
 
 // Function to create a memory provider which allocates memory from the specified NUMA node
 // by using umfMemspaceCreateFromNumaArray
diff --git a/test/providers/level_zero_helpers.cpp b/src/utils/utils_level_zero.cpp
similarity index 92%
rename from test/providers/level_zero_helpers.cpp
rename to src/utils/utils_level_zero.cpp
index cd387ab913..833047dd79 100644
--- a/test/providers/level_zero_helpers.cpp
+++ b/src/utils/utils_level_zero.cpp
@@ -5,7 +5,7 @@
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  */
 
-#include "level_zero_helpers.h"
+#include "utils_level_zero.h"
 
 #include <memory>
 #include <stdlib.h>
@@ -297,7 +297,7 @@ int InitLevelZeroOps() {
 }
 #endif // USE_DLOPEN
 
-static int init_level_zero_lib(void) {
+static int utils_ze_init_level_zero_lib(void) {
     ze_init_flag_t flags = ZE_INIT_FLAG_GPU_ONLY;
     ze_result_t result = libze_ops.zeInit(flags);
     if (result != ZE_RESULT_SUCCESS) {
@@ -306,31 +306,33 @@ static int init_level_zero_lib(void) {
     return 0;
 }
 
-UTIL_ONCE_FLAG level_zero_init_flag;
-int InitResult;
-void init_level_zero_once() {
+static UTIL_ONCE_FLAG level_zero_init_flag = UTIL_ONCE_FLAG_INIT;
+static int InitResult;
+
+static void utils_ze_init_level_zero_once(void) {
     InitResult = InitLevelZeroOps();
     if (InitResult != 0) {
         return;
     }
-    InitResult = init_level_zero_lib();
+    InitResult = utils_ze_init_level_zero_lib();
 }
 
-int init_level_zero() {
-    utils_init_once(&level_zero_init_flag, init_level_zero_once);
+int utils_ze_init_level_zero(void) {
+    utils_init_once(&level_zero_init_flag, utils_ze_init_level_zero_once);
 
     return InitResult;
 }
 
-int get_drivers(uint32_t *drivers_num_, ze_driver_handle_t **drivers_) {
+int utils_ze_get_drivers(uint32_t *drivers_num_,
+                         ze_driver_handle_t **drivers_) {
     int ret = 0;
     ze_result_t ze_result;
     ze_driver_handle_t *drivers = NULL;
     uint32_t drivers_num = 0;
 
-    ret = init_level_zero();
+    ret = utils_ze_init_level_zero();
     if (ret != 0) {
-        fprintf(stderr, "init_level_zero() failed!\n");
+        fprintf(stderr, "utils_ze_init_level_zero() failed!\n");
         goto init_fail;
     }
 
@@ -374,16 +376,16 @@ int get_drivers(uint32_t *drivers_num_, ze_driver_handle_t **drivers_) {
     return ret;
 }
 
-int get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
-                ze_device_handle_t **devices_) {
+int utils_ze_get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
+                         ze_device_handle_t **devices_) {
     ze_result_t ze_result;
     int ret = 0;
     uint32_t devices_num = 0;
     ze_device_handle_t *devices = NULL;
 
-    ret = init_level_zero();
+    ret = utils_ze_init_level_zero();
     if (ret != 0) {
-        fprintf(stderr, "init_level_zero() failed!\n");
+        fprintf(stderr, "utils_ze_init_level_zero() failed!\n");
         goto init_fail;
     }
 
@@ -426,7 +428,8 @@ int get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
     return ret;
 }
 
-int find_driver_with_gpu(uint32_t *driver_idx, ze_driver_handle_t *driver_) {
+int utils_ze_find_driver_with_gpu(uint32_t *driver_idx,
+                                  ze_driver_handle_t *driver_) {
     int ret = 0;
     ze_result_t ze_result;
     uint32_t drivers_num = 0;
@@ -434,7 +437,7 @@ int find_driver_with_gpu(uint32_t *driver_idx, ze_driver_handle_t *driver_) {
     ze_driver_handle_t *drivers = NULL;
     ze_driver_handle_t driver_with_gpus = NULL;
 
-    ret = get_drivers(&drivers_num, &drivers);
+    ret = utils_ze_get_drivers(&drivers_num, &drivers);
     if (ret) {
         goto fn_fail;
     }
@@ -444,7 +447,7 @@ int find_driver_with_gpu(uint32_t *driver_idx, ze_driver_handle_t *driver_) {
         uint32_t devices_num = 0;
         ze_driver_handle_t driver = drivers[i];
 
-        ret = get_devices(driver, &devices_num, &devices);
+        ret = utils_ze_get_devices(driver, &devices_num, &devices);
         if (ret) {
             goto fn_fail;
         }
@@ -493,13 +496,14 @@ int find_driver_with_gpu(uint32_t *driver_idx, ze_driver_handle_t *driver_) {
     return ret;
 }
 
-int find_gpu_device(ze_driver_handle_t driver, ze_device_handle_t *device_) {
+int utils_ze_find_gpu_device(ze_driver_handle_t driver,
+                             ze_device_handle_t *device_) {
     int ret = -1;
     uint32_t devices_num = 0;
     ze_device_handle_t *devices = NULL;
     ze_device_handle_t device;
 
-    ret = get_devices(driver, &devices_num, &devices);
+    ret = utils_ze_get_devices(driver, &devices_num, &devices);
     if (ret) {
         return ret;
     }
@@ -531,9 +535,9 @@ int find_gpu_device(ze_driver_handle_t driver, ze_device_handle_t *device_) {
     return ret;
 }
 
-int level_zero_fill(ze_context_handle_t context, ze_device_handle_t device,
-                    void *ptr, size_t size, const void *pattern,
-                    size_t pattern_size) {
+int utils_ze_level_zero_fill(ze_context_handle_t context,
+                             ze_device_handle_t device, void *ptr, size_t size,
+                             const void *pattern, size_t pattern_size) {
     int ret = 0;
 
     ze_command_queue_desc_t commandQueueDesc = {
@@ -617,8 +621,9 @@ int level_zero_fill(ze_context_handle_t context, ze_device_handle_t device,
     return ret;
 }
 
-int level_zero_copy(ze_context_handle_t context, ze_device_handle_t device,
-                    void *dst_ptr, const void *src_ptr, size_t size) {
+int utils_ze_level_zero_copy(ze_context_handle_t context,
+                             ze_device_handle_t device, void *dst_ptr,
+                             const void *src_ptr, size_t size) {
     int ret = 0;
     ze_command_queue_desc_t commandQueueDesc = {
         ZE_STRUCTURE_TYPE_COMMAND_QUEUE_DESC,
@@ -700,7 +705,8 @@ int level_zero_copy(ze_context_handle_t context, ze_device_handle_t device,
     return ret;
 }
 
-int create_context(ze_driver_handle_t driver, ze_context_handle_t *context) {
+int utils_ze_create_context(ze_driver_handle_t driver,
+                            ze_context_handle_t *context) {
     ze_result_t ze_result;
     ze_context_desc_t ctxtDesc;
     ctxtDesc.stype = ZE_STRUCTURE_TYPE_CONTEXT_DESC;
@@ -716,7 +722,7 @@ int create_context(ze_driver_handle_t driver, ze_context_handle_t *context) {
     return 0;
 }
 
-int destroy_context(ze_context_handle_t context) {
+int utils_ze_destroy_context(ze_context_handle_t context) {
     ze_result_t ze_result;
     ze_result = libze_ops.zeContextDestroy(context);
     if (ze_result != ZE_RESULT_SUCCESS) {
@@ -727,7 +733,7 @@ int destroy_context(ze_context_handle_t context) {
     return 0;
 }
 
-ze_memory_type_t get_mem_type(ze_context_handle_t context, void *ptr) {
+ze_memory_type_t utils_ze_get_mem_type(ze_context_handle_t context, void *ptr) {
     ze_device_handle_t device = NULL;
     ze_memory_allocation_properties_t alloc_props;
     alloc_props.stype = ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES;
diff --git a/src/utils/utils_level_zero.h b/src/utils/utils_level_zero.h
new file mode 100644
index 0000000000..b29a4dc438
--- /dev/null
+++ b/src/utils/utils_level_zero.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ */
+
+#ifndef UMF_UTILS_LEVEL_ZERO_H
+#define UMF_UTILS_LEVEL_ZERO_H
+
+#include <umf/providers/provider_level_zero.h>
+
+#include "ze_api.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int utils_ze_init_level_zero(void);
+int utils_ze_init_level_zero(void);
+
+int utils_ze_get_drivers(uint32_t *drivers_num_, ze_driver_handle_t **drivers_);
+
+int utils_ze_get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
+                         ze_device_handle_t **devices_);
+
+int utils_ze_find_driver_with_gpu(uint32_t *driver_idx,
+                                  ze_driver_handle_t *driver_);
+
+int utils_ze_find_gpu_device(ze_driver_handle_t driver,
+                             ze_device_handle_t *device_);
+
+int utils_ze_level_zero_fill(ze_context_handle_t context,
+                             ze_device_handle_t device, void *ptr, size_t size,
+                             const void *pattern, size_t pattern_size);
+
+int utils_ze_level_zero_copy(ze_context_handle_t context,
+                             ze_device_handle_t device, void *dst_ptr,
+                             const void *src_ptr, size_t size);
+
+int utils_ze_create_context(ze_driver_handle_t driver,
+                            ze_context_handle_t *context);
+
+int utils_ze_destroy_context(ze_context_handle_t context);
+
+ze_memory_type_t utils_ze_get_mem_type(ze_context_handle_t context, void *ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UMF_UTILS_LEVEL_ZERO_H
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 6ce94654a9..c3a191b1dd 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -22,6 +22,7 @@ FetchContent_MakeAvailable(googletest)
 enable_testing()
 
 set(UMF_TEST_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+set(UMF_UTILS_DIR ${UMF_CMAKE_SOURCE_DIR}/src/utils)
 
 function(build_umf_test)
     # Parameters: * NAME - a name of the test * SRCS - source files * LIBS -
@@ -136,20 +137,22 @@ if(UMF_BUILD_SHARED_LIBRARY)
     set(UMF_UTILS_FOR_TEST umf_utils)
     if(LINUX OR MACOSX)
         set(UMF_UTILS_SOURCES
-            ../src/utils/utils_common.c ../src/utils/utils_posix_common.c
-            ../src/utils/utils_posix_concurrency.c)
+            ${UMF_UTILS_DIR}/utils_common.c
+            ${UMF_UTILS_DIR}/utils_posix_common.c
+            ${UMF_UTILS_DIR}/utils_posix_concurrency.c)
         if(LINUX)
             set(UMF_UTILS_SOURCES ${UMF_UTILS_SOURCES}
-                                  ../src/utils/utils_linux_common.c)
+                                  ${UMF_UTILS_DIR}/utils_linux_common.c)
             set(UMF_LOGGER_LIBS rt) # librt for shm_open()
         elseif(MACOSX)
             set(UMF_UTILS_SOURCES ${UMF_UTILS_SOURCES}
-                                  ../src/utils/utils_macosx_common.c)
+                                  ${UMF_UTILS_DIR}/utils_macosx_common.c)
         endif()
     elseif(WINDOWS)
         set(UMF_UTILS_SOURCES
-            ../src/utils/utils_common.c ../src/utils/utils_windows_common.c
-            ../src/utils/utils_windows_concurrency.c)
+            ${UMF_UTILS_DIR}/utils_common.c
+            ${UMF_UTILS_DIR}/utils_windows_common.c
+            ${UMF_UTILS_DIR}/utils_windows_concurrency.c)
     endif()
 endif()
 
@@ -358,16 +361,16 @@ if(UMF_BUILD_GPU_TESTS AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
     # dlopen)
     add_umf_test(
         NAME provider_level_zero
-        SRCS providers/provider_level_zero.cpp providers/level_zero_helpers.cpp
-             ${BA_SOURCES_FOR_TEST}
+        SRCS providers/provider_level_zero.cpp
+             ${UMF_UTILS_DIR}/utils_level_zero.cpp ${BA_SOURCES_FOR_TEST}
         LIBS ${UMF_UTILS_FOR_TEST} ze_loader)
     target_include_directories(umf_test-provider_level_zero
                                PRIVATE ${LEVEL_ZERO_INCLUDE_DIRS})
 
     add_umf_test(
         NAME provider_level_zero_dlopen
-        SRCS providers/provider_level_zero.cpp providers/level_zero_helpers.cpp
-             ${BA_SOURCES_FOR_TEST}
+        SRCS providers/provider_level_zero.cpp
+             ${UMF_UTILS_DIR}/utils_level_zero.cpp ${BA_SOURCES_FOR_TEST}
         LIBS ${UMF_UTILS_FOR_TEST})
     target_compile_definitions(umf_test-provider_level_zero_dlopen
                                PUBLIC USE_DLOPEN=1)
@@ -580,7 +583,7 @@ if(LINUX)
             providers/ipc_level_zero_prov_consumer.c
             common/ipc_common.c
             providers/ipc_level_zero_prov_common.c
-            providers/level_zero_helpers.cpp
+            ${UMF_UTILS_DIR}/utils_level_zero.cpp
             LIBS
             ze_loader
             disjoint_pool
@@ -592,7 +595,7 @@ if(LINUX)
             providers/ipc_level_zero_prov_producer.c
             common/ipc_common.c
             providers/ipc_level_zero_prov_common.c
-            providers/level_zero_helpers.cpp
+            ${UMF_UTILS_DIR}/utils_level_zero.cpp
             LIBS
             ze_loader
             disjoint_pool
diff --git a/test/providers/ipc_level_zero_prov_common.c b/test/providers/ipc_level_zero_prov_common.c
index 8b951cfc86..485cb41b57 100644
--- a/test/providers/ipc_level_zero_prov_common.c
+++ b/test/providers/ipc_level_zero_prov_common.c
@@ -6,7 +6,7 @@
  */
 
 #include "ipc_level_zero_prov_common.h"
-#include "level_zero_helpers.h"
+#include "utils_level_zero.h"
 
 #include <umf/providers/provider_level_zero.h>
 
@@ -14,8 +14,8 @@
 
 void memcopy(void *dst, const void *src, size_t size, void *context) {
     level_zero_copy_ctx_t *l0_params = (level_zero_copy_ctx_t *)context;
-    int ret =
-        level_zero_copy(l0_params->context, l0_params->device, dst, src, size);
+    int ret = utils_ze_level_zero_copy(l0_params->context, l0_params->device,
+                                       dst, src, size);
     if (ret != 0) {
         fprintf(stderr, "level_zero_copy failed with error %d\n", ret);
     }
diff --git a/test/providers/ipc_level_zero_prov_consumer.c b/test/providers/ipc_level_zero_prov_consumer.c
index 7fcb031cb6..8ec0648e4f 100644
--- a/test/providers/ipc_level_zero_prov_consumer.c
+++ b/test/providers/ipc_level_zero_prov_consumer.c
@@ -13,7 +13,7 @@
 
 #include "ipc_common.h"
 #include "ipc_level_zero_prov_common.h"
-#include "level_zero_helpers.h"
+#include "utils_level_zero.h"
 
 int main(int argc, char *argv[]) {
     if (argc < 2) {
@@ -27,21 +27,21 @@ int main(int argc, char *argv[]) {
     ze_device_handle_t hDevice = NULL;
     ze_context_handle_t hContext = NULL;
 
-    int ret = find_driver_with_gpu(&driver_idx, &hDriver);
+    int ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver);
     if (ret != 0 || hDriver == NULL) {
-        fprintf(stderr, "find_driver_with_gpu() failed!\n");
+        fprintf(stderr, "utils_ze_find_driver_with_gpu() failed!\n");
         return -1;
     }
 
-    ret = find_gpu_device(hDriver, &hDevice);
+    ret = utils_ze_find_gpu_device(hDriver, &hDevice);
     if (ret != 0 || hDevice == NULL) {
-        fprintf(stderr, "find_gpu_device() failed!\n");
+        fprintf(stderr, "utils_ze_find_gpu_device() failed!\n");
         return -1;
     }
 
-    ret = create_context(hDriver, &hContext);
+    ret = utils_ze_create_context(hDriver, &hContext);
     if (ret != 0) {
-        fprintf(stderr, "create_context() failed!\n");
+        fprintf(stderr, "utils_ze_create_context() failed!\n");
         return -1;
     }
 
@@ -103,7 +103,7 @@ int main(int argc, char *argv[]) {
     umfLevelZeroMemoryProviderParamsDestroy(l0_params);
 
 destroy_context:
-    destroy_context(hContext);
+    utils_ze_destroy_context(hContext);
 
     return ret;
 }
diff --git a/test/providers/ipc_level_zero_prov_producer.c b/test/providers/ipc_level_zero_prov_producer.c
index d9c672dee9..2a8fedc374 100644
--- a/test/providers/ipc_level_zero_prov_producer.c
+++ b/test/providers/ipc_level_zero_prov_producer.c
@@ -13,7 +13,7 @@
 
 #include "ipc_common.h"
 #include "ipc_level_zero_prov_common.h"
-#include "level_zero_helpers.h"
+#include "utils_level_zero.h"
 
 int main(int argc, char *argv[]) {
     if (argc < 2) {
@@ -27,21 +27,21 @@ int main(int argc, char *argv[]) {
     ze_device_handle_t hDevice = NULL;
     ze_context_handle_t hContext = NULL;
 
-    int ret = find_driver_with_gpu(&driver_idx, &hDriver);
+    int ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver);
     if (ret != 0 || hDriver == NULL) {
-        fprintf(stderr, "find_driver_with_gpu() failed!\n");
+        fprintf(stderr, "utils_ze_find_driver_with_gpu() failed!\n");
         return -1;
     }
 
-    ret = find_gpu_device(hDriver, &hDevice);
+    ret = utils_ze_find_gpu_device(hDriver, &hDevice);
     if (ret != 0 || hDevice == NULL) {
-        fprintf(stderr, "find_gpu_device() failed!\n");
+        fprintf(stderr, "utils_ze_find_gpu_device() failed!\n");
         return -1;
     }
 
-    ret = create_context(hDriver, &hContext);
+    ret = utils_ze_create_context(hDriver, &hContext);
     if (ret != 0) {
-        fprintf(stderr, "create_context() failed!\n");
+        fprintf(stderr, "utils_ze_create_context() failed!\n");
         return -1;
     }
 
@@ -103,7 +103,7 @@ int main(int argc, char *argv[]) {
     umfLevelZeroMemoryProviderParamsDestroy(l0_params);
 
 destroy_context:
-    destroy_context(hContext);
+    utils_ze_destroy_context(hContext);
 
     return ret;
 }
diff --git a/test/providers/level_zero_helpers.h b/test/providers/level_zero_helpers.h
deleted file mode 100644
index aa76f8f55b..0000000000
--- a/test/providers/level_zero_helpers.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * Copyright (C) 2024 Intel Corporation
- *
- * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
- * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
- */
-
-#ifndef UMF_TEST_LEVEL_ZERO_HELPERS_H
-#define UMF_TEST_LEVEL_ZERO_HELPERS_H
-
-#include <umf/providers/provider_level_zero.h>
-
-#include "ze_api.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int get_drivers(uint32_t *drivers_num_, ze_driver_handle_t **drivers_);
-
-int get_devices(ze_driver_handle_t driver, uint32_t *devices_num_,
-                ze_device_handle_t **devices_);
-
-int find_driver_with_gpu(uint32_t *driver_idx, ze_driver_handle_t *driver_);
-
-int find_gpu_device(ze_driver_handle_t driver, ze_device_handle_t *device_);
-
-int level_zero_fill(ze_context_handle_t context, ze_device_handle_t device,
-                    void *ptr, size_t size, const void *pattern,
-                    size_t pattern_size);
-
-int level_zero_copy(ze_context_handle_t context, ze_device_handle_t device,
-                    void *dst_ptr, const void *src_ptr, size_t size);
-
-int create_context(ze_driver_handle_t driver, ze_context_handle_t *context);
-
-int destroy_context(ze_context_handle_t context);
-
-ze_memory_type_t get_mem_type(ze_context_handle_t context, void *ptr);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // UMF_TEST_LEVEL_ZERO_HELPERS_H
diff --git a/test/providers/provider_level_zero.cpp b/test/providers/provider_level_zero.cpp
index 06742d102b..d0584777be 100644
--- a/test/providers/provider_level_zero.cpp
+++ b/test/providers/provider_level_zero.cpp
@@ -12,8 +12,8 @@
 #include <umf/providers/provider_level_zero.h>
 
 #include "ipcFixtures.hpp"
-#include "level_zero_helpers.h"
 #include "pool.hpp"
+#include "utils_level_zero.h"
 #include "utils_load_library.h"
 
 using umf_test::test;
@@ -25,7 +25,7 @@ class LevelZeroTestHelper {
 
     ~LevelZeroTestHelper() {
         if (hContext_) {
-            destroy_context(hContext_);
+            utils_ze_destroy_context(hContext_);
         }
     }
 
@@ -42,21 +42,21 @@ class LevelZeroTestHelper {
 LevelZeroTestHelper::LevelZeroTestHelper() {
     uint32_t driver_idx = 0;
 
-    int ret = find_driver_with_gpu(&driver_idx, &hDriver_);
+    int ret = utils_ze_find_driver_with_gpu(&driver_idx, &hDriver_);
     if (ret != 0 || hDriver_ == NULL) {
-        fprintf(stderr, "find_driver_with_gpu() failed!\n");
+        fprintf(stderr, "utils_ze_find_driver_with_gpu() failed!\n");
         return;
     }
 
-    ret = find_gpu_device(hDriver_, &hDevice_);
+    ret = utils_ze_find_gpu_device(hDriver_, &hDevice_);
     if (ret != 0 || hDevice_ == NULL) {
-        fprintf(stderr, "find_gpu_device() failed!\n");
+        fprintf(stderr, "utils_ze_find_gpu_device() failed!\n");
         return;
     }
 
-    ret = create_context(hDriver_, &hContext_);
+    ret = utils_ze_create_context(hDriver_, &hContext_);
     if (ret != 0) {
-        fprintf(stderr, "create_context() failed!\n");
+        fprintf(stderr, "utils_ze_create_context() failed!\n");
         return;
     }
 }
@@ -218,8 +218,8 @@ class LevelZeroMemoryAccessor : public MemoryAccessor {
               size_t pattern_size) {
         ASSERT_NE(ptr, nullptr);
 
-        int ret = level_zero_fill(hContext_, hDevice_, ptr, size, pattern,
-                                  pattern_size);
+        int ret = utils_ze_level_zero_fill(hContext_, hDevice_, ptr, size,
+                                           pattern, pattern_size);
         ASSERT_EQ(ret, 0);
     }
 
@@ -227,7 +227,8 @@ class LevelZeroMemoryAccessor : public MemoryAccessor {
         ASSERT_NE(dst_ptr, nullptr);
         ASSERT_NE(src_ptr, nullptr);
 
-        int ret = level_zero_copy(hContext_, hDevice_, dst_ptr, src_ptr, size);
+        int ret = utils_ze_level_zero_copy(hContext_, hDevice_, dst_ptr,
+                                           src_ptr, size);
         ASSERT_EQ(ret, 0);
     }
 
@@ -301,7 +302,7 @@ TEST_P(umfLevelZeroProviderTest, basic) {
     // use the allocated memory - fill it with a 0xAB pattern
     memAccessor->fill(ptr, size, &pattern, sizeof(pattern));
 
-    ze_memory_type_t zeMemoryTypeActual = get_mem_type(hContext, ptr);
+    ze_memory_type_t zeMemoryTypeActual = utils_ze_get_mem_type(hContext, ptr);
     ASSERT_EQ(zeMemoryTypeActual, zeMemoryTypeExpected);
 
     // check if the pattern was successfully applied