intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-04 07:14:10 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Remove duplicate FsAccess class definition

Browse Source 
Related-To: NEO-9661

Signed-off-by: Bellekallu Rajkiran <bellekallu.rajkiran@intel.com>
This commit is contained in:
Bellekallu Rajkiran
2023-11-30 16:56:59 +00:00
committed by Compute-Runtime-Automation
parent b92b5892b8
commit 3349fcaf75
83 changed files with 306 additions and 1057 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
level_zero/sysman/test/unit_tests/sources/diagnostics/linux/mock_zes_sysman_diagnostics.h
View File

@@ -70,7 +70,7 @@ struct MockGlobalOperationsEngineHandleContext : public L0::Sysman::EngineHandle
ADDMETHOD_NOBASE_VOIDRETURN(init, (uint32_t subDeviceCount));
};
struct MockDiagFsAccess : public L0::Sysman::FsAccess {
struct MockDiagFsAccess : public L0::Sysman::FsAccessInterface {
ze_result_t mockReadError = ZE_RESULT_SUCCESS;
ze_result_t mockWriteError = ZE_RESULT_SUCCESS;
ze_result_t mockListDirError = ZE_RESULT_SUCCESS;
@@ -125,7 +125,7 @@ struct MockDiagFsAccess : public L0::Sysman::FsAccess {
MockDiagFsAccess() = default;
};
struct MockDiagSysfsAccess : public L0::Sysman::SysfsAccess {
struct MockDiagSysfsAccess : public L0::Sysman::SysFsAccessInterface {
ze_result_t mockError = ZE_RESULT_SUCCESS;
int checkErrorAfterCount = 0;
ze_result_t getRealPath(const std::string file, std::string &val) override {
@@ -180,7 +180,7 @@ struct MockDiagSysfsAccess : public L0::Sysman::SysfsAccess {
MockDiagSysfsAccess() = default;
};
struct MockDiagProcfsAccess : public L0::Sysman::ProcfsAccess {
struct MockDiagProcfsAccess : public L0::Sysman::ProcFsAccessInterface {
std::vector<::pid_t> pidList = {1, 2, 3};
::pid_t ourDevicePid = 0;
ze_result_t mockError = ZE_RESULT_SUCCESS;

32
level_zero/sysman/test/unit_tests/sources/diagnostics/linux/test_zes_sysman_diagnostics.cpp
View File

@@ -111,9 +111,9 @@ class ZesDiagnosticsFixture : public SysmanDeviceFixture {
std::unique_ptr<MockDiagLinuxSysmanImp> pMockDiagLinuxSysmanImp;
L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::FsAccess *pFsAccessOld = nullptr;
L0::Sysman::ProcfsAccess *pProcfsAccessOld = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOld = nullptr;
L0::Sysman::ProcFsAccessInterface *pProcfsAccessOld = nullptr;
L0::Sysman::EngineHandleContext *pEngineHandleContextOld = nullptr;
L0::Sysman::SysmanDevice *device = nullptr;
@@ -265,7 +265,7 @@ TEST_F(ZesDiagnosticsFixture, GivenValidDiagnosticsHandleWhenRunningDiagnosticsT
pPublicLinuxDiagnosticsImp->pFwInterface = pMockDiagFwInterface.get();
pPublicLinuxDiagnosticsImp->pLinuxSysmanImp = pMockDiagLinuxSysmanImp.get();
pPublicLinuxDiagnosticsImp->osDiagType = "MEMORY_PPR";
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
pMockDiagLinuxSysmanImp->pProcfsAccess = pMockDiagProcfsAccess.get();
std::unique_ptr<L0::Sysman::DiagnosticsImp> ptestDiagnosticsImp = std::make_unique<L0::Sysman::DiagnosticsImp>(pSysmanDeviceImp->pDiagnosticsHandleContext->pOsSysman, mockSupportedDiagTypes[0]);
@@ -288,7 +288,7 @@ TEST_F(ZesDiagnosticsFixture, GivenValidDiagnosticsHandleWhenRunningDiagnosticsT
pPublicLinuxDiagnosticsImp->pSysfsAccess = pMockSysfsAccess.get();
pPublicLinuxDiagnosticsImp->pFwInterface = pMockDiagFwInterface.get();
pPublicLinuxDiagnosticsImp->pLinuxSysmanImp = pMockDiagLinuxSysmanImp.get();
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
pMockDiagLinuxSysmanImp->pProcfsAccess = pMockDiagProcfsAccess.get();
pMockDiagFwInterface->setDiagResult(ZES_DIAG_RESULT_FORCE_UINT32);
@@ -313,7 +313,7 @@ TEST_F(ZesDiagnosticsFixture, GivenValidDiagnosticsHandleWhenListProcessFailsThe
pPublicLinuxDiagnosticsImp->pSysfsAccess = pMockSysfsAccess.get();
pPublicLinuxDiagnosticsImp->pFwInterface = pMockDiagFwInterface.get();
pPublicLinuxDiagnosticsImp->pLinuxSysmanImp = pMockDiagLinuxSysmanImp.get();
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
pMockDiagLinuxSysmanImp->pProcfsAccess = pMockDiagProcfsAccess.get();
pMockDiagProcfsAccess->setMockError(ZE_RESULT_ERROR_NOT_AVAILABLE);
std::unique_ptr<L0::Sysman::DiagnosticsImp> ptestDiagnosticsImp = std::make_unique<L0::Sysman::DiagnosticsImp>(pSysmanDeviceImp->pDiagnosticsHandleContext->pOsSysman, mockSupportedDiagTypes[0]);
@@ -337,7 +337,7 @@ TEST_F(ZesDiagnosticsFixture, GivenValidDiagnosticsHandleWhenQuiescentingFailsTh
pPublicLinuxDiagnosticsImp->pSysfsAccess = pMockSysfsAccess.get();
pPublicLinuxDiagnosticsImp->pFwInterface = pMockDiagFwInterface.get();
pPublicLinuxDiagnosticsImp->pLinuxSysmanImp = pMockDiagLinuxSysmanImp.get();
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
pMockDiagLinuxSysmanImp->pProcfsAccess = pMockDiagProcfsAccess.get();
pMockSysfsAccess->setMockError(ZE_RESULT_ERROR_NOT_AVAILABLE);
std::unique_ptr<L0::Sysman::DiagnosticsImp> ptestDiagnosticsImp = std::make_unique<L0::Sysman::DiagnosticsImp>(pSysmanDeviceImp->pDiagnosticsHandleContext->pOsSysman, mockSupportedDiagTypes[0]);
@@ -361,7 +361,7 @@ TEST_F(ZesDiagnosticsFixture, GivenValidDiagnosticsHandleWhenInvalidateLmemFails
pPublicLinuxDiagnosticsImp->pSysfsAccess = pMockSysfsAccess.get();
pPublicLinuxDiagnosticsImp->pFwInterface = pMockDiagFwInterface.get();
pPublicLinuxDiagnosticsImp->pLinuxSysmanImp = pMockDiagLinuxSysmanImp.get();
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
pMockDiagLinuxSysmanImp->pProcfsAccess = pMockDiagProcfsAccess.get();
pMockSysfsAccess->setMockError(ZE_RESULT_ERROR_NOT_AVAILABLE);
std::unique_ptr<L0::Sysman::DiagnosticsImp> ptestDiagnosticsImp = std::make_unique<L0::Sysman::DiagnosticsImp>(pSysmanDeviceImp->pDiagnosticsHandleContext->pOsSysman, mockSupportedDiagTypes[0]);
@@ -385,7 +385,7 @@ TEST_F(ZesDiagnosticsFixture, GivenValidDiagnosticsHandleWhenColdResetFailsThenC
pPublicLinuxDiagnosticsImp->pSysfsAccess = pMockSysfsAccess.get();
pPublicLinuxDiagnosticsImp->pFwInterface = pMockDiagFwInterface.get();
pPublicLinuxDiagnosticsImp->pLinuxSysmanImp = pMockDiagLinuxSysmanImp.get();
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
pMockDiagLinuxSysmanImp->pProcfsAccess = pMockDiagProcfsAccess.get();
pMockDiagFwInterface->setDiagResult(ZES_DIAG_RESULT_REBOOT_FOR_REPAIR);
pMockDiagLinuxSysmanImp->setMockError(ZE_RESULT_ERROR_NOT_AVAILABLE);
@@ -410,7 +410,7 @@ TEST_F(ZesDiagnosticsFixture, GivenValidDiagnosticsHandleWhenWarmResetFailsThenC
pPublicLinuxDiagnosticsImp->pSysfsAccess = pMockSysfsAccess.get();
pPublicLinuxDiagnosticsImp->pFwInterface = pMockDiagFwInterface.get();
pPublicLinuxDiagnosticsImp->pLinuxSysmanImp = pMockDiagLinuxSysmanImp.get();
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
pMockDiagLinuxSysmanImp->pProcfsAccess = pMockDiagProcfsAccess.get();
pMockDiagLinuxSysmanImp->setMockError(ZE_RESULT_ERROR_NOT_AVAILABLE);
std::unique_ptr<L0::Sysman::DiagnosticsImp> ptestDiagnosticsImp = std::make_unique<L0::Sysman::DiagnosticsImp>(pSysmanDeviceImp->pDiagnosticsHandleContext->pOsSysman, mockSupportedDiagTypes[0]);
@@ -434,7 +434,7 @@ TEST_F(ZesDiagnosticsFixture, GivenValidDiagnosticsHandleWhenWarmResetSucceedsAn
pPublicLinuxDiagnosticsImp->pSysfsAccess = pMockSysfsAccess.get();
pPublicLinuxDiagnosticsImp->pFwInterface = pMockDiagFwInterface.get();
pPublicLinuxDiagnosticsImp->pLinuxSysmanImp = pMockDiagLinuxSysmanImp.get();
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
pMockDiagLinuxSysmanImp->pProcfsAccess = pMockDiagProcfsAccess.get();
pMockDiagLinuxSysmanImp->setMockReInitSysmanDeviceError(ZE_RESULT_ERROR_NOT_AVAILABLE);
std::unique_ptr<L0::Sysman::DiagnosticsImp> ptestDiagnosticsImp = std::make_unique<L0::Sysman::DiagnosticsImp>(pSysmanDeviceImp->pDiagnosticsHandleContext->pOsSysman, mockSupportedDiagTypes[0]);
@@ -458,7 +458,7 @@ TEST_F(ZesDiagnosticsFixture, GivenValidDiagnosticsHandleWhenColdResetSucceedsAn
pPublicLinuxDiagnosticsImp->pSysfsAccess = pMockSysfsAccess.get();
pPublicLinuxDiagnosticsImp->pFwInterface = pMockDiagFwInterface.get();
pPublicLinuxDiagnosticsImp->pLinuxSysmanImp = pMockDiagLinuxSysmanImp.get();
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
pMockDiagLinuxSysmanImp->pProcfsAccess = pMockDiagProcfsAccess.get();
pMockDiagFwInterface->setDiagResult(ZES_DIAG_RESULT_REBOOT_FOR_REPAIR);
pMockDiagLinuxSysmanImp->setMockReInitSysmanDeviceError(ZE_RESULT_ERROR_NOT_AVAILABLE);
@@ -482,7 +482,7 @@ TEST_F(ZesDiagnosticsFixture, GivenValidDiagnosticsHandleWhenGPUProcessCleanupSu
pPublicLinuxDiagnosticsImp->pSysfsAccess = pMockSysfsAccess.get();
pPublicLinuxDiagnosticsImp->pFwInterface = pMockDiagFwInterface.get();
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
pMockDiagLinuxSysmanImp->pProcfsAccess = pMockDiagProcfsAccess.get();
pPublicLinuxDiagnosticsImp->pLinuxSysmanImp = pMockDiagLinuxSysmanImp.get();
pMockDiagProcfsAccess->ourDevicePid = getpid();
@@ -499,7 +499,7 @@ TEST_F(ZesDiagnosticsFixture, GivenValidDiagnosticsHandleWhenGPUProcessCleanupFa
pPublicLinuxDiagnosticsImp->pSysfsAccess = pMockSysfsAccess.get();
pPublicLinuxDiagnosticsImp->pFwInterface = pMockDiagFwInterface.get();
pPublicLinuxDiagnosticsImp->pLinuxSysmanImp = pMockDiagLinuxSysmanImp.get();
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
pMockDiagLinuxSysmanImp->pProcfsAccess = pMockDiagProcfsAccess.get();
pMockSysfsAccess->setMockError(ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE);
pMockDiagProcfsAccess->setMockError(ZE_RESULT_ERROR_NOT_AVAILABLE);
@@ -514,7 +514,7 @@ TEST_F(ZesDiagnosticsFixture, GivenValidDiagnosticsHandleWhenQuiescentFailsConti
pPublicLinuxDiagnosticsImp->pSysfsAccess = pMockSysfsAccess.get();
pPublicLinuxDiagnosticsImp->pFwInterface = pMockDiagFwInterface.get();
pPublicLinuxDiagnosticsImp->pLinuxSysmanImp = pMockDiagLinuxSysmanImp.get();
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
pMockDiagLinuxSysmanImp->pProcfsAccess = pMockDiagProcfsAccess.get();
pMockSysfsAccess->setErrorAfterCount(12, ZE_RESULT_ERROR_HANDLE_OBJECT_IN_USE);
@@ -529,7 +529,7 @@ TEST_F(ZesDiagnosticsFixture, GivenValidDiagnosticsHandleWhenInvalidateLmemFails
pPublicLinuxDiagnosticsImp->pSysfsAccess = pMockSysfsAccess.get();
pPublicLinuxDiagnosticsImp->pFwInterface = pMockDiagFwInterface.get();
pPublicLinuxDiagnosticsImp->pLinuxSysmanImp = pMockDiagLinuxSysmanImp.get();
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pMockDiagLinuxSysmanImp->pProcfsAccess);
pMockDiagLinuxSysmanImp->pProcfsAccess = pMockDiagProcfsAccess.get();
pMockSysfsAccess->setErrorAfterCount(1, ZE_RESULT_ERROR_NOT_AVAILABLE);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, pPublicLinuxDiagnosticsImp->waitForQuiescentCompletion());

5
level_zero/sysman/test/unit_tests/sources/engine/linux/mock_engine_prelim.h
View File

@@ -13,6 +13,7 @@
#include "level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.h"
#include "level_zero/sysman/source/api/engine/sysman_engine_imp.h"
#include "level_zero/sysman/source/shared/linux/pmu/sysman_pmu_imp.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_hw_device_id.h"
@@ -137,7 +138,7 @@ struct MockEnginePmuInterfaceImp : public L0::Sysman::PmuInterfaceImp {
}
};
struct MockEngineFsAccess : public L0::Sysman::FsAccess {
struct MockEngineFsAccess : public L0::Sysman::FsAccessInterface {
bool mockReadVal = false;
@@ -157,7 +158,7 @@ struct MockEngineFsAccess : public L0::Sysman::FsAccess {
}
};
struct MockEngineSysfsAccess : public L0::Sysman::SysfsAccess {
struct MockEngineSysfsAccess : public L0::Sysman::SysFsAccessInterface {
bool mockReadSymLinkFailure = false;
bool mockReadSymLinkSuccess = false;

8
level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine_prelim.cpp
View File

@@ -25,9 +25,9 @@ class ZesEngineFixture : public SysmanDeviceFixture {
Drm *pOriginalDrm = nullptr;
L0::Sysman::PmuInterface *pOriginalPmuInterface = nullptr;
std::unique_ptr<MockEngineSysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOriginal = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOriginal = nullptr;
std::unique_ptr<MockEngineFsAccess> pFsAccess;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::SysmanDevice *device = nullptr;
@@ -315,9 +315,9 @@ class ZesEngineMultiFixture : public SysmanMultiDeviceFixture {
std::unique_ptr<MockEnginePmuInterfaceImp> pPmuInterface;
L0::Sysman::PmuInterface *pOriginalPmuInterface = nullptr;
std::unique_ptr<MockEngineSysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOriginal = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOriginal = nullptr;
std::unique_ptr<MockEngineFsAccess> pFsAccess;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::SysmanDevice *device = nullptr;
void SetUp() override {

5
level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine_xe.cpp
View File

@@ -27,6 +27,11 @@ class ZesEngineFixtureXe : public SysmanDeviceFixture {
void SetUp() override {
SysmanDeviceFixture::SetUp();
VariableBackup<decltype(NEO::SysCalls::sysCallsReadlink)> mockReadLink(&NEO::SysCalls::sysCallsReadlink, [](const char *path, char *buf, size_t bufsize) -> int {
std::string str = "../../devices/pci0000:37/0000:37:01.0/0000:38:00.0/0000:39:01.0/0000:3a:00.0/drm/renderD128";
std::memcpy(buf, str.c_str(), str.size());
return static_cast<int>(str.size());
});
device = pSysmanDevice;
MockNeoDrm *pDrm = new MockNeoDrm(const_cast<NEO::RootDeviceEnvironment &>(pSysmanDeviceImp->getRootDeviceEnvironment()));
pDrm->ioctlHelper = std::make_unique<NEO::IoctlHelperXe>(*pDrm);

5
level_zero/sysman/test/unit_tests/sources/events/linux/mock_events.h
View File

@@ -18,6 +18,7 @@
#include "level_zero/sysman/source/api/events/sysman_events_imp.h"
#include "level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h"
#include "level_zero/sysman/source/shared/linux/pmu/sysman_pmu_imp.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/shared/linux/zes_os_sysman_driver_imp.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_hw_device_id.h"
@@ -67,7 +68,7 @@ struct MockPmuInterfaceImpForEvents : public L0::Sysman::PmuInterfaceImp {
}
};
struct MockEventsFsAccess : public L0::Sysman::FsAccess {
struct MockEventsFsAccess : public L0::Sysman::FsAccessInterface {
bool mockReadValSuccess = false;
bool mockReadValOne = false;
@@ -174,7 +175,7 @@ struct MockEventsFsAccess : public L0::Sysman::FsAccess {
MockEventsFsAccess() = default;
};
struct MockEventsSysfsAccess : public L0::Sysman::SysfsAccess {
struct MockEventsSysfsAccess : public L0::Sysman::SysFsAccessInterface {
ze_result_t getRealPathResult = ZE_RESULT_SUCCESS;
std::string realPath = "/sys/devices/pci0000:97/0000:97:02.0/0000:98:00.0/0000:99:01.0/0000:9a:00.0";

4
level_zero/sysman/test/unit_tests/sources/events/linux/test_zes_events.cpp
View File

@@ -23,11 +23,11 @@ class SysmanEventsFixture : public SysmanDeviceFixture {
std::unique_ptr<MockEventsFsAccess> pFsAccess;
MockEventNeoDrm *pDrm = nullptr;
Drm *pOriginalDrm = nullptr;
FsAccess *pFsAccessOriginal = nullptr;
FsAccessInterface *pFsAccessOriginal = nullptr;
OsEvents *pOsEventsPrev = nullptr;
L0::Sysman::EventsImp *pEventsImp;
std::unique_ptr<MockEventsSysfsAccess> pSysfsAccess;
SysfsAccess *pSysfsAccessOriginal = nullptr;
SysFsAccessInterface *pSysfsAccessOriginal = nullptr;
std::unique_ptr<MockPmuInterfaceImpForEvents> pPmuInterface;
PmuInterface *pOriginalPmuInterface = nullptr;
PublicLinuxEventsImp *pLinuxEventsImp = nullptr;

6
level_zero/sysman/test/unit_tests/sources/fabric_port/linux/mock_fabric_device.h
View File

@@ -10,7 +10,7 @@
#include "shared/test/common/test_macros/mock_method_macros.h"
#include "level_zero/sysman/source/api/fabric_port/sysman_fabric_port.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h"
namespace L0 {
@@ -27,7 +27,7 @@ struct MockFabricDevice : public L0::Sysman::FabricDevice {
MockFabricDevice() = default;
};
class MockFabricFsAccess : public L0::Sysman::FsAccess {
class MockFabricFsAccess : public L0::Sysman::FsAccessInterface {
public:
ze_result_t mockListDirectory = ZE_RESULT_SUCCESS;
ze_result_t canRead(const std::string file) override {
@@ -65,7 +65,7 @@ class MockFabricFsAccess : public L0::Sysman::FsAccess {
std::vector<std::string> accessibleDirectories = {};
};
class MockFabricSysFsAccess : public L0::Sysman::SysfsAccess {
class MockFabricSysFsAccess : public L0::Sysman::SysFsAccessInterface {
public:
ze_result_t getRealPath(const std::string path, std::string &buf) override {
buf.append("/mockRealPath");

36
level_zero/sysman/test/unit_tests/sources/fabric_port/linux/test_sysman_fabric_port_prelim.cpp
View File

@@ -651,8 +651,8 @@ TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortG
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersWithLegacyPathAndCallSucceeds) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
VariableBackup<FsAccessInterface *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysFsAccessInterface *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
@@ -699,8 +699,8 @@ TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortG
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersCallSucceeds) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
VariableBackup<FsAccessInterface *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysFsAccessInterface *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
@@ -748,8 +748,8 @@ TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortG
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndGetRealPathFailsThenFailureIsReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
VariableBackup<FsAccessInterface *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysFsAccessInterface *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
@@ -774,8 +774,8 @@ TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortG
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndListDirectoryFailsThenFailureIsReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
VariableBackup<FsAccessInterface *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysFsAccessInterface *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
@@ -800,8 +800,8 @@ TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortG
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndIafSysfsFilesAreNotPresentThenFailureIsReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
VariableBackup<FsAccessInterface *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysFsAccessInterface *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
@@ -827,8 +827,8 @@ TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortG
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndLinkFailureSysfsNodeIsAbsentThenZeroLinkFailuresAreReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
VariableBackup<FsAccessInterface *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysFsAccessInterface *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
@@ -878,8 +878,8 @@ TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortG
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndLinkDegradesSysfsNodeIsAbsentThenZeroLinkDegradesAreReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
VariableBackup<FsAccessInterface *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysFsAccessInterface *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
@@ -930,8 +930,8 @@ TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortG
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndFwErrorSysfsNodeIsAbsentThenZeroFwErrorsAreReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
VariableBackup<FsAccessInterface *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysFsAccessInterface *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
@@ -982,8 +982,8 @@ TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortG
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndFwCommErrorSysfsNodeIsAbsentThenZeroFwCommErrorsAreReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
VariableBackup<FsAccessInterface *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysFsAccessInterface *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;

2
level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware.h
View File

@@ -21,7 +21,7 @@ std::vector<std::string> mockSupportedFwTypes = {"GSC", "OptionROM"};
std::vector<std::string> mockUnsupportedFwTypes = {"unknown"};
std::string mockEmpty = {};
class FirmwareInterface : public L0::Sysman::FirmwareUtil {};
class FirmwareFsAccess : public L0::Sysman::FsAccess {};
class FirmwareFsAccess : public L0::Sysman::FsAccessInterface {};
struct MockFirmwareFsAccess : public FirmwareFsAccess {
ze_bool_t isReadFwTypes = true;

6
level_zero/sysman/test/unit_tests/sources/firmware/linux/mock_zes_sysman_firmware_prelim.h
View File

@@ -23,8 +23,8 @@ std::vector<std::string> mockSupportedFirmwareTypes = {"GSC", "OptionROM", "PSC"
std::vector<std::string> mockUnsupportedFwTypes = {"unknown"};
std::string mockEmpty = {};
class FirmwareInterface : public L0::Sysman::FirmwareUtil {};
class FirmwareFsAccess : public L0::Sysman::FsAccess {};
class FirmwareSysfsAccess : public L0::Sysman::SysfsAccess {};
class FirmwareFsAccess : public L0::Sysman::FsAccessInterface {};
class FirmwareSysfsAccess : public L0::Sysman::SysFsAccessInterface {};
struct MockFirmwareFsAccess : public FirmwareFsAccess {
ze_bool_t isReadFwTypes = true;
@@ -41,7 +41,7 @@ struct MockFirmwareFsAccess : public FirmwareFsAccess {
}
};
struct MockFirmwareSysfsAccess : public L0::Sysman::SysfsAccess {
struct MockFirmwareSysfsAccess : public L0::Sysman::SysFsAccessInterface {
ze_result_t readResult = ZE_RESULT_SUCCESS;
ze_result_t scanDirEntriesResult = ZE_RESULT_SUCCESS;

4
level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware.cpp
View File

@@ -18,7 +18,7 @@ class ZesFirmwareFixture : public SysmanDeviceFixture {
std::unique_ptr<MockFirmwareInterface> pMockFwInterface;
L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr;
std::unique_ptr<MockFirmwareFsAccess> pFsAccess;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::SysmanDevice *device = nullptr;
void SetUp() override {
@@ -237,7 +237,7 @@ class ZesFirmwareUninitializedFixture : public SysmanDeviceFixture {
std::unique_ptr<MockFirmwareInterface> pMockFwInterface;
L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr;
std::unique_ptr<MockFirmwareFsAccess> pFsAccess;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
void SetUp() override {
SysmanDeviceFixture::SetUp();

14
level_zero/sysman/test/unit_tests/sources/firmware/linux/test_zes_sysman_firmware_prelim.cpp
View File

@@ -18,8 +18,9 @@ class ZesSysmanFirmwareFixture : public SysmanDeviceFixture {
std::unique_ptr<MockFirmwareInterface> pMockFwInterface;
L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr;
std::unique_ptr<MockFirmwareFsAccess> pFsAccess;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
MockFirmwareSysfsAccess *pMockSysfsAccess = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::SysFsAccessInterface *pSysFsAccessOriginal = nullptr;
std::unique_ptr<MockFirmwareSysfsAccess> pMockSysfsAccess;
L0::Sysman::SysmanDevice *device = nullptr;
void SetUp() override {
@@ -28,9 +29,9 @@ class ZesSysmanFirmwareFixture : public SysmanDeviceFixture {
pFsAccess = std::make_unique<MockFirmwareFsAccess>();
pLinuxSysmanImp->pFsAccess = pFsAccess.get();
pMockSysfsAccess = new MockFirmwareSysfsAccess();
delete pLinuxSysmanImp->pSysfsAccess;
pLinuxSysmanImp->pSysfsAccess = pMockSysfsAccess;
pSysFsAccessOriginal = pLinuxSysmanImp->pSysfsAccess;
pMockSysfsAccess = std::make_unique<MockFirmwareSysfsAccess>();
pLinuxSysmanImp->pSysfsAccess = pMockSysfsAccess.get();
pFwUtilInterfaceOld = pLinuxSysmanImp->pFwUtilInterface;
pMockFwInterface = std::make_unique<MockFirmwareInterface>();
@@ -50,6 +51,7 @@ class ZesSysmanFirmwareFixture : public SysmanDeviceFixture {
void TearDown() override {
pLinuxSysmanImp->pFwUtilInterface = pFwUtilInterfaceOld;
pLinuxSysmanImp->pFsAccess = pFsAccessOriginal;
pLinuxSysmanImp->pSysfsAccess = pSysFsAccessOriginal;
SysmanDeviceFixture::TearDown();
}
@@ -298,7 +300,7 @@ class ZesFirmwareUninitializedFixture : public SysmanDeviceFixture {
std::unique_ptr<MockFirmwareInterface> pMockFwInterface;
L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr;
std::unique_ptr<MockFirmwareFsAccess> pFsAccess;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
void SetUp() override {
SysmanDeviceFixture::SetUp();

3
level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysfs_frequency.h
View File

@@ -10,6 +10,7 @@
#include "shared/test/common/test_macros/mock_method_macros.h"
#include "level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "gtest/gtest.h"
@@ -49,7 +50,7 @@ const std::string throttleReasonPL2FileLegacy("gt_throttle_reason_status_pl2");
const std::string throttleReasonPL4FileLegacy("gt_throttle_reason_status_pl4");
const std::string throttleReasonThermalFileLegacy("gt_throttle_reason_status_thermal");
struct MockFrequencySysfsAccess : public L0::Sysman::SysfsAccess {
struct MockFrequencySysfsAccess : public L0::Sysman::SysFsAccessInterface {
double mockMin = 0;
double mockMax = 0;
double mockBoost = 0;

3
level_zero/sysman/test/unit_tests/sources/frequency/linux/mock_sysfs_frequency_prelim.h
View File

@@ -12,6 +12,7 @@
#include "shared/test/common/test_macros/mock_method_macros.h"
#include "level_zero/sysman/source/api/frequency/linux/sysman_os_frequency_imp_prelim.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "gtest/gtest.h"
#include "igfxfmid.h"
@@ -52,7 +53,7 @@ const std::string throttleReasonPL2FileLegacy("gt_throttle_reason_status_pl2");
const std::string throttleReasonPL4FileLegacy("gt_throttle_reason_status_pl4");
const std::string throttleReasonThermalFileLegacy("gt_throttle_reason_status_thermal");
struct MockFrequencySysfsAccess : public L0::Sysman::SysfsAccess {
struct MockFrequencySysfsAccess : public L0::Sysman::SysFsAccessInterface {
double mockMin = 0;
double mockMax = 0;
double mockBoost = 0;

4
level_zero/sysman/test/unit_tests/sources/frequency/linux/test_zes_frequency.cpp
View File

@@ -31,7 +31,7 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
void SetUp() override {
SysmanDeviceFixture::SetUp();
@@ -874,7 +874,7 @@ class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
void SetUp() override {
SysmanMultiDeviceFixture::SetUp();

4
level_zero/sysman/test/unit_tests/sources/frequency/linux/test_zes_frequency_prelim.cpp
View File

@@ -30,7 +30,7 @@ class SysmanDeviceFrequencyFixture : public SysmanDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
std::unique_ptr<ProductHelper> pProductHelper;
std::unique_ptr<ProductHelper> pProductHelperOld;
uint32_t numClocks = 0;
@@ -927,7 +927,7 @@ class FreqMultiDeviceFixture : public SysmanMultiDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
std::unique_ptr<MockFrequencySysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
std::unique_ptr<ProductHelper> pProductHelper;
void SetUp() override {

8
level_zero/sysman/test/unit_tests/sources/global_operations/linux/mock_global_operations.h
View File

@@ -14,7 +14,7 @@
#include "level_zero/sysman/source/api/global_operations/linux/sysman_os_global_operations_imp.h"
#include "level_zero/sysman/source/api/global_operations/sysman_global_operations_imp.h"
#include "level_zero/sysman/source/shared/firmware_util/sysman_firmware_util.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_hw_device_id.h"
namespace L0 {
@@ -91,7 +91,7 @@ struct MockGlobalOperationsFirmwareHandleContext : public L0::Sysman::FirmwareHa
ADDMETHOD_NOBASE_VOIDRETURN(init, ());
};
struct MockGlobalOperationsSysfsAccess : public L0::Sysman::SysfsAccess {
struct MockGlobalOperationsSysfsAccess : public L0::Sysman::SysFsAccessInterface {
ze_result_t mockScanDirEntriesError = ZE_RESULT_SUCCESS;
ze_result_t mockReadError = ZE_RESULT_SUCCESS;
@@ -363,7 +363,7 @@ struct MockGlobalOperationsSysfsAccess : public L0::Sysman::SysfsAccess {
ADDMETHOD_NOBASE(fileExists, bool, true, (const std::string file));
};
struct MockGlobalOperationsProcfsAccess : public L0::Sysman::ProcfsAccess {
struct MockGlobalOperationsProcfsAccess : public L0::Sysman::ProcFsAccessInterface {
const ::pid_t extraPid = 4;
const int extraFd = 5;
@@ -466,7 +466,7 @@ struct MockGlobalOperationsProcfsAccess : public L0::Sysman::ProcfsAccess {
MockGlobalOperationsProcfsAccess() = default;
};
struct MockGlobalOperationsFsAccess : public L0::Sysman::FsAccess {
struct MockGlobalOperationsFsAccess : public L0::Sysman::FsAccessInterface {
ze_result_t mockReadError = ZE_RESULT_SUCCESS;
ze_result_t readResult = ZE_RESULT_ERROR_NOT_AVAILABLE;
std::string mockReadVal = "";

6
level_zero/sysman/test/unit_tests/sources/global_operations/linux/test_zes_global_operations.cpp
View File

@@ -58,9 +58,9 @@ class SysmanGlobalOperationsFixture : public SysmanDeviceFixture {
L0::Sysman::DiagnosticsHandleContext *pDiagnosticsHandleContextOld = nullptr;
L0::Sysman::FirmwareHandleContext *pFirmwareHandleContextOld = nullptr;
L0::Sysman::RasHandleContext *pRasHandleContextOld = nullptr;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::ProcfsAccess *pProcfsAccessOld = nullptr;
L0::Sysman::FsAccess *pFsAccessOld = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
L0::Sysman::ProcFsAccessInterface *pProcfsAccessOld = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOld = nullptr;
L0::Sysman::LinuxSysmanImp *pLinuxSysmanImpOld = nullptr;
L0::Sysman::OsGlobalOperations *pOsGlobalOperationsPrev = nullptr;
L0::Sysman::GlobalOperations *pGlobalOperationsPrev = nullptr;

6
level_zero/sysman/test/unit_tests/sources/global_operations/linux/test_zes_global_operations_prelim.cpp
View File

@@ -19,9 +19,9 @@ class SysmanGlobalOperationsHelperFixture : public SysmanDeviceFixture {
std::unique_ptr<MockGlobalOperationsFsAccess> pFsAccess;
std::unique_ptr<MockGlobalOpsFwInterface> pMockFwInterface;
L0::Sysman::FirmwareUtil *pFwUtilInterfaceOld = nullptr;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::ProcfsAccess *pProcfsAccessOld = nullptr;
L0::Sysman::FsAccess *pFsAccessOld = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
L0::Sysman::ProcFsAccessInterface *pProcfsAccessOld = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOld = nullptr;
L0::Sysman::OsGlobalOperations *pOsGlobalOperationsPrev = nullptr;
L0::Sysman::GlobalOperations *pGlobalOperationsPrev = nullptr;
L0::Sysman::GlobalOperationsImp *pGlobalOperationsImp;

13
level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h
View File

@@ -20,7 +20,7 @@
#include "level_zero/sysman/source/device/sysman_device.h"
#include "level_zero/sysman/source/driver/sysman_driver.h"
#include "level_zero/sysman/source/driver/sysman_driver_handle_imp.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/shared/linux/zes_os_sysman_driver_imp.h"
#include "level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h"
#include "level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h"
@@ -148,16 +148,9 @@ class SysmanMultiDeviceFixture : public ::testing::Test {
DebugManagerStateRestore restorer;
};
class PublicFsAccess : public L0::Sysman::FsAccess {
public:
using FsAccess::accessSyscall;
using FsAccess::statSyscall;
};
class PublicFsAccess : public L0::Sysman::FsAccessInterface {};
class PublicSysfsAccess : public L0::Sysman::SysfsAccess {
public:
using SysfsAccess::accessSyscall;
};
class PublicSysfsAccess : public L0::Sysman::SysFsAccessInterface {};
class PublicLinuxSysmanDriverImp : public L0::Sysman::LinuxSysmanDriverImp {
public:

4
level_zero/sysman/test/unit_tests/sources/linux/pmt/mock_pmt.h
View File

@@ -30,7 +30,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";
struct MockPmtFsAccess : public L0::Sysman::FsAccess {
struct MockPmtFsAccess : public L0::Sysman::FsAccessInterface {
ze_result_t listDirectoryResult = ZE_RESULT_SUCCESS;
ze_result_t getRealPathResult = ZE_RESULT_SUCCESS;
@@ -145,7 +145,7 @@ struct MockPmtFsAccess : public L0::Sysman::FsAccess {
class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech {
public:
PublicPlatformMonitoringTech(L0::Sysman::FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
PublicPlatformMonitoringTech(L0::Sysman::FsAccessInterface *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
using PlatformMonitoringTech::doInitPmtObject;
using PlatformMonitoringTech::init;
using PlatformMonitoringTech::keyOffsetMap;

105
level_zero/sysman/test/unit_tests/sources/linux/test_sysman.cpp
View File

@@ -29,25 +29,17 @@ struct dirent mockEntries[] = {
{0, 0, 0, 0, "mockDir2"},
};
inline static int mockAccessFailure(const char *pathname, int mode) {
inline static int mockStatFailure(const std::string &filePath, struct stat *statbuf) noexcept {
return -1;
}
inline static int mockAccessSuccess(const char *pathname, int mode) {
inline static int mockStatSuccess(const std::string &filePath, struct stat *statbuf) noexcept {
statbuf->st_mode = S_IWUSR | S_IRUSR;
return 0;
}
inline static int mockStatFailure(const char *pathname, struct stat *sb) noexcept {
return -1;
}
inline static int mockStatSuccess(const char *pathname, struct stat *sb) noexcept {
sb->st_mode = S_IWUSR | S_IRUSR;
return 0;
}
inline static int mockStatNoPermissions(const char *pathname, struct stat *sb) noexcept {
sb->st_mode = 0;
inline static int mockStatNoPermissions(const std::string &filePath, struct stat *statbuf) noexcept {
statbuf->st_mode = 0;
return 0;
}
@@ -79,23 +71,13 @@ TEST_F(SysmanDeviceFixture, GivenValidSysmanKmdInterfaceWhenCallingListDirectori
EXPECT_EQ(ZE_RESULT_SUCCESS, pFsAccess->listDirectory("MockDir", listFiles));
}
TEST_F(SysmanDeviceFixture, GivenCreateFsAccessHandleWhenCallinggetFsAccessThenCreatedFsAccessHandleWillBeRetrieved) {
if (pLinuxSysmanImp->pFsAccess != nullptr) {
// delete previously allocated pFsAccess
delete pLinuxSysmanImp->pFsAccess;
pLinuxSysmanImp->pFsAccess = nullptr;
}
pLinuxSysmanImp->pFsAccess = L0::Sysman::FsAccess::create();
EXPECT_EQ(&pLinuxSysmanImp->getFsAccess(), pLinuxSysmanImp->pFsAccess);
}
TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingDirectoryExistsWithValidAndInvalidPathThenSuccessAndFailureAreReturnedRespectively) {
PublicFsAccess *tempFsAccess = new PublicFsAccess();
tempFsAccess->accessSyscall = mockAccessSuccess;
NEO::SysCalls::allowFakeDevicePath = true;
char cwd[PATH_MAX];
std::string path = getcwd(cwd, PATH_MAX);
EXPECT_TRUE(tempFsAccess->directoryExists(path));
tempFsAccess->accessSyscall = mockAccessFailure;
NEO::SysCalls::allowFakeDevicePath = false;
path = "invalidDiretory";
EXPECT_FALSE(tempFsAccess->directoryExists(path));
delete tempFsAccess;
@@ -103,7 +85,6 @@ TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingDirectoryExistsWi
TEST_F(SysmanDeviceFixture, GivenPublicSysfsAccessClassWhenCallingDirectoryExistsWithInvalidPathThenFalseIsRetured) {
PublicFsAccess *tempSysfsAccess = new PublicFsAccess();
tempSysfsAccess->accessSyscall = mockAccessFailure;
std::string path = "invalidDiretory";
EXPECT_FALSE(tempSysfsAccess->directoryExists(path));
delete tempSysfsAccess;
@@ -111,7 +92,7 @@ TEST_F(SysmanDeviceFixture, GivenPublicSysfsAccessClassWhenCallingDirectoryExist
TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanWriteWithUserHavingWritePermissionsThenSuccessIsReturned) {
PublicFsAccess *tempFsAccess = new PublicFsAccess();
tempFsAccess->statSyscall = mockStatSuccess;
VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> mockStat(&NEO::SysCalls::sysCallsStat, &mockStatSuccess);
char cwd[PATH_MAX];
std::string path = getcwd(cwd, PATH_MAX);
EXPECT_EQ(ZE_RESULT_SUCCESS, tempFsAccess->canWrite(path));
@@ -120,7 +101,7 @@ TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanWriteWithUserH
TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanReadWithUserHavingReadPermissionsThenSuccessIsReturned) {
PublicFsAccess *tempFsAccess = new PublicFsAccess();
tempFsAccess->statSyscall = mockStatSuccess;
VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> mockStat(&NEO::SysCalls::sysCallsStat, &mockStatSuccess);
char cwd[PATH_MAX];
std::string path = getcwd(cwd, PATH_MAX);
EXPECT_EQ(ZE_RESULT_SUCCESS, tempFsAccess->canRead(path));
@@ -129,7 +110,7 @@ TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanReadWithUserHa
TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanWriteWithUserNotHavingWritePermissionsThenInsufficientIsReturned) {
PublicFsAccess *tempFsAccess = new PublicFsAccess();
tempFsAccess->statSyscall = mockStatNoPermissions;
VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> mockStat(&NEO::SysCalls::sysCallsStat, &mockStatNoPermissions);
char cwd[PATH_MAX];
std::string path = getcwd(cwd, PATH_MAX);
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, tempFsAccess->canWrite(path));
@@ -138,7 +119,7 @@ TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanWriteWithUserN
TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanReadWithUserNotHavingReadPermissionsThenInsufficientIsReturned) {
PublicFsAccess *tempFsAccess = new PublicFsAccess();
tempFsAccess->statSyscall = mockStatNoPermissions;
VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> mockStat(&NEO::SysCalls::sysCallsStat, &mockStatNoPermissions);
char cwd[PATH_MAX];
std::string path = getcwd(cwd, PATH_MAX);
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, tempFsAccess->canRead(path));
@@ -147,7 +128,7 @@ TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanReadWithUserNo
TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanReadWithInvalidPathThenErrorIsReturned) {
PublicFsAccess *tempFsAccess = new PublicFsAccess();
tempFsAccess->statSyscall = mockStatFailure;
VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> mockStat(&NEO::SysCalls::sysCallsStat, &mockStatFailure);
std::string path = "invalidPath";
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, tempFsAccess->canRead(path));
delete tempFsAccess;
@@ -155,7 +136,7 @@ TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanReadWithInvali
TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanWriteWithInvalidPathThenErrorIsReturned) {
PublicFsAccess *tempFsAccess = new PublicFsAccess();
tempFsAccess->statSyscall = mockStatFailure;
VariableBackup<decltype(NEO::SysCalls::sysCallsStat)> mockStat(&NEO::SysCalls::sysCallsStat, &mockStatFailure);
std::string path = "invalidPath";
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, tempFsAccess->canRead(path));
delete tempFsAccess;
@@ -163,38 +144,18 @@ TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanWriteWithInval
TEST_F(SysmanDeviceFixture, GivenValidPathnameWhenCallingFsAccessExistsThenSuccessIsReturned) {
VariableBackup<bool> allowFakeDevicePathBackup(&SysCalls::allowFakeDevicePath, true);
auto fsAccess = pLinuxSysmanImp->getFsAccess();
auto fsAccess = &pLinuxSysmanImp->getFsAccess();
char cwd[PATH_MAX];
std::string path = getcwd(cwd, PATH_MAX);
EXPECT_TRUE(fsAccess.fileExists(path));
EXPECT_TRUE(fsAccess->fileExists(path));
}
TEST_F(SysmanDeviceFixture, GivenInvalidPathnameWhenCallingFsAccessExistsThenErrorIsReturned) {
auto fsAccess = pLinuxSysmanImp->getFsAccess();
auto fsAccess = &pLinuxSysmanImp->getFsAccess();
std::string path = "noSuchFileOrDirectory";
EXPECT_FALSE(fsAccess.fileExists(path));
}
TEST_F(SysmanDeviceFixture, GivenCreateSysfsAccessHandleWhenCallinggetSysfsAccessThenCreatedSysfsAccessHandleHandleWillBeRetrieved) {
if (pLinuxSysmanImp->pSysfsAccess != nullptr) {
// delete previously allocated pSysfsAccess
delete pLinuxSysmanImp->pSysfsAccess;
pLinuxSysmanImp->pSysfsAccess = nullptr;
}
pLinuxSysmanImp->pSysfsAccess = L0::Sysman::SysfsAccess::create("");
EXPECT_EQ(&pLinuxSysmanImp->getSysfsAccess(), pLinuxSysmanImp->pSysfsAccess);
}
TEST_F(SysmanDeviceFixture, GivenCreateProcfsAccessHandleWhenCallinggetProcfsAccessThenCreatedProcfsAccessHandleWillBeRetrieved) {
if (pLinuxSysmanImp->pProcfsAccess != nullptr) {
// delete previously allocated pProcfsAccess
delete pLinuxSysmanImp->pProcfsAccess;
pLinuxSysmanImp->pProcfsAccess = nullptr;
}
pLinuxSysmanImp->pProcfsAccess = L0::Sysman::ProcfsAccess::create();
EXPECT_EQ(&pLinuxSysmanImp->getProcfsAccess(), pLinuxSysmanImp->pProcfsAccess);
EXPECT_FALSE(fsAccess->fileExists(path));
}
TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndIntegerWhenCallingReadOnMultipleFilesThenSuccessIsReturned) {
@@ -212,7 +173,7 @@ TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndIntegerWhenCallingReadOnMult
PublicSysfsAccess *tempSysfsAccess = new PublicSysfsAccess();
std::string fileName = {};
int iVal32;
for (auto i = 0; i < L0::Sysman::FdCache::maxSize + 2; i++) {
for (auto i = 0; i < L0::Sysman::FdCacheInterface::maxSize + 2; i++) {
fileName = "mockfile" + std::to_string(i) + ".txt";
EXPECT_EQ(ZE_RESULT_SUCCESS, tempSysfsAccess->read(fileName, iVal32));
}
@@ -221,9 +182,9 @@ TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndIntegerWhenCallingReadOnMult
TEST(FdCacheTest, GivenValidFdCacheWhenCallingGetFdOnSameFileThenVerifyCacheIsUpdatedProperly) {
class MockFdCache : public FdCache {
class MockFdCache : public FdCacheInterface {
public:
using FdCache::fdMap;
using FdCacheInterface::fdMap;
};
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
@@ -232,7 +193,7 @@ TEST(FdCacheTest, GivenValidFdCacheWhenCallingGetFdOnSameFileThenVerifyCacheIsUp
std::unique_ptr<MockFdCache> pFdCache = std::make_unique<MockFdCache>();
std::string fileName = {};
for (auto i = 0; i < L0::Sysman::FdCache::maxSize; i++) {
for (auto i = 0; i < L0::Sysman::FdCacheInterface::maxSize; i++) {
fileName = "mockfile" + std::to_string(i) + ".txt";
EXPECT_LE(0, pFdCache->getFd(fileName));
}
@@ -242,7 +203,7 @@ TEST(FdCacheTest, GivenValidFdCacheWhenCallingGetFdOnSameFileThenVerifyCacheIsUp
EXPECT_LE(0, pFdCache->getFd(fileName));
}
for (auto i = 1; i < L0::Sysman::FdCache::maxSize - 1; i++) {
for (auto i = 1; i < L0::Sysman::FdCacheInterface::maxSize - 1; i++) {
fileName = "mockfile" + std::to_string(i) + ".txt";
EXPECT_LE(0, pFdCache->getFd(fileName));
}
@@ -259,9 +220,9 @@ TEST(FdCacheTest, GivenValidFdCacheWhenCallingGetFdOnSameFileThenVerifyCacheIsUp
TEST(FdCacheTest, GivenValidFdCacheWhenClearingCacheThenVerifyProperFdsAreClosedAndCacheIsUpdatedProperly) {
class MockFdCache : public FdCache {
class MockFdCache : public FdCacheInterface {
public:
using FdCache::fdMap;
using FdCacheInterface::fdMap;
};
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
@@ -275,7 +236,7 @@ TEST(FdCacheTest, GivenValidFdCacheWhenClearingCacheThenVerifyProperFdsAreClosed
MockFdCache *pFdCache = new MockFdCache();
std::string fileName = {};
for (auto i = 0; i < L0::Sysman::FdCache::maxSize; i++) {
for (auto i = 0; i < L0::Sysman::FdCacheInterface::maxSize; i++) {
fileName = "mockfile" + std::to_string(i) + ".txt";
EXPECT_LE(0, pFdCache->getFd(fileName));
}
@@ -285,7 +246,7 @@ TEST(FdCacheTest, GivenValidFdCacheWhenClearingCacheThenVerifyProperFdsAreClosed
EXPECT_LE(0, pFdCache->getFd(fileName));
}
for (auto i = 1; i < L0::Sysman::FdCache::maxSize - 1; i++) {
for (auto i = 1; i < L0::Sysman::FdCacheInterface::maxSize - 1; i++) {
fileName = "mockfile" + std::to_string(i) + ".txt";
EXPECT_LE(0, pFdCache->getFd(fileName));
}
@@ -325,15 +286,15 @@ TEST_F(SysmanDeviceFixture, GivenSysfsAccessClassAndOpenSysCallFailsWhenCallingR
TEST_F(SysmanDeviceFixture, GivenValidPidWhenCallingProcfsAccessIsAliveThenSuccessIsReturned) {
VariableBackup<bool> allowFakeDevicePathBackup(&SysCalls::allowFakeDevicePath, true);
auto procfsAccess = pLinuxSysmanImp->getProcfsAccess();
auto procfsAccess = &pLinuxSysmanImp->getProcfsAccess();
EXPECT_TRUE(procfsAccess.isAlive(getpid()));
EXPECT_TRUE(procfsAccess->isAlive(getpid()));
}
TEST_F(SysmanDeviceFixture, GivenInvalidPidWhenCallingProcfsAccessIsAliveThenErrorIsReturned) {
auto procfsAccess = pLinuxSysmanImp->getProcfsAccess();
auto procfsAccess = &pLinuxSysmanImp->getProcfsAccess();
EXPECT_FALSE(procfsAccess.isAlive(reinterpret_cast<::pid_t>(-1)));
EXPECT_FALSE(procfsAccess->isAlive(reinterpret_cast<::pid_t>(-1)));
}
TEST_F(SysmanDeviceFixture, GivenValidPciPathWhileGettingCardBusPortThenReturnedPathIs1LevelUpThenTheCurrentPath) {
@@ -350,11 +311,11 @@ TEST_F(SysmanDeviceFixture, GivenValidPciPathWhileGettingCardBusPortThenReturned
TEST_F(SysmanMultiDeviceFixture, GivenValidEffectiveUserIdCheckWhetherPermissionsReturnedByIsRootUserAreCorrect) {
int euid = geteuid();
auto pFsAccess = pLinuxSysmanImp->getFsAccess();
auto pFsAccess = &pLinuxSysmanImp->getFsAccess();
if (euid == 0) {
EXPECT_EQ(true, pFsAccess.isRootUser());
EXPECT_EQ(true, pFsAccess->isRootUser());
} else {
EXPECT_EQ(false, pFsAccess.isRootUser());
EXPECT_EQ(false, pFsAccess->isRootUser());
}
}

6
level_zero/sysman/test/unit_tests/sources/memory/linux/mock_memory_prelim.h
View File

@@ -102,7 +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";
struct MockMemorySysfsAccess : public L0::Sysman::SysfsAccess {
struct MockMemorySysfsAccess : public L0::Sysman::SysFsAccessInterface {
std::vector<ze_result_t> mockReadReturnStatus{};
std::vector<std::string> mockReadStringValue{};
@@ -263,7 +263,7 @@ struct MockMemoryPmt : public L0::Sysman::PlatformMonitoringTech {
this->guid = guid;
}
MockMemoryPmt(L0::Sysman::FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
MockMemoryPmt(L0::Sysman::FsAccessInterface *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
ze_result_t readValue(const std::string key, uint32_t &val) override {
ze_result_t result = ZE_RESULT_SUCCESS;
@@ -438,7 +438,7 @@ struct MockMemoryPmt : public L0::Sysman::PlatformMonitoringTech {
}
};
struct MockMemoryFsAccess : public L0::Sysman::FsAccess {
struct MockMemoryFsAccess : public L0::Sysman::FsAccessInterface {
ze_result_t listDirectory(const std::string directory, std::vector<std::string> &listOfTelemNodes) override {
if (directory.compare(baseTelemSysFS) == 0) {
listOfTelemNodes.push_back("telem1");

6
level_zero/sysman/test/unit_tests/sources/memory/linux/test_sysman_memory_prelim.cpp
View File

@@ -44,8 +44,8 @@ class SysmanDeviceMemoryFixture : public SysmanDeviceFixture {
protected:
std::unique_ptr<MockMemorySysfsAccess> pSysfsAccess;
std::unique_ptr<MockMemoryFsAccess> pFsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
MockMemoryNeoDrm *pDrm = nullptr;
Drm *pOriginalDrm = nullptr;
L0::Sysman::SysmanDevice *device = nullptr;
@@ -807,7 +807,7 @@ TEST_F(SysmanMultiDeviceFixture, GivenValidDevicePointerWhenGettingMemoryPropert
class SysmanMultiDeviceMemoryFixture : public SysmanMultiDeviceFixture {
protected:
std::unique_ptr<MockMemorySysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
MockMemoryNeoDrm *pDrm = nullptr;
Drm *pOriginalDrm = nullptr;
L0::Sysman::SysmanDevice *device = nullptr;

4
level_zero/sysman/test/unit_tests/sources/pci/linux/mock_sysfs_pci.h
View File

@@ -9,7 +9,7 @@
#include "level_zero/sysman/source/api/pci/linux/sysman_os_pci_imp.h"
#include "level_zero/sysman/source/api/pci/sysman_pci_imp.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/sysman_const.h"
namespace L0 {
@@ -41,7 +41,7 @@ const std::vector<std::string> mockReadBytes =
"0x0000000000000000 0x0000000000000000 0x0000000000000000",
};
struct MockPciSysfsAccess : public L0::Sysman::SysfsAccess {
struct MockPciSysfsAccess : public L0::Sysman::SysFsAccessInterface {
bool isStringSymLinkEmpty = false;

4
level_zero/sysman/test/unit_tests/sources/pci/linux/test_zes_pci.cpp
View File

@@ -206,8 +206,8 @@ class ZesPciFixture : public SysmanDeviceFixture {
protected:
std::unique_ptr<MockPciSysfsAccess> pSysfsAccess;
L0::Sysman::SysmanDevice *device = nullptr;
L0::Sysman::SysfsAccess *pOriginalSysfsAccess = nullptr;
L0::Sysman::FsAccess *pOriginalFsAccess = nullptr;
L0::Sysman::SysFsAccessInterface *pOriginalSysfsAccess = nullptr;
L0::Sysman::FsAccessInterface *pOriginalFsAccess = nullptr;
L0::Sysman::PciImp *pPciImp;
L0::Sysman::OsPci *pOsPciPrev;
std::unique_ptr<L0::ult::Mock<L0::DriverHandleImp>> driverHandle;

6
level_zero/sysman/test/unit_tests/sources/performance/linux/mock_sysfs_performance_prelim.h
View File

@@ -10,7 +10,9 @@
#include "level_zero/sysman/source/api/performance/linux/sysman_os_performance_imp_prelim.h"
#include "level_zero/sysman/source/api/performance/sysman_performance.h"
#include "level_zero/sysman/source/api/performance/sysman_performance_imp.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include <list>
namespace L0 {
namespace Sysman {
@@ -26,7 +28,7 @@ const std::string baseFreqFactorSubDevice1("gt/gt1/base_freq_factor");
const std::string baseScaleSubDevice1("gt/gt1/base_freq_factor.scale");
const std::string pwrBalance("sys_pwr_balance");
struct MockPerformanceSysfsAccess : public L0::Sysman::SysfsAccess {
struct MockPerformanceSysfsAccess : public L0::Sysman::SysFsAccessInterface {
ze_result_t mockReadResult = ZE_RESULT_SUCCESS;
ze_result_t mockCanReadResult = ZE_RESULT_SUCCESS;
ze_bool_t isComputeInvalid = false;

2
level_zero/sysman/test/unit_tests/sources/performance/linux/test_zes_performance_prelim.cpp
View File

@@ -23,7 +23,7 @@ constexpr double minPerformanceFactor = 0;
class ZesPerformanceFixture : public SysmanMultiDeviceFixture {
protected:
std::unique_ptr<MockPerformanceSysfsAccess> ptestSysfsAccess;
L0::Sysman::SysfsAccess *pOriginalSysfsAccess = nullptr;
L0::Sysman::SysFsAccessInterface *pOriginalSysfsAccess = nullptr;
L0::Sysman::SysmanDevice *device = nullptr;
void SetUp() override {
SysmanMultiDeviceFixture::SetUp();

16
level_zero/sysman/test/unit_tests/sources/power/linux/mock_sysfs_power.h
View File

@@ -50,7 +50,7 @@ const std::map<std::string, uint64_t> deviceKeyOffsetMapPower = {
{"SOC_TEMPERATURES", 0x60},
{"CORE_TEMPERATURES", 0x6c}};
struct MockPowerSysfsAccess : public L0::Sysman::SysfsAccess {
struct MockPowerSysfsAccess : public L0::Sysman::SysFsAccessInterface {
std::vector<ze_result_t> mockReadReturnStatus{};
std::vector<ze_result_t> mockWriteReturnStatus{};
@@ -525,12 +525,12 @@ struct MockPowerPmt : public L0::Sysman::PlatformMonitoringTech {
using L0::Sysman::PlatformMonitoringTech::preadFunction;
using L0::Sysman::PlatformMonitoringTech::telemetryDeviceEntry;
MockPowerPmt(L0::Sysman::FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
MockPowerPmt(L0::Sysman::FsAccessInterface *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
~MockPowerPmt() override {
rootDeviceTelemNodeIndex = 0;
}
void mockedInit(L0::Sysman::FsAccess *pFsAccess) {
void mockedInit(L0::Sysman::FsAccessInterface *pFsAccess) {
std::string gpuUpstreamPortPath = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0";
if (ZE_RESULT_SUCCESS != L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pFsAccess, gpuUpstreamPortPath)) {
return;
@@ -539,7 +539,7 @@ struct MockPowerPmt : public L0::Sysman::PlatformMonitoringTech {
}
};
struct MockPowerFsAccess : public L0::Sysman::FsAccess {
struct MockPowerFsAccess : public L0::Sysman::FsAccessInterface {
ze_result_t listDirectory(const std::string directory, std::vector<std::string> &listOfTelemNodes) override {
if (directory.compare(baseTelemSysFS) == 0) {
@@ -595,8 +595,8 @@ class SysmanDevicePowerFixtureI915 : public SysmanDeviceFixture {
std::unique_ptr<MockPowerPmt> pPmt;
std::unique_ptr<MockPowerFsAccess> pFsAccess;
std::unique_ptr<MockPowerSysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::OsPower *pOsPowerOriginal = nullptr;
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> pmtMapOriginal;
@@ -660,8 +660,8 @@ class SysmanDevicePowerMultiDeviceFixture : public SysmanMultiDeviceFixture {
std::unique_ptr<MockPowerPmt> pPmt;
std::unique_ptr<MockPowerFsAccess> pFsAccess;
std::unique_ptr<MockPowerSysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::OsPower *pOsPowerOriginal = nullptr;
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> mapOriginal;
void SetUp() override {

16
level_zero/sysman/test/unit_tests/sources/power/linux/mock_sysfs_power_prelim.h
View File

@@ -49,7 +49,7 @@ const std::map<std::string, uint64_t> deviceKeyOffsetMapPower = {
{"SOC_TEMPERATURES", 0x60},
{"CORE_TEMPERATURES", 0x6c}};
struct MockPowerSysfsAccess : public L0::Sysman::SysfsAccess {
struct MockPowerSysfsAccess : public L0::Sysman::SysFsAccessInterface {
ze_result_t mockReadResult = ZE_RESULT_SUCCESS;
ze_result_t mockReadPeakResult = ZE_RESULT_SUCCESS;
ze_result_t mockWriteResult = ZE_RESULT_SUCCESS;
@@ -236,7 +236,7 @@ struct MockPowerSysfsAccess : public L0::Sysman::SysfsAccess {
struct MockPowerPmt : public L0::Sysman::PlatformMonitoringTech {
MockPowerPmt(L0::Sysman::FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
MockPowerPmt(L0::Sysman::FsAccessInterface *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
using L0::Sysman::PlatformMonitoringTech::keyOffsetMap;
using L0::Sysman::PlatformMonitoringTech::preadFunction;
using L0::Sysman::PlatformMonitoringTech::telemetryDeviceEntry;
@@ -244,7 +244,7 @@ struct MockPowerPmt : public L0::Sysman::PlatformMonitoringTech {
rootDeviceTelemNodeIndex = 0;
}
void mockedInit(L0::Sysman::FsAccess *pFsAccess) {
void mockedInit(L0::Sysman::FsAccessInterface *pFsAccess) {
std::string gpuUpstreamPortPath = "/sys/devices/pci0000:89/0000:89:02.0/0000:8a:00.0";
if (ZE_RESULT_SUCCESS != L0::Sysman::PlatformMonitoringTech::enumerateRootTelemIndex(pFsAccess, gpuUpstreamPortPath)) {
return;
@@ -254,7 +254,7 @@ struct MockPowerPmt : public L0::Sysman::PlatformMonitoringTech {
}
};
struct MockPowerFsAccess : public L0::Sysman::FsAccess {
struct MockPowerFsAccess : public L0::Sysman::FsAccessInterface {
ze_result_t listDirectory(const std::string directory, std::vector<std::string> &listOfTelemNodes) override {
if (directory.compare(baseTelemSysFS) == 0) {
@@ -304,8 +304,8 @@ class SysmanDevicePowerFixture : public SysmanDeviceFixture {
std::unique_ptr<MockPowerPmt> pPmt;
std::unique_ptr<MockPowerFsAccess> pFsAccess;
std::unique_ptr<MockPowerSysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::OsPower *pOsPowerOriginal = nullptr;
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> pmtMapOriginal;
void SetUp() override {
@@ -354,8 +354,8 @@ class SysmanDevicePowerMultiDeviceFixture : public SysmanMultiDeviceFixture {
std::unique_ptr<MockPowerPmt> pPmt;
std::unique_ptr<MockPowerFsAccess> pFsAccess;
std::unique_ptr<MockPowerSysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::OsPower *pOsPowerOriginal = nullptr;
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> mapOriginal;
void SetUp() override {

6
level_zero/sysman/test/unit_tests/sources/ras/linux/mock_sysman_ras.h
View File

@@ -14,7 +14,7 @@
#include "level_zero/sysman/source/api/ras/sysman_ras.h"
#include "level_zero/sysman/source/api/ras/sysman_ras_imp.h"
#include "level_zero/sysman/source/shared/linux/pmu/sysman_pmu_imp.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/source/shared/linux/zes_os_sysman_imp.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_hw_device_id.h"
@@ -264,7 +264,7 @@ struct MockRasPmuInterfaceImp : public L0::Sysman::PmuInterfaceImp {
}
};
struct MockRasSysfsAccess : public L0::Sysman::SysfsAccess {
struct MockRasSysfsAccess : public L0::Sysman::SysFsAccessInterface {
ze_result_t mockReadSymLinkStatus = ZE_RESULT_SUCCESS;
bool mockReadSymLinkResult = false;
@@ -461,7 +461,7 @@ struct MockRasSysfsAccess : public L0::Sysman::SysfsAccess {
}
};
struct MockRasFsAccess : public L0::Sysman::FsAccess {
struct MockRasFsAccess : public L0::Sysman::FsAccessInterface {
ze_result_t mockListDirectoryStatus = ZE_RESULT_SUCCESS;
bool mockReadDirectoryFailure = false;

8
level_zero/sysman/test/unit_tests/sources/ras/linux/test_zes_ras.cpp
View File

@@ -26,8 +26,8 @@ struct SysmanRasFixture : public SysmanDeviceFixture {
std::unique_ptr<MockRasPmuInterfaceImp> pPmuInterface;
std::unique_ptr<MockRasFwInterface> pRasFwUtilInterface;
MockRasNeoDrm *pDrm = nullptr;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
L0::Sysman::SysfsAccess *pSysfsAccessOriginal = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOriginal = nullptr;
L0::Sysman::PmuInterface *pOriginalPmuInterface = nullptr;
L0::Sysman::FirmwareUtil *pFwUtilOriginal = nullptr;
L0::Sysman::SysmanDevice *device = nullptr;
@@ -537,8 +537,8 @@ struct SysmanRasMultiDeviceFixture : public SysmanMultiDeviceFixture {
std::unique_ptr<MockRasPmuInterfaceImp> pPmuInterface;
std::unique_ptr<MockRasFwInterface> pRasFwUtilInterface;
MockRasNeoDrm *pDrm = nullptr;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
L0::Sysman::SysfsAccess *pSysfsAccessOriginal = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOriginal = nullptr;
L0::Sysman::PmuInterface *pOriginalPmuInterface = nullptr;
L0::Sysman::FirmwareUtil *pFwUtilOriginal = nullptr;
Drm *pOriginalDrm = nullptr;

4
level_zero/sysman/test/unit_tests/sources/scheduler/linux/mock_sysfs_scheduler.h
View File

@@ -10,7 +10,7 @@
#include "shared/source/os_interface/linux/engine_info.h"
#include "level_zero/sysman/source/api/scheduler/linux/sysman_os_scheduler_imp.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_hw_device_id.h"
#include "drm/xe_drm.h"
@@ -47,7 +47,7 @@ class SchedulerFileProperties {
}
};
struct MockSchedulerSysfsAccess : public L0::Sysman::SysfsAccess {
struct MockSchedulerSysfsAccess : public L0::Sysman::SysFsAccessInterface {
std::string preemptTimeout{};
std::string defaultpreemptTimeout{};

8
level_zero/sysman/test/unit_tests/sources/scheduler/linux/mock_sysfs_scheduler_prelim.h
View File

@@ -12,7 +12,7 @@
#include "shared/source/os_interface/linux/ioctl_helper.h"
#include "level_zero/sysman/source/api/scheduler/linux/sysman_os_scheduler_imp.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
#include "level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_hw_device_id.h"
namespace L0 {
@@ -180,7 +180,7 @@ class SchedulerFileProperties {
}
};
class MockSchedulerProcfsAccess : public L0::Sysman::ProcfsAccess {
class MockSchedulerProcfsAccess : public L0::Sysman::ProcFsAccessInterface {
public:
MockSchedulerProcfsAccess() = default;
@@ -266,8 +266,8 @@ class CalledTimesUpdate {
int &calledTimesVar;
};
struct MockSchedulerSysfsAccess : public L0::Sysman::SysfsAccess {
using SysfsAccess::deviceNames;
struct MockSchedulerSysfsAccess : public L0::Sysman::SysFsAccessInterface {
using SysFsAccessInterface::deviceNames;
ze_result_t mockReadFileFailureError = ZE_RESULT_SUCCESS;
ze_result_t mockGetScanDirEntryError = ZE_RESULT_SUCCESS;

4
level_zero/sysman/test/unit_tests/sources/scheduler/linux/test_zes_scheduler.cpp
View File

@@ -56,7 +56,7 @@ class SysmanDeviceSchedulerFixtureI915 : public SysmanDeviceSchedulerFixture {
protected:
std::unique_ptr<MockSchedulerSysfsAccessI915> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
uint64_t defaultTimeout = 650u;
uint64_t defaultTimeslice = 1u;
@@ -639,7 +639,7 @@ class SysmanDeviceSchedulerFixtureXe : public SysmanDeviceSchedulerFixture {
protected:
std::unique_ptr<MockSchedulerSysfsAccessXe> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
uint64_t defaultTimeout = 650u;
uint64_t defaultTimeslice = 1u;

20
level_zero/sysman/test/unit_tests/sources/scheduler/linux/test_zes_scheduler_prelim.cpp
View File

@@ -35,7 +35,7 @@ class SysmanDeviceSchedulerFixture : public SysmanDeviceFixture {
protected:
std::unique_ptr<MockSchedulerSysfsAccess> pSysfsAccess;
L0::Sysman::SysfsAccess *pSysfsAccessOld = nullptr;
L0::Sysman::SysFsAccessInterface *pSysfsAccessOld = nullptr;
PublicLinuxSchedulerImp *pLinuxSchedulerImp = nullptr;
L0::Sysman::SysmanDevice *device = nullptr;
@@ -359,7 +359,7 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul
}
TEST_F(SysmanDeviceSchedulerFixture, GivenCurrentModeIsDebugModeWhenCallingzesSchedulerSetTimeoutModeThenVerifyCallSucceeds) {
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pLinuxSysmanImp->pProcfsAccess);
auto pMockSchedulerProcfsAccess = new MockSchedulerProcfsAccess;
pLinuxSysmanImp->pProcfsAccess = pMockSchedulerProcfsAccess;
@@ -383,7 +383,7 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenCurrentModeIsDebugModeWhenCallingzesSc
}
TEST_F(SysmanDeviceSchedulerFixture, GivenCurrentModeIsDebugModeWhenSettingTimeoutModeAndDebugModeCantBeChangedThenVerifyCallFails) {
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pLinuxSysmanImp->pProcfsAccess);
auto pMockSchedulerProcfsAccess = new MockSchedulerProcfsAccess;
pLinuxSysmanImp->pProcfsAccess = pMockSchedulerProcfsAccess;
pMockSchedulerProcfsAccess->listProcessesResult = ZE_RESULT_ERROR_NOT_AVAILABLE; // Expect failure when calling gpuProcessCleanup()
@@ -514,7 +514,7 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul
}
TEST_F(SysmanDeviceSchedulerFixture, GivenCurrentModeIsDebugModeWhenCallingzesSchedulerSetTimesliceModeThenVerifyCallSucceeds) {
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pLinuxSysmanImp->pProcfsAccess);
auto pMockSchedulerProcfsAccess = new MockSchedulerProcfsAccess;
pLinuxSysmanImp->pProcfsAccess = pMockSchedulerProcfsAccess;
@@ -540,7 +540,7 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenCurrentModeIsDebugModeWhenCallingzesSc
}
TEST_F(SysmanDeviceSchedulerFixture, GivenCurrentModeIsDebugModeWhenSettingTimesliceModeAndDebugModeCantBeChangedThenVerifyCallFails) {
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pLinuxSysmanImp->pProcfsAccess);
auto pMockSchedulerProcfsAccess = new MockSchedulerProcfsAccess;
pLinuxSysmanImp->pProcfsAccess = pMockSchedulerProcfsAccess;
pMockSchedulerProcfsAccess->listProcessesResult = ZE_RESULT_ERROR_NOT_AVAILABLE; // Expect failure when calling gpuProcessCleanup()
@@ -653,7 +653,7 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul
}
TEST_F(SysmanDeviceSchedulerFixture, GivenCurrentModeIsDebugModeWhenCallingzesSchedulerSetExclusiveModeThenVerifyCallSucceeds) {
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pLinuxSysmanImp->pProcfsAccess);
auto pMockSchedulerProcfsAccess = new MockSchedulerProcfsAccess;
pLinuxSysmanImp->pProcfsAccess = pMockSchedulerProcfsAccess;
@@ -672,7 +672,7 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenCurrentModeIsDebugModeWhenCallingzesSc
}
TEST_F(SysmanDeviceSchedulerFixture, GivenCurrentModeIsDebugModeWhenSettingExclusiveModeAndDebugModeCantBeChangedThenVerifyCallFails) {
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pLinuxSysmanImp->pProcfsAccess);
auto pMockSchedulerProcfsAccess = new MockSchedulerProcfsAccess;
pLinuxSysmanImp->pProcfsAccess = pMockSchedulerProcfsAccess;
pMockSchedulerProcfsAccess->listProcessesResult = ZE_RESULT_ERROR_NOT_AVAILABLE; // Expect failure when calling gpuProcessCleanup()
@@ -790,7 +790,7 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul
}
TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetComputeUnitDebugModeThenSuccessIsReturned) {
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pLinuxSysmanImp->pProcfsAccess);
auto pMockSchedulerProcfsAccess = new MockSchedulerProcfsAccess;
pLinuxSysmanImp->pProcfsAccess = pMockSchedulerProcfsAccess;
@@ -811,7 +811,7 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul
}
TEST_F(SysmanDeviceSchedulerFixture, GivenGpuProcessCleanupFailedWhenCallingzesSchedulerSetComputeUnitDebugModeThenErrorIsReturned) {
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pLinuxSysmanImp->pProcfsAccess);
auto pMockSchedulerProcfsAccess = new MockSchedulerProcfsAccess;
pLinuxSysmanImp->pProcfsAccess = pMockSchedulerProcfsAccess;
pMockSchedulerProcfsAccess->listProcessesResult = ZE_RESULT_ERROR_NOT_AVAILABLE; // Expect failure when calling gpuProcessCleanup()
@@ -833,7 +833,7 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenGpuProcessCleanupFailedWhenCallingzesS
}
TEST_F(SysmanDeviceSchedulerFixture, GivenEuDebugNodeWriteFailsWhenCallingzesSchedulerSetComputeUnitDebugModeThenErrorIsReturned) {
VariableBackup<L0::Sysman::ProcfsAccess *> backup(&pLinuxSysmanImp->pProcfsAccess);
VariableBackup<L0::Sysman::ProcFsAccessInterface *> backup(&pLinuxSysmanImp->pProcfsAccess);
auto pMockSchedulerProcfsAccess = new MockSchedulerProcfsAccess;
pLinuxSysmanImp->pProcfsAccess = pMockSchedulerProcfsAccess;

1
level_zero/sysman/test/unit_tests/sources/standby/linux/test_zes_sysman_standby.cpp
View File

@@ -380,7 +380,6 @@ TEST_F(ZesStandbyFixtureXe, GivenKmdInterfaceWhenQueryingSupportForStandbyForXeV
}
class ZesStandbyMultiDeviceFixture : public SysmanMultiDeviceFixture {
protected:
L0::Sysman::SysmanDevice *device = nullptr;
uint32_t subDeviceCount;

8
level_zero/sysman/test/unit_tests/sources/temperature/linux/mock_sysfs_temperature.h
View File

@@ -10,7 +10,7 @@
#include "level_zero/sysman/source/api/temperature/linux/sysman_os_temperature_imp.h"
#include "level_zero/sysman/source/api/temperature/sysman_temperature_imp.h"
#include "level_zero/sysman/source/shared/linux/pmt/sysman_pmt.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access.h"
#include "level_zero/sysman/source/shared/linux/sysman_fs_access_interface.h"
namespace L0 {
namespace Sysman {
@@ -43,7 +43,7 @@ const std::string sysfsPahTelem4 = "/sys/class/intel_pmt/telem4";
const std::string sysfsPahTelem5 = "/sys/class/intel_pmt/telem5";
struct MockTemperaturePmt : public L0::Sysman::PlatformMonitoringTech {
MockTemperaturePmt(L0::Sysman::FsAccess *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
MockTemperaturePmt(L0::Sysman::FsAccessInterface *pFsAccess, ze_bool_t onSubdevice, uint32_t subdeviceId) : L0::Sysman::PlatformMonitoringTech(pFsAccess, onSubdevice, subdeviceId) {}
using L0::Sysman::PlatformMonitoringTech::keyOffsetMap;
using L0::Sysman::PlatformMonitoringTech::preadFunction;
using L0::Sysman::PlatformMonitoringTech::telemetryDeviceEntry;
@@ -56,7 +56,7 @@ struct MockTemperaturePmt : public L0::Sysman::PlatformMonitoringTech {
rootDeviceTelemNodeIndex = 0;
}
void mockedInit(L0::Sysman::FsAccess *pFsAccess) {
void mockedInit(L0::Sysman::FsAccessInterface *pFsAccess) {
if (ZE_RESULT_SUCCESS != PlatformMonitoringTech::enumerateRootTelemIndex(pFsAccess, gpuUpstreamPortPathInTemperature)) {
return;
}
@@ -123,7 +123,7 @@ struct MockTemperaturePmt : public L0::Sysman::PlatformMonitoringTech {
}
};
struct MockTemperatureFsAccess : public L0::Sysman::FsAccess {
struct MockTemperatureFsAccess : public L0::Sysman::FsAccessInterface {
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 {

4
level_zero/sysman/test/unit_tests/sources/temperature/linux/test_zes_temperature.cpp
View File

@@ -25,7 +25,7 @@ class SysmanMultiDeviceTemperatureFixture : public SysmanMultiDeviceFixture {
protected:
std::unique_ptr<PublicLinuxTemperatureImp> pPublicLinuxTemperatureImp;
std::unique_ptr<MockTemperatureFsAccess> pFsAccess;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> mapOriginal;
L0::Sysman::SysmanDevice *device = nullptr;
void SetUp() override {
@@ -160,7 +160,7 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture {
protected:
std::unique_ptr<PublicLinuxTemperatureImp> pPublicLinuxTemperatureImp;
std::unique_ptr<MockTemperatureFsAccess> pFsAccess;
L0::Sysman::FsAccess *pFsAccessOriginal = nullptr;
L0::Sysman::FsAccessInterface *pFsAccessOriginal = nullptr;
std::map<uint32_t, L0::Sysman::PlatformMonitoringTech *> pmtMapOriginal;
L0::Sysman::SysmanDevice *device = nullptr;
void SetUp() override {