From aafe562bce63d9bea353b385dd25c00c8507e857 Mon Sep 17 00:00:00 2001 From: "Bari, Pratik" Date: Mon, 28 Nov 2022 11:41:56 +0000 Subject: [PATCH] Added Fabric Port ULTs Related-To: LOCI-3650 Signed-off-by: Bari, Pratik --- .../sysman/fabric_port/linux/CMakeLists.txt | 16 +- .../test_sysman_fabric_device_prelim.cpp | 399 +++++++ .../linux/test_sysman_fabric_port_prelim.cpp | 577 +++++++++++ .../sysman/linux/nl_api/CMakeLists.txt | 10 +- .../linux/nl_api/mock_iaf_nl_api_prelim.cpp | 277 +++++ .../linux/nl_api/mock_iaf_nl_api_prelim.h | 116 +++ .../linux/nl_api/mock_nl_api_prelim.cpp | 498 +++++++++ .../sysman/linux/nl_api/mock_nl_api_prelim.h | 161 +++ .../nl_api/test_sysman_iaf_nl_api_prelim.cpp | 972 ++++++++++++++++++ 9 files changed, 3018 insertions(+), 8 deletions(-) create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_sysman_fabric_device_prelim.cpp create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_sysman_fabric_port_prelim.cpp create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.cpp create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.h create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_nl_api_prelim.cpp create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_nl_api_prelim.h create mode 100644 level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/test_sysman_iaf_nl_api_prelim.cpp diff --git a/level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/CMakeLists.txt index e12c1a85ff..f146523c4a 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/CMakeLists.txt +++ b/level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/CMakeLists.txt @@ -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() diff --git a/level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_sysman_fabric_device_prelim.cpp b/level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_sysman_fabric_device_prelim.cpp new file mode 100644 index 0000000000..821dcf7693 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_sysman_fabric_device_prelim.cpp @@ -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 + +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(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(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(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 ports; + pMockIafNlApi->mockGetPortsResult = ZE_RESULT_ERROR_UNKNOWN; + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pFabricDeviceAccess->getPorts(ports)); +} + +} // namespace ult +} // namespace L0 diff --git a/level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_sysman_fabric_port_prelim.cpp b/level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_sysman_fabric_port_prelim.cpp new file mode 100644 index 0000000000..5922ed1478 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/fabric_port/linux/test_sysman_fabric_port_prelim.cpp @@ -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 + +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(pFabricPortHandleContext->pFabricDevice->getOsFabricDevice()); + PublicFabricDeviceAccessNl *pPublicFabricDeviceAccessNl = reinterpret_cast(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(pFabricPortHandleContext->pFabricDevice); + PublicLinuxFabricDeviceImp *pPublicLinuxFabricDeviceImp = reinterpret_cast(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(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(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::max(); + std::memset(properties.model, std::numeric_limits::max(), ZES_MAX_FABRIC_PORT_MODEL_SIZE); + properties.portId.fabricId = std::numeric_limits::max(); + properties.portId.attachId = std::numeric_limits::max(); + properties.portId.portNumber = std::numeric_limits::max(); + properties.maxRxSpeed.bitRate = std::numeric_limits::max(); + properties.maxRxSpeed.width = std::numeric_limits::max(); + properties.maxTxSpeed.bitRate = std::numeric_limits::max(); + properties.maxTxSpeed.width = std::numeric_limits::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::max(); + throughput.txCounter = std::numeric_limits::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 diff --git a/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/CMakeLists.txt b/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/CMakeLists.txt index bd2bd5ec58..bd11fcca34 100644 --- a/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/CMakeLists.txt +++ b/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/CMakeLists.txt @@ -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 diff --git a/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.cpp b/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.cpp new file mode 100644 index 0000000000..9ef247b85b --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.cpp @@ -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 &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 &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 \ No newline at end of file diff --git a/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.h b/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.h new file mode 100644 index 0000000000..e1ec4400f2 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_iaf_nl_api_prelim.h @@ -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 + +namespace L0 { +namespace ult { + +class MockIafNlApi : public IafNlApi { + public: + std::vector 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 &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 &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 &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 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 mockPorts = {}; + ze_result_t mockGetPortsResult = ZE_RESULT_SUCCESS; + IafPortState mockPortState = {}; +}; + +} // namespace ult +} // namespace L0 diff --git a/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_nl_api_prelim.cpp b/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_nl_api_prelim.cpp new file mode 100644 index 0000000000..915b4e6354 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_nl_api_prelim.cpp @@ -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(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(head); + bool succeeded = false; + if (0 == (pOps->o_cmds[cmdIndex].c_msg_parser)(reinterpret_cast(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(attr); + return pAttr->nested; +} + +uint32_t MockNlApi::nlaGetU32(const struct nlattr *attr) { + const MyNlattr *pAttr = reinterpret_cast(attr); + return pAttr->content & 0xFFFFFFFFUL; +} + +uint64_t MockNlApi::nlaGetU64(const struct nlattr *attr) { + const MyNlattr *pAttr = reinterpret_cast(attr); + return pAttr->content; +} + +uint8_t MockNlApi::nlaGetU8(const struct nlattr *attr) { + const MyNlattr *pAttr = reinterpret_cast(attr); + return pAttr->content & 0xFFUL; +} + +int MockNlApi::nlaIsNested(const struct nlattr *attr) { + const MyNlattr *pAttr = reinterpret_cast(attr); + return nullptr != pAttr->nested; +} + +int MockNlApi::nlaLen(const struct nlattr *attr) { + if (nullptr == attr) + return 0; + const MyNlattr *pAttr = reinterpret_cast(attr); + return sizeof(MyNlattr) + nlaLen(reinterpret_cast(pAttr->next)) + nlaLen(reinterpret_cast(pAttr->nested)); +} + +struct nlattr *MockNlApi::nlaNext(const struct nlattr *attr, int *remaining) { + const MyNlattr *pAttr = reinterpret_cast(attr); + *remaining = nlaLen(reinterpret_cast(pAttr->next)); + return reinterpret_cast(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(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(new char[128]); +} + +struct nlattr *MockNlApi::nlmsgAttrdata(const struct nlmsghdr *hdr, int attr) { + return reinterpret_cast(const_cast(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(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 diff --git a/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_nl_api_prelim.h b/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_nl_api_prelim.h new file mode 100644 index 0000000000..a239c23f15 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/mock_nl_api_prelim.h @@ -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 + +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 mockNlSocketAllocReturnValue{}; + std::vector mockGenlRegisterFamilyArgumentValue{}; + std::vector mockNlmsgAllocReturnValue{}; + std::vector mockGenlmsgPutReturnValue{}; + std::vector mockGenlRegisterFamilyReturnValue{}; + std::vector mockGenlConnectReturnValue{}; + std::vector mockGenlOpsResolveReturnValue{}; + std::vector mockGenCtrlResolveReturnValue{}; + std::vector mockNlSocketModifyCbReturnValue{}; + std::vector mockNlRecvmsgsDefaultReturnValue{}; + std::vector mockGenlUnregisterFamilyReturnValue{}; + std::vector mockNlSendAutoReturnValue{}; + std::vector mockLoadEntryPointsReturnValue{}; + std::vector 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 testFabricIds; + + private: + int cmdIndex = 0; + std::map 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 diff --git a/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/test_sysman_iaf_nl_api_prelim.cpp b/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/test_sysman_iaf_nl_api_prelim.cpp new file mode 100644 index 0000000000..c975a9a694 --- /dev/null +++ b/level_zero/tools/test/unit_tests/sources/sysman/linux/nl_api/test_sysman_iaf_nl_api_prelim.cpp @@ -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 +#include + +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> 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(); + + 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(testIafNlApi.pNlApi.get()); + pMockNlApi->mockNlSendAutoReturnValue.push_back(0); +} + +void SysmanIafNlApiFixture::setupExpectInit() { + MockNlApi *pMockNlApi = static_cast(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(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(testIafNlApi.pNlApi.get()); + pMockNlApi->mockGenlUnregisterFamilyReturnValue.push_back(0); + pMockNlApi->isRepeated = true; +} + +void SysmanIafNlApiFixture::setupExpectCleanup() { + MockNlApi *pMockNlApi = static_cast(testIafNlApi.pNlApi.get()); + pMockNlApi->mockGenlUnregisterFamilyReturnValue.push_back(0); +} + +TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenLoadEntryPointsFailsThenInitRepeatedlyReturnsDependencyUnavailable) { + MockNlApi *pMockNlApi = static_cast(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(testIafNlApi.pNlApi.get()); + setupExpectInit(); + setupExpectCleanup(); + setupExpectCommand(IAF_CMD_OP_ROUTING_GEN_QUERY); + uint32_t start = std::numeric_limits::max(), end = std::numeric_limits::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(testIafNlApi.pNlApi.get()); + setupExpectInit(); + setupExpectCleanup(); + setupExpectCommand(IAF_CMD_OP_ROUTING_GEN_QUERY); + uint32_t start = std::numeric_limits::max(), end = std::numeric_limits::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(testIafNlApi.pNlApi.get()); + pMockNlApi->mockLoadEntryPointsReturnValue.push_back(false); + uint32_t start = std::numeric_limits::max(), end = std::numeric_limits::max(); + EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, testIafNlApi.routingGenQuery(start, end)); +} + +TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenRoutingGenQueryCalledAndNlmsgAllocFailsThenUnknownErrorReturned) { + MockNlApi *pMockNlApi = static_cast(testIafNlApi.pNlApi.get()); + setupExpectInit(); + setupExpectCleanup(); + pMockNlApi->mockNlmsgAllocReturnValue.push_back(nullptr); + uint32_t start = std::numeric_limits::max(), end = std::numeric_limits::max(); + EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, testIafNlApi.routingGenQuery(start, end)); +} + +TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenGetThroughputCalledThenRxCounterAndTxCounterReturned) { + MockNlApi *pMockNlApi = static_cast(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::max(); + throughput.rxCounter = std::numeric_limits::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(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::max(); + throughput.rxCounter = std::numeric_limits::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 fabricIds; + + setupExpectInit(); + setupExpectCleanup(); + setupExpectCommand(IAF_CMD_OP_DEVICE_ENUM); + fabricIds.clear(); + MockNlApi *mockNlApi = static_cast(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(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(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(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(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(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(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(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(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(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(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 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(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 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(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 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(testIafNlApi.pNlApi.get()); + pMockNlApi->mockLoadEntryPointsReturnValue.push_back(false); + + uint64_t guid = 0; + std::vector 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(testIafNlApi.pNlApi.get()); + setupExpectInit(); + setupExpectCleanup(); + pMockNlApi->mockNlmsgAllocReturnValue.push_back(nullptr); + uint64_t guid = 0; + std::vector 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(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(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(state.healthStatus)); +} + +TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWhenFPortStatusQueryCalledAndPortHealthOffThenPortStatusDisabledReturned) { + MockNlApi *pMockNlApi = static_cast(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(state.healthStatus)); +} + +TEST_F(SysmanIafNlApiFixture, GivenIafNlApiWithLegacyIafPortsWhenGetPortsIsCalledValidPortsAreReturned) { + NEO::directoryFilesMap.insert({"/sys/class/drm/card1/device/", {"iaf.0"}}); + + VariableBackup mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int { + std::vector 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(std::distance(supportedFiles.begin(), itr)) + 1; + } + return 0; + }); + + VariableBackup 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 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 mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int { + return 1; + }); + + VariableBackup 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 ports; + + MockNlApi *pMockNlApi = static_cast(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 ports; + + MockNlApi *pMockNlApi = static_cast(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 mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int { + return -1; + }); + + setupExpectInitMultiple(); + setupExpectCleanupMultiple(); + + std::vector ports; + MockNlApi *pMockNlApi = static_cast(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 mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int { + return 1; + }); + + VariableBackup mockPread(&NEO::SysCalls::sysCallsPread, [](int fd, void *buf, size_t count, off_t offset) -> ssize_t { + return 0; + }); + + setupExpectInitMultiple(); + setupExpectCleanupMultiple(); + + std::vector ports; + MockNlApi *pMockNlApi = static_cast(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 mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int { + return 1; + }); + + VariableBackup 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 ports; + MockNlApi *pMockNlApi = static_cast(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 mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int { + return 1; + }); + VariableBackup 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(testIafNlApi.pNlApi.get()); + pMockNlApi->mockGenlRegisterFamilyArgumentValue.clear(); + pMockNlApi->mockGenlRegisterFamilyReturnValue.clear(); + pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.clear(); + + std::vector 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 mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int { + return 1; + }); + VariableBackup 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(testIafNlApi.pNlApi.get()); + pMockNlApi->mockGenlRegisterFamilyArgumentValue.clear(); + pMockNlApi->mockGenlRegisterFamilyReturnValue.clear(); + pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.clear(); + + std::vector 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 mockOpen(&NEO::SysCalls::sysCallsOpen, [](const char *pathname, int flags) -> int { + return 1; + }); + VariableBackup 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(testIafNlApi.pNlApi.get()); + pMockNlApi->mockGenlRegisterFamilyArgumentValue.clear(); + pMockNlApi->mockGenlRegisterFamilyReturnValue.clear(); + pMockNlApi->isMockGenlRegisterFamilyRepeatedCall.clear(); + + std::vector 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