Removal of Template Specializations and NiceMocks

Template Specializations and NiceMocks have been removed in
Memory, Performance, Scheduler and Temperature ULT.

Related-To: LOCI-3391

Signed-off-by: Bari, Pratik <pratik.bari@intel.com>

level_zero/tools/test/unit_tests/sources/sysman/memory/linux/mock_memory.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -31,15 +31,10 @@ struct MockMemoryManagerSysman : public MemoryManagerMock {
     MockMemoryManagerSysman(NEO::ExecutionEnvironment &executionEnvironment) : MemoryManagerMock(const_cast<NEO::ExecutionEnvironment &>(executionEnvironment)) {}
 };
 
-class MemoryNeoDrm : public Drm {
-  public:
+struct MockMemoryNeoDrm : public Drm {
     using Drm::memoryInfo;
     const int mockFd = 33;
-    MemoryNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<HwDeviceIdDrm>(mockFd, ""), rootDeviceEnvironment) {}
-};
-
-struct MockMemoryNeoDrm : public MemoryNeoDrm {
-    MockMemoryNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment) : MemoryNeoDrm(rootDeviceEnvironment) {}
+    MockMemoryNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<HwDeviceIdDrm>(mockFd, ""), rootDeviceEnvironment) {}
     std::vector<bool> mockQueryMemoryInfoReturnStatus{};
     bool queryMemoryInfo() override {
         if (!mockQueryMemoryInfoReturnStatus.empty()) {

level_zero/tools/test/unit_tests/sources/sysman/memory/linux/mock_memory_prelim.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2022 Intel Corporation
+ * Copyright (C) 2021-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -102,9 +102,7 @@ const std::string sysfsPahTelem3 = "/sys/class/intel_pmt/telem3";
 const std::string sysfsPahTelem4 = "/sys/class/intel_pmt/telem4";
 const std::string sysfsPahTelem5 = "/sys/class/intel_pmt/telem5";
 
-class MemorySysfsAccess : public SysfsAccess {};
-
-struct MockMemorySysfsAccess : public MemorySysfsAccess {
+struct MockMemorySysfsAccess : public SysfsAccess {
 
     std::vector<ze_result_t> mockReadReturnStatus{};
     std::vector<std::string> mockReadStringValue{};
@@ -213,18 +211,13 @@ struct MockMemoryManagerSysman : public MemoryManagerMock {
     MockMemoryManagerSysman(NEO::ExecutionEnvironment &executionEnvironment) : MemoryManagerMock(const_cast<NEO::ExecutionEnvironment &>(executionEnvironment)) {}
 };
 
-class MemoryNeoDrm : public Drm {
-  public:
+struct MockMemoryNeoDrm : public Drm {
     using Drm::ioctlHelper;
     const int mockFd = 33;
-    MemoryNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<HwDeviceIdDrm>(mockFd, ""), rootDeviceEnvironment) {}
-};
-
-struct MockMemoryNeoDrm : public MemoryNeoDrm {
     std::vector<bool> mockQuerySystemInfoReturnValue{};
     bool isRepeated = false;
     bool mockReturnEmptyRegions = false;
-    MockMemoryNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment) : MemoryNeoDrm(rootDeviceEnvironment) {}
+    MockMemoryNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<HwDeviceIdDrm>(mockFd, ""), rootDeviceEnvironment) {}
 
     std::vector<uint8_t> getMemoryRegions() override {
         if (mockReturnEmptyRegions == true) {
@@ -274,13 +267,9 @@ struct MockMemoryNeoDrm : public MemoryNeoDrm {
     }
 };
 
-class MemoryPmt : public PlatformMonitoringTech {
-  public:
-    MemoryPmt(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
-    using PlatformMonitoringTech::keyOffsetMap;
-};
+struct MockMemoryPmt : public PlatformMonitoringTech {
 
-struct MockMemoryPmt : public MemoryPmt {
+    using PlatformMonitoringTech::keyOffsetMap;
     std::vector<ze_result_t> mockReadValueReturnStatus{};
     std::vector<uint32_t> mockReadArgumentValue{};
     ze_result_t mockIdiReadValueFailureReturnStatus = ZE_RESULT_SUCCESS;
@@ -291,8 +280,7 @@ struct MockMemoryPmt : public MemoryPmt {
     bool mockVfid1Status = false;
     bool isRepeated = false;
 
-    MockMemoryPmt(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : MemoryPmt(pFsAccess, onSubdevice, subdeviceId) {}
-
+    MockMemoryPmt(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
     ze_result_t readValue(const std::string key, uint32_t &val) override {
         ze_result_t result = ZE_RESULT_SUCCESS;
 
@@ -455,9 +443,7 @@ struct MockMemoryPmt : public MemoryPmt {
     }
 };
 
-class MemoryFsAccess : public FsAccess {};
-
-struct MockMemoryFsAccess : public MemoryFsAccess {
+struct MockMemoryFsAccess : public FsAccess {
     ze_result_t listDirectory(const std::string directory, std::vector<std::string> &listOfTelemNodes) override {
         if (directory.compare(baseTelemSysFS) == 0) {
             listOfTelemNodes.push_back("telem1");

level_zero/tools/test/unit_tests/sources/sysman/memory/linux/test_sysman_memory_prelim.cpp

@@ -13,8 +13,6 @@
 
 extern bool sysmanUltsEnable;
 
-using ::testing::Matcher;
-using ::testing::Return;
 namespace L0 {
 namespace ult {
 

level_zero/tools/test/unit_tests/sources/sysman/performance/linux/mock_sysfs_performance_prelim.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2022 Intel Corporation
+ * Copyright (C) 2021-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -26,8 +26,7 @@ const std::string baseScaleSubDevice1("gt/gt1/base_freq_factor.scale");
 const std::string pwrBalance("sys_pwr_balance");
 class PerformanceSysfsAccess : public SysfsAccess {};
 
-template <>
-struct Mock<PerformanceSysfsAccess> : public PerformanceSysfsAccess {
+struct MockPerformanceSysfsAccess : public PerformanceSysfsAccess {
     ze_result_t mockReadResult = ZE_RESULT_SUCCESS;
     ze_result_t mockCanReadResult = ZE_RESULT_SUCCESS;
     ze_bool_t isComputeInvalid = false;
@@ -152,7 +151,7 @@ struct Mock<PerformanceSysfsAccess> : public PerformanceSysfsAccess {
     double mockMultiplierMedia = 512.0;
     double mockScale = 0.00390625;
     double mockPwrBalance = 0.0;
-    Mock<PerformanceSysfsAccess>() = default;
+    MockPerformanceSysfsAccess() = default;
 };
 
 class PublicLinuxPerformanceImp : public L0::LinuxPerformanceImp {

level_zero/tools/test/unit_tests/sources/sysman/performance/linux/test_zes_performance.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2022 Intel Corporation
+ * Copyright (C) 2021-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -11,9 +11,6 @@
 
 extern bool sysmanUltsEnable;
 
-using ::testing::_;
-using ::testing::Matcher;
-
 namespace L0 {
 namespace ult {
 
@@ -113,4 +110,4 @@ TEST_F(ZesPerformanceFixture, GivenValidOfjectsOfClassPerformanceImpAndPerforman
 }
 
 } // namespace ult
-} // namespace L0
+} // namespace L0

level_zero/tools/test/unit_tests/sources/sysman/performance/linux/test_zes_performance_prelim.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2022 Intel Corporation
+ * Copyright (C) 2021-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -10,12 +10,6 @@
 
 extern bool sysmanUltsEnable;
 
-using ::testing::_;
-using ::testing::DoDefault;
-using ::testing::InSequence;
-using ::testing::Matcher;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 
@@ -25,7 +19,7 @@ constexpr double halfOfMaxPerformanceFactor = 50;
 constexpr double minPerformanceFactor = 0;
 class ZesPerformanceFixture : public SysmanMultiDeviceFixture {
   protected:
-    std::unique_ptr<Mock<PerformanceSysfsAccess>> ptestSysfsAccess;
+    std::unique_ptr<MockPerformanceSysfsAccess> ptestSysfsAccess;
     std::vector<ze_device_handle_t> deviceHandles;
     SysfsAccess *pOriginalSysfsAccess = nullptr;
     void SetUp() override {
@@ -33,7 +27,7 @@ class ZesPerformanceFixture : public SysmanMultiDeviceFixture {
             GTEST_SKIP();
         }
         SysmanMultiDeviceFixture::SetUp();
-        ptestSysfsAccess = std::make_unique<Mock<PerformanceSysfsAccess>>();
+        ptestSysfsAccess = std::make_unique<MockPerformanceSysfsAccess>();
         pOriginalSysfsAccess = pLinuxSysmanImp->pSysfsAccess;
         pLinuxSysmanImp->pSysfsAccess = ptestSysfsAccess.get();
         for (auto &handle : pSysmanDeviceImp->pPerformanceHandleContext->handleList) {

level_zero/tools/test/unit_tests/sources/sysman/power/linux/mock_sysfs_power.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -496,4 +496,4 @@ class SysmanDevicePowerMultiDeviceFixture : public SysmanMultiDeviceFixture {
 };
 
 } // namespace ult
-} // namespace L0
+} // namespace L0

level_zero/tools/test/unit_tests/sources/sysman/power/linux/test_zes_power_helper.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2021-2022 Intel Corporation
+ * Copyright (C) 2021-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -62,4 +62,4 @@ TEST_F(SysmanDevicePowerMultiDeviceFixtureHelper, GivenScanDirectoriesFailAndPmt
 }
 
 } // namespace ult
-} // namespace L0
+} // namespace L0

level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/mock_sysfs_scheduler.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -22,7 +22,6 @@ const std::string defaultHeartbeatIntervalMilliSecs(".defaults/heartbeat_interva
 const std::string engineDir("engine");
 const std::vector<std::string> listOfMockedEngines = {"rcs0", "bcs0", "vcs0", "vcs1", "vecs0"};
 
-class SchedulerSysfsAccess : public SysfsAccess {};
 typedef struct SchedulerConfigValues {
     uint64_t defaultVal;
     uint64_t actualVal;

level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/mock_sysfs_scheduler_prelim.h

@@ -29,16 +29,11 @@ const std::vector<std::string> listOfMockedEngines = {"rcs0", "bcs0", "vcs0", "v
 uint32_t tileCount = 2u;
 uint32_t numberOfEnginesInSched = 34u;
 
-class SchedulerNeoDrm : public Drm {
-  public:
+struct MockSchedulerNeoDrm : public Drm {
     using Drm::getEngineInfo;
     using Drm::setupIoctlHelper;
     const int mockFd = 0;
-    SchedulerNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<HwDeviceIdDrm>(mockFd, ""), rootDeviceEnvironment) {}
-};
-
-struct MockSchedulerNeoDrm : public SchedulerNeoDrm {
-    MockSchedulerNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment) : SchedulerNeoDrm(rootDeviceEnvironment) {}
+    MockSchedulerNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique<HwDeviceIdDrm>(mockFd, ""), rootDeviceEnvironment) {}
 
     bool sysmanQueryEngineInfo() override {
 

level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/test_zes_scheduler.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -11,9 +11,6 @@
 
 extern bool sysmanUltsEnable;
 
-using ::testing::DoDefault;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 constexpr uint32_t handleComponentCount = 4u;

level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/test_zes_scheduler_prelim.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -13,9 +13,6 @@ extern bool sysmanUltsEnable;
 
 using namespace NEO;
 
-using ::testing::DoDefault;
-using ::testing::Return;
-
 namespace L0 {
 namespace ult {
 constexpr uint32_t handleComponentCount = 5u;

level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/mock_sysfs_temperature.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -39,24 +39,20 @@ const std::string sysfsPahTelem2 = "/sys/class/intel_pmt/telem2";
 const std::string sysfsPahTelem3 = "/sys/class/intel_pmt/telem3";
 const std::string sysfsPahTelem4 = "/sys/class/intel_pmt/telem4";
 const std::string sysfsPahTelem5 = "/sys/class/intel_pmt/telem5";
-class TemperaturePmt : public PlatformMonitoringTech {
-  public:
-    TemperaturePmt(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
+
+struct MockTemperaturePmt : public PlatformMonitoringTech {
+    MockTemperaturePmt(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
     using PlatformMonitoringTech::closeFunction;
     using PlatformMonitoringTech::keyOffsetMap;
     using PlatformMonitoringTech::openFunction;
     using PlatformMonitoringTech::preadFunction;
     using PlatformMonitoringTech::telemetryDeviceEntry;
-};
 
-template <>
-struct Mock<TemperaturePmt> : public TemperaturePmt {
     ze_result_t mockReadValueResult = ZE_RESULT_SUCCESS;
     ze_result_t mockReadCoreTempResult = ZE_RESULT_SUCCESS;
     ze_result_t mockReadComputeTempResult = ZE_RESULT_SUCCESS;
 
-    Mock<TemperaturePmt>(FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : TemperaturePmt(pFsAccess, onSubdevice, subdeviceId) {}
-    ~Mock() override {
+    ~MockTemperaturePmt() override {
         rootDeviceTelemNodeIndex = 0;
     }
 
@@ -127,10 +123,7 @@ struct Mock<TemperaturePmt> : public TemperaturePmt {
     }
 };
 
-class TemperatureFsAccess : public FsAccess {};
-
-template <>
-struct Mock<TemperatureFsAccess> : public TemperatureFsAccess {
+struct MockTemperatureFsAccess : public FsAccess {
     ze_result_t mockErrorListDirectory = ZE_RESULT_SUCCESS;
     ze_result_t mockErrorGetRealPath = ZE_RESULT_SUCCESS;
     ze_result_t listDirectory(const std::string directory, std::vector<std::string> &listOfTelemNodes) override {
@@ -168,7 +161,7 @@ struct Mock<TemperatureFsAccess> : public TemperatureFsAccess {
         return ZE_RESULT_SUCCESS;
     }
 
-    Mock<TemperatureFsAccess>() = default;
+    MockTemperatureFsAccess() = default;
 };
 
 class PublicLinuxTemperatureImp : public L0::LinuxTemperatureImp {

level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_zes_temperature.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2022 Intel Corporation
+ * Copyright (C) 2020-2023 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -25,7 +25,7 @@ const std::string sampleGuid2 = "0x490e01";
 class SysmanMultiDeviceTemperatureFixture : public SysmanMultiDeviceFixture {
   protected:
     std::unique_ptr<PublicLinuxTemperatureImp> pPublicLinuxTemperatureImp;
-    std::unique_ptr<Mock<TemperatureFsAccess>> pFsAccess;
+    std::unique_ptr<MockTemperatureFsAccess> pFsAccess;
     FsAccess *pFsAccessOriginal = nullptr;
     std::vector<ze_device_handle_t> deviceHandles;
     PRODUCT_FAMILY productFamily;
@@ -40,7 +40,7 @@ class SysmanMultiDeviceTemperatureFixture : public SysmanMultiDeviceFixture {
             handle = nullptr;
         }
         pSysmanDeviceImp->pTempHandleContext->handleList.clear();
-        pFsAccess = std::make_unique<Mock<TemperatureFsAccess>>();
+        pFsAccess = std::make_unique<MockTemperatureFsAccess>();
         pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
         pLinuxSysmanImp->pFsAccess = pFsAccess.get();
 
@@ -58,8 +58,8 @@ class SysmanMultiDeviceTemperatureFixture : public SysmanMultiDeviceFixture {
         for (auto &deviceHandle : deviceHandles) {
             ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
             Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
-            auto pPmt = new Mock<TemperaturePmt>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
-                                                 deviceProperties.subdeviceId);
+            auto pPmt = new MockTemperaturePmt(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
+                                               deviceProperties.subdeviceId);
             pPmt->mockedInit(pFsAccess.get());
             // Get keyOffsetMap
             auto keyOffsetMapEntry = guidToKeyOffsetMap.find(sampleGuid1);
@@ -167,7 +167,7 @@ TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleAndPmtReadValueF
     for (auto &deviceHandle : deviceHandles) {
         ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
         Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
-        auto pPmt = static_cast<Mock<TemperaturePmt> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
+        auto pPmt = static_cast<MockTemperaturePmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
         pPmt->mockReadValueResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
     }
 
@@ -182,7 +182,7 @@ TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleAndPmtReadValueF
 class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
   protected:
     std::unique_ptr<PublicLinuxTemperatureImp> pPublicLinuxTemperatureImp;
-    std::unique_ptr<Mock<TemperatureFsAccess>> pFsAccess;
+    std::unique_ptr<MockTemperatureFsAccess> pFsAccess;
     FsAccess *pFsAccessOriginal = nullptr;
     std::vector<ze_device_handle_t> deviceHandles;
     PRODUCT_FAMILY productFamily;
@@ -192,7 +192,7 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
             GTEST_SKIP();
         }
         SysmanDeviceFixture::SetUp();
-        pFsAccess = std::make_unique<Mock<TemperatureFsAccess>>();
+        pFsAccess = std::make_unique<MockTemperatureFsAccess>();
         pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
         pLinuxSysmanImp->pFsAccess = pFsAccess.get();
 
@@ -210,8 +210,8 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
         for (auto &deviceHandle : deviceHandles) {
             ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
             Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
-            auto pPmt = new Mock<TemperaturePmt>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
-                                                 deviceProperties.subdeviceId);
+            auto pPmt = new MockTemperaturePmt(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
+                                               deviceProperties.subdeviceId);
             pPmt->mockedInit(pFsAccess.get());
             // Get keyOffsetMap
             auto keyOffsetMapEntry = guidToKeyOffsetMap.find(sampleGuid2);
@@ -268,7 +268,7 @@ HWTEST2_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleAndReadCoreTempera
     for (auto &deviceHandle : deviceHandles) {
         ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
         Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
-        auto pPmt = static_cast<Mock<TemperaturePmt> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
+        auto pPmt = static_cast<MockTemperaturePmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
         pPmt->mockReadCoreTempResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
     }
 
@@ -291,7 +291,7 @@ HWTEST2_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleAndReadComputeTemp
     for (auto &deviceHandle : deviceHandles) {
         ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
         Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
-        auto pPmt = static_cast<Mock<TemperaturePmt> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
+        auto pPmt = static_cast<MockTemperaturePmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
         pPmt->mockReadComputeTempResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
     }
 
@@ -331,7 +331,7 @@ TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleAndPmtReadValueFailsW
     for (auto &deviceHandle : deviceHandles) {
         ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
         Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
-        auto pPmt = static_cast<Mock<TemperaturePmt> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
+        auto pPmt = static_cast<MockTemperaturePmt *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
         pPmt->mockReadValueResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
     }
     for (auto &handle : handles) {
@@ -361,7 +361,7 @@ TEST_F(SysmanDeviceTemperatureFixture, GivenValidateEnumerateRootTelemIndexWheng
 }
 
 TEST_F(SysmanDeviceTemperatureFixture, GivenValidatePmtReadValueWhenkeyOffsetMapIsNotThereThenFailureReturned) {
-    auto pPmt = std::make_unique<Mock<TemperaturePmt>>(pFsAccess.get(), 0, 0);
+    auto pPmt = std::make_unique<MockTemperaturePmt>(pFsAccess.get(), 0, 0);
     pPmt->mockedInit(pFsAccess.get());
     // Get keyOffsetMap
     auto keyOffsetMapEntry = guidToKeyOffsetMap.find(sampleGuid2);