intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-12-30 09:58:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

Added Fabric Port ULTs

Browse Source 
Related-To: LOCI-3650

Signed-off-by: Bari, Pratik <pratik.bari@intel.com>
This commit is contained in:
Bari, Pratik
2022-11-28 11:41:56 +00:00
committed by Compute-Runtime-Automation
parent 675272a32c
commit aafe562bce
9 changed files with 3018 additions and 8 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/CMakeLists.txt
View File

@@ -6,12 +6,17 @@
set(L0_TESTS_TOOLS_SYSMAN_FABRICPORT_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}test_zes_fabric_port.cpp
${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}mock_fabric_device.h
)
if(NEO_ENABLE_i915_PRELIM_DETECTION AND("${BRANCH_TYPE}" STREQUAL ""))
list(REMOVE_ITEM L0_TESTS_TOOLS_SYSMAN_FABRICPORT_LINUX
if(NEO_ENABLE_i915_PRELIM_DETECTION)
if(LIBGENL_FOUND)
list(APPEND L0_TESTS_TOOLS_SYSMAN_FABRICPORT_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_fabric_device_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_fabric_port_prelim.cpp
)
endif()
else()
list(APPEND L0_TESTS_TOOLS_SYSMAN_FABRICPORT_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_zes_fabric_port.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_fabric_device.h
)
@@ -22,7 +27,4 @@ if(UNIX)
PRIVATE
${L0_TESTS_TOOLS_SYSMAN_FABRICPORT_LINUX}
)
add_subdirectories()
endif()

399
level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_sysman_fabric_device_prelim.cpp Normal file
View File

@@ -0,0 +1,399 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
#include "level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "sysman/fabric_port/linux/fabric_device_access_imp.h"
#include <limits>
extern bool sysmanUltsEnable;
using ::testing::Invoke;
using ::testing::Matcher;
using ::testing::Return;
namespace L0 {
namespace ult {
class PublicFabricDeviceAccessNl : public FabricDeviceAccessNl {
public:
using FabricDeviceAccessNl::fabricPorts;
using FabricDeviceAccessNl::pIafNlApi;
};
class SysmanFabricDeviceFixture : public SysmanDeviceFixture {
protected:
MockIafNlApi *pMockIafNlApi = nullptr;
FabricDeviceAccess *pFabricDeviceAccess = nullptr;
zes_fabric_port_id_t testPortId = {};
void SetUp() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
SysmanDeviceFixture::SetUp();
pFabricDeviceAccess = FabricDeviceAccess::create(pOsSysman);
PublicFabricDeviceAccessNl *pPublicFabricDeviceAccessNl = reinterpret_cast<PublicFabricDeviceAccessNl *>(pFabricDeviceAccess);
pMockIafNlApi = new MockIafNlApi;
delete pPublicFabricDeviceAccessNl->pIafNlApi;
pPublicFabricDeviceAccessNl->pIafNlApi = pMockIafNlApi;
pPublicFabricDeviceAccessNl->fabricPorts.clear();
setupDefaults();
}
void TearDown() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
delete pFabricDeviceAccess;
SysmanDeviceFixture::TearDown();
}
void setupDefaults();
};
void SysmanFabricDeviceFixture::setupDefaults() {
testPortId.attachId = pMockIafNlApi->testPortId.attachId;
testPortId.fabricId = pMockIafNlApi->testPortId.fabricId;
testPortId.portNumber = pMockIafNlApi->testPortId.portNumber;
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWithoutIafNlApiWhenTearDownIsCalledThenNoSegfault) {
PublicFabricDeviceAccessNl *pPublicFabricDeviceAccessNl = reinterpret_cast<PublicFabricDeviceAccessNl *>(pFabricDeviceAccess);
EXPECT_NE(nullptr, pPublicFabricDeviceAccessNl);
delete pPublicFabricDeviceAccessNl->pIafNlApi;
pPublicFabricDeviceAccessNl->pIafNlApi = nullptr;
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetPortEnabledStateIsCalledReturnsEnabledTrue) {
bool enabled;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getPortEnabledState(testPortId, enabled));
EXPECT_EQ(true, enabled);
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetPortBeaconStateIsCalledReturnsEnabledTrue) {
bool enabled;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getPortBeaconState(testPortId, enabled));
EXPECT_EQ(true, enabled);
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenEnablePortBeaconingCalledReturnsSuccess) {
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->enablePortBeaconing(testPortId));
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenDisablePortBeaconingCalledReturnsSuccess) {
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->disablePortBeaconing(testPortId));
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenEnableCalledReturnsSuccess) {
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->enable(testPortId));
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenDisableCalledReturnsSuccess) {
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->disable(testPortId));
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenEnableUsageCalledReturnsSuccess) {
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->enableUsage(testPortId));
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenDisableUsageCalledReturnsSuccess) {
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->disableUsage(testPortId));
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenForceSweepCalledReturnsSuccess) {
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->forceSweep());
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenRoutingQueryCalledReturnsSuccess) {
uint32_t start = 0, end = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->routingQuery(start, end));
EXPECT_EQ(pMockIafNlApi->genStart, start);
EXPECT_EQ(pMockIafNlApi->genEnd, end);
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetPropertiesCalledThenAllPropertiesAreReturned) {
PublicFabricDeviceAccessNl *pPublicFabricDeviceAccessNl = reinterpret_cast<PublicFabricDeviceAccessNl *>(pFabricDeviceAccess);
struct Port p;
pPublicFabricDeviceAccessNl->fabricPorts.clear();
// First port, wrong attachId
p.portId.fabricId = pMockIafNlApi->testPortId.fabricId;
p.portId.attachId = 0U;
p.portId.portNumber = pMockIafNlApi->testPortId.portNumber;
p.onSubdevice = false;
p.model = std::string("wrongPort");
p.maxRxSpeed.bitRate = 1L;
p.maxRxSpeed.width = 1;
p.maxTxSpeed.bitRate = 1L;
p.maxTxSpeed.width = 1;
pPublicFabricDeviceAccessNl->fabricPorts.push_back(p);
// Second port, wrong portNumber
p.portId.fabricId = pMockIafNlApi->testPortId.fabricId;
p.portId.attachId = pMockIafNlApi->testPortId.attachId;
p.portId.portNumber = 0U;
p.onSubdevice = false;
p.model = std::string("wrongPort");
p.maxRxSpeed.bitRate = 2L;
p.maxRxSpeed.width = 2;
p.maxTxSpeed.bitRate = 2L;
p.maxTxSpeed.width = 2;
pPublicFabricDeviceAccessNl->fabricPorts.push_back(p);
// Third port, is a match
p.portId.fabricId = pMockIafNlApi->testPortId.fabricId;
p.portId.attachId = pMockIafNlApi->testPortId.attachId;
p.portId.portNumber = pMockIafNlApi->testPortId.portNumber;
p.onSubdevice = true;
p.model = std::string("rightPort");
p.maxRxSpeed.bitRate = 3L;
p.maxRxSpeed.width = 3;
p.maxTxSpeed.bitRate = 3L;
p.maxTxSpeed.width = 3;
pPublicFabricDeviceAccessNl->fabricPorts.push_back(p);
std::string model = std::string("");
bool onSubdevice = false;
uint32_t subdeviceId = 0U;
zes_fabric_port_speed_t maxRxSpeed = {.bitRate = -1L, .width = -1};
zes_fabric_port_speed_t maxTxSpeed = {.bitRate = -1L, .width = -1};
pFabricDeviceAccess->getProperties(testPortId, model, onSubdevice, subdeviceId, maxRxSpeed, maxTxSpeed);
EXPECT_EQ(p.model, model);
EXPECT_EQ(p.onSubdevice, onSubdevice);
EXPECT_EQ(p.portId.attachId, subdeviceId);
EXPECT_EQ(p.maxRxSpeed.bitRate, maxRxSpeed.bitRate);
EXPECT_EQ(p.maxRxSpeed.width, maxRxSpeed.width);
EXPECT_EQ(p.maxTxSpeed.bitRate, maxTxSpeed.bitRate);
EXPECT_EQ(p.maxTxSpeed.width, maxTxSpeed.width);
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetThroughputCalledReturnsThroughputValues) {
zes_fabric_port_throughput_t throughput = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getThroughput(testPortId, throughput));
EXPECT_EQ(throughput.rxCounter, pMockIafNlApi->rxCounter);
EXPECT_EQ(throughput.txCounter, pMockIafNlApi->txCounter);
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetStateIsCalledAndfPortStatusIsHealthyReturnsSuccess) {
zes_fabric_port_state_t state1 = {};
state1.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES;
state1.pNext = nullptr;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state1));
EXPECT_EQ(state1.stype, ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES);
EXPECT_EQ(state1.pNext, nullptr);
EXPECT_EQ(state1.status, ZES_FABRIC_PORT_STATUS_HEALTHY);
EXPECT_EQ(state1.qualityIssues, 0U);
EXPECT_EQ(state1.failureReasons, 0U);
EXPECT_EQ(state1.remotePortId.fabricId, pMockIafNlApi->testPortId.fabricId);
EXPECT_EQ(state1.remotePortId.attachId, pMockIafNlApi->testPortId.attachId);
EXPECT_EQ(state1.remotePortId.portNumber, pMockIafNlApi->testPortId.portNumber + 1);
EXPECT_EQ(state1.rxSpeed.bitRate, -1);
EXPECT_EQ(state1.rxSpeed.width, -1);
EXPECT_EQ(state1.txSpeed.bitRate, -1);
EXPECT_EQ(state1.txSpeed.width, -1);
zes_fabric_port_state_t state2 = {};
state2.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES;
state2.pNext = nullptr;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state2));
EXPECT_EQ(state2.stype, ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES);
EXPECT_EQ(state2.pNext, nullptr);
EXPECT_EQ(state2.status, ZES_FABRIC_PORT_STATUS_HEALTHY);
EXPECT_EQ(state2.qualityIssues, 0U);
EXPECT_EQ(state2.failureReasons, 0U);
EXPECT_EQ(state2.remotePortId.fabricId, pMockIafNlApi->testPortId.fabricId);
EXPECT_EQ(state2.remotePortId.attachId, pMockIafNlApi->testPortId.attachId);
EXPECT_EQ(state2.remotePortId.portNumber, pMockIafNlApi->testPortId.portNumber + 1);
EXPECT_EQ(state2.rxSpeed.bitRate, -1);
EXPECT_EQ(state2.rxSpeed.width, -1);
EXPECT_EQ(state2.txSpeed.bitRate, -1);
EXPECT_EQ(state2.txSpeed.width, -1);
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetStateIsCalledAndfPortStatusIsDegradedReturnsSuccess) {
zes_fabric_port_state_t state = {};
state.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES;
state.pNext = nullptr;
pMockIafNlApi->fPortStatus = ZES_FABRIC_PORT_STATUS_DEGRADED;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
EXPECT_EQ(state.stype, ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES);
EXPECT_EQ(state.pNext, nullptr);
EXPECT_EQ(state.status, ZES_FABRIC_PORT_STATUS_DEGRADED);
EXPECT_EQ(state.qualityIssues, 0U);
EXPECT_EQ(state.failureReasons, 0U);
EXPECT_EQ(state.remotePortId.fabricId, pMockIafNlApi->testPortId.fabricId);
EXPECT_EQ(state.remotePortId.attachId, pMockIafNlApi->testPortId.attachId);
EXPECT_EQ(state.remotePortId.portNumber, pMockIafNlApi->testPortId.portNumber + 1);
EXPECT_EQ(state.rxSpeed.bitRate, -1);
EXPECT_EQ(state.rxSpeed.width, -1);
EXPECT_EQ(state.txSpeed.bitRate, -1);
EXPECT_EQ(state.txSpeed.width, -1);
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetStateIsCalledAndfPortStatusIsFailedReturnsSuccess) {
zes_fabric_port_state_t state = {};
state.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES;
state.pNext = nullptr;
pMockIafNlApi->fPortStatus = ZES_FABRIC_PORT_STATUS_FAILED;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
EXPECT_EQ(state.stype, ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES);
EXPECT_EQ(state.pNext, nullptr);
EXPECT_EQ(state.status, ZES_FABRIC_PORT_STATUS_FAILED);
EXPECT_EQ(state.qualityIssues, 0U);
EXPECT_EQ(state.failureReasons, 0U);
EXPECT_EQ(state.remotePortId.fabricId, pMockIafNlApi->testPortId.fabricId);
EXPECT_EQ(state.remotePortId.attachId, pMockIafNlApi->testPortId.attachId);
EXPECT_EQ(state.remotePortId.portNumber, pMockIafNlApi->testPortId.portNumber + 1);
EXPECT_EQ(state.rxSpeed.bitRate, -1);
EXPECT_EQ(state.rxSpeed.width, -1);
EXPECT_EQ(state.txSpeed.bitRate, -1);
EXPECT_EQ(state.txSpeed.width, -1);
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetStateIsCalledAndfPortStatusIsDisabledReturnsSuccess) {
zes_fabric_port_state_t state = {};
state.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES;
state.pNext = nullptr;
pMockIafNlApi->fPortStatus = ZES_FABRIC_PORT_STATUS_DISABLED;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
EXPECT_EQ(state.stype, ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES);
EXPECT_EQ(state.pNext, nullptr);
EXPECT_EQ(state.status, ZES_FABRIC_PORT_STATUS_DISABLED);
EXPECT_EQ(state.qualityIssues, 0U);
EXPECT_EQ(state.failureReasons, 0U);
EXPECT_EQ(state.rxSpeed.bitRate, -1);
EXPECT_EQ(state.rxSpeed.width, -1);
EXPECT_EQ(state.txSpeed.bitRate, -1);
EXPECT_EQ(state.txSpeed.width, -1);
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetStateIsCalledAndfPortStatusIsUnknownReturnsSuccess) {
zes_fabric_port_state_t state = {};
state.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES;
state.pNext = nullptr;
pMockIafNlApi->fPortStatus = ZES_FABRIC_PORT_STATUS_UNKNOWN;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
EXPECT_EQ(state.stype, ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES);
EXPECT_EQ(state.pNext, nullptr);
EXPECT_EQ(state.status, ZES_FABRIC_PORT_STATUS_UNKNOWN);
EXPECT_EQ(state.qualityIssues, 0U);
EXPECT_EQ(state.failureReasons, 0U);
EXPECT_EQ(state.remotePortId.fabricId, 0U);
EXPECT_EQ(state.remotePortId.attachId, 0U);
EXPECT_EQ(state.remotePortId.portNumber, 0U);
EXPECT_EQ(state.rxSpeed.bitRate, -1);
EXPECT_EQ(state.rxSpeed.width, -1);
EXPECT_EQ(state.txSpeed.bitRate, -1);
EXPECT_EQ(state.txSpeed.width, -1);
}
TEST_F(SysmanFabricDeviceFixture, GivenPortStatusFailedWhenGetStateIsCalledThenVerifyFailureReasonsAreAsExpected) {
zes_fabric_port_state_t state = {};
state.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES;
state.pNext = nullptr;
pMockIafNlApi->fPortStatus = ZES_FABRIC_PORT_STATUS_FAILED;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
EXPECT_EQ(state.status, ZES_FABRIC_PORT_STATUS_FAILED);
EXPECT_EQ(state.failureReasons, 0U);
pMockIafNlApi->mockPortState.failed = 1;
pMockIafNlApi->mockPortState.isolated = 1;
pMockIafNlApi->mockPortState.linkDown = 1;
pMockIafNlApi->mockPortState.didNotTrain = 1;
pMockIafNlApi->mockPortState.flapping = 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
EXPECT_EQ(ZES_FABRIC_PORT_FAILURE_FLAG_FAILED, state.failureReasons & ZES_FABRIC_PORT_FAILURE_FLAG_FAILED);
EXPECT_EQ(ZES_FABRIC_PORT_FAILURE_FLAG_TRAINING_TIMEOUT, state.failureReasons & ZES_FABRIC_PORT_FAILURE_FLAG_TRAINING_TIMEOUT);
EXPECT_EQ(ZES_FABRIC_PORT_FAILURE_FLAG_FLAPPING, state.failureReasons & ZES_FABRIC_PORT_FAILURE_FLAG_FLAPPING);
pMockIafNlApi->mockPortState.failed = 1;
pMockIafNlApi->mockPortState.isolated = 0;
pMockIafNlApi->mockPortState.linkDown = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
EXPECT_EQ(ZES_FABRIC_PORT_FAILURE_FLAG_FAILED, state.failureReasons & ZES_FABRIC_PORT_FAILURE_FLAG_FAILED);
pMockIafNlApi->mockPortState.failed = 0;
pMockIafNlApi->mockPortState.isolated = 1;
pMockIafNlApi->mockPortState.linkDown = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
EXPECT_EQ(ZES_FABRIC_PORT_FAILURE_FLAG_FAILED, state.failureReasons & ZES_FABRIC_PORT_FAILURE_FLAG_FAILED);
pMockIafNlApi->mockPortState.failed = 0;
pMockIafNlApi->mockPortState.isolated = 0;
pMockIafNlApi->mockPortState.linkDown = 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
EXPECT_EQ(ZES_FABRIC_PORT_FAILURE_FLAG_FAILED, state.failureReasons & ZES_FABRIC_PORT_FAILURE_FLAG_FAILED);
}
TEST_F(SysmanFabricDeviceFixture, GivenPortStatusDegradedWhenGetStateIsCalledThenVerifyQualityIssuesAreAsExpected) {
zes_fabric_port_state_t state = {};
state.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES;
state.pNext = nullptr;
pMockIafNlApi->fPortStatus = ZES_FABRIC_PORT_STATUS_DEGRADED;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
EXPECT_EQ(state.status, ZES_FABRIC_PORT_STATUS_DEGRADED);
EXPECT_EQ(state.failureReasons, 0U);
pMockIafNlApi->mockPortState.lqi = 1;
pMockIafNlApi->mockPortState.lwd = 1;
pMockIafNlApi->mockPortState.rate = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
EXPECT_EQ(ZES_FABRIC_PORT_QUAL_ISSUE_FLAG_LINK_ERRORS, state.qualityIssues & ZES_FABRIC_PORT_QUAL_ISSUE_FLAG_LINK_ERRORS);
EXPECT_EQ(ZES_FABRIC_PORT_QUAL_ISSUE_FLAG_SPEED, state.qualityIssues & ZES_FABRIC_PORT_QUAL_ISSUE_FLAG_SPEED);
pMockIafNlApi->mockPortState.lwd = 0;
pMockIafNlApi->mockPortState.rate = 1;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
EXPECT_EQ(ZES_FABRIC_PORT_QUAL_ISSUE_FLAG_SPEED, state.qualityIssues & ZES_FABRIC_PORT_QUAL_ISSUE_FLAG_SPEED);
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetStateIsCalledWhenFPortStatusQueryFailsReturnsError) {
pMockIafNlApi->mockfPortStatusQueryReturnStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_state_t state;
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, pFabricDeviceAccess->getState(testPortId, state));
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetStateIsCalledWhenFPortPropertiesQueryFailsReturnsError) {
pMockIafNlApi->mockfportPropertiesReturnStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_state_t state;
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, pFabricDeviceAccess->getState(testPortId, state));
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetStateIsCalledWhenDeviceEnumFailsThenGetStateReturnsSuccess) {
pMockIafNlApi->mockdeviceEnumReturnStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_state_t state;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetStateIsCalledWhenFabricDevicePropertiesFailsThenGetStateReturnsSuccess) {
pMockIafNlApi->mockfabricDevicePropertiesReturnStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_state_t state;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetStateIsCalledWhenSubDevicePropertiesGetFailsThenGetStateReturnsSuccess) {
pMockIafNlApi->mocksubdevicePropertiesGetReturnStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_state_t state;
EXPECT_EQ(ZE_RESULT_SUCCESS, pFabricDeviceAccess->getState(testPortId, state));
}
TEST_F(SysmanFabricDeviceFixture, GivenFabricDeviceAccessNlWhenGetPortsCalledWithNoPortsAndInitMyPortGetNumSubDevicesFailsReturnsError) {
std::vector<zes_fabric_port_id_t> ports;
pMockIafNlApi->mockGetPortsResult = ZE_RESULT_ERROR_UNKNOWN;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFabricDeviceAccess->getPorts(ports));
}
} // namespace ult
} // namespace L0

577
level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_sysman_fabric_port_prelim.cpp Normal file
View File

@@ -0,0 +1,577 @@
/*
* Copyright (C) 2020-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "level_zero/tools/test/unit_tests/sources/sysman/linux/mock_sysman_fixture.h"
#include "level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "sysman/fabric_port/fabric_port_imp.h"
#include "sysman/fabric_port/linux/fabric_device_access_imp.h"
#include "sysman/fabric_port/linux/os_fabric_port_imp_prelim.h"
#include <limits>
extern bool sysmanUltsEnable;
using ::testing::Invoke;
using ::testing::Matcher;
using ::testing::Return;
namespace L0 {
namespace ult {
constexpr auto maxNumPorts = 32u;
class PublicFabricDeviceAccessNl : public FabricDeviceAccessNl {
public:
using FabricDeviceAccessNl::fabricPorts;
using FabricDeviceAccessNl::pIafNlApi;
};
class PublicLinuxFabricDeviceImp : public LinuxFabricDeviceImp {
public:
using LinuxFabricDeviceImp::pFabricDeviceAccess;
};
class PublicFabricDeviceImp : public FabricDeviceImp {
public:
using FabricDeviceImp::pOsFabricDevice;
};
class ZesFabricPortFixture : public SysmanDeviceFixture {
protected:
MockIafNlApi *pMockIafNlApi = nullptr;
FabricPortHandleContext *pFabricPortHandleContext = nullptr;
void SetUp() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
SysmanDeviceFixture::SetUp();
pFabricPortHandleContext = pSysmanDeviceImp->pFabricPortHandleContext;
if (nullptr != pFabricPortHandleContext->pFabricDevice) {
for (FabricPort *pFabricPort : pFabricPortHandleContext->handleList) {
delete pFabricPort;
}
pFabricPortHandleContext->handleList.clear();
delete pFabricPortHandleContext->pFabricDevice;
pFabricPortHandleContext->pFabricDevice = nullptr;
}
pFabricPortHandleContext->pFabricDevice = new FabricDeviceImp(pOsSysman);
PublicLinuxFabricDeviceImp *pPublicLinuxFabricDeviceImp = reinterpret_cast<PublicLinuxFabricDeviceImp *>(pFabricPortHandleContext->pFabricDevice->getOsFabricDevice());
PublicFabricDeviceAccessNl *pPublicFabricDeviceAccessNl = reinterpret_cast<PublicFabricDeviceAccessNl *>(pPublicLinuxFabricDeviceImp->pFabricDeviceAccess);
delete pPublicFabricDeviceAccessNl->pIafNlApi;
pMockIafNlApi = new MockIafNlApi;
pPublicFabricDeviceAccessNl->pIafNlApi = pMockIafNlApi;
pPublicFabricDeviceAccessNl->fabricPorts.clear();
setupDefaults();
}
void TearDown() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
SysmanDeviceFixture::TearDown();
}
void setupDefaults();
};
void ZesFabricPortFixture::setupDefaults() {
pMockIafNlApi->validateParams = false;
}
TEST_F(ZesFabricPortFixture, GivenFabricDeviceImpValidatepOsFabricDevice) {
PublicFabricDeviceImp *pPublicFabricDeviceImp = reinterpret_cast<PublicFabricDeviceImp *>(pFabricPortHandleContext->pFabricDevice);
PublicLinuxFabricDeviceImp *pPublicLinuxFabricDeviceImp = reinterpret_cast<PublicLinuxFabricDeviceImp *>(pPublicFabricDeviceImp->pOsFabricDevice);
EXPECT_EQ(pFabricPortHandleContext->pFabricDevice->getOsFabricDevice(), pPublicLinuxFabricDeviceImp);
}
TEST_F(ZesFabricPortFixture, GivenPortCountZeroAndValidHandlePtrWhenCallingZesFabricPortGetThenCountIsReturnedAndNoHandlesReturnedAndVerifyZesFabricPortGetCallSucceeds) {
uint32_t count = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumFabricPorts(device, &count, NULL));
if (nullptr != pFabricPortHandleContext->pFabricDevice) {
for (FabricPort *pFabricPort : pFabricPortHandleContext->handleList) {
delete pFabricPort;
}
pFabricPortHandleContext->handleList.clear();
}
pMockIafNlApi->numPorts = 0U;
count = pMockIafNlApi->numPorts;
zes_fabric_port_handle_t handle = static_cast<zes_fabric_port_handle_t>(0UL);
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, &handle);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
EXPECT_EQ(handle, static_cast<zes_fabric_port_handle_t>(0UL));
}
TEST_F(ZesFabricPortFixture, GivenPortCountCorrectWhenCallingZesFabricPortGetThenCountHandlesAreReturnedAndAndVerifyZesFabricPortGetCallSucceeds) {
pMockIafNlApi->numPorts = 1U;
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
}
TEST_F(ZesFabricPortFixture, GivenPortCountGreaterThanPortsWhenCallingZesFabricPortGetThenCorrectCountIsReturnedAndAndVerifyZesFabricPortGetCallSucceeds) {
uint32_t count = pMockIafNlApi->numPorts + 1U;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
}
TEST_F(ZesFabricPortFixture, GivenPortCounLessThanPortsWhenCallingZesFabricPortGetThenCountLessThenPortsHandlesAreReturned) {
uint32_t count = pMockIafNlApi->numPorts - 1U;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts - 1U);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortGetPropertiesThenZesFabricPortGetPropertiesCallSucceeds) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
zes_fabric_port_properties_t properties;
// Initialize values
properties.onSubdevice = true;
properties.subdeviceId = std::numeric_limits<uint32_t>::max();
std::memset(properties.model, std::numeric_limits<int8_t>::max(), ZES_MAX_FABRIC_PORT_MODEL_SIZE);
properties.portId.fabricId = std::numeric_limits<uint32_t>::max();
properties.portId.attachId = std::numeric_limits<uint32_t>::max();
properties.portId.portNumber = std::numeric_limits<uint8_t>::max();
properties.maxRxSpeed.bitRate = std::numeric_limits<int64_t>::max();
properties.maxRxSpeed.width = std::numeric_limits<int32_t>::max();
properties.maxTxSpeed.bitRate = std::numeric_limits<int64_t>::max();
properties.maxTxSpeed.width = std::numeric_limits<int32_t>::max();
uint8_t portNumberIndex = pMockIafNlApi->testPortId.portNumber - 1U;
if (1U == pMockIafNlApi->testPortId.attachId) {
portNumberIndex += pMockIafNlApi->portsPerSubdevice;
}
result = zesFabricPortGetProperties(hPorts[portNumberIndex], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_TRUE(properties.onSubdevice);
EXPECT_EQ(pMockIafNlApi->testPortId.attachId, properties.subdeviceId);
EXPECT_STREQ("XeLink", properties.model);
EXPECT_EQ(pMockIafNlApi->testPortId.fabricId, properties.portId.fabricId);
EXPECT_EQ(pMockIafNlApi->testPortId.attachId, properties.portId.attachId);
EXPECT_EQ(pMockIafNlApi->testPortId.portNumber, properties.portId.portNumber);
EXPECT_EQ(-1L, properties.maxRxSpeed.bitRate);
EXPECT_EQ(-1, properties.maxRxSpeed.width);
EXPECT_EQ(-1L, properties.maxTxSpeed.bitRate);
EXPECT_EQ(-1, properties.maxTxSpeed.width);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortGetLinkTypeThenZesFabricPortGetLinkTypeCallSucceeds) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
for (auto i = 0U; i < count; i++) {
zes_fabric_link_type_t linkType;
result = zesFabricPortGetLinkType(hPorts[i], &linkType);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_STREQ("XeLink", linkType.desc);
}
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortGetConfigThenZesFabricPortGetConfigCallSucceeds) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
for (auto i = 0U; i < count; i++) {
pMockIafNlApi->portEnabled = false;
pMockIafNlApi->portBeaconing = false;
zes_fabric_port_config_t getConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = true, .beaconing = true};
result = zesFabricPortGetConfig(hPorts[i], &getConfig);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_FALSE(getConfig.enabled);
EXPECT_FALSE(getConfig.beaconing);
}
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortSetConfigAndEnabledTrueAndBeaconingTrueThenZesFabricPortGetConfigCallSucceeds) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
for (auto i = 0U; i < count; i++) {
pMockIafNlApi->portEnabled = false;
pMockIafNlApi->portBeaconing = false;
zes_fabric_port_config_t setConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = true, .beaconing = true};
result = zesFabricPortSetConfig(hPorts[i], &setConfig);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
for (auto i = 0U; i < count; i++) {
zes_fabric_port_config_t getConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = false, .beaconing = false};
result = zesFabricPortGetConfig(hPorts[i], &getConfig);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_TRUE(getConfig.enabled);
EXPECT_TRUE(getConfig.beaconing);
}
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortSetConfigAndEnabledFalseAndBeaconingFalseThenZesFabricPortGetConfigCallSucceeds) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
for (auto i = 0U; i < count; i++) {
pMockIafNlApi->portEnabled = true;
pMockIafNlApi->portBeaconing = true;
zes_fabric_port_config_t setConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = false, .beaconing = false};
result = zesFabricPortSetConfig(hPorts[i], &setConfig);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
for (auto i = 0U; i < count; i++) {
zes_fabric_port_config_t getConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = true, .beaconing = true};
result = zesFabricPortGetConfig(hPorts[i], &getConfig);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_FALSE(getConfig.enabled);
EXPECT_FALSE(getConfig.beaconing);
}
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortSetConfigAndEnabledAlreadyTrueAndBeaconingAlreadyTrueThenZesFabricPortGetConfigCallSucceeds) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
for (auto i = 0U; i < count; i++) {
pMockIafNlApi->portEnabled = true;
pMockIafNlApi->portBeaconing = true;
zes_fabric_port_config_t setConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = true, .beaconing = true};
result = zesFabricPortSetConfig(hPorts[i], &setConfig);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
}
for (auto i = 0U; i < count; i++) {
zes_fabric_port_config_t getConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = true, .beaconing = true};
result = zesFabricPortGetConfig(hPorts[i], &getConfig);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_TRUE(getConfig.enabled);
EXPECT_TRUE(getConfig.beaconing);
}
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortSetConfigAndEnabledAlreadyTrueAndBeaconingAlreadyTrueAndGetPortBeaconStateFailsThenZesFabricPortGetConfigCallFails) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
pMockIafNlApi->portEnabled = true;
pMockIafNlApi->portBeaconing = true;
pMockIafNlApi->mockportBeaconStateQueryReturnStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_config_t setConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = true, .beaconing = true};
result = zesFabricPortSetConfig(hPorts[0], &setConfig);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortSetConfigAndEnabledTrueAndBeaconingTrueAndEnablePortFailsThenZesFabricPortGetConfigCallFails) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
pMockIafNlApi->portEnabled = false;
pMockIafNlApi->portBeaconing = false;
pMockIafNlApi->mockportEnableReturnStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_config_t setConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = true, .beaconing = true};
result = zesFabricPortSetConfig(hPorts[0], &setConfig);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortSetConfigAndEnabledFalseAndBeaconingFalseAndPortUsageDisableFailsThenZesFabricPortGetConfigCallFails) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
pMockIafNlApi->portEnabled = true;
pMockIafNlApi->portBeaconing = true;
pMockIafNlApi->mockportUsageDisableReturnStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_config_t setConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = false, .beaconing = false};
result = zesFabricPortSetConfig(hPorts[0], &setConfig);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortSetConfigAndEnabledFalseAndBeaconingFalseAndDisableFailsThenZesFabricPortGetConfigCallFails) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
pMockIafNlApi->portEnabled = true;
pMockIafNlApi->portBeaconing = true;
pMockIafNlApi->mockportDisableReturnStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_config_t setConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = false, .beaconing = false};
result = zesFabricPortSetConfig(hPorts[0], &setConfig);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortSetConfigAndEnabledFalseAndBeaconingFalseAndEnableUsageFailsThenZesFabricPortGetConfigCallFails) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
pMockIafNlApi->portEnabled = true;
pMockIafNlApi->portBeaconing = true;
pMockIafNlApi->mockportUsageEnableReturnStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_config_t setConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = false, .beaconing = false};
result = zesFabricPortSetConfig(hPorts[0], &setConfig);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortSetConfigAndEnabledTrueAndBeaconingFalseAndEnableUsageFailsThenZesFabricPortGetConfigCallFails) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
pMockIafNlApi->portEnabled = false;
pMockIafNlApi->portBeaconing = true;
pMockIafNlApi->mockportStateQueryReturnStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_config_t setConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = false, .beaconing = false};
result = zesFabricPortSetConfig(hPorts[0], &setConfig);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortSetConfigAndEnabledTrueAndBeaconingTrueAndForceSweepFailsThenZesFabricPortGetConfigCallFails) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
pMockIafNlApi->portEnabled = false;
pMockIafNlApi->portBeaconing = false;
pMockIafNlApi->mockremRequestReturnStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_config_t setConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = true, .beaconing = true};
result = zesFabricPortSetConfig(hPorts[0], &setConfig);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortSetConfigAndEnabledTrueAndBeaconingTrueAndFirstRoutingQueryFailsThenZesFabricPortGetConfigCallFails) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
pMockIafNlApi->portEnabled = false;
pMockIafNlApi->portBeaconing = false;
pMockIafNlApi->mockroutingGenQueryReturnStatus.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
pMockIafNlApi->isRepeated = true;
zes_fabric_port_config_t setConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = true, .beaconing = true};
result = zesFabricPortSetConfig(hPorts[0], &setConfig);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortSetConfigAndEnabledTrueAndBeaconingTrueAndSecondRoutingQueryFailsThenZesFabricPortGetConfigCallFails) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
pMockIafNlApi->portEnabled = false;
pMockIafNlApi->portBeaconing = false;
pMockIafNlApi->mockroutingGenQueryReturnStatus.push_back(ZE_RESULT_SUCCESS);
pMockIafNlApi->mockroutingGenQueryReturnStatus.push_back(ZE_RESULT_ERROR_NOT_AVAILABLE);
pMockIafNlApi->isRepeated = true;
zes_fabric_port_config_t setConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = true, .beaconing = true};
result = zesFabricPortSetConfig(hPorts[0], &setConfig);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
}
TEST_F(ZesFabricPortFixture, GivenWhenCallingZesFabricPortGetConfigAndGetPortEnabledStateReturnsUnAvailableThenCallFails) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
pMockIafNlApi->mockportStateQueryReturnStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_config_t getConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = true, .beaconing = true};
result = zesFabricPortGetConfig(hPorts[0], &getConfig);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
}
TEST_F(ZesFabricPortFixture, GivenWhenCallingZesFabricPortGetConfigAndGetPortBeaconStateReturnsUnAvailableThenCallFails) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
pMockIafNlApi->mockportBeaconStateQueryReturnStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_config_t getConfig = {.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, .pNext = nullptr, .enabled = true, .beaconing = true};
result = zesFabricPortGetConfig(hPorts[0], &getConfig);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortGetStateThenZesFabricPortGetStateCallSucceeds) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
uint8_t portNumberIndex = pMockIafNlApi->testPortId.portNumber - 1U;
if (1U == pMockIafNlApi->testPortId.attachId) {
portNumberIndex += pMockIafNlApi->portsPerSubdevice;
}
zes_fabric_port_state_t state = {};
state.stype = ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES;
state.pNext = nullptr;
result = zesFabricPortGetState(hPorts[portNumberIndex], &state);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(ZES_STRUCTURE_TYPE_FABRIC_PORT_PROPERTIES, state.stype);
EXPECT_EQ(nullptr, state.pNext);
EXPECT_EQ(pMockIafNlApi->fPortStatus, state.status);
EXPECT_EQ(0U, state.qualityIssues);
EXPECT_EQ(0U, state.failureReasons);
EXPECT_EQ(pMockIafNlApi->testPortId.fabricId, state.remotePortId.fabricId);
EXPECT_EQ(pMockIafNlApi->testPortId.attachId, state.remotePortId.attachId);
EXPECT_EQ(pMockIafNlApi->testPortId.portNumber + 1, state.remotePortId.portNumber);
EXPECT_EQ(-1L, state.rxSpeed.bitRate);
EXPECT_EQ(-1, state.rxSpeed.width);
EXPECT_EQ(-1L, state.txSpeed.bitRate);
EXPECT_EQ(-1, state.txSpeed.width);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortGetThroughputThenZesFabricPortGetThroughputCallSucceeds) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
uint8_t portNumberIndex = pMockIafNlApi->testPortId.portNumber - 1U;
if (1U == pMockIafNlApi->testPortId.attachId) {
portNumberIndex += pMockIafNlApi->portsPerSubdevice;
}
zes_fabric_port_throughput_t throughput;
// Initialize values
throughput.timestamp = 0LU;
throughput.rxCounter = std::numeric_limits<uint64_t>::max();
throughput.txCounter = std::numeric_limits<uint64_t>::max();
result = zesFabricPortGetThroughput(hPorts[portNumberIndex], &throughput);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
// Timestamp is not provided by IafNlApi
EXPECT_EQ(pMockIafNlApi->rxCounter, throughput.rxCounter);
EXPECT_EQ(pMockIafNlApi->txCounter, throughput.txCounter);
}
} // namespace ult
} // namespace L0

10
level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/CMakeLists.txt
View File

@@ -14,7 +14,15 @@ if(UNIX)
${CMAKE_CURRENT_SOURCE_DIR}/mock_nl_dll.h
)
add_subdirectories()
if(NEO_ENABLE_i915_PRELIM_DETECTION)
list(APPEND L0_TESTS_TOOLS_SYSMAN_IAF_NLAPI_LINUX
${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_iaf_nl_api_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_nl_api_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_iaf_nl_api_prelim.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_nl_api_prelim.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_iaf_nl_api_prelim.h
)
endif()
target_sources(${TARGET_NAME}
PRIVATE

277
level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.cpp Normal file
View File

@@ -0,0 +1,277 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "mock_iaf_nl_api_prelim.h"
#include "sysman/linux/nl_api/iaf_nl_api.h"
namespace L0 {
namespace ult {
ze_result_t MockIafNlApi::fPortStatusQuery(const IafPortId portId, IafPortState &state) {
if (mockfPortStatusQueryReturnStatus != ZE_RESULT_SUCCESS) {
return mockfPortStatusQueryReturnStatus;
}
if (validateParams) {
EXPECT_EQ(portId.fabricId, testPortId.fabricId);
EXPECT_EQ(portId.attachId, testPortId.attachId);
EXPECT_EQ(portId.portNumber, testPortId.portNumber);
}
state = mockPortState;
state.healthStatus = _IAF_FPORT_HEALTH_COUNT;
switch (fPortStatus) {
case ZES_FABRIC_PORT_STATUS_HEALTHY:
state.healthStatus = IAF_FPORT_HEALTH_HEALTHY;
break;
case ZES_FABRIC_PORT_STATUS_DEGRADED:
state.healthStatus = IAF_FPORT_HEALTH_DEGRADED;
break;
case ZES_FABRIC_PORT_STATUS_FAILED:
state.healthStatus = IAF_FPORT_HEALTH_FAILED;
break;
case ZES_FABRIC_PORT_STATUS_DISABLED:
state.healthStatus = IAF_FPORT_HEALTH_OFF;
break;
default:
break;
}
return ZE_RESULT_SUCCESS;
}
ze_result_t MockIafNlApi::getThroughput(const IafPortId portId, IafPortThroughPut &throughput) {
if (validateParams) {
EXPECT_EQ(portId.fabricId, testPortId.fabricId);
EXPECT_EQ(portId.attachId, testPortId.attachId);
EXPECT_EQ(portId.portNumber, testPortId.portNumber);
}
// Timestamp is not provided by IafNlApi
throughput.rxCounter = rxCounter;
throughput.txCounter = txCounter;
return ZE_RESULT_SUCCESS;
}
ze_result_t MockIafNlApi::portStateQuery(const IafPortId portId, bool &enabled) {
if (mockportStateQueryReturnStatus != ZE_RESULT_SUCCESS) {
return mockportStateQueryReturnStatus;
}
if (validateParams) {
EXPECT_EQ(portId.fabricId, testPortId.fabricId);
EXPECT_EQ(portId.attachId, testPortId.attachId);
EXPECT_EQ(portId.portNumber, testPortId.portNumber);
}
enabled = portEnabled;
return ZE_RESULT_SUCCESS;
}
ze_result_t MockIafNlApi::portBeaconStateQuery(const IafPortId portId, bool &enabled) {
if (mockportBeaconStateQueryReturnStatus != ZE_RESULT_SUCCESS) {
return mockportBeaconStateQueryReturnStatus;
}
if (validateParams) {
EXPECT_EQ(portId.fabricId, testPortId.fabricId);
EXPECT_EQ(portId.attachId, testPortId.attachId);
EXPECT_EQ(portId.portNumber, testPortId.portNumber);
}
enabled = portBeaconing;
return ZE_RESULT_SUCCESS;
}
ze_result_t MockIafNlApi::portBeaconEnable(const IafPortId portId) {
if (validateParams) {
EXPECT_EQ(portId.fabricId, testPortId.fabricId);
EXPECT_EQ(portId.attachId, testPortId.attachId);
EXPECT_EQ(portId.portNumber, testPortId.portNumber);
}
portBeaconing = true;
return ZE_RESULT_SUCCESS;
}
ze_result_t MockIafNlApi::portBeaconDisable(const IafPortId portId) {
if (validateParams) {
EXPECT_EQ(portId.fabricId, testPortId.fabricId);
EXPECT_EQ(portId.attachId, testPortId.attachId);
EXPECT_EQ(portId.portNumber, testPortId.portNumber);
}
portBeaconing = false;
return ZE_RESULT_SUCCESS;
}
ze_result_t MockIafNlApi::portEnable(const IafPortId portId) {
if (mockportEnableReturnStatus != ZE_RESULT_SUCCESS) {
return mockportEnableReturnStatus;
}
if (validateParams) {
EXPECT_EQ(portId.fabricId, testPortId.fabricId);
EXPECT_EQ(portId.attachId, testPortId.attachId);
EXPECT_EQ(portId.portNumber, testPortId.portNumber);
}
portEnabled = true;
return ZE_RESULT_SUCCESS;
}
ze_result_t MockIafNlApi::portDisable(const IafPortId portId) {
if (mockportDisableReturnStatus != ZE_RESULT_SUCCESS) {
return mockportDisableReturnStatus;
}
if (validateParams) {
EXPECT_EQ(portId.fabricId, testPortId.fabricId);
EXPECT_EQ(portId.attachId, testPortId.attachId);
EXPECT_EQ(portId.portNumber, testPortId.portNumber);
}
portEnabled = false;
return ZE_RESULT_SUCCESS;
}
ze_result_t MockIafNlApi::portUsageEnable(const IafPortId portId) {
if (mockportUsageEnableReturnStatus != ZE_RESULT_SUCCESS) {
return mockportUsageEnableReturnStatus;
}
if (validateParams) {
EXPECT_EQ(portId.fabricId, testPortId.fabricId);
EXPECT_EQ(portId.attachId, testPortId.attachId);
EXPECT_EQ(portId.portNumber, testPortId.portNumber);
}
return ZE_RESULT_SUCCESS;
}
ze_result_t MockIafNlApi::portUsageDisable(const IafPortId portId) {
if (mockportUsageDisableReturnStatus != ZE_RESULT_SUCCESS) {
return mockportUsageDisableReturnStatus;
}
if (validateParams) {
EXPECT_EQ(portId.fabricId, testPortId.fabricId);
EXPECT_EQ(portId.attachId, testPortId.attachId);
EXPECT_EQ(portId.portNumber, testPortId.portNumber);
}
return ZE_RESULT_SUCCESS;
}
ze_result_t MockIafNlApi::remRequest() {
if (mockremRequestReturnStatus != ZE_RESULT_SUCCESS) {
return mockremRequestReturnStatus;
}
genStart += 5;
return ZE_RESULT_SUCCESS;
}
ze_result_t MockIafNlApi::routingGenQuery(uint32_t &start, uint32_t &end) {
ze_result_t result = ZE_RESULT_SUCCESS;
if (!mockroutingGenQueryReturnStatus.empty()) {
result = mockroutingGenQueryReturnStatus.front();
if (isRepeated != true || result == ZE_RESULT_SUCCESS) {
mockroutingGenQueryReturnStatus.erase(mockroutingGenQueryReturnStatus.begin());
}
}
start = genStart;
end = ++genEnd;
return result;
}
ze_result_t MockIafNlApi::deviceEnum(std::vector<uint32_t> &fabricIds) {
if (mockdeviceEnumReturnStatus != ZE_RESULT_SUCCESS) {
return mockdeviceEnumReturnStatus;
}
fabricIds.clear();
for (auto i = 0U; i < fabricIdCount; i++) {
fabricIds.push_back(testPortId.fabricId + i);
}
return ZE_RESULT_SUCCESS;
}
ze_result_t MockIafNlApi::fabricDeviceProperties(const uint32_t fabricId, uint32_t &numSubdevices) {
if (mockfabricDevicePropertiesReturnStatus != ZE_RESULT_SUCCESS) {
return mockfabricDevicePropertiesReturnStatus;
}
if (validateParams) {
EXPECT_NE(0U, fabricId);
}
numSubdevices = subDeviceCount;
return ZE_RESULT_SUCCESS;
}
ze_result_t MockIafNlApi::subdevicePropertiesGet(const uint32_t fabricId, const uint32_t attachId, uint64_t &guid, std::vector<uint8_t> &ports) {
if (mocksubdevicePropertiesGetReturnStatus != ZE_RESULT_SUCCESS) {
return mocksubdevicePropertiesGetReturnStatus;
}
if (validateParams) {
EXPECT_NE(0U, fabricId);
EXPECT_LT(attachId, 2U);
}
ports.clear();
for (auto i = 0U; i < 8U; i++) {
ports.push_back(i + 1);
}
guid = constructGuid(fabricId, attachId);
return ZE_RESULT_SUCCESS;
}
ze_result_t MockIafNlApi::fportProperties(const IafPortId portId, uint64_t &neighborGuid, uint8_t &neighborPortNumber,
IafPortSpeed &maxRxSpeed, IafPortSpeed &maxTxSpeed,
IafPortSpeed &rxSpeed, IafPortSpeed &txSpeed) {
if (mockfportPropertiesReturnStatus != ZE_RESULT_SUCCESS) {
return mockfportPropertiesReturnStatus;
}
if (validateParams) {
EXPECT_EQ(portId.fabricId, testPortId.fabricId);
EXPECT_EQ(portId.attachId, testPortId.attachId);
EXPECT_EQ(portId.portNumber, testPortId.portNumber);
}
neighborGuid = constructGuid(portId.fabricId, portId.attachId);
neighborPortNumber = portId.portNumber + 1;
maxRxSpeed.bitRate = -1;
maxRxSpeed.width = -1;
maxTxSpeed.bitRate = -1;
maxTxSpeed.width = -1;
rxSpeed.bitRate = -1;
rxSpeed.width = -1;
txSpeed.bitRate = -1;
txSpeed.width = -1;
return ZE_RESULT_SUCCESS;
}
} // namespace ult
} // namespace L0

116
level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.h Normal file
View File

@@ -0,0 +1,116 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "gmock/gmock.h"
#include "sysman/linux/nl_api/iaf_nl_api.h"
#include <sstream>
namespace L0 {
namespace ult {
class MockIafNlApi : public IafNlApi {
public:
std::vector<ze_result_t> mockroutingGenQueryReturnStatus{};
ze_result_t mockfPortStatusQueryReturnStatus = ZE_RESULT_SUCCESS;
ze_result_t mockfportPropertiesReturnStatus = ZE_RESULT_SUCCESS;
ze_result_t mockdeviceEnumReturnStatus = ZE_RESULT_SUCCESS;
ze_result_t mockfabricDevicePropertiesReturnStatus = ZE_RESULT_SUCCESS;
ze_result_t mocksubdevicePropertiesGetReturnStatus = ZE_RESULT_SUCCESS;
ze_result_t mockportBeaconStateQueryReturnStatus = ZE_RESULT_SUCCESS;
ze_result_t mockportEnableReturnStatus = ZE_RESULT_SUCCESS;
ze_result_t mockportUsageEnableReturnStatus = ZE_RESULT_SUCCESS;
ze_result_t mockportUsageDisableReturnStatus = ZE_RESULT_SUCCESS;
ze_result_t mockportDisableReturnStatus = ZE_RESULT_SUCCESS;
ze_result_t mockportStateQueryReturnStatus = ZE_RESULT_SUCCESS;
ze_result_t mockremRequestReturnStatus = ZE_RESULT_SUCCESS;
bool isRepeated = false;
ze_result_t getPorts(const std::string &devicePciPath, std::vector<IafPort> &ports) override {
IafPort defaultPort;
defaultPort.onSubdevice = true;
defaultPort.portId.fabricId = testPortId.fabricId;
defaultPort.portId.attachId = testPortId.attachId;
defaultPort.portId.portNumber = testPortId.portNumber;
defaultPort.model = "XeLink";
defaultPort.maxRxSpeed.width = -1;
defaultPort.maxRxSpeed.bitRate = -1;
defaultPort.maxTxSpeed.width = -1;
defaultPort.maxTxSpeed.bitRate = -1;
if (mockPorts.size() == 0) {
for (uint32_t i = 0; i < numPorts; i++) {
mockPorts.push_back(defaultPort);
}
}
ports = mockPorts;
return mockGetPortsResult;
}
ze_result_t fPortStatusQuery(const IafPortId portId, IafPortState &state) override;
ze_result_t getThroughput(const IafPortId portId, IafPortThroughPut &throughput) override;
ze_result_t portStateQuery(const IafPortId portId, bool &enabled) override;
ze_result_t portBeaconStateQuery(const IafPortId portId, bool &enabled) override;
ze_result_t portBeaconEnable(const IafPortId portId) override;
ze_result_t portBeaconDisable(const IafPortId portId) override;
ze_result_t portEnable(const IafPortId portId) override;
ze_result_t portDisable(const IafPortId portId) override;
ze_result_t portUsageEnable(const IafPortId portId) override;
ze_result_t portUsageDisable(const IafPortId portId) override;
ze_result_t remRequest() override;
ze_result_t routingGenQuery(uint32_t &start, uint32_t &end) override;
ze_result_t deviceEnum(std::vector<uint32_t> &fabricIds) override;
ze_result_t fabricDeviceProperties(const uint32_t fabricId, uint32_t &numSubdevices) override;
ze_result_t subdevicePropertiesGet(const uint32_t fabricId, const uint32_t attachId, uint64_t &guid, std::vector<uint8_t> &ports) override;
ze_result_t fportProperties(const IafPortId portId, uint64_t &neighborGuid, uint8_t &neighborPortNumber,
IafPortSpeed &maxRxSpeed, IafPortSpeed &maxTxSpeed,
IafPortSpeed &rxSpeed, IafPortSpeed &txSpeed) override;
bool validateParams = true;
static constexpr uint32_t defaultFabricId = 0x10000000U;
static constexpr IafPortId testPortId{defaultFabricId, 0x1U, 7};
static const uint32_t fabricIdCount = 6;
std::vector<uint32_t> testFabricIds;
uint32_t portsPerSubdevice = 8U;
uint32_t subDeviceCount = 2U;
uint32_t numPorts = subDeviceCount * portsPerSubdevice;
uint64_t timeStamp = 100000000UL;
uint64_t rxCounter = 100000000UL; // Any non-zero, non-maxlongint value
uint64_t txCounter = 200000000UL; // Any non-zero, non-maxlongint value
zes_fabric_port_status_t fPortStatus = ZES_FABRIC_PORT_STATUS_HEALTHY;
uint64_t constructGuid(const uint32_t fabricId, const uint32_t attachId) {
union {
uint32_t u32[2];
uint64_t u64;
} s;
s.u32[0] = fabricId;
s.u32[1] = attachId;
return s.u64;
}
bool portEnabled = true;
bool portBeaconing = true;
uint32_t genStart = 0;
uint32_t genEnd = 0;
std::vector<IafPort> mockPorts = {};
ze_result_t mockGetPortsResult = ZE_RESULT_SUCCESS;
IafPortState mockPortState = {};
};
} // namespace ult
} // namespace L0

498
level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_nl_api_prelim.cpp Normal file
View File

@@ -0,0 +1,498 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "mock_nl_api_prelim.h"
#include "sysman/linux/nl_api/iaf_nl_api.h"
namespace L0 {
namespace ult {
void MockNlApi::validateId(bool checkFabricId, bool checkAttachId, bool checkPortNumber) {
uint64_t fabricId = 0UL;
uint64_t attachId = 0UL;
uint64_t portNumber = 0UL;
if (checkFabricId) {
fabricId = MockNlApi::testPortId.fabricId;
EXPECT_EQ(attribs[IAF_ATTR_FABRIC_ID], fabricId);
}
if (checkAttachId) {
attachId = MockNlApi::testPortId.attachId;
EXPECT_EQ(attribs[IAF_ATTR_SD_INDEX], attachId);
}
if (checkPortNumber) {
portNumber = MockNlApi::testPortId.portNumber;
EXPECT_EQ(attribs[IAF_ATTR_FABRIC_PORT_NUMBER], portNumber);
}
}
MyNlattr *MockNlApi::copyId(struct genl_info &info, MyNlattr *next, bool copyFabricId, bool copyAttachId, bool copyPortNumber) {
if (copyFabricId) {
next = addAttrib(info, next, IAF_ATTR_FABRIC_ID, attribs[IAF_ATTR_FABRIC_ID]);
}
if (copyAttachId) {
next = addAttrib(info, next, IAF_ATTR_SD_INDEX, attribs[IAF_ATTR_SD_INDEX]);
}
if (copyPortNumber) {
next = addAttrib(info, next, IAF_ATTR_FABRIC_PORT_NUMBER, attribs[IAF_ATTR_FABRIC_PORT_NUMBER]);
}
return next;
}
MyNlattr *MockNlApi::addAttrib(struct genl_info &info, MyNlattr *next, uint16_t type, uint64_t content) {
next->type = type;
next->content = content;
if (nullptr == info.attrs[type]) {
info.attrs[type] = reinterpret_cast<struct nlattr *>(next);
}
return next->addNext();
}
MyNlattr *MockNlApi::addNested(struct genl_info &info, MyNlattr *next, uint16_t type, MyNlattr *nested) {
next->type = type;
next->nested = nested;
return next->addNext();
}
MyNlattr *MockNlApi::addDefaultAttribs(struct genl_info &info, MyNlattr *next) {
if (true == cmdMakeContextNotPresent) {
cmdMakeContextNotPresent = false;
} else {
next = addAttrib(info, next, IAF_ATTR_CMD_OP_CONTEXT, cmdMakeContextNotMatch ? 0 : attribs[IAF_ATTR_CMD_OP_CONTEXT]);
}
if (_IAF_CMD_MSG_TYPE_COUNT != cmdMsgType) {
next = addAttrib(info, next, IAF_ATTR_CMD_OP_MSG_TYPE, cmdMsgType);
}
if (_IAF_CMD_RSP_COUNT != cmdRspRslt) {
next = addAttrib(info, next, IAF_ATTR_CMD_OP_RESULT, cmdRspRslt);
}
return next;
}
MyNlattr *MockNlApi::addPort(struct genl_info &info, MyNlattr *next, zes_fabric_port_id_t *port) {
next = addAttrib(info, next, IAF_ATTR_FABRIC_ID, port->fabricId);
next = addAttrib(info, next, IAF_ATTR_SD_INDEX, port->attachId);
next = addAttrib(info, next, IAF_ATTR_FABRIC_PORT_NUMBER, port->portNumber);
return next;
}
void *MockNlApi::genlmsgPut(struct nl_msg *msg, uint32_t port, uint32_t seq, int family, int hdrlen, int flags, uint8_t cmd, uint8_t version) {
if (!mockGenlmsgPutReturnValue.empty()) {
void *returnPtr = mockGenlmsgPutReturnValue.front();
if (isRepeated != true) {
mockGenlmsgPutReturnValue.erase(mockGenlmsgPutReturnValue.begin());
}
return returnPtr;
}
for (int i = 0; i < pOps->o_ncmds; i++) {
if (pOps->o_cmds[i].c_id == cmd) {
cmdIndex = i;
}
}
return &pOps->o_cmds[cmdIndex];
}
int MockNlApi::genlHandleMsg(struct nl_msg *msg, void *arg) {
struct genl_info info;
MyNlattr *head = new MyNlattr;
MyNlattr *next = head;
info.attrs = new struct nlattr *[pOps->o_cmds[cmdIndex].c_maxattr];
for (auto i = 0; i < pOps->o_cmds[cmdIndex].c_maxattr; i++) {
info.attrs[i] = nullptr;
}
next = addDefaultAttribs(info, next);
switch (pOps->o_cmds[cmdIndex].c_id) {
case IAF_CMD_OP_FPORT_STATUS_QUERY:
validateId(true, true, true);
for (auto i = 0U; i < 1; i++) {
MyNlattr *nested = new MyNlattr;
MyNlattr *nextNested = nested;
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_HEALTH, fportHealth);
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_ISSUE_LQI, fportIssueLqi);
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_ISSUE_LWD, fportIssueLwd);
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_ISSUE_RATE, fportIssueRate);
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_ERROR_FAILED, fportReasonFailed);
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_ERROR_ISOLATED, fportReasonIsolated);
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_ERROR_LINK_DOWN, fportReasonLinkDown);
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_ERROR_FLAPPING, fportReasonFlapping);
addAttrib(info, nextNested, IAF_ATTR_FPORT_ERROR_DID_NOT_TRAIN, fportReasonDidNotTrain);
next = addNested(info, next, IAF_ATTR_FABRIC_PORT, nested);
}
break;
case IAF_CMD_OP_FABRIC_DEVICE_PROPERTIES:
validateId(true, false, false);
if (true == addSubDeviceCount) {
addAttrib(info, next, IAF_ATTR_SUBDEVICE_COUNT, 2);
}
break;
case IAF_CMD_OP_FPORT_PROPERTIES:
validateId(true, false, false);
for (auto i = 0U; i < 1; i++) {
MyNlattr *nested = new MyNlattr;
MyNlattr *nextNested = nested;
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_NEIGHBOR_GUID, testGuid);
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_NEIGHBOR_PORT_NUMBER, testPortId.portNumber);
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_LINK_WIDTH_ENABLED, useInvalidWidth ? 0 : linkWidth1x);
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_LINK_WIDTH_ACTIVE, useInvalidWidth ? 0 : linkWidth2x);
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_BPS_LINK_SPEED_ACTIVE, linkSpeed);
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_LINK_WIDTH_DOWNGRADE_RX_ACTIVE, useInvalidWidth ? 0 : linkWidth3x);
nextNested = addAttrib(info, nextNested, IAF_ATTR_FPORT_LINK_WIDTH_DOWNGRADE_TX_ACTIVE, useInvalidWidth ? 0 : linkWidth4x);
addAttrib(info, nextNested, IAF_ATTR_FPORT_BPS_LINK_SPEED_MAX, linkSpeed);
next = addNested(info, next, IAF_ATTR_FABRIC_PORT, nested);
}
break;
case IAF_CMD_OP_SUB_DEVICE_PROPERTIES_GET:
validateId(true, false, false);
if (true == addGUID) {
next = addAttrib(info, next, IAF_ATTR_GUID, testGuid);
}
next = addAttrib(info, next, IAF_ATTR_EXTENDED_PORT_COUNT, 13);
next = addAttrib(info, next, IAF_ATTR_FABRIC_PORT_COUNT, 8);
next = addAttrib(info, next, IAF_ATTR_SWITCH_LIFETIME, 12);
next = addAttrib(info, next, IAF_ATTR_ROUTING_MODE_SUPPORTED, 1);
next = addAttrib(info, next, IAF_ATTR_ROUTING_MODE_ENABLED, 1);
next = addAttrib(info, next, IAF_ATTR_EHHANCED_PORT_0_PRESENT, 1);
for (auto i = addPortZeroAndTypeDisconnected ? 0U : 1U; i <= 8U; i++) {
MyNlattr *nested = new MyNlattr;
MyNlattr *nextNested = nested;
nextNested = addAttrib(info, nextNested, IAF_ATTR_FABRIC_PORT_NUMBER, i);
addAttrib(info, nextNested, IAF_ATTR_FABRIC_PORT_TYPE, addPortZeroAndTypeDisconnected ? IAF_FPORT_TYPE_DISCONNECTED : IAF_FPORT_TYPE_FIXED);
next = addNested(info, next, IAF_ATTR_FABRIC_PORT, nested);
}
for (auto i = 9U; i <= 12U; i++) {
next = addAttrib(info, next, IAF_ATTR_BRIDGE_PORT_NUMBER, i);
}
break;
case IAF_CMD_OP_FPORT_XMIT_RECV_COUNTS:
validateId(true, true, true);
if (true == addRxTxCounters) {
next = addAttrib(info, next, IAF_ATTR_FPORT_TX_BYTES, txCounter);
addAttrib(info, next, IAF_ATTR_FPORT_RX_BYTES, rxCounter);
}
break;
case IAF_CMD_OP_PORT_STATE_QUERY:
validateId(true, true, true);
for (auto i = 0U; i < 1; i++) {
MyNlattr *nested = new MyNlattr;
MyNlattr *nextNested = nested;
nextNested = addAttrib(info, nextNested, IAF_ATTR_FABRIC_PORT_NUMBER, testPortId.portNumber);
addAttrib(info, nextNested, IAF_ATTR_ENABLED_STATE, 1);
next = addNested(info, next, IAF_ATTR_FABRIC_PORT, nested);
}
break;
case IAF_CMD_OP_PORT_BEACON_STATE_QUERY:
validateId(true, true, true);
for (auto i = 0U; i < 1; i++) {
MyNlattr *nested = new MyNlattr;
MyNlattr *nextNested = nested;
addAttrib(info, nextNested, IAF_ATTR_ENABLED_STATE, 1);
next = addNested(info, next, IAF_ATTR_FABRIC_PORT, nested);
}
break;
case IAF_CMD_OP_ROUTING_GEN_QUERY:
validateId(false, false, false);
if (true == addRoutingGenStartEnd) {
next = addAttrib(info, next, IAF_ATTR_ROUTING_GEN_START, genStart);
addAttrib(info, next, IAF_ATTR_ROUTING_GEN_END, genEnd);
}
break;
case IAF_CMD_OP_DEVICE_ENUM:
validateId(false, false, false);
next = addAttrib(info, next, IAF_ATTR_ENTRIES, testFabricIds.size());
for (auto i = 0U; i < testFabricIds.size(); i++) {
MyNlattr *nested = new MyNlattr;
MyNlattr *nextNested = nested;
nextNested = addAttrib(info, nextNested, IAF_ATTR_FABRIC_ID, testFabricIds[i]);
nextNested = addAttrib(info, nextNested, IAF_ATTR_DEV_NAME, 0UL);
nextNested = addAttrib(info, nextNested, IAF_ATTR_PARENT_DEV_NAME, 0UL);
nextNested = addAttrib(info, nextNested, IAF_ATTR_SOCKET_ID, 0UL);
nextNested = addAttrib(info, nextNested, IAF_ATTR_PCI_SLOT_NUM, 0UL);
nextNested = addAttrib(info, nextNested, IAF_ATTR_SUBDEVICE_COUNT, 0UL);
nextNested = addAttrib(info, nextNested, IAF_ATTR_VERSION, 0UL);
addAttrib(info, nextNested, IAF_ATTR_PRODUCT_TYPE, 0UL);
next = addNested(info, next, IAF_ATTR_FABRIC_DEVICE, nested);
}
break;
case IAF_CMD_OP_PORT_BEACON_ENABLE:
case IAF_CMD_OP_PORT_BEACON_DISABLE:
case IAF_CMD_OP_PORT_ENABLE:
case IAF_CMD_OP_PORT_DISABLE:
case IAF_CMD_OP_PORT_USAGE_ENABLE:
case IAF_CMD_OP_PORT_USAGE_DISABLE:
validateId(true, true, true);
copyId(info, next, true, true, true);
break;
case IAF_CMD_OP_REM_REQUEST:
validateId(false, false, false);
break;
}
info.nlh = reinterpret_cast<struct nlmsghdr *>(head);
bool succeeded = false;
if (0 == (pOps->o_cmds[cmdIndex].c_msg_parser)(reinterpret_cast<struct nl_cache_ops *>(this), &pOps->o_cmds[cmdIndex], &info, arg)) {
succeeded = true;
}
delete head;
delete info.attrs;
if (succeeded) {
return NLE_SUCCESS;
} else {
return -NLE_FAILURE;
}
}
int MockNlApi::genlOpsResolve(struct nl_sock *sock, struct genl_ops *ops) {
int returnValue = 0;
if (!mockGenlOpsResolveReturnValue.empty()) {
returnValue = mockGenlOpsResolveReturnValue.front();
if (isRepeated != true) {
mockGenlOpsResolveReturnValue.erase(mockGenlOpsResolveReturnValue.begin());
}
return returnValue;
}
EXPECT_EQ(0U, ops->o_hdrsize);
EXPECT_NE(nullptr, ops->o_cmds);
attribs.clear();
pOps = ops;
return returnValue;
}
int MockNlApi::genlCtrlResolve(struct nl_sock *sock, const char *name) {
int returnValue = 0;
if (!mockGenCtrlResolveReturnValue.empty()) {
returnValue = mockGenCtrlResolveReturnValue.front();
if (isRepeated != true) {
mockGenCtrlResolveReturnValue.erase(mockGenCtrlResolveReturnValue.begin());
}
}
return returnValue;
}
int MockNlApi::nlRecvmsgsDefault(struct nl_sock *sock) {
int returnValue = 0;
if (!mockNlRecvmsgsDefaultReturnValue.empty()) {
returnValue = mockNlRecvmsgsDefaultReturnValue.front();
if (isRepeated != true) {
mockNlRecvmsgsDefaultReturnValue.erase(mockNlRecvmsgsDefaultReturnValue.begin());
}
return returnValue;
}
struct nl_msg *msg = nlmsgAlloc();
returnValue = myCallback(msg, myArgP);
nlmsgFree(msg);
return returnValue;
}
void *MockNlApi::nlaData(const struct nlattr *attr) {
const MyNlattr *pAttr = reinterpret_cast<const MyNlattr *>(attr);
return pAttr->nested;
}
uint32_t MockNlApi::nlaGetU32(const struct nlattr *attr) {
const MyNlattr *pAttr = reinterpret_cast<const MyNlattr *>(attr);
return pAttr->content & 0xFFFFFFFFUL;
}
uint64_t MockNlApi::nlaGetU64(const struct nlattr *attr) {
const MyNlattr *pAttr = reinterpret_cast<const MyNlattr *>(attr);
return pAttr->content;
}
uint8_t MockNlApi::nlaGetU8(const struct nlattr *attr) {
const MyNlattr *pAttr = reinterpret_cast<const MyNlattr *>(attr);
return pAttr->content & 0xFFUL;
}
int MockNlApi::nlaIsNested(const struct nlattr *attr) {
const MyNlattr *pAttr = reinterpret_cast<const MyNlattr *>(attr);
return nullptr != pAttr->nested;
}
int MockNlApi::nlaLen(const struct nlattr *attr) {
if (nullptr == attr)
return 0;
const MyNlattr *pAttr = reinterpret_cast<const MyNlattr *>(attr);
return sizeof(MyNlattr) + nlaLen(reinterpret_cast<const struct nlattr *>(pAttr->next)) + nlaLen(reinterpret_cast<const struct nlattr *>(pAttr->nested));
}
struct nlattr *MockNlApi::nlaNext(const struct nlattr *attr, int *remaining) {
const MyNlattr *pAttr = reinterpret_cast<const MyNlattr *>(attr);
*remaining = nlaLen(reinterpret_cast<const nlattr *>(pAttr->next));
return reinterpret_cast<nlattr *>(pAttr->next);
}
int MockNlApi::nlaOk(const struct nlattr *attr, int remaining) {
return nullptr != attr;
}
int MockNlApi::nlaPutU16(struct nl_msg *msg, int id, uint16_t data) {
EXPECT_EQ(attribs.end(), attribs.find(id));
EXPECT_EQ(NLA_U16, pOps->o_cmds[cmdIndex].c_attr_policy[id].type);
attribs[id] = data;
return 0;
}
int MockNlApi::nlaPutU32(struct nl_msg *msg, int id, uint32_t data) {
EXPECT_EQ(attribs.end(), attribs.find(id));
EXPECT_EQ(NLA_U32, pOps->o_cmds[cmdIndex].c_attr_policy[id].type);
attribs[id] = data;
return 0;
}
int MockNlApi::nlaPutU64(struct nl_msg *msg, int id, uint64_t data) {
EXPECT_EQ(attribs.end(), attribs.find(id));
EXPECT_EQ(NLA_U64, pOps->o_cmds[cmdIndex].c_attr_policy[id].type);
attribs[id] = data;
return 0;
}
int MockNlApi::nlaPutU8(struct nl_msg *msg, int id, uint8_t data) {
EXPECT_EQ(attribs.end(), attribs.find(id));
EXPECT_EQ(NLA_U8, pOps->o_cmds[cmdIndex].c_attr_policy[id].type);
attribs[id] = data;
return 0;
}
int MockNlApi::nlaType(const struct nlattr *attr) {
const MyNlattr *pAttr = reinterpret_cast<const MyNlattr *>(attr);
return pAttr->type;
}
struct nl_msg *MockNlApi::nlmsgAlloc() {
struct nl_msg *returnPtr = nullptr;
if (!mockNlmsgAllocReturnValue.empty()) {
returnPtr = mockNlmsgAllocReturnValue.front();
if (isRepeated != true) {
mockNlmsgAllocReturnValue.erase(mockNlmsgAllocReturnValue.begin());
}
return returnPtr;
}
return reinterpret_cast<nl_msg *>(new char[128]);
}
struct nlattr *MockNlApi::nlmsgAttrdata(const struct nlmsghdr *hdr, int attr) {
return reinterpret_cast<nlattr *>(const_cast<struct nlmsghdr *>(hdr));
}
int MockNlApi::nlmsgAttrlen(const struct nlmsghdr *hdr, int attr) {
return nlaLen(nlmsgAttrdata(hdr, attr));
}
void MockNlApi::nlmsgFree(struct nl_msg *msg) {
delete reinterpret_cast<char *>(msg); // NOLINT(clang-analyzer-unix.MismatchedDeallocator)
}
int MockNlApi::nlSendAuto(struct nl_sock *sock, struct nl_msg *msg) {
int returnValue = 0;
if (!mockNlSendAutoReturnValue.empty()) {
returnValue = mockNlSendAutoReturnValue.front();
mockNlSendAutoReturnValue.erase(mockNlSendAutoReturnValue.begin());
}
return returnValue;
}
bool MockNlApi::loadEntryPoints() {
bool returnValue = true;
if (!mockLoadEntryPointsReturnValue.empty()) {
returnValue = mockLoadEntryPointsReturnValue.front();
if (isRepeated != true) {
mockLoadEntryPointsReturnValue.erase(mockLoadEntryPointsReturnValue.begin());
}
}
return returnValue;
}
int MockNlApi::genlRegisterFamily(struct genl_ops *ops) {
int returnValue = 0;
if (!mockGenlRegisterFamilyReturnValue.empty()) {
returnValue = mockGenlRegisterFamilyReturnValue.front();
if (!mockGenlRegisterFamilyArgumentValue.empty()) {
pOps = mockGenlRegisterFamilyArgumentValue.front();
}
if (isMockGenlRegisterFamilyRepeatedCall.front() != true) {
if (!mockGenlRegisterFamilyArgumentValue.empty()) {
mockGenlRegisterFamilyArgumentValue.erase(mockGenlRegisterFamilyArgumentValue.begin());
}
mockGenlRegisterFamilyReturnValue.erase(mockGenlRegisterFamilyReturnValue.begin());
isMockGenlRegisterFamilyRepeatedCall.erase(isMockGenlRegisterFamilyRepeatedCall.begin());
}
}
return returnValue;
}
struct nl_sock *MockNlApi::nlSocketAlloc() {
struct nl_sock *returnPtr = nullptr;
if (!mockNlSocketAllocReturnValue.empty()) {
returnPtr = mockNlSocketAllocReturnValue.front();
if (isRepeated != true) {
mockNlSocketAllocReturnValue.erase(mockNlSocketAllocReturnValue.begin());
}
}
return returnPtr;
}
int MockNlApi::genlConnect(struct nl_sock *sock) {
int returnValue = 0;
if (!mockGenlConnectReturnValue.empty()) {
returnValue = mockGenlConnectReturnValue.front();
if (isRepeated != true) {
mockGenlConnectReturnValue.erase(mockGenlConnectReturnValue.begin());
}
}
return returnValue;
}
int MockNlApi::nlSocketModifyCb(struct nl_sock *sock, enum nl_cb_type type, enum nl_cb_kind kind, nl_recvmsg_msg_cb_t cb, void *arg) {
int returnValue = 0;
myCallback = cb;
myArgP = arg;
if (!mockNlSocketModifyCbReturnValue.empty()) {
returnValue = mockNlSocketModifyCbReturnValue.front();
if (isRepeated != true) {
mockNlSocketModifyCbReturnValue.erase(mockNlSocketModifyCbReturnValue.begin());
}
}
return returnValue;
}
int MockNlApi::genlUnregisterFamily(struct genl_ops *ops) {
int returnValue = 0;
if (!mockGenlUnregisterFamilyReturnValue.empty()) {
returnValue = mockGenlUnregisterFamilyReturnValue.front();
if (isRepeated != true) {
mockGenlUnregisterFamilyReturnValue.erase(mockGenlUnregisterFamilyReturnValue.begin());
}
}
return returnValue;
}
} // namespace ult
} // namespace L0

161
level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_nl_api_prelim.h Normal file
View File

@@ -0,0 +1,161 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "level_zero/core/test/unit_tests/fixtures/device_fixture.h"
#include "gmock/gmock.h"
#include "sysman/linux/nl_api/iaf_nl_api.h"
#include "sysman/linux/nl_api/nl_api.h"
#include <map>
namespace L0 {
namespace ult {
class MyNlattr {
public:
uint16_t type = NLA_UNSPEC;
uint64_t content;
MyNlattr *next = nullptr;
MyNlattr *nested = nullptr;
MyNlattr *addNext() {
next = new MyNlattr;
return next;
}
MyNlattr() = default;
~MyNlattr() {
if (nested)
delete nested;
if (next)
delete next;
}
};
class MockNlApi : public NlApi {
public:
std::vector<struct nl_sock *> mockNlSocketAllocReturnValue{};
std::vector<struct genl_ops *> mockGenlRegisterFamilyArgumentValue{};
std::vector<struct nl_msg *> mockNlmsgAllocReturnValue{};
std::vector<void *> mockGenlmsgPutReturnValue{};
std::vector<int> mockGenlRegisterFamilyReturnValue{};
std::vector<int> mockGenlConnectReturnValue{};
std::vector<int> mockGenlOpsResolveReturnValue{};
std::vector<int> mockGenCtrlResolveReturnValue{};
std::vector<int> mockNlSocketModifyCbReturnValue{};
std::vector<int> mockNlRecvmsgsDefaultReturnValue{};
std::vector<int> mockGenlUnregisterFamilyReturnValue{};
std::vector<int> mockNlSendAutoReturnValue{};
std::vector<bool> mockLoadEntryPointsReturnValue{};
std::vector<bool> isMockGenlRegisterFamilyRepeatedCall{};
bool isRepeated = false;
int genlUnregisterFamily(struct genl_ops *ops) override;
int genlHandleMsg(struct nl_msg *msg, void *arg) override;
int genlOpsResolve(struct nl_sock *sock, struct genl_ops *ops) override;
int genlCtrlResolve(struct nl_sock *sock, const char *name) override;
void *genlmsgPut(struct nl_msg *msg, uint32_t port, uint32_t seq, int family, int hdrlen, int flags, uint8_t cmd, uint8_t version) override;
int nlRecvmsgsDefault(struct nl_sock *sock) override;
void *nlaData(const struct nlattr *attr) override;
uint32_t nlaGetU32(const struct nlattr *attr) override;
uint64_t nlaGetU64(const struct nlattr *attr) override;
uint8_t nlaGetU8(const struct nlattr *attr) override;
int nlaIsNested(const struct nlattr *attr) override;
int nlaLen(const struct nlattr *attr) override;
struct nlattr *nlaNext(const struct nlattr *attr, int *remaining) override;
int nlaOk(const struct nlattr *attr, int remaining) override;
int nlaPutU16(struct nl_msg *msg, int id, uint16_t data) override;
int nlaPutU32(struct nl_msg *msg, int id, uint32_t data) override;
int nlaPutU64(struct nl_msg *msg, int id, uint64_t data) override;
int nlaPutU8(struct nl_msg *msg, int id, uint8_t data) override;
int nlaType(const struct nlattr *attr) override;
struct nl_msg *nlmsgAlloc() override;
struct nlattr *nlmsgAttrdata(const struct nlmsghdr *hdr, int attr) override;
int nlmsgAttrlen(const struct nlmsghdr *hdr, int attr) override;
void nlmsgFree(struct nl_msg *msg) override;
int nlSendAuto(struct nl_sock *sock, struct nl_msg *msg) override;
bool loadEntryPoints() override;
int genlRegisterFamily(struct genl_ops *ops) override;
struct nl_sock *nlSocketAlloc() override;
int genlConnect(struct nl_sock *sock) override;
int nlSocketModifyCb(struct nl_sock *sock, enum nl_cb_type type, enum nl_cb_kind kind, nl_recvmsg_msg_cb_t cb, void *arg) override;
ADDMETHOD_NOBASE(nlmsgHdr, struct nlmsghdr *, nullptr, (struct nl_msg * msg));
ADDMETHOD_NOBASE_VOIDRETURN(nlSocketDisableSeqCheck, (struct nl_sock * sock));
ADDMETHOD_NOBASE_VOIDRETURN(nlSocketFree, (struct nl_sock * sock));
MockNlApi() = default;
~MockNlApi() override = default;
nl_recvmsg_msg_cb_t myCallback;
void *myArgP;
static constexpr IafPortId testPortId{0x10000000U, 0x1U, 7};
const uint64_t testGuid = 0x1234567887654321;
const uint8_t linkSpeed12g = 1;
const uint8_t linkSpeed25g = 2;
const uint8_t linkSpeed53g = 4;
const uint8_t linkSpeed90g = 8;
const uint8_t linkWidth1x = 1;
const uint8_t linkWidth2x = 2;
const uint8_t linkWidth3x = 4;
const uint8_t linkWidth4x = 8;
bool useInvalidWidth = false;
uint8_t linkSpeed = linkSpeed90g;
bool addRxTxCounters = true;
bool addRoutingGenStartEnd = true;
bool addSubDeviceCount = true;
bool addGUID = true;
bool addPortZeroAndTypeDisconnected = false;
enum iaf_fport_health fportHealth = IAF_FPORT_HEALTH_HEALTHY;
uint8_t fportIssueLqi = 0;
uint8_t fportIssueLwd = 0;
uint8_t fportIssueRate = 0;
uint8_t fportReasonFailed = 0;
uint8_t fportReasonIsolated = 0;
uint8_t fportReasonLinkDown = 0;
uint8_t fportReasonDidNotTrain = 0;
uint8_t fportReasonFlapping = 0;
const uint8_t testLinkWidthUnknown = -1;
const uint8_t testLinkWidth1x = 1;
const uint8_t testLinkWidth2x = 2;
const uint8_t testLinkWidth3x = 3;
const uint8_t testLinkWidth4x = 4;
uint32_t genStart = 1U; // Any non-zero, non-maxint value
uint32_t genEnd = 2U; // Any non-zero, non-maxint value
uint64_t rxCounter = 100000000UL; // Any non-zero, non-maxlongint value
uint64_t txCounter = 200000000UL; // Any non-zero, non-maxlongint value
bool cmdMakeContextNotPresent = false;
bool cmdMakeContextNotMatch = false;
uint8_t cmdMsgType = IAF_CMD_MSG_RESPONSE;
uint8_t cmdRspRslt = IAF_CMD_RSP_SUCCESS;
std::vector<uint32_t> testFabricIds;
private:
int cmdIndex = 0;
std::map<int, uint64_t> attribs;
struct genl_ops *pOps = nullptr;
void validateId(bool checkFabricId, bool checkAttachId, bool checkPortNumber);
MyNlattr *copyId(struct genl_info &info, MyNlattr *next, bool checkFabricId, bool checkAttachId, bool checkPortNumber);
MyNlattr *addAttrib(struct genl_info &info, MyNlattr *next, uint16_t type, uint64_t content);
MyNlattr *addNested(struct genl_info &info, MyNlattr *next, uint16_t type, MyNlattr *nested);
MyNlattr *addDefaultAttribs(struct genl_info &info, MyNlattr *next);
MyNlattr *addPort(struct genl_info &info, MyNlattr *next, zes_fabric_port_id_t *port);
};
} // namespace ult
} // namespace L0

972
level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/test_sysman_iaf_nl_api_prelim.cpp Normal file
View File

@@ -0,0 +1,972 @@
/*
* Copyright (C) 2021-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/common/os_interface/linux/sys_calls_linux_ult.h"
#include "gmock/gmock.h"
#include "mock_nl_api_prelim.h"
#include "sysman/linux/nl_api/iaf_nl_api.h"
#include <limits>
#include <netlink/handlers.h>
extern bool sysmanUltsEnable;
using ::testing::_;
using ::testing::ByRef;
using ::testing::DoAll;
using ::testing::Eq;
using ::testing::Invoke;
using ::testing::Return;
using ::testing::SaveArg;
using ::testing::StrEq;
struct nl_sock {
};
namespace NEO {
extern std::map<std::string, std::vector<std::string>> directoryFilesMap;
}
namespace L0 {
namespace ult {
class PublicIafNlApi : public IafNlApi {
public:
using IafNlApi::cleanup;
using IafNlApi::init;
using IafNlApi::pNlApi;
};
class SysmanIafNlApiFixture : public ::testing::Test {
protected:
PublicIafNlApi testIafNlApi;
void SetUp() override {
if (!sysmanUltsEnable) {
GTEST_SKIP();
}
auto mockNlApi = std::make_unique<MockNlApi>();
testIafNlApi.pNlApi = std::move(mockNlApi);
}
void TearDown() override {
}
void setupExpectCommand(uint16_t cmd, uint32_t fabricId, uint32_t attachId, uint8_t portId);
void setupExpectCommand(uint16_t cmd, uint32_t fabricId, uint32_t attachId);
void setupExpectCommand(uint16_t cmd, uint32_t fabricId);
void setupExpectCommand(uint16_t cmd);
void setupExpectInit();
void setupExpectCleanup();
void setupExpectInitMultiple();
void setupExpectCleanupMultiple();
public:
struct nl_sock nlSock;
struct genl_ops *pOps;
static const char *iafFamilyName;
};
const char *SysmanIafNlApiFixture::iafFamilyName = "iaf_ze";
void SysmanIafNlApiFixture::setupExpectCommand(uint16_t cmd, uint32_t fabricId, uint32_t attachId, uint8_t portNumber) {
setupExpectCommand(cmd, fabricId, attachId);
}
void SysmanIafNlApiFixture::setupExpectCommand(uint16_t cmd, uint32_t fabricId, uint32_t attachId) {
setupExpectCommand(cmd, fabricId);
}
void SysmanIafNlApiFixture::setupExpectCommand(uint16_t cmd, uint32_t fabricId) {
setupExpectCommand(cmd);
}
void SysmanIafNlApiFixture::setupExpectCommand(uint16_t cmd) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockNlSendAutoReturnValue.push_back(0);
}
void SysmanIafNlApiFixture::setupExpectInit() {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(true);
pMockNlApi->mockGenlRegisterFamilyArgumentValue.push_back(pOps);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(0);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(false);
pMockNlApi->mockNlSocketAllocReturnValue.push_back(&nlSock);
pMockNlApi->mockGenlConnectReturnValue.push_back(0);
pMockNlApi->mockGenCtrlResolveReturnValue.push_back(0);
pMockNlApi->mockNlSocketModifyCbReturnValue.push_back(0);
}
void SysmanIafNlApiFixture::setupExpectInitMultiple() {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(true);
pMockNlApi->mockGenlRegisterFamilyArgumentValue.push_back(pOps);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(0);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(true);
pMockNlApi->mockNlSocketAllocReturnValue.push_back(&nlSock);
pMockNlApi->mockGenlConnectReturnValue.push_back(0);
pMockNlApi->mockGenCtrlResolveReturnValue.push_back(0);
pMockNlApi->mockNlSocketModifyCbReturnValue.push_back(0);
pMockNlApi->isRepeated = true;
}
void SysmanIafNlApiFixture::setupExpectCleanupMultiple() {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockGenlUnregisterFamilyReturnValue.push_back(0);
pMockNlApi->isRepeated = true;
}
void SysmanIafNlApiFixture::setupExpectCleanup() {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockGenlUnregisterFamilyReturnValue.push_back(0);
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenLoadEntryPointsFailsThenInitRepeatedlyReturnsDependencyUnavailable) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(false);
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, testIafNlApi.init());
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, testIafNlApi.init());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenGenlRegisterFamilyFailesWithExistThenInitReturnsNotReady) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(true);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(-NLE_EXIST);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(false);
EXPECT_EQ(ZE_RESULT_NOT_READY, testIafNlApi.init());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenGenlRegisterFamilyFailesWithAnyOtherErrorInitReturnsErrorUnknown) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(true);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(-NLE_FAILURE);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(false);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.init());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenNlSocketAllocFailsThenInitReturnsErrorUnknown) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(true);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(0);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(false);
pMockNlApi->mockNlSocketAllocReturnValue.push_back(nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.init());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenGenlConnectFailsThenInitReturnsErrorUnknown) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(true);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(0);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(false);
pMockNlApi->mockNlSocketAllocReturnValue.push_back(&nlSock);
pMockNlApi->mockGenlConnectReturnValue.push_back(-1);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.init());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenGenlOpsResolveFailsThenInitReturnsErrorUnknown) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(true);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(0);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(false);
pMockNlApi->mockNlSocketAllocReturnValue.push_back(&nlSock);
pMockNlApi->mockGenlConnectReturnValue.push_back(0);
pMockNlApi->mockGenlOpsResolveReturnValue.push_back(-1);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.init());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenGenlCtrlResolveFailsThenInitReturnsErrorUnknown) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(true);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(0);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(false);
pMockNlApi->mockNlSocketAllocReturnValue.push_back(&nlSock);
pMockNlApi->mockGenlConnectReturnValue.push_back(0);
pMockNlApi->mockGenlOpsResolveReturnValue.push_back(0);
pMockNlApi->mockGenCtrlResolveReturnValue.push_back(-1);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.init());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenNlSocketModifyCbFailsThenInitReturnsErrorUnknown) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(true);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(0);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(false);
pMockNlApi->mockNlSocketAllocReturnValue.push_back(&nlSock);
pMockNlApi->mockGenlConnectReturnValue.push_back(0);
pMockNlApi->mockGenlOpsResolveReturnValue.push_back(0);
pMockNlApi->mockGenCtrlResolveReturnValue.push_back(0);
pMockNlApi->mockNlSocketModifyCbReturnValue.push_back(-1);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.init());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenAllNlApisReturnSuccessThenInitReturnsSuccess) {
setupExpectInit();
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.init());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenInitSucceedsThenCleanupSucceeds) {
setupExpectInit();
setupExpectCleanup();
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.init());
testIafNlApi.cleanup();
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenInitCalledMultipleTimesThenLoadEntryPointsOnlyCalledOnce) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(true);
pMockNlApi->mockGenlRegisterFamilyArgumentValue.push_back(pOps);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(0);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(true);
pMockNlApi->mockNlSocketAllocReturnValue.push_back(&nlSock);
pMockNlApi->mockGenlConnectReturnValue.push_back(0);
pMockNlApi->mockGenlOpsResolveReturnValue.push_back(0);
pMockNlApi->mockGenCtrlResolveReturnValue.push_back(0);
pMockNlApi->mockNlSocketModifyCbReturnValue.push_back(0);
pMockNlApi->isRepeated = true;
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.init());
testIafNlApi.cleanup();
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.init());
testIafNlApi.cleanup();
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRemRequestCalledThenReturnSuccess) {
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_REM_REQUEST);
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.remRequest());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRemRequestCalledAndInitFailsThenErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(false);
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, testIafNlApi.remRequest());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRemRequestCalledAndNlmsgAllocFailsThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
pMockNlApi->mockNlmsgAllocReturnValue.push_back(nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.remRequest());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenCallingHandleResponseWithInvalidCommandThenUnknownErrorReturned) {
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.handleResponse(_IAF_CMD_OP_COUNT + 1, nullptr, nullptr));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRemRequestCalledAndPerformTransactionRecvmsgsDefaultFailedThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
pMockNlApi->mockNlSendAutoReturnValue.push_back(0);
pMockNlApi->mockNlRecvmsgsDefaultReturnValue.push_back(-NLE_FAILURE);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.remRequest());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRemRequestCalledAndPerformTransactionRecvmsgsDefaulFailsWith_NLE_PERM_ThenInsufficientPermissionsReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
pMockNlApi->mockNlSendAutoReturnValue.push_back(0);
pMockNlApi->mockNlRecvmsgsDefaultReturnValue.push_back(-NLE_PERM);
EXPECT_EQ(ZE_RESULT_ERROR_INSUFFICIENT_PERMISSIONS, testIafNlApi.remRequest());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRemRequestCalledAndNlOperationFailsWhenResponseTypeNotResponseThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_REM_REQUEST);
pMockNlApi->cmdMsgType = IAF_CMD_MSG_REQUEST;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.remRequest());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRemRequestCalledAndNlOperationFailsWhenOpResultNotSuccessThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_REM_REQUEST);
pMockNlApi->cmdRspRslt = IAF_CMD_RSP_FAILURE;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.remRequest());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRemRequestCalledAndNlOperationFailsWhenResponseTypeNotPresentThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_REM_REQUEST);
pMockNlApi->cmdMsgType = _IAF_CMD_MSG_TYPE_COUNT;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.remRequest());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRemRequestCalledAndNlOperationFailsWhenOpResultNotPresentThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_REM_REQUEST);
pMockNlApi->cmdRspRslt = _IAF_CMD_RSP_COUNT;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.remRequest());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRemRequestCalledAndPerformTransactionNlSendAutoFailedThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
pMockNlApi->mockNlSendAutoReturnValue.push_back(-1);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.remRequest());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRemRequestCalledAndNlOperationFailsWhenMakeContextNotMatchThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_REM_REQUEST);
pMockNlApi->cmdMakeContextNotMatch = true;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.remRequest());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRemRequestCalledAndNlOperationFailsWhenMakeContextNotPresentThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
pMockNlApi->cmdMakeContextNotPresent = true;
pMockNlApi->mockNlSendAutoReturnValue.push_back(0);
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.remRequest());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRemRequestCalledAndAllocMsgFailsWhenGenlmsgPutReturnNullPtrThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
pMockNlApi->mockGenlmsgPutReturnValue.push_back(nullptr);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.remRequest());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRemRequestCalledAndUnexpectedCmdCompletesThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
pMockNlApi->mockGenlmsgPutReturnValue.push_back(pMockNlApi);
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.remRequest());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenPortBeaconEnableCalledThenReturnSuccess) {
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_PORT_BEACON_ENABLE, MockNlApi::testPortId.fabricId, MockNlApi::testPortId.attachId, MockNlApi::testPortId.portNumber);
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.portBeaconEnable(MockNlApi::testPortId));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenPortBeaconDisableCalledThenReturnSuccess) {
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_PORT_BEACON_DISABLE, MockNlApi::testPortId.fabricId, MockNlApi::testPortId.attachId, MockNlApi::testPortId.portNumber);
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.portBeaconDisable(MockNlApi::testPortId));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenPortEnableCalledThenReturnSuccess) {
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_PORT_ENABLE, MockNlApi::testPortId.fabricId, MockNlApi::testPortId.attachId, MockNlApi::testPortId.portNumber);
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.portEnable(MockNlApi::testPortId));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenPortDisableCalledThenReturnSuccess) {
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_PORT_DISABLE, MockNlApi::testPortId.fabricId, MockNlApi::testPortId.attachId, MockNlApi::testPortId.portNumber);
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.portDisable(MockNlApi::testPortId));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenPortUsageEnableCalledThenReturnSuccess) {
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_PORT_USAGE_ENABLE, MockNlApi::testPortId.fabricId, MockNlApi::testPortId.attachId, MockNlApi::testPortId.portNumber);
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.portUsageEnable(MockNlApi::testPortId));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenPortUsageDisableCalledThenReturnSuccess) {
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_PORT_USAGE_DISABLE, MockNlApi::testPortId.fabricId, MockNlApi::testPortId.attachId, MockNlApi::testPortId.portNumber);
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.portUsageDisable(MockNlApi::testPortId));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRoutingGenQueryCalledThenBeginAndEndReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_ROUTING_GEN_QUERY);
uint32_t start = std::numeric_limits<uint32_t>::max(), end = std::numeric_limits<uint32_t>::max();
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.routingGenQuery(start, end));
EXPECT_EQ(pMockNlApi->genStart, start);
EXPECT_EQ(pMockNlApi->genEnd, end);
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRoutingGenQueryCalledAndStartAndEndNotPresentThenStartAndEndZeroReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_ROUTING_GEN_QUERY);
uint32_t start = std::numeric_limits<uint32_t>::max(), end = std::numeric_limits<uint32_t>::max();
pMockNlApi->addRoutingGenStartEnd = false;
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.routingGenQuery(start, end));
EXPECT_EQ(0U, start);
EXPECT_EQ(0U, end);
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRoutingGenQueryCalledAndLoadEntryPointsFailsThenErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(false);
uint32_t start = std::numeric_limits<uint32_t>::max(), end = std::numeric_limits<uint32_t>::max();
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, testIafNlApi.routingGenQuery(start, end));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRoutingGenQueryCalledAndNlmsgAllocFailsThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
pMockNlApi->mockNlmsgAllocReturnValue.push_back(nullptr);
uint32_t start = std::numeric_limits<uint32_t>::max(), end = std::numeric_limits<uint32_t>::max();
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.routingGenQuery(start, end));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenGetThroughputCalledThenRxCounterAndTxCounterReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_FPORT_XMIT_RECV_COUNTS, pMockNlApi->testPortId.fabricId,
pMockNlApi->testPortId.attachId, pMockNlApi->testPortId.portNumber);
IafPortThroughPut throughput;
throughput.txCounter = std::numeric_limits<uint64_t>::max();
throughput.rxCounter = std::numeric_limits<uint64_t>::max();
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.getThroughput(MockNlApi::testPortId, throughput));
EXPECT_EQ(pMockNlApi->txCounter, throughput.txCounter);
EXPECT_EQ(pMockNlApi->rxCounter, throughput.rxCounter);
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenGetThroughputCalledAndRxAndTxCountersNotPresentThenRxAndTxCountersOfZeroReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_FPORT_XMIT_RECV_COUNTS, pMockNlApi->testPortId.fabricId,
pMockNlApi->testPortId.attachId, pMockNlApi->testPortId.portNumber);
IafPortThroughPut throughput;
throughput.txCounter = std::numeric_limits<uint64_t>::max();
throughput.rxCounter = std::numeric_limits<uint64_t>::max();
pMockNlApi->addRxTxCounters = false;
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.getThroughput(pMockNlApi->testPortId, throughput));
EXPECT_EQ(0U, throughput.txCounter);
EXPECT_EQ(0U, throughput.rxCounter);
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenDeviceEnumCalledThenFabricIdsReturned) {
std::vector<uint32_t> fabricIds;
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_DEVICE_ENUM);
fabricIds.clear();
MockNlApi *mockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
mockNlApi->testFabricIds.clear();
mockNlApi->testFabricIds.push_back(mockNlApi->testPortId.fabricId);
mockNlApi->testFabricIds.push_back(mockNlApi->testPortId.fabricId + 1U);
mockNlApi->testFabricIds.push_back(mockNlApi->testPortId.fabricId + 2U);
mockNlApi->testFabricIds.push_back(mockNlApi->testPortId.fabricId + 3U);
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.deviceEnum(fabricIds));
EXPECT_EQ(mockNlApi->testFabricIds.size(), fabricIds.size());
for (auto i = 0U; i < mockNlApi->testFabricIds.size(); i++) {
EXPECT_EQ(mockNlApi->testFabricIds.at(i), fabricIds.at(i));
}
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenFPortStatusQueryCalledThenPortStateReturned) {
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_FPORT_STATUS_QUERY, MockNlApi::testPortId.fabricId,
MockNlApi::testPortId.attachId, MockNlApi::testPortId.portNumber);
IafPortState state = {};
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.fPortStatusQuery(MockNlApi::testPortId, state));
EXPECT_EQ(IAF_FPORT_HEALTH_HEALTHY, static_cast<iaf_fport_health>(state.healthStatus));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenFabricDevicePropertiesCalledThenSubDeviceCountReturned) {
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_FABRIC_DEVICE_PROPERTIES, MockNlApi::testPortId.fabricId);
uint32_t numSubDevices = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.fabricDeviceProperties(MockNlApi::testPortId.fabricId, numSubDevices));
EXPECT_EQ(2U, numSubDevices);
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenFabricDevicePropertiesCalledAndSubDeviceCountNotPresentThenZeroSubDevicesReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_FABRIC_DEVICE_PROPERTIES, pMockNlApi->testPortId.fabricId);
uint32_t numSubDevices = 0;
pMockNlApi->addSubDeviceCount = false;
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.fabricDeviceProperties(MockNlApi::testPortId.fabricId, numSubDevices));
EXPECT_EQ(0U, numSubDevices);
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenFabricDevicePropertiesCalledAndLoadEntryPointsFailsThenErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(false);
uint32_t numSubDevices = 0;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, testIafNlApi.fabricDeviceProperties(MockNlApi::testPortId.fabricId, numSubDevices));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenFabricDevicePropertiesCalledAndNlmsgAllocFailsThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
pMockNlApi->mockNlmsgAllocReturnValue.push_back(nullptr);
uint32_t numSubDevices = 0;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.fabricDeviceProperties(MockNlApi::testPortId.fabricId, numSubDevices));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenFportPropertiesCalledThenPropertiesReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_FPORT_PROPERTIES, pMockNlApi->testPortId.fabricId,
pMockNlApi->testPortId.attachId, pMockNlApi->testPortId.portNumber);
uint64_t neighborGuid;
uint8_t neighborPortNumber;
IafPortSpeed maxRxSpeed;
IafPortSpeed maxTxSpeed;
IafPortSpeed rxSpeed;
IafPortSpeed txSpeed;
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.fportProperties(pMockNlApi->testPortId, neighborGuid, neighborPortNumber,
maxRxSpeed, maxTxSpeed, rxSpeed, txSpeed));
EXPECT_EQ(neighborGuid, pMockNlApi->testGuid);
EXPECT_EQ(neighborPortNumber, pMockNlApi->testPortId.portNumber);
EXPECT_EQ(maxRxSpeed.bitRate, pMockNlApi->linkSpeed90g);
EXPECT_EQ(maxRxSpeed.width, pMockNlApi->testLinkWidth1x);
EXPECT_EQ(maxTxSpeed.bitRate, pMockNlApi->linkSpeed90g);
EXPECT_EQ(maxTxSpeed.width, pMockNlApi->testLinkWidth1x);
EXPECT_EQ(rxSpeed.bitRate, pMockNlApi->linkSpeed90g);
EXPECT_EQ(rxSpeed.width, pMockNlApi->testLinkWidth3x);
EXPECT_EQ(txSpeed.bitRate, pMockNlApi->linkSpeed90g);
EXPECT_EQ(txSpeed.width, pMockNlApi->testLinkWidth4x);
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenFportPropertiesCalledAndInvalidWidthAndBitRate0DetectedThenNegativeOneReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_FPORT_PROPERTIES, pMockNlApi->testPortId.fabricId,
pMockNlApi->testPortId.attachId, pMockNlApi->testPortId.portNumber);
uint64_t neighborGuid;
uint8_t neighborPortNumber;
IafPortSpeed maxRxSpeed;
IafPortSpeed maxTxSpeed;
IafPortSpeed rxSpeed;
IafPortSpeed txSpeed;
pMockNlApi->useInvalidWidth = true;
pMockNlApi->linkSpeed = 0;
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.fportProperties(pMockNlApi->testPortId, neighborGuid, neighborPortNumber,
maxRxSpeed, maxTxSpeed, rxSpeed, txSpeed));
EXPECT_EQ(neighborGuid, pMockNlApi->testGuid);
EXPECT_EQ(neighborPortNumber, pMockNlApi->testPortId.portNumber);
EXPECT_EQ(maxRxSpeed.bitRate, -1);
EXPECT_EQ(maxRxSpeed.width, -1);
EXPECT_EQ(maxTxSpeed.bitRate, -1);
EXPECT_EQ(maxTxSpeed.width, -1);
EXPECT_EQ(rxSpeed.bitRate, -1);
EXPECT_EQ(rxSpeed.width, -1);
EXPECT_EQ(txSpeed.bitRate, -1);
EXPECT_EQ(txSpeed.width, -1);
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenFportPropertiesCalledAndLoadEntryPointsFailsThenErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(false);
uint64_t neighborGuid;
uint8_t neighborPortNumber;
IafPortSpeed maxRxSpeed;
IafPortSpeed maxTxSpeed;
IafPortSpeed rxSpeed;
IafPortSpeed txSpeed;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, testIafNlApi.fportProperties(pMockNlApi->testPortId, neighborGuid, neighborPortNumber,
maxRxSpeed, maxTxSpeed, rxSpeed, txSpeed));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenFportPropertiesCalledAndNlmsgAllocFailsThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
pMockNlApi->mockNlmsgAllocReturnValue.push_back(nullptr);
uint64_t neighborGuid;
uint8_t neighborPortNumber;
IafPortSpeed maxRxSpeed;
IafPortSpeed maxTxSpeed;
IafPortSpeed rxSpeed;
IafPortSpeed txSpeed;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.fportProperties(pMockNlApi->testPortId, neighborGuid, neighborPortNumber,
maxRxSpeed, maxTxSpeed, rxSpeed, txSpeed));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenPortBeaconStateQueryCalledThenPortBeaconStateReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_PORT_BEACON_STATE_QUERY, pMockNlApi->testPortId.fabricId,
pMockNlApi->testPortId.attachId, pMockNlApi->testPortId.portNumber);
bool enabled = false;
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.portBeaconStateQuery(pMockNlApi->testPortId, enabled));
EXPECT_EQ(true, enabled);
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenPortSubDevicePropertiesGetCalledThenGuidAndPortsReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_SUB_DEVICE_PROPERTIES_GET, pMockNlApi->testPortId.fabricId, pMockNlApi->testPortId.attachId);
uint64_t guid = 0;
std::vector<uint8_t> ports;
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.subdevicePropertiesGet(pMockNlApi->testPortId.fabricId, pMockNlApi->testPortId.attachId,
guid, ports));
EXPECT_EQ(guid, pMockNlApi->testGuid);
EXPECT_EQ(8U, ports.size());
for (auto i = 0U; i < ports.size(); i++) {
EXPECT_EQ(ports.at(i), i + 1);
}
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenPortSubDevicePropertiesGetCalledAndGuidNotPresentThenGuidIsZeroAndPortsReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_SUB_DEVICE_PROPERTIES_GET, pMockNlApi->testPortId.fabricId, pMockNlApi->testPortId.attachId);
uint64_t guid = pMockNlApi->testGuid;
std::vector<uint8_t> ports;
pMockNlApi->addGUID = false;
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.subdevicePropertiesGet(pMockNlApi->testPortId.fabricId, pMockNlApi->testPortId.attachId,
guid, ports));
EXPECT_EQ(0U, guid);
EXPECT_EQ(8U, ports.size());
for (auto i = 0U; i < ports.size(); i++) {
EXPECT_EQ(ports.at(i), i + 1);
}
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenPortSubDevicePropertiesGetCalledAndAddPortZeroAndTypeDisconnectedThenGuidAndZeroPortsReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_SUB_DEVICE_PROPERTIES_GET, pMockNlApi->testPortId.fabricId, pMockNlApi->testPortId.attachId);
uint64_t guid = 0;
std::vector<uint8_t> ports;
pMockNlApi->addPortZeroAndTypeDisconnected = true;
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.subdevicePropertiesGet(pMockNlApi->testPortId.fabricId, pMockNlApi->testPortId.attachId,
guid, ports));
EXPECT_EQ(guid, pMockNlApi->testGuid);
EXPECT_EQ(0U, ports.size());
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenPortSubDevicePropertiesGetCalledAndLoadEntryPointsFailsThenErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockLoadEntryPointsReturnValue.push_back(false);
uint64_t guid = 0;
std::vector<uint8_t> ports;
EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, testIafNlApi.subdevicePropertiesGet(pMockNlApi->testPortId.fabricId,
pMockNlApi->testPortId.attachId, guid, ports));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenPortSubDevicePropertiesGetAndNlmsgAllocFailsThenUnknownErrorReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
pMockNlApi->mockNlmsgAllocReturnValue.push_back(nullptr);
uint64_t guid = 0;
std::vector<uint8_t> ports;
EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.subdevicePropertiesGet(pMockNlApi->testPortId.fabricId,
pMockNlApi->testPortId.attachId, guid, ports));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenPortStateQueryCalledThenPortStateReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_PORT_STATE_QUERY, pMockNlApi->testPortId.fabricId,
pMockNlApi->testPortId.attachId, pMockNlApi->testPortId.portNumber);
bool enabled = false;
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.portStateQuery(pMockNlApi->testPortId, enabled));
EXPECT_EQ(true, enabled);
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenFPortStatusQueryCalledAndHeathIsOutOfRangeThenPortStatusUnknownReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_FPORT_STATUS_QUERY, pMockNlApi->testPortId.fabricId,
pMockNlApi->testPortId.attachId, pMockNlApi->testPortId.portNumber);
IafPortState state = {};
pMockNlApi->fportHealth = _IAF_FPORT_HEALTH_COUNT;
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.fPortStatusQuery(pMockNlApi->testPortId, state));
EXPECT_EQ(_IAF_FPORT_HEALTH_COUNT, static_cast<iaf_fport_health>(state.healthStatus));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenFPortStatusQueryCalledAndPortHealthOffThenPortStatusDisabledReturned) {
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
setupExpectInit();
setupExpectCleanup();
setupExpectCommand(IAF_CMD_OP_FPORT_STATUS_QUERY, pMockNlApi->testPortId.fabricId,
pMockNlApi->testPortId.attachId, pMockNlApi->testPortId.portNumber);
IafPortState state = {};
pMockNlApi->fportHealth = IAF_FPORT_HEALTH_OFF;
EXPECT_EQ(ZE_RESULT_SUCCESS, testIafNlApi.fPortStatusQuery(pMockNlApi->testPortId, state));
EXPECT_EQ(IAF_FPORT_HEALTH_OFF, static_cast<iaf_fport_health>(state.healthStatus));
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWithLegacyIafPortsWhenGetPortsIsCalledValidPortsAreReturned) {
NEO::directoryFilesMap.insert({"/sys/class/drm/card1/device/", {"iaf.0"}});
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
std::vector<std::string> supportedFiles = {
"/sys/class/drm/card1/device/iaf.0/iaf_fabric_id",
};
auto itr = std::find(supportedFiles.begin(), supportedFiles.end(), std::string(pathname));
if (itr != supportedFiles.end()) {
return static_cast<int>(std::distance(supportedFiles.begin(), itr)) + 1;
}
return 0;
});
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
std::string fabricId("0x10000000");
memcpy(buf, fabricId.c_str(), fabricId.size());
return fabricId.size();
});
setupExpectInitMultiple();
setupExpectCleanupMultiple();
std::vector<IafPort> ports;
ze_result_t result = testIafNlApi.getPorts("/sys/class/drm/card1/device/", ports);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
NEO::directoryFilesMap.clear();
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenGetPortsIsCalledValidPortsAreReturned) {
NEO::directoryFilesMap.insert({"/sys/class/drm/card1/device/", {"i915.iaf.0"}});
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
return 1;
});
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
std::string fabricId("0x10000000");
memcpy(buf, fabricId.c_str(), fabricId.size());
return fabricId.size();
});
setupExpectInitMultiple();
setupExpectCleanupMultiple();
std::vector<IafPort> ports;
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->addSubDeviceCount = false;
ze_result_t result = testIafNlApi.getPorts("/sys/class/drm/card1/device/", ports);
EXPECT_EQ(result, ZE_RESULT_SUCCESS);
NEO::directoryFilesMap.clear();
}
TEST_F(SysmanIafNlApiFixture, GivenIafDirectoryIsUnavailableWhenGetPortsIsCalledThenUnSupportedFeatureIsReturned) {
NEO::directoryFilesMap.insert({"/sys/class/drm/card1/device/", {"iafX.0"}});
setupExpectInitMultiple();
setupExpectCleanupMultiple();
std::vector<IafPort> ports;
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->addSubDeviceCount = false;
ze_result_t result = testIafNlApi.getPorts("/sys/class/drm/card1/device/", ports);
EXPECT_EQ(result, ZE_RESULT_ERROR_UNSUPPORTED_FEATURE);
NEO::directoryFilesMap.clear();
}
TEST_F(SysmanIafNlApiFixture, GivenOpeningFabricIdFileFailsWhenGetPortsIsCalledThenDependencyUnavailableIsReturned) {
NEO::directoryFilesMap.insert({"/sys/class/drm/card1/device/", {"iaf.0"}});
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
return -1;
});
setupExpectInitMultiple();
setupExpectCleanupMultiple();
std::vector<IafPort> ports;
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->addSubDeviceCount = false;
ze_result_t result = testIafNlApi.getPorts("/sys/class/drm/card1/device/", ports);
EXPECT_EQ(result, ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
NEO::directoryFilesMap.clear();
}
TEST_F(SysmanIafNlApiFixture, GivenReadingFabricIdFileFailsWhenGetPortsIsCalledThenDependencyUnavailableIsReturned) {
NEO::directoryFilesMap.insert({"/sys/class/drm/card1/device/", {"iaf.0"}});
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
return 1;
});
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
return 0;
});
setupExpectInitMultiple();
setupExpectCleanupMultiple();
std::vector<IafPort> ports;
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->addSubDeviceCount = false;
ze_result_t result = testIafNlApi.getPorts("/sys/class/drm/card1/device/", ports);
EXPECT_EQ(result, ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE);
NEO::directoryFilesMap.clear();
}
TEST_F(SysmanIafNlApiFixture, GivenIncorrectValueInFabricIdFileFailsWhenGetPortsIsCalledThenUnknownErrorIsReturned) {
NEO::directoryFilesMap.insert({"/sys/class/drm/card1/device/", {"iaf.0"}});
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
return 1;
});
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
std::string fabricId("0xFFFFFFFFFF");
memcpy(buf, fabricId.c_str(), fabricId.size());
return fabricId.size();
});
setupExpectInitMultiple();
setupExpectCleanupMultiple();
std::vector<IafPort> ports;
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->addSubDeviceCount = false;
ze_result_t result = testIafNlApi.getPorts("/sys/class/drm/card1/device/", ports);
EXPECT_EQ(result, ZE_RESULT_ERROR_UNKNOWN);
NEO::directoryFilesMap.clear();
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenGetPortsIsCalledAndfabricDevicePropertiesReturnsFailureThenUnknownErrorIsReturned) {
NEO::directoryFilesMap.insert({"/sys/class/drm/card1/device/", {"iaf.0"}});
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
return 1;
});
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
std::string fabricId("0x10000000");
memcpy(buf, fabricId.c_str(), fabricId.size());
return fabricId.size();
});
setupExpectInitMultiple();
setupExpectCleanupMultiple();
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockGenlRegisterFamilyArgumentValue.clear();
pMockNlApi->mockGenlRegisterFamilyReturnValue.clear();
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.clear();
std::vector<IafPort> ports;
pMockNlApi->mockGenlRegisterFamilyArgumentValue.push_back(pOps);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(-6);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(true);
ze_result_t result = testIafNlApi.getPorts("/sys/class/drm/card1/device/", ports);
EXPECT_EQ(result, ZE_RESULT_ERROR_UNKNOWN);
NEO::directoryFilesMap.clear();
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenGetPortsIsCalledAndSubdevicePropertiesGetReturnsFailureThenUnknownErrorIsReturned) {
NEO::directoryFilesMap.insert({"/sys/class/drm/card1/device/", {"iaf.0"}});
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
return 1;
});
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
std::string fabricId("0x10000000");
memcpy(buf, fabricId.c_str(), fabricId.size());
return fabricId.size();
});
setupExpectInitMultiple();
setupExpectCleanupMultiple();
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockGenlRegisterFamilyArgumentValue.clear();
pMockNlApi->mockGenlRegisterFamilyReturnValue.clear();
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.clear();
std::vector<IafPort> ports;
// Override the registerfamily to return error
pMockNlApi->mockGenlRegisterFamilyArgumentValue.push_back(pOps);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(0);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(false);
pMockNlApi->mockGenlRegisterFamilyArgumentValue.push_back(pOps);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(-6);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(true);
ze_result_t result = testIafNlApi.getPorts("/sys/class/drm/card1/device/", ports);
EXPECT_EQ(result, ZE_RESULT_ERROR_UNKNOWN);
NEO::directoryFilesMap.clear();
}
TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenGetPortsIsCalledAndFportPropertiesReturnsFailureThenUnknownErrorIsReturned) {
NEO::directoryFilesMap.insert({"/sys/class/drm/card1/device/", {"iaf.0"}});
VariableBackup<decltype(NEO::SysCalls::sysCallsOpen)> mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int {
return 1;
});
VariableBackup<decltype(NEO::SysCalls::sysCallsPread)> mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t {
std::string fabricId("0x10000000");
memcpy(buf, fabricId.c_str(), fabricId.size());
return fabricId.size();
});
setupExpectInitMultiple();
setupExpectCleanupMultiple();
MockNlApi *pMockNlApi = static_cast<MockNlApi *>(testIafNlApi.pNlApi.get());
pMockNlApi->mockGenlRegisterFamilyArgumentValue.clear();
pMockNlApi->mockGenlRegisterFamilyReturnValue.clear();
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.clear();
std::vector<IafPort> ports;
// Override the registerfamily to return error
pMockNlApi->mockGenlRegisterFamilyArgumentValue.push_back(pOps);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(0);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(false);
pMockNlApi->mockGenlRegisterFamilyArgumentValue.push_back(pOps);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(0);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(false);
pMockNlApi->mockGenlRegisterFamilyArgumentValue.push_back(pOps);
pMockNlApi->mockGenlRegisterFamilyReturnValue.push_back(-6);
pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.push_back(true);
ze_result_t result = testIafNlApi.getPorts("/sys/class/drm/card1/device/", ports);
EXPECT_EQ(result, ZE_RESULT_ERROR_UNKNOWN);
NEO::directoryFilesMap.clear();
}
} // namespace ult
} // namespace L0