Update sysman standby APIs to support latest spec.

Change-Id: I7a605c538432b2117ba968f155e4665078abc94f
Signed-off-by: Vilvaraj, T J Vivek <t.j.vivek.vilvaraj@intel.com>

level_zero/tools/source/sysman/linux/os_sysman_imp.h

@@ -5,6 +5,7 @@
  *
  */
 
+#pragma once
 #include "shared/source/helpers/non_copyable_or_moveable.h"
 #include "shared/source/os_interface/linux/drm_neo.h"
 #include "shared/source/os_interface/linux/os_interface.h"

level_zero/tools/source/sysman/standby/linux/os_standby_imp.cpp

@@ -11,24 +11,54 @@ namespace L0 {
 
 const std::string LinuxStandbyImp::standbyModeFile("power/rc6_enable");
 
+bool LinuxStandbyImp::isStandbySupported(void) {
+    if (ZE_RESULT_SUCCESS == pSysfsAccess->canRead(standbyModeFile)) {
+        return true;
+    } else {
+        return false;
+    }
+}
 ze_result_t LinuxStandbyImp::getMode(zet_standby_promo_mode_t &mode) {
-    int currentMode;
+    int currentMode = -1;
     ze_result_t result = pSysfsAccess->read(standbyModeFile, currentMode);
     if (ZE_RESULT_SUCCESS != result) {
         return result;
     }
     if (standbyModeDefault == currentMode) {
         mode = ZET_STANDBY_PROMO_MODE_DEFAULT;
-        return ZE_RESULT_SUCCESS;
-    }
-    if (standbyModeNever == currentMode) {
+    } else if (standbyModeNever == currentMode) {
         mode = ZET_STANDBY_PROMO_MODE_NEVER;
-        return ZE_RESULT_SUCCESS;
+    } else {
+        result = ZE_RESULT_ERROR_UNKNOWN;
     }
-    return ZE_RESULT_ERROR_UNKNOWN;
+    return result;
+}
+ze_result_t LinuxStandbyImp::setMode(zet_standby_promo_mode_t mode) {
+    // standbyModeFile is not writable.
+    // Mode cannot be set from L0.
+    // To set the mode, user must reload
+    // the i915 module and set module parameter
+    // enable_rc6 appropriately.
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
-ze_result_t LinuxStandbyImp::setMode(zet_standby_promo_mode_t mode) {
+ze_result_t LinuxStandbyImp::getMode(zes_standby_promo_mode_t &mode) {
+    int currentMode = -1;
+    ze_result_t result = pSysfsAccess->read(standbyModeFile, currentMode);
+    if (ZE_RESULT_SUCCESS != result) {
+        return result;
+    }
+    if (standbyModeDefault == currentMode) {
+        mode = ZES_STANDBY_PROMO_MODE_DEFAULT;
+    } else if (standbyModeNever == currentMode) {
+        mode = ZES_STANDBY_PROMO_MODE_NEVER;
+    } else {
+        result = ZE_RESULT_ERROR_UNKNOWN;
+    }
+    return result;
+}
+
+ze_result_t LinuxStandbyImp::setMode(zes_standby_promo_mode_t mode) {
     // standbyModeFile is not writable.
     // Mode cannot be set from L0.
     // To set the mode, user must reload

level_zero/tools/source/sysman/standby/linux/os_standby_imp.h

@@ -18,6 +18,12 @@ class LinuxStandbyImp : public OsStandby, NEO::NonCopyableOrMovableClass {
   public:
     ze_result_t getMode(zet_standby_promo_mode_t &mode) override;
     ze_result_t setMode(zet_standby_promo_mode_t mode) override;
+
+    ze_result_t getMode(zes_standby_promo_mode_t &mode) override;
+    ze_result_t setMode(zes_standby_promo_mode_t mode) override;
+
+    bool isStandbySupported(void) override;
+
     LinuxStandbyImp() = default;
     LinuxStandbyImp(OsSysman *pOsSysman);
     ~LinuxStandbyImp() override = default;

level_zero/tools/source/sysman/standby/os_standby.h

@@ -10,6 +10,8 @@
 #include "level_zero/tools/source/sysman/os_sysman.h"
 #include <level_zero/zet_api.h>
 
+#include "third_party/level_zero/zes_api_ext.h"
+
 namespace L0 {
 
 class OsStandby {
@@ -17,6 +19,11 @@ class OsStandby {
     virtual ze_result_t getMode(zet_standby_promo_mode_t &mode) = 0;
     virtual ze_result_t setMode(zet_standby_promo_mode_t mode) = 0;
 
+    virtual ze_result_t getMode(zes_standby_promo_mode_t &mode) = 0;
+    virtual ze_result_t setMode(zes_standby_promo_mode_t mode) = 0;
+
+    virtual bool isStandbySupported(void) = 0;
+
     static OsStandby *create(OsSysman *pOsSysman);
     virtual ~OsStandby() {}
 };

level_zero/tools/source/sysman/standby/standby.cpp

@@ -19,10 +19,13 @@ StandbyHandleContext::~StandbyHandleContext() {
     }
 }
 
-ze_result_t StandbyHandleContext::init() {
+void StandbyHandleContext::init() {
     Standby *pStandby = new StandbyImp(pOsSysman);
-    handleList.push_back(pStandby);
-    return ZE_RESULT_SUCCESS;
+    if (pStandby->isStandbyEnabled == true) {
+        handleList.push_back(pStandby);
+    } else {
+        delete pStandby;
+    }
 }
 
 ze_result_t StandbyHandleContext::standbyGet(uint32_t *pCount, zet_sysman_standby_handle_t *phStandby) {
@@ -39,4 +42,17 @@ ze_result_t StandbyHandleContext::standbyGet(uint32_t *pCount, zet_sysman_standb
     return ZE_RESULT_SUCCESS;
 }
 
+ze_result_t StandbyHandleContext::standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby) {
+    uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
+    uint32_t numToCopy = std::min(*pCount, handleListSize);
+    if (0 == *pCount || *pCount > handleListSize) {
+        *pCount = handleListSize;
+    }
+    if (nullptr != phStandby) {
+        for (uint32_t i = 0; i < numToCopy; i++) {
+            phStandby[i] = handleList[i]->toStandbyHandle();
+        }
+    }
+    return ZE_RESULT_SUCCESS;
+}
 } // namespace L0

level_zero/tools/source/sysman/standby/standby.h

@@ -8,34 +8,53 @@
 #pragma once
 #include <level_zero/zet_api.h>
 
+#include "third_party/level_zero/zes_api_ext.h"
+
 #include <vector>
 
-struct _zet_sysman_standby_handle_t {};
+struct _zet_sysman_standby_handle_t {
+    virtual ~_zet_sysman_standby_handle_t() = default;
+};
+struct _zes_standby_handle_t {
+    virtual ~_zes_standby_handle_t() = default;
+};
 
 namespace L0 {
 
 struct OsSysman;
 
-class Standby : _zet_sysman_standby_handle_t {
+class Standby : _zet_sysman_standby_handle_t, _zes_standby_handle_t {
   public:
     virtual ~Standby() {}
     virtual ze_result_t standbyGetProperties(zet_standby_properties_t *pProperties) = 0;
     virtual ze_result_t standbyGetMode(zet_standby_promo_mode_t *pMode) = 0;
     virtual ze_result_t standbySetMode(const zet_standby_promo_mode_t mode) = 0;
 
+    virtual ze_result_t standbyGetProperties(zes_standby_properties_t *pProperties) = 0;
+    virtual ze_result_t standbyGetMode(zes_standby_promo_mode_t *pMode) = 0;
+    virtual ze_result_t standbySetMode(const zes_standby_promo_mode_t mode) = 0;
+
+    inline zet_sysman_standby_handle_t toHandle() { return this; }
+    inline zes_standby_handle_t toStandbyHandle() { return this; }
+
     static Standby *fromHandle(zet_sysman_standby_handle_t handle) {
         return static_cast<Standby *>(handle);
     }
-    inline zet_sysman_standby_handle_t toHandle() { return this; }
+
+    static Standby *fromHandle(zes_standby_handle_t handle) {
+        return static_cast<Standby *>(handle);
+    }
+    bool isStandbyEnabled = false;
 };
 
 struct StandbyHandleContext {
     StandbyHandleContext(OsSysman *pOsSysman) : pOsSysman(pOsSysman){};
     ~StandbyHandleContext();
 
-    ze_result_t init();
+    void init();
 
     ze_result_t standbyGet(uint32_t *pCount, zet_sysman_standby_handle_t *phStandby);
+    ze_result_t standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby);
 
     OsSysman *pOsSysman;
     std::vector<Standby *> handleList = {};

level_zero/tools/source/sysman/standby/standby_imp.cpp

@@ -26,16 +26,33 @@ ze_result_t StandbyImp::standbySetMode(const zet_standby_promo_mode_t mode) {
     return pOsStandby->setMode(mode);
 }
 
+ze_result_t StandbyImp::standbyGetProperties(zes_standby_properties_t *pProperties) {
+    *pProperties = zesStandbyProperties;
+    return ZE_RESULT_SUCCESS;
+}
+
+ze_result_t StandbyImp::standbyGetMode(zes_standby_promo_mode_t *pMode) {
+    return pOsStandby->getMode(*pMode);
+}
+
+ze_result_t StandbyImp::standbySetMode(const zes_standby_promo_mode_t mode) {
+    return pOsStandby->setMode(mode);
+}
+
 void StandbyImp::init() {
     standbyProperties.type = ZET_STANDBY_TYPE_GLOBAL; // Currently the only defined type
     standbyProperties.onSubdevice = false;
     standbyProperties.subdeviceId = 0;
+    zesStandbyProperties.type = ZES_STANDBY_TYPE_GLOBAL;
+    zesStandbyProperties.onSubdevice = false;
+    zesStandbyProperties.subdeviceId = 0;
+    zesStandbyProperties.pNext = nullptr;
+    this->isStandbyEnabled = pOsStandby->isStandbySupported();
 }
 
 StandbyImp::StandbyImp(OsSysman *pOsSysman) {
     pOsStandby = OsStandby::create(pOsSysman);
     UNRECOVERABLE_IF(nullptr == pOsStandby);
-
     init();
 }
 

level_zero/tools/source/sysman/standby/standby_imp.h

@@ -12,6 +12,7 @@
 
 #include "os_standby.h"
 #include "standby.h"
+#include "third_party/level_zero/zes_api_ext.h"
 
 namespace L0 {
 
@@ -21,6 +22,10 @@ class StandbyImp : public Standby, NEO::NonCopyableOrMovableClass {
     ze_result_t standbyGetMode(zet_standby_promo_mode_t *pMode) override;
     ze_result_t standbySetMode(const zet_standby_promo_mode_t mode) override;
 
+    ze_result_t standbyGetProperties(zes_standby_properties_t *pProperties) override;
+    ze_result_t standbyGetMode(zes_standby_promo_mode_t *pMode) override;
+    ze_result_t standbySetMode(const zes_standby_promo_mode_t mode) override;
+
     StandbyImp() = default;
     StandbyImp(OsSysman *pOsSysman);
     ~StandbyImp() override;
@@ -30,6 +35,7 @@ class StandbyImp : public Standby, NEO::NonCopyableOrMovableClass {
 
   private:
     zet_standby_properties_t standbyProperties = {};
+    zes_standby_properties_t zesStandbyProperties = {};
 };
 
 } // namespace L0

level_zero/tools/source/sysman/standby/windows/os_standby_imp.cpp

@@ -13,6 +13,9 @@ class WddmStandbyImp : public OsStandby {
   public:
     ze_result_t getMode(zet_standby_promo_mode_t &mode) override;
     ze_result_t setMode(zet_standby_promo_mode_t mode) override;
+    ze_result_t getMode(zes_standby_promo_mode_t &mode) override;
+    ze_result_t setMode(zes_standby_promo_mode_t mode) override;
+    bool isStandbySupported(void) override;
 };
 
 ze_result_t WddmStandbyImp::getMode(zet_standby_promo_mode_t &mode) {
@@ -23,6 +26,18 @@ ze_result_t WddmStandbyImp::setMode(zet_standby_promo_mode_t mode) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }
 
+ze_result_t WddmStandbyImp::getMode(zes_standby_promo_mode_t &mode) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+ze_result_t WddmStandbyImp::setMode(zes_standby_promo_mode_t mode) {
+    return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
+}
+
+bool WddmStandbyImp::isStandbySupported(void) {
+    return false;
+}
+
 OsStandby *OsStandby::create(OsSysman *pOsSysman) {
     WddmStandbyImp *pWddmStandbyImp = new WddmStandbyImp();
     return static_cast<OsStandby *>(pWddmStandbyImp);

level_zero/tools/source/sysman/sysman.h

@@ -85,6 +85,7 @@ struct SysmanDevice : _ze_device_handle_t {
     virtual ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) = 0;
     virtual ze_result_t fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort) = 0;
     virtual ze_result_t temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) = 0;
+    virtual ze_result_t standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby) = 0;
     virtual ~SysmanDevice() = default;
 };
 

level_zero/tools/source/sysman/sysman_imp.cpp

@@ -26,9 +26,11 @@ SysmanDeviceImp::SysmanDeviceImp(ze_device_handle_t hDevice) {
     pFrequencyHandleContext = new FrequencyHandleContext(pOsSysman);
     pFabricPortHandleContext = new FabricPortHandleContext(pOsSysman);
     pTempHandleContext = new TemperatureHandleContext(pOsSysman);
+    pStandbyHandleContext = new StandbyHandleContext(pOsSysman);
 }
 
 SysmanDeviceImp::~SysmanDeviceImp() {
+    freeResource(pStandbyHandleContext);
     freeResource(pTempHandleContext);
     freeResource(pFabricPortHandleContext);
     freeResource(pFrequencyHandleContext);
@@ -50,6 +52,9 @@ void SysmanDeviceImp::init() {
     if (pTempHandleContext) {
         pTempHandleContext->init();
     }
+    if (pStandbyHandleContext) {
+        pStandbyHandleContext->init();
+    }
 }
 
 SysmanImp::SysmanImp(ze_device_handle_t hDevice) {
@@ -226,6 +231,10 @@ ze_result_t SysmanImp::standbyGet(uint32_t *pCount, zet_sysman_standby_handle_t
     return pStandbyHandleContext->standbyGet(pCount, phStandby);
 }
 
+ze_result_t SysmanDeviceImp::standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby) {
+    return pStandbyHandleContext->standbyGet(pCount, phStandby);
+}
+
 ze_result_t SysmanImp::firmwareGet(uint32_t *pCount, zet_sysman_firmware_handle_t *phFirmware) {
     return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
 }

level_zero/tools/source/sysman/sysman_imp.h

@@ -95,11 +95,13 @@ struct SysmanDeviceImp : SysmanDevice, NEO::NonCopyableOrMovableClass {
     FrequencyHandleContext *pFrequencyHandleContext = nullptr;
     FabricPortHandleContext *pFabricPortHandleContext = nullptr;
     TemperatureHandleContext *pTempHandleContext = nullptr;
+    StandbyHandleContext *pStandbyHandleContext = nullptr;
 
     ze_result_t powerGet(uint32_t *pCount, zes_pwr_handle_t *phPower) override;
     ze_result_t frequencyGet(uint32_t *pCount, zes_freq_handle_t *phFrequency) override;
     ze_result_t fabricPortGet(uint32_t *pCount, zes_fabric_port_handle_t *phPort) override;
     ze_result_t temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) override;
+    ze_result_t standbyGet(uint32_t *pCount, zes_standby_handle_t *phStandby) override;
 
   private:
     template <typename T>

level_zero/tools/test/unit_tests/sources/sysman/standby/linux/CMakeLists.txt

@@ -10,5 +10,7 @@ if(UNIX)
            ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
            ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_standby.cpp
            ${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_standby.h
+           ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_sysman_standby.cpp
+
     )
 endif()

level_zero/tools/test/unit_tests/sources/sysman/standby/linux/mock_sysfs_standby.h

@@ -6,20 +6,9 @@
  */
 
 #pragma once
-#include "level_zero/core/test/unit_tests/mock.h"
+
 #include "level_zero/tools/source/sysman/standby/linux/os_standby_imp.h"
 
-#include "sysman/linux/fs_access.h"
-#include "sysman/standby/os_standby.h"
-#include "sysman/standby/standby_imp.h"
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Winconsistent-missing-override"
-#endif
-
-using ::testing::_;
-
 namespace L0 {
 namespace ult {
 
@@ -30,21 +19,36 @@ class StandbySysfsAccess : public SysfsAccess {};
 template <>
 struct Mock<StandbySysfsAccess> : public StandbySysfsAccess {
     int mockStandbyMode = -1;
-    MOCK_METHOD2(read, ze_result_t(const std::string file, int &val));
-    MOCK_METHOD2(write, ze_result_t(const std::string file, const int val));
+    MOCK_METHOD(ze_result_t, read, (const std::string file, int &val), (override));
+    MOCK_METHOD(ze_result_t, canRead, (const std::string file), (override));
 
+    ze_result_t getCanReadStatus(const std::string file) {
+        if (file.compare(standbyModeFile) == 0) {
+            return ZE_RESULT_SUCCESS;
+        }
+        return ZE_RESULT_ERROR_UNKNOWN;
+    }
     ze_result_t getVal(const std::string file, int &val) {
         if (file.compare(standbyModeFile) == 0) {
             val = mockStandbyMode;
+            return ZE_RESULT_SUCCESS;
         }
-        return ZE_RESULT_SUCCESS;
+        return ZE_RESULT_ERROR_NOT_AVAILABLE;
     }
 
     ze_result_t setVal(const std::string file, const int val) {
         if (file.compare(standbyModeFile) == 0) {
             mockStandbyMode = val;
+            return ZE_RESULT_SUCCESS;
         }
-        return ZE_RESULT_SUCCESS;
+        return ZE_RESULT_ERROR_NOT_AVAILABLE;
+    }
+
+    ze_result_t setValReturnError(const std::string file, const int val) {
+        if (file.compare(standbyModeFile) == 0) {
+            return ZE_RESULT_ERROR_NOT_AVAILABLE;
+        }
+        return ZE_RESULT_ERROR_NOT_AVAILABLE;
     }
 
     Mock() = default;
@@ -57,7 +61,3 @@ class PublicLinuxStandbyImp : public L0::LinuxStandbyImp {
 };
 } // namespace ult
 } // namespace L0
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif

level_zero/tools/test/unit_tests/sources/sysman/standby/linux/test_zes_sysman_standby.cpp

@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/tools/test/unit_tests/sources/sysman/mock_sysman_fixture.h"
+
+#include "mock_sysfs_standby.h"
+
+using ::testing::_;
+using ::testing::Matcher;
+
+constexpr uint32_t standbyHandleComponentCount = 1u;
+namespace L0 {
+namespace ult {
+
+constexpr int standbyModeDefault = 1;
+constexpr int standbyModeNever = 0;
+constexpr int standbyModeInvalid = 0xff;
+constexpr uint32_t mockHandleCount = 1;
+class ZesStandbyFixture : public SysmanDeviceFixture {
+
+  protected:
+    std::unique_ptr<Mock<StandbySysfsAccess>> ptestSysfsAccess;
+    zes_standby_handle_t hSysmanStandby;
+    SysfsAccess *pOriginalSysfsAccess = nullptr;
+
+    void SetUp() override {
+        SysmanDeviceFixture::SetUp();
+        ptestSysfsAccess = std::make_unique<NiceMock<Mock<StandbySysfsAccess>>>();
+        pOriginalSysfsAccess = pLinuxSysmanImp->pSysfsAccess;
+        pLinuxSysmanImp->pSysfsAccess = ptestSysfsAccess.get();
+        ptestSysfsAccess->setVal(standbyModeFile, standbyModeDefault);
+        ON_CALL(*ptestSysfsAccess.get(), read(_, Matcher<int &>(_)))
+            .WillByDefault(::testing::Invoke(ptestSysfsAccess.get(), &Mock<StandbySysfsAccess>::getVal));
+        ON_CALL(*ptestSysfsAccess.get(), canRead(_))
+            .WillByDefault(::testing::Invoke(ptestSysfsAccess.get(), &Mock<StandbySysfsAccess>::getCanReadStatus));
+        pSysmanDeviceImp->pStandbyHandleContext->handleList.clear();
+        pSysmanDeviceImp->pStandbyHandleContext->init();
+    }
+    void TearDown() override {
+        SysmanDeviceFixture::TearDown();
+        pLinuxSysmanImp->pSysfsAccess = pOriginalSysfsAccess;
+    }
+
+    std::vector<zes_standby_handle_t> get_standby_handles(uint32_t count) {
+        std::vector<zes_standby_handle_t> handles(count, nullptr);
+        EXPECT_EQ(zesDeviceEnumStandbyDomains(device, &count, handles.data()), ZE_RESULT_SUCCESS);
+        return handles;
+    }
+};
+
+TEST_F(ZesStandbyFixture, GivenComponentCountZeroWhenCallingzetSysmanStandbyGetThenNonZeroCountIsReturnedAndVerifyzetSysmanStandbyGetCallSucceeds) {
+    std::vector<zes_standby_handle_t> standbyHandle;
+    uint32_t count = 0;
+
+    ze_result_t result = zesDeviceEnumStandbyDomains(device, &count, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, mockHandleCount);
+
+    uint32_t testCount = count + 1;
+
+    result = zesDeviceEnumStandbyDomains(device, &testCount, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(testCount, count);
+
+    standbyHandle.resize(count);
+    result = zesDeviceEnumStandbyDomains(device, &count, standbyHandle.data());
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_NE(nullptr, standbyHandle.data());
+    EXPECT_EQ(count, mockHandleCount);
+
+    StandbyImp *ptestStandbyImp = new StandbyImp(pSysmanDeviceImp->pStandbyHandleContext->pOsSysman);
+    count = 0;
+    pSysmanDeviceImp->pStandbyHandleContext->handleList.push_back(ptestStandbyImp);
+    result = zesDeviceEnumStandbyDomains(device, &count, nullptr);
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, mockHandleCount + 1);
+
+    testCount = count - 1;
+
+    standbyHandle.resize(testCount);
+    result = zesDeviceEnumStandbyDomains(device, &testCount, standbyHandle.data());
+
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_NE(nullptr, standbyHandle.data());
+    EXPECT_EQ(count, mockHandleCount + 1);
+
+    pSysmanDeviceImp->pStandbyHandleContext->handleList.pop_back();
+    delete ptestStandbyImp;
+}
+
+TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzetSysmanStandbyGetPropertiesThenVerifyzetSysmanStandbyGetPropertiesCallSucceeds) {
+    zes_standby_properties_t properties;
+    auto handles = get_standby_handles(standbyHandleComponentCount);
+
+    for (auto hSysmanStandby : handles) {
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbyGetProperties(hSysmanStandby, &properties));
+        EXPECT_EQ(ZES_STANDBY_TYPE_GLOBAL, properties.type);
+        EXPECT_FALSE(properties.onSubdevice);
+    }
+}
+
+TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzetSysmanStandbyGetModeThenVerifyzetSysmanStandbyGetModeCallSucceedsForDefaultMode) {
+    zes_standby_promo_mode_t mode;
+    auto handles = get_standby_handles(standbyHandleComponentCount);
+
+    for (auto hSysmanStandby : handles) {
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbyGetMode(hSysmanStandby, &mode));
+        EXPECT_EQ(ZES_STANDBY_PROMO_MODE_DEFAULT, mode);
+    }
+}
+
+TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzetSysmanStandbyGetModeThenVerifyzetSysmanStandbyGetModeCallSucceedsForNeverMode) {
+    zes_standby_promo_mode_t mode;
+    ptestSysfsAccess->setVal(standbyModeFile, standbyModeNever);
+    auto handles = get_standby_handles(standbyHandleComponentCount);
+
+    for (auto hSysmanStandby : handles) {
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesStandbyGetMode(hSysmanStandby, &mode));
+        EXPECT_EQ(ZES_STANDBY_PROMO_MODE_NEVER, mode);
+    }
+}
+
+TEST_F(ZesStandbyFixture, GivenInvalidStandbyFileWhenReadisCalledThenExpectFailure) {
+    zes_standby_promo_mode_t mode;
+    ON_CALL(*ptestSysfsAccess.get(), read(_, Matcher<int &>(_)))
+        .WillByDefault(::testing::Invoke(ptestSysfsAccess.get(), &Mock<StandbySysfsAccess>::setValReturnError));
+
+    auto handles = get_standby_handles(standbyHandleComponentCount);
+
+    for (auto hSysmanStandby : handles) {
+        EXPECT_NE(ZE_RESULT_SUCCESS, zesStandbyGetMode(hSysmanStandby, &mode));
+    }
+}
+
+TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzetSysmanStandbyGetModeThenVerifyzetSysmanStandbyGetModeCallFailsForInvalidMode) {
+    zes_standby_promo_mode_t mode;
+    ptestSysfsAccess->setVal(standbyModeFile, standbyModeInvalid);
+    auto handles = get_standby_handles(standbyHandleComponentCount);
+
+    for (auto hSysmanStandby : handles) {
+        EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, zesStandbyGetMode(hSysmanStandby, &mode));
+    }
+}
+
+TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingzetSysmanStandbySetModeThenVerifySysmanzetStandbySetModeCallSucceeds) {
+    auto handles = get_standby_handles(standbyHandleComponentCount);
+
+    for (auto hSysmanStandby : handles) {
+        EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesStandbySetMode(hSysmanStandby, ZES_STANDBY_PROMO_MODE_NEVER));
+    }
+}
+
+} // namespace ult
+} // namespace L0

level_zero/tools/test/unit_tests/sources/sysman/standby/windows/CMakeLists.txt

@@ -1,14 +0,0 @@
-#
-# Copyright (C) 2020 Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-#
-
-if(WIN32)
-    target_sources(${TARGET_NAME}
-        PRIVATE
-            ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-            ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_standby.cpp
-            ${CMAKE_CURRENT_SOURCE_DIR}/mock_standby.h
-    )
-endif()

level_zero/tools/test/unit_tests/sources/sysman/standby/windows/mock_standby.h

@@ -1,46 +0,0 @@
-/*
- * Copyright (C) 2020 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#pragma once
-#include "level_zero/core/test/unit_tests/mock.h"
-
-#include "sysman/standby/os_standby.h"
-#include "sysman/standby/standby_imp.h"
-
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Winconsistent-missing-override"
-#endif
-
-namespace L0 {
-namespace ult {
-
-template <>
-struct Mock<OsStandby> : public OsStandby {
-
-    Mock<OsStandby>() = default;
-    zet_standby_promo_mode_t mode;
-
-    ze_result_t getMockMode(zet_standby_promo_mode_t &m) {
-        m = mode;
-        return ZE_RESULT_SUCCESS;
-    }
-    ze_result_t setMockMode(zet_standby_promo_mode_t m) {
-        mode = m;
-        return ZE_RESULT_SUCCESS;
-    }
-
-    MOCK_METHOD1(getMode, ze_result_t(zet_standby_promo_mode_t &mode));
-    MOCK_METHOD1(setMode, ze_result_t(zet_standby_promo_mode_t mode));
-};
-
-} // namespace ult
-} // namespace L0
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif

level_zero/tools/test/unit_tests/sources/sysman/standby/windows/test_sysman_standby.cpp

@@ -1,131 +0,0 @@
-/*
- * Copyright (C) 2020 Intel Corporation
- *
- * SPDX-License-Identifier: MIT
- *
- */
-
-#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
-#include "level_zero/tools/source/sysman/sysman_imp.h"
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "mock_standby.h"
-
-#include <cmath>
-
-using ::testing::_;
-using ::testing::DoAll;
-using ::testing::InSequence;
-using ::testing::Invoke;
-using ::testing::NiceMock;
-using ::testing::Return;
-
-namespace L0 {
-namespace ult {
-
-class SysmanStandbyFixture : public DeviceFixture, public ::testing::Test {
-
-  protected:
-    SysmanImp *sysmanImp;
-    zet_sysman_handle_t hSysman;
-
-    Mock<OsStandby> *pOsStandby;
-    StandbyImp *pStandbyImp;
-
-    zet_sysman_standby_handle_t hSysmanStandby;
-
-    void SetUp() override {
-        DeviceFixture::SetUp();
-        sysmanImp = new SysmanImp(device->toHandle());
-        pOsStandby = new NiceMock<Mock<OsStandby>>;
-        pStandbyImp = new StandbyImp();
-        pStandbyImp->pOsStandby = pOsStandby;
-        pOsStandby->setMockMode(ZET_STANDBY_PROMO_MODE_DEFAULT);
-        ON_CALL(*pOsStandby, getMode(_))
-            .WillByDefault(Invoke(pOsStandby, &Mock<OsStandby>::getMockMode));
-        ON_CALL(*pOsStandby, setMode(_))
-            .WillByDefault(Invoke(pOsStandby, &Mock<OsStandby>::setMockMode));
-
-        pStandbyImp->init();
-        sysmanImp->pStandbyHandleContext->handleList.push_back(pStandbyImp);
-
-        hSysman = sysmanImp->toHandle();
-        hSysmanStandby = pStandbyImp->toHandle();
-    }
-
-    void TearDown() override {
-        if (sysmanImp != nullptr) {
-            delete sysmanImp;
-            sysmanImp = nullptr;
-        }
-        DeviceFixture::TearDown();
-    }
-};
-
-TEST_F(SysmanStandbyFixture, GivenComponentCountZeroWhenCallingzetSysmanStandbyGetThenNonZeroCountIsReturnedAndVerifyzetSysmanStandbyGetCallSucceeds) {
-    zet_sysman_standby_handle_t standbyHandle;
-    uint32_t count;
-
-    ze_result_t result = zetSysmanStandbyGet(hSysman, &count, NULL);
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_GT(count, 0u);
-
-    uint32_t testCount = count + 1;
-
-    result = zetSysmanStandbyGet(hSysman, &testCount, NULL);
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(testCount, count);
-
-    result = zetSysmanStandbyGet(hSysman, &count, &standbyHandle);
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_NE(nullptr, standbyHandle);
-    EXPECT_GT(count, 0u);
-}
-
-TEST_F(SysmanStandbyFixture, GivenValidStandbyHandleWhenCallingzetSysmanStandbyGetPropertiesThenVerifyzetSysmanStandbyGetPropertiesCallSucceeds) {
-    zet_standby_properties_t properties;
-
-    ze_result_t result = zetSysmanStandbyGetProperties(hSysmanStandby, &properties);
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(ZET_STANDBY_TYPE_GLOBAL, properties.type);
-    EXPECT_FALSE(properties.onSubdevice);
-}
-
-TEST_F(SysmanStandbyFixture, GivenValidStandbyHandleWhenCallingzetSysmanStandbyGetModeThenVerifyzetSysmanStandbyGetModeCallSucceeds) {
-    zet_standby_promo_mode_t mode;
-
-    ze_result_t result = zetSysmanStandbyGetMode(hSysmanStandby, &mode);
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(ZET_STANDBY_PROMO_MODE_DEFAULT, mode);
-}
-
-TEST_F(SysmanStandbyFixture, GivenValidStandbyHandleWhenCallingzetSysmanStandbySetModeThenVerifySysmanzetStandbySetModeCallSucceeds) {
-    zet_standby_promo_mode_t mode;
-
-    ze_result_t result = zetSysmanStandbySetMode(hSysmanStandby, ZET_STANDBY_PROMO_MODE_NEVER);
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-
-    result = zetSysmanStandbyGetMode(hSysmanStandby, &mode);
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(ZET_STANDBY_PROMO_MODE_NEVER, mode);
-
-    result = zetSysmanStandbySetMode(hSysmanStandby, ZET_STANDBY_PROMO_MODE_DEFAULT);
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-
-    result = zetSysmanStandbyGetMode(hSysmanStandby, &mode);
-
-    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
-    EXPECT_EQ(ZET_STANDBY_PROMO_MODE_DEFAULT, mode);
-}
-
-} // namespace ult
-} // namespace L0