From 41d7fbd235c3c44cfd8e5c6bcea3f3362557f209 Mon Sep 17 00:00:00 2001 From: Pratik Bari Date: Wed, 14 Jan 2026 11:25:13 +0530 Subject: [PATCH 1/3] 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 --- test/CMakeLists.txt | 62 ++++++++++++ test/loader_api.cpp | 227 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 289 insertions(+) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index e13c178f..cc33f4e2 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -541,6 +541,68 @@ else() 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") endif() +add_test(NAME tests_single_driver_sysman_diagnostics_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManDiagnosticsApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_diagnostics_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_diagnostics_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManDiagnosticsApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + 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/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + 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") +endif() + +add_test(NAME tests_single_driver_sysman_ecc_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManEccApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_ecc_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_ecc_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManEccApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + 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/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + 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") +endif() + +add_test(NAME tests_single_driver_sysman_event_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManEventApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_event_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_event_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManEventApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + 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/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + 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") +endif() + +add_test(NAME tests_single_driver_sysman_fabric_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManFabricApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_fabric_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_fabric_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManFabricApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + 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/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + 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") +endif() + +add_test(NAME tests_single_driver_sysman_fan_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManFanApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_fan_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_fan_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManFanApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + 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/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + 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") +endif() + +add_test(NAME tests_single_driver_sysman_firmware_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManFirmwareApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_firmware_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_firmware_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManFirmwareApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + 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/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + 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") +endif() + + + # Driver ordering tests - each test added individually add_test(NAME tests_driver_ordering_specific_type_and_index COMMAND tests --gtest_filter=*GivenZelDriversOrderWithSpecificTypeAndIndexWhenCallingZeInitDriversThenSuccessfulReturn) if (MSVC) diff --git a/test/loader_api.cpp b/test/loader_api.cpp index cefc65a6..c98cc3ea 100644 --- a/test/loader_api.cpp +++ b/test/loader_api.cpp @@ -2191,6 +2191,233 @@ TEST( } } + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManDiagnosticsApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + uint32_t count = 1; + uint32_t startIndex = 0; + uint32_t endIndex = 1; + zes_diag_handle_t diagHandle{}; + zes_diag_properties_t diagProperties{}; + zes_diag_test_t diagTest{}; + zes_diag_result_t diagResult{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumDiagnosticTestSuites(deviceHandle, &count, &diagHandle)); + EXPECT_TRUE(compare_env("zesDeviceEnumDiagnosticTestSuites", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDiagnosticsGetProperties(diagHandle, &diagProperties)); + EXPECT_TRUE(compare_env("zesDiagnosticsGetProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDiagnosticsGetTests(diagHandle, &count, &diagTest)); + EXPECT_TRUE(compare_env("zesDiagnosticsGetTests", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDiagnosticsRunTests(diagHandle, startIndex, endIndex, &diagResult)); + EXPECT_TRUE(compare_env("zesDiagnosticsRunTests", std::to_string(i + 1))); + } + } + + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManEccApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + ze_bool_t available{}; + ze_bool_t configurable{}; + zes_device_ecc_properties_t eccState{}; + zes_device_ecc_desc_t newEccState{}; + zes_device_ecc_properties_t eccStateAfterSet{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccAvailable(deviceHandle, &available)); + EXPECT_TRUE(compare_env("zesDeviceEccAvailable", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEccConfigurable(deviceHandle, &configurable)); + EXPECT_TRUE(compare_env("zesDeviceEccConfigurable", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetEccState(deviceHandle, &eccState)); + EXPECT_TRUE(compare_env("zesDeviceGetEccState", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetEccState(deviceHandle, &newEccState, &eccStateAfterSet)); + EXPECT_TRUE(compare_env("zesDeviceSetEccState", std::to_string(i + 1))); + } + } + + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManEventApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + zes_event_type_flags_t events = ZES_EVENT_TYPE_FLAG_DEVICE_DETACH; + uint32_t timeout = 0; + uint32_t numDeviceEvents = 0; + zes_event_type_flags_t pEvents{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(deviceHandle, events)); + EXPECT_TRUE(compare_env("zesDeviceEventRegister", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListen(driverHandles[i], timeout, deviceCount, &deviceHandle, &numDeviceEvents, &pEvents)); + EXPECT_TRUE(compare_env("zesDriverEventListen", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverEventListenEx(driverHandles[i], timeout, deviceCount, &deviceHandle, &numDeviceEvents, &pEvents)); + EXPECT_TRUE(compare_env("zesDriverEventListenEx", std::to_string(i + 1))); + } + } + + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManFabricApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + uint32_t count = 1; + zes_fabric_port_handle_t fabricPortHandle{}; + zes_fabric_port_properties_t fabricPortProperties{}; + zes_fabric_link_type_t linkType{}; + zes_fabric_port_config_t fabricPortConfig{}; + zes_fabric_port_state_t fabricPortState{}; + zes_fabric_port_throughput_t fabricPortThroughput{}; + zes_fabric_port_throughput_t *pFabricPortThroughput = nullptr; + zes_fabric_port_error_counters_t fabricPortErrorCounters{}; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFabricPorts(deviceHandle, &count, &fabricPortHandle)); + EXPECT_TRUE(compare_env("zesDeviceEnumFabricPorts", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortGetProperties(fabricPortHandle, &fabricPortProperties)); + EXPECT_TRUE(compare_env("zesFabricPortGetProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortGetLinkType(fabricPortHandle, &linkType)); + EXPECT_TRUE(compare_env("zesFabricPortGetLinkType", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortGetConfig(fabricPortHandle, &fabricPortConfig)); + EXPECT_TRUE(compare_env("zesFabricPortGetConfig", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortSetConfig(fabricPortHandle, &fabricPortConfig)); + EXPECT_TRUE(compare_env("zesFabricPortSetConfig", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortGetState(fabricPortHandle, &fabricPortState)); + EXPECT_TRUE(compare_env("zesFabricPortGetState", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortGetThroughput(fabricPortHandle, &fabricPortThroughput)); + EXPECT_TRUE(compare_env("zesFabricPortGetThroughput", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortGetFabricErrorCounters(fabricPortHandle, &fabricPortErrorCounters)); + EXPECT_TRUE(compare_env("zesFabricPortGetFabricErrorCounters", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFabricPortGetMultiPortThroughput(deviceHandle, count, &fabricPortHandle, &pFabricPortThroughput)); + EXPECT_TRUE(compare_env("zesFabricPortGetMultiPortThroughput", std::to_string(i + 1))); + } + } + + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManFanApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + uint32_t count = 1; + zes_fan_handle_t fanHandle{}; + zes_fan_properties_t fanProperties{}; + zes_fan_config_t fanConfig{}; + zes_fan_speed_t fanSpeed{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFans(deviceHandle, &count, &fanHandle)); + EXPECT_TRUE(compare_env("zesDeviceEnumFans", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanGetProperties(fanHandle, &fanProperties)); + EXPECT_TRUE(compare_env("zesFanGetProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanGetConfig(fanHandle, &fanConfig)); + EXPECT_TRUE(compare_env("zesFanGetConfig", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanSetDefaultMode(fanHandle)); + EXPECT_TRUE(compare_env("zesFanSetDefaultMode", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanSetFixedSpeedMode(fanHandle, &fanSpeed)); + EXPECT_TRUE(compare_env("zesFanSetFixedSpeedMode", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFanGetState(fanHandle, ZES_FAN_SPEED_UNITS_RPM, &fanSpeed.speed)); + EXPECT_TRUE(compare_env("zesFanGetState", std::to_string(i + 1))); + } + } + + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManFirmwareApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + uint32_t count = 1; + uint32_t flashImageSize = 1; + size_t firmwareLogSize = 1; + zes_firmware_handle_t firmwareHandle{}; + zes_firmware_properties_t firmwareProperties{}; + char * firmwareLogs = nullptr; + void * flashImage = nullptr; + uint32_t completionPercent = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFirmwares(deviceHandle, &count, &firmwareHandle)); + EXPECT_TRUE(compare_env("zesDeviceEnumFirmwares", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetProperties(firmwareHandle, &firmwareProperties)); + EXPECT_TRUE(compare_env("zesFirmwareGetProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareFlash(firmwareHandle, flashImage, flashImageSize)); + EXPECT_TRUE(compare_env("zesFirmwareFlash", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetFlashProgress(firmwareHandle, &completionPercent)); + EXPECT_TRUE(compare_env("zesFirmwareGetFlashProgress", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFirmwareGetConsoleLogs(firmwareHandle, &firmwareLogSize, firmwareLogs)); + EXPECT_TRUE(compare_env("zesFirmwareGetConsoleLogs", std::to_string(i + 1))); + } + } + // Helper function to clear ZEL_DRIVERS_ORDER environment variable void clearDriverOrderEnv() { putenv_safe(const_cast("ZEL_DRIVERS_ORDER=")); From 8d6ec7d4bb0d6a03e1990462916334c2d2237229 Mon Sep 17 00:00:00 2001 From: Pratik Bari Date: Wed, 14 Jan 2026 14:47:08 +0530 Subject: [PATCH 2/3] Loader Driver interaction conformance tests for Sysman Modules Added tests for the following Sysman modules Diagnostics, ECC, Events, Fabric, Fan, Firmware, Frequency, Led Performance Related-To: NEO-15551 Signed-off-by: Pratik Bari --- test/CMakeLists.txt | 30 ++++++++++ test/loader_api.cpp | 141 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 171 insertions(+) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index cc33f4e2..fcc00bff 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -601,6 +601,36 @@ else() 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") endif() +add_test(NAME tests_single_driver_sysman_frequency_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManFrequencyApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_frequency_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_frequency_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManFrequencyApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + set_property(TEST tests_multi_driver_sysman_frequency_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + set_property(TEST tests_multi_driver_sysman_frequency_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") +endif() + +add_test(NAME tests_single_driver_sysman_led_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManLedApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_led_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_led_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManLedApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + set_property(TEST tests_multi_driver_sysman_led_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + set_property(TEST tests_multi_driver_sysman_led_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") +endif() + +add_test(NAME tests_single_driver_sysman_performance_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManPerformanceApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_performance_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_performance_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManPerformanceApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + set_property(TEST tests_multi_driver_sysman_performance_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + set_property(TEST tests_multi_driver_sysman_performance_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") +endif() + # Driver ordering tests - each test added individually diff --git a/test/loader_api.cpp b/test/loader_api.cpp index c98cc3ea..5d72e9e8 100644 --- a/test/loader_api.cpp +++ b/test/loader_api.cpp @@ -2418,6 +2418,147 @@ TEST( } } + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManFrequencyApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + uint32_t count = 1; + zes_freq_handle_t freqHandle{}; + zes_freq_properties_t freqProperties{}; + uint32_t numClocks = 0; + zes_freq_range_t freqRange{}; + zes_freq_state_t freqState{}; + zes_freq_throttle_time_t freqThrottleTime{}; + zes_oc_capabilities_t ocCapabilities{}; + zes_oc_mode_t ocMode{}; + double ocFrequency = 0.0; + double ocVoltageTarget = 0.0; + double ocVoltageOffset = 0.0; + double ocIccMax = 0.0; + double ocTjMax = 0.0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFrequencyDomains(deviceHandle, &count, &freqHandle)); + EXPECT_TRUE(compare_env("zesDeviceEnumFrequencyDomains", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetProperties(freqHandle, &freqProperties)); + EXPECT_TRUE(compare_env("zesFrequencyGetProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetAvailableClocks(freqHandle, &numClocks, nullptr)); + EXPECT_TRUE(compare_env("zesFrequencyGetAvailableClocks", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetRange(freqHandle, &freqRange)); + EXPECT_TRUE(compare_env("zesFrequencyGetRange", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencySetRange(freqHandle, &freqRange)); + EXPECT_TRUE(compare_env("zesFrequencySetRange", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetState(freqHandle, &freqState)); + EXPECT_TRUE(compare_env("zesFrequencyGetState", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyGetThrottleTime(freqHandle, &freqThrottleTime)); + EXPECT_TRUE(compare_env("zesFrequencyGetThrottleTime", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetCapabilities(freqHandle, &ocCapabilities)); + EXPECT_TRUE(compare_env("zesFrequencyOcGetCapabilities", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetFrequencyTarget(freqHandle, &ocFrequency)); + EXPECT_TRUE(compare_env("zesFrequencyOcGetFrequencyTarget", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetFrequencyTarget(freqHandle, ocFrequency)); + EXPECT_TRUE(compare_env("zesFrequencyOcSetFrequencyTarget", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetVoltageTarget(freqHandle, &ocVoltageTarget, &ocVoltageOffset)); + EXPECT_TRUE(compare_env("zesFrequencyOcGetVoltageTarget", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetVoltageTarget(freqHandle, ocVoltageTarget, ocVoltageOffset)); + EXPECT_TRUE(compare_env("zesFrequencyOcSetVoltageTarget", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetMode(freqHandle, ocMode)); + EXPECT_TRUE(compare_env("zesFrequencyOcSetMode", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetMode(freqHandle, &ocMode)); + EXPECT_TRUE(compare_env("zesFrequencyOcGetMode", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetIccMax(freqHandle, &ocIccMax)); + EXPECT_TRUE(compare_env("zesFrequencyOcGetIccMax", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetIccMax(freqHandle, ocIccMax)); + EXPECT_TRUE(compare_env("zesFrequencyOcSetIccMax", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcGetTjMax(freqHandle, &ocTjMax)); + EXPECT_TRUE(compare_env("zesFrequencyOcGetTjMax", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesFrequencyOcSetTjMax(freqHandle, ocTjMax)); + EXPECT_TRUE(compare_env("zesFrequencyOcSetTjMax", std::to_string(i + 1))); + } + } + + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManLedApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + uint32_t count = 1; + zes_led_handle_t ledHandle{}; + zes_led_properties_t ledProperties{}; + zes_led_state_t ledState{}; + zes_led_color_t ledColor{}; + ze_bool_t enable = true; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumLeds(deviceHandle, &count, &ledHandle)); + EXPECT_TRUE(compare_env("zesDeviceEnumLeds", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesLedGetProperties(ledHandle, &ledProperties)); + EXPECT_TRUE(compare_env("zesLedGetProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesLedGetState(ledHandle, &ledState)); + EXPECT_TRUE(compare_env("zesLedGetState", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesLedSetState(ledHandle, enable)); + EXPECT_TRUE(compare_env("zesLedSetState", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesLedSetColor(ledHandle, &ledColor)); + EXPECT_TRUE(compare_env("zesLedSetColor", std::to_string(i + 1))); + } + } + + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManPerformanceApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + uint32_t count = 1; + zes_perf_handle_t perfHandle{}; + zes_perf_properties_t perfProperties{}; + double perfFactor = 0.0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumPerformanceFactorDomains(deviceHandle, &count, &perfHandle)); + EXPECT_TRUE(compare_env("zesDeviceEnumPerformanceFactorDomains", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetProperties(perfHandle, &perfProperties)); + EXPECT_TRUE(compare_env("zesPerformanceFactorGetProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorGetConfig(perfHandle, &perfFactor)); + EXPECT_TRUE(compare_env("zesPerformanceFactorGetConfig", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPerformanceFactorSetConfig(perfHandle, perfFactor)); + EXPECT_TRUE(compare_env("zesPerformanceFactorSetConfig", std::to_string(i + 1))); + } + } + // Helper function to clear ZEL_DRIVERS_ORDER environment variable void clearDriverOrderEnv() { putenv_safe(const_cast("ZEL_DRIVERS_ORDER=")); From cdc6f97e61c4a7492a8449ebba64ac16655c3484 Mon Sep 17 00:00:00 2001 From: Pratik Bari Date: Mon, 19 Jan 2026 20:21:47 +0530 Subject: [PATCH 3/3] Loader Driver interaction conformance tests for Sysman Modules Added tests for the following Sysman modules Diagnostics, ECC, Events, Fabric, Fan, Firmware, Frequency, Led, Performance, Power, Psu, Ras, Scheduler, Standby, Temperature and Overclock Related-To: NEO-15551 Signed-off-by: Pratik Bari --- test/CMakeLists.txt | 70 ++++++++++ test/loader_api.cpp | 305 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 375 insertions(+) diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index fcc00bff..27b75a7d 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -631,6 +631,76 @@ else() set_property(TEST tests_multi_driver_sysman_performance_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") endif() +add_test(NAME tests_single_driver_sysman_power_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManPowerApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_power_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_power_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManPowerApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + set_property(TEST tests_multi_driver_sysman_power_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + set_property(TEST tests_multi_driver_sysman_power_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") +endif() + +add_test(NAME tests_single_driver_sysman_psu_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManPsuApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_psu_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_psu_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManPsuApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + set_property(TEST tests_multi_driver_sysman_psu_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + set_property(TEST tests_multi_driver_sysman_psu_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") +endif() + +add_test(NAME tests_single_driver_sysman_ras_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManRasApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_ras_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_ras_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManRasApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + set_property(TEST tests_multi_driver_sysman_ras_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + set_property(TEST tests_multi_driver_sysman_ras_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") +endif() + +add_test(NAME tests_single_driver_sysman_scheduler_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManSchedulerApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_scheduler_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_scheduler_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManSchedulerApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + set_property(TEST tests_multi_driver_sysman_scheduler_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + set_property(TEST tests_multi_driver_sysman_scheduler_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") +endif() + +add_test(NAME tests_single_driver_sysman_standby_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManStandbyApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_standby_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_standby_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManStandbyApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + set_property(TEST tests_multi_driver_sysman_standby_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + set_property(TEST tests_multi_driver_sysman_standby_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") +endif() + +add_test(NAME tests_single_driver_sysman_temperature_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManTemperatureApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_temperature_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_temperature_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManTemperatureApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + set_property(TEST tests_multi_driver_sysman_temperature_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + set_property(TEST tests_multi_driver_sysman_temperature_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") +endif() + +add_test(NAME tests_single_driver_sysman_overclock_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManOverclockApisThenExpectNullDriverIsReachedSuccessfully) +set_property(TEST tests_single_driver_sysman_overclock_api PROPERTY ENVIRONMENT "ZE_ENABLE_NULL_DRIVER=1") + +add_test(NAME tests_multi_driver_sysman_overclock_api COMMAND tests --gtest_filter=*GivenLevelZeroLoaderPresentWhenCallingSysManOverclockApisThenExpectNullDriverIsReachedSuccessfully) +if (MSVC) + set_property(TEST tests_multi_driver_sysman_overclock_api APPEND PROPERTY ENVIRONMENT "ZE_ENABLE_LOADER_DEBUG_TRACE=1;ZE_ENABLE_ALT_DRIVERS=${CMAKE_BINARY_DIR}/bin/$/ze_null_test1.dll,${CMAKE_BINARY_DIR}/bin/$/ze_null_test2.dll") +else() + set_property(TEST tests_multi_driver_sysman_overclock_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") +endif() + # Driver ordering tests - each test added individually diff --git a/test/loader_api.cpp b/test/loader_api.cpp index 5d72e9e8..976aed1f 100644 --- a/test/loader_api.cpp +++ b/test/loader_api.cpp @@ -2559,6 +2559,311 @@ TEST( } } + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManPowerApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + uint32_t count = 1; + zes_pwr_handle_t powerHandle{}; + zes_pwr_handle_t cardPowerHandle{}; + zes_power_properties_t powerProperties{}; + zes_power_energy_counter_t energyCounter{}; + zes_power_sustained_limit_t sustained{}; + zes_power_burst_limit_t burst{}; + zes_power_peak_limit_t peak{}; + zes_energy_threshold_t threshold{}; + double energyThreshold = 1000.0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetCardPowerDomain(deviceHandle, &cardPowerHandle)); + EXPECT_TRUE(compare_env("zesDeviceGetCardPowerDomain", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumPowerDomains(deviceHandle, &count, &powerHandle)); + EXPECT_TRUE(compare_env("zesDeviceEnumPowerDomains", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(powerHandle, &powerProperties)); + EXPECT_TRUE(compare_env("zesPowerGetProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetEnergyCounter(powerHandle, &energyCounter)); + EXPECT_TRUE(compare_env("zesPowerGetEnergyCounter", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(powerHandle, &sustained, &burst, &peak)); + EXPECT_TRUE(compare_env("zesPowerGetLimits", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(powerHandle, &sustained, &burst, &peak)); + EXPECT_TRUE(compare_env("zesPowerSetLimits", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetEnergyThreshold(powerHandle, &threshold)); + EXPECT_TRUE(compare_env("zesPowerGetEnergyThreshold", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetEnergyThreshold(powerHandle, energyThreshold)); + EXPECT_TRUE(compare_env("zesPowerSetEnergyThreshold", std::to_string(i + 1))); + } + } + + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManPsuApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + uint32_t count = 1; + zes_psu_handle_t psuHandle{}; + zes_psu_properties_t psuProperties{}; + zes_psu_state_t psuState{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumPsus(deviceHandle, &count, &psuHandle)); + EXPECT_TRUE(compare_env("zesDeviceEnumPsus", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPsuGetProperties(psuHandle, &psuProperties)); + EXPECT_TRUE(compare_env("zesPsuGetProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPsuGetState(psuHandle, &psuState)); + EXPECT_TRUE(compare_env("zesPsuGetState", std::to_string(i + 1))); + } + } + + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManRasApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + uint32_t count = 1; + zes_ras_handle_t rasHandle{}; + zes_ras_properties_t rasProperties{}; + zes_ras_config_t rasConfig{}; + zes_ras_state_t rasState{}; + ze_bool_t clear = false; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumRasErrorSets(deviceHandle, &count, &rasHandle)); + EXPECT_TRUE(compare_env("zesDeviceEnumRasErrorSets", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetProperties(rasHandle, &rasProperties)); + EXPECT_TRUE(compare_env("zesRasGetProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetConfig(rasHandle, &rasConfig)); + EXPECT_TRUE(compare_env("zesRasGetConfig", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasSetConfig(rasHandle, &rasConfig)); + EXPECT_TRUE(compare_env("zesRasSetConfig", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesRasGetState(rasHandle, clear, &rasState)); + EXPECT_TRUE(compare_env("zesRasGetState", std::to_string(i + 1))); + } + } + + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManSchedulerApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + uint32_t count = 1; + zes_sched_handle_t schedHandle{}; + zes_sched_properties_t schedProperties{}; + zes_sched_mode_t schedMode{}; + zes_sched_timeout_properties_t timeoutProperties{}; + zes_sched_timeslice_properties_t timesliceProperties{}; + ze_bool_t getDefaults = false; + ze_bool_t needReload = false; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumSchedulers(deviceHandle, &count, &schedHandle)); + EXPECT_TRUE(compare_env("zesDeviceEnumSchedulers", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesSchedulerGetProperties(schedHandle, &schedProperties)); + EXPECT_TRUE(compare_env("zesSchedulerGetProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesSchedulerGetCurrentMode(schedHandle, &schedMode)); + EXPECT_TRUE(compare_env("zesSchedulerGetCurrentMode", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesSchedulerGetTimeoutModeProperties(schedHandle, getDefaults, &timeoutProperties)); + EXPECT_TRUE(compare_env("zesSchedulerGetTimeoutModeProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesSchedulerGetTimesliceModeProperties(schedHandle, getDefaults, ×liceProperties)); + EXPECT_TRUE(compare_env("zesSchedulerGetTimesliceModeProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesSchedulerSetTimeoutMode(schedHandle, &timeoutProperties, &needReload)); + EXPECT_TRUE(compare_env("zesSchedulerSetTimeoutMode", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesSchedulerSetTimesliceMode(schedHandle, ×liceProperties, &needReload)); + EXPECT_TRUE(compare_env("zesSchedulerSetTimesliceMode", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesSchedulerSetExclusiveMode(schedHandle, &needReload)); + EXPECT_TRUE(compare_env("zesSchedulerSetExclusiveMode", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesSchedulerSetComputeUnitDebugMode(schedHandle, &needReload)); + EXPECT_TRUE(compare_env("zesSchedulerSetComputeUnitDebugMode", std::to_string(i + 1))); + } + } + + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManStandbyApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + uint32_t count = 1; + zes_standby_handle_t standbyHandle{}; + zes_standby_properties_t standbyProperties{}; + zes_standby_promo_mode_t standbyMode{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumStandbyDomains(deviceHandle, &count, &standbyHandle)); + EXPECT_TRUE(compare_env("zesDeviceEnumStandbyDomains", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbyGetProperties(standbyHandle, &standbyProperties)); + EXPECT_TRUE(compare_env("zesStandbyGetProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbyGetMode(standbyHandle, &standbyMode)); + EXPECT_TRUE(compare_env("zesStandbyGetMode", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbySetMode(standbyHandle, standbyMode)); + EXPECT_TRUE(compare_env("zesStandbySetMode", std::to_string(i + 1))); + } + } + + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManTemperatureApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + uint32_t count = 1; + zes_temp_handle_t tempHandle{}; + zes_temp_properties_t tempProperties{}; + zes_temp_config_t tempConfig{}; + double temperature = 0.0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumTemperatureSensors(deviceHandle, &count, &tempHandle)); + EXPECT_TRUE(compare_env("zesDeviceEnumTemperatureSensors", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(tempHandle, &tempProperties)); + EXPECT_TRUE(compare_env("zesTemperatureGetProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetConfig(tempHandle, &tempConfig)); + EXPECT_TRUE(compare_env("zesTemperatureGetConfig", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureSetConfig(tempHandle, &tempConfig)); + EXPECT_TRUE(compare_env("zesTemperatureSetConfig", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(tempHandle, &temperature)); + EXPECT_TRUE(compare_env("zesTemperatureGetState", std::to_string(i + 1))); + } + } + + TEST( + SysManApiLoaderDriverInteraction, + GivenLevelZeroLoaderPresentWhenCallingSysManOverclockApisThenExpectNullDriverIsReachedSuccessfully) + { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesInit(0)); + uint32_t driverCount = 0; + std::vector driverHandles{}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, nullptr)); + EXPECT_GT(driverCount, 0); + driverHandles.resize(driverCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDriverGet(&driverCount, driverHandles.data())); + + for (std::size_t i = 0; i < driverHandles.size(); i++) + { + uint32_t deviceCount = 1; + zes_device_handle_t deviceHandle{}; + uint32_t count = 1; + zes_overclock_handle_t overclockHandle{}; + zes_overclock_properties_t overclockProperties{}; + zes_vf_property_t vfProperties{}; + zes_overclock_control_t domainControl = ZES_OVERCLOCK_CONTROL_VF; + zes_overclock_domain_t domainType = ZES_OVERCLOCK_DOMAIN_GPU_ALL; + zes_control_property_t controlProperties{}; + double currentValue = 0.0; + double pendingValue = 0.0; + double userValue = 100.0; + zes_pending_action_t pendingAction{}; + zes_control_state_t controlState{}; + zes_vf_type_t vfType = ZES_VF_TYPE_VOLT; + zes_vf_array_type_t vfArrayType = ZES_VF_ARRAY_TYPE_USER_VF_ARRAY; + uint32_t pointIndex = 0; + uint32_t pointValue = 0; + uint32_t overclockDomains = 0; + uint32_t availableControls = 0; + ze_bool_t onShippedState = true; + zes_overclock_mode_t overclockMode{}; + ze_bool_t waiverSetting = false; + ze_bool_t overclockState = false; + ze_bool_t pendingReset = false; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGet(driverHandles[i], &deviceCount, &deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceGet", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceSetOverclockWaiver(deviceHandle)); + EXPECT_TRUE(compare_env("zesDeviceSetOverclockWaiver", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetOverclockDomains(deviceHandle, &overclockDomains)); + EXPECT_TRUE(compare_env("zesDeviceGetOverclockDomains", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceGetOverclockControls(deviceHandle, domainType, &availableControls)); + EXPECT_TRUE(compare_env("zesDeviceGetOverclockControls", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceResetOverclockSettings(deviceHandle, onShippedState)); + EXPECT_TRUE(compare_env("zesDeviceResetOverclockSettings", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceReadOverclockState(deviceHandle, &overclockMode, &waiverSetting, &overclockState, &pendingAction, &pendingReset)); + EXPECT_TRUE(compare_env("zesDeviceReadOverclockState", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumOverclockDomains(deviceHandle, &count, &overclockHandle)); + EXPECT_TRUE(compare_env("zesDeviceEnumOverclockDomains", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesOverclockGetDomainProperties(overclockHandle, &overclockProperties)); + EXPECT_TRUE(compare_env("zesOverclockGetDomainProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesOverclockGetDomainVFProperties(overclockHandle, &vfProperties)); + EXPECT_TRUE(compare_env("zesOverclockGetDomainVFProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesOverclockGetDomainControlProperties(overclockHandle, domainControl, &controlProperties)); + EXPECT_TRUE(compare_env("zesOverclockGetDomainControlProperties", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesOverclockGetControlCurrentValue(overclockHandle, domainControl, ¤tValue)); + EXPECT_TRUE(compare_env("zesOverclockGetControlCurrentValue", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesOverclockGetControlPendingValue(overclockHandle, domainControl, &pendingValue)); + EXPECT_TRUE(compare_env("zesOverclockGetControlPendingValue", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesOverclockSetControlUserValue(overclockHandle, domainControl, userValue, &pendingAction)); + EXPECT_TRUE(compare_env("zesOverclockSetControlUserValue", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesOverclockGetControlState(overclockHandle, domainControl, &controlState, &pendingAction)); + EXPECT_TRUE(compare_env("zesOverclockGetControlState", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesOverclockGetVFPointValues(overclockHandle, vfType, vfArrayType, pointIndex, &pointValue)); + EXPECT_TRUE(compare_env("zesOverclockGetVFPointValues", std::to_string(i + 1))); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesOverclockSetVFPointValues(overclockHandle, vfType, pointIndex, pointValue)); + EXPECT_TRUE(compare_env("zesOverclockSetVFPointValues", std::to_string(i + 1))); + } + } + // Helper function to clear ZEL_DRIVERS_ORDER environment variable void clearDriverOrderEnv() { putenv_safe(const_cast("ZEL_DRIVERS_ORDER="));