From 229ab9e30c54855ec5cfb4db8d45001695251a44 Mon Sep 17 00:00:00 2001 From: Joshua Santosh Ranjan Date: Wed, 14 Jul 2021 17:01:58 +0000 Subject: [PATCH] Add tests for sysman schedulder Adding unit tests for scheduler module Signed-off-by: Joshua Santosh Ranjan --- .../scheduler/linux/mock_sysfs_scheduler.h | 91 +++++- .../scheduler/linux/test_zes_scheduler.cpp | 266 +++++++++++++++--- 2 files changed, 319 insertions(+), 38 deletions(-) diff --git a/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/mock_sysfs_scheduler.h b/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/mock_sysfs_scheduler.h index be3f166027..abf10b1f26 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/mock_sysfs_scheduler.h +++ b/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/mock_sysfs_scheduler.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020 Intel Corporation + * Copyright (C) 2020-2021 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -34,9 +34,27 @@ typedef struct SchedulerConfig { SchedulerConfigValues_t heartBeat; } SchedulerConfig_t; +class SchedulerFileProperties { + bool isAvailable = false; + ::mode_t mode = 0; + + public: + SchedulerFileProperties() = default; + SchedulerFileProperties(bool isAvailable, ::mode_t mode) : isAvailable(isAvailable), mode(mode) {} + + bool getAvailability() { + return isAvailable; + } + + bool hasMode(::mode_t mode) { + return mode & this->mode; + } +}; + template <> struct Mock : public SysfsAccess { std::map engineSchedMap; + std::map engineSchedFilePropertiesMap; ze_result_t getValForError(const std::string file, uint64_t &val) { return ZE_RESULT_ERROR_NOT_AVAILABLE; @@ -54,7 +72,39 @@ struct Mock : public SysfsAccess { } } } + + ze_result_t getFileProperties(const std::string file, SchedulerFileProperties &fileProps) { + auto iterator = engineSchedFilePropertiesMap.find(file); + if (iterator != engineSchedFilePropertiesMap.end()) { + fileProps = static_cast(iterator->second); + return ZE_RESULT_SUCCESS; + } + return ZE_RESULT_ERROR_UNKNOWN; + } + + ze_result_t setFileProperties(const std::string &engine, const std::string file, bool isAvailable, ::mode_t mode) { + auto iterator = std::find(listOfMockedEngines.begin(), listOfMockedEngines.end(), engine); + if (iterator != listOfMockedEngines.end()) { + engineSchedFilePropertiesMap[engineDir + "/" + engine + "/" + file] = SchedulerFileProperties(isAvailable, mode); + return ZE_RESULT_SUCCESS; + } + return ZE_RESULT_ERROR_UNKNOWN; + } + ze_result_t getVal(const std::string file, uint64_t &val) { + SchedulerFileProperties fileProperties; + ze_result_t result = getFileProperties(file, fileProperties); + if (ZE_RESULT_SUCCESS == result) { + if (!fileProperties.getAvailability()) { + return ZE_RESULT_ERROR_NOT_AVAILABLE; + } + if (!fileProperties.hasMode(S_IRUSR)) { + return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS; + } + } else { + return ZE_RESULT_ERROR_UNKNOWN; + } + for (std::string mappedEngine : listOfMockedEngines) { if (file.find(mappedEngine) == std::string::npos) { continue; @@ -96,7 +146,21 @@ struct Mock : public SysfsAccess { } return ZE_RESULT_ERROR_NOT_AVAILABLE; } + ze_result_t setVal(const std::string file, const uint64_t val) { + SchedulerFileProperties fileProperties; + ze_result_t result = getFileProperties(file, fileProperties); + if (ZE_RESULT_SUCCESS == result) { + if (!fileProperties.getAvailability()) { + return ZE_RESULT_ERROR_NOT_AVAILABLE; + } + if (!fileProperties.hasMode(S_IWUSR)) { + return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS; + } + } else { + return ZE_RESULT_ERROR_UNKNOWN; + } + for (std::string mappedEngine : listOfMockedEngines) { if (file.find(mappedEngine) == std::string::npos) { continue; @@ -166,21 +230,38 @@ struct Mock : public SysfsAccess { return ZE_RESULT_ERROR_NOT_AVAILABLE; } ze_result_t getscanDirEntries(const std::string file, std::vector &listOfEntries) { - if (file.compare(engineDir) == 0) { - listOfEntries = listOfMockedEngines; - return ZE_RESULT_SUCCESS; + + if (!isDirectoryAccessible(engineDir)) { + return ZE_RESULT_ERROR_NOT_AVAILABLE; } - return ZE_RESULT_ERROR_NOT_AVAILABLE; + if (!(engineDirectoryPermissions & S_IRUSR)) { + return ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS; + } + listOfEntries = listOfMockedEngines; + return ZE_RESULT_SUCCESS; } ze_result_t getscanDirEntriesStatusReturnError(const std::string file, std::vector &listOfEntries) { return ZE_RESULT_ERROR_NOT_AVAILABLE; } + void setEngineDirectoryPermission(::mode_t permission) { + engineDirectoryPermissions = permission; + } + Mock() = default; MOCK_METHOD(ze_result_t, read, (const std::string file, uint64_t &val), (override)); MOCK_METHOD(ze_result_t, write, (const std::string file, const uint64_t val), (override)); MOCK_METHOD(ze_result_t, scanDirEntries, (const std::string file, std::vector &listOfEntries), (override)); + + private: + ::mode_t engineDirectoryPermissions = S_IRUSR | S_IWUSR; + bool isDirectoryAccessible(const std::string dir) { + if (dir.compare(engineDir) == 0) { + return true; + } + return false; + } }; class PublicLinuxSchedulerImp : public L0::LinuxSchedulerImp { diff --git a/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/test_zes_scheduler.cpp b/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/test_zes_scheduler.cpp index df7327d8af..6da79a8986 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/test_zes_scheduler.cpp +++ b/level_zero/tools/test/unit_tests/sources/sysman/scheduler/linux/test_zes_scheduler.cpp @@ -43,6 +43,13 @@ class SysmanDeviceSchedulerFixture : public SysmanDeviceFixture { pLinuxSysmanImp->pSysfsAccess = pSysfsAccess.get(); for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(), [=](std::string engineName) { + pSysfsAccess->setFileProperties(engineName, defaultPreemptTimeoutMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR); + pSysfsAccess->setFileProperties(engineName, defaultTimesliceDurationMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR); + pSysfsAccess->setFileProperties(engineName, defaultHeartbeatIntervalMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR); + pSysfsAccess->setFileProperties(engineName, preemptTimeoutMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR); + pSysfsAccess->setFileProperties(engineName, timesliceDurationMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR); + pSysfsAccess->setFileProperties(engineName, heartbeatIntervalMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR); + pSysfsAccess->setVal(engineDir + "/" + engineName + "/" + defaultPreemptTimeoutMilliSecs, defaultTimeoutMilliSecs); pSysfsAccess->setVal(engineDir + "/" + engineName + "/" + defaultTimesliceDurationMilliSecs, defaultTimesliceMilliSecs); pSysfsAccess->setVal(engineDir + "/" + engineName + "/" + defaultHeartbeatIntervalMilliSecs, defaultHeartbeatMilliSecs); @@ -118,6 +125,13 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenComponentCountZeroWhenCallingzesDevice EXPECT_EQ(0u, static_cast(pSchedulerHandleContextTest->handleList.size())); } +TEST_F(SysmanDeviceSchedulerFixture, GivenComponentCountZeroWhenCallingzesDeviceEnumSchedulersAndSysfsCanReadReturnsIncorrectPermissionThenZeroCountIsReturned) { + pSysfsAccess->setEngineDirectoryPermission(0); + auto pSchedulerHandleContextTest = std::make_unique(pOsSysman); + pSchedulerHandleContextTest->init(deviceHandles); + EXPECT_EQ(0u, static_cast(pSchedulerHandleContextTest->handleList.size())); +} + TEST_F(SysmanDeviceSchedulerFixture, GivenComponentCountZeroWhenCallingzesDeviceEnumSchedulersThenNonZeroCountIsReturnedAndVerifyCallSucceeds) { uint32_t count = 0; EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumSchedulers(device->toHandle(), &count, NULL)); @@ -312,6 +326,91 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul } } +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenTimeoutLessThanMinimumThenVerifyzesSchedulerSetTimeoutModeCallFails) { + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + ze_bool_t needReboot; + zes_sched_timeout_properties_t setConfig; + setConfig.watchdogTimeout = minTimeoutModeHeartbeat - 1; + ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result); + } +} + +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenCurrentModeIsTimeoutModeThenVerifyzesSchedulerSetTimeoutModeCallSucceeds) { + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + ze_bool_t needReboot; + zes_sched_timeout_properties_t setTimeOutConfig; + setTimeOutConfig.watchdogTimeout = 10000u; + ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setTimeOutConfig, &needReboot); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + + result = zesSchedulerSetTimeoutMode(handle, &setTimeOutConfig, &needReboot); + EXPECT_EQ(ZE_RESULT_SUCCESS, result); + } +} + +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenHeartBeatSettingFailsThenVerifyzesSchedulerSetTimeoutModeCallFails) { + for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(), + [=](std::string engineName) { + pSysfsAccess->setFileProperties(engineName, heartbeatIntervalMilliSecs, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR); + }); + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + ze_bool_t needReboot; + zes_sched_timeout_properties_t setTimeOutConfig; + setTimeOutConfig.watchdogTimeout = 10000u; + ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setTimeOutConfig, &needReboot); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result); + } +} + +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenGetCurrentModeFailsThenVerifyzesSchedulerSetTimeoutModeCallFails) { + for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(), + [=](std::string engineName) { + pSysfsAccess->setFileProperties(engineName, preemptTimeoutMilliSecs, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR); + }); + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + ze_bool_t needReboot; + zes_sched_timeout_properties_t setConfig; + setConfig.watchdogTimeout = minTimeoutModeHeartbeat; + ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result); + } +} + +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenPreEmptTimeoutNoPermissionThenVerifyzesSchedulerSetTimeoutModeCallFails) { + for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(), + [=](std::string engineName) { + pSysfsAccess->setFileProperties(engineName, preemptTimeoutMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH); + }); + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + ze_bool_t needReboot; + zes_sched_timeout_properties_t setConfig; + setConfig.watchdogTimeout = minTimeoutModeHeartbeat; + ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot); + EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result); + } +} + +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenTimeSliceDurationNoPermissionThenVerifyzesSchedulerSetTimeoutModeCallFails) { + for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(), + [=](std::string engineName) { + pSysfsAccess->setFileProperties(engineName, timesliceDurationMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH); + }); + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + ze_bool_t needReboot; + zes_sched_timeout_properties_t setConfig; + setConfig.watchdogTimeout = minTimeoutModeHeartbeat; + ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot); + EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result); + } +} + TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeThenVerifyzesSchedulerSetTimesliceModeCallSucceeds) { auto handles = get_sched_handles(handleComponentCount); for (auto handle : handles) { @@ -330,6 +429,50 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul } } +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenIntervalIsLessThanMinimumThenVerifyzesSchedulerSetTimesliceModeCallFails) { + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + ze_bool_t needReboot; + zes_sched_timeslice_properties_t setConfig; + setConfig.interval = minTimeoutInMicroSeconds - 1; + setConfig.yieldTimeout = 1000u; + ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, result); + } +} + +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenNoAccessToTimeSliceDurationThenVerifyzesSchedulerSetTimesliceModeCallFails) { + for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(), + [=](std::string engineName) { + pSysfsAccess->setFileProperties(engineName, timesliceDurationMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH); + }); + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + ze_bool_t needReboot; + zes_sched_timeslice_properties_t setConfig; + setConfig.interval = minTimeoutInMicroSeconds; + setConfig.yieldTimeout = 1000u; + ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot); + EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result); + } +} + +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenNoAccessToHeartBeatIntervalThenVerifyzesSchedulerSetTimesliceModeCallFails) { + for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(), + [=](std::string engineName) { + pSysfsAccess->setFileProperties(engineName, heartbeatIntervalMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH); + }); + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + ze_bool_t needReboot; + zes_sched_timeslice_properties_t setConfig; + setConfig.interval = minTimeoutInMicroSeconds; + setConfig.yieldTimeout = 1000u; + ze_result_t result = zesSchedulerSetTimesliceMode(handle, &setConfig, &needReboot); + EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result); + } +} + TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetExclusiveModeThenVerifyzesSchedulerSetExclusiveModeCallSucceeds) { auto handles = get_sched_handles(handleComponentCount); for (auto handle : handles) { @@ -342,9 +485,50 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul } } -TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetCurrentModeWhenSysfsNodeIsAbsentThenFailureIsReturned) { - ON_CALL(*pSysfsAccess.get(), read(_, _)) - .WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock::getValForError)); +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetExclusiveModeWhenPreEmptTimeoutNotAvailableThenVerifyzesSchedulerSetExclusiveModeCallFails) { + for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(), + [=](std::string engineName) { + pSysfsAccess->setFileProperties(engineName, preemptTimeoutMilliSecs, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR); + }); + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + ze_bool_t needReboot; + ze_result_t result = zesSchedulerSetExclusiveMode(handle, &needReboot); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result); + } +} + +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetExclusiveModeWhenTimeSliceDurationNotAvailableThenVerifyzesSchedulerSetExclusiveModeCallFails) { + for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(), + [=](std::string engineName) { + pSysfsAccess->setFileProperties(engineName, timesliceDurationMilliSecs, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR); + }); + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + ze_bool_t needReboot; + ze_result_t result = zesSchedulerSetExclusiveMode(handle, &needReboot); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result); + } +} + +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetExclusiveModeWhenTimeSliceDurationHasNoPermissionsThenVerifyzesSchedulerSetExclusiveModeCallFails) { + for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(), + [=](std::string engineName) { + pSysfsAccess->setFileProperties(engineName, timesliceDurationMilliSecs, true, S_IRUSR | S_IRGRP | S_IROTH); + }); + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + ze_bool_t needReboot; + ze_result_t result = zesSchedulerSetExclusiveMode(handle, &needReboot); + EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result); + } +} + +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetCurrentModeWhenPreEmptTimeOutNotAvailableThenFailureIsReturned) { + for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(), + [=](std::string engineName) { + pSysfsAccess->setFileProperties(engineName, preemptTimeoutMilliSecs, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR); + }); auto handles = get_sched_handles(handleComponentCount); for (auto handle : handles) { zes_sched_mode_t mode; @@ -353,6 +537,41 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul } } +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetCurrentModeWhenTimeSliceDurationNotAvailableThenFailureIsReturned) { + for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(), + [=](std::string engineName) { + pSysfsAccess->setFileProperties(engineName, timesliceDurationMilliSecs, false, S_IRUSR | S_IRGRP | S_IROTH | S_IWUSR); + }); + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + zes_sched_mode_t mode; + ze_result_t result = zesSchedulerGetCurrentMode(handle, &mode); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result); + } +} + +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetCurrentModeWhenTimeSliceDurationHasNoPermissionThenFailureIsReturned) { + for_each(listOfMockedEngines.begin(), listOfMockedEngines.end(), + [=](std::string engineName) { + pSysfsAccess->setFileProperties(engineName, timesliceDurationMilliSecs, true, S_IRGRP | S_IROTH | S_IWUSR); + }); + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + zes_sched_mode_t mode; + ze_result_t result = zesSchedulerGetCurrentMode(handle, &mode); + EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result); + } +} + +TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetComputeUnitDebugModeThenUnsupportedFeatureIsReturned) { + auto handles = get_sched_handles(handleComponentCount); + for (auto handle : handles) { + ze_bool_t needReload; + ze_result_t result = zesSchedulerSetComputeUnitDebugMode(handle, &needReload); + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result); + } +} + TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerGetTimeoutModePropertiesWithDefaultsWhenSysfsNodeIsAbsentThenFailureIsReturned) { ON_CALL(*pSysfsAccess.get(), read(_, _)) .WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock::getValForError)); @@ -375,35 +594,6 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul } } -TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenSysfsNodeIsAbsentThenFailureIsReturned) { - ON_CALL(*pSysfsAccess.get(), write(_, _)) - .WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock::getValForErrorWhileWrite)); - auto handles = get_sched_handles(handleComponentCount); - for (auto handle : handles) { - ze_bool_t needReboot; - zes_sched_timeout_properties_t setConfig; - setConfig.watchdogTimeout = 10000u; - ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot); - EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, result); - } -} - -TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimeoutModeWhenSysfsNodeWithoutPermissionsThenFailureIsReturned) { - ON_CALL(*pSysfsAccess.get(), write(_, _)) - .WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock::getValForErrorWhileWrite)); - auto handles = get_sched_handles(handleComponentCount); - for (auto handle : handles) { - ze_bool_t needReboot; - zes_sched_timeout_properties_t setConfig; - setConfig.watchdogTimeout = 10000u; - EXPECT_CALL(*pSysfsAccess.get(), write(_, _)) - .WillOnce(Return(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS)) - .WillRepeatedly(DoDefault()); - ze_result_t result = zesSchedulerSetTimeoutMode(handle, &setConfig, &needReboot); - EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, result); - } -} - TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedulerSetTimesliceModeWhenSysfsNodeIsAbsentThenFailureIsReturned) { ON_CALL(*pSysfsAccess.get(), write(_, _)) .WillByDefault(::testing::Invoke(pSysfsAccess.get(), &Mock::getValForErrorWhileWrite)); @@ -447,6 +637,16 @@ TEST_F(SysmanDeviceSchedulerFixture, GivenValidDeviceHandleWhenCallingzesSchedul } } +TEST_F(SysmanDeviceSchedulerFixture, GivenValidObjectsOfClassSchedulerImpAndSchedulerHandleContextThenDuringObjectReleaseCheckDestructorBranches) { + for (auto &handle : pSysmanDeviceImp->pSchedulerHandleContext->handleList) { + auto pSchedulerImp = static_cast(handle); + delete pSchedulerImp->pOsScheduler; + pSchedulerImp->pOsScheduler = nullptr; + delete handle; + handle = nullptr; + } +} + TEST_F(SysmanMultiDeviceFixture, GivenValidDevicePointerWhenGettingSchedPropertiesThenValidSchedPropertiesRetrieved) { zes_sched_properties_t properties = {}; std::vector listOfEngines; @@ -461,4 +661,4 @@ TEST_F(SysmanMultiDeviceFixture, GivenValidDevicePointerWhenGettingSchedProperti } } // namespace ult -} // namespace L0 \ No newline at end of file +} // namespace L0