diff --git a/level_zero/tools/source/sysman/sysman_imp.cpp b/level_zero/tools/source/sysman/sysman_imp.cpp
index 7c9c76f2bd..cd5e960acd 100644
--- a/level_zero/tools/source/sysman/sysman_imp.cpp
+++ b/level_zero/tools/source/sysman/sysman_imp.cpp
@@ -103,9 +103,6 @@ ze_result_t SysmanDeviceImp::init() {
     if (pFabricPortHandleContext) {
         pFabricPortHandleContext->init();
     }
-    if (pTempHandleContext) {
-        pTempHandleContext->init(deviceHandles);
-    }
     if (pPci) {
         pPci->init();
     }
diff --git a/level_zero/tools/source/sysman/temperature/temperature.cpp b/level_zero/tools/source/sysman/temperature/temperature.cpp
index 7a052aed07..4b28dd15a7 100644
--- a/level_zero/tools/source/sysman/temperature/temperature.cpp
+++ b/level_zero/tools/source/sysman/temperature/temperature.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -7,6 +7,7 @@
 
 #include "shared/source/helpers/basic_math.h"
 
+#include "level_zero/tools/source/sysman/os_sysman.h"
 #include "level_zero/tools/source/sysman/temperature/temperature_imp.h"
 
 namespace L0 {
@@ -35,6 +36,9 @@ void TemperatureHandleContext::init(std::vector<ze_device_handle_t> &deviceHandl
 }
 
 ze_result_t TemperatureHandleContext::temperatureGet(uint32_t *pCount, zes_temp_handle_t *phTemperature) {
+    std::call_once(initTemperatureOnce, [this]() {
+        this->init(pOsSysman->getDeviceHandles());
+    });
     uint32_t handleListSize = static_cast<uint32_t>(handleList.size());
     uint32_t numToCopy = std::min(*pCount, handleListSize);
     if (0 == *pCount || *pCount > handleListSize) {
diff --git a/level_zero/tools/source/sysman/temperature/temperature.h b/level_zero/tools/source/sysman/temperature/temperature.h
index da96d14c74..0405be97cd 100644
--- a/level_zero/tools/source/sysman/temperature/temperature.h
+++ b/level_zero/tools/source/sysman/temperature/temperature.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2020-2021 Intel Corporation
+ * Copyright (C) 2020-2022 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -8,6 +8,7 @@
 #pragma once
 #include <level_zero/zes_api.h>
 
+#include <mutex>
 #include <vector>
 
 struct _zes_temp_handle_t {
@@ -45,6 +46,7 @@ struct TemperatureHandleContext {
 
   private:
     void createHandle(const ze_device_handle_t &deviceHandle, zes_temp_sensors_t type);
+    std::once_flag initTemperatureOnce;
 };
 
-} // namespace L0
\ No newline at end of file
+} // namespace L0
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/CMakeLists.txt
index 406bdb9480..9bf5d4bc09 100644
--- a/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/CMakeLists.txt
+++ b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/CMakeLists.txt
@@ -6,12 +6,15 @@
 
 set(L0_TESTS_TOOLS_SYSMAN_TEMPERATURE_LINUX
     ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
-    ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}test_zes_temperature.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_sysfs_temperature.h
 )
 
-if((NEO_ENABLE_i915_PRELIM_DETECTION) AND ("${BRANCH_TYPE}" STREQUAL ""))
-  list(REMOVE_ITEM L0_TESTS_TOOLS_SYSMAN_TEMPERATURE_LINUX
+if(NEO_ENABLE_i915_PRELIM_DETECTION)
+  list(APPEND L0_TESTS_TOOLS_SYSMAN_TEMPERATURE_LINUX
+       ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_temperature_prelim.cpp
+  )
+else()
+  list(APPEND L0_TESTS_TOOLS_SYSMAN_TEMPERATURE_LINUX
        ${CMAKE_CURRENT_SOURCE_DIR}/test_zes_temperature.cpp
   )
 endif()
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_zes_temperature.cpp b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_zes_temperature.cpp
index 9fe4f16c8c..ca28a97bef 100644
--- a/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_zes_temperature.cpp
+++ b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_zes_temperature.cpp
@@ -114,7 +114,7 @@ class SysmanMultiDeviceTemperatureFixture : public SysmanMultiDeviceFixture {
             pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(deviceProperties.subdeviceId, pPmt);
         }
 
-        pSysmanDeviceImp->pTempHandleContext->init(deviceHandles);
+        getTempHandles(0);
     }
     void TearDown() override {
         if (!sysmanUltsEnable) {
@@ -230,7 +230,7 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
             pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(deviceProperties.subdeviceId, pPmt);
         }
 
-        pSysmanDeviceImp->pTempHandleContext->init(deviceHandles);
+        getTempHandles(0);
     }
     void TearDown() override {
         if (!sysmanUltsEnable) {
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_zes_temperature_prelim.cpp b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_zes_temperature_prelim.cpp
new file mode 100644
index 0000000000..92de20e204
--- /dev/null
+++ b/level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/test_zes_temperature_prelim.cpp
@@ -0,0 +1,427 @@
+/*
+ * Copyright (C) 2020-2022 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "level_zero/tools/source/sysman/linux/pmt/pmt_xml_offsets.h"
+#include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
+#include "level_zero/tools/test/unit_tests/sources/sysman/temperature/linux/mock_sysfs_temperature.h"
+
+extern bool sysmanUltsEnable;
+
+namespace L0 {
+namespace ult {
+
+const static int fakeFileDescriptor = 123;
+constexpr uint32_t handleComponentCountForSubDevices = 6u;
+constexpr uint32_t handleComponentCountForNoSubDevices = 2u;
+constexpr uint32_t invalidMaxTemperature = 125;
+constexpr uint32_t invalidMinTemperature = 10;
+const std::string sampleGuid1 = "0xb15a0edc";
+const std::string sampleGuid2 = "0x490e01";
+
+inline static int openMockTemp(const char *pathname, int flags) {
+    if (strcmp(pathname, "/sys/class/intel_pmt/telem2/telem") == 0) {
+        return fakeFileDescriptor;
+    }
+    if (strcmp(pathname, "/sys/class/intel_pmt/telem3/telem") == 0) {
+        return fakeFileDescriptor;
+    }
+    return -1;
+}
+
+inline static int closeMockTemp(int fd) {
+    if (fd == fakeFileDescriptor) {
+        return 0;
+    }
+    return -1;
+}
+
+ssize_t preadMockTemp(int fd, void *buf, size_t count, off_t offset) {
+    if (count == sizeof(uint32_t)) {
+        uint32_t *mockBuf = static_cast<uint32_t *>(buf);
+        if (offset == memory2MaxTempIndex) {
+            *mockBuf = memory2MaxTemperature;
+        } else if (offset == memory3MaxTempIndex) {
+            *mockBuf = memory3MaxTemperature;
+        } else {
+            for (uint64_t i = 0; i < sizeof(uint32_t); i++) {
+                *mockBuf |= (uint32_t)tempArrForSubDevices[(offset - offsetForSubDevices) + i] << (i * 8);
+            }
+        }
+    } else {
+        uint64_t *mockBuf = static_cast<uint64_t *>(buf);
+        *mockBuf = 0;
+        for (uint64_t i = 0; i < sizeof(uint64_t); i++) {
+            *mockBuf |= (uint64_t)tempArrForSubDevices[(offset - offsetForSubDevices) + i] << (i * 8);
+        }
+    }
+    return count;
+}
+
+ssize_t preadMockTempNoSubDevices(int fd, void *buf, size_t count, off_t offset) {
+    if (count == sizeof(uint32_t)) {
+        uint32_t *mockBuf = static_cast<uint32_t *>(buf);
+        for (uint64_t i = 0; i < sizeof(uint32_t); i++) {
+            *mockBuf |= (uint32_t)tempArrForNoSubDevices[(offset - offsetForNoSubDevices) + i] << (i * 8);
+        }
+    } else {
+        uint64_t *mockBuf = static_cast<uint64_t *>(buf);
+        *mockBuf = 0;
+        for (uint64_t i = 0; i < sizeof(uint64_t); i++) {
+            *mockBuf |= (uint64_t)tempArrForNoSubDevices[(offset - offsetForNoSubDevices) + i] << (i * 8);
+        }
+    }
+    return count;
+}
+
+class SysmanMultiDeviceTemperatureFixture : public SysmanMultiDeviceFixture {
+  protected:
+    std::unique_ptr<PublicLinuxTemperatureImp> pPublicLinuxTemperatureImp;
+    std::unique_ptr<Mock<TemperatureFsAccess>> pFsAccess;
+    FsAccess *pFsAccessOriginal = nullptr;
+    std::vector<ze_device_handle_t> deviceHandles;
+    PRODUCT_FAMILY productFamily;
+    std::map<uint32_t, L0::PlatformMonitoringTech *> mapOriginal;
+    void SetUp() override {
+        if (!sysmanUltsEnable) {
+            GTEST_SKIP();
+        }
+        SysmanMultiDeviceFixture::SetUp();
+        for (auto &handle : pSysmanDeviceImp->pTempHandleContext->handleList) {
+            delete handle;
+            handle = nullptr;
+        }
+        pSysmanDeviceImp->pTempHandleContext->handleList.clear();
+        pFsAccess = std::make_unique<NiceMock<Mock<TemperatureFsAccess>>>();
+        pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
+        pLinuxSysmanImp->pFsAccess = pFsAccess.get();
+
+        uint32_t subDeviceCount = 0;
+        Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, nullptr);
+        if (subDeviceCount == 0) {
+            deviceHandles.resize(1, device->toHandle());
+        } else {
+            deviceHandles.resize(subDeviceCount, nullptr);
+            Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, deviceHandles.data());
+        }
+        mapOriginal = pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject;
+        pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
+
+        for (auto &deviceHandle : deviceHandles) {
+            ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
+            Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
+            auto pPmt = new NiceMock<Mock<TemperaturePmt>>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
+                                                           deviceProperties.subdeviceId);
+            pPmt->mockedInit(pFsAccess.get());
+            // Get keyOffsetMap
+            auto keyOffsetMapEntry = guidToKeyOffsetMap.find(sampleGuid1);
+            pPmt->keyOffsetMap = keyOffsetMapEntry->second;
+            pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(deviceProperties.subdeviceId, pPmt);
+        }
+
+        productFamily = pLinuxSysmanImp->getDeviceHandle()->getNEODevice()->getHardwareInfo().platform.eProductFamily;
+        getTempHandles(0);
+    }
+    void TearDown() override {
+        if (!sysmanUltsEnable) {
+            GTEST_SKIP();
+        }
+        for (const auto &pmtMapElement : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
+            delete pmtMapElement.second;
+        }
+        pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
+        pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject = mapOriginal;
+        SysmanMultiDeviceFixture::TearDown();
+    }
+
+    std::vector<zes_temp_handle_t> getTempHandles(uint32_t count) {
+        std::vector<zes_temp_handle_t> handles(count, nullptr);
+        EXPECT_EQ(zesDeviceEnumTemperatureSensors(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
+        return handles;
+    }
+};
+
+TEST_F(SysmanMultiDeviceTemperatureFixture, GivenComponentCountZeroWhenCallingZetSysmanTemperatureGetThenZeroCountIsReturnedAndVerifySysmanTemperatureGetCallSucceeds) {
+    uint32_t count = 0;
+    ze_result_t result = zesDeviceEnumTemperatureSensors(device->toHandle(), &count, NULL);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(count, handleComponentCountForSubDevices);
+
+    uint32_t testcount = count + 1;
+    result = zesDeviceEnumTemperatureSensors(device->toHandle(), &testcount, NULL);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, result);
+    EXPECT_EQ(testcount, handleComponentCountForSubDevices);
+
+    count = 0;
+    std::vector<zes_temp_handle_t> handles(count, nullptr);
+    EXPECT_EQ(zesDeviceEnumTemperatureSensors(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
+    EXPECT_EQ(count, handleComponentCountForSubDevices);
+}
+
+TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperatureThenValidTemperatureReadingsRetrieved) {
+    auto handles = getTempHandles(handleComponentCountForSubDevices);
+    for (auto &deviceHandle : deviceHandles) {
+        ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
+        Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
+        auto pPmt = static_cast<NiceMock<Mock<TemperaturePmt>> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
+        pPmt->openFunction = openMockTemp;
+        pPmt->closeFunction = closeMockTemp;
+        pPmt->preadFunction = preadMockTemp;
+    }
+
+    for (auto handle : handles) {
+        zes_temp_properties_t properties = {};
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(handle, &properties));
+        double temperature;
+        if (properties.type == ZES_TEMP_SENSORS_GLOBAL) {
+            ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
+            EXPECT_EQ(temperature, static_cast<double>(tempArrForSubDevices[subDeviceMaxTempIndex]));
+        }
+        if (properties.type == ZES_TEMP_SENSORS_GPU) {
+            ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
+            EXPECT_EQ(temperature, static_cast<double>(tempArrForSubDevices[gtMaxTempIndex]));
+        }
+        if (properties.type == ZES_TEMP_SENSORS_MEMORY) {
+            if (productFamily == IGFX_XE_HP_SDV) {
+                ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
+                EXPECT_EQ(temperature, static_cast<double>(std::max({tempArrForSubDevices[memory0MaxTempIndex], tempArrForSubDevices[memory1MaxTempIndex]})));
+            }
+            if (productFamily == IGFX_PVC) {
+                ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
+                EXPECT_EQ(temperature, static_cast<double>(std::max({memory0MaxTemperature, memory1MaxTemperature, memory2MaxTemperature, memory3MaxTemperature})));
+            }
+        }
+    }
+}
+
+TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleWhenGettingTemperatureConfigThenUnsupportedIsReturned) {
+    auto handles = getTempHandles(handleComponentCountForSubDevices);
+    for (auto handle : handles) {
+        zes_temp_config_t config = {};
+        EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesTemperatureGetConfig(handle, &config));
+    }
+}
+
+TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleWhenSettingTemperatureConfigThenUnsupportedIsReturned) {
+    auto handles = getTempHandles(handleComponentCountForSubDevices);
+    for (auto handle : handles) {
+        zes_temp_config_t config = {};
+        EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesTemperatureSetConfig(handle, &config));
+    }
+}
+
+TEST_F(SysmanMultiDeviceTemperatureFixture, GivenCreatePmtObjectsWhenRootTileIndexEnumeratesSuccessfulThenValidatePmtObjectsReceivedAndBranches) {
+    std::map<uint32_t, L0::PlatformMonitoringTech *> mapOfSubDeviceIdToPmtObject;
+    PlatformMonitoringTech::create(deviceHandles, pFsAccess.get(), gpuUpstreamPortPathInTemperature, mapOfSubDeviceIdToPmtObject);
+    uint32_t deviceHandlesIndex = 0;
+    for (auto &subDeviceIdToPmtEntry : mapOfSubDeviceIdToPmtObject) {
+        ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
+        Device::fromHandle(deviceHandles[deviceHandlesIndex++])->getProperties(&deviceProperties);
+        EXPECT_NE(subDeviceIdToPmtEntry.second, nullptr);
+        EXPECT_EQ(subDeviceIdToPmtEntry.first, deviceProperties.subdeviceId);
+        delete subDeviceIdToPmtEntry.second; // delete memory to avoid mem leak here, as we finished our test validation just above.
+    }
+}
+
+TEST_F(SysmanMultiDeviceTemperatureFixture, GivenValidTempHandleAndPmtReadValueFailsWhenGettingTemperatureThenFailureReturned) {
+    // delete previously allocated pPmt objects
+    for (auto &subDeviceIdToPmtEntry : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
+        delete subDeviceIdToPmtEntry.second;
+    }
+    pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
+    // delete previously created temp handles
+    for (auto &handle : pSysmanDeviceImp->pTempHandleContext->handleList) {
+        delete handle;
+        handle = nullptr;
+        pSysmanDeviceImp->pTempHandleContext->handleList.pop_back();
+    }
+    for (auto &deviceHandle : deviceHandles) {
+        ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
+        Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
+        auto pPmt = new NiceMock<Mock<TemperaturePmt>>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
+                                                       deviceProperties.subdeviceId);
+        pPmt->mockedInit(pFsAccess.get());
+        pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(deviceProperties.subdeviceId, pPmt);
+    }
+
+    pSysmanDeviceImp->pTempHandleContext->init(deviceHandles);
+    auto handles = getTempHandles(handleComponentCountForSubDevices);
+    for (auto &handle : handles) {
+        zes_temp_properties_t properties = {};
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(handle, &properties));
+        double temperature;
+        ASSERT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesTemperatureGetState(handle, &temperature));
+    }
+}
+
+class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
+  protected:
+    std::unique_ptr<PublicLinuxTemperatureImp> pPublicLinuxTemperatureImp;
+    std::unique_ptr<Mock<TemperatureFsAccess>> pFsAccess;
+    FsAccess *pFsAccessOriginal = nullptr;
+    std::vector<ze_device_handle_t> deviceHandles;
+    PRODUCT_FAMILY productFamily;
+    void SetUp() override {
+        if (!sysmanUltsEnable) {
+            GTEST_SKIP();
+        }
+        SysmanDeviceFixture::SetUp();
+        pFsAccess = std::make_unique<NiceMock<Mock<TemperatureFsAccess>>>();
+        pFsAccessOriginal = pLinuxSysmanImp->pFsAccess;
+        pLinuxSysmanImp->pFsAccess = pFsAccess.get();
+
+        uint32_t subDeviceCount = 0;
+        Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, nullptr);
+        if (subDeviceCount == 0) {
+            deviceHandles.resize(1, device->toHandle());
+        } else {
+            deviceHandles.resize(subDeviceCount, nullptr);
+            Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, deviceHandles.data());
+        }
+
+        for (auto &deviceHandle : deviceHandles) {
+            ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
+            Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
+            auto pPmt = new NiceMock<Mock<TemperaturePmt>>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
+                                                           deviceProperties.subdeviceId);
+            pPmt->mockedInit(pFsAccess.get());
+            // Get keyOffsetMap
+            auto keyOffsetMapEntry = guidToKeyOffsetMap.find(sampleGuid2);
+            pPmt->keyOffsetMap = keyOffsetMapEntry->second;
+            pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(deviceProperties.subdeviceId, pPmt);
+        }
+
+        productFamily = pLinuxSysmanImp->getDeviceHandle()->getNEODevice()->getHardwareInfo().platform.eProductFamily;
+        getTempHandles(0);
+    }
+    void TearDown() override {
+        if (!sysmanUltsEnable) {
+            GTEST_SKIP();
+        }
+        pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
+        SysmanDeviceFixture::TearDown();
+    }
+
+    std::vector<zes_temp_handle_t> getTempHandles(uint32_t count) {
+        std::vector<zes_temp_handle_t> handles(count, nullptr);
+        EXPECT_EQ(zesDeviceEnumTemperatureSensors(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
+        return handles;
+    }
+};
+
+TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingGPUAndGlobalTemperatureThenValidTemperatureReadingsRetrieved) {
+    auto handles = getTempHandles(handleComponentCountForNoSubDevices);
+    for (auto &deviceHandle : deviceHandles) {
+        ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
+        Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
+        auto pPmt = static_cast<NiceMock<Mock<TemperaturePmt>> *>(pLinuxSysmanImp->getPlatformMonitoringTechAccess(deviceProperties.subdeviceId));
+        pPmt->openFunction = openMockTemp;
+        pPmt->closeFunction = closeMockTemp;
+        pPmt->preadFunction = preadMockTempNoSubDevices;
+    }
+    for (auto &handle : handles) {
+        zes_temp_properties_t properties = {};
+        EXPECT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetProperties(handle, &properties));
+        double temperature;
+        ASSERT_EQ(ZE_RESULT_SUCCESS, zesTemperatureGetState(handle, &temperature));
+        if (properties.type == ZES_TEMP_SENSORS_GLOBAL) {
+            uint8_t maxTemp = 0;
+            for (uint64_t i = 0; i < sizeof(tempArrForNoSubDevices) / sizeof(uint8_t); i++) {
+                if ((tempArrForNoSubDevices[i] > invalidMaxTemperature) ||
+                    (tempArrForNoSubDevices[i] < invalidMinTemperature) || (maxTemp > tempArrForNoSubDevices[i])) {
+                    continue;
+                }
+                maxTemp = tempArrForNoSubDevices[i];
+            }
+            if (productFamily == IGFX_DG1) {
+                EXPECT_EQ(temperature, static_cast<double>(maxTemp));
+            }
+        }
+        if (properties.type == ZES_TEMP_SENSORS_GPU) {
+            if (productFamily == IGFX_DG1) {
+                EXPECT_EQ(temperature, static_cast<double>(tempArrForNoSubDevices[computeIndexForNoSubDevices]));
+            }
+        }
+    }
+}
+
+TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleAndPmtReadValueFailsWhenGettingTemperatureThenFailureReturned) {
+    // delete previously allocated pPmt objects
+    for (auto &subDeviceIdToPmtEntry : pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject) {
+        delete subDeviceIdToPmtEntry.second;
+    }
+    pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.clear();
+    // delete previously created temp handles
+    for (auto &handle : pSysmanDeviceImp->pTempHandleContext->handleList) {
+        delete handle;
+        handle = nullptr;
+        pSysmanDeviceImp->pTempHandleContext->handleList.pop_back();
+    }
+    for (auto &deviceHandle : deviceHandles) {
+        ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
+        Device::fromHandle(deviceHandle)->getProperties(&deviceProperties);
+        auto pPmt = new NiceMock<Mock<TemperaturePmt>>(pFsAccess.get(), deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
+                                                       deviceProperties.subdeviceId);
+        pPmt->mockedInit(pFsAccess.get());
+        pLinuxSysmanImp->mapOfSubDeviceIdToPmtObject.emplace(deviceProperties.subdeviceId, pPmt);
+    }
+
+    pSysmanDeviceImp->pTempHandleContext->init(deviceHandles);
+    auto handles = getTempHandles(handleComponentCountForNoSubDevices);
+    for (auto &handle : handles) {
+        double temperature;
+        ASSERT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesTemperatureGetState(handle, &temperature));
+    }
+}
+
+TEST_F(SysmanDeviceTemperatureFixture, GivenValidTempHandleWhenGettingUnsupportedSensorsTemperatureThenUnsupportedReturned) {
+    ze_device_properties_t deviceProperties = {ZE_STRUCTURE_TYPE_DEVICE_PROPERTIES};
+    Device::fromHandle(device->toHandle())->getProperties(&deviceProperties);
+    auto pPublicLinuxTemperatureImp = std::make_unique<LinuxTemperatureImp>(pOsSysman, deviceProperties.flags & ZE_DEVICE_PROPERTY_FLAG_SUBDEVICE,
+                                                                            deviceProperties.subdeviceId);
+    pPublicLinuxTemperatureImp->setSensorType(ZES_TEMP_SENSORS_MEMORY_MIN);
+    double temperature;
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pPublicLinuxTemperatureImp->getSensorTemperature(&temperature));
+}
+
+TEST_F(SysmanDeviceTemperatureFixture, GivenValidateEnumerateRootTelemIndexWhengetRealPathFailsThenFailureReturned) {
+    pFsAccess->mockErrorListDirectory = ZE_RESULT_ERROR_NOT_AVAILABLE;
+    EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE,
+              PlatformMonitoringTech::enumerateRootTelemIndex(pFsAccess.get(), gpuUpstreamPortPathInTemperature));
+
+    std::map<uint32_t, L0::PlatformMonitoringTech *> mapOfSubDeviceIdToPmtObject;
+    PlatformMonitoringTech::create(deviceHandles, pFsAccess.get(), gpuUpstreamPortPathInTemperature, mapOfSubDeviceIdToPmtObject);
+    EXPECT_TRUE(mapOfSubDeviceIdToPmtObject.empty());
+}
+
+TEST_F(SysmanDeviceTemperatureFixture, GivenValidatePmtReadValueWhenkeyOffsetMapIsNotThereThenFailureReturned) {
+    auto pPmt = std::make_unique<NiceMock<Mock<TemperaturePmt>>>(pFsAccess.get(), 0, 0);
+    pPmt->mockedInit(pFsAccess.get());
+    // Get keyOffsetMap
+    auto keyOffsetMapEntry = guidToKeyOffsetMap.find(sampleGuid2);
+    pPmt->keyOffsetMap = keyOffsetMapEntry->second;
+    uint32_t val = 0;
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pPmt->readValue("SOMETHING", val));
+}
+
+TEST_F(SysmanDeviceTemperatureFixture, GivenCreatePmtObjectsWhenRootTileIndexEnumeratesSuccessfulThenValidatePmtObjectsReceivedAndBranches) {
+    std::map<uint32_t, L0::PlatformMonitoringTech *> mapOfSubDeviceIdToPmtObject1;
+    PlatformMonitoringTech::create(deviceHandles, pFsAccess.get(), gpuUpstreamPortPathInTemperature, mapOfSubDeviceIdToPmtObject1);
+    for (auto &subDeviceIdToPmtEntry : mapOfSubDeviceIdToPmtObject1) {
+        EXPECT_NE(subDeviceIdToPmtEntry.second, nullptr);
+        EXPECT_EQ(subDeviceIdToPmtEntry.first, 0u); // We know that subdeviceID is zero as core device didnt have any subdevices
+        delete subDeviceIdToPmtEntry.second;        // delete memory to avoid mem leak here, as we finished our test validation just above.
+    }
+
+    std::map<uint32_t, L0::PlatformMonitoringTech *> mapOfSubDeviceIdToPmtObject2;
+    std::vector<ze_device_handle_t> testHandleVector;
+    // If empty device handle vector is provided then empty map is retrieved
+    PlatformMonitoringTech::create(testHandleVector, pFsAccess.get(), gpuUpstreamPortPathInTemperature, mapOfSubDeviceIdToPmtObject2);
+    EXPECT_TRUE(mapOfSubDeviceIdToPmtObject2.empty());
+}
+
+} // namespace ult
+} // namespace L0
diff --git a/level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/test_zes_temperature.cpp b/level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/test_zes_temperature.cpp
index 967758221c..894efd3511 100644
--- a/level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/test_zes_temperature.cpp
+++ b/level_zero/tools/test/unit_tests/sources/sysman/temperature/windows/test_zes_temperature.cpp
@@ -49,7 +49,7 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
             deviceHandles.resize(subDeviceCount, nullptr);
             Device::fromHandle(device->toHandle())->getSubDevices(&subDeviceCount, deviceHandles.data());
         }
-        pSysmanDeviceImp->pTempHandleContext->init(deviceHandles);
+        getTempHandles(0);
     }
     void TearDown() override {
         if (!sysmanUltsEnable) {