/*
 * Copyright (c) 2024 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 <algorithm>
#include <array>
#include <atomic>
#include <cstdio>
#include <cstdlib>
#include <devmon/driver_abi.h>
#include <dlfcn.h>
#include <fstream>
#include <mc/engine/property/ref_object.h>
#include <mc/log.h>
#include <memory>
#include <openssl/evp.h>
#include <sys/stat.h>
#include <test_utilities/test_base.h>
#include <thread>
#include <unistd.h>
#include <unordered_map>
#include <vector>
#include <gtest/gtest.h>

#define private public
#include "../../../drivers/connector/connector/connector.h"
#undef private

#include "../../../drivers/connector/connector/sr_overlay.h"

#include "../test_utils/root_object.h"

using namespace dev;
using namespace devmon;

namespace drivers {
namespace connector {
namespace test {

class mock_self_description_record : public mc::engine::interface<mock_self_description_record> {
public:
    MC_INTERFACE("bmc.dev.Chip.SelfDescriptionRecord")

    mc::engine::property<std::string> FormatVersion;
    mc::engine::property<std::string> DataVersion;
    mc::engine::property<std::string> BoardId;

    std::tuple<uint8_t, std::string> GetSRData()
    {
        csr2_call_count++;
        if (throw_on_call) {
            MC_THROW(mc::not_implemented_exception, "CSR2 GetSRData disabled");
        }
        return std::make_tuple(status, payload);
    }

    uint8_t     status          = load_status::SUCCESS;
    std::string payload         = R"({"Name":"CSR2_EEPROM"})";
    bool        throw_on_call   = false;
    int         csr2_call_count = 0;
};

class mock_eeprom_data : public mc::engine::interface<mock_eeprom_data> {
public:
    MC_INTERFACE("bmc.kepler.EepromData")

    mc::engine::property<std::string> DataVersion;

    std::tuple<uint8_t, std::string, std::string> GetSRData()
    {
        csr1_call_count++;
        DataVersion = data_version;
        if (throw_on_call) {
            MC_THROW(mc::not_implemented_exception, "CSR1 GetSRData disabled");
        }
        if (hardware_access_failures_remaining > 0) {
            hardware_access_failures_remaining--;
            return std::make_tuple(load_status::HARDWARE_ACCESS_FAIL, std::string{}, std::string{});
        }
        return std::make_tuple(status, payload, uid);
    }

    // 接口层 header 探测方法:仅返回 uid/版本,不读取全量 SR 数据。
    // 与 csr1 不可用语义保持一致:csr1 不可用时同样抛异常,由 connector 回退全量读取。
    std::tuple<uint8_t, std::string, std::string> GetEepromHeader()
    {
        header_call_count++;
        if (throw_on_call) {
            MC_THROW(mc::not_implemented_exception, "CSR1 GetEepromHeader disabled");
        }
        return std::make_tuple(status, uid, data_version);
    }

    uint8_t     status                             = load_status::SUCCESS;
    std::string payload                            = R"({"Name":"CSR1_EEPROM"})";
    std::string uid                                = "EEPROMUID";
    std::string data_version                       = "3.10";
    bool        throw_on_call                      = false;
    int         hardware_access_failures_remaining = 0;
    int         csr1_call_count                    = 0;
    int         header_call_count                  = 0;
};

class mock_eeprom_chip : public mc::engine::object<mock_eeprom_chip> {
public:
    MC_OBJECT(mock_eeprom_chip, "MockEepromChip", "/bmc/test/MockEepromChip/${object_name}",
              (mock_self_description_record)(mock_eeprom_data))

    mock_self_description_record csr2;
    mock_eeprom_data             csr1;
};

class mock_devmon_interface : public mc::engine::interface<mock_devmon_interface> {
public:
    MC_INTERFACE("bmc.dev")

    mc::result<void> AddDeviceWithData(const mc::variant& sr_data, const mc::dict& connector)
    {
        add_device_call_count++;
        last_sr_data = sr_data;
        add_device_connectors.push_back(connector);
        if (fail_add) {
            return mc::make_shared<mc::error>("InvalidCsr", "CSR Unit Type is empty");
        }
        if (delay_add) {
            return mc::delay(mc::milliseconds(50));
        }
        return mc::resolve();
    }

    void RemoveDevice(const mc::dict& connector)
    {
        remove_device_call_count++;
        remove_device_connectors.push_back(connector);
    }

    int                        add_device_call_count    = 0;
    int                        remove_device_call_count = 0;
    bool                       delay_add                = false;
    bool                       fail_add                 = false;
    std::optional<mc::variant> last_sr_data;
    std::vector<mc::dict>      add_device_connectors;
    std::vector<mc::dict>      remove_device_connectors;
};

class mock_devmon_object : public mc::engine::object<mock_devmon_object> {
public:
    MC_OBJECT(mock_devmon_object, "Devmon", "/bmc/test/Devmon/${object_name}", (mock_devmon_interface))

    mock_devmon_interface devmon;
};

class connector_test_service : public mc::engine::service {
public:
    connector_test_service(const std::string& name) : mc::engine::service(name)
    {}
};

class ConnectorTest : public mc::test::TestWithEngine {
protected:
    static void SetUpTestSuite()
    {
        TestWithEngine::SetUpTestSuite();
        m_test_service = mc::make_shared<connector_test_service>("bmc.kepler.test_connector");
        m_test_service->init();
        m_test_service->start();

        // 创建根对象
        m_root_object = root_object::create_root_object(m_test_service.get());
    }

    static void TearDownTestSuite()
    {
        m_test_service->stop();
        m_root_object.reset();
        m_test_service.reset();
        TestWithEngine::TearDownTestSuite();
    }

    void SetUp() override
    {
        // 保存原始环境变量
        original_csr_path = std::getenv("PROG_CSR_PATH");

        mkdir("/tmp/connector_ut_empty_gold", 0755);
        mkdir("/tmp/connector_ut_empty_temp", 0755);
        setenv("CONNECTOR_SR_GOLD_DIR", "/tmp/connector_ut_empty_gold", 1);
        setenv("CONNECTOR_SR_TEMP_DIR", "/tmp/connector_ut_empty_temp", 1);

        // 创建Connector对象
        m_connector = mc::make_shared<Connector>();
        m_connector->set_position("97");
        m_connector->set_object_name("Connector");
        m_test_service->register_object(m_connector);
        // 这些用例直接验证运行期加载入口;建立 start() 的运行态,但不在 init() 前投递预加载任务。
        m_connector->i_connector.begin_start();
    }

    void TearDown() override
    {
        cleanup_test_sr_dir();
        unsetenv("CONNECTOR_SR_DIR");
        unsetenv("CONNECTOR_SR_GOLD_DIR");
        unsetenv("CONNECTOR_SR_TEMP_DIR");

        // 恢复环境变量
        if (original_csr_path) {
            setenv("PROG_CSR_PATH", original_csr_path, 1);
        } else {
            unsetenv("PROG_CSR_PATH");
        }

        // 注销并释放mock chip
        if (m_mock_chip) {
            m_test_service->unregister_object(std::string(m_mock_chip->get_object_path()));
            m_mock_chip.reset();
        }
        if (m_mock_devmon) {
            m_test_service->unregister_object(std::string(m_mock_devmon->get_object_path()));
            m_mock_devmon.reset();
        }
        restore_root_devmon();

        // 注销并释放对象
        if (m_connector) {
            m_test_service->unregister_object(std::string(m_connector->get_object_path()));
            m_connector.reset();
        }
    }

    // 创建测试用的CSR配置
    mc::dict create_test_connector()
    {
        mc::dict connector{{"Bom", "BOM123"}, {"Id", "BOARD456"}, {"AuxId", "AUX789"}, {"GroupPosition", "POS1"}};
        return connector;
    }

    mc::mutable_dict create_test_csr(uint8_t presence, uint8_t identify_mode = 0)
    {
        return mc::mutable_dict{{"Bom", std::string("BOM12345")},
                                {"Slot", static_cast<uint8_t>(1)},
                                {"GroupId", static_cast<uint32_t>(10)},
                                {"GroupPosition", std::string("A1")},
                                {"Presence", presence},
                                {"Id", std::string("BOARD456")},
                                {"AuxId", std::string("AUX789")},
                                {"Buses", std::vector<std::string>{"I2c_1"}},
                                {"SystemId", static_cast<uint8_t>(1)},
                                {"ManagerId", std::string("Manager1")},
                                {"SilkText", std::string("Silk1")},
                                {"Type", std::string("Card")},
                                {"IdentifyMode", identify_mode},
                                {"ChassisId", std::string("Chassis1")},
                                {"LoadStatus", static_cast<uint8_t>(load_status::DEFAULT)},
                                {"Chip", std::string()}};
    }

    std::string test_sr_dir;
    std::string test_gold_dir;
    std::string test_temp_dir;

    void set_test_sr_dir(const std::string& dir)
    {
        test_sr_dir   = dir;
        test_gold_dir = dir + "_gold";
        test_temp_dir = dir + "_temp";
        mkdir(test_sr_dir.c_str(), 0755);
        mkdir(test_gold_dir.c_str(), 0755);
        mkdir(test_temp_dir.c_str(), 0755);
        setenv("CONNECTOR_SR_DIR", test_sr_dir.c_str(), 1);
        setenv("CONNECTOR_SR_GOLD_DIR", test_gold_dir.c_str(), 1);
        setenv("CONNECTOR_SR_TEMP_DIR", test_temp_dir.c_str(), 1);
    }

    void write_file(const std::string& path, const std::string& content)
    {
        std::ofstream ofs(path);
        ofs << content;
        ofs.close();
    }

    static std::string md5_hex_of(const std::string& content)
    {
        auto context = std::unique_ptr<EVP_MD_CTX, decltype(&EVP_MD_CTX_free)>(EVP_MD_CTX_new(), EVP_MD_CTX_free);
        EXPECT_TRUE(context);
        EXPECT_EQ(EVP_DigestInit_ex(context.get(), EVP_md5(), nullptr), 1);
        EXPECT_EQ(EVP_DigestUpdate(context.get(), content.data(), content.size()), 1);
        unsigned char digest[EVP_MAX_MD_SIZE];
        unsigned int  digest_size = 0;
        EXPECT_EQ(EVP_DigestFinal_ex(context.get(), digest, &digest_size), 1);
        static constexpr char hex[] = "0123456789abcdef";
        std::string           result;
        result.reserve(digest_size * 2);
        for (unsigned int i = 0; i < digest_size; ++i) {
            result.push_back(hex[digest[i] >> 4]);
            result.push_back(hex[digest[i] & 0x0f]);
        }
        return result;
    }

    void write_sr_with_md5(const std::string& path, const std::string& content)
    {
        write_file(path, content);
        write_file(path + ".md5", md5_hex_of(content));
    }

    void write_csr_version(const std::string& file_key, const std::string& version)
    {
        write_file(test_sr_dir + "/csr_version.json",
                   std::string("{\"") + file_key + "\":{\"DataVersion\":\"" + version + "\"}}");
    }

    static void remove_sr_pair(const std::string& dir, const std::string& name)
    {
        if (dir.empty()) {
            return;
        }
        std::remove((dir + "/" + name).c_str());
        std::remove((dir + "/" + name + ".md5").c_str());
    }

    void cleanup_overlay_dir(const std::string& dir)
    {
        remove_sr_pair(dir, "BOM12345_EEPROMUID_AUX789.sr");
        remove_sr_pair(dir, "BOM12345_EEPROMUID_AUX789_soft.sr");
        remove_sr_pair(dir, "BOM12345_.sr");
        remove_sr_pair(dir, "BOM12345_BOARD456_AUX789.sr");
        remove_sr_pair(dir, "BOM12345_BOARD456_AUX789_soft.sr");
        remove_sr_pair(dir, "NEWBOM_NEWID_NEWAUX.sr");
        if (!dir.empty()) {
            rmdir(dir.c_str());
        }
    }

    void cleanup_test_sr_dir()
    {
        if (test_sr_dir.empty()) {
            return;
        }
        std::remove((test_sr_dir + "/csr_version.json").c_str());
        cleanup_overlay_dir(test_sr_dir);
        cleanup_overlay_dir(test_gold_dir);
        cleanup_overlay_dir(test_temp_dir);
        test_sr_dir.clear();
        test_gold_dir.clear();
        test_temp_dir.clear();
    }

    template <typename T>
    mc::shared_ptr<mc::engine::ref_object> make_ref_object(const mc::shared_ptr<T>& object)
    {
        std::string object_name   = std::string(object->get_object_name());
        auto        object_finder = [object](mc::string_view name) -> mc::engine::abstract_object* {
            if (name == object->get_object_name()) {
                return object.get();
            }
            return nullptr;
        };
        return mc::make_shared<mc::engine::ref_object>(object_name, object_finder);
    }

    template <typename Property, typename T>
    void install_ref_object(Property& property, const mc::shared_ptr<T>& object)
    {
        auto ref_object = make_ref_object(object);
        auto cache      = std::make_unique<mc::variant>(ref_object);
        property.set_property_type(mc::engine::p_type::ref_object);
        property.set_ref_object_cache(std::move(cache));
        property.set_internal_value(mc::variant(std::string(ref_object->get_object_name())));
    }

    void install_mock_chip()
    {
        m_mock_chip = mc::make_shared<mock_eeprom_chip>();
        m_mock_chip->set_object_name("MockEepromChip");
        m_test_service->register_object(m_mock_chip);
        install_ref_object(m_connector->Chip, m_mock_chip);
    }

    void install_mock_devmon()
    {
        if (m_root_object && !m_root_devmon_replaced) {
            m_test_service->unregister_object(std::string(m_root_object->get_object_path()));
            m_root_devmon_replaced = true;
        }

        m_mock_devmon = mc::make_shared<mock_devmon_object>();
        m_mock_devmon->set_object_name("Devmon");
        m_test_service->register_object(m_mock_devmon);
    }

    void restore_root_devmon()
    {
        if (!m_root_devmon_replaced || !m_root_object) {
            return;
        }

        m_test_service->register_object(m_root_object);
        m_root_devmon_replaced = false;
    }

    bool wait_for_load_status(uint8_t expected, int timeout_ms = 2000)
    {
        auto deadline = std::chrono::steady_clock::now() + std::chrono::milliseconds(timeout_ms);
        while (std::chrono::steady_clock::now() < deadline) {
            if (m_connector->i_connector.LoadStatus.get_value().as<uint8_t>() == expected) {
                return true;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(5));
        }
        return false;
    }

protected:
    static mc::shared_ptr<connector_test_service> m_test_service;
    static root_object_ptr                        m_root_object;
    mc::shared_ptr<Connector>                     m_connector;
    mc::shared_ptr<mock_eeprom_chip>              m_mock_chip;
    mc::shared_ptr<mock_devmon_object>            m_mock_devmon;
    const char*                                   original_csr_path      = nullptr;
    bool                                          m_root_devmon_replaced = false;
};

mc::shared_ptr<connector_test_service> ConnectorTest::m_test_service;
root_object_ptr                        ConnectorTest::m_root_object;

// 测试基本初始化
TEST_F(ConnectorTest, test_basic_init)
{
    auto csr       = create_test_csr(1);
    auto connector = create_test_connector();

    bool result = m_connector->init(csr, connector);
    EXPECT_TRUE(result);

    // 验证属性是否正确设置
    EXPECT_EQ(m_connector->i_connector.Presence.get_value(), 1);
}

// 测试基本初始化
TEST_F(ConnectorTest, test_basic_init2)
{
    auto csr       = create_test_csr(0);
    auto connector = create_test_connector();

    bool result = m_connector->init(csr, connector);
    EXPECT_TRUE(result);

    // 验证属性是否正确设置
    EXPECT_EQ(m_connector->i_connector.Presence.get_value(), 0);
}

TEST_F(ConnectorTest, ConnectorInterfaceExcludesChipObjectOwnsChip)
{
    auto csr       = create_test_csr(1);
    auto connector = create_test_connector();
    csr["Chip"]    = std::string("ConfiguredEepromChip");

    ASSERT_TRUE(m_connector->init(csr, connector));

    EXPECT_TRUE(m_connector->get_property("Chip", "bmc.kepler.Connector", 0).is_null());
    EXPECT_EQ(m_connector->get_property("Chip", {}, 0).as<std::string>(), "ConfiguredEepromChip");
    EXPECT_EQ(m_connector->i_connector.build_connector_dict().at("Chip").as<std::string>(), "ConfiguredEepromChip");
    EXPECT_EQ(m_connector->i_connector.build_connector_dict().at("ObjectName").as<std::string>(), "Connector");
}

// 测试init:缺少必需字段但Connector::init不验证字段
TEST_F(ConnectorTest, test_init_missing_fields)
{
    // 缺少Presence字段
    // 注意:Connector::init 只使用 mc::from_variant 解析 CSR,不验证必要字段,
    // 因此即使 CSR 缺少必要字段,init 也会成功返回
    auto csr       = mc::mutable_dict{{"InvalidField", "InvalidValue"}};
    auto connector = create_test_connector();

    bool result = m_connector->init(csr, connector);
    EXPECT_TRUE(result);
}

// build_connector_dict:CSR 未配置属性时使用默认值,不抛异常
TEST_F(ConnectorTest, build_connector_dict_uses_defaults_when_properties_missing)
{
    auto csr       = mc::mutable_dict{{"InvalidField", "InvalidValue"}};
    auto connector = create_test_connector();

    ASSERT_TRUE(m_connector->init(csr, connector));

    mc::dict dict;
    EXPECT_NO_THROW(dict = m_connector->i_connector.build_connector_dict());
    EXPECT_EQ(dict.at("SystemId").as<uint8_t>(), 1); // gen 接口默认值
    EXPECT_EQ(dict.at("ManagerId").as<std::string>(), "1");
    // ChassisId 未配置时使用 gen 接口默认值 "1",与 SystemId/ManagerId 及 Lua 版
    // def.default_value 对齐;下游 devmon 以此替换 CSR 路径中的 ${ChassisId}
    EXPECT_EQ(dict.at("ChassisId").as<std::string>(), "1");
    EXPECT_EQ(dict.at("SilkText").as<std::string>(), "");
    EXPECT_EQ(dict.at("Slot").as<uint8_t>(), 0);
    EXPECT_EQ(dict.at("LoadStatus").as<uint8_t>(), load_status::DEFAULT);
    EXPECT_EQ(dict.at("Buses").as<std::vector<std::string>>().size(), 0u);
}

// build_connector_dict:CSR 显式配置的 ChassisId 覆盖默认值,显式空串保留空串
// (对齐 Lua 版语义:anchor_data 未配置回填 '1',显式配置的空值原样保留)
TEST_F(ConnectorTest, build_connector_dict_respects_configured_chassis_id)
{
    auto connector = create_test_connector();

    auto csr_configured         = create_test_csr(1);
    csr_configured["ChassisId"] = std::string("Chassis1");
    ASSERT_TRUE(m_connector->init(csr_configured, connector));
    EXPECT_EQ(m_connector->i_connector.build_connector_dict().at("ChassisId").as<std::string>(), "Chassis1");

    // 再次 init 覆盖为显式空串:from_variant 写入空值,不回退默认
    auto csr_empty = mc::mutable_dict{{"ChassisId", std::string("")}};
    ASSERT_TRUE(m_connector->init(csr_empty, connector));
    EXPECT_EQ(m_connector->i_connector.build_connector_dict().at("ChassisId").as<std::string>(), "");
}

// ========================= get_file_path 功能测试 =========================

// 测试正常读取
TEST_F(ConnectorTest, GetFilePath_WithBomAndAuxId)
{
    Context ctx{"BOM123", "BOARD456", "AUX789", "POS1"};

    std::string path = m_connector->i_connector.get_file_path(ctx, "/config/csr");
    EXPECT_EQ(path, "/config/csr/BOM123_BOARD456_AUX789.sr");
}

// 测试aux_id为空
TEST_F(ConnectorTest, GetFilePath_WithBomNoAuxId)
{
    Context     ctx{"BOM123", "BOARD456", "", "POS1"};
    std::string path = m_connector->i_connector.get_file_path(ctx, "/config/csr");
    EXPECT_EQ(path, "/config/csr/BOM123_BOARD456.sr");
}

// 测试bom为空
TEST_F(ConnectorTest, GetFilePath_NoBomWithAuxId)
{
    Context     ctx{"", "BOARD456", "AUX789", "POS1"};
    std::string path = m_connector->i_connector.get_file_path(ctx, "/config/csr");
    EXPECT_EQ(path, "/config/csr/BOARD456_AUX789.sr");
}

// 测试bom和aux_id均为空
TEST_F(ConnectorTest, GetFilePath_NoBomNoAuxId)
{
    Context     ctx{"", "BOARD456", "", "POS1"};
    std::string path = m_connector->i_connector.get_file_path(ctx, "/config/csr");
    EXPECT_EQ(path, "/config/csr/BOARD456.sr");
}

// ========================= get_csr_file 功能测试 =========================

TEST_F(ConnectorTest, GetCsrFile_Success)
{
    auto connector = create_test_connector();

    std::string path = m_connector->i_connector.get_csr_file(connector);
    EXPECT_EQ(path, "/opt/bmc/sr/BOM123_BOARD456_AUX789.sr");
}

TEST_F(ConnectorTest, GetCsrFile_MissingEnvVar_DoesNotAffectDefaultPath)
{
    unsetenv("PROG_CSR_PATH");
    auto connector = create_test_connector();

    std::string path = m_connector->i_connector.get_csr_file(connector);
    EXPECT_EQ(path, "/opt/bmc/sr/BOM123_BOARD456_AUX789.sr");
}

TEST_F(ConnectorTest, GetCsrFile_UsesUnitTestSrDirOverride)
{
    set_test_sr_dir("/tmp/connector_sr_dir_override");
    auto connector = create_test_connector();

    std::string path = m_connector->i_connector.get_csr_file(connector);

    EXPECT_EQ(path, "/tmp/connector_sr_dir_override/BOM123_BOARD456_AUX789.sr");
}

// 测试connector缺少字段
TEST_F(ConnectorTest, GetCsrFile_MissingFieldInDict)
{
    setenv("PROG_CSR_PATH", "/firmware/csr", 1);
    mc::dict bad_connector;
    // 缺少 "Id" 字段

    std::string path = m_connector->i_connector.get_csr_file(bad_connector);
    EXPECT_TRUE(path.empty());
}

// ========================= get_csr_data 功能测试 =========================

// 测试正常读取
TEST_F(ConnectorTest, GetCsrData_ValidFile_ReturnsJsonString)
{
    const std::string temp_file    = "/tmp/test_csr.json";
    const std::string json_content = R"({"chip_id": 123, "status": "ok"})";
    std::ofstream     ofs(temp_file);
    ofs << json_content;
    ofs.close();

    std::string result = m_connector->i_connector.get_csr_data(temp_file);

    EXPECT_EQ(result, json_content);

    std::remove(temp_file.c_str());
}

// 测试传入路径异常
TEST_F(ConnectorTest, GetCsrData_NonExistentFile_ReturnsEmptyString)
{
    std::string result = m_connector->i_connector.get_csr_data("/non/existent/file.json");
    EXPECT_EQ(result, "");
}

// 测试内容为空
TEST_F(ConnectorTest, GetCsrData_InvalidJson_ReturnsEmptyString)
{
    const std::string temp_file = "/tmp/invalid_csr.json";
    std::ofstream     ofs(temp_file);
    ofs << "{ invalid json }";
    ofs.close();

    std::string result = m_connector->i_connector.get_csr_data(temp_file);
    EXPECT_EQ(result, "");

    std::remove(temp_file.c_str());
}

// ========================= get_local_csr_data_version 测试 =========================

TEST_F(ConnectorTest, GetLocalCsrDataVersion_ReturnsVersionForMatchingFile)
{
    set_test_sr_dir("/tmp/connector_sr_local_version_match");

    mc::mutable_dict versions;
    versions["BOM123_BOARD456_AUX789"] = mc::dict{{"DataVersion", std::string("3.10")}};

    // local sr 文件真实存在时,csr_version.json 登记的版本号才有效
    // 使用专属目录 + TearDown 统一清理,避免在 /tmp 顶层共享固定文件名
    const std::string sr_file = test_sr_dir + "/BOM123_BOARD456_AUX789.sr";
    write_file(sr_file, R"({"Name":"LOCAL"})");

    std::string version = m_connector->i_connector.get_local_csr_data_version(versions, sr_file);

    EXPECT_EQ(version, "3.10");
}

TEST_F(ConnectorTest, GetLocalCsrDataVersion_ReturnsEmptyWhenFileAbsent)
{
    set_test_sr_dir("/tmp/connector_sr_local_version_absent");

    mc::mutable_dict versions;
    versions["BOM123_BOARD456_AUX789"] = mc::dict{{"DataVersion", std::string("3.10")}};

    // csr_version.json 登记了匹配条目,但 local sr 文件不存在 → 版本号已失效应返回空,
    // 避免文件缺失时误用登记版本参与选源比较
    // 使用从未写入该文件的专属目录保证「文件不存在」前置条件;再防御性 remove 一次,
    // 规避上一次进程崩溃残留导致的偶发污染
    const std::string sr_file = test_sr_dir + "/BOM123_BOARD456_AUX789.sr";
    std::remove(sr_file.c_str());

    std::string version = m_connector->i_connector.get_local_csr_data_version(versions, sr_file);

    EXPECT_EQ(version, "");
}

TEST_F(ConnectorTest, GetLocalCsrDataVersion_ReturnsEmptyForMissingEntry)
{
    set_test_sr_dir("/tmp/connector_sr_local_version_missing_entry");

    mc::mutable_dict versions;
    versions["OTHER"] = mc::dict{{"DataVersion", std::string("1.00")}};

    // 文件存在但 csr_version.json 无对应条目 → 返回空
    const std::string sr_file = test_sr_dir + "/BOM123_BOARD456_AUX789.sr";
    write_file(sr_file, R"({"Name":"LOCAL"})");

    std::string version = m_connector->i_connector.get_local_csr_data_version(versions, sr_file);

    EXPECT_EQ(version, "");
}

TEST_F(ConnectorTest, GetLocalCsrDataVersion_ReturnsEmptyForInvalidShape)
{
    set_test_sr_dir("/tmp/connector_sr_local_version_invalid_shape");

    mc::mutable_dict versions;
    versions["BOM123_BOARD456_AUX789"] = std::string("invalid");

    // 文件存在、条目形状非法(非 dict) → 返回空
    const std::string sr_file = test_sr_dir + "/BOM123_BOARD456_AUX789.sr";
    write_file(sr_file, R"({"Name":"LOCAL"})");

    std::string version = m_connector->i_connector.get_local_csr_data_version(versions, sr_file);

    EXPECT_EQ(version, "");
}

// ========================= connector_sr_cache 测试 =========================

TEST_F(ConnectorTest, ConnectorPayloadCache_HitsWhenSourceAndKeyMatch)
{
    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    mc::variant payload = mc::dict{{"Name", std::string("CachedSr")}};
    m_connector->i_connector.update_cached_sr_data(connector_sr_source::local, payload, "BOARD456", "", "3.10",
                                                   "/opt/bmc/sr/BOM123_BOARD456_AUX789.sr");

    mc::variant cached;
    bool hit = m_connector->i_connector.try_get_cached_sr_data(connector_sr_source::local, "BOARD456", "", "3.10",
                                                               "/opt/bmc/sr/BOM123_BOARD456_AUX789.sr", cached);

    ASSERT_TRUE(hit);
    EXPECT_EQ(cached.as<mc::dict>()["Name"].as<std::string>(), "CachedSr");
}

TEST_F(ConnectorTest, ConnectorPayloadCache_MissesWhenSourceDiffers)
{
    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    mc::variant payload = mc::dict{{"Name", std::string("CachedSr")}};
    m_connector->i_connector.update_cached_sr_data(connector_sr_source::local, payload, "BOARD456", "", "3.10",
                                                   "/opt/bmc/sr/BOM123_BOARD456_AUX789.sr");

    mc::variant cached;
    bool hit = m_connector->i_connector.try_get_cached_sr_data(connector_sr_source::eeprom, "BOARD456", "", "3.10",
                                                               "/opt/bmc/sr/BOM123_BOARD456_AUX789.sr", cached);

    EXPECT_FALSE(hit);
}

TEST_F(ConnectorTest, ConnectorPayloadCache_MissesWhenVersionDiffers)
{
    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    mc::variant payload = mc::dict{{"Name", std::string("CachedSr")}};
    m_connector->i_connector.update_cached_sr_data(connector_sr_source::local, payload, "BOARD456", "", "3.10",
                                                   "/opt/bmc/sr/BOM123_BOARD456_AUX789.sr");

    mc::variant cached;
    bool hit = m_connector->i_connector.try_get_cached_sr_data(connector_sr_source::local, "BOARD456", "", "3.11",
                                                               "/opt/bmc/sr/BOM123_BOARD456_AUX789.sr", cached);

    EXPECT_FALSE(hit);
}

TEST_F(ConnectorTest, ConnectorPayloadCache_MissesWhenMergedFlagDiffers)
{
    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    mc::variant payload = mc::dict{{"Name", std::string("CachedSr")}};
    m_connector->i_connector.update_cached_sr_data(connector_sr_source::local, payload, "BOARD456", "", "3.10",
                                                   "/opt/bmc/sr/BOM123_BOARD456_AUX789.sr", "", false);

    mc::variant cached;
    bool hit = m_connector->i_connector.try_get_cached_sr_data(connector_sr_source::local, "BOARD456", "", "3.10",
                                                               "/opt/bmc/sr/BOM123_BOARD456_AUX789.sr", cached, true);

    EXPECT_FALSE(hit);
}

TEST_F(ConnectorTest, ConnectorPayloadCache_MissesWhenIdentityKeyDiffers)
{
    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    mc::variant payload = mc::dict{{"Name", std::string("CachedSr")}};
    m_connector->i_connector.update_cached_sr_data(connector_sr_source::local, payload, "EEPROMUID-A", "", "3.10",
                                                   "/opt/bmc/sr/BOM123_EEPROMUID-A_AUX789.sr");

    mc::variant cached;
    bool hit = m_connector->i_connector.try_get_cached_sr_data(connector_sr_source::local, "EEPROMUID-B", "", "3.10",
                                                               "/opt/bmc/sr/BOM123_EEPROMUID-A_AUX789.sr", cached);

    EXPECT_FALSE(hit);
}

TEST_F(ConnectorTest, ResolveSrData_RefreshFlagSkipsMatchingCacheAndReReadsEeprom)
{
    set_test_sr_dir("/tmp/connector_sr_refresh_flag");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_FIRST"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    uint8_t err   = 0;
    auto    first = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(first.has_value());
    auto first_data = first->as<mc::dict>();
    EXPECT_EQ(first_data["Name"].as<std::string>(), "EEPROM_FIRST");
    EXPECT_EQ(first_data["DataVersion"].as<std::string>(), "3.10");
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 1);

    m_mock_chip->csr1.payload = R"({"Name":"EEPROM_SECOND"})";
    auto second               = m_connector->i_connector.resolve_sr_data(true, true, false, err);

    ASSERT_TRUE(second.has_value());
    auto second_data = second->as<mc::dict>();
    EXPECT_EQ(second_data["Name"].as<std::string>(), "EEPROM_SECOND");
    EXPECT_EQ(second_data["DataVersion"].as<std::string>(), "3.10");
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 2);
}

// ========================= get_local_csr_data 测试 =========================

TEST_F(ConnectorTest, GetLocalCsrData_InvalidJsonSetsDataFormatError)
{
    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    const std::string temp_file = "/tmp/connector_invalid_sr.json";
    std::ofstream     ofs(temp_file);
    ofs << "{ invalid json }";
    ofs.close();

    uint8_t error   = 0;
    auto    payload = m_connector->i_connector.get_local_csr_data(temp_file, &error);

    EXPECT_FALSE(payload.has_value());
    EXPECT_EQ(error, load_status::DATA_FORMAT_ERROR);
    std::remove(temp_file.c_str());
}

TEST_F(ConnectorTest, GetLocalCsrData_MissingFileSetsLocalFileError)
{
    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    uint8_t error   = 0;
    auto    payload = m_connector->i_connector.get_local_csr_data("/tmp/connector_missing_sr.json", &error);

    EXPECT_FALSE(payload.has_value());
    EXPECT_EQ(error, load_status::LOCAL_FILE_ERROR);
}

// ========================= get_e2p_csr_data 测试 =========================

TEST_F(ConnectorTest, GetE2pCsrData_UsesCsr1First)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"CSR1"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    auto result = m_connector->i_connector.get_e2p_csr_data();

    ASSERT_TRUE(result.has_value());
    EXPECT_EQ(result->identity_key, "EEPROMUID");
    EXPECT_EQ(result->data_version, "3.10");
    EXPECT_EQ(result->payload.as<std::string>(), R"({"Name":"CSR1"})");
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 1);
    EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 0);
}

TEST_F(ConnectorTest, GetE2pCsrData_FallsBackToCsr2AndReturnsBoardId)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr1.throw_on_call = true;
    m_mock_chip->csr2.BoardId       = std::string("CSR2BOARD");
    m_mock_chip->csr2.DataVersion   = std::string("3.12");
    m_mock_chip->csr2.payload       = R"({"Name":"CSR2"})";

    auto result = m_connector->i_connector.get_e2p_csr_data();

    ASSERT_TRUE(result.has_value());
    EXPECT_EQ(result->identity_key, "CSR2BOARD");
    EXPECT_EQ(result->data_version, "3.12");
    EXPECT_EQ(result->payload.as<std::string>(), R"({"Name":"CSR2"})");
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 1);
    EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 1);
}

TEST_F(ConnectorTest, GetE2pCsrData_RetriesCsr1HardwareAccessFailure)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr1.status = load_status::HARDWARE_ACCESS_FAIL;

    uint8_t error_status = load_status::DEFAULT;
    auto    result       = m_connector->i_connector.get_e2p_csr_data(&error_status);

    EXPECT_FALSE(result.has_value());
    EXPECT_EQ(error_status, load_status::HARDWARE_ACCESS_FAIL);
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 5);
    EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 0);
}

TEST_F(ConnectorTest, GetE2pCsrData_RecoversAfterHardwareAccessFailures)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr1.hardware_access_failures_remaining = 3;

    auto result = m_connector->i_connector.get_e2p_csr_data();

    ASSERT_TRUE(result.has_value());
    EXPECT_EQ(result->payload.as<std::string>(), R"({"Name":"CSR1_EEPROM"})");
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 4);
    EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 0);
}

TEST_F(ConnectorTest, GetE2pCsrData_RetriesCsr2HardwareAccessFailure)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr1.throw_on_call = true;
    m_mock_chip->csr2.status        = load_status::HARDWARE_ACCESS_FAIL;

    uint8_t error_status = load_status::DEFAULT;
    auto    result       = m_connector->i_connector.get_e2p_csr_data(&error_status);

    EXPECT_FALSE(result.has_value());
    EXPECT_EQ(error_status, load_status::HARDWARE_ACCESS_FAIL);
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 1);
    EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 5);
}

TEST_F(ConnectorTest, GetE2pCsrData_DoesNotRetryNonHardwareFailure)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr1.status = load_status::DATA_FORMAT_ERROR;

    uint8_t error_status = load_status::DEFAULT;
    auto    result       = m_connector->i_connector.get_e2p_csr_data(&error_status);

    EXPECT_FALSE(result.has_value());
    EXPECT_EQ(error_status, load_status::DATA_FORMAT_ERROR);
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 1);
    EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 0);
}

// EEPROM header 完整性校验失败(白名单也不能放行)时,器件不得加载成功:
// 既不回退 CSR2,也不降级到本地文件,LoadStatus 必须落在 INTEGRITY_VERIFY_ERROR(6)
TEST_F(ConnectorTest, TryLoadDevice_KeepsEepromIntegrityVerifyError)
{
    set_test_sr_dir("/tmp/connector_integrity_verify_error");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();
    install_mock_devmon();

    m_mock_chip->csr1.status = load_status::INTEGRITY_VERIFY_ERROR;

    EXPECT_NO_THROW(m_connector->i_connector.try_load_device().get());

    EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::INTEGRITY_VERIFY_ERROR);
    EXPECT_EQ(m_mock_chip->csr1.header_call_count, 1);
    EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 0);
    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 0);
}

TEST_F(ConnectorTest, GetE2pCsrData_RejectsCsr1EmptyUid)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.status        = load_status::SUCCESS;
    m_mock_chip->csr1.payload       = R"({"Name":"CSR1"})";
    m_mock_chip->csr1.uid           = "";
    m_mock_chip->csr1.data_version  = "3.11";

    auto result = m_connector->i_connector.get_e2p_csr_data();

    EXPECT_FALSE(result.has_value());
    EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 1);
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 1);
}

TEST_F(ConnectorTest, GetCsr1EepromHeader_RetriesHardwareAccessFailure)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr1.status = load_status::HARDWARE_ACCESS_FAIL;

    auto* ref_obj = m_connector->i_connector.get_chip_ref_object();
    ASSERT_NE(ref_obj, nullptr);
    uint8_t error_status = load_status::DEFAULT;
    bool    unsupported  = false;
    auto    result       = m_connector->i_connector.get_csr1_eeprom_header(*ref_obj, &error_status, unsupported);

    EXPECT_FALSE(result.has_value());
    EXPECT_FALSE(unsupported);
    EXPECT_EQ(error_status, load_status::HARDWARE_ACCESS_FAIL);
    EXPECT_EQ(m_mock_chip->csr1.header_call_count, 5);
}

// ========================= resolve_sr_data CSR1 UID source selection 测试 =========================

TEST_F(ConnectorTest, ResolveSrData_Csr1UsesUidPathAndLocalWhenLocalVersionNewer)
{
    set_test_sr_dir("/tmp/connector_sr_csr1_local_newer");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_OLDER"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.09";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "LOCAL_NEWER");
    EXPECT_EQ(m_connector->i_connector.Id.get_value().as<std::string>(), "EEPROMUID");
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.valid);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.board_id, "EEPROMUID");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.file_path, test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr");
}

// 探测阶段仅读取 EEPROM header(uid/版本),本地版本较新时不应全量读取 EEPROM
TEST_F(ConnectorTest, ResolveSrData_ProbeUsesHeaderOnlyAndSkipsFullReadWhenLocalNewer)
{
    set_test_sr_dir("/tmp/connector_sr_probe_header_only");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_OLDER"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.09";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "LOCAL_NEWER");
    // 探测阶段仅读取 header,未全量读取 EEPROM
    EXPECT_EQ(m_mock_chip->csr1.header_call_count, 1);
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 0);
}

TEST_F(ConnectorTest, ResolveSrData_Csr1UsesEepromWhenEepromVersionEqualOrNewer)
{
    set_test_sr_dir("/tmp/connector_sr_csr1_eeprom_newer");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_NEWER"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    auto data = payload->as<mc::dict>();
    EXPECT_EQ(data["Name"].as<std::string>(), "EEPROM_NEWER");
    EXPECT_EQ(data["DataVersion"].as<std::string>(), "3.10");
    EXPECT_EQ(m_connector->i_connector.Id.get_value().as<std::string>(), "EEPROMUID");
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.valid);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.board_id, "EEPROMUID");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.file_path, test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr");
}

TEST_F(ConnectorTest, ResolveSrData_Csr1EmptyUidFallsBackToConfiguredLocalPath)
{
    set_test_sr_dir("/tmp/connector_sr_csr1_empty_uid");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"LOCAL_CONFIGURED"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_NO_UID"})";
    m_mock_chip->csr1.uid           = "";
    m_mock_chip->csr1.data_version  = "3.11";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "LOCAL_CONFIGURED");
    EXPECT_EQ(m_connector->i_connector.Id.get_value().as<std::string>(), "BOARD456");
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.valid);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.board_id, "BOARD456");
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.eeprom_data_version.empty());
}

// local 文件缺失(无 csr_version 记录)但 EEPROM 数据可用时,不应拿空版本做比较,
// 而应直接选用 EEPROM 数据。
TEST_F(ConnectorTest, ResolveSrData_Csr1UsesEepromWhenLocalFileAbsent)
{
    set_test_sr_dir("/tmp/connector_sr_csr1_local_absent");
    // 故意不写入 BOM12345_EEPROMUID_AUX789.sr,也不在 csr_version.json 登记
    // → local_data_version 保持为空,触发空串比较场景。

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_ONLY"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    uint8_t err     = load_status::DEFAULT;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    auto data = payload->as<mc::dict>();
    EXPECT_EQ(data["Name"].as<std::string>(), "EEPROM_ONLY");
    EXPECT_EQ(data["DataVersion"].as<std::string>(), "3.10");
    EXPECT_EQ(m_connector->i_connector.Id.get_value().as<std::string>(), "EEPROMUID");
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.valid);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.board_id, "EEPROMUID");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.eeprom_data_version, "3.10");
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.local_data_version.empty());
    // 选用 EEPROM 成功,不应上报本地文件错误
    EXPECT_EQ(err, load_status::DEFAULT);
}

// csr_version.json 有版本但磁盘上没有对应 .sr 时,该条目不能当作有效文件源,
// 应独立回退 EEPROM,而不是按版本比较选 local 后读盘失败。
TEST_F(ConnectorTest, ResolveSrData_EepromFallbackWhenCsrVersionExistsButFileAbsent)
{
    set_test_sr_dir("/tmp/connector_sr_json_ver_no_file");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_FALLBACK"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.09";

    uint8_t err     = load_status::DEFAULT;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "EEPROM_FALLBACK");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
    EXPECT_EQ(err, load_status::DEFAULT);
}

// 首次 resolve 选定 EEPROM 后,第二次进入快速缓存路径时 local_data_version 仍为空,
// 同样不应拿空版本做比较;应命中缓存且不触发芯片访问。
TEST_F(ConnectorTest, ResolveSrData_CacheHitWhenLocalFileAbsent)
{
    set_test_sr_dir("/tmp/connector_sr_csr1_local_absent_cache");
    // 不写入本地 .sr 文件,也不登记 csr_version

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_ONLY"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    // 首次:local 缺失 → 选用 EEPROM 并写入缓存
    uint8_t err   = load_status::DEFAULT;
    auto    first = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(first.has_value());
    auto first_data = first->as<mc::dict>();
    EXPECT_EQ(first_data["Name"].as<std::string>(), "EEPROM_ONLY");
    EXPECT_EQ(first_data["DataVersion"].as<std::string>(), "3.10");

    int csr1_calls_before = m_mock_chip->csr1.csr1_call_count;

    // 第二次:local 仍为空,快速缓存路径应命中缓存且不再访问芯片。
    uint8_t err2   = load_status::DEFAULT;
    auto    second = m_connector->i_connector.resolve_sr_data(false, true, false, err2);

    ASSERT_TRUE(second.has_value());
    auto second_data = second->as<mc::dict>();
    EXPECT_EQ(second_data["Name"].as<std::string>(), "EEPROM_ONLY");
    EXPECT_EQ(second_data["DataVersion"].as<std::string>(), "3.10");
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, csr1_calls_before);
    EXPECT_EQ(err2, load_status::DEFAULT);
}

// ========================= 本地版本兜底:从内置 SR 全文提取 DataVersion =========================

// csr_version.json 未登记时,应从内置 SR 全文提取 DataVersion 参与比较:
// 版本与 EEPROM 一致时选定本地源,且兜底阶段读到的数据直接复用(不二次读盘);
// 删除文件后二次调用应命中缓存,仍返回相同数据且不再访问芯片。
TEST_F(ConnectorTest, ResolveSrData_LocalVersionFallbackFromSrFileSelectsLocalWhenEqual)
{
    set_test_sr_dir("/tmp/connector_sr_fallback_equal");
    // 不写 csr_version.json,内置 SR 自带 DataVersion 且与 eeprom 一致
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_FROM_SR","DataVersion":"3.99"})");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_SAME_VER"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.99";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    auto d = payload->as<mc::dict>();
    // 版本一致 → 选本地源,内容为内置 SR 数据(非 EEPROM)
    EXPECT_EQ(d["Name"].as<std::string>(), "LOCAL_FROM_SR");
    EXPECT_EQ(d["DataVersion"].as<std::string>(), "3.99");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.local_data_version, "3.99");
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.local_version_from_sr_file);
    // 仅 header 探测,未全量读取 EEPROM
    EXPECT_EQ(m_mock_chip->csr1.header_call_count, 1);
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 0);

    // 删除本地文件后二次调用:应命中缓存直接返回,不重新读盘也不访问芯片。
    std::remove((test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr").c_str());
    int header_calls_before = m_mock_chip->csr1.header_call_count;
    int csr1_calls_before   = m_mock_chip->csr1.csr1_call_count;

    uint8_t err2   = 0;
    auto    second = m_connector->i_connector.resolve_sr_data(false, true, false, err2);

    ASSERT_TRUE(second.has_value());
    auto d2 = second->as<mc::dict>();
    EXPECT_EQ(d2["Name"].as<std::string>(), "LOCAL_FROM_SR");
    EXPECT_EQ(d2["DataVersion"].as<std::string>(), "3.99");
    EXPECT_EQ(m_mock_chip->csr1.header_call_count, header_calls_before);
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, csr1_calls_before);
}

// 内置 SR 兜底取到的版本较 EEPROM 旧时,仍应选 EEPROM,且本地版本被记录进缓存。
TEST_F(ConnectorTest, ResolveSrData_LocalVersionFallbackFromSrFileSelectsEepromWhenOlder)
{
    set_test_sr_dir("/tmp/connector_sr_fallback_older");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_FROM_SR","DataVersion":"3.09"})");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_NEWER"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "EEPROM_NEWER");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.local_data_version, "3.09");
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.local_version_from_sr_file);
}

// 内置 SR 存在但无 DataVersion 字段时,兜底后版本仍为空,维持原语义直接选 EEPROM。
TEST_F(ConnectorTest, ResolveSrData_LocalVersionFallbackWithoutDataVersionStillUsesEeprom)
{
    set_test_sr_dir("/tmp/connector_sr_fallback_no_ver");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NO_VER"})");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_ONLY"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "EEPROM_ONLY");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.local_data_version.empty());
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.local_version_from_sr_file);
}

// ========================= DataVersion 始终对齐 EEPROM 版本 =========================

// local 版本较新被选中时,内容用内置 SR,但 DataVersion 仍对齐到 EEPROM 版本(内置无该字段则补写)。
TEST_F(ConnectorTest, ResolveSrData_LocalSelectedStampsEepromDataVersionOntoPayload)
{
    set_test_sr_dir("/tmp/connector_sr_local_stamp_eeprom_ver");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_OLDER"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.09";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    auto d = payload->as<mc::dict>();
    EXPECT_EQ(d["Name"].as<std::string>(), "LOCAL_NEWER");
    // 选中内置源,但 EEPROM 版本(3.09)与内置不一致 → DataVersion 被盖成 EEPROM 版本
    EXPECT_EQ(d["DataVersion"].as<std::string>(), "3.09");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.eeprom_data_version, "3.09");
}

// local 文件自身已有 DataVersion 时,选中 local 仍用 EEPROM 版本覆盖,保证与硬件一致
TEST_F(ConnectorTest, ResolveSrData_LocalSelectedOverwritesExistingDataVersionWithEepromVersion)
{
    set_test_sr_dir("/tmp/connector_sr_local_stamp_overwrite");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER","DataVersion":"9.9"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_OLDER"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.09";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    auto d = payload->as<mc::dict>();
    EXPECT_EQ(d["Name"].as<std::string>(), "LOCAL_NEWER");
    // 内置文件自带 9.9,但 EEPROM 版本(3.09)与之不一致 → 被盖成 EEPROM 版本
    EXPECT_EQ(d["DataVersion"].as<std::string>(), "3.09");
}

// eeprom 版本不可用(空 uid 路径下 eeprom_data_version 被清空)时,即使最终选用 local 也不改写
TEST_F(ConnectorTest, ResolveSrData_LocalSelectedWithoutEepromVersionDoesNotStamp)
{
    set_test_sr_dir("/tmp/connector_sr_local_no_eeprom_ver");
    // local 文件自带 DataVersion,eeprom uid 为空 → eeprom_data_version 为空 → 不改写
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"LOCAL_CONFIGURED","DataVersion":"2.0"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_NO_UID"})";
    m_mock_chip->csr1.uid           = ""; // 空 uid → eeprom_data_version 被清空
    m_mock_chip->csr1.data_version  = "3.11";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    auto d = payload->as<mc::dict>();
    EXPECT_EQ(d["Name"].as<std::string>(), "LOCAL_CONFIGURED");
    // 没有 eeprom 版本可写入,保持 local 文件自身的 DataVersion
    ASSERT_TRUE(d.contains("DataVersion"));
    EXPECT_EQ(d["DataVersion"].as<std::string>(), "2.0");
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.eeprom_data_version.empty());
}

// 选用 EEPROM 数据时,应将最终 DataVersion 设置为 EEPROM header 中的版本。
TEST_F(ConnectorTest, ResolveSrData_EepromSelectedStampsDataVersion)
{
    set_test_sr_dir("/tmp/connector_sr_eeprom_selected_no_stamp");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_NEWER"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10"; // eeprom 较新 → 选用 eeprom

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    auto data = payload->as<mc::dict>();
    EXPECT_EQ(data["Name"].as<std::string>(), "EEPROM_NEWER");
    EXPECT_EQ(data["DataVersion"].as<std::string>(), "3.10");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
}

TEST_F(ConnectorTest, ResolveSrData_LocalFallbackStampsEepromHeaderDataVersion)
{
    set_test_sr_dir("/tmp/connector_sr_eeprom_fallback_stamp");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_FALLBACK","DataVersion":"1.00"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.BoardId       = std::string("EEPROMUID");
    m_mock_chip->csr2.DataVersion   = std::string("3.10");
    m_mock_chip->csr2.status        = load_status::HARDWARE_ACCESS_FAIL;
    m_mock_chip->csr1.throw_on_call = true;

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    auto data = payload->as<mc::dict>();
    EXPECT_EQ(data["Name"].as<std::string>(), "LOCAL_FALLBACK");
    // EEPROM 全量读失败回退到内置数据,但已拿到 EEPROM header 版本(3.10) → DataVersion 对齐到 3.10
    EXPECT_EQ(data["DataVersion"].as<std::string>(), "3.10");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
}

// 首次 resolve 选定 local 后把 DataVersion 对齐到 EEPROM(3.09),第二次缓存命中应返回同样已改写的 payload
TEST_F(ConnectorTest, ResolveSrData_CacheHitReturnsStampedDataVersion)
{
    set_test_sr_dir("/tmp/connector_sr_local_stamp_cache");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER","DataVersion":"3.10"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_OLDER"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.09";

    uint8_t err   = 0;
    auto    first = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(first.has_value());
    EXPECT_EQ(first->as<mc::dict>()["Name"].as<std::string>(), "LOCAL_NEWER");
    // 内置文件版本 3.10 与 EEPROM(3.09) 不一致 → 首次即被盖成 EEPROM 版本
    EXPECT_EQ(first->as<mc::dict>()["DataVersion"].as<std::string>(), "3.09");

    int csr1_calls_before = m_mock_chip->csr1.csr1_call_count;

    // 第二次:缓存命中,不再访问芯片,返回已对齐 EEPROM 版本(3.09)的 payload
    uint8_t err2   = 0;
    auto    second = m_connector->i_connector.resolve_sr_data(false, true, false, err2);
    ASSERT_TRUE(second.has_value());
    EXPECT_EQ(second->as<mc::dict>()["DataVersion"].as<std::string>(), "3.09");
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, csr1_calls_before);
}

// ========================= 版本号 x.xx 归一化 =========================

// normalize_version 把任意版本串/数值统一格式化为 x.xx(major + 两位 minor)
TEST(NormalizeVersionTest, FormatsVersionToTwoDecimalPlaces)
{
    EXPECT_EQ(normalize_version(std::string("3.1")), "3.10");
    EXPECT_EQ(normalize_version(std::string("3.10")), "3.10");
    EXPECT_EQ(normalize_version(std::string("3")), "3.00");
    EXPECT_EQ(normalize_version(std::string("5.0")), "5.00");
    EXPECT_EQ(normalize_version(std::string("3.09")), "3.09");
    EXPECT_EQ(normalize_version(3.1), "3.10");
    EXPECT_EQ(normalize_version(5.0), "5.00");
}

// 空串原样返回空串;无法解析为数值的串原样返回,不抛异常
TEST(NormalizeVersionTest, PreservesEmptyAndNonNumeric)
{
    EXPECT_EQ(normalize_version(std::string("")), "");
    EXPECT_EQ(normalize_version(std::string("abc")), "abc");
}

// EEPROM header 返回非 x.xx 版本("3.1")时,源头归一化为"3.10"并 stamp 到选中数据
TEST_F(ConnectorTest, ResolveSrData_NormalizesEepromDataVersionToTwoDecimals)
{
    set_test_sr_dir("/tmp/connector_sr_normalize_eeprom_ver");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_OLDER"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.1"; // 非 x.xx,源头应归一化为 3.10

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    auto d = payload->as<mc::dict>();
    EXPECT_EQ(d["Name"].as<std::string>(), "LOCAL_NEWER");
    // EEPROM "3.1" 归一化为 "3.10",与内置登记版本相等 → 选内置,DataVersion 盖成 "3.10"
    EXPECT_EQ(d["DataVersion"].as<std::string>(), "3.10");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.eeprom_data_version, "3.10");
}

// 内置 SR 数据的 DataVersion 为数值型时,永不视为已对齐 → 必被 stamp 成 EEPROM 的 x.xx 字符串
TEST_F(ConnectorTest, ResolveSrData_NumericDataVersionAlwaysStampedToString)
{
    set_test_sr_dir("/tmp/connector_sr_numeric_data_ver");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER","DataVersion":3.1})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_OLDER"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    auto d = payload->as<mc::dict>();
    EXPECT_EQ(d["Name"].as<std::string>(), "LOCAL_NEWER");
    // 数值型 3.1 不会与字符串 "3.10" 逐字符相等 → 被 stamp,且结果必为字符串(上报路径按字符串读取)
    EXPECT_TRUE(d["DataVersion"].is_string());
    EXPECT_EQ(d["DataVersion"].as<std::string>(), "3.10");
}

// csr_version.json 登记的非 x.xx 本地版本("3.1")经 get_local_csr_data_version 归一化为"3.10",
// 避免 version_greater 把 "3.1" 误解析为 (3,1) 而错选 EEPROM 源
TEST_F(ConnectorTest, ResolveSrData_NormalizesLocalCsrVersionForSourceSelection)
{
    set_test_sr_dir("/tmp/connector_sr_normalize_local_ver");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_NEWER"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.1"); // 归一化后为 3.10

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_OLDER"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.09";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    // 本地版本归一化为 "3.10" > EEPROM "3.09" → 选内置源;若未归一化("3.1"→(3,1)) 会误判 EEPROM 更新
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.local_data_version, "3.10");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
    auto d = payload->as<mc::dict>();
    EXPECT_EQ(d["Name"].as<std::string>(), "LOCAL_NEWER");
    EXPECT_EQ(d["DataVersion"].as<std::string>(), "3.09"); // stamp 到 EEPROM 版本
}

// ========================= dump 功能测试 =========================

// 测试 IConnector::dump 方法
TEST_F(ConnectorTest, test_iconnector_dump)
{
    auto csr       = create_test_csr(0);
    auto connector = create_test_connector();

    bool result = m_connector->init(csr, connector);
    ASSERT_TRUE(result);

    // 执行一些操作
    uint8_t presence = m_connector->i_connector.Presence.get_value().as<uint8_t>();
    m_connector->i_connector.Presence.set_value(1);

    // 调用 dump 方法
    auto dump_info = m_connector->i_connector.dump();

    // 验证 dump 信息
    EXPECT_EQ(dump_info.presence, 1);
}

// 测试 Connector::dump 方法 — 非 SUCCESS 路径:验证所有标准属性及值,确认 extra properties 不输出
TEST_F(ConnectorTest, test_connector_dump)
{
    auto csr       = create_test_csr(0);
    auto connector = create_test_connector();

    bool result = m_connector->init(csr, connector);
    ASSERT_TRUE(result);

    m_connector->i_connector.Presence.set_value(1);
    ASSERT_TRUE(wait_for_load_status(load_status::LOCAL_FILE_ERROR));

    std::string dump_output = m_connector->dump();

    // Helper: 验证 dump 输出中某一行包含指定的 prefix+label 和 value
    auto verify_line = [&](const std::string& prefix, const std::string& label, const std::string& value_str) {
        auto pos = dump_output.find(prefix + label);
        EXPECT_NE(pos, std::string::npos) << "Missing line for: " << prefix << label;
        if (pos == std::string::npos) {
            return;
        }
        auto nl = dump_output.find('\n', pos);
        ASSERT_NE(nl, std::string::npos);
        std::string line = dump_output.substr(pos, nl - pos);
        EXPECT_NE(line.find(value_str), std::string::npos) << "Expected value '" << value_str << "' in line: " << line;
    };

    EXPECT_FALSE(dump_output.empty());

    // 验证全部 15 个标准属性(. 前缀)存在且值正确
    verify_line(".", "AuxId", "AUX789");
    verify_line(".", "Bom", "BOM12345");
    verify_line(".", "Buses", R"(["I2c_1"])");
    verify_line(".", "ChassisId", "Chassis1");
    verify_line(".", "GroupId", "10");
    verify_line(".", "GroupPosition", "A1");
    verify_line(".", "Id", "BOARD456");
    verify_line(".", "IdentifyMode", "0");
    verify_line(".", "LoadStatus", "4"); // load_status::LOCAL_FILE_ERROR (SR 文件未找到)
    verify_line(".", "ManagerId", "Manager1");
    verify_line(".", "Presence", "1");
    verify_line(".", "SilkText", "Silk1");
    verify_line(".", "Slot", "1");
    verify_line(".", "SystemId", "1");
    verify_line(".", "Type", "Card");

    // 非 SUCCESS 径径:extra properties(- 前缀)不应出现
    EXPECT_EQ(dump_output.find("-SoftSourcePath"), std::string::npos);
    EXPECT_EQ(dump_output.find("-DataSource"), std::string::npos);
    EXPECT_EQ(dump_output.find("-EffectiveFormatVersion"), std::string::npos);
    EXPECT_EQ(dump_output.find("-EffectiveDataVersion"), std::string::npos);
    EXPECT_EQ(dump_output.find("-EepromFormatVersion"), std::string::npos);
    EXPECT_EQ(dump_output.find("-EepromDataVersion"), std::string::npos);
    EXPECT_EQ(dump_output.find("-LocalFormatVersion"), std::string::npos);
    EXPECT_EQ(dump_output.find("-LocalDataVersion"), std::string::npos);
}

// 测试 Connector::dump 方法 — SUCCESS 路径:验证 extra properties(- 前缀)正确输出
TEST_F(ConnectorTest, test_connector_dump_success)
{
    set_test_sr_dir("/tmp/connector_dump_success");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr",
               R"({"Name":"DUMP_LOCAL","FormatVersion":"1.0","DataVersion":"2.0"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    // 模拟 EEPROM 版本更新 → 选中 eeprom source
    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"DUMP_EEPROM","FormatVersion":"3.0","DataVersion":"4.0"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(payload.has_value());

    // 注意:resolve_sr_data 返回数据但不设置 LoadStatus
    // LoadStatus 只在 add_device_to_devmon 成功后才设置为 SUCCESS
    // 因此 LoadStatus 保持 DEFAULT (255)

    std::string dump_output = m_connector->dump();

    auto verify_line = [&](const std::string& prefix, const std::string& label, const std::string& value_str) {
        auto pos = dump_output.find(prefix + label);
        EXPECT_NE(pos, std::string::npos) << "Missing line for: " << prefix << label;
        if (pos == std::string::npos) {
            return;
        }
        auto nl = dump_output.find('\n', pos);
        ASSERT_NE(nl, std::string::npos);
        std::string line = dump_output.substr(pos, nl - pos);
        EXPECT_NE(line.find(value_str), std::string::npos) << "Expected value '" << value_str << "' in line: " << line;
    };

    EXPECT_FALSE(dump_output.empty());

    // 标准属性 verification(Presence 来自 create_test_csr(1) = 1)
    verify_line(".", "AuxId", "AUX789");
    verify_line(".", "Bom", "BOM12345");
    verify_line(".", "Buses", R"(["I2c_1"])");
    verify_line(".", "ChassisId", "Chassis1");
    verify_line(".", "GroupId", "10");
    verify_line(".", "GroupPosition", "A1");
    verify_line(".", "Id", "EEPROMUID");   // resolve_sr_data 更新了 Id
    verify_line(".", "IdentifyMode", "3"); // identify_mode::EEPROM
    verify_line(".", "LoadStatus", "255"); // load_status::DEFAULT (resolve_sr_data 不设置 LoadStatus)
    verify_line(".", "ManagerId", "Manager1");
    verify_line(".", "Presence", "1");
    verify_line(".", "SilkText", "Silk1");
    verify_line(".", "Slot", "1");
    verify_line(".", "SystemId", "1");
    verify_line(".", "Type", "Card");

    // LoadStatus 不是 SUCCESS,extra properties(- 前缀)不应出现
    EXPECT_EQ(dump_output.find("-SourcePath"), std::string::npos);
    EXPECT_EQ(dump_output.find("-LocalDataVersion"), std::string::npos);
}

TEST_F(ConnectorTest, test_connector_dump_success_includes_source_path)
{
    auto csr       = create_test_csr(0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);
    m_connector->i_connector.m_sr_cache.valid     = true;
    m_connector->i_connector.m_sr_cache.source    = connector_sr_source::local;
    m_connector->i_connector.m_sr_cache.file_path = "/opt/bmc/sr/test_connector.sr";

    EXPECT_TRUE(m_connector->get_managed_objects().empty());
    EXPECT_NE(m_connector->dump().find("/opt/bmc/sr/test_connector.sr"), std::string::npos);
}

TEST_F(ConnectorTest, test_connector_dump_eeprom_source_path)
{
    auto csr       = create_test_csr(0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);
    m_connector->i_connector.m_sr_cache.valid    = true;
    m_connector->i_connector.m_sr_cache.source   = connector_sr_source::eeprom;
    m_connector->i_connector.m_sr_cache.board_id = "EEPROMUID";

    EXPECT_NE(m_connector->dump().find("/data/opt/bmc/sr/backup/EEPROMUID.bin"), std::string::npos);
}

TEST_F(ConnectorTest, test_connector_dump_gold_source_path)
{
    auto csr       = create_test_csr(0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);
    m_connector->i_connector.m_sr_cache.valid         = true;
    m_connector->i_connector.m_sr_cache.source        = connector_sr_source::gold;
    m_connector->i_connector.m_sr_cache.selected_path = "/data/opt/bmc/sr/gold/test_connector.sr";

    std::string dump_output = m_connector->dump();
    EXPECT_NE(dump_output.find("GOLD"), std::string::npos);
    EXPECT_NE(dump_output.find("/data/opt/bmc/sr/gold/test_connector.sr"), std::string::npos);
}

TEST_F(ConnectorTest, test_connector_dump_temp_source_path)
{
    auto csr       = create_test_csr(0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);
    m_connector->i_connector.m_sr_cache.valid         = true;
    m_connector->i_connector.m_sr_cache.source        = connector_sr_source::temp;
    m_connector->i_connector.m_sr_cache.selected_path = "/data/opt/bmc/sr/temp/test_connector.sr";

    std::string dump_output = m_connector->dump();
    EXPECT_NE(dump_output.find("TEMP"), std::string::npos);
    EXPECT_NE(dump_output.find("/data/opt/bmc/sr/temp/test_connector.sr"), std::string::npos);
}

// 测试 Connector::dump 字符串输出中 Buses 的序列化
TEST_F(ConnectorTest, test_connector_dump_buses_string_output)
{
    auto check_buses_line = [](const std::string& output, const std::string& expected_buses) {
        auto pos = output.find(".Buses");
        EXPECT_NE(pos, std::string::npos);
        if (pos == std::string::npos) {
            return;
        }
        auto nl = output.find('\n', pos);
        ASSERT_NE(nl, std::string::npos);
        std::string line = output.substr(pos, nl - pos);
        EXPECT_NE(line.find(expected_buses), std::string::npos);
    };

    // 场景1: 简单 Buses
    {
        auto csr       = create_test_csr(0);
        csr["Buses"]   = std::vector<std::string>{"I2c_1", "I2c_2"};
        auto connector = create_test_connector();
        ASSERT_TRUE(m_connector->init(csr, connector));

        std::string output = m_connector->dump();
        check_buses_line(output, R"(["I2c_1","I2c_2"])");
    }

    // 场景2: 含特殊字符的 Buses
    {
        auto csr       = create_test_csr(0);
        csr["Buses"]   = std::vector<std::string>{"bus\"with\"quotes", "bus\\backslash", "bus\nnewline"};
        auto connector = create_test_connector();
        ASSERT_TRUE(m_connector->init(csr, connector));

        std::string output = m_connector->dump();
        check_buses_line(output, R"(["bus\"with\"quotes","bus\\backslash","bus\nnewline"])");
    }

    // 场景3: 空 Buses
    {
        auto csr       = create_test_csr(0);
        csr["Buses"]   = std::vector<std::string>{};
        auto connector = create_test_connector();
        ASSERT_TRUE(m_connector->init(csr, connector));

        std::string output = m_connector->dump();
        check_buses_line(output, "[]");
    }
}

TEST_F(ConnectorTest, test_connector_dump_buses_json_escape)
{
    auto csr       = create_test_csr(0);
    csr["Buses"]   = std::vector<std::string>{"bus\"with\"quotes", "bus\\backslash", "bus\nnewline"};
    auto connector = create_test_connector();

    bool result = m_connector->init(csr, connector);
    ASSERT_TRUE(result);

    auto dump_info = m_connector->i_connector.dump();

    EXPECT_EQ(dump_info.buses, R"(["bus\"with\"quotes","bus\\backslash","bus\nnewline"])");
}

TEST_F(ConnectorTest, test_connector_dump_buses_simple)
{
    auto csr       = create_test_csr(0);
    csr["Buses"]   = std::vector<std::string>{"I2c_1", "I2c_2"};
    auto connector = create_test_connector();

    bool result = m_connector->init(csr, connector);
    ASSERT_TRUE(result);

    auto dump_info = m_connector->i_connector.dump();

    EXPECT_EQ(dump_info.buses, R"(["I2c_1","I2c_2"])");
}

TEST_F(ConnectorTest, test_connector_dump_buses_empty)
{
    auto csr       = create_test_csr(0);
    csr["Buses"]   = std::vector<std::string>{};
    auto connector = create_test_connector();

    bool result = m_connector->init(csr, connector);
    ASSERT_TRUE(result);

    auto dump_info = m_connector->i_connector.dump();

    EXPECT_EQ(dump_info.buses, "[]");
}

// ========================= Reload 功能测试 =========================

TEST_F(ConnectorTest, Reload_RemovesOldIdentityThenLoadsReplacementIdentity)
{
    set_test_sr_dir("/tmp/connector_reload_local");
    write_file(test_sr_dir + "/NEWBOM_NEWID_NEWAUX.sr", R"({"Name":"RELOADED"})");
    write_csr_version("NEWBOM_NEWID_NEWAUX", "3.10");

    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_devmon();

    m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);

    m_connector->i_connector.Reload("NEWBOM", "NEWID", "NEWAUX", 0);

    ASSERT_EQ(m_mock_devmon->devmon.remove_device_call_count, 1);
    ASSERT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
    ASSERT_EQ(m_mock_devmon->devmon.remove_device_connectors.size(), 1u);
    ASSERT_EQ(m_mock_devmon->devmon.add_device_connectors.size(), 1u);

    const auto& removed = m_mock_devmon->devmon.remove_device_connectors.front();
    EXPECT_EQ(removed.at("Bom").as<std::string>(), "BOM12345");
    EXPECT_EQ(removed.at("Id").as<std::string>(), "BOARD456");
    EXPECT_EQ(removed.at("AuxId").as<std::string>(), "AUX789");

    const auto& added = m_mock_devmon->devmon.add_device_connectors.front();
    EXPECT_EQ(added.at("Bom").as<std::string>(), "NEWBOM");
    EXPECT_EQ(added.at("Id").as<std::string>(), "NEWID");
    EXPECT_EQ(added.at("AuxId").as<std::string>(), "NEWAUX");
    EXPECT_EQ(added.at("IdentifyMode").as<uint8_t>(), 0);

    EXPECT_EQ(m_connector->i_connector.Bom.get_value().as<std::string>(), "NEWBOM");
    EXPECT_EQ(m_connector->i_connector.Id.get_value().as<std::string>(), "NEWID");
    EXPECT_EQ(m_connector->i_connector.AuxId.get_value().as<std::string>(), "NEWAUX");
    EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::SUCCESS);
}

TEST_F(ConnectorTest, TryLoadDeviceWaitsForAsyncDevmonWithoutBlockingCaller)
{
    set_test_sr_dir("/tmp/connector_async_load");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"ASYNC_LOAD"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr       = create_test_csr(0, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_devmon();
    m_mock_devmon->devmon.delay_add = true;

    auto completion = m_connector->i_connector.try_load_device();
    EXPECT_FALSE(completion.is_ready());

    EXPECT_NO_THROW(completion.get());
    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
    EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::SUCCESS);
}

TEST_F(ConnectorTest, TryLoadDeviceSetsObjectParseErrorWhenDevmonRejectsCsr)
{
    set_test_sr_dir("/tmp/connector_devmon_reject");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"INVALID_CSR"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr       = create_test_csr(0, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_devmon();
    m_mock_devmon->devmon.fail_add = true;

    auto completion = m_connector->i_connector.try_load_device();

    EXPECT_THROW(completion.get(), mc::exception);
    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
    EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::OBJECT_PARSE_ERROR);
}

// 单飞守卫(Fix B 核心场景):同一启动代次内,Presence 信号与初始在位检查对同一 position
// 并发触发时,只应真正下发一次 AddDeviceWithData;且首链终态后守卫须归还,使后续合法
// 触发仍可加载(不永久泄漏)。
TEST_F(ConnectorTest, TryLoadDeviceSingleFlightGuardDedupsDuplicateTriggerThenReleases)
{
    set_test_sr_dir("/tmp/connector_singleflight_guard");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"SINGLEFLIGHT"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr       = create_test_csr(0, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_devmon();
    // 让 AddDeviceWithData 异步延迟,令首链在第二发触发时仍处「在飞」状态、守卫被持有
    m_mock_devmon->devmon.delay_add = true;

    auto epoch = m_connector->i_connector.begin_start();

    // 双触发:f1 同步抢占守卫并进入在飞加载,返回 true(本链真正执行);紧随其后的 f2 抢不到守卫
    // → 跳过并返回 false(调用方据此不再打印「device loaded」),不再下发 AddDeviceWithData
    auto f1 = m_connector->i_connector.try_load_device_with_sr_retry(epoch);
    auto f2 = m_connector->i_connector.try_load_device_with_sr_retry(epoch);
    EXPECT_TRUE(f1.get());
    EXPECT_FALSE(f2.get());
    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
    EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::SUCCESS);

    // 首链终态已按自身链 id 归还守卫:再次触发应能重新抢占并真正加载(证明守卫未永久泄漏)
    auto f3 = m_connector->i_connector.try_load_device_with_sr_retry(epoch);
    EXPECT_TRUE(f3.get());
    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 2);
}

// R1 回归:同代次「拔掉→再插入」且旧链仍在飞时,移除路径强制释放守卫后新链抢占;
// 待旧链终态释放时必须按「自身链 id」CAS,因与新链 id 不匹配而空操作,绝不
// 误清新链守卫——否则后续第三条触发会误以为空闲而并发下发。本用例验证该保证。
TEST_F(ConnectorTest, OldInflightChainTerminalReleaseDoesNotClobberReinsertedChainGuard)
{
    set_test_sr_dir("/tmp/connector_singleflight_clobber");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"CLOBBER"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr       = create_test_csr(0, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_devmon();
    m_mock_devmon->devmon.delay_add = true; // 令链 A/B 在 get() 前保持在飞

    auto epoch = m_connector->i_connector.begin_start();

    // 链 A 抢占守卫并进入在飞加载(其 AddDevice 尚在延迟中,未到终态)
    auto chainA = m_connector->i_connector.try_load_device_with_sr_retry(epoch);
    // 模拟「拔掉」:移除路径无条件强制释放守卫,为新链让位
    m_connector->i_connector.force_release_load_guard();
    // 模拟「再插入」链 B 持有守卫:仅用不同链 id 占位,避免 B 的异步完成干扰本用例确定性时序
    auto tokenB = m_connector->i_connector.next_load_chain_id();
    ASSERT_TRUE(m_connector->i_connector.acquire_load_guard(tokenB));

    // 旧链 A 到达终态,其释放按自身链 id 做 CAS;此时守卫是 tokenB,应空操作不致误清
    EXPECT_TRUE(chainA.get());

    // 链 B 仍持有守卫:第三条触发应被拦下(返回 false),证明 A 未误清 B 的守卫
    auto chainC = m_connector->i_connector.try_load_device_with_sr_retry(epoch);
    EXPECT_FALSE(chainC.get());

    // 归还链 B 的守卫后,新触发才能重新抢占
    m_connector->i_connector.release_load_guard(tokenB);
    auto chainD = m_connector->i_connector.try_load_device_with_sr_retry(epoch);
    EXPECT_TRUE(chainD.get());
}

// 重试链(attempt>1)复查守卫所有权:若守卫已不属于本链(被 force_release 或被新链抢占),
// 重试应放弃而非继续下发 AddDeviceWithData,否则与新链并发。本用例验证两条路径。
TEST_F(ConnectorTest, RetryChainAbortsWhenGuardOwnershipLost)
{
    set_test_sr_dir("/tmp/connector_retry_abort");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"RETRYABORT"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr       = create_test_csr(0, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_devmon();

    auto epoch = m_connector->i_connector.begin_start();

    // 负例:attempt>1 但守卫空闲(本链从未持有)→ 重试放弃、不下发 AddDeviceWithData
    auto foreign_token = m_connector->i_connector.next_load_chain_id();
    auto f_abort       = m_connector->i_connector.try_load_device_with_sr_retry(epoch, foreign_token, 2);
    EXPECT_FALSE(f_abort.get());
    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 0);

    // 正例:attempt>1 且守卫归本链持有 → 重试正常执行并下发 AddDeviceWithData
    m_mock_devmon->devmon.delay_add = true;
    auto held_token                 = m_connector->i_connector.next_load_chain_id();
    ASSERT_TRUE(m_connector->i_connector.acquire_load_guard(held_token)); // 模拟首轮已抢占
    auto f_ok = m_connector->i_connector.try_load_device_with_sr_retry(epoch, held_token, 2);
    EXPECT_TRUE(f_ok.get()); // 执行了加载并终态释放
    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
}

TEST_F(ConnectorTest, PresenceChangeLoadsDeviceAfterPropertyCallbackReturns)
{
    set_test_sr_dir("/tmp/connector_presence_load");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"PRESENCE_LOAD"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr       = create_test_csr(0, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_devmon();

    EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(1));
    ASSERT_TRUE(wait_for_load_status(load_status::SUCCESS));

    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
    EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::SUCCESS);
}

TEST_F(ConnectorTest, PresenceChangeRetriesWholeEepromLoad)
{
    set_test_sr_dir("/tmp/connector_presence_load_retry");

    auto csr       = create_test_csr(0, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();
    install_mock_devmon();

    // 第一次整体加载中 GetSRData 的 5 次硬件访问均失败;第二次整体加载应成功。
    m_mock_chip->csr1.hardware_access_failures_remaining = 5;

    EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(1));
    ASSERT_TRUE(wait_for_load_status(load_status::SUCCESS));

    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 6);
    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
}

TEST_F(ConnectorTest, TryLoadDeviceWithRetryStopsAfterTwoFailedEepromLoads)
{
    set_test_sr_dir("/tmp/connector_presence_load_retry_exhausted");

    auto csr       = create_test_csr(0, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();
    install_mock_devmon();

    // 每次整体加载包含 5 次 EEPROM 硬件访问;两次整体加载均失败后停止。
    m_mock_chip->csr1.hardware_access_failures_remaining = 10;
    auto epoch                                           = m_connector->i_connector.begin_start();

    auto completion = m_connector->i_connector.try_load_device_with_sr_retry(epoch);
    EXPECT_NO_THROW(completion.get());

    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 10);
    EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, 0);
    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 0);
    // 无有效本地候选源时,不能用本地文件错误覆盖 EEPROM 硬件访问失败。
    EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::HARDWARE_ACCESS_FAIL);
}

TEST_F(ConnectorTest, PresenceChangeDoesNotRetryDevmonFailure)
{
    set_test_sr_dir("/tmp/connector_presence_devmon_failure");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"INVALID_CSR"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr       = create_test_csr(0, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_devmon();
    m_mock_devmon->devmon.fail_add = true;

    EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(1));
    ASSERT_TRUE(wait_for_load_status(load_status::OBJECT_PARSE_ERROR));

    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
}

TEST_F(ConnectorTest, MissingHotPluggableDefaultsToSupported)
{
    set_test_sr_dir("/tmp/connector_hotplug_default");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"DEFAULT_HOTPLUG"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_devmon();

    EXPECT_NO_THROW(m_connector->i_connector.try_load_device().get());
    EXPECT_TRUE(m_connector->i_connector.HotPluggable.get_value().as<bool>());
    EXPECT_TRUE(m_mock_devmon->devmon.add_device_connectors.front().at("HotPluggable").as<bool>());
}

TEST_F(ConnectorTest, NonHotPluggableDeviceStaysLoadedAcrossPresenceChanges)
{
    set_test_sr_dir("/tmp/connector_non_hotplug");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"NON_HOTPLUG"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr            = create_test_csr(0, 0);
    csr["HotPluggable"] = false;
    auto connector      = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_devmon();

    EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(1));
    ASSERT_TRUE(wait_for_load_status(load_status::SUCCESS));
    EXPECT_FALSE(m_connector->i_connector.HotPluggable.get_value().as<bool>());
    EXPECT_FALSE(m_mock_devmon->devmon.add_device_connectors.front().at("HotPluggable").as<bool>());

    EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(static_cast<uint8_t>(0)));
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
    EXPECT_EQ(m_mock_devmon->devmon.remove_device_call_count, 0);
    EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::SUCCESS);

    EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(1));
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
}

TEST_F(ConnectorTest, NonHotPluggableDeviceRetriesSrLoadFiveTimes)
{
    set_test_sr_dir("/tmp/connector_non_hotplug_sr_retry");

    auto csr            = create_test_csr(1, identify_mode::EEPROM);
    csr["HotPluggable"] = false;
    auto connector      = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();
    install_mock_devmon();

    m_mock_chip->csr2.throw_on_call                      = true;
    m_mock_chip->csr1.hardware_access_failures_remaining = 25;
    auto epoch                                           = m_connector->i_connector.begin_start();
    auto start                                           = std::chrono::steady_clock::now();

    EXPECT_NO_THROW(m_connector->i_connector.try_load_device_with_sr_retry(epoch).get());
    const auto elapsed =
        std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - start);
    EXPECT_GE(elapsed.count(), 1900);
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 25);
    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 0);
    EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::HARDWARE_ACCESS_FAIL);
}

TEST_F(ConnectorTest, NonHotPluggableDeviceDoesNotRetryAddDeviceFailure)
{
    set_test_sr_dir("/tmp/connector_non_hotplug_add_failure");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"NON_HOTPLUG"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr            = create_test_csr(1, 0);
    csr["HotPluggable"] = false;
    auto connector      = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_devmon();
    m_mock_devmon->devmon.fail_add = true;

    EXPECT_THROW(m_connector->i_connector.try_load_device().get(), mc::exception);
    EXPECT_FALSE(m_connector->i_connector.HotPluggable.get_value().as<bool>());
    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
    EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::OBJECT_PARSE_ERROR);
}

TEST_F(ConnectorTest, HotPluggableDeviceUnloadsOnPresenceDeassertion)
{
    set_test_sr_dir("/tmp/connector_hotplug_unload");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"HOTPLUG"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr       = create_test_csr(0, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_devmon();

    EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(1));
    ASSERT_TRUE(wait_for_load_status(load_status::SUCCESS));
    EXPECT_TRUE(m_connector->i_connector.HotPluggable.get_value().as<bool>());

    EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(static_cast<uint8_t>(0)));
    ASSERT_TRUE(wait_for_load_status(load_status::DEFAULT));
    EXPECT_EQ(m_mock_devmon->devmon.remove_device_call_count, 1);
}

TEST_F(ConnectorTest, TryLoadDeviceWithRetrySkipsStoppedAndStaleStart)
{
    set_test_sr_dir("/tmp/connector_retry_stale_start");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"STALE_START"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr       = create_test_csr(0, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_devmon();

    auto old_epoch = m_connector->i_connector.begin_start();
    m_connector->stop();
    EXPECT_NO_THROW(m_connector->i_connector.try_load_device_with_sr_retry(old_epoch).get());

    m_connector->i_connector.begin_start();
    EXPECT_NO_THROW(m_connector->i_connector.try_load_device_with_sr_retry(old_epoch).get());

    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 0);
    EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::DEFAULT);
}

TEST_F(ConnectorTest, Reload_EepromModeRefreshesCachedEepromData)
{
    set_test_sr_dir("/tmp/connector_reload_eeprom_refresh");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();
    install_mock_devmon();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_FIRST"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    uint8_t err   = 0;
    auto    first = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(first.has_value());
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 1);

    m_mock_chip->csr1.payload = R"({"Name":"EEPROM_SECOND"})";
    m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);

    m_connector->i_connector.Reload("BOM12345", "EEPROMUID", "AUX789", identify_mode::EEPROM);

    EXPECT_GE(m_mock_chip->csr1.csr1_call_count, 2);
    ASSERT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
    ASSERT_TRUE(m_mock_devmon->devmon.last_sr_data.has_value());
    auto data = m_mock_devmon->devmon.last_sr_data->as<mc::dict>();
    EXPECT_EQ(data["Name"].as<std::string>(), "EEPROM_SECOND");
    EXPECT_EQ(data["DataVersion"].as<std::string>(), "3.10");
}

// ========================= LoadStatus preload 隔离测试 =========================

TEST_F(ConnectorTest, PreloadEepromFailureDoesNotChangeLoadStatus)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.status        = load_status::HARDWARE_ACCESS_FAIL;
    m_mock_chip->csr1.throw_on_call = true;

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, false, true, err);

    EXPECT_FALSE(payload.has_value());
    EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::DEFAULT);
}

TEST_F(ConnectorTest, PreloadLocalFileFailureDoesNotChangeLoadStatus)
{
    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    // 使用不存在的文件路径
    setenv("CONNECTOR_SR_DIR", "/tmp/connector_nonexistent_dir", 1);
    unsetenv("PROG_CSR_PATH");
    m_connector->i_connector.Bom.set_value(std::string("BOM12345"));
    m_connector->i_connector.Id.set_value(std::string("NONEXISTENT"));

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, false, true, err);

    EXPECT_FALSE(payload.has_value());
    EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::DEFAULT);
}

TEST_F(ConnectorTest, PreloadWithoutIdentitySkipsMalformedLocalPath)
{
    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    set_test_sr_dir("/tmp/connector_preload_without_identity");
    write_file(test_sr_dir + "/csr_version.json", "{}");
    write_file(test_sr_dir + "/BOM12345_.sr", R"({"Name":"SHOULD_NOT_LOAD"})");
    unsetenv("PROG_CSR_PATH");
    m_connector->i_connector.Bom.set_value(std::string("BOM12345"));
    m_connector->i_connector.Id.set_value(std::string());
    m_connector->i_connector.AuxId.set_value(std::string());

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, false, true, err);

    EXPECT_FALSE(payload.has_value());
    EXPECT_EQ(m_connector->i_connector.LoadStatus.get_value().as<uint8_t>(), load_status::DEFAULT);
}

TEST_F(ConnectorTest, LoadPathEepromFailureSetsErrorStatus)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.status        = load_status::HARDWARE_ACCESS_FAIL;
    m_mock_chip->csr1.throw_on_call = true;

    uint8_t err     = load_status::DEFAULT;
    auto    payload = m_connector->i_connector.resolve_sr_data(true, true, false, err);

    EXPECT_FALSE(payload.has_value());
    EXPECT_EQ(err, load_status::HARDWARE_ACCESS_FAIL);
}

TEST_F(ConnectorTest, LoadPathLocalFileFailureSetsErrorStatus)
{
    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    setenv("CONNECTOR_SR_DIR", "/tmp/connector_nonexistent_dir", 1);
    unsetenv("PROG_CSR_PATH");
    m_connector->i_connector.Bom.set_value(std::string("BOM12345"));
    m_connector->i_connector.Id.set_value(std::string("NONEXISTENT"));

    uint8_t err     = load_status::DEFAULT;
    auto    payload = m_connector->i_connector.resolve_sr_data(true, true, false, err);

    EXPECT_FALSE(payload.has_value());
    EXPECT_EQ(err, load_status::LOCAL_FILE_ERROR);
}

TEST_F(ConnectorTest, LoadPathSuccessDoesNotChangeErrorStatus)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr1.payload       = R"({"Name":"TEST"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";
    m_mock_chip->csr2.throw_on_call = true;

    set_test_sr_dir("/tmp/connector_sr_success_test");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "0.1");
    unsetenv("PROG_CSR_PATH");

    uint8_t err     = load_status::DEFAULT;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    EXPECT_TRUE(payload.has_value());
    EXPECT_EQ(err, load_status::DEFAULT);
}

// ========================= 快速缓存查找跳过芯片访问 =========================

TEST_F(ConnectorTest, LoadPathCacheHitSkipsChipAccess)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"CSR1"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    set_test_sr_dir("/tmp/connector_sr_fast_cache_hit");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "0.1");
    unsetenv("PROG_CSR_PATH");

    // preload: CSR2 throws → CSR1 succeeds → 缓存 eeprom payload
    uint8_t dummy          = 0;
    auto    preload_result = m_connector->i_connector.resolve_sr_data(false, false, true, dummy);
    ASSERT_TRUE(preload_result.has_value());

    int csr2_calls_before = m_mock_chip->csr2.csr2_call_count;
    int csr1_calls_before = m_mock_chip->csr1.csr1_call_count;

    // load path: 缓存应命中,不触发芯片访问
    uint8_t err         = load_status::DEFAULT;
    auto    load_result = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    EXPECT_TRUE(load_result.has_value());
    EXPECT_EQ(m_mock_chip->csr2.csr2_call_count, csr2_calls_before);
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, csr1_calls_before);
}

TEST_F(ConnectorTest, LoadPathCacheMissFallsBackToChipAccess)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"CSR1"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    set_test_sr_dir("/tmp/connector_sr_fast_cache_miss");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "0.1");
    unsetenv("PROG_CSR_PATH");

    // preload: EEPROM 版本 3.10 > 本地 0.1 → source=eeprom
    uint8_t dummy          = 0;
    auto    preload_result = m_connector->i_connector.resolve_sr_data(false, false, true, dummy);
    ASSERT_TRUE(preload_result.has_value());

    // 修改本地版本使其高于 EEPROM → desired_source 变为 local → 快速缓存 miss
    write_csr_version("BOM12345_EEPROMUID_AUX789", "5.0");
    m_connector->i_connector.m_local_csr_version_cache.reset();

    int header_calls_before = m_mock_chip->csr1.header_call_count;
    int csr1_calls_before   = m_mock_chip->csr1.csr1_call_count;

    // load path: 缓存 miss → 应回退到芯片访问(探测阶段读取 EEPROM header,
    // 本地版本较新时不触发全量读取)
    uint8_t err         = load_status::DEFAULT;
    auto    load_result = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    EXPECT_TRUE(load_result.has_value());
    EXPECT_GT(m_mock_chip->csr1.header_call_count, header_calls_before);
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, csr1_calls_before);
}

// ========================= get_soft_file_path 测试 =========================

TEST_F(ConnectorTest, GetSoftFilePath_NormalPath)
{
    EXPECT_EQ(m_connector->i_connector.get_soft_file_path("/opt/bmc/sr/BOM_BOARD.sr"), "/opt/bmc/sr/BOM_BOARD_soft.sr");
}

TEST_F(ConnectorTest, GetSoftFilePath_WithoutExtension)
{
    EXPECT_EQ(m_connector->i_connector.get_soft_file_path("/opt/bmc/sr/noext"), "/opt/bmc/sr/noext_soft.sr");
}

TEST_F(ConnectorTest, GetSoftFilePath_EmptyPath)
{
    EXPECT_EQ(m_connector->i_connector.get_soft_file_path(""), "_soft.sr");
}

// ========================= merge_soft_data 单元测试 =========================

// 场景1:FormatVersion 在 [3.0, 5.0) 区间,soft 文件存在,Objects 正确合并
//   - 同名键:soft 为底,eeprom 覆盖
//   - eeprom 独有的键保留
//   - soft 独有的键追加
TEST_F(ConnectorTest, MergeSoftData_MergesObjectsCorrectly)
{
    set_test_sr_dir("/tmp/connector_merge_basic");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
               R"({"FormatVersion":"3.0","Objects":{"chip1":{"name":"soft","type":"chip"},"chip3":{"addr":3}}})");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    std::string soft_path = test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr";
    mc::variant eeprom_payload(std::string(
        R"({"FormatVersion":"3.0","DataVersion":"1.0","Objects":{"chip1":{"addr":1},"chip2":{"addr":2}}})"));
    auto        merged = m_connector->i_connector.merge_soft_data(eeprom_payload, soft_path);

    ASSERT_TRUE(merged.has_value());
    auto d       = merged->as<mc::dict>();
    auto objects = d["Objects"].as<mc::dict>();

    // chip1: 同名键合并,soft 为底 eeprom 覆盖 → name 来自 soft,addr 来自 eeprom
    ASSERT_TRUE(objects.contains("chip1"));
    auto chip1 = objects["chip1"].as<mc::dict>();
    EXPECT_EQ(chip1["name"].as<std::string>(), "soft");
    EXPECT_EQ(chip1["type"].as<std::string>(), "chip");
    EXPECT_EQ(chip1["addr"].as<int>(), 1);

    // chip2: eeprom 独有,保留
    ASSERT_TRUE(objects.contains("chip2"));
    auto chip2 = objects["chip2"].as<mc::dict>();
    EXPECT_EQ(chip2["addr"].as<int>(), 2);

    // chip3: soft 独有,追加
    ASSERT_TRUE(objects.contains("chip3"));
    auto chip3 = objects["chip3"].as<mc::dict>();
    EXPECT_EQ(chip3["addr"].as<int>(), 3);
}

TEST_F(ConnectorTest, MergeSoftData_PreservesBaseSectionsAndMergesTopology)
{
    set_test_sr_dir("/tmp/connector_merge_topology");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr", R"({
        "FormatVersion":"3.0",
        "Unit":{"Name":"SOFT_UNIT"},
        "SoftOnly":{"value":1},
        "Objects":{"shared":{"soft":1},"soft_object":{"value":1}},
        "ManagementTopology":{
            "Anchor":{"Buses":["B","A"]},
            "Bus":{"Chips":["soft_chip"],"Connectors":["connector"],"SoftField":2},
            "SoftBus":{"Buses":["soft_bus"]}
        }
    })");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    mc::variant eeprom_payload(std::string(R"({
        "FormatVersion":"3.0",
        "DataVersion":"3.10",
        "Unit":{"Name":"EEPROM_UNIT"},
        "BaseOnly":{"value":1},
        "Objects":{"shared":{"eeprom":1},"eeprom_object":{"value":1}},
        "ManagementTopology":{
            "Anchor":{"Buses":["A"]},
            "Bus":{"Chips":["eeprom_chip"],"Buses":["base_bus"],"BaseField":1},
            "EepromBus":{"Buses":["eeprom_bus"]}
        }
    })"));
    auto        merged =
        m_connector->i_connector.merge_soft_data(eeprom_payload, test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr");

    ASSERT_TRUE(merged.has_value());
    auto data = merged->as<mc::dict>();
    EXPECT_EQ(data["Unit"].as<mc::dict>()["Name"].as<std::string>(), "EEPROM_UNIT");
    EXPECT_TRUE(data.contains("BaseOnly"));
    EXPECT_FALSE(data.contains("SoftOnly"));

    auto objects = data["Objects"].as<mc::dict>();
    EXPECT_TRUE(objects.contains("eeprom_object"));
    EXPECT_TRUE(objects.contains("soft_object"));
    auto shared = objects["shared"].as<mc::dict>();
    EXPECT_EQ(shared["eeprom"].as<int>(), 1);
    EXPECT_EQ(shared["soft"].as<int>(), 1);

    auto topology = data["ManagementTopology"].as<mc::dict>();
    EXPECT_TRUE(topology.contains("EepromBus"));
    EXPECT_TRUE(topology.contains("SoftBus"));
    EXPECT_EQ(topology["Anchor"].as<mc::dict>()["Buses"].as<std::vector<std::string>>(),
              (std::vector<std::string>{"A", "B"}));
    auto bus = topology["Bus"].as<mc::dict>();
    EXPECT_EQ(bus["Chips"].as<std::vector<std::string>>(), (std::vector<std::string>{"eeprom_chip", "soft_chip"}));
    EXPECT_EQ(bus["Buses"].as<std::vector<std::string>>(), (std::vector<std::string>{"base_bus"}));
    EXPECT_EQ(bus["Connectors"].as<std::vector<std::string>>(), (std::vector<std::string>{"connector"}));
    EXPECT_EQ(bus["BaseField"].as<int>(), 1);
    EXPECT_EQ(bus["SoftField"].as<int>(), 2);
}

TEST_F(ConnectorTest, MergeSoftData_KeepsBaseTopologyNodeWhenSoftNodeIsInvalid)
{
    set_test_sr_dir("/tmp/connector_merge_invalid_topology");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr", R"({
        "FormatVersion":"3.0",
        "Objects":{"soft_object":{"value":1}},
        "ManagementTopology":{"Bus":"invalid"}
    })");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    mc::variant base_payload(std::string(R"({
        "FormatVersion":"3.0",
        "Objects":{"base_object":{"value":1}},
        "ManagementTopology":{"Bus":{"Buses":["base_bus"]}}
    })"));
    auto        merged =
        m_connector->i_connector.merge_soft_data(base_payload, test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr");

    ASSERT_TRUE(merged.has_value());
    auto data    = merged->as<mc::dict>();
    auto objects = data["Objects"].as<mc::dict>();
    EXPECT_TRUE(objects.contains("base_object"));
    EXPECT_TRUE(objects.contains("soft_object"));
    EXPECT_EQ(data["ManagementTopology"].as<mc::dict>()["Bus"].as<mc::dict>()["Buses"].as<std::vector<std::string>>(),
              (std::vector<std::string>{"base_bus"}));
}

// 场景2:soft 文件不存在 → 返回 nullopt,原始 eeprom 数据不变
TEST_F(ConnectorTest, MergeSoftData_SoftFileNotFoundReturnsNullopt)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    mc::variant eeprom_payload(std::string(R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})"));
    auto        merged = m_connector->i_connector.merge_soft_data(eeprom_payload, "/nonexistent/soft.sr");

    EXPECT_FALSE(merged.has_value());
}

// 场景3:FormatVersion < 3.0 → 跳过合并
TEST_F(ConnectorTest, MergeSoftData_FormatVersionBelowRangeSkipsMerge)
{
    set_test_sr_dir("/tmp/connector_merge_low_version");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
               R"({"FormatVersion":"2.0","Objects":{"chip1":{"name":"soft"}}})");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    std::string soft_path = test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr";
    mc::variant eeprom_payload(std::string(R"({"FormatVersion":"2.0","Objects":{"chip1":{"addr":1}}})"));
    auto        merged = m_connector->i_connector.merge_soft_data(eeprom_payload, soft_path);

    EXPECT_FALSE(merged.has_value());
}

// 场景4:FormatVersion >= 5.0 → 跳过合并
TEST_F(ConnectorTest, MergeSoftData_FormatVersionAboveRangeSkipsMerge)
{
    set_test_sr_dir("/tmp/connector_merge_high_version");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
               R"({"FormatVersion":"5.0","Objects":{"chip1":{"name":"soft"}}})");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    std::string soft_path = test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr";
    mc::variant eeprom_payload(std::string(R"({"FormatVersion":"5.0","Objects":{"chip1":{"addr":1}}})"));
    auto        merged = m_connector->i_connector.merge_soft_data(eeprom_payload, soft_path);

    EXPECT_FALSE(merged.has_value());
}

// 场景5:eeprom 数据不含 FormatVersion → 跳过合并
TEST_F(ConnectorTest, MergeSoftData_NoFormatVersionSkipsMerge)
{
    set_test_sr_dir("/tmp/connector_merge_no_fmt_ver");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr", R"({"Objects":{"chip1":{"name":"soft"}}})");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    std::string soft_path = test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr";
    mc::variant eeprom_payload(std::string(R"({"Objects":{"chip1":{"addr":1}}})"));
    auto        merged = m_connector->i_connector.merge_soft_data(eeprom_payload, soft_path);

    EXPECT_FALSE(merged.has_value());
}

// 场景6:soft 文件不含 Objects → 跳过合并
TEST_F(ConnectorTest, MergeSoftData_SoftFileNoObjectsSkipsMerge)
{
    set_test_sr_dir("/tmp/connector_merge_no_objects");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr", R"({"FormatVersion":"3.0"})");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    std::string soft_path = test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr";
    mc::variant eeprom_payload(std::string(R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})"));
    auto        merged = m_connector->i_connector.merge_soft_data(eeprom_payload, soft_path);

    EXPECT_FALSE(merged.has_value());
}

// 场景7:soft 文件为无效 JSON → 跳过合并
TEST_F(ConnectorTest, MergeSoftData_InvalidSoftJsonReturnsNullopt)
{
    set_test_sr_dir("/tmp/connector_merge_invalid_json");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr", "{ invalid json }");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    std::string soft_path = test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr";
    mc::variant eeprom_payload(std::string(R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})"));
    auto        merged = m_connector->i_connector.merge_soft_data(eeprom_payload, soft_path);

    EXPECT_FALSE(merged.has_value());
}

// 场景8:eeprom payload 不含 Objects → 跳过合并
TEST_F(ConnectorTest, MergeSoftData_EepromNoObjectsSkipsMerge)
{
    set_test_sr_dir("/tmp/connector_merge_eeprom_no_obj");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
               R"({"FormatVersion":"3.0","Objects":{"chip1":{"name":"soft"}}})");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    std::string soft_path = test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr";
    mc::variant eeprom_payload(std::string(R"({"FormatVersion":"3.0"})"));
    auto        merged = m_connector->i_connector.merge_soft_data(eeprom_payload, soft_path);

    EXPECT_FALSE(merged.has_value());
}

// ========================= resolve_sr_data 集成测试:eeprom 合并流程 =========================

// 场景9:resolve_sr_data 中 eeprom 源触发 soft 合并,缓存已合并结果
TEST_F(ConnectorTest, ResolveSrData_EepromSourceMergesSoftDataAndCachesResult)
{
    set_test_sr_dir("/tmp/connector_resolve_merge");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
               R"({"FormatVersion":"3.0","Objects":{"chip1":{"name":"soft","type":"chip"},"chip3":{"addr":3}}})");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload =
        std::string(R"({"FormatVersion":"3.0","DataVersion":"1.0","Objects":{"chip1":{"addr":1},"chip2":{"addr":2}}})");
    m_mock_chip->csr1.uid          = "EEPROMUID";
    m_mock_chip->csr1.data_version = "3.10";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    // payload 应为合并后的 dict,包含 Objects
    auto d       = payload->as<mc::dict>();
    auto objects = d["Objects"].as<mc::dict>();

    EXPECT_EQ(objects["chip1"].as<mc::dict>()["name"].as<std::string>(), "soft");
    EXPECT_EQ(objects["chip1"].as<mc::dict>()["addr"].as<int>(), 1);
    EXPECT_TRUE(objects.contains("chip2")); // eeprom 独有
    EXPECT_TRUE(objects.contains("chip3")); // soft 独有

    // EEPROM header 版本必须在合并完成后覆盖最终 DataVersion。
    EXPECT_EQ(d["DataVersion"].as<std::string>(), "3.10");

    // 缓存应记录 source=eeprom,且 soft_source_path 不为空
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.valid);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
    EXPECT_FALSE(m_connector->i_connector.m_sr_cache.soft_source_path.empty());
}

// 场景10:csr_version 未标记 Merged 时,local 源也应与 soft 文件合并。
TEST_F(ConnectorTest, ResolveSrData_LocalSourceMergesWhenCsrVersionIsNotMerged)
{
    set_test_sr_dir("/tmp/connector_resolve_local_no_merge");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr",
               R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.10"); // local 版本新
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
               R"({"FormatVersion":"3.0","Objects":{"chip1":{"name":"soft"}}})");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = std::string(R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})");
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.09"; // eeprom 版本旧 → local 被选中

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    auto objects = payload->as<mc::dict>()["Objects"].as<mc::dict>();
    EXPECT_EQ(objects["chip1"].as<mc::dict>()["addr"].as<int>(), 1);
    EXPECT_EQ(objects["chip1"].as<mc::dict>()["name"].as<std::string>(), "soft");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
    EXPECT_FALSE(m_connector->i_connector.m_sr_cache.local_sr_merged);
    EXPECT_FALSE(m_connector->i_connector.m_sr_cache.soft_source_path.empty());
}

// csr_version 标记 Merged 时,local SR 已包含 soft 内容,不应重复合并。
TEST_F(ConnectorTest, ResolveSrData_LocalSourceSkipsMergeWhenCsrVersionIsMerged)
{
    set_test_sr_dir("/tmp/connector_resolve_local_merged");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr",
               R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})");
    write_file(test_sr_dir + "/csr_version.json",
               R"({"BOM12345_EEPROMUID_AUX789":{"DataVersion":"3.10","Merged":true}})");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
               R"({"FormatVersion":"3.0","Objects":{"chip1":{"name":"soft"}}})");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = std::string(R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})");
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.09";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    auto objects = payload->as<mc::dict>()["Objects"].as<mc::dict>();
    EXPECT_EQ(objects["chip1"].as<mc::dict>()["addr"].as<int>(), 1);
    EXPECT_FALSE(objects["chip1"].as<mc::dict>().contains("name"));
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::local);
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.local_sr_merged);
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.soft_source_path.empty());
}

// 场景11:resolve_sr_data 合并失败不影响 EEPROM 数据下发
TEST_F(ConnectorTest, ResolveSrData_MergeFailureStillReturnsEepromData)
{
    set_test_sr_dir("/tmp/connector_resolve_merge_fail");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");
    // 故意不创建 soft 文件 → merge 失败

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = std::string(R"({"FormatVersion":"3.0","Objects":{"chip1":{"addr":1}}})");
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);

    ASSERT_TRUE(payload.has_value());
    // Merge 失败时仍返回 EEPROM 数据,Objects 保留。
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.soft_source_path.empty());
}

// ========================= dump 与 soft 合并集成测试 =========================

// 场景12:合并后 dump 正确展示 soft_source_path 与合并后的有效版本
TEST_F(ConnectorTest, DumpShowsSoftSourcePathAfterMerge)
{
    set_test_sr_dir("/tmp/connector_dump_merge");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
               R"({"FormatVersion":"3.0","Objects":{"chip1":{"name":"soft"}}})");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload =
        std::string(R"({"FormatVersion":"3.0","DataVersion":"1.0","Objects":{"chip1":{"addr":1}}})");
    m_mock_chip->csr1.uid          = "EEPROMUID";
    m_mock_chip->csr1.data_version = "3.10";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(payload.has_value());

    auto dump_info = m_connector->i_connector.dump();
    EXPECT_NE(dump_info.soft_source_path, "NA");
    EXPECT_NE(dump_info.soft_source_path.find("_soft.sr"), std::string::npos);
}

// 场景13:未触发合并时 dump 中 soft_source_path 为 NA
TEST_F(ConnectorTest, DumpShowsNASoftSourcePathWithoutMerge)
{
    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    m_connector->i_connector.m_sr_cache.valid  = true;
    m_connector->i_connector.m_sr_cache.source = connector_sr_source::local;
    m_connector->i_connector.m_sr_cache.payload =
        mc::dict{{"FormatVersion", std::string("1.0")}, {"DataVersion", std::string("2.0")}};
    m_connector->i_connector.m_sr_cache.board_id           = "BOARD456";
    m_connector->i_connector.m_sr_cache.file_path          = "/opt/bmc/sr/test.sr";
    m_connector->i_connector.m_sr_cache.soft_source_path   = "";
    m_connector->i_connector.m_sr_cache.local_data_version = "2.0";

    auto dump_info = m_connector->i_connector.dump();
    EXPECT_EQ(dump_info.soft_source_path, "NA");
}

// 场景14:cleanup() 清空 soft_source_path
TEST_F(ConnectorTest, CleanupClearsSoftSourcePath)
{
    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    // 预置一个带 soft_source_path 的缓存
    m_connector->i_connector.m_sr_cache.valid              = true;
    m_connector->i_connector.m_sr_cache.source             = connector_sr_source::eeprom;
    m_connector->i_connector.m_sr_cache.payload            = mc::dict{{"Name", std::string("test")}};
    m_connector->i_connector.m_sr_cache.soft_source_path   = "/opt/bmc/sr/BOM_BOARD_soft.sr";
    m_connector->i_connector.m_sr_cache.selected_path      = "/data/opt/bmc/sr/gold/BOM_BOARD.sr";
    m_connector->i_connector.m_sr_cache.flash_data_version = "2.0";

    ASSERT_FALSE(m_connector->i_connector.m_sr_cache.soft_source_path.empty());

    m_connector->i_connector.cleanup();

    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.soft_source_path.empty());
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.selected_path.empty());
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.flash_data_version.empty());
    EXPECT_FALSE(m_connector->i_connector.m_sr_cache.valid);
}

// ========================= gold/temp overlay 选择 =========================

namespace {
constexpr const char* k_sr_v10      = R"({"Name":"LOCAL","DataVersion":"1.0"})";
constexpr const char* k_sr_v11      = R"({"Name":"LOCAL","DataVersion":"1.1"})";
constexpr const char* k_sr_v20_gold = R"({"Name":"GOLD","DataVersion":"2.0"})";
constexpr const char* k_sr_v20_temp = R"({"Name":"TEMP","DataVersion":"2.0"})";
constexpr const char* k_sr_v90_temp = R"({"Name":"TEMP","DataVersion":"9.0"})";
} // namespace

TEST_F(ConnectorTest, ResolveSrData_GoldSkipsTempWhenMd5Ok)
{
    set_test_sr_dir("/tmp/connector_sr_gold_skips_temp");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v10);
    write_csr_version("BOM12345_BOARD456_AUX789", "1.0");
    write_sr_with_md5(test_gold_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v20_gold);
    write_sr_with_md5(test_temp_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v90_temp);

    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(payload.has_value());
    EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "GOLD");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::gold);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.selected_path, test_gold_dir + "/BOM12345_BOARD456_AUX789.sr");
}

TEST_F(ConnectorTest, ResolveSrData_GoldMd5FailUsesTemp)
{
    set_test_sr_dir("/tmp/connector_sr_gold_md5_fail");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v11);
    write_csr_version("BOM12345_BOARD456_AUX789", "1.1");
    write_file(test_gold_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v10);
    write_file(test_gold_dir + "/BOM12345_BOARD456_AUX789.sr.md5", "ffffffffffffffffffffffffffffffff");
    write_sr_with_md5(test_temp_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v20_temp);

    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(payload.has_value());
    EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "TEMP");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::temp);
}

TEST_F(ConnectorTest, ResolveSrData_EqualVersionPrefersGoldOverEeprom)
{
    set_test_sr_dir("/tmp/connector_sr_gold_tie_eeprom");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", k_sr_v10);
    write_csr_version("BOM12345_EEPROMUID_AUX789", "2.0");
    write_sr_with_md5(test_gold_dir + "/BOM12345_EEPROMUID_AUX789.sr", k_sr_v20_gold);

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_SAME"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "2.0";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(payload.has_value());
    EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "GOLD");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::gold);
    EXPECT_EQ(m_mock_chip->csr1.csr1_call_count, 0);
}

TEST_F(ConnectorTest, ResolveSrData_EepromWinsWhenNewerThanGold)
{
    set_test_sr_dir("/tmp/connector_sr_eeprom_newer_than_gold");
    write_sr_with_md5(test_gold_dir + "/BOM12345_EEPROMUID_AUX789.sr", k_sr_v20_gold);
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", k_sr_v10);
    write_csr_version("BOM12345_EEPROMUID_AUX789", "1.0");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_NEWER"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(payload.has_value());
    EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "EEPROM_NEWER");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
}

TEST_F(ConnectorTest, ResolveSrData_UidRenameLooksUpGoldUnderNewBasename)
{
    set_test_sr_dir("/tmp/connector_sr_gold_uid_rename");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v10);
    write_csr_version("BOM12345_BOARD456_AUX789", "1.0");
    write_sr_with_md5(test_gold_dir + "/BOM12345_EEPROMUID_AUX789.sr", k_sr_v20_gold);

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_OLDER"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "1.0";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(payload.has_value());
    EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "GOLD");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::gold);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.selected_path, test_gold_dir + "/BOM12345_EEPROMUID_AUX789.sr");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.file_path, test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr");
}

TEST_F(ConnectorTest, ResolveSrData_EepromOnlyWhenGoldTempLocalAbsent)
{
    set_test_sr_dir("/tmp/connector_sr_eeprom_only_overlay");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload       = R"({"Name":"EEPROM_ONLY"})";
    m_mock_chip->csr1.uid           = "EEPROMUID";
    m_mock_chip->csr1.data_version  = "3.10";

    uint8_t err     = load_status::DEFAULT;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(payload.has_value());
    EXPECT_EQ(payload->as<mc::dict>()["Name"].as<std::string>(), "EEPROM_ONLY");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
    EXPECT_TRUE(m_connector->i_connector.m_sr_cache.selected_path.empty());
    EXPECT_EQ(err, load_status::DEFAULT);
}

TEST_F(ConnectorTest, ResolveSrData_GoldCacheHitAndDumpSourcePath)
{
    set_test_sr_dir("/tmp/connector_sr_gold_cache_dump");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v10);
    write_csr_version("BOM12345_BOARD456_AUX789", "1.0");
    write_sr_with_md5(test_gold_dir + "/BOM12345_BOARD456_AUX789.sr", k_sr_v20_gold);

    auto csr       = create_test_csr(1, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));

    uint8_t err   = 0;
    auto    first = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(first.has_value());
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::gold);

    auto second = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(second.has_value());
    EXPECT_EQ(second->as<mc::dict>()["Name"].as<std::string>(), "GOLD");

    m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);
    auto dump_info = m_connector->i_connector.dump();
    EXPECT_EQ(dump_info.data_source, "GOLD");
    EXPECT_EQ(dump_info.source_path, test_gold_dir + "/BOM12345_BOARD456_AUX789.sr");
}

TEST_F(ConnectorTest, ResolveSrData_SoftOverlayFromGoldAndDumpSoftPath)
{
    set_test_sr_dir("/tmp/connector_sr_gold_soft");
    write_file(test_sr_dir + "/BOM12345_EEPROMUID_AUX789.sr", R"({"Name":"LOCAL_OLDER"})");
    write_csr_version("BOM12345_EEPROMUID_AUX789", "3.09");
    write_sr_with_md5(test_gold_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr",
                      R"({"FormatVersion":"3.0","Objects":{"chip1":{"name":"gold_soft"}}})");

    auto csr       = create_test_csr(1, identify_mode::EEPROM);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_chip();

    m_mock_chip->csr2.throw_on_call = true;
    m_mock_chip->csr1.payload =
        std::string(R"({"FormatVersion":"3.0","DataVersion":"1.0","Objects":{"chip1":{"addr":1}}})");
    m_mock_chip->csr1.uid          = "EEPROMUID";
    m_mock_chip->csr1.data_version = "3.10";

    uint8_t err     = 0;
    auto    payload = m_connector->i_connector.resolve_sr_data(false, true, false, err);
    ASSERT_TRUE(payload.has_value());
    auto objects = payload->as<mc::dict>()["Objects"].as<mc::dict>();
    EXPECT_EQ(objects["chip1"].as<mc::dict>()["name"].as<std::string>(), "gold_soft");
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.source, connector_sr_source::eeprom);
    EXPECT_EQ(m_connector->i_connector.m_sr_cache.soft_source_path,
              test_gold_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr");

    m_connector->i_connector.LoadStatus.set_value(load_status::SUCCESS);
    auto dump_info = m_connector->i_connector.dump();
    EXPECT_EQ(dump_info.soft_source_path, test_gold_dir + "/BOM12345_EEPROMUID_AUX789_soft.sr");
}

// ---------------------------------------------------------------------------
// L0 边沿净化:claim_edge 以二元 m_prev_presence{0} CAS 把“事件流”净化成“真实翻转才发号”。
// 一个新建 Connector(SetUp 重置)prev=0 基线不在位。这些用例验证纯 CAS 语义(确定性)。
// ---------------------------------------------------------------------------

// 基线不在位:同值 0 无沿(不发卸动作);首次读到 1 才是 0→1 加载沿。
TEST_F(ConnectorTest, claim_edge_starts_from_baseline_absent)
{
    auto& conn = m_connector->i_connector;
    EXPECT_EQ(conn.m_prev_presence.load(), 0);
    EXPECT_FALSE(conn.claim_edge(0)) << "0 on baseline 0 is not an edge";
    EXPECT_TRUE(conn.claim_edge(1)) << "0->1 is a load edge";
    EXPECT_EQ(conn.m_prev_presence.load(), 1);
}

// 启动期双触发去重:信号回调与 check_initial_presence 都读到 1,只有第一次赢边沿。
TEST_F(ConnectorTest, prev_edge_dedups_startup_double)
{
    auto& conn = m_connector->i_connector;
    EXPECT_TRUE(conn.claim_edge(1)) << "first 0->1 wins the edge";
    EXPECT_FALSE(conn.claim_edge(1)) << "duplicate same-value trigger must be deduped";
    EXPECT_FALSE(conn.claim_edge(1)) << "repeated same value stays no-op";
}

// 快速 1→0→1 用事件值判沿:三个真实翻转各发一个边沿,不被合并(不靠现读终值)。
TEST_F(ConnectorTest, fast_1_0_1_emits_three_edges_not_coalesced)
{
    auto& conn = m_connector->i_connector;
    EXPECT_TRUE(conn.claim_edge(1)) << "insert edge (LOAD)";
    EXPECT_FALSE(conn.claim_edge(1)) << "redundant same-value write between real edges";
    EXPECT_TRUE(conn.claim_edge(0)) << "pull edge (UNLOAD)";
    EXPECT_TRUE(conn.claim_edge(1)) << "re-insert edge (LOAD), not coalesced with the first";
    EXPECT_EQ(conn.m_prev_presence.load(), 1);
}

// 重启/清理:force_release_load_guard 同处将 prev 归零,使在位设备能重新判为 0→1 加载沿。
TEST_F(ConnectorTest, restart_resets_prev_and_reloads_present)
{
    auto& conn = m_connector->i_connector;
    EXPECT_TRUE(conn.claim_edge(1));  // 在位,已记 prev=1
    EXPECT_FALSE(conn.claim_edge(1)); // 重启前同值无边沿

    conn.force_release_load_guard(); // 重启/清理兜底将 prev 归 0
    EXPECT_EQ(conn.m_prev_presence.load(), 0);
    EXPECT_TRUE(conn.claim_edge(1)) << "present device re-claims a 0->1 load edge after restart";
}

// 真并发:多线程同时抢同一 0→1 边沿,CAS 必须恰好放一个胜者(顺序用例证不到原子性)。
TEST_F(ConnectorTest, claim_edge_concurrent_same_value_yields_exactly_one_winner)
{
    auto&                    conn     = m_connector->i_connector;
    constexpr int            kThreads = 16;
    std::atomic<int>         winners{0};
    std::atomic<bool>        go{false};
    std::vector<std::thread> ts;
    ts.reserve(kThreads);
    for (int i = 0; i < kThreads; ++i) {
        ts.emplace_back([&conn, &winners, &go] {
            while (!go.load(std::memory_order_relaxed)) { // 自旋对齐起跑,最大化竞争窗口
            }
            if (conn.claim_edge(1)) {
                winners.fetch_add(1);
            }
        });
    }
    go.store(true, std::memory_order_release);
    for (auto& t : ts) {
        t.join();
    }
    EXPECT_EQ(winners.load(), 1) << "CAS must admit exactly one 0->1 winner under contention";
    EXPECT_EQ(conn.m_prev_presence.load(), 1);
}

// 长序列反复插拔:每一次真实翻转都发沿、连续同值不发沿,防边沿净化被误合并。
TEST_F(ConnectorTest, claim_edge_emits_every_real_flip_over_long_sequence)
{
    auto& conn = m_connector->i_connector;
    for (int k = 0; k < 8; ++k) {
        EXPECT_TRUE(conn.claim_edge(1)) << "insert flip #" << k;
        EXPECT_FALSE(conn.claim_edge(1)) << "duplicate insert #" << k;
        EXPECT_TRUE(conn.claim_edge(0)) << "pull flip #" << k;
        EXPECT_FALSE(conn.claim_edge(0)) << "duplicate pull #" << k;
    }
    EXPECT_EQ(conn.m_prev_presence.load(), 0);
}

// 接线级去重(本 PR 的真正回归点,不是纯 CAS 语义):Presence 信号回调(init_connector_signal)与
// check_initial_presence 两条路都接了共享的 claim_edge,同一个 0→1 在位沿只应起一条加载链。
// 先经信号回调加载成功(prev 抬到 1),再手动跑初始检查读到同一 1 → claim_edge(1) 无边沿 → 跳过,
// 不得再下发第二条 AddDeviceWithData。
TEST_F(ConnectorTest, PresenceSignalAndInitialCheckDedupToSingleLoad)
{
    set_test_sr_dir("/tmp/connector_wiring_dedup");
    write_file(test_sr_dir + "/BOM12345_BOARD456_AUX789.sr", R"({"Name":"WIRING_DEDUP"})");
    write_csr_version("BOM12345_BOARD456_AUX789", "3.10");

    auto csr       = create_test_csr(0, 0);
    auto connector = create_test_connector();
    ASSERT_TRUE(m_connector->init(csr, connector));
    install_mock_devmon();

    // 路 1:Presence 信号回调 0→1 抢占边沿并起链,加载成功。
    EXPECT_NO_THROW(m_connector->i_connector.Presence.set_value(1));
    ASSERT_TRUE(wait_for_load_status(load_status::SUCCESS));
    ASSERT_EQ(m_mock_devmon->devmon.add_device_call_count, 1);
    EXPECT_EQ(m_connector->i_connector.m_prev_presence.load(), 1);

    // 路 2:check_initial_presence 再读到同一 1 → claim_edge(1) 无边沿 → 早退,不再起第二条链。
    EXPECT_NO_THROW(m_connector->i_connector.check_initial_presence());
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
    EXPECT_EQ(m_mock_devmon->devmon.add_device_call_count, 1)
        << "initial check must not start a second load chain for an already-claimed 0->1 edge";
    EXPECT_EQ(m_connector->i_connector.m_prev_presence.load(), 1);
}

} // namespace test
} // namespace connector
} // namespace drivers

MC_REFLECT(drivers::connector::test::mock_self_description_record,
           (FormatVersion)(DataVersion)(BoardId)((GetSRData, "GetSRData")))
MC_REFLECT(drivers::connector::test::mock_eeprom_data,
           (DataVersion)((GetSRData, "GetSRData"))((GetEepromHeader, "GetEepromHeader")))
MC_REFLECT(drivers::connector::test::mock_eeprom_chip,
           ((csr2, "bmc.dev.Chip.SelfDescriptionRecord"))((csr1, "bmc.kepler.EepromData")))
MC_REFLECT(drivers::connector::test::mock_devmon_interface,
           ((AddDeviceWithData, "AddDeviceWithData"))((RemoveDevice, "RemoveDevice")))
MC_REFLECT(drivers::connector::test::mock_devmon_object, ((devmon, "bmc.dev")))