diff --git a/level_zero/api/core/ze_core_loader.cpp b/level_zero/api/core/ze_core_loader.cpp
index 5a45b36029..bd362fb11b 100644
--- a/level_zero/api/core/ze_core_loader.cpp
+++ b/level_zero/api/core/ze_core_loader.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2019-2020 Intel Corporation
+ * Copyright (C) 2019-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -22,8 +22,9 @@ zeGetDriverProcAddrTable(
     ze_driver_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
     ze_result_t result = ZE_RESULT_SUCCESS;
     pDdiTable->pfnGet = zeDriverGet;
@@ -48,8 +49,9 @@ zeGetMemProcAddrTable(
     ze_mem_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
     ze_result_t result = ZE_RESULT_SUCCESS;
@@ -83,8 +85,9 @@ zeGetContextProcAddrTable(
     ze_context_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
 
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
@@ -118,8 +121,9 @@ zeGetPhysicalMemProcAddrTable(
     ze_physical_mem_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
 
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
@@ -141,8 +145,9 @@ zeGetVirtualMemProcAddrTable(
     ze_virtual_mem_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
     ze_result_t result = ZE_RESULT_SUCCESS;
@@ -173,8 +178,9 @@ zeGetGlobalProcAddrTable(
     ze_global_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
     ze_result_t result = ZE_RESULT_SUCCESS;
@@ -192,8 +198,9 @@ zeGetDeviceProcAddrTable(
     ze_device_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
     ze_result_t result = ZE_RESULT_SUCCESS;
@@ -237,8 +244,9 @@ zeGetCommandQueueProcAddrTable(
     ze_command_queue_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
     ze_result_t result = ZE_RESULT_SUCCESS;
@@ -262,8 +270,9 @@ zeGetCommandListProcAddrTable(
     ze_command_list_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
     ze_result_t result = ZE_RESULT_SUCCESS;
@@ -331,8 +340,9 @@ zeGetFenceProcAddrTable(
     ze_fence_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
     ze_result_t result = ZE_RESULT_SUCCESS;
@@ -358,8 +368,9 @@ zeGetEventPoolProcAddrTable(
     ze_event_pool_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
     ze_result_t result = ZE_RESULT_SUCCESS;
@@ -385,8 +396,9 @@ zeGetEventProcAddrTable(
     ze_event_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
     ze_result_t result = ZE_RESULT_SUCCESS;
@@ -416,8 +428,9 @@ zeGetImageProcAddrTable(
     ze_image_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
     ze_result_t result = ZE_RESULT_SUCCESS;
@@ -439,8 +452,9 @@ zeGetModuleProcAddrTable(
     ze_module_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
     ze_result_t result = ZE_RESULT_SUCCESS;
@@ -472,8 +486,9 @@ zeGetModuleBuildLogProcAddrTable(
     ze_module_build_log_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
     ze_result_t result = ZE_RESULT_SUCCESS;
@@ -493,8 +508,9 @@ zeGetKernelProcAddrTable(
     ze_kernel_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
     ze_result_t result = ZE_RESULT_SUCCESS;
@@ -534,8 +550,9 @@ zeGetSamplerProcAddrTable(
     ze_sampler_dditable_t *pDdiTable) {
     if (nullptr == pDdiTable)
         return ZE_RESULT_ERROR_INVALID_ARGUMENT;
-    if (driver_ddiTable.version < version)
-        return ZE_RESULT_ERROR_UNKNOWN;
+    if (ZE_MAJOR_VERSION(driver_ddiTable.version) != ZE_MAJOR_VERSION(version) ||
+        ZE_MINOR_VERSION(driver_ddiTable.version) > ZE_MINOR_VERSION(version))
+        return ZE_RESULT_ERROR_UNSUPPORTED_VERSION;
     driver_ddiTable.enableTracing = getenv_tobool("ZET_ENABLE_API_TRACING_EXP");
 
     ze_result_t result = ZE_RESULT_SUCCESS;
diff --git a/level_zero/core/test/unit_tests/sources/loader/CMakeLists.txt b/level_zero/core/test/unit_tests/sources/loader/CMakeLists.txt
new file mode 100644
index 0000000000..ef16e0e0c0
--- /dev/null
+++ b/level_zero/core/test/unit_tests/sources/loader/CMakeLists.txt
@@ -0,0 +1,10 @@
+#
+# Copyright (C) 2021 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+target_sources(${TARGET_NAME} PRIVATE
+               ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+               ${CMAKE_CURRENT_SOURCE_DIR}/test_loader.cpp
+)
diff --git a/level_zero/core/test/unit_tests/sources/loader/test_loader.cpp b/level_zero/core/test/unit_tests/sources/loader/test_loader.cpp
new file mode 100644
index 0000000000..f4426f6479
--- /dev/null
+++ b/level_zero/core/test/unit_tests/sources/loader/test_loader.cpp
@@ -0,0 +1,358 @@
+/*
+ * Copyright (C) 2021 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "test.h"
+
+#include <level_zero/ze_api.h>
+
+#include "ze_ddi_tables.h"
+
+namespace L0 {
+namespace ult {
+
+TEST(zeGetDriverProcAddrTableTest,
+     whenCallingZeGetDriverProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_driver_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetDriverProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetMemProcAddrTableTest,
+     whenCallingZeGetMemProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_mem_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetMemProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetContextProcAddrTableTest,
+     whenCallingZeGetContextProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_context_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetContextProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetPhysicalMemProcAddrTableTest,
+     whenCallingZeGetPhysicalMemProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_physical_mem_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetPhysicalMemProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetVirtualMemProcAddrTableTest,
+     whenCallingZeGetVirtualMemProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_virtual_mem_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetVirtualMemProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetGlobalProcAddrTableTest,
+     whenCallingZeGetGlobalProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_global_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetGlobalProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetDeviceProcAddrTableTest,
+     whenCallingZeGetDeviceProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_device_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetDeviceProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetCommandQueueProcAddrTableTest,
+     whenCallingZeGetCommandQueueProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_command_queue_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetCommandQueueProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetCommandListProcAddrTableTest,
+     whenCallingZeGetCommandListProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_command_list_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetCommandListProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetFenceProcAddrTableTest,
+     whenCallingZeGetFenceProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_fence_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetFenceProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetEventPoolProcAddrTableTest,
+     whenCallingZeGetEventPoolProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_event_pool_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetEventPoolProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetEventProcAddrTableTest,
+     whenCallingZeGetEventProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_event_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetEventProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetImageProcAddrTableTest,
+     whenCallingZeGetImageProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_image_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetImageProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetModuleProcAddrTableTest,
+     whenCallingZeGetModuleProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_module_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetModuleProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetModuleBuildLogProcAddrTableTest,
+     whenCallingZeGetModuleBuildLogProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_module_build_log_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetModuleBuildLogProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetKernelProcAddrTableTest,
+     whenCallingZeGetKernelProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_kernel_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetKernelProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetSamplerProcAddrTableTest,
+     whenCallingZeGetSamplerProcAddrTableWithCorrectMajorVersionThenSuccessIsReturnedAndMinorVersionIsIgnored) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(1u, 64u));
+    ze_sampler_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetSamplerProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+}
+
+TEST(zeGetDriverProcAddrTableTest,
+     whenCallingZeGetDriverProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_driver_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetDriverProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetMemProcAddrTableTest,
+     whenCallingZeGetMemProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_mem_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetMemProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetContextProcAddrTableTest,
+     whenCallingZeGetContextProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_context_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetContextProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetPhysicalMemProcAddrTableTest,
+     whenCallingZeGetPhysicalMemProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_physical_mem_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetPhysicalMemProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetVirtualMemProcAddrTableTest,
+     whenCallingZeGetVirtualMemProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_virtual_mem_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetVirtualMemProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetGlobalProcAddrTableTest,
+     whenCallingZeGetGlobalProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_global_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetGlobalProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetDeviceProcAddrTableTest,
+     whenCallingZeGetDeviceProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_device_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetDeviceProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetCommandQueueProcAddrTableTest,
+     whenCallingZeGetCommandQueueProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_command_queue_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetCommandQueueProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetCommandListProcAddrTableTest,
+     whenCallingZeGetCommandListProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_command_list_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetCommandListProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetFenceProcAddrTableTest,
+     whenCallingZeGetFenceProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_fence_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetFenceProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetEventPoolProcAddrTableTest,
+     whenCallingZeGetEventPoolProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_event_pool_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetEventPoolProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetEventProcAddrTableTest,
+     whenCallingZeGetEventProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_event_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetEventProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetImageProcAddrTableTest,
+     whenCallingZeGetImageProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_image_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetImageProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetModuleProcAddrTableTest,
+     whenCallingZeGetModuleProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_module_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetModuleProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetModuleBuildLogProcAddrTableTest,
+     whenCallingZeGetModuleBuildLogProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_module_build_log_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetModuleBuildLogProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetKernelProcAddrTableTest,
+     whenCallingZeGetKernelProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_kernel_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetKernelProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+TEST(zeGetSamplerProcAddrTableTest,
+     whenCallingZeGetSamplerProcAddrTableWithGreaterThanAllowedMajorVersionThenUnitializedIsReturned) {
+
+    ze_api_version_t version = static_cast<ze_api_version_t>(ZE_MAKE_VERSION(64u, 0u));
+    ze_sampler_dditable_t pDdiTable = {};
+
+    ze_result_t result = zeGetSamplerProcAddrTable(version, &pDdiTable);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_VERSION, result);
+}
+
+} // namespace ult
+} // namespace L0