* Copyright (c) 2026 Huawei Technologies Co., Ltd.
* openUBMC is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* http://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include <gtest/gtest.h>
#include <internal/bus/bus_base/bus.h>
#include <internal/chip/chip_ina/ina.h>
#include <mc/dict.h>
#include <mc/exception.h>
#include <deque>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
namespace {
class ina_test_bus : public dev::bus_base {
public:
ina_test_bus() = default;
~ina_test_bus() override = default;
uint32_t read(ACCESS_DATA_S& input) override
{
++m_read_call_count;
m_last_access = input;
if (m_throw_on_read) {
throw std::runtime_error(m_exception_message);
}
if (!m_read_payloads.empty()) {
input.out_buffer = m_read_payloads.front();
m_read_payloads.pop_front();
} else {
input.out_buffer.clear();
}
return m_read_result;
}
uint32_t write(ACCESS_DATA_S& input) override
{
++m_write_call_count;
m_last_access = input;
m_last_write_buffer = input.in_buffer;
if (m_throw_on_write) {
throw std::runtime_error(m_exception_message);
}
return m_write_result;
}
uint8_t get_id() override
{
return m_id;
}
void bus_lock() override
{}
void bus_unlock() override
{}
void set_id(uint8_t id)
{
m_id = id;
}
void enqueue_read_payload(std::vector<uint8_t> payload)
{
m_read_payloads.emplace_back(std::move(payload));
}
void set_read_result(int32_t result)
{
m_read_result = result;
}
void set_write_result(int32_t result)
{
m_write_result = result;
}
void set_throw_on_read(bool enabled, std::string message = "mock read exception")
{
m_throw_on_read = enabled;
m_exception_message = std::move(message);
}
void set_throw_on_write(bool enabled, std::string message = "mock write exception")
{
m_throw_on_write = enabled;
m_exception_message = std::move(message);
}
int read_call_count() const
{
return m_read_call_count;
}
int write_call_count() const
{
return m_write_call_count;
}
const ACCESS_DATA_S& last_access() const
{
return m_last_access;
}
const std::vector<uint8_t>& last_write_buffer() const
{
return m_last_write_buffer;
}
void clear_records()
{
m_read_call_count = 0;
m_write_call_count = 0;
m_last_write_buffer.clear();
}
private:
uint8_t m_id = 0;
std::deque<std::vector<uint8_t>> m_read_payloads;
int32_t m_read_result = HAS_OK;
int32_t m_write_result = HAS_OK;
bool m_throw_on_read = false;
bool m_throw_on_write = false;
std::string m_exception_message = "mock exception";
int m_read_call_count = 0;
int m_write_call_count = 0;
ACCESS_DATA_S m_last_access = {};
std::vector<uint8_t> m_last_write_buffer;
};
class chip_ina_test : public ::testing::Test {
protected:
void SetUp() override
{
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["object_name"] = std::string("ina_test");
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina226");
ASSERT_TRUE(m_chip.init(csr));
}
std::shared_ptr<ina_test_bus> bind_test_bus()
{
auto bus = std::make_shared<ina_test_bus>();
m_chip.set_left_bus(bus);
m_chip.set_host_bus(bus);
return bus;
}
dev::chip_ina m_chip;
};
TEST_F(chip_ina_test, init_success_with_required_fields)
{
dev::chip_ina chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina226");
EXPECT_TRUE(chip.init(csr));
}
TEST_F(chip_ina_test, init_success_with_config_register_at_por_default)
{
dev::chip_ina chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x7FF);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina226");
ASSERT_TRUE(chip.init(csr));
auto bus = std::make_shared<ina_test_bus>();
chip.set_left_bus(bus);
chip.set_host_bus(bus);
bus->set_read_result(HAS_OK);
bus->set_write_result(HAS_OK);
bus->enqueue_read_payload({0x12, 0x34});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip.bit_read(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_EQ(bus->write_call_count(), 2);
}
TEST_F(chip_ina_test, init_fails_without_configuration_register)
{
dev::chip_ina chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina226");
EXPECT_FALSE(chip.init(csr));
}
TEST_F(chip_ina_test, init_fails_without_calibration_register)
{
dev::chip_ina chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["ChipModel"] = std::string("Ina226");
EXPECT_FALSE(chip.init(csr));
}
TEST_F(chip_ina_test, init_fails_without_chip_model)
{
dev::chip_ina chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
EXPECT_FALSE(chip.init(csr));
}
TEST_F(chip_ina_test, init_with_ina220_model)
{
dev::chip_ina chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina220");
EXPECT_TRUE(chip.init(csr));
}
TEST_F(chip_ina_test, init_with_ina238_model)
{
dev::chip_ina chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina238");
EXPECT_TRUE(chip.init(csr));
}
TEST_F(chip_ina_test, bit_read_success_with_length_2)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->set_write_result(HAS_OK);
bus->enqueue_read_payload({0x12, 0x34});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_read(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(error.empty());
EXPECT_EQ(out_buffer.size(), 2u);
}
TEST_F(chip_ina_test, bit_read_exceeds_max_length_for_ina226)
{
auto bus = bind_test_bus();
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_read(0x01, 3, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_ina_test, bit_read_with_ina238_max_length_3_fails)
{
dev::chip_ina chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina238");
ASSERT_TRUE(chip.init(csr));
auto bus = std::make_shared<ina_test_bus>();
chip.set_left_bus(bus);
chip.set_host_bus(bus);
bus->set_read_result(HAS_OK);
bus->set_write_result(HAS_OK);
bus->enqueue_read_payload({0x01, 0x02, 0x03});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip.bit_read(0x01, 3, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_ina_test, bit_read_with_ina220_max_length_2)
{
dev::chip_ina chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina220");
ASSERT_TRUE(chip.init(csr));
auto bus = std::make_shared<ina_test_bus>();
chip.set_left_bus(bus);
chip.set_host_bus(bus);
bus->set_read_result(HAS_OK);
bus->set_write_result(HAS_OK);
bus->enqueue_read_payload({0x12, 0x34});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip.bit_read(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_EQ(out_buffer.size(), 2u);
}
TEST_F(chip_ina_test, bit_read_handles_bus_failure)
{
auto bus = bind_test_bus();
bus->set_write_result(HAS_OK);
bus->set_read_result(HAS_ERR);
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_read(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_ina_test, bit_read_returns_error_when_bus_is_missing)
{
dev::chip_ina chip_without_bus;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina226");
ASSERT_TRUE(chip_without_bus.init(csr));
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip_without_bus.bit_read(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_ina_test, bit_read_handles_bus_exception)
{
auto bus = bind_test_bus();
bus->set_throw_on_read(true, "forced failure");
bus->set_write_result(HAS_OK);
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_read(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_ina_test, bit_write_success)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->set_write_result(HAS_OK);
std::vector<uint8_t> in_buffer = {0x12, 0x34};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_write(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(error.empty());
}
TEST_F(chip_ina_test, bit_write_buffer_size_too_small)
{
auto bus = bind_test_bus();
std::vector<uint8_t> in_buffer = {0x12};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_write(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_ina_test, bit_write_exceeds_max_length)
{
auto bus = bind_test_bus();
std::vector<uint8_t> in_buffer = {0x01, 0x02, 0x03};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_write(0x01, 3, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_ina_test, bit_write_handles_bus_failure)
{
auto bus = bind_test_bus();
bus->set_write_result(HAS_ERR);
std::vector<uint8_t> in_buffer = {0x12, 0x34};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_write(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_ina_test, bit_write_handles_bus_exception)
{
auto bus = bind_test_bus();
bus->set_throw_on_write(true, "forced failure");
bus->set_read_result(HAS_OK);
std::vector<uint8_t> in_buffer = {0x12, 0x34};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_write(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_ina_test, bit_write_returns_error_when_bus_is_missing)
{
dev::chip_ina chip_without_bus;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina226");
ASSERT_TRUE(chip_without_bus.init(csr));
std::vector<uint8_t> in_buffer = {0x12, 0x34};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip_without_bus.bit_write(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_ina_test, block_read_success)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->set_write_result(HAS_OK);
bus->enqueue_read_payload({0x12, 0x34});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.block_read(0x01, 2, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(error.empty());
}
TEST_F(chip_ina_test, block_read_exceeds_max_length)
{
auto bus = bind_test_bus();
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.block_read(0x01, 3, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_ina_test, block_read_handles_bus_failure)
{
auto bus = bind_test_bus();
bus->set_write_result(HAS_OK);
bus->set_read_result(HAS_ERR);
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.block_read(0x01, 2, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_ina_test, block_read_handles_bus_exception)
{
auto bus = bind_test_bus();
bus->set_throw_on_read(true, "forced failure");
bus->set_write_result(HAS_OK);
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.block_read(0x01, 2, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_ina_test, block_read_returns_error_when_bus_is_missing)
{
dev::chip_ina chip_without_bus;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina226");
ASSERT_TRUE(chip_without_bus.init(csr));
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip_without_bus.block_read(0x01, 2, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_ina_test, block_read_with_ina238)
{
dev::chip_ina chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina238");
ASSERT_TRUE(chip.init(csr));
auto bus = std::make_shared<ina_test_bus>();
chip.set_left_bus(bus);
chip.set_host_bus(bus);
bus->set_read_result(HAS_OK);
bus->set_write_result(HAS_OK);
bus->enqueue_read_payload({0x12, 0x34});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip.block_read(0x01, 2, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
}
TEST_F(chip_ina_test, block_write_success)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->set_write_result(HAS_OK);
std::vector<uint8_t> in_buffer = {0x12, 0x34};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.block_write(0x01, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(error.empty());
}
TEST_F(chip_ina_test, block_write_exceeds_max_length)
{
auto bus = bind_test_bus();
std::vector<uint8_t> in_buffer = {0x01, 0x02, 0x03};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.block_write(0x01, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_ina_test, block_write_handles_bus_failure)
{
auto bus = bind_test_bus();
bus->set_write_result(HAS_ERR);
std::vector<uint8_t> in_buffer = {0x12, 0x34};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.block_write(0x01, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_ina_test, block_write_handles_bus_exception)
{
auto bus = bind_test_bus();
bus->set_throw_on_write(true, "forced failure");
bus->set_read_result(HAS_OK);
std::vector<uint8_t> in_buffer = {0x12, 0x34};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.block_write(0x01, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_ina_test, block_write_returns_error_when_bus_is_missing)
{
dev::chip_ina chip_without_bus;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina226");
ASSERT_TRUE(chip_without_bus.init(csr));
std::vector<uint8_t> in_buffer = {0x12, 0x34};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip_without_bus.block_write(0x01, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_ina_test, chip_config_writes_config_and_calibration_registers)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->set_write_result(HAS_OK);
bus->enqueue_read_payload({0x12, 0x34});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_read(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_EQ(bus->write_call_count(), 2);
}
TEST_F(chip_ina_test, chip_config_fails_on_write_failure)
{
auto bus = bind_test_bus();
bus->set_write_result(HAS_ERR);
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_read(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_ina_test, chip_config_calibration_write_failure)
{
}
TEST_F(chip_ina_test, bit_write_failure_after_config_success)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->set_write_result(HAS_OK);
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
bus->enqueue_read_payload({0x12, 0x34});
int32_t ret = m_chip.bit_read(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
bus->set_write_result(HAS_ERR);
std::vector<uint8_t> write_buffer = {0xAA, 0xBB};
ret = m_chip.bit_write(0x02, 2, 0xFFFF, write_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_ina_test, bit_read_length_1_success)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->set_write_result(HAS_OK);
bus->enqueue_read_payload({0x12});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_read(0x01, 1, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_EQ(out_buffer.size(), 1u);
}
TEST_F(chip_ina_test, block_write_with_ina238)
{
dev::chip_ina chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x40);
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina238");
ASSERT_TRUE(chip.init(csr));
auto bus = std::make_shared<ina_test_bus>();
chip.set_left_bus(bus);
chip.set_host_bus(bus);
bus->set_read_result(HAS_OK);
bus->set_write_result(HAS_OK);
std::vector<uint8_t> in_buffer = {0x12, 0x34};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip.block_write(0x01, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
}
TEST_F(chip_ina_test, init_with_invalid_type_field)
{
dev::chip_ina chip;
mc::mutable_dict csr;
csr["Address"] = std::string("invalid");
csr["ConfigurationRegister"] = static_cast<uint16_t>(0x4127);
csr["CalibrationRegister"] = static_cast<uint16_t>(0x1000);
csr["ChipModel"] = std::string("Ina226");
EXPECT_FALSE(chip.init(csr));
}
TEST_F(chip_ina_test, multiple_read_operations)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->set_write_result(HAS_OK);
bus->enqueue_read_payload({0x12, 0x34});
bus->enqueue_read_payload({0x56, 0x78});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret1 = m_chip.bit_read(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret1, HAS_OK);
int32_t ret2 = m_chip.bit_read(0x02, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret2, HAS_OK);
}
TEST_F(chip_ina_test, mixed_read_write_operations)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->set_write_result(HAS_OK);
bus->enqueue_read_payload({0x12, 0x34});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret1 = m_chip.bit_read(0x01, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret1, HAS_OK);
std::vector<uint8_t> write_buffer = {0xAA, 0xBB};
int32_t ret2 = m_chip.bit_write(0x02, 2, 0xFFFF, write_buffer, out_buffer, error);
EXPECT_EQ(ret2, HAS_OK);
}
}