Skip to content

Commit 41d7fbd

Browse files
pratikbariintelpratikbariintel
committed
Loader Driver interaction conformance tests for Sysman Modules
Added tests for the following Sysman modules Diagnostics, ECC, Events, Fabric, Fan, Firmware Related-To: NEO-15551 Signed-off-by: Pratik Bari <pratik.bari@intel.com>
1 parent b313227 commit 41d7fbd

2 files changed

Lines changed: 289 additions & 0 deletions

File tree

‎test/CMakeLists.txt‎

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -541,6 +541,68 @@ else()
541541
set_property(TEST tests_multi_driver_sysman_memory_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/lib/libze_null_test1.so,${CMAKE_BINARY_DIR}/lib/libze_null_test2.so")
542542
endif()
543543

544+
add_test(NAME tests_single_driver_sysman_diagnostics_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManDiagnosticsApisThenExpectNullDriverIsReachedSuccessfully)
545+
set_property(TEST tests_single_driver_sysman_diagnostics_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1")
546+
547+
add_test(NAME tests_multi_driver_sysman_diagnostics_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManDiagnosticsApisThenExpectNullDriverIsReachedSuccessfully)
548+
if (MSVC)
549+
set_property(TEST tests_multi_driver_sysman_diagnostics_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test2.dll")
550+
else()
551+
set_property(TEST tests_multi_driver_sysman_diagnostics_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/lib/libze_null_test1.so,${CMAKE_BINARY_DIR}/lib/libze_null_test2.so")
552+
endif()
553+
554+
add_test(NAME tests_single_driver_sysman_ecc_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManEccApisThenExpectNullDriverIsReachedSuccessfully)
555+
set_property(TEST tests_single_driver_sysman_ecc_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1")
556+
557+
add_test(NAME tests_multi_driver_sysman_ecc_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManEccApisThenExpectNullDriverIsReachedSuccessfully)
558+
if (MSVC)
559+
set_property(TEST tests_multi_driver_sysman_ecc_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test2.dll")
560+
else()
561+
set_property(TEST tests_multi_driver_sysman_ecc_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/lib/libze_null_test1.so,${CMAKE_BINARY_DIR}/lib/libze_null_test2.so")
562+
endif()
563+
564+
add_test(NAME tests_single_driver_sysman_event_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManEventApisThenExpectNullDriverIsReachedSuccessfully)
565+
set_property(TEST tests_single_driver_sysman_event_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1")
566+
567+
add_test(NAME tests_multi_driver_sysman_event_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManEventApisThenExpectNullDriverIsReachedSuccessfully)
568+
if (MSVC)
569+
set_property(TEST tests_multi_driver_sysman_event_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test2.dll")
570+
else()
571+
set_property(TEST tests_multi_driver_sysman_event_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/lib/libze_null_test1.so,${CMAKE_BINARY_DIR}/lib/libze_null_test2.so")
572+
endif()
573+
574+
add_test(NAME tests_single_driver_sysman_fabric_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManFabricApisThenExpectNullDriverIsReachedSuccessfully)
575+
set_property(TEST tests_single_driver_sysman_fabric_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1")
576+
577+
add_test(NAME tests_multi_driver_sysman_fabric_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManFabricApisThenExpectNullDriverIsReachedSuccessfully)
578+
if (MSVC)
579+
set_property(TEST tests_multi_driver_sysman_fabric_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test2.dll")
580+
else()
581+
set_property(TEST tests_multi_driver_sysman_fabric_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/lib/libze_null_test1.so,${CMAKE_BINARY_DIR}/lib/libze_null_test2.so")
582+
endif()
583+
584+
add_test(NAME tests_single_driver_sysman_fan_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManFanApisThenExpectNullDriverIsReachedSuccessfully)
585+
set_property(TEST tests_single_driver_sysman_fan_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1")
586+
587+
add_test(NAME tests_multi_driver_sysman_fan_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManFanApisThenExpectNullDriverIsReachedSuccessfully)
588+
if (MSVC)
589+
set_property(TEST tests_multi_driver_sysman_fan_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test2.dll")
590+
else()
591+
set_property(TEST tests_multi_driver_sysman_fan_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/lib/libze_null_test1.so,${CMAKE_BINARY_DIR}/lib/libze_null_test2.so")
592+
endif()
593+
594+
add_test(NAME tests_single_driver_sysman_firmware_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManFirmwareApisThenExpectNullDriverIsReachedSuccessfully)
595+
set_property(TEST tests_single_driver_sysman_firmware_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1")
596+
597+
add_test(NAME tests_multi_driver_sysman_firmware_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManFirmwareApisThenExpectNullDriverIsReachedSuccessfully)
598+
if (MSVC)
599+
set_property(TEST tests_multi_driver_sysman_firmware_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$<CONFIG>/ze_null_test2.dll")
600+
else()
601+
set_property(TEST tests_multi_driver_sysman_firmware_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/lib/libze_null_test1.so,${CMAKE_BINARY_DIR}/lib/libze_null_test2.so")
602+
endif()
603+
604+
605+
544606
# Driver ordering tests - each test added individually
545607
add_test(NAME tests_driver_ordering_specific_type_and_index COMMAND tests --gtest_filter=*GivenZelDriversOrderWithSpecificTypeAndIndexWhenCallingZeInitDriversThenSuccessfulReturn)
546608
if (MSVC)

‎test/loader_api.cpp‎

Lines changed: 227 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2191,6 +2191,233 @@ TEST(
21912191
}
21922192
}
21932193

2194+
TEST(
2195+
SysManApiLoaderDriverInteraction,
2196+
GivenLevelZeroLoaderPresentWhenCallingSysManDiagnosticsApisThenExpectNullDriverIsReachedSuccessfully)
2197+
{
2198+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0));
2199+
uint32_t driverCount = 0;
2200+
std::vector<zes_driver_handle_t> driverHandles{};
2201+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr));
2202+
EXPECT_GT(driverCount, 0);
2203+
driverHandles.resize(driverCount);
2204+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data()));
2205+
2206+
for (std::size_t i = 0; i < driverHandles.size(); i++)
2207+
{
2208+
uint32_t deviceCount = 1;
2209+
zes_device_handle_t deviceHandle{};
2210+
uint32_t count = 1;
2211+
uint32_t startIndex = 0;
2212+
uint32_t endIndex = 1;
2213+
zes_diag_handle_t diagHandle{};
2214+
zes_diag_properties_t diagProperties{};
2215+
zes_diag_test_t diagTest{};
2216+
zes_diag_result_t diagResult{};
2217+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle));
2218+
EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1)));
2219+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumDiagnosticTestSuites(deviceHandle, &count, &diagHandle));
2220+
EXPECT_TRUE(compare_env("zesDeviceEnumDiagnosticTestSuites", std::to_string(i + 1)));
2221+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDiagnosticsGetProperties(diagHandle, &diagProperties));
2222+
EXPECT_TRUE(compare_env("zesDiagnosticsGetProperties", std::to_string(i + 1)));
2223+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDiagnosticsGetTests(diagHandle, &count, &diagTest));
2224+
EXPECT_TRUE(compare_env("zesDiagnosticsGetTests", std::to_string(i + 1)));
2225+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDiagnosticsRunTests(diagHandle, startIndex, endIndex, &diagResult));
2226+
EXPECT_TRUE(compare_env("zesDiagnosticsRunTests", std::to_string(i + 1)));
2227+
}
2228+
}
2229+
2230+
TEST(
2231+
SysManApiLoaderDriverInteraction,
2232+
GivenLevelZeroLoaderPresentWhenCallingSysManEccApisThenExpectNullDriverIsReachedSuccessfully)
2233+
{
2234+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0));
2235+
uint32_t driverCount = 0;
2236+
std::vector<zes_driver_handle_t> driverHandles{};
2237+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr));
2238+
EXPECT_GT(driverCount, 0);
2239+
driverHandles.resize(driverCount);
2240+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data()));
2241+
2242+
for (std::size_t i = 0; i < driverHandles.size(); i++)
2243+
{
2244+
uint32_t deviceCount = 1;
2245+
zes_device_handle_t deviceHandle{};
2246+
ze_bool_t available{};
2247+
ze_bool_t configurable{};
2248+
zes_device_ecc_properties_t eccState{};
2249+
zes_device_ecc_desc_t newEccState{};
2250+
zes_device_ecc_properties_t eccStateAfterSet{};
2251+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle));
2252+
EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1)));
2253+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccAvailable(deviceHandle, &available));
2254+
EXPECT_TRUE(compare_env("zesDeviceEccAvailable", std::to_string(i + 1)));
2255+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccConfigurable(deviceHandle, &configurable));
2256+
EXPECT_TRUE(compare_env("zesDeviceEccConfigurable", std::to_string(i + 1)));
2257+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetEccState(deviceHandle, &eccState));
2258+
EXPECT_TRUE(compare_env("zesDeviceGetEccState", std::to_string(i + 1)));
2259+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(deviceHandle, &newEccState, &eccStateAfterSet));
2260+
EXPECT_TRUE(compare_env("zesDeviceSetEccState", std::to_string(i + 1)));
2261+
}
2262+
}
2263+
2264+
TEST(
2265+
SysManApiLoaderDriverInteraction,
2266+
GivenLevelZeroLoaderPresentWhenCallingSysManEventApisThenExpectNullDriverIsReachedSuccessfully)
2267+
{
2268+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0));
2269+
uint32_t driverCount = 0;
2270+
std::vector<zes_driver_handle_t> driverHandles{};
2271+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr));
2272+
EXPECT_GT(driverCount, 0);
2273+
driverHandles.resize(driverCount);
2274+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data()));
2275+
2276+
for (std::size_t i = 0; i < driverHandles.size(); i++)
2277+
{
2278+
uint32_t deviceCount = 1;
2279+
zes_device_handle_t deviceHandle{};
2280+
zes_event_type_flags_t events = ZES_EVENT_TYPE_FLAG_DEVICE_DETACH;
2281+
uint32_t timeout = 0;
2282+
uint32_t numDeviceEvents = 0;
2283+
zes_event_type_flags_t pEvents{};
2284+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle));
2285+
EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1)));
2286+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(deviceHandle, events));
2287+
EXPECT_TRUE(compare_env("zesDeviceEventRegister", std::to_string(i + 1)));
2288+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandles[i], timeout, deviceCount, &deviceHandle, &numDeviceEvents, &pEvents));
2289+
EXPECT_TRUE(compare_env("zesDriverEventListen", std::to_string(i + 1)));
2290+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListenEx(driverHandles[i], timeout, deviceCount, &deviceHandle, &numDeviceEvents, &pEvents));
2291+
EXPECT_TRUE(compare_env("zesDriverEventListenEx", std::to_string(i + 1)));
2292+
}
2293+
}
2294+
2295+
TEST(
2296+
SysManApiLoaderDriverInteraction,
2297+
GivenLevelZeroLoaderPresentWhenCallingSysManFabricApisThenExpectNullDriverIsReachedSuccessfully)
2298+
{
2299+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0));
2300+
uint32_t driverCount = 0;
2301+
std::vector<zes_driver_handle_t> driverHandles{};
2302+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr));
2303+
EXPECT_GT(driverCount, 0);
2304+
driverHandles.resize(driverCount);
2305+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data()));
2306+
2307+
for (std::size_t i = 0; i < driverHandles.size(); i++)
2308+
{
2309+
uint32_t deviceCount = 1;
2310+
zes_device_handle_t deviceHandle{};
2311+
uint32_t count = 1;
2312+
zes_fabric_port_handle_t fabricPortHandle{};
2313+
zes_fabric_port_properties_t fabricPortProperties{};
2314+
zes_fabric_link_type_t linkType{};
2315+
zes_fabric_port_config_t fabricPortConfig{};
2316+
zes_fabric_port_state_t fabricPortState{};
2317+
zes_fabric_port_throughput_t fabricPortThroughput{};
2318+
zes_fabric_port_throughput_t *pFabricPortThroughput = nullptr;
2319+
zes_fabric_port_error_counters_t fabricPortErrorCounters{};
2320+
2321+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle));
2322+
EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1)));
2323+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFabricPorts(deviceHandle, &count, &fabricPortHandle));
2324+
EXPECT_TRUE(compare_env("zesDeviceEnumFabricPorts", std::to_string(i + 1)));
2325+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortGetProperties(fabricPortHandle, &fabricPortProperties));
2326+
EXPECT_TRUE(compare_env("zesFabricPortGetProperties", std::to_string(i + 1)));
2327+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortGetLinkType(fabricPortHandle, &linkType));
2328+
EXPECT_TRUE(compare_env("zesFabricPortGetLinkType", std::to_string(i + 1)));
2329+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortGetConfig(fabricPortHandle, &fabricPortConfig));
2330+
EXPECT_TRUE(compare_env("zesFabricPortGetConfig", std::to_string(i + 1)));
2331+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortSetConfig(fabricPortHandle, &fabricPortConfig));
2332+
EXPECT_TRUE(compare_env("zesFabricPortSetConfig", std::to_string(i + 1)));
2333+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortGetState(fabricPortHandle, &fabricPortState));
2334+
EXPECT_TRUE(compare_env("zesFabricPortGetState", std::to_string(i + 1)));
2335+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortGetThroughput(fabricPortHandle, &fabricPortThroughput));
2336+
EXPECT_TRUE(compare_env("zesFabricPortGetThroughput", std::to_string(i + 1)));
2337+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortGetFabricErrorCounters(fabricPortHandle, &fabricPortErrorCounters));
2338+
EXPECT_TRUE(compare_env("zesFabricPortGetFabricErrorCounters", std::to_string(i + 1)));
2339+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortGetMultiPortThroughput(deviceHandle, count, &fabricPortHandle, &pFabricPortThroughput));
2340+
EXPECT_TRUE(compare_env("zesFabricPortGetMultiPortThroughput", std::to_string(i + 1)));
2341+
}
2342+
}
2343+
2344+
TEST(
2345+
SysManApiLoaderDriverInteraction,
2346+
GivenLevelZeroLoaderPresentWhenCallingSysManFanApisThenExpectNullDriverIsReachedSuccessfully)
2347+
{
2348+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0));
2349+
uint32_t driverCount = 0;
2350+
std::vector<zes_driver_handle_t> driverHandles{};
2351+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr));
2352+
EXPECT_GT(driverCount, 0);
2353+
driverHandles.resize(driverCount);
2354+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data()));
2355+
2356+
for (std::size_t i = 0; i < driverHandles.size(); i++)
2357+
{
2358+
uint32_t deviceCount = 1;
2359+
zes_device_handle_t deviceHandle{};
2360+
uint32_t count = 1;
2361+
zes_fan_handle_t fanHandle{};
2362+
zes_fan_properties_t fanProperties{};
2363+
zes_fan_config_t fanConfig{};
2364+
zes_fan_speed_t fanSpeed{};
2365+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle));
2366+
EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1)));
2367+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFans(deviceHandle, &count, &fanHandle));
2368+
EXPECT_TRUE(compare_env("zesDeviceEnumFans", std::to_string(i + 1)));
2369+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanGetProperties(fanHandle, &fanProperties));
2370+
EXPECT_TRUE(compare_env("zesFanGetProperties", std::to_string(i + 1)));
2371+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanGetConfig(fanHandle, &fanConfig));
2372+
EXPECT_TRUE(compare_env("zesFanGetConfig", std::to_string(i + 1)));
2373+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanSetDefaultMode(fanHandle));
2374+
EXPECT_TRUE(compare_env("zesFanSetDefaultMode", std::to_string(i + 1)));
2375+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanSetFixedSpeedMode(fanHandle, &fanSpeed));
2376+
EXPECT_TRUE(compare_env("zesFanSetFixedSpeedMode", std::to_string(i + 1)));
2377+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanGetState(fanHandle, ZES_FAN_SPEED_UNITS_RPM, &fanSpeed.speed));
2378+
EXPECT_TRUE(compare_env("zesFanGetState", std::to_string(i + 1)));
2379+
}
2380+
}
2381+
2382+
TEST(
2383+
SysManApiLoaderDriverInteraction,
2384+
GivenLevelZeroLoaderPresentWhenCallingSysManFirmwareApisThenExpectNullDriverIsReachedSuccessfully)
2385+
{
2386+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0));
2387+
uint32_t driverCount = 0;
2388+
std::vector<zes_driver_handle_t> driverHandles{};
2389+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr));
2390+
EXPECT_GT(driverCount, 0);
2391+
driverHandles.resize(driverCount);
2392+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data()));
2393+
2394+
for (std::size_t i = 0; i < driverHandles.size(); i++)
2395+
{
2396+
uint32_t deviceCount = 1;
2397+
zes_device_handle_t deviceHandle{};
2398+
uint32_t count = 1;
2399+
uint32_t flashImageSize = 1;
2400+
size_t firmwareLogSize = 1;
2401+
zes_firmware_handle_t firmwareHandle{};
2402+
zes_firmware_properties_t firmwareProperties{};
2403+
char * firmwareLogs = nullptr;
2404+
void * flashImage = nullptr;
2405+
uint32_t completionPercent = 0;
2406+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle));
2407+
EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1)));
2408+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFirmwares(deviceHandle, &count, &firmwareHandle));
2409+
EXPECT_TRUE(compare_env("zesDeviceEnumFirmwares", std::to_string(i + 1)));
2410+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(firmwareHandle, &firmwareProperties));
2411+
EXPECT_TRUE(compare_env("zesFirmwareGetProperties", std::to_string(i + 1)));
2412+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareFlash(firmwareHandle, flashImage, flashImageSize));
2413+
EXPECT_TRUE(compare_env("zesFirmwareFlash", std::to_string(i + 1)));
2414+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetFlashProgress(firmwareHandle, &completionPercent));
2415+
EXPECT_TRUE(compare_env("zesFirmwareGetFlashProgress", std::to_string(i + 1)));
2416+
EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetConsoleLogs(firmwareHandle, &firmwareLogSize, firmwareLogs));
2417+
EXPECT_TRUE(compare_env("zesFirmwareGetConsoleLogs", std::to_string(i + 1)));
2418+
}
2419+
}
2420+
21942421
// Helper function to clear ZEL_DRIVERS_ORDER environment variable
21952422
void clearDriverOrderEnv() {
21962423
putenv_safe(const_cast<char *>("ZEL_DRIVERS_ORDER="));

0 commit comments

Comments
 (0)