/*
 * 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 {

// 将原始字节打包为 skynet seri 格式的字符串,供 _luaseri_unpack 解包
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;
}

// Mock bus for testing
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";
        }

        // 从源码树拷贝 test_plugin 到构建目录
        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());
            // 检查文件是否存在且大小大于0
            std::ifstream check(dst_file);
            if (check.good() && check.peek() != std::ifstream::traits_type::eof()) {
                plugin_created = true;
            }
            check.close();
        }

        // 如果复制失败或 MESON_SOURCE_ROOT 未设置,内联创建测试插件
        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);
}

// 测试 init 成功
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");
}

// 测试 init 部分字段
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));
}

// Address 是否「显式给出」决定聚合窗口能否共享:CSR 静态配置与运行期显式赋值
// (属性回调 / Lua 脚本 / SPI ChipSelect)都必须置位;否则这类器件的共享会被
// 静默关掉,退化成每对象各自一次物理读。
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);

    // 重新 init 时标志随本次 CSR 复位(不留上一次的残留)
    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);
}

// Address 写成 property binding 时,init 阶段求不出真实值,safe_get_numeric_value
// 会静默回落默认 0;这种「回落 0」不能当作显式地址,否则聚合窗口共享键会把多个
// 未真正配址的器件按 0 合并到同一个窗口。运行期经 update_address 落实后才置位。
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;
    }
}

// Address 与 SPI Flash ChipSelect 共用的显式地址入口:数值正常解析并置位
// configured;绑定表达式在 init 阶段求不出地址,回落默认 0 且不置位。
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());

    // 绑定表达式 / null 都不是显式地址,不得置位。
    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
// SPI Flash 的 ChipSelect 接入该入口(chip_spi_flash 只在 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

// 测试 init 支持 abi_v2 嵌套接口形态(属性在接口 dict 内层)。
// 背景:嵌套形态此前读不到顶层 Address,m_address 落 0,master 以错误
// 地址执行硬件访问(devmon hwproxy_chip_merge_design §5.2)。
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));
}

// 顶层平铺优先于嵌套接口形态(abi_v1 兼容)
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));
}

// 多个嵌套接口同时提供 Address 时不能依赖容器遍历顺序。解析拒绝二义的嵌套来源,
// 保持未配置 Address 的默认值;顶层平铺字段仍可按上例显式消除二义性。
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);
}

// 测试 init 空字典
TEST_F(chip_base_test, init_empty_dict)
{
    mc::mutable_dict csr_object;
    EXPECT_TRUE(m_chip->init(csr_object));
}

// 测试 init 异常处理
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));
}

// 测试 set_left_chip 和 get_left_chip
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);
}

// 测试 set_left_bus 和 get_left_bus
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);
}

// 测试 set_host_bus 和 get_host_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);
}

// 测试 chip_init
TEST_F(chip_base_test, chip_init)
{
    int32_t ret = m_chip->chip_init();
    EXPECT_EQ(ret, HAS_OK);
}

// 测试 chip_test 成功:两次读取返回相同数据
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);
}

// 测试 chip_test 失败:两次读取数据不一致
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);
}

// 测试 chip_test 失败:无 bus
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);
}

// 测试 chip_reset
TEST_F(chip_base_test, chip_reset)
{
    int32_t ret = m_chip->chip_reset();
    EXPECT_EQ(ret, HAS_OK);
}

// 测试 open_channel
TEST_F(chip_base_test, open_channel)
{
    int32_t ret = m_chip->open_channel(m_bus);
    EXPECT_EQ(ret, HAS_OK);
}

// 测试 close_channel
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);
}

// 注意:output_to_input、pack_access_data、input、output、data_access 是 protected 方法,无法直接测试
// 可以通过 bit_read、bit_write、block_read、block_write、plugin_request 等公共方法间接测试

// 测试 bit_read 成功
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");
}

// 测试 bit_read 无 bus
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);
}

// 测试 bit_write 成功
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());
}

// 测试 bit_write 无 bus
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);
}

// 测试 block_read 成功
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);
}

// 测试 block_read 无 bus
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);
}

// 前级 mux 芯片:open_channel 可配置抛异常或返回错误码,前 N 次尝试失败、之后成功,
// 用于验证前级失败精准归因与切通道重试语义
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; // 前 N 次尝试失败(0 表示一直成功)
    bool    throw_on_open = false;
    int32_t open_result   = HAS_OK;
};

// 前级通道切换抛异常且 3 次重试均失败:失败归因前级器件,本器件不记状态、不累计失败、
// 不劣化健康;前级芯片经健康观察者通道收到 1 次失败结论(3 次连续失败等价喂满防抖,当场翻牌)
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);
}

// 前级通道切换返回错误码且 3 次重试均失败:同样归因前级器件
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);
}

// 归因标记读取即清零:consume 一次后标记不再残留,后续无关访问的失败判定不受影响
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());
}

// 前级通道切换前 2 次失败、第 3 次成功:访问最终成功,前级只收到 1 次成功结论
// (失败重试不单独上报,成功即恢复),本器件自身 I/O 正常计数
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 自身的 output/input 需要前级总线
    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);
}

// 前级通道切换成功:前级芯片收到成功结论(健康恢复),本器件自身 I/O 正常计数
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 自身的 output/input 需要前级总线
    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);
}

// 测试 block_write 成功
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);
}

// B3 兜底:非 raw 路径下 chip 方法签名无 context 位,requestor 无法随参数下发;
// devmon router execute_default 在硬件 worker 线程用 with_context 注入 Requestor 后,
// pack_access_data 应从当前 engine context 读到它并归属 trace。
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);

    // 模拟 router 注入的调用方名字(scanner/accessor 对象名)
    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");
}

// trace 关闭时 pack_access_data 不应读取 context,避免给高频芯片访问增加无谓开销。
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());
}

// 测试 block_write 无 bus
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);
}

// 测试 block_write_read 成功
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());
}

// 扩展读请求(offset == CHIP_EXTEND_READ_MODE)不再由 chip_base 自动设置 protocol_flag,
// 而是由总线层(如 I2cOverLocalBus)根据 offset 值直接路由到 write_read 路径
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);
}

// 显式指定 protocol_flag 时原样透传到总线(如 WriteReadByProtocol 的 SMBUS 协议)
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);
}

// 测试 combo_block_write_read 成功
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());
}

// 测试 combo_block_write_read 写入失败
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);
}

// 测试多次 init
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));
}

// 测试 plugin_request 成功(仅在非 UNIDEV 模式下有效,UNIDEV 模式由 test_lua_plugin.cpp 测试)
#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); // PLUGIN_REQUEST_READ_LENGTH = 129
    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

// 测试 plugin_request 无 bus
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);
}

// 测试 plugin_request 写入失败
// unidev 下走 Lua:write_fail → chip:write → 失败时 luaL_error,plugin_request 返回 HAS_ERR
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());
}

// 测试 plugin_request 读取失败
// unidev 下用 read_simple(chip:read → 失败时 luaL_error);旧路径仍走 block_read 语义
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());
}

// 测试插件业务失败信号 (false, errmsg):hwproxy 插件普遍用 pcall(chip.read, ...) 捕获
// 硬件访问异常后 return ok, ret(失败时 ok=false、ret=错误消息)。
// call_plugin 必须将该失败信号翻译为 HAS_ERR + error,而不是打包进 out_buffer 当作数据返回。
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);
}

// ===== Topology path tests =====

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); // 与 chip1 同地址 → 合并
        m_chip3 = create_chip(0x71); // 不同地址 → 不合并

        // 预构建 topo_path 供后续验证
        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;
};

// ── topo_path 格式验证 ──
TEST_F(chip_topo_path_test, topo_path_format_with_bus)
{
    // 预期格式: "BusType:BusId@ChipType:Address_wAddrWidthOffsetWidth"
    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)
{
    // get_class_name() 默认返回 "",build_topo_path 会 fallback 到 m_class_name
    // set_class_name("CustomType") 应反映在 topo_path 中
    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)
{
    // chip1 和 chip2 同一总线同一地址 → topo_path 相同
    EXPECT_EQ(m_chip1->get_topo_path(), m_chip2->get_topo_path());
}

TEST_F(chip_topo_path_test, topo_path_different_addr_are_different)
{
    // chip3 地址不同 → topo_path 不同
    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;
                // A preallocated caller buffer must not disguise an empty reply.
                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;

    // LocalBus has already extracted (register & 0xf0) >> 4.
    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}));

    // A shifted response must still contain the requested number of bytes.
    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);
        }
    }
}

} // namespace