* Copyright (c) 2025 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 <chrono>
#include <cstdlib>
#include <fstream>
#include <internal/bus/bus_base/bus.h>
#include <internal/chip/chip_base/chip.h>
#if COMPONENT_DRIVERS_ENABLE_UNIDEV
#include <internal/chip/chip_spi_flash/spi_flash.h>
#endif
#include <internal/hasdef.h>
#include <mc/dict.h>
#include <mc/engine/context.h>
#include <memory>
#include <stdexcept>
#include <string>
#include <thread>
#include <unistd.h>
#include <vector>
#include <gtest/gtest.h>
#include "../test_utils/mock_bus.h"
namespace {
static std::vector<uint8_t> seri_pack_string(const std::vector<uint8_t>& raw)
{
std::vector<uint8_t> buf;
size_t len = raw.size();
constexpr uint8_t TYPE_SHORT_STRING = 4;
constexpr uint8_t TYPE_LONG_STRING = 5;
constexpr int MAX_COOKIE = 32;
if (len < MAX_COOKIE) {
buf.push_back(static_cast<uint8_t>(TYPE_SHORT_STRING | (len << 3)));
buf.insert(buf.end(), raw.begin(), raw.end());
} else if (len < 0x10000) {
buf.push_back(static_cast<uint8_t>(TYPE_LONG_STRING | (2 << 3)));
uint16_t x = static_cast<uint16_t>(len);
buf.insert(buf.end(), reinterpret_cast<uint8_t*>(&x), reinterpret_cast<uint8_t*>(&x) + sizeof(x));
buf.insert(buf.end(), raw.begin(), raw.end());
} else {
buf.push_back(static_cast<uint8_t>(TYPE_LONG_STRING | (4 << 3)));
uint32_t x = static_cast<uint32_t>(len);
buf.insert(buf.end(), reinterpret_cast<uint8_t*>(&x), reinterpret_cast<uint8_t*>(&x) + sizeof(x));
buf.insert(buf.end(), raw.begin(), raw.end());
}
return buf;
}
class test_bus : public dev::bus_base {
public:
test_bus() = default;
~test_bus() override = default;
uint32_t read(ACCESS_DATA_S& input) override
{
++m_read_call_count;
m_last_access = input;
if (!m_read_payloads.empty()) {
input.out_buffer = m_read_payloads.front();
m_read_payloads.erase(m_read_payloads.begin());
} else {
input.out_buffer.clear();
}
return m_read_result;
}
uint32_t write(ACCESS_DATA_S& input) override
{
++m_write_call_count;
m_last_access = input;
return m_write_result;
}
uint8_t get_id() override
{
return m_id;
}
void bus_lock() override
{
++m_lock_call_count;
}
void bus_unlock() override
{
++m_unlock_call_count;
}
void set_id(uint8_t id)
{
m_id = id;
}
void set_read_result(int32_t result)
{
m_read_result = result;
}
void set_write_result(int32_t result)
{
m_write_result = result;
}
void add_read_payload(const std::vector<uint8_t>& payload)
{
m_read_payloads.push_back(payload);
}
ACCESS_DATA_S m_last_access{};
int m_read_call_count = 0;
int m_write_call_count = 0;
int m_lock_call_count = 0;
int m_unlock_call_count = 0;
private:
uint8_t m_id = 0;
int32_t m_read_result = HAS_OK;
int32_t m_write_result = HAS_OK;
std::vector<std::vector<uint8_t>> m_read_payloads;
};
class trace_context_chip : public dev::chip_base {
public:
int32_t read_with_forward_trace_context(const ACCESS_DATA_S& context, std::vector<uint8_t>& out_buffer)
{
const ACCESS_DATA_S* previous = set_forward_trace_context(&context);
std::vector<uint8_t> in_buffer;
std::string error;
try {
int32_t ret = block_read(0x10, 2, in_buffer, out_buffer, error);
set_forward_trace_context(previous);
return ret;
} catch (...) {
set_forward_trace_context(previous);
throw;
}
}
};
class chip_base_test : public ::testing::Test {
protected:
void SetUp() override
{
m_bus = std::make_shared<test_bus>();
m_bus->set_id(1);
m_chip = std::make_shared<dev::chip_base>();
const char* root_dir = std::getenv("ROOT_DIR");
if (root_dir != nullptr && root_dir[0] != '\0') {
m_test_dir = std::string(root_dir) + "/opt/bmc/lualib";
} else {
char cwd[4096];
m_test_dir = std::string(getcwd(cwd, sizeof(cwd))) + "/opt/bmc/lualib";
}
std::string plugin_dir = m_test_dir + "/hwproxy/plugins/test_plugin";
std::string cmd = "mkdir -p " + plugin_dir;
std::system(cmd.c_str());
std::string dst_file = plugin_dir + "/init.lua";
bool plugin_created = false;
const char* src_root = std::getenv("MESON_SOURCE_ROOT");
if (src_root) {
std::string src_file = std::string(src_root) + "/tests/drivers/internal/chip/test_plugin/init.lua";
std::string cp_cmd = "cp " + src_file + " " + dst_file + " 2>/dev/null";
int ret = std::system(cp_cmd.c_str());
std::ifstream check(dst_file);
if (check.good() && check.peek() != std::ifstream::traits_type::eof()) {
plugin_created = true;
}
check.close();
}
if (!plugin_created) {
std::ofstream f(dst_file);
f << R"lua(
local M = {}
M._cmds = {}
function M._cmds.read_data(chip, params)
local data = chip:block_read(0x10, 4)
return data
end
function M._cmds.echo(chip, params)
return params
end
function M:has_cmd(cmd)
return M._cmds[cmd] ~= nil
end
function M:run_cmd(chip, cmd, params)
return self._cmds[cmd](chip, params)
end
return M
)lua";
f.flush();
f.close();
}
}
void TearDown() override
{}
std::shared_ptr<test_bus> m_bus;
std::shared_ptr<dev::chip_base> m_chip;
std::string m_test_dir;
};
TEST_F(chip_base_test, constructor_and_destructor)
{
dev::chip_base chip;
EXPECT_EQ(chip.get_left_chip(), nullptr);
EXPECT_EQ(chip.get_left_bus(), nullptr);
EXPECT_EQ(chip.get_host_bus(), nullptr);
}
TEST_F(chip_base_test, init_success)
{
mc::mutable_dict csr_object;
csr_object["Address"] = static_cast<uint32_t>(0x70);
csr_object["OffsetWidth"] = static_cast<uint8_t>(1);
csr_object["AddrWidth"] = static_cast<uint8_t>(1);
csr_object["WriteTmout"] = static_cast<uint32_t>(100);
csr_object["ReadTmout"] = static_cast<uint32_t>(100);
EXPECT_TRUE(m_chip->init(csr_object));
}
TEST_F(chip_base_test, init_all_optional_fields_and_get_object_name)
{
mc::mutable_dict csr_object;
csr_object["Address"] = static_cast<uint32_t>(0x70);
csr_object["OffsetWidth"] = static_cast<uint8_t>(1);
csr_object["AddrWidth"] = static_cast<uint8_t>(1);
csr_object["WriteTmout"] = static_cast<uint32_t>(100);
csr_object["ReadTmout"] = static_cast<uint32_t>(100);
csr_object["RwBlockSize"] = static_cast<uint8_t>(32);
csr_object["WriteInterval"] = static_cast<uint8_t>(2);
csr_object["ReadInterval"] = static_cast<uint8_t>(3);
csr_object["WriteRetryTimes"] = static_cast<uint8_t>(4);
csr_object["ReadRetryTimes"] = static_cast<uint8_t>(5);
csr_object["DrvWriteDelay"] = static_cast<uint8_t>(6);
csr_object["object_name"] = std::string("chip-base-full");
EXPECT_TRUE(m_chip->init(csr_object));
EXPECT_EQ(m_chip->get_object_name(), "chip-base-full");
}
TEST_F(chip_base_test, init_partial_fields)
{
mc::mutable_dict csr_object;
csr_object["Address"] = static_cast<uint32_t>(0x70);
EXPECT_TRUE(m_chip->init(csr_object));
}
TEST_F(chip_base_test, address_configured_flag_tracks_init_and_update)
{
EXPECT_FALSE(m_chip->is_address_configured());
mc::mutable_dict without_address;
ASSERT_TRUE(m_chip->init(without_address));
EXPECT_FALSE(m_chip->is_address_configured());
m_chip->update_address(0x5A);
EXPECT_TRUE(m_chip->is_address_configured());
EXPECT_EQ(m_chip->get_address(), 0x5A);
ASSERT_TRUE(m_chip->init(without_address));
EXPECT_FALSE(m_chip->is_address_configured());
mc::mutable_dict with_address;
with_address["Address"] = static_cast<uint32_t>(0x70);
ASSERT_TRUE(m_chip->init(with_address));
EXPECT_TRUE(m_chip->is_address_configured());
EXPECT_EQ(m_chip->get_address(), 0x70);
}
TEST_F(chip_base_test, binding_address_is_not_treated_as_configured)
{
const char* bindings[] = {R"json($sync:{"properties":["/bmc/kepler/Nodes/Node_1/Base"]})json",
R"json($const:{"properties":[1],"expressions":["expr($1)"]})json"};
for (const char* binding : bindings) {
mc::mutable_dict csr_object;
csr_object["object_name"] = std::string("chip-binding-address");
csr_object["Address"] = std::string(binding);
ASSERT_TRUE(m_chip->init(csr_object));
EXPECT_EQ(m_chip->get_address(), 0u) << binding;
EXPECT_FALSE(m_chip->is_address_configured()) << binding;
}
}
class explicit_address_probe : public dev::chip_base {
public:
void apply_value(const mc::variant& value, const std::string& field_name)
{
apply_explicit_address_value(value, field_name, get_object_name());
}
};
TEST_F(chip_base_test, explicit_address_value_helper_contract)
{
explicit_address_probe chip;
mc::mutable_dict csr;
csr["object_name"] = std::string("chip-address-helper");
ASSERT_TRUE(chip.init(csr));
chip.apply_value(static_cast<uint32_t>(2), "ChipSelect");
EXPECT_EQ(chip.get_address(), 2u);
EXPECT_TRUE(chip.is_address_configured());
chip.apply_value(std::string("$sync:/bmc/dev/Systems/1/SPI/ChipSelect"), "ChipSelect");
EXPECT_EQ(chip.get_address(), 0u);
EXPECT_FALSE(chip.is_address_configured());
chip.apply_value(mc::variant(), "ChipSelect");
EXPECT_EQ(chip.get_address(), 0u);
EXPECT_FALSE(chip.is_address_configured());
}
#if COMPONENT_DRIVERS_ENABLE_UNIDEV
TEST_F(chip_base_test, chip_select_uses_explicit_address_contract)
{
dev::chip_spi_flash chip;
mc::mutable_dict csr;
csr["object_name"] = std::string("chip-spi-cs");
csr["ChipSelect"] = static_cast<uint32_t>(2);
ASSERT_TRUE(chip.init(csr));
EXPECT_EQ(chip.get_address(), 2u);
EXPECT_TRUE(chip.is_address_configured());
dev::chip_spi_flash binding_chip;
mc::mutable_dict binding_csr;
binding_csr["object_name"] = std::string("chip-spi-cs-binding");
binding_csr["ChipSelect"] = std::string("$sync:/bmc/dev/Systems/1/SPI/ChipSelect");
ASSERT_TRUE(binding_chip.init(binding_csr));
EXPECT_EQ(binding_chip.get_address(), 0u);
EXPECT_FALSE(binding_chip.is_address_configured());
}
#endif
TEST_F(chip_base_test, init_nested_interface_form)
{
mc::mutable_dict inner;
inner["Address"] = static_cast<uint32_t>(0x60);
inner["OffsetWidth"] = static_cast<uint8_t>(1);
inner["AddrWidth"] = static_cast<uint8_t>(1);
mc::mutable_dict csr_object;
csr_object["bmc.dev.Chip.Smc"] = inner;
csr_object["object_name"] = std::string("chip-nested");
EXPECT_TRUE(m_chip->init(csr_object));
EXPECT_EQ(m_chip->get_address(), static_cast<uint32_t>(0x60));
EXPECT_EQ(m_chip->get_offset_width(), static_cast<uint8_t>(1));
EXPECT_EQ(m_chip->get_address_width(), static_cast<uint8_t>(1));
}
TEST_F(chip_base_test, init_top_level_takes_priority_over_nested)
{
mc::mutable_dict inner;
inner["Address"] = static_cast<uint32_t>(0x61);
mc::mutable_dict csr_object;
csr_object["Address"] = static_cast<uint32_t>(0x60);
csr_object["bmc.dev.Chip.Smc"] = inner;
EXPECT_TRUE(m_chip->init(csr_object));
EXPECT_EQ(m_chip->get_address(), static_cast<uint32_t>(0x60));
}
TEST_F(chip_base_test, init_ambiguous_nested_interfaces_do_not_choose_arbitrarily)
{
mc::mutable_dict smc;
smc["Address"] = static_cast<uint32_t>(0x60);
mc::mutable_dict cpld;
cpld["Address"] = static_cast<uint32_t>(0x61);
mc::mutable_dict csr_object;
csr_object["bmc.dev.Chip.Smc"] = smc;
csr_object["bmc.dev.Chip.Cpld"] = cpld;
EXPECT_TRUE(m_chip->init(csr_object));
EXPECT_EQ(m_chip->get_address(), static_cast<uint32_t>(0));
}
TEST_F(chip_base_test, default_bus_type_is_forwarded_to_bus_access)
{
mc::mutable_dict csr_object;
ASSERT_TRUE(m_chip->init(csr_object));
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
ASSERT_EQ(m_chip->block_read(0x10, 1, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(m_bus->m_last_access.bus_type, 0);
}
TEST_F(chip_base_test, configured_bus_type_is_forwarded_to_bus_access)
{
mc::mutable_dict csr_object;
csr_object["BusType"] = static_cast<uint8_t>(2);
ASSERT_TRUE(m_chip->init(csr_object));
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
std::vector<uint8_t> in_buffer = {0x01};
std::vector<uint8_t> out_buffer;
std::string error;
ASSERT_EQ(m_chip->block_write(0x10, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(m_bus->m_last_access.bus_type, 2);
}
TEST_F(chip_base_test, init_empty_dict)
{
mc::mutable_dict csr_object;
EXPECT_TRUE(m_chip->init(csr_object));
}
TEST_F(chip_base_test, init_exception)
{
mc::mutable_dict csr_object;
csr_object["Address"] = std::string("invalid");
EXPECT_FALSE(m_chip->init(csr_object));
}
TEST_F(chip_base_test, set_and_get_left_chip)
{
auto left_chip = std::make_shared<dev::chip_base>();
m_chip->set_left_chip(left_chip);
auto retrieved_chip = m_chip->get_left_chip();
EXPECT_NE(retrieved_chip, nullptr);
EXPECT_EQ(retrieved_chip, left_chip);
}
TEST_F(chip_base_test, set_and_get_left_bus)
{
m_chip->set_left_bus(m_bus);
auto retrieved_bus = m_chip->get_left_bus();
EXPECT_NE(retrieved_bus, nullptr);
EXPECT_EQ(retrieved_bus, m_bus);
}
TEST_F(chip_base_test, set_and_get_host_bus)
{
m_chip->set_host_bus(m_bus);
auto retrieved_bus = m_chip->get_host_bus();
EXPECT_NE(retrieved_bus, nullptr);
EXPECT_EQ(retrieved_bus, m_bus);
}
TEST_F(chip_base_test, chip_init)
{
int32_t ret = m_chip->chip_init();
EXPECT_EQ(ret, HAS_OK);
}
TEST_F(chip_base_test, chip_test)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
std::vector<uint8_t> data = {0x42};
m_bus->add_read_payload(data);
m_bus->add_read_payload(data);
uint32_t result = 0;
int32_t ret = m_chip->chip_test(&result);
EXPECT_EQ(ret, HAS_OK);
EXPECT_EQ(result, 1U);
}
TEST_F(chip_base_test, chip_test_inconsistent)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_bus->add_read_payload({0x42});
m_bus->add_read_payload({0x99});
uint32_t result = 1;
int32_t ret = m_chip->chip_test(&result);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_EQ(result, 0U);
}
TEST_F(chip_base_test, chip_test_no_bus)
{
uint32_t result = 1;
int32_t ret = m_chip->chip_test(&result);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_EQ(result, 0U);
}
TEST_F(chip_base_test, chip_reset)
{
int32_t ret = m_chip->chip_reset();
EXPECT_EQ(ret, HAS_OK);
}
TEST_F(chip_base_test, open_channel)
{
int32_t ret = m_chip->open_channel(m_bus);
EXPECT_EQ(ret, HAS_OK);
}
TEST_F(chip_base_test, close_channel)
{
int32_t ret = m_chip->close_channel(m_bus);
EXPECT_EQ(ret, HAS_OK);
}
TEST_F(chip_base_test, update_drv_write_delay_is_forwarded_to_access_data)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_chip->update_drv_write_delay(9);
std::vector<uint8_t> in_buffer = {0x01};
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip->block_write(0x10, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(m_bus->m_last_access.drv_write_delay, 9);
}
TEST_F(chip_base_test, bit_read_success)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_bus->set_read_result(HAS_OK);
std::vector<uint8_t> read_data = {0x01, 0x02};
m_bus->add_read_payload(read_data);
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->bit_read(0x10, 2, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(error.empty());
}
TEST_F(chip_base_test, bit_read_applies_uint8_uint16_and_uint32_masks)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
m_bus->add_read_payload({0xF0});
EXPECT_EQ(m_chip->bit_read(0x10, sizeof(uint8_t), 0xF0, in_buffer, out_buffer, error), HAS_OK);
ASSERT_EQ(out_buffer.size(), 1U);
EXPECT_EQ(out_buffer[0], 0x0F);
m_bus->add_read_payload({0x34, 0x12});
EXPECT_EQ(m_chip->bit_read(0x10, sizeof(uint16_t), 0x0FF0, in_buffer, out_buffer, error), HAS_OK);
ASSERT_EQ(out_buffer.size(), 2U);
EXPECT_EQ(out_buffer[0], 0x23);
EXPECT_EQ(out_buffer[1], 0x00);
m_bus->add_read_payload({0x78, 0x56, 0x34, 0x12});
EXPECT_EQ(m_chip->bit_read(0x10, sizeof(uint32_t), 0x00FFFF00, in_buffer, out_buffer, error), HAS_OK);
ASSERT_EQ(out_buffer.size(), 4U);
EXPECT_EQ(out_buffer[0], 0x56);
EXPECT_EQ(out_buffer[1], 0x34);
EXPECT_EQ(out_buffer[2], 0x00);
EXPECT_EQ(out_buffer[3], 0x00);
}
TEST_F(chip_base_test, bit_read_returns_error_for_unsupported_mask_length)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_bus->add_read_payload({0x01, 0x02, 0x03});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip->bit_read(0x10, 3, 0xFF, in_buffer, out_buffer, error), HAS_ERR);
EXPECT_EQ(error, "bit_read invalid length");
}
TEST_F(chip_base_test, bit_read_no_bus)
{
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_THROW(m_chip->bit_read(0x10, 2, 0xFF, in_buffer, out_buffer, error), mc::invalid_op_exception);
}
TEST_F(chip_base_test, bit_write_success)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_bus->set_write_result(HAS_OK);
std::vector<uint8_t> in_buffer = {0x01, 0x02};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->bit_write(0x10, 2, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(error.empty());
}
TEST_F(chip_base_test, bit_write_no_bus)
{
std::vector<uint8_t> in_buffer = {0x01, 0x02};
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_THROW(m_chip->bit_write(0x10, 2, 0xFF, in_buffer, out_buffer, error), mc::invalid_op_exception);
}
TEST_F(chip_base_test, block_read_success)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_bus->set_read_result(HAS_OK);
std::vector<uint8_t> read_data = {0x01, 0x02, 0x03};
m_bus->add_read_payload(read_data);
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->block_read(0x10, 3, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(error.empty());
EXPECT_EQ(out_buffer.size(), 3);
}
TEST_F(chip_base_test, block_read_no_bus)
{
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_THROW(m_chip->block_read(0x10, 3, in_buffer, out_buffer, error), mc::invalid_op_exception);
}
class front_mux_chip : public dev::chip_base {
public:
int32_t open_channel(std::shared_ptr<dev::bus_base> bus) override
{
(void)bus;
if (fail_attempts > 0) {
--fail_attempts;
if (throw_on_open) {
throw std::runtime_error("Pca9545 bus select failed: mock i2c write fail");
}
return open_result;
}
return HAS_OK;
}
int fail_attempts = 0;
bool throw_on_open = false;
int32_t open_result = HAS_OK;
};
TEST_F(chip_base_test, front_chip_open_throw_is_attributed_to_front_chip)
{
auto mux = std::make_shared<front_mux_chip>();
mux->throw_on_open = true;
mux->fail_attempts = 3;
m_chip->set_left_chip(mux);
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
int failed_conclusion = 0;
int ok_conclusion = 0;
mux->set_health_observer([&](uint8_t status, bool validity, bool from_external, uint64_t seq) {
EXPECT_TRUE(validity);
EXPECT_FALSE(from_external);
EXPECT_EQ(seq, 0U);
if (status == 1) {
++failed_conclusion;
} else {
++ok_conclusion;
}
});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->block_read(0x10, 3, in_buffer, out_buffer, error);
EXPECT_NE(ret, HAS_OK);
EXPECT_TRUE(m_chip->get_last_failure_from_front_chip());
EXPECT_EQ(m_chip->get_last_status_code(), HAS_OK);
EXPECT_EQ(m_chip->get_read_failure_count(), 0U);
EXPECT_EQ(failed_conclusion, 1);
EXPECT_EQ(ok_conclusion, 0);
EXPECT_NE(error.find("open_channel failed for left chip"), std::string::npos);
}
TEST_F(chip_base_test, front_chip_open_return_error_is_attributed_to_front_chip)
{
auto mux = std::make_shared<front_mux_chip>();
mux->open_result = HAS_ERR;
mux->fail_attempts = 3;
m_chip->set_left_chip(mux);
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
int failed_conclusion = 0;
mux->set_health_observer([&](uint8_t status, bool validity, bool from_external, uint64_t seq) {
if (status == 1) {
++failed_conclusion;
}
});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->block_read(0x10, 3, in_buffer, out_buffer, error);
EXPECT_NE(ret, HAS_OK);
EXPECT_TRUE(m_chip->get_last_failure_from_front_chip());
EXPECT_EQ(m_chip->get_read_failure_count(), 0U);
EXPECT_EQ(failed_conclusion, 1);
}
TEST_F(chip_base_test, front_chip_failure_mark_consumed_once)
{
m_chip->mark_front_chip_failure();
EXPECT_TRUE(m_chip->consume_front_chip_failure());
EXPECT_FALSE(m_chip->get_last_failure_from_front_chip());
EXPECT_FALSE(m_chip->consume_front_chip_failure());
}
TEST_F(chip_base_test, front_chip_open_retries_then_succeeds)
{
auto mux = std::make_shared<front_mux_chip>();
mux->throw_on_open = true;
mux->fail_attempts = 2;
mux->set_left_bus(m_bus);
mux->set_host_bus(m_bus);
m_chip->set_left_chip(mux);
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
int failed_conclusion = 0;
int ok_conclusion = 0;
mux->set_health_observer([&](uint8_t status, bool validity, bool from_external, uint64_t seq) {
if (status == 1) {
++failed_conclusion;
} else {
++ok_conclusion;
}
});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->block_read(0x10, 3, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_FALSE(m_chip->get_last_failure_from_front_chip());
EXPECT_EQ(m_chip->get_read_failure_count(), 0U);
EXPECT_EQ(failed_conclusion, 0);
EXPECT_EQ(ok_conclusion, 1);
}
TEST_F(chip_base_test, front_chip_open_success_notifies_front_chip_and_counts_own_access)
{
auto mux = std::make_shared<front_mux_chip>();
mux->set_left_bus(m_bus);
mux->set_host_bus(m_bus);
m_chip->set_left_chip(mux);
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
int failed_conclusion = 0;
int ok_conclusion = 0;
mux->set_health_observer([&](uint8_t status, bool validity, bool from_external, uint64_t seq) {
if (status == 1) {
++failed_conclusion;
} else {
++ok_conclusion;
}
});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->block_read(0x10, 3, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_FALSE(m_chip->get_last_failure_from_front_chip());
EXPECT_EQ(m_chip->get_read_failure_count(), 0U);
EXPECT_EQ(ok_conclusion, 1);
EXPECT_EQ(failed_conclusion, 0);
}
TEST_F(chip_base_test, block_write_success)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_bus->set_write_result(HAS_OK);
std::vector<uint8_t> in_buffer = {0x01, 0x02, 0x03};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->block_write(0x10, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(error.empty());
}
TEST_F(chip_base_test, trace_state_is_forwarded_to_bus_access)
{
mc::mutable_dict csr_object;
csr_object["Address"] = static_cast<uint32_t>(0x70);
csr_object["OffsetWidth"] = static_cast<uint8_t>(1);
csr_object["object_name"] = std::string("trace-chip");
ASSERT_TRUE(m_chip->init(csr_object));
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_chip->set_trace_enabled(true);
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip->block_read(0x10, 2, in_buffer, out_buffer, error), HAS_OK);
EXPECT_TRUE(m_bus->m_last_access.trace_enabled);
EXPECT_EQ(m_bus->m_last_access.trace_chip_name, "trace-chip");
m_chip->set_trace_enabled(false);
EXPECT_EQ(m_chip->block_write(0x20, std::vector<uint8_t>{0x01}, out_buffer, error), HAS_OK);
EXPECT_FALSE(m_bus->m_last_access.trace_enabled);
}
TEST_F(chip_base_test, trace_requestor_falls_back_to_current_context)
{
mc::mutable_dict csr_object;
csr_object["Address"] = static_cast<uint32_t>(0x70);
csr_object["OffsetWidth"] = static_cast<uint8_t>(1);
csr_object["object_name"] = std::string("trace-chip");
ASSERT_TRUE(m_chip->init(csr_object));
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_chip->set_trace_enabled(true);
mc::engine::context ctx;
ctx.set_extensions_arg("Requestor", std::string("MyScanner"));
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
mc::engine::with_context(std::move(ctx), [&]() {
EXPECT_EQ(m_chip->block_read(0x10, 2, in_buffer, out_buffer, error), HAS_OK);
});
EXPECT_EQ(m_bus->m_last_access.trace_requestor, "MyScanner");
}
TEST_F(chip_base_test, trace_requestor_not_read_when_trace_disabled)
{
mc::mutable_dict csr_object;
csr_object["Address"] = static_cast<uint32_t>(0x70);
csr_object["OffsetWidth"] = static_cast<uint8_t>(1);
csr_object["object_name"] = std::string("trace-chip");
ASSERT_TRUE(m_chip->init(csr_object));
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_chip->set_trace_enabled(false);
mc::engine::context ctx;
ctx.set_extensions_arg("Requestor", std::string("MyScanner"));
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
mc::engine::with_context(std::move(ctx), [&]() {
EXPECT_EQ(m_chip->block_read(0x10, 2, in_buffer, out_buffer, error), HAS_OK);
});
EXPECT_TRUE(m_bus->m_last_access.trace_requestor.empty());
}
TEST_F(chip_base_test, block_write_no_bus)
{
std::vector<uint8_t> in_buffer = {0x01, 0x02};
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_THROW(m_chip->block_write(0x10, in_buffer, out_buffer, error), mc::invalid_op_exception);
}
TEST_F(chip_base_test, block_write_read_success)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_bus->set_read_result(HAS_OK);
m_bus->set_write_result(HAS_OK);
std::vector<uint8_t> read_data = {0x01, 0x02};
m_bus->add_read_payload(read_data);
std::vector<uint8_t> indata = {0xAA, 0xBB};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->block_write_read(0x10, indata, 2, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(error.empty());
}
TEST_F(chip_base_test, block_write_read_with_extend_read_mode_does_not_set_protocol_flag)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_bus->set_read_result(HAS_OK);
m_bus->set_write_result(HAS_OK);
std::vector<uint8_t> read_data = {0x01, 0x02};
m_bus->add_read_payload(read_data);
std::vector<uint8_t> indata = {0xAA, 0xBB};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->block_write_read(dev::CHIP_EXTEND_READ_MODE, indata, 2, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_EQ(m_bus->m_last_access.offset, dev::CHIP_EXTEND_READ_MODE);
EXPECT_EQ(m_bus->m_last_access.protocol_flag, 0);
}
TEST_F(chip_base_test, block_write_read_with_explicit_protocol_flag)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_bus->set_read_result(HAS_OK);
m_bus->set_write_result(HAS_OK);
std::vector<uint8_t> read_data = {0x01, 0x02};
m_bus->add_read_payload(read_data);
std::vector<uint8_t> indata = {0xAA, 0xBB};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->block_write_read(0x10, indata, 2, out_buffer, error, 0x02);
EXPECT_EQ(ret, HAS_OK);
EXPECT_EQ(m_bus->m_last_access.protocol_flag, 0x02);
}
TEST_F(chip_base_test, combo_block_write_read_success)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_bus->set_read_result(HAS_OK);
m_bus->set_write_result(HAS_OK);
std::vector<uint8_t> read_data = {0x01, 0x02};
m_bus->add_read_payload(read_data);
std::vector<uint8_t> write_buffer = {0xAA};
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->combo_block_write_read(0x10, write_buffer, 0x20, 2, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(error.empty());
}
TEST_F(chip_base_test, combo_block_write_read_write_failure)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_bus->set_write_result(HAS_ERR);
std::vector<uint8_t> write_buffer = {0xAA};
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->combo_block_write_read(0x10, write_buffer, 0x20, 2, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_base_test, combo_block_write_read_read_failure)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_bus->set_write_result(HAS_OK);
m_bus->set_read_result(HAS_ERR);
std::vector<uint8_t> write_buffer = {0xAA};
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->combo_block_write_read(0x10, write_buffer, 0x20, 2, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_NE(error.find("combo_block_write_read read failed"), std::string::npos);
}
TEST_F(chip_base_test, init_multiple_times)
{
mc::mutable_dict csr_object1;
csr_object1["Address"] = static_cast<uint32_t>(0x70);
EXPECT_TRUE(m_chip->init(csr_object1));
mc::mutable_dict csr_object2;
csr_object2["Address"] = static_cast<uint32_t>(0x71);
EXPECT_TRUE(m_chip->init(csr_object2));
}
#if !COMPONENT_DRIVERS_ENABLE_UNIDEV
TEST_F(chip_base_test, plugin_request_success)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_chip->set_plugin_base_path(m_test_dir);
m_bus->set_read_result(HAS_OK);
m_bus->set_write_result(HAS_OK);
std::vector<uint8_t> read_data(129, 0x01);
m_bus->add_read_payload(read_data);
std::vector<uint8_t> params = seri_pack_string({0xAA, 0xBB});
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->plugin_request("test_plugin", "read_data", params, out_buffer, error);
EXPECT_EQ(ret, HAS_OK) << "error: " << error;
EXPECT_TRUE(error.empty());
}
#endif
TEST_F(chip_base_test, plugin_request_no_bus)
{
std::vector<uint8_t> params = {0xAA};
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_THROW(m_chip->plugin_request("test_plugin", "test_cmd", params, out_buffer, error),
mc::invalid_op_exception);
}
TEST_F(chip_base_test, plugin_request_write_failure)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_chip->set_plugin_base_path(m_test_dir);
m_bus->set_write_result(HAS_ERR);
std::vector<uint8_t> params = seri_pack_string({0xAA});
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->plugin_request("test_plugin", "write_fail", params, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_base_test, plugin_request_read_failure)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_chip->set_plugin_base_path(m_test_dir);
m_bus->set_write_result(HAS_OK);
m_bus->set_read_result(HAS_ERR);
std::vector<uint8_t> params = seri_pack_string({0xAA});
std::vector<uint8_t> out_buffer;
std::string error;
#if COMPONENT_DRIVERS_ENABLE_UNIDEV
int32_t ret = m_chip->plugin_request("test_plugin", "read_simple", params, out_buffer, error);
#else
int32_t ret = m_chip->plugin_request("test_plugin", "test_cmd", params, out_buffer, error);
#endif
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_base_test, plugin_request_business_failure_signal)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_chip->set_plugin_base_path(m_test_dir);
m_bus->set_write_result(HAS_OK);
m_bus->set_read_result(HAS_ERR);
std::vector<uint8_t> params = seri_pack_string({0xAA});
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip->plugin_request("test_plugin", "pcall_read", params, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
EXPECT_TRUE(out_buffer.empty());
}
TEST_F(chip_base_test, dump_reports_counters_bus_name_and_error_history)
{
mc::mutable_dict csr_object;
csr_object["object_name"] = std::string("dump-chip");
ASSERT_TRUE(m_chip->init(csr_object));
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
m_bus->set_read_result(HAS_OK);
EXPECT_EQ(m_chip->block_read(0x10, 1, in_buffer, out_buffer, error), HAS_OK);
m_bus->set_write_result(HAS_OK);
EXPECT_EQ(m_chip->block_write(0x10, std::vector<uint8_t>{0x01}, out_buffer, error), HAS_OK);
m_bus->set_read_result(HAS_ERR);
EXPECT_EQ(m_chip->block_read(0x10, 1, in_buffer, out_buffer, error), HAS_ERR);
m_chip->set_left_bus(nullptr);
EXPECT_THROW(m_chip->block_read(0x10, 1, in_buffer, out_buffer, error), mc::invalid_op_exception);
std::this_thread::sleep_for(std::chrono::milliseconds(1));
auto dump = m_chip->dump();
EXPECT_NE(dump.find("dump-chip"), std::string::npos);
EXPECT_NE(dump.find("pre bus object not found"), std::string::npos);
}
class chip_topo_path_test : public ::testing::Test {
protected:
void SetUp() override
{
m_bus = std::make_shared<test_bus>();
m_bus->set_id(1);
m_bus->set_class_name("SmBus");
m_bus->set_read_result(HAS_OK);
m_bus->set_write_result(HAS_OK);
m_chip1 = create_chip(0x70);
m_chip2 = create_chip(0x70);
m_chip3 = create_chip(0x71);
m_topo = m_chip1->get_topo_path();
}
void TearDown() override
{
m_chip1->set_left_bus(nullptr);
m_chip1->set_host_bus(nullptr);
m_chip2->set_left_bus(nullptr);
m_chip2->set_host_bus(nullptr);
m_chip3->set_left_bus(nullptr);
m_chip3->set_host_bus(nullptr);
}
std::shared_ptr<dev::chip_base> create_chip(uint32_t addr)
{
auto chip = std::make_shared<dev::chip_base>();
mc::mutable_dict csr_object;
csr_object["Address"] = addr;
csr_object["OffsetWidth"] = static_cast<uint8_t>(1);
csr_object["AddrWidth"] = static_cast<uint8_t>(1);
chip->init(csr_object);
chip->set_class_name("TestChip");
chip->set_left_bus(m_bus);
chip->set_host_bus(m_bus);
return chip;
}
std::shared_ptr<test_bus> m_bus;
std::shared_ptr<dev::chip_base> m_chip1;
std::shared_ptr<dev::chip_base> m_chip2;
std::shared_ptr<dev::chip_base> m_chip3;
std::string m_topo;
};
TEST_F(chip_topo_path_test, topo_path_format_with_bus)
{
std::string expected = "SmBus:1@TestChip:70w1_1";
EXPECT_EQ(m_topo, expected);
}
TEST_F(chip_topo_path_test, topo_path_without_bus)
{
auto chip = create_chip(0x50);
chip->set_left_bus(nullptr);
std::string expected = "TestChip:50w1_1";
EXPECT_EQ(chip->get_topo_path(), expected);
}
TEST_F(chip_topo_path_test, topo_path_class_name_fallback_to_m_class_name)
{
auto chip = std::make_shared<dev::chip_base>();
chip->set_class_name("CustomType");
mc::mutable_dict csr_object;
csr_object["Address"] = static_cast<uint32_t>(0x10);
csr_object["OffsetWidth"] = static_cast<uint8_t>(2);
csr_object["AddrWidth"] = static_cast<uint8_t>(1);
chip->init(csr_object);
chip->set_left_bus(nullptr);
std::string expected = "CustomType:10w1_2";
EXPECT_EQ(chip->get_topo_path(), expected);
}
TEST_F(chip_topo_path_test, topo_path_same_bus_and_addr_are_equal)
{
EXPECT_EQ(m_chip1->get_topo_path(), m_chip2->get_topo_path());
}
TEST_F(chip_topo_path_test, topo_path_different_addr_are_different)
{
EXPECT_NE(m_chip1->get_topo_path(), m_chip3->get_topo_path());
}
TEST_F(chip_base_test, memory_safety_bit_read_rejects_every_short_reply)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
for (uint8_t width : {1, 2, 4}) {
for (size_t received = 0; received < width; ++received) {
for (uint32_t mask : {0U, 0xffffffffU}) {
SCOPED_TRACE(::testing::Message() << +width << "/" << received << "/" << mask);
m_bus->add_read_payload(std::vector<uint8_t>(received, 0x5a));
std::vector<uint8_t> input;
std::vector<uint8_t> output(width, 0xff);
std::string error;
EXPECT_EQ(m_chip->bit_read(0x10, width, mask, input, output, error), HAS_ERR);
EXPECT_FALSE(error.empty());
}
}
}
}
TEST_F(chip_base_test, memory_safety_shifted_bus_preserves_value_and_rejects_short_reply)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
m_bus->has_shifted_bit_read = true;
std::vector<uint8_t> input, output;
std::string error;
m_bus->add_read_payload({3, 0, 0, 0});
ASSERT_EQ(m_chip->bit_read(0x10, 4, 0xf0, input, output, error), HAS_OK);
EXPECT_EQ(output, (std::vector<uint8_t>{3, 0, 0, 0}));
m_bus->add_read_payload({3});
EXPECT_EQ(m_chip->bit_read(0x10, 4, 0xf0, input, output, error), HAS_ERR);
EXPECT_TRUE(output.empty());
EXPECT_FALSE(error.empty());
}
TEST_F(chip_base_test, memory_safety_bit_write_rejects_short_input_before_bus)
{
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
for (uint8_t width : {1, 2, 4}) {
for (size_t provided = 0; provided < width; ++provided) {
SCOPED_TRACE(::testing::Message() << +width << "/" << provided);
std::vector<uint8_t> input(provided, 0x5a), output;
std::string error;
EXPECT_EQ(m_chip->bit_write(0x10, width, 0xffffffffU, input, output, error), HAS_ERR);
EXPECT_FALSE(error.empty());
EXPECT_EQ(m_bus->m_write_call_count, 0);
}
}
}
}