* Copyright (c) 2026 Huawei Technologies Co., Ltd.
* openUBMC is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* http://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <functional>
#include <mc/common.h>
#include <mctp/mctp.h>
#include <memory>
#include <ssu_oob/ssu_oob.h>
#include <string>
#include <test_utilities/test_base.h>
#include <vector>
#include <gtest/gtest.h>
#define private public
#include "ssu_card.h"
#undef private
namespace dev {
void set_mctp_request_handler(std::function<bool(const mc::dict&, const std::vector<uint8_t>&, std::string&)> handler);
}
using namespace dev;
namespace {
const std::string TEST_ELABEL = "SN001";
std::string build_response(uint16_t status, const std::vector<uint8_t>& payload)
{
std::vector<uint8_t> rsp;
rsp.insert(rsp.end(), 4, 0);
std::vector<uint8_t> cqe(12, 0);
cqe[10] = static_cast<uint8_t>(status & 0xFF);
cqe[11] = static_cast<uint8_t>((status >> 8) & 0xFF);
rsp.insert(rsp.end(), cqe.begin(), cqe.end());
rsp.insert(rsp.end(), payload.begin(), payload.end());
return std::string(rsp.begin(), rsp.end());
}
class ssu_card_test_service : public mc::engine::service {
public:
ssu_card_test_service(const std::string& name) : mc::engine::service(name)
{}
};
class SsuChipTest : public mc::test::TestWithEngine {
protected:
static void SetUpTestSuite()
{
TestWithEngine::SetUpTestSuite();
m_service = mc::make_shared<ssu_card_test_service>("bmc.kepler.test_ssu_card");
m_service->init();
m_service->start();
}
static void TearDownTestSuite()
{
m_service->stop();
m_service.reset();
TestWithEngine::TearDownTestSuite();
}
void SetUp() override
{
dev::set_mctp_request_handler(nullptr);
m_mctp = mc::make_shared<dev::mctp>(nullptr, 0, dev::MCTP_MESSAGE_TYPE_NVME, "");
}
void TearDown() override
{
dev::set_mctp_request_handler(nullptr);
if (m_card) {
m_service->unregister_object(std::string(m_card->get_object_path()));
m_card.reset();
}
m_mctp.reset();
}
void create_card()
{
m_card = mc::make_shared<dev::ssu_card>();
m_card->set_object_name("SsuCard");
m_card->set_object_path("/bmc/dev/Systems/1/SsuCards/SsuCard");
m_service->register_object(m_card);
}
void set_ssu_oob()
{
m_card->m_ssu_oob = std::make_shared<dev::ssu_oob>(*m_mctp, 1);
}
static mc::shared_ptr<ssu_card_test_service> m_service;
mc::shared_ptr<dev::mctp> m_mctp;
mc::shared_ptr<dev::ssu_card> m_card;
};
mc::shared_ptr<ssu_card_test_service> SsuChipTest::m_service;
TEST_F(SsuChipTest, block_io_read_success)
{
const std::vector<uint8_t> payload(TEST_ELABEL.begin(), TEST_ELABEL.end());
dev::set_mctp_request_handler([payload](const mc::dict&, const std::vector<uint8_t>&, std::string& rsp) {
rsp = build_response(SSU_CMD_STATUS_SUCCESS, payload);
return true;
});
create_card();
set_ssu_oob();
auto result = m_card->m_chip.BlockIORead(0, static_cast<uint32_t>(payload.size()));
EXPECT_EQ(result, payload);
}
TEST_F(SsuChipTest, block_io_read_partial_with_padding)
{
const std::vector<uint8_t> payload(TEST_ELABEL.begin(), TEST_ELABEL.end());
dev::set_mctp_request_handler([payload](const mc::dict&, const std::vector<uint8_t>&, std::string& rsp) {
rsp = build_response(SSU_CMD_STATUS_SUCCESS, payload);
return true;
});
create_card();
set_ssu_oob();
std::vector<uint8_t> expected = {'0', '0', '1'};
expected.resize(10, 0);
auto result = m_card->m_chip.BlockIORead(2, 10);
EXPECT_EQ(result, expected);
}
TEST_F(SsuChipTest, block_io_read_offset_out_of_range)
{
const std::vector<uint8_t> payload(TEST_ELABEL.begin(), TEST_ELABEL.end());
dev::set_mctp_request_handler([payload](const mc::dict&, const std::vector<uint8_t>&, std::string& rsp) {
rsp = build_response(SSU_CMD_STATUS_SUCCESS, payload);
return true;
});
create_card();
set_ssu_oob();
auto result = m_card->m_chip.BlockIORead(10, 4);
EXPECT_EQ(result, std::vector<uint8_t>(4, 0));
}
TEST_F(SsuChipTest, block_io_read_length_zero)
{
const std::vector<uint8_t> payload(TEST_ELABEL.begin(), TEST_ELABEL.end());
dev::set_mctp_request_handler([payload](const mc::dict&, const std::vector<uint8_t>&, std::string& rsp) {
rsp = build_response(SSU_CMD_STATUS_SUCCESS, payload);
return true;
});
create_card();
set_ssu_oob();
auto result = m_card->m_chip.BlockIORead(0, 0);
EXPECT_TRUE(result.empty());
}
TEST_F(SsuChipTest, block_io_read_owner_null)
{
dev::SSUChip chip;
chip.set_owner(nullptr);
auto result = chip.BlockIORead(0, 0);
EXPECT_TRUE(result.empty());
}
TEST_F(SsuChipTest, block_io_read_oob_null)
{
create_card();
EXPECT_THROW(m_card->m_chip.BlockIORead(0, 0), mc::runtime_exception);
}
TEST_F(SsuChipTest, block_io_read_fail)
{
dev::set_mctp_request_handler([](const mc::dict&, const std::vector<uint8_t>&, std::string&) {
return false;
});
create_card();
set_ssu_oob();
auto result = m_card->m_chip.BlockIORead(0, 0);
EXPECT_TRUE(result.empty());
}
}