diff --git a/level_zero/sysman/test/unit_tests/sources/linux/test_sysman.cpp b/level_zero/sysman/test/unit_tests/sources/linux/test_sysman.cpp index bbdae9ef28..cfcb4ebfca 100644 --- a/level_zero/sysman/test/unit_tests/sources/linux/test_sysman.cpp +++ b/level_zero/sysman/test/unit_tests/sources/linux/test_sysman.cpp @@ -249,6 +249,14 @@ TEST_F(SysmanDeviceFixture, GivenInvalidPathnameWhenCallingFsAccessExistsThenErr EXPECT_FALSE(fsAccess->fileExists(path)); } +TEST_F(SysmanDeviceFixture, GivenInvalidPathnameWhenCallingSysFsAccessScanDirEntriesThenErrorIsReturned) { + auto pSysFsAccess = &pLinuxSysmanImp->getSysfsAccess(); + + std::string path = "noSuchDirectory"; + std::vector listFiles; + EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, pSysFsAccess->scanDirEntries(path, listFiles)); +} + TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndIntegerWhenCallingReadOnMultipleFilesThenSuccessIsReturned) { VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int { diff --git a/level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power.cpp b/level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power.cpp index 942b190b27..d4b5ae19d6 100644 --- a/level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power.cpp +++ b/level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power.cpp @@ -207,35 +207,6 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndHandleCountZeroWhen EXPECT_EQ(count, powerHandleComponentCount); } -HWTEST2_F(SysmanDevicePowerFixtureI915, GivenSetPowerLimitsWhenGettingPowerLimitsWhenHwmonInterfaceExistThenLimitsSetEarlierAreRetrieved, IsXeHpOrXeHpcOrXeHpgCore) { - auto handles = getPowerHandles(powerHandleComponentCount); - for (auto handle : handles) { - ASSERT_NE(nullptr, handle); - zes_power_sustained_limit_t sustainedSet = {}; - zes_power_sustained_limit_t sustainedGet = {}; - sustainedSet.enabled = 1; - sustainedSet.interval = 10; - sustainedSet.power = 300000; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr)); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr)); - EXPECT_EQ(sustainedGet.power, sustainedSet.power); - - zes_power_burst_limit_t burstGet = {}; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, nullptr, nullptr)); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr)); - EXPECT_EQ(burstGet.enabled, false); - EXPECT_EQ(burstGet.power, -1); - - zes_power_peak_limit_t peakSet = {}; - zes_power_peak_limit_t peakGet = {}; - peakSet.powerAC = 300000; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, nullptr, &peakSet)); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet)); - EXPECT_EQ(peakGet.powerAC, peakSet.powerAC); - EXPECT_EQ(peakGet.powerDC, -1); - } -} - TEST_F(SysmanDevicePowerFixtureI915, GivenDefaultLimitSysfsNodesNotAvailableWhenGettingPowerPropertiesThenApiCallReturnsFailure) { auto handles = getPowerHandles(powerHandleComponentCount); for (auto handle : handles) { @@ -264,104 +235,6 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenDefaultLimitSysfsNodesNotAvailableWhen } } -HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsPVC) { - auto handles = getPowerHandles(powerHandleComponentCount); - for (auto handle : handles) { - ASSERT_NE(nullptr, handle); - - uint32_t limitCount = 0; - const int32_t testLimit = 300000; - const int32_t testInterval = 10; - - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); - EXPECT_EQ(limitCount, mockLimitCount); - - limitCount++; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); - EXPECT_EQ(limitCount, mockLimitCount); - - std::vector allLimits(limitCount); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); - for (uint32_t i = 0; i < limitCount; i++) { - if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { - EXPECT_FALSE(allLimits[i].limitValueLocked); - EXPECT_TRUE(allLimits[i].enabledStateLocked); - EXPECT_FALSE(allLimits[i].intervalValueLocked); - EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); - EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit); - allLimits[i].limit = testLimit; - allLimits[i].interval = testInterval; - } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { - EXPECT_FALSE(allLimits[i].limitValueLocked); - EXPECT_TRUE(allLimits[i].enabledStateLocked); - EXPECT_TRUE(allLimits[i].intervalValueLocked); - EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); - EXPECT_EQ(ZES_LIMIT_UNIT_CURRENT, allLimits[i].limitUnit); - allLimits[i].limit = testLimit; - } - } - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data())); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); - for (uint32_t i = 0; i < limitCount; i++) { - if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { - EXPECT_EQ(testInterval, allLimits[i].interval); - } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { - EXPECT_EQ(0, allLimits[i].interval); - } - EXPECT_EQ(testLimit, allLimits[i].limit); - } - } -} - -HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsDG1) { - auto handles = getPowerHandles(powerHandleComponentCount); - for (auto handle : handles) { - ASSERT_NE(nullptr, handle); - - uint32_t limitCount = 0; - const int32_t testLimit = 300000; - const int32_t testInterval = 10; - - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); - EXPECT_EQ(limitCount, mockLimitCount); - - limitCount++; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); - EXPECT_EQ(limitCount, mockLimitCount); - - std::vector allLimits(limitCount); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); - for (uint32_t i = 0; i < limitCount; i++) { - if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { - EXPECT_FALSE(allLimits[i].limitValueLocked); - EXPECT_TRUE(allLimits[i].enabledStateLocked); - EXPECT_FALSE(allLimits[i].intervalValueLocked); - EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); - EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit); - allLimits[i].limit = testLimit; - allLimits[i].interval = testInterval; - } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { - EXPECT_FALSE(allLimits[i].limitValueLocked); - EXPECT_TRUE(allLimits[i].enabledStateLocked); - EXPECT_TRUE(allLimits[i].intervalValueLocked); - EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); - EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit); - allLimits[i].limit = testLimit; - } - } - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data())); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); - for (uint32_t i = 0; i < limitCount; i++) { - if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { - EXPECT_EQ(testInterval, allLimits[i].interval); - } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { - EXPECT_EQ(0, allLimits[i].interval); - } - EXPECT_EQ(testLimit, allLimits[i].limit); - } - } -} - TEST_F(SysmanDevicePowerFixtureI915, GivenReadingSustainedPowerLimitNodeReturnErrorWhenSetOrGetPowerLimitsWhenHwmonInterfaceExistForSustainedPowerLimitEnabledThenProperErrorCodesReturned) { auto handles = getPowerHandles(powerHandleComponentCount); @@ -502,36 +375,6 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenCallingGetPowerLim } } -HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndWritingToPeakLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned, IsPVC) { - auto handles = getPowerHandles(powerHandleComponentCount); - - pSysfsAccess->mockWritePeakLimitResult = ZE_RESULT_ERROR_NOT_AVAILABLE; - - for (auto handle : handles) { - ASSERT_NE(nullptr, handle); - uint32_t count = mockLimitCount; - std::vector allLimits(mockLimitCount); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data())); - - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data())); - } -} - -HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndWritingToPeakLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned, IsDG1) { - auto handles = getPowerHandles(powerHandleComponentCount); - - pSysfsAccess->mockWritePeakLimitResult = ZE_RESULT_ERROR_NOT_AVAILABLE; - - for (auto handle : handles) { - ASSERT_NE(nullptr, handle); - uint32_t count = mockLimitCount; - std::vector allLimits(mockLimitCount); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data())); - - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data())); - } -} - TEST_F(SysmanDevicePowerFixtureI915, GivenReadingPeakPowerLimitNodeReturnErrorWhenSetOrGetPowerLimitsWhenHwmonInterfaceExistForPeakPowerLimitEnabledThenProperErrorCodesReturned) { auto handles = getPowerHandles(powerHandleComponentCount); @@ -570,19 +413,6 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenReadingpeakPowerNodeReturnErrorWhenGet } } -HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleAndPermissionsThenFirstDisableSustainedPowerLimitAndThenEnableItAndCheckSuccesIsReturned, IsXeHpOrXeHpcOrXeHpgCore) { - auto handles = getPowerHandles(powerHandleComponentCount); - ASSERT_NE(nullptr, handles[0]); - zes_power_sustained_limit_t sustainedSet = {}; - zes_power_sustained_limit_t sustainedGet = {}; - sustainedSet.enabled = 0; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr)); - sustainedSet.power = 300000; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr)); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handles[0], &sustainedGet, nullptr, nullptr)); - EXPECT_EQ(sustainedGet.power, sustainedSet.power); -} - TEST_F(SysmanDevicePowerFixtureI915, GivenwritingSustainedPowerNodeReturnErrorWhenSetPowerLimitsForSustainedPowerWhenHwmonInterfaceExistThenProperErrorCodesReturned) { auto handles = getPowerHandles(powerHandleComponentCount); ASSERT_NE(nullptr, handles[0]); @@ -607,16 +437,6 @@ TEST_F(SysmanDevicePowerFixtureI915, GivenwritingSustainedPowerIntervalNodeRetur EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr)); } -HWTEST2_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenWritingToSustainedPowerEnableNodeWithoutPermissionsThenValidErrorIsReturned, IsXeHpOrXeHpcOrXeHpgCore) { - auto handles = getPowerHandles(powerHandleComponentCount); - ASSERT_NE(nullptr, handles[0]); - - pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS); - zes_power_sustained_limit_t sustainedSet = {}; - sustainedSet.enabled = 0; - EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr)); -} - TEST_F(SysmanDevicePowerFixtureI915, GivenValidPowerHandleWhenGettingPowerPropertiesThenCallSucceeds) { for (const auto &handle : pSysmanDeviceImp->pPowerHandleContext->handleList) { diff --git a/level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power_helper.cpp b/level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power_helper.cpp index 6e8242e8af..b545c139a4 100644 --- a/level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power_helper.cpp +++ b/level_zero/sysman/test/unit_tests/sources/power/linux/test_zes_power_helper.cpp @@ -210,191 +210,6 @@ TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandleWhenGetti } } -HWTEST2_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenSetPowerLimitsWhenGettingPowerLimitsThenLimitsSetEarlierAreRetrieved, IsXeHpOrXeHpcOrXeHpgCore) { - auto handles = getPowerHandles(powerHandleComponentCountMultiDevice); - for (auto handle : handles) { - ASSERT_NE(nullptr, handle); - zes_power_properties_t properties = {}; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties)); - - zes_power_sustained_limit_t sustainedSet = {}; - zes_power_sustained_limit_t sustainedGet = {}; - sustainedSet.power = 300000; - if (!properties.onSubdevice) { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr)); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr)); - EXPECT_EQ(sustainedGet.power, sustainedSet.power); - } else { - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr)); - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr)); - } - - zes_power_burst_limit_t burstGet = {}; - if (!properties.onSubdevice) { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr)); - EXPECT_EQ(burstGet.enabled, false); - EXPECT_EQ(burstGet.power, -1); - } else { - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr)); - } - - zes_power_peak_limit_t peakSet = {}; - zes_power_peak_limit_t peakGet = {}; - peakSet.powerAC = 300000; - if (!properties.onSubdevice) { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, nullptr, &peakSet)); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet)); - EXPECT_EQ(peakGet.powerAC, peakSet.powerAC); - EXPECT_EQ(peakGet.powerDC, -1); - } else { - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet)); - } - } -} - -HWTEST2_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsPVC) { - auto handles = getPowerHandles(powerHandleComponentCountMultiDevice); - for (auto handle : handles) { - ASSERT_NE(nullptr, handle); - - uint32_t limitCount = 0; - const int32_t testLimit = 300000; - const int32_t testInterval = 10; - - zes_power_properties_t properties = {}; - zes_power_limit_ext_desc_t limits = {}; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties)); - - if (!properties.onSubdevice) { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); - EXPECT_EQ(limitCount, mockLimitCount); - } else { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, &limits)); - EXPECT_EQ(limitCount, 0u); - } - - limitCount++; - if (!properties.onSubdevice) { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); - EXPECT_EQ(limitCount, mockLimitCount); - } else { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); - EXPECT_EQ(limitCount, 0u); - } - - std::vector allLimits(limitCount); - if (!properties.onSubdevice) { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); - } else { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); - EXPECT_EQ(limitCount, 0u); - } - for (uint32_t i = 0; i < limitCount; i++) { - if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { - EXPECT_FALSE(allLimits[i].limitValueLocked); - EXPECT_TRUE(allLimits[i].enabledStateLocked); - EXPECT_FALSE(allLimits[i].intervalValueLocked); - EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); - EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit); - allLimits[i].limit = testLimit; - allLimits[i].interval = testInterval; - } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { - EXPECT_FALSE(allLimits[i].limitValueLocked); - EXPECT_TRUE(allLimits[i].enabledStateLocked); - EXPECT_TRUE(allLimits[i].intervalValueLocked); - EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); - EXPECT_EQ(ZES_LIMIT_UNIT_CURRENT, allLimits[i].limitUnit); - allLimits[i].limit = testLimit; - } - } - if (!properties.onSubdevice) { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data())); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); - for (uint32_t i = 0; i < limitCount; i++) { - if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { - EXPECT_EQ(testInterval, allLimits[i].interval); - } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { - EXPECT_EQ(0, allLimits[i].interval); - } - EXPECT_EQ(testLimit, allLimits[i].limit); - } - } else { - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data())); - } - } -} - -HWTEST2_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsDG1) { - auto handles = getPowerHandles(powerHandleComponentCountMultiDevice); - for (auto handle : handles) { - ASSERT_NE(nullptr, handle); - uint32_t limitCount = 0; - const int32_t testLimit = 300000; - const int32_t testInterval = 10; - - zes_power_properties_t properties = {}; - zes_power_limit_ext_desc_t limits = {}; - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties)); - - if (!properties.onSubdevice) { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); - EXPECT_EQ(limitCount, mockLimitCount); - } else { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, &limits)); - EXPECT_EQ(limitCount, 0u); - } - - limitCount++; - if (!properties.onSubdevice) { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); - EXPECT_EQ(limitCount, mockLimitCount); - } else { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); - EXPECT_EQ(limitCount, 0u); - } - - std::vector allLimits(limitCount); - if (!properties.onSubdevice) { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); - } else { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); - EXPECT_EQ(limitCount, 0u); - } - for (uint32_t i = 0; i < limitCount; i++) { - if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { - EXPECT_FALSE(allLimits[i].limitValueLocked); - EXPECT_TRUE(allLimits[i].enabledStateLocked); - EXPECT_FALSE(allLimits[i].intervalValueLocked); - EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); - EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit); - allLimits[i].limit = testLimit; - allLimits[i].interval = testInterval; - } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { - EXPECT_FALSE(allLimits[i].limitValueLocked); - EXPECT_TRUE(allLimits[i].enabledStateLocked); - EXPECT_TRUE(allLimits[i].intervalValueLocked); - EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); - EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit); - allLimits[i].limit = testLimit; - } - } - if (!properties.onSubdevice) { - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data())); - EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); - for (uint32_t i = 0; i < limitCount; i++) { - if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { - EXPECT_EQ(testInterval, allLimits[i].interval); - } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { - EXPECT_EQ(0, allLimits[i].interval); - } - EXPECT_EQ(testLimit, allLimits[i].limit); - } - } else { - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data())); - } - } -} - } // namespace ult } // namespace Sysman } // namespace L0 diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_power_tests.cpp b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_power_tests.cpp index 3761225732..8692ea26c5 100644 --- a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_power_tests.cpp +++ b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_power_tests.cpp @@ -13,12 +13,11 @@ namespace L0 { namespace Sysman { namespace ult { -using SysmanProductHelperPowerTest = SysmanDeviceFixture; +using SysmanProductHelperPowerTest = SysmanDevicePowerFixtureI915; constexpr uint32_t powerHandleComponentCount = 1u; static int mockReadLinkSuccess(const char *path, char *buf, size_t bufsize) { - std::map fileNameLinkMap = { {sysfsPathTelem, realPathTelem}, }; @@ -283,6 +282,374 @@ HWTEST2_F(SysmanProductHelperPowerTest, GivenComponentCountZeroWhenEnumeratingPo } } +HWTEST2_F(SysmanProductHelperPowerTest, GivenSetPowerLimitsWhenGettingPowerLimitsWhenHwmonInterfaceExistThenLimitsSetEarlierAreRetrieved, IsXeHpOrXeHpcOrXeHpgCore) { + auto handles = getPowerHandles(powerHandleComponentCount); + for (auto handle : handles) { + ASSERT_NE(nullptr, handle); + zes_power_sustained_limit_t sustainedSet = {}; + zes_power_sustained_limit_t sustainedGet = {}; + sustainedSet.enabled = 1; + sustainedSet.interval = 10; + sustainedSet.power = 300000; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr)); + EXPECT_EQ(sustainedGet.power, sustainedSet.power); + + zes_power_burst_limit_t burstGet = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, nullptr, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr)); + EXPECT_EQ(burstGet.enabled, false); + EXPECT_EQ(burstGet.power, -1); + + zes_power_peak_limit_t peakSet = {}; + zes_power_peak_limit_t peakGet = {}; + peakSet.powerAC = 300000; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, nullptr, &peakSet)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet)); + EXPECT_EQ(peakGet.powerAC, peakSet.powerAC); + EXPECT_EQ(peakGet.powerDC, -1); + } +} + +HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsPVC) { + auto handles = getPowerHandles(powerHandleComponentCount); + for (auto handle : handles) { + ASSERT_NE(nullptr, handle); + + uint32_t limitCount = 0; + const int32_t testLimit = 300000; + const int32_t testInterval = 10; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); + EXPECT_EQ(limitCount, mockLimitCount); + + limitCount++; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); + EXPECT_EQ(limitCount, mockLimitCount); + + std::vector allLimits(limitCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); + for (uint32_t i = 0; i < limitCount; i++) { + if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { + EXPECT_FALSE(allLimits[i].limitValueLocked); + EXPECT_TRUE(allLimits[i].enabledStateLocked); + EXPECT_FALSE(allLimits[i].intervalValueLocked); + EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); + EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit); + allLimits[i].limit = testLimit; + allLimits[i].interval = testInterval; + } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { + EXPECT_FALSE(allLimits[i].limitValueLocked); + EXPECT_TRUE(allLimits[i].enabledStateLocked); + EXPECT_TRUE(allLimits[i].intervalValueLocked); + EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); + EXPECT_EQ(ZES_LIMIT_UNIT_CURRENT, allLimits[i].limitUnit); + allLimits[i].limit = testLimit; + } + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data())); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); + for (uint32_t i = 0; i < limitCount; i++) { + if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { + EXPECT_EQ(testInterval, allLimits[i].interval); + } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { + EXPECT_EQ(0, allLimits[i].interval); + } + EXPECT_EQ(testLimit, allLimits[i].limit); + } + } +} + +HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsDG1) { + auto handles = getPowerHandles(powerHandleComponentCount); + for (auto handle : handles) { + ASSERT_NE(nullptr, handle); + + uint32_t limitCount = 0; + const int32_t testLimit = 300000; + const int32_t testInterval = 10; + + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); + EXPECT_EQ(limitCount, mockLimitCount); + + limitCount++; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); + EXPECT_EQ(limitCount, mockLimitCount); + + std::vector allLimits(limitCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); + for (uint32_t i = 0; i < limitCount; i++) { + if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { + EXPECT_FALSE(allLimits[i].limitValueLocked); + EXPECT_TRUE(allLimits[i].enabledStateLocked); + EXPECT_FALSE(allLimits[i].intervalValueLocked); + EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); + EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit); + allLimits[i].limit = testLimit; + allLimits[i].interval = testInterval; + } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { + EXPECT_FALSE(allLimits[i].limitValueLocked); + EXPECT_TRUE(allLimits[i].enabledStateLocked); + EXPECT_TRUE(allLimits[i].intervalValueLocked); + EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); + EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit); + allLimits[i].limit = testLimit; + } + } + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data())); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); + for (uint32_t i = 0; i < limitCount; i++) { + if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { + EXPECT_EQ(testInterval, allLimits[i].interval); + } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { + EXPECT_EQ(0, allLimits[i].interval); + } + EXPECT_EQ(testLimit, allLimits[i].limit); + } + } +} + +HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandleAndWritingToPeakLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned, IsPVC) { + auto handles = getPowerHandles(powerHandleComponentCount); + + pSysfsAccess->mockWritePeakLimitResult = ZE_RESULT_ERROR_NOT_AVAILABLE; + + for (auto handle : handles) { + ASSERT_NE(nullptr, handle); + uint32_t count = mockLimitCount; + std::vector allLimits(mockLimitCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data())); + + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data())); + } +} + +HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandleAndWritingToPeakLimitSysNodesFailsWhenCallingSetPowerLimitsExtThenProperErrorCodesReturned, IsDG1) { + auto handles = getPowerHandles(powerHandleComponentCount); + + pSysfsAccess->mockWritePeakLimitResult = ZE_RESULT_ERROR_NOT_AVAILABLE; + + for (auto handle : handles) { + ASSERT_NE(nullptr, handle); + uint32_t count = mockLimitCount; + std::vector allLimits(mockLimitCount); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &count, allLimits.data())); + + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &count, allLimits.data())); + } +} + +HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandleAndPermissionsThenFirstDisableSustainedPowerLimitAndThenEnableItAndCheckSuccesIsReturned, IsXeHpOrXeHpcOrXeHpgCore) { + auto handles = getPowerHandles(powerHandleComponentCount); + ASSERT_NE(nullptr, handles[0]); + zes_power_sustained_limit_t sustainedSet = {}; + zes_power_sustained_limit_t sustainedGet = {}; + sustainedSet.enabled = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr)); + sustainedSet.power = 300000; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handles[0], &sustainedGet, nullptr, nullptr)); + EXPECT_EQ(sustainedGet.power, sustainedSet.power); +} + +HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandleWhenWritingToSustainedPowerEnableNodeWithoutPermissionsThenValidErrorIsReturned, IsXeHpOrXeHpcOrXeHpgCore) { + auto handles = getPowerHandles(powerHandleComponentCount); + ASSERT_NE(nullptr, handles[0]); + + pSysfsAccess->mockWriteUnsignedResult.push_back(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS); + zes_power_sustained_limit_t sustainedSet = {}; + sustainedSet.enabled = 0; + EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, zesPowerSetLimits(handles[0], &sustainedSet, nullptr, nullptr)); +} + +using SysmanProductHelperPowerMultiDeviceTest = SysmanDevicePowerMultiDeviceFixture; +constexpr uint32_t powerHandleComponentCountMultiDevice = 3u; + +HWTEST2_F(SysmanProductHelperPowerMultiDeviceTest, GivenSetPowerLimitsWhenGettingPowerLimitsThenLimitsSetEarlierAreRetrieved, IsXeHpOrXeHpcOrXeHpgCore) { + auto handles = getPowerHandles(powerHandleComponentCountMultiDevice); + for (auto handle : handles) { + ASSERT_NE(nullptr, handle); + zes_power_properties_t properties = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties)); + + zes_power_sustained_limit_t sustainedSet = {}; + zes_power_sustained_limit_t sustainedGet = {}; + sustainedSet.power = 300000; + if (!properties.onSubdevice) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr)); + EXPECT_EQ(sustainedGet.power, sustainedSet.power); + } else { + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimits(handle, &sustainedSet, nullptr, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, &sustainedGet, nullptr, nullptr)); + } + + zes_power_burst_limit_t burstGet = {}; + if (!properties.onSubdevice) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr)); + EXPECT_EQ(burstGet.enabled, false); + EXPECT_EQ(burstGet.power, -1); + } else { + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, &burstGet, nullptr)); + } + + zes_power_peak_limit_t peakSet = {}; + zes_power_peak_limit_t peakGet = {}; + peakSet.powerAC = 300000; + if (!properties.onSubdevice) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimits(handle, nullptr, nullptr, &peakSet)); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet)); + EXPECT_EQ(peakGet.powerAC, peakSet.powerAC); + EXPECT_EQ(peakGet.powerDC, -1); + } else { + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerGetLimits(handle, nullptr, nullptr, &peakGet)); + } + } +} + +HWTEST2_F(SysmanProductHelperPowerMultiDeviceTest, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsPVC) { + auto handles = getPowerHandles(powerHandleComponentCountMultiDevice); + for (auto handle : handles) { + ASSERT_NE(nullptr, handle); + + uint32_t limitCount = 0; + const int32_t testLimit = 300000; + const int32_t testInterval = 10; + + zes_power_properties_t properties = {}; + zes_power_limit_ext_desc_t limits = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties)); + + if (!properties.onSubdevice) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); + EXPECT_EQ(limitCount, mockLimitCount); + } else { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, &limits)); + EXPECT_EQ(limitCount, 0u); + } + + limitCount++; + if (!properties.onSubdevice) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); + EXPECT_EQ(limitCount, mockLimitCount); + } else { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); + EXPECT_EQ(limitCount, 0u); + } + + std::vector allLimits(limitCount); + if (!properties.onSubdevice) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); + } else { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); + EXPECT_EQ(limitCount, 0u); + } + for (uint32_t i = 0; i < limitCount; i++) { + if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { + EXPECT_FALSE(allLimits[i].limitValueLocked); + EXPECT_TRUE(allLimits[i].enabledStateLocked); + EXPECT_FALSE(allLimits[i].intervalValueLocked); + EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); + EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit); + allLimits[i].limit = testLimit; + allLimits[i].interval = testInterval; + } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { + EXPECT_FALSE(allLimits[i].limitValueLocked); + EXPECT_TRUE(allLimits[i].enabledStateLocked); + EXPECT_TRUE(allLimits[i].intervalValueLocked); + EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); + EXPECT_EQ(ZES_LIMIT_UNIT_CURRENT, allLimits[i].limitUnit); + allLimits[i].limit = testLimit; + } + } + if (!properties.onSubdevice) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data())); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); + for (uint32_t i = 0; i < limitCount; i++) { + if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { + EXPECT_EQ(testInterval, allLimits[i].interval); + } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { + EXPECT_EQ(0, allLimits[i].interval); + } + EXPECT_EQ(testLimit, allLimits[i].limit); + } + } else { + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data())); + } + } +} + +HWTEST2_F(SysmanProductHelperPowerMultiDeviceTest, GivenValidPowerHandlesWhenCallingSetAndGetPowerLimitExtThenLimitsSetEarlierAreRetrieved, IsDG1) { + auto handles = getPowerHandles(powerHandleComponentCountMultiDevice); + for (auto handle : handles) { + ASSERT_NE(nullptr, handle); + uint32_t limitCount = 0; + const int32_t testLimit = 300000; + const int32_t testInterval = 10; + + zes_power_properties_t properties = {}; + zes_power_limit_ext_desc_t limits = {}; + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetProperties(handle, &properties)); + + if (!properties.onSubdevice) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); + EXPECT_EQ(limitCount, mockLimitCount); + } else { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, &limits)); + EXPECT_EQ(limitCount, 0u); + } + + limitCount++; + if (!properties.onSubdevice) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); + EXPECT_EQ(limitCount, mockLimitCount); + } else { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, nullptr)); + EXPECT_EQ(limitCount, 0u); + } + + std::vector allLimits(limitCount); + if (!properties.onSubdevice) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); + } else { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); + EXPECT_EQ(limitCount, 0u); + } + for (uint32_t i = 0; i < limitCount; i++) { + if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { + EXPECT_FALSE(allLimits[i].limitValueLocked); + EXPECT_TRUE(allLimits[i].enabledStateLocked); + EXPECT_FALSE(allLimits[i].intervalValueLocked); + EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); + EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit); + allLimits[i].limit = testLimit; + allLimits[i].interval = testInterval; + } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { + EXPECT_FALSE(allLimits[i].limitValueLocked); + EXPECT_TRUE(allLimits[i].enabledStateLocked); + EXPECT_TRUE(allLimits[i].intervalValueLocked); + EXPECT_EQ(ZES_POWER_SOURCE_ANY, allLimits[i].source); + EXPECT_EQ(ZES_LIMIT_UNIT_POWER, allLimits[i].limitUnit); + allLimits[i].limit = testLimit; + } + } + if (!properties.onSubdevice) { + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data())); + EXPECT_EQ(ZE_RESULT_SUCCESS, zesPowerGetLimitsExt(handle, &limitCount, allLimits.data())); + for (uint32_t i = 0; i < limitCount; i++) { + if (allLimits[i].level == ZES_POWER_LEVEL_SUSTAINED) { + EXPECT_EQ(testInterval, allLimits[i].interval); + } else if (allLimits[i].level == ZES_POWER_LEVEL_PEAK) { + EXPECT_EQ(0, allLimits[i].interval); + } + EXPECT_EQ(testLimit, allLimits[i].limit); + } + } else { + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesPowerSetLimitsExt(handle, &limitCount, allLimits.data())); + } + } +} + } // namespace ult } // namespace Sysman } // namespace L0