diff --git a/level_zero/sysman/test/unit_tests/sources/ras/linux/test_zes_ras.cpp b/level_zero/sysman/test/unit_tests/sources/ras/linux/test_zes_ras.cpp
index 2094f7d0aa..6a154b1bbd 100644
--- a/level_zero/sysman/test/unit_tests/sources/ras/linux/test_zes_ras.cpp
+++ b/level_zero/sysman/test/unit_tests/sources/ras/linux/test_zes_ras.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2024 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -7,6 +7,7 @@
 
 #include "shared/test/common/libult/linux/drm_mock.h"
 
+#include "level_zero/sysman/source/api/ras/linux/ras_util/sysman_ras_util.h"
 #include "level_zero/sysman/source/sysman_const.h"
 #include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
 #include "level_zero/sysman/test/unit_tests/sources/ras/linux/mock_sysman_ras.h"
@@ -540,19 +541,6 @@ HWTEST2_F(SysmanRasFixture, GivenValidRasHandleAndHandleCountZeroWhenCallingReIn
     EXPECT_EQ(count, mockHandleCount);
 }
 
-HWTEST2_F(SysmanRasFixture, GivenValidRasHandleAndRasUtilInterfaceIsNullWhenRequestingCountWithzesGetStateStateThenVerifyGetStateReturnsFailure, isRasNotSupportedProduct) {
-    bool isSubDevice = true;
-    uint32_t subDeviceId = 0u;
-
-    auto pLinuxRasImp = std::make_unique<PublicLinuxRasImp>(pOsSysman, ZES_RAS_ERROR_TYPE_CORRECTABLE, isSubDevice, subDeviceId);
-    pLinuxRasImp->rasSources.clear();
-    pLinuxRasImp->rasSources.push_back(std::make_unique<L0::Sysman::LinuxRasSourceGt>(pLinuxSysmanImp, ZES_RAS_ERROR_TYPE_CORRECTABLE, isSubDevice, subDeviceId));
-    pLinuxRasImp->rasSources.push_back(std::make_unique<L0::Sysman::LinuxRasSourceHbm>(pLinuxSysmanImp, ZES_RAS_ERROR_TYPE_CORRECTABLE, isSubDevice, subDeviceId));
-
-    zes_ras_state_t state = {};
-    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxRasImp->osRasGetState(state, 0));
-}
-
 HWTEST2_F(SysmanRasFixture, GivenValidRasHandleWhenCallingZesGetRasStateAndFirmwareInterfaceIsAbsentOtherInterfacesAreAlsoAbsentThenCallFails, IsPVC) {
     pDrm->setMemoryType(NEO::DeviceBlobConstants::MemoryType::hbm2e);
     pFsAccess->mockReadVal = true;
@@ -573,6 +561,13 @@ HWTEST2_F(SysmanRasFixture, GivenValidRasHandleWhenCallingZesGetRasStateAndFirmw
     }
 }
 
+TEST_F(SysmanRasFixture, GivenRasUtilAsNoneWhenCallingRasGetStateAndRasGetCategoryCountThenErrorAndNoCategoryCountIsReturned) {
+    auto pRasUtil = std::make_unique<RasUtilNone>();
+    zes_ras_state_t state = {};
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pRasUtil->rasGetState(state, false));
+    EXPECT_EQ(0u, pRasUtil->rasGetCategoryCount());
+}
+
 struct SysmanRasMultiDeviceFixture : public SysmanMultiDeviceFixture {
   protected:
     std::unique_ptr<MockRasFsAccess> pFsAccess;
diff --git a/level_zero/sysman/test/unit_tests/sources/ras/linux/test_zes_ras_exp.cpp b/level_zero/sysman/test/unit_tests/sources/ras/linux/test_zes_ras_exp.cpp
index 332d5de672..994bf561bc 100644
--- a/level_zero/sysman/test/unit_tests/sources/ras/linux/test_zes_ras_exp.cpp
+++ b/level_zero/sysman/test/unit_tests/sources/ras/linux/test_zes_ras_exp.cpp
@@ -7,6 +7,7 @@
 
 #include "shared/test/common/libult/linux/drm_mock.h"
 
+#include "level_zero/sysman/source/api/ras/linux/ras_util/sysman_ras_util.h"
 #include "level_zero/sysman/source/sysman_const.h"
 #include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h"
 #include "level_zero/sysman/test/unit_tests/sources/ras/linux/mock_sysman_ras.h"
@@ -680,20 +681,6 @@ HWTEST2_F(SysmanRasExpFixture, GivenValidRasHandleAndRasUtilInterfaceIsNullWhenC
     EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pLinuxRasImp->osRasClearStateExp(ZES_RAS_ERROR_CATEGORY_EXP_DRIVER_ERRORS));
 }
 
-HWTEST2_F(SysmanRasExpFixture, GivenValidRasHandleAndRasUtilInterfaceIsNullWhenCallingzesGetStateStateExpThenVerifyGetStateExpReturnsFailure, IsNotPVC) {
-    bool isSubDevice = true;
-    uint32_t subDeviceId = 0u;
-
-    auto pLinuxRasImp = std::make_unique<PublicLinuxRasImp>(pOsSysman, ZES_RAS_ERROR_TYPE_CORRECTABLE, isSubDevice, subDeviceId);
-    pLinuxRasImp->rasSources.clear();
-    pLinuxRasImp->rasSources.push_back(std::make_unique<L0::Sysman::LinuxRasSourceGt>(pLinuxSysmanImp, ZES_RAS_ERROR_TYPE_CORRECTABLE, isSubDevice, subDeviceId));
-    pLinuxRasImp->rasSources.push_back(std::make_unique<L0::Sysman::LinuxRasSourceHbm>(pLinuxSysmanImp, ZES_RAS_ERROR_TYPE_CORRECTABLE, isSubDevice, subDeviceId));
-
-    uint32_t count = 2;
-    std::vector<zes_ras_state_exp_t> rasStates(count);
-    EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, pLinuxRasImp->osRasGetStateExp(&count, rasStates.data()));
-}
-
 HWTEST2_F(SysmanRasExpFixture, GivenValidRasHandleWhenCallingzesRasClearStateExpAndGetStateExpForHbmThenVerifyErrorCountersAreCleared, IsPVC) {
     pDrm->setMemoryType(NEO::DeviceBlobConstants::MemoryType::hbm2);
     pPmuInterface->mockPmuReadResult = true;
@@ -765,6 +752,13 @@ HWTEST2_F(SysmanRasExpFixture, GivenValidRasHandleWhenCallingzesRasClearStateExp
     }
 }
 
+TEST_F(SysmanRasExpFixture, GivenRasUtilAsNoneWhenCallingRasGetStateExpAndRasClearStateExpThenErrorAreReturned) {
+    auto pRasUtil = std::make_unique<RasUtilNone>();
+    std::vector<zes_ras_state_exp_t> rasStates(maxRasErrorCategoryExpCount);
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pRasUtil->rasGetStateExp(maxRasErrorCategoryExpCount, rasStates.data()));
+    EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pRasUtil->rasClearStateExp(ZES_RAS_ERROR_CATEGORY_EXP_COMPUTE_ERRORS));
+}
+
 struct SysmanRasExpMultiDeviceFixture : public SysmanMultiDeviceFixture {
   protected:
     std::unique_ptr<MockRasFsAccess> pFsAccess;
diff --git a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_ras_tests.cpp b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_ras_tests.cpp
index 7936a181a8..3a8d00a0cb 100644
--- a/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_ras_tests.cpp
+++ b/level_zero/sysman/test/unit_tests/sources/shared/linux/product_helper/sysman_product_helper_ras_tests.cpp
@@ -56,6 +56,107 @@ HWTEST2_F(SysmanProductHelperRasTest, GivenValidRasHandleWhenRequestingCountWith
     EXPECT_EQ(3u, count);
 }
 
+HWTEST2_F(SysmanProductHelperRasTest, GivenValidRasHandleAndRasSourcesWhenCallingRasGetStateThenSuccessIsReturned, IsPVC) {
+
+    VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, [](const char *path, char *buf, size_t bufsize) -> int {
+        constexpr size_t sizeofPath = sizeof("/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0");
+        strcpy_s(buf, sizeofPath, "/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0");
+        return sizeofPath;
+    });
+
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
+        std::ostringstream oStream;
+        oStream << pmuDriverType;
+        std::string value = oStream.str();
+        memcpy(buf, value.data(), count);
+        return count;
+    });
+
+    VariableBackup<L0::Sysman::FsAccessInterface *> fsBackup(&pLinuxSysmanImp->pFsAccess);
+    auto pFsAccess = std::make_unique<MockRasFsAccess>();
+    pLinuxSysmanImp->pFsAccess = pFsAccess.get();
+
+    auto pPmuInterface = std::make_unique<MockRasPmuInterfaceImp>(pLinuxSysmanImp);
+    pPmuInterface->mockPmuReadAfterClear = true;
+    VariableBackup<L0::Sysman::PmuInterface *> pmuBackup(&pLinuxSysmanImp->pPmuInterface);
+    pLinuxSysmanImp->pPmuInterface = pPmuInterface.get();
+
+    VariableBackup<L0::Sysman::SysFsAccessInterface *> sysfsBackup(&pLinuxSysmanImp->pSysfsAccess);
+    auto pSysfsAccess = std::make_unique<MockRasSysfsAccess>();
+    pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
+
+    bool isSubDevice = false;
+    uint32_t subDeviceId = 0u;
+
+    auto pLinuxRasImp = std::make_unique<PublicLinuxRasImp>(pOsSysman, ZES_RAS_ERROR_TYPE_CORRECTABLE, isSubDevice, subDeviceId);
+    pLinuxRasImp->rasSources.clear();
+    pLinuxRasImp->rasSources.push_back(std::make_unique<L0::Sysman::LinuxRasSourceGt>(pLinuxSysmanImp, ZES_RAS_ERROR_TYPE_CORRECTABLE, isSubDevice, subDeviceId));
+    pLinuxRasImp->rasSources.push_back(std::make_unique<L0::Sysman::LinuxRasSourceHbm>(pLinuxSysmanImp, ZES_RAS_ERROR_TYPE_CORRECTABLE, isSubDevice, subDeviceId));
+
+    zes_ras_state_t state = {};
+    EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxRasImp->osRasGetState(state, 0));
+    EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_RESET], 0u);
+    EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_PROGRAMMING_ERRORS], 0u);
+    EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_DRIVER_ERRORS], 0u);
+    EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_COMPUTE_ERRORS], correctableGrfErrorCount + correctableEuErrorCount + initialCorrectableComputeErrors);
+    EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_NON_COMPUTE_ERRORS], 0u);
+    EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_CACHE_ERRORS], 0u);
+    EXPECT_EQ(state.category[ZES_RAS_ERROR_CAT_DISPLAY_ERRORS], 0u);
+}
+
+HWTEST2_F(SysmanProductHelperRasTest, GivenValidRasHandleAndRasSourcesWhenCallingRasGetStateStateExpThenSuccessIsReturned, IsPVC) {
+
+    VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, [](const char *path, char *buf, size_t bufsize) -> int {
+        constexpr size_t sizeofPath = sizeof("/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0");
+        strcpy_s(buf, sizeofPath, "/sys/devices/pci0000:00/0000:00:01.0/0000:01:00.0/0000:02:01.0/0000:03:00.0");
+        return sizeofPath;
+    });
+
+    VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
+        std::ostringstream oStream;
+        oStream << pmuDriverType;
+        std::string value = oStream.str();
+        memcpy(buf, value.data(), count);
+        return count;
+    });
+
+    VariableBackup<L0::Sysman::FsAccessInterface *> fsBackup(&pLinuxSysmanImp->pFsAccess);
+    auto pFsAccess = std::make_unique<MockRasFsAccess>();
+    pLinuxSysmanImp->pFsAccess = pFsAccess.get();
+
+    auto pPmuInterface = std::make_unique<MockRasPmuInterfaceImp>(pLinuxSysmanImp);
+    pPmuInterface->mockPmuReadAfterClear = true;
+    VariableBackup<L0::Sysman::PmuInterface *> pmuBackup(&pLinuxSysmanImp->pPmuInterface);
+    pLinuxSysmanImp->pPmuInterface = pPmuInterface.get();
+
+    VariableBackup<L0::Sysman::SysFsAccessInterface *> sysfsBackup(&pLinuxSysmanImp->pSysfsAccess);
+    auto pSysfsAccess = std::make_unique<MockRasSysfsAccess>();
+    pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get();
+
+    bool isSubDevice = false;
+    uint32_t subDeviceId = 0u;
+
+    auto pLinuxRasImp = std::make_unique<PublicLinuxRasImp>(pOsSysman, ZES_RAS_ERROR_TYPE_CORRECTABLE, isSubDevice, subDeviceId);
+    pLinuxRasImp->rasSources.clear();
+    pLinuxRasImp->rasSources.push_back(std::make_unique<L0::Sysman::LinuxRasSourceGt>(pLinuxSysmanImp, ZES_RAS_ERROR_TYPE_CORRECTABLE, isSubDevice, subDeviceId));
+    pLinuxRasImp->rasSources.push_back(std::make_unique<L0::Sysman::LinuxRasSourceHbm>(pLinuxSysmanImp, ZES_RAS_ERROR_TYPE_CORRECTABLE, isSubDevice, subDeviceId));
+
+    uint32_t count = 2;
+    std::vector<zes_ras_state_exp_t> rasStates(count);
+    EXPECT_EQ(ZE_RESULT_SUCCESS, pLinuxRasImp->osRasGetStateExp(&count, rasStates.data()));
+    for (uint32_t i = 0; i < count; i++) {
+        if (rasStates[i].category == ZES_RAS_ERROR_CATEGORY_EXP_COMPUTE_ERRORS) {
+            uint32_t expectedErrCount = correctableGrfErrorCount + correctableEuErrorCount + initialCorrectableComputeErrors;
+            EXPECT_EQ(rasStates[i].errorCounter, expectedErrCount);
+            break;
+        } else if (rasStates[i].category == ZES_RAS_ERROR_CATEGORY_EXP_NON_COMPUTE_ERRORS) {
+            uint32_t expectedErrCount = 0u;
+            EXPECT_EQ(rasStates[i].errorCounter, expectedErrCount);
+            break;
+        }
+    }
+}
+
 } // namespace ult
 } // namespace Sysman
 } // namespace L0