1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
/*
* Copyright (C) 2025 Intel Corporation
* SPDX-License-Identifier: MIT
*/
#include "test/init_driver_unit_tests_common.h"
// Helper to create a mock null driver with a given name and type
loader::driver_t createNullDriver(const std::string& name, loader::zel_driver_type_t type) {
loader::driver_t driver;
std::string libraryPath;
auto loaderLibraryPathEnv = getenv_string("ZEL_LIBRARY_PATH");
if (!loaderLibraryPathEnv.empty()) {
libraryPath = loaderLibraryPathEnv;
#ifdef _WIN32
libraryPath.append("\\");
#else
libraryPath.append("/");
#endif
}
#ifdef _WIN32
driver.name = libraryPath + name + ".dll";
#else
driver.name = libraryPath + "lib" + name + ".so.1";
#endif
driver.driverType = type;
driver.handle = nullptr; // Simulate null driver
driver.initStatus = ZE_RESULT_SUCCESS;
driver.driverInuse = false;
driver.ddiInitialized = false;
return driver;
}
TEST_F(InitDriverUnitTest, InitWithSingleGPUDriver) {
loader::driver_t gpuDriver = createNullDriver("ze_fake_gpu", loader::ZEL_DRIVER_TYPE_DISCRETE_GPU);
ze_result_t result = loader::context->init_driver(gpuDriver, ZE_INIT_FLAG_GPU_ONLY, nullptr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_TRUE(gpuDriver.ddiInitialized);
}
TEST_F(InitDriverUnitTest, InitWithSingleNPUDriver) {
loader::driver_t npuDriver = createNullDriver("ze_fake_npu", loader::ZEL_DRIVER_TYPE_NPU);
ze_init_driver_type_desc_t desc = {};
desc.flags = ZE_INIT_DRIVER_TYPE_FLAG_NPU;
ze_result_t result = loader::context->init_driver(npuDriver, 0, &desc);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_TRUE(npuDriver.ddiInitialized);
}
TEST_F(InitDriverUnitTest, InitWithSingleVPUDriver) {
loader::driver_t vpuDriver = createNullDriver("ze_fake_vpu", loader::ZEL_DRIVER_TYPE_NPU);
ze_result_t result = loader::context->init_driver(vpuDriver, ZE_INIT_FLAG_VPU_ONLY, nullptr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_TRUE(vpuDriver.ddiInitialized);
}
TEST_F(InitDriverUnitTest, zeInitWithMultipleDrivers) {
std::vector<loader::driver_t> drivers = {
createNullDriver("ze_fake_gpu", loader::ZEL_DRIVER_TYPE_DISCRETE_GPU),
createNullDriver("ze_fake_npu", loader::ZEL_DRIVER_TYPE_NPU),
createNullDriver("ze_fake_vpu", loader::ZEL_DRIVER_TYPE_NPU)
};
for (auto& driver : drivers) {
ze_result_t result = loader::context->init_driver(driver, 0, nullptr);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_TRUE(driver.ddiInitialized);
}
}
TEST_F(InitDriverUnitTest, zeInitDriversWithMultipleDrivers) {
std::vector<loader::driver_t> drivers = {
createNullDriver("ze_fake_gpu", loader::ZEL_DRIVER_TYPE_DISCRETE_GPU),
createNullDriver("ze_fake_npu", loader::ZEL_DRIVER_TYPE_NPU),
createNullDriver("ze_fake_vpu", loader::ZEL_DRIVER_TYPE_NPU)
};
ze_init_driver_type_desc_t desc = {};
desc.flags = UINT32_MAX; // Request all driver types
for (auto& driver : drivers) {
ze_result_t result = loader::context->init_driver(driver, 0, &desc);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_TRUE(driver.ddiInitialized);
}
}
TEST_F(InitDriverUnitTest, zeInitDriversWithMultipleDriversNPURequested) {
std::vector<loader::driver_t> drivers = {
createNullDriver("ze_fake_gpu", loader::ZEL_DRIVER_TYPE_DISCRETE_GPU),
createNullDriver("ze_fake_npu", loader::ZEL_DRIVER_TYPE_NPU),
createNullDriver("ze_fake_vpu", loader::ZEL_DRIVER_TYPE_NPU)
};
ze_init_driver_type_desc_t desc = {};
desc.flags = ZE_INIT_DRIVER_TYPE_FLAG_NPU; // Request NPU driver types
for (auto& driver : drivers) {
if (driver.driverType == loader::ZEL_DRIVER_TYPE_NPU) {
ze_result_t result = loader::context->init_driver(driver, 0, &desc);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_TRUE(driver.ddiInitialized);
} else {
ze_result_t result = loader::context->init_driver(driver, 0, &desc);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
EXPECT_FALSE(driver.ddiInitialized);
}
}
}
TEST_F(InitDriverUnitTest, zeInitDriversWithMultipleDriversGPURequested) {
std::vector<loader::driver_t> drivers = {
createNullDriver("ze_fake_gpu", loader::ZEL_DRIVER_TYPE_DISCRETE_GPU),
createNullDriver("ze_fake_npu", loader::ZEL_DRIVER_TYPE_NPU),
createNullDriver("ze_fake_vpu", loader::ZEL_DRIVER_TYPE_NPU)
};
ze_init_driver_type_desc_t desc = {};
desc.flags = ZE_INIT_DRIVER_TYPE_FLAG_GPU; // Request GPU driver types
for (auto& driver : drivers) {
if (driver.driverType == loader::ZEL_DRIVER_TYPE_DISCRETE_GPU) {
ze_result_t result = loader::context->init_driver(driver, 0, &desc);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
EXPECT_TRUE(driver.ddiInitialized);
} else {
ze_result_t result = loader::context->init_driver(driver, 0, &desc);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
EXPECT_FALSE(driver.ddiInitialized);
}
}
}
TEST_F(InitDriverUnitTest, InitWithUnsupportedNullDriverType) {
loader::driver_t otherDriver = createNullDriver("ze_fake_other", loader::ZEL_DRIVER_TYPE_OTHER);
ze_result_t result = loader::context->init_driver(otherDriver, 0, nullptr);
EXPECT_NE(result, ZE_RESULT_SUCCESS);
EXPECT_FALSE(otherDriver.ddiInitialized);
}
|
