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

Improve Sysman windows ult coverage

Browse Source 
Related-To: LOCI-4141

Signed-off-by: Mayank Raghuwanshi <mayank.raghuwanshi@intel.com>
This commit is contained in:
Mayank Raghuwanshi
2023-03-19 19:15:05 +00:00
committed by Compute-Runtime-Automation
parent 9608879372
commit d0fd7c1667
7 changed files with 261 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
level_zero/tools/test/unit_tests/sources/sysman/events/windows/test_zes_events.cpp
View File

@@ -1,5 +1,5 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
* Copyright (C) 2020-2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
@@ -67,7 +67,7 @@ class SysmanEventsFixture : public SysmanDeviceFixture {
}
};
TEST_F(SysmanEventsFixture, DISABLED_GivenValidDeviceHandleWhenListeningForResetRequiredEventsThenEventListenAPIReturnsAfterTimingOutWithNoEvent) {
TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForResetRequiredEventsThenEventListenAPIReturnsAfterTimingOutWithNoEvent) {
init(true);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_DETACH));
zes_device_handle_t *phDevices = new zes_device_handle_t[1];
@@ -80,7 +80,7 @@ TEST_F(SysmanEventsFixture, DISABLED_GivenValidDeviceHandleWhenListeningForReset
delete[] pDeviceEvents;
}
TEST_F(SysmanEventsFixture, DISABLED_GivenValidDeviceHandleWhenListeningForResetRequiredEventsThenEventListenAPIReturnsAfterReceivingEventOnInfiniteWait) {
TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForResetRequiredEventsThenEventListenAPIReturnsAfterReceivingEventOnInfiniteWait) {
init(true);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_DETACH));
zes_device_handle_t *phDevices = new zes_device_handle_t[1];
@@ -96,7 +96,7 @@ TEST_F(SysmanEventsFixture, DISABLED_GivenValidDeviceHandleWhenListeningForReset
delete[] pDeviceEvents;
}
TEST_F(SysmanEventsFixture, DISABLED_GivenValidDeviceHandleWhenListeningForResetRequiredEventsThenEventListenAPIReturnsAfterReceivingEventOnInfiniteWaitMultipleTimes) {
TEST_F(SysmanEventsFixture, GivenValidDeviceHandleWhenListeningForResetRequiredEventsThenEventListenAPIReturnsAfterReceivingEventOnInfiniteWaitMultipleTimes) {
init(true);
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEventRegister(device->toHandle(), ZES_EVENT_TYPE_FLAG_DEVICE_DETACH));
zes_device_handle_t *phDevices = new zes_device_handle_t[1];

13
level_zero/tools/test/unit_tests/sources/sysman/fabric_port/windows/CMakeLists.txt Normal file
View File

@@ -0,0 +1,13 @@
#
# Copyright (C) 2023 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
if(WIN32)
target_sources(${TARGET_NAME}
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_fabric_port.cpp
)
endif()

72
level_zero/tools/test/unit_tests/sources/sysman/fabric_port/windows/test_zes_fabric_port.cpp Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright (C) 2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/sysman/fabric_port/fabric_port_imp.h"
#include "level_zero/tools/test/unit_tests/sources/sysman/windows/mock_sysman_fixture.h"
extern bool sysmanUltsEnable;
namespace L0 {
namespace ult {
class SysmanFabricPortFixture : public SysmanDeviceFixture {
protected:
std::unique_ptr<FabricDeviceImp> pFabricDevice;
std::unique_ptr<FabricPortImp> pFabricPortImp;
void SetUp() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
SysmanDeviceFixture::SetUp();
pFabricDevice.reset(new FabricDeviceImp(pOsSysman));
pFabricPortImp.reset(new FabricPortImp(pFabricDevice.get(), 0u));
}
void TearDown() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
SysmanDeviceFixture::TearDown();
}
};
TEST_F(SysmanFabricPortFixture, GivenValidFabricPortHandleWhenCallingFabricPortGetPropertiesThenFailureIsReturned) {
zes_fabric_port_properties_t pProperties = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFabricPortImp->fabricPortGetProperties(&pProperties));
}
TEST_F(SysmanFabricPortFixture, GivenValidFabricPortHandleWhenCallingFabricPortGetConfigThenFailureIsReturned) {
zes_fabric_port_config_t pConfig = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFabricPortImp->fabricPortGetConfig(&pConfig));
}
TEST_F(SysmanFabricPortFixture, GivenValidFabricPortHandleWhenCallingFabricPortSetConfigThenFailureIsReturned) {
zes_fabric_port_config_t pConfig = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFabricPortImp->fabricPortSetConfig(&pConfig));
}
TEST_F(SysmanFabricPortFixture, GivenValidFabricPortHandleWhenCallingFabricPortGetStateThenFailureIsReturned) {
zes_fabric_port_state_t pState = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFabricPortImp->fabricPortGetState(&pState));
}
TEST_F(SysmanFabricPortFixture, GivenValidFabricPortHandleWhenCallingFabricPortGetThroughputThenFailureIsReturned) {
zes_fabric_port_throughput_t pThroughput = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFabricPortImp->fabricPortGetThroughput(&pThroughput));
}
TEST_F(SysmanFabricPortFixture, GivenValidFabricPortHandleWhenCallingFabricPortGetErrorCountersThenFailureIsReturned) {
zes_fabric_port_error_counters_t pErrors = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFabricPortImp->fabricPortGetErrorCounters(&pErrors));
}
TEST_F(SysmanFabricPortFixture, GivenValidFabricPortHandleWhenCallingFabricPortGetLinkTupeThenFailureIsReturned) {
zes_fabric_link_type_t pLinkType = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pFabricPortImp->fabricPortGetLinkType(&pLinkType));
}
} // namespace ult
} // namespace L0

13
level_zero/tools/test/unit_tests/sources/sysman/ras/windows/CMakeLists.txt Normal file
View File

@@ -0,0 +1,13 @@
#
# Copyright (C) 2023 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
if(WIN32)
target_sources(${TARGET_NAME}
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_ras.cpp
)
endif()

72
level_zero/tools/test/unit_tests/sources/sysman/ras/windows/test_zes_ras.cpp Normal file
View File

@@ -0,0 +1,72 @@
/*
* Copyright (C) 2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/sysman/ras/ras_imp.h"
#include "level_zero/tools/test/unit_tests/sources/sysman/windows/mock_sysman_fixture.h"
extern bool sysmanUltsEnable;
namespace L0 {
namespace ult {
constexpr uint32_t mockHandleCount = 0u;
class SysmanRasFixture : public SysmanDeviceFixture {
protected:
void SetUp() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
SysmanDeviceFixture::SetUp();
}
void TearDown() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
SysmanDeviceFixture::TearDown();
}
std::vector<zes_ras_handle_t> getRasHandles(uint32_t count) {
std::vector<zes_ras_handle_t> handles(count, nullptr);
EXPECT_EQ(zesDeviceEnumRasErrorSets(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS);
return handles;
}
};
TEST_F(SysmanRasFixture, GivenValidSysmanHandleWhenRasErrorSetsThenCorrectCountIsReported) {
uint32_t count = 0;
ze_result_t result = zesDeviceEnumRasErrorSets(device->toHandle(), &count, NULL);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, mockHandleCount);
}
TEST_F(SysmanRasFixture, GivenValidRasHandleRetrievingRasPropertiesThenSuccessIsReturned) {
auto pRasImp = std::make_unique<RasImp>(pOsSysman, ZES_RAS_ERROR_TYPE_CORRECTABLE, device->toHandle());
zes_ras_properties_t properties = {};
pRasImp->init();
EXPECT_EQ(ZE_RESULT_SUCCESS, pRasImp->rasGetProperties(&properties));
}
TEST_F(SysmanRasFixture, GivenValidRasHandleWhenCallingRasGetStateThenFailureIsReturned) {
auto pRasImp = std::make_unique<RasImp>(pOsSysman, ZES_RAS_ERROR_TYPE_CORRECTABLE, device->toHandle());
zes_ras_state_t state = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pRasImp->rasGetState(&state, false));
}
TEST_F(SysmanRasFixture, GivenValidRasHandleWhenCallingRasGetConfigThenFailureIsReturned) {
auto pRasImp = std::make_unique<RasImp>(pOsSysman, ZES_RAS_ERROR_TYPE_CORRECTABLE, device->toHandle());
zes_ras_config_t config = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pRasImp->rasGetConfig(&config));
}
TEST_F(SysmanRasFixture, GivenValidRasHandleWhenCallingRasSetConfigThenFailureIsReturned) {
auto pRasImp = std::make_unique<RasImp>(pOsSysman, ZES_RAS_ERROR_TYPE_CORRECTABLE, device->toHandle());
zes_ras_config_t config = {};
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pRasImp->rasSetConfig(&config));
}
} // namespace ult
} // namespace L0

13
level_zero/tools/test/unit_tests/sources/sysman/standby/windows/CMakeLists.txt Normal file
View File

@@ -0,0 +1,13 @@
#
# Copyright (C) 2023 Intel Corporation
#
# SPDX-License-Identifier: MIT
#
if(WIN32)
target_sources(${TARGET_NAME}
PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_sysman_standby.cpp
)
endif()

74
level_zero/tools/test/unit_tests/sources/sysman/standby/windows/test_zes_sysman_standby.cpp Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright (C) 2023 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/source/sysman/standby/standby_imp.h"
#include "level_zero/tools/test/unit_tests/sources/sysman/windows/mock_sysman_fixture.h"
extern bool sysmanUltsEnable;
namespace L0 {
namespace ult {
constexpr uint32_t mockHandleCount = 0u;
class ZesStandbyFixture : public SysmanDeviceFixture {
protected:
void SetUp() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
SysmanDeviceFixture::SetUp();
}
void TearDown() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
SysmanDeviceFixture::TearDown();
}
};
TEST_F(ZesStandbyFixture, GivenValidSysmanHandleWhenRetrievingStandbyHandlesThenCorrectCountIsReported) {
std::vector<zes_standby_handle_t> standbyHandle = {};
uint32_t count = 0;
ze_result_t result = zesDeviceEnumStandbyDomains(device, &count, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, mockHandleCount);
uint32_t testCount = count + 1;
result = zesDeviceEnumStandbyDomains(device, &testCount, nullptr);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(testCount, count);
}
TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenRetrievingStandbyPropertiesThenSuccessIsReturned) {
auto pStandbyImp = std::make_unique<StandbyImp>(pOsSysman, device->toHandle());
zes_standby_properties_t properties = {};
pStandbyImp->init();
EXPECT_EQ(ZE_RESULT_SUCCESS, pStandbyImp->standbyGetProperties(&properties));
}
TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingGetModeThenFailureIsReturned) {
auto pStandbyImp = std::make_unique<StandbyImp>(pOsSysman, device->toHandle());
zes_standby_promo_mode_t mode = {};
pStandbyImp->init();
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pStandbyImp->standbyGetMode(&mode));
}
TEST_F(ZesStandbyFixture, GivenValidStandbyHandleWhenCallingSetModeThenFailureIsReturned) {
auto pStandbyImp = std::make_unique<StandbyImp>(pOsSysman, device->toHandle());
zes_standby_promo_mode_t mode = {};
pStandbyImp->init();
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, pStandbyImp->standbySetMode(mode));
}
} // namespace ult
} // namespace L0