* 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_lm75/lm75.h>
#include <mc/dict.h>
#include <mc/exception.h>
#include <cstring>
#include <deque>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
namespace {
class lm75_test_bus : public dev::bus_base {
public:
lm75_test_bus() = default;
~lm75_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(uint32_t result)
{
m_read_result = result;
}
void set_write_result(uint32_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;
uint32_t m_read_result = 0;
uint32_t m_write_result = 0;
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_lm75_test : public ::testing::Test {
protected:
void SetUp() override
{
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["object_name"] = std::string("lm75_test");
ASSERT_TRUE(m_chip.init(csr));
}
std::shared_ptr<lm75_test_bus> bind_test_bus()
{
auto bus = std::make_shared<lm75_test_bus>();
m_chip.set_left_bus(bus);
m_chip.set_host_bus(bus);
return bus;
}
dev::chip_lm75 m_chip;
};
TEST_F(chip_lm75_test, init_success_with_default_limitations)
{
dev::chip_lm75 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
EXPECT_TRUE(chip.init(csr));
}
TEST_F(chip_lm75_test, init_success_with_custom_limitations)
{
dev::chip_lm75 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["HighTempLimitation"] = static_cast<uint16_t>(0x5000);
csr["LowTempLimitation"] = static_cast<uint16_t>(0x1000);
EXPECT_TRUE(chip.init(csr));
}
TEST_F(chip_lm75_test, init_success_with_only_high_limitation)
{
dev::chip_lm75 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["HighTempLimitation"] = static_cast<uint16_t>(0x5000);
EXPECT_TRUE(chip.init(csr));
}
TEST_F(chip_lm75_test, init_success_with_only_low_limitation)
{
dev::chip_lm75 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["LowTempLimitation"] = static_cast<uint16_t>(0x1000);
EXPECT_TRUE(chip.init(csr));
}
TEST_F(chip_lm75_test, init_fails_with_invalid_limitation_type)
{
dev::chip_lm75 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["HighTempLimitation"] = std::string("invalid");
EXPECT_FALSE(chip.init(csr));
}
TEST_F(chip_lm75_test, chip_init_success_with_default_limitations)
{
auto bus = bind_test_bus();
bus->set_write_result(0);
bus->set_read_result(0);
int32_t ret = m_chip.chip_init();
EXPECT_EQ(ret, HAS_OK);
}
TEST_F(chip_lm75_test, bit_read_with_high_limitation_config)
{
dev::chip_lm75 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["object_name"] = std::string("lm75_high_limit_test");
csr["HighTempLimitation"] = static_cast<uint16_t>(0x5000);
ASSERT_TRUE(chip.init(csr));
auto bus = std::make_shared<lm75_test_bus>();
chip.set_left_bus(bus);
chip.set_host_bus(bus);
bus->set_write_result(0);
bus->set_read_result(0);
bus->enqueue_read_payload({0x00, 0x50});
bus->enqueue_read_payload({0x19, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip.bit_read(0, 2, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_GE(bus->write_call_count(), 1);
EXPECT_GE(bus->read_call_count(), 1);
}
TEST_F(chip_lm75_test, bit_read_with_low_limitation_config)
{
dev::chip_lm75 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["object_name"] = std::string("lm75_low_limit_test");
csr["LowTempLimitation"] = static_cast<uint16_t>(0x1000);
ASSERT_TRUE(chip.init(csr));
auto bus = std::make_shared<lm75_test_bus>();
chip.set_left_bus(bus);
chip.set_host_bus(bus);
bus->set_write_result(0);
bus->set_read_result(0);
bus->enqueue_read_payload({0x00, 0x10});
bus->enqueue_read_payload({0x19, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip.bit_read(0, 2, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
}
TEST_F(chip_lm75_test, bit_read_with_both_limitations_config)
{
dev::chip_lm75 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["object_name"] = std::string("lm75_both_limit_test");
csr["HighTempLimitation"] = static_cast<uint16_t>(0x5000);
csr["LowTempLimitation"] = static_cast<uint16_t>(0x1000);
ASSERT_TRUE(chip.init(csr));
auto bus = std::make_shared<lm75_test_bus>();
chip.set_left_bus(bus);
chip.set_host_bus(bus);
bus->set_write_result(0);
bus->set_read_result(0);
bus->enqueue_read_payload({0x00, 0x50});
bus->enqueue_read_payload({0x00, 0x10});
bus->enqueue_read_payload({0x19, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip.bit_read(0, 2, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
}
TEST_F(chip_lm75_test, high_limitation_write_failure)
{
dev::chip_lm75 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["object_name"] = std::string("lm75_write_fail_test");
csr["HighTempLimitation"] = static_cast<uint16_t>(0x5000);
ASSERT_TRUE(chip.init(csr));
auto bus = std::make_shared<lm75_test_bus>();
chip.set_left_bus(bus);
chip.set_host_bus(bus);
bus->set_write_result(static_cast<uint32_t>(-1));
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip.bit_read(0, 2, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_lm75_test, high_limitation_read_failure)
{
dev::chip_lm75 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["object_name"] = std::string("lm75_read_fail_test");
csr["HighTempLimitation"] = static_cast<uint16_t>(0x5000);
ASSERT_TRUE(chip.init(csr));
auto bus = std::make_shared<lm75_test_bus>();
chip.set_left_bus(bus);
chip.set_host_bus(bus);
bus->set_write_result(0);
bus->set_read_result(static_cast<uint32_t>(-1));
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip.bit_read(0, 2, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_lm75_test, high_limitation_readback_mismatch)
{
dev::chip_lm75 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["object_name"] = std::string("lm75_mismatch_test");
csr["HighTempLimitation"] = static_cast<uint16_t>(0x5000);
ASSERT_TRUE(chip.init(csr));
auto bus = std::make_shared<lm75_test_bus>();
chip.set_left_bus(bus);
chip.set_host_bus(bus);
bus->set_write_result(0);
bus->set_read_result(0);
bus->enqueue_read_payload({0xAA, 0xBB});
bus->enqueue_read_payload({0x19, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip.bit_read(0, 2, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
}
TEST_F(chip_lm75_test, low_limitation_write_failure)
{
dev::chip_lm75 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["object_name"] = std::string("lm75_low_write_fail_test");
csr["LowTempLimitation"] = static_cast<uint16_t>(0x1000);
ASSERT_TRUE(chip.init(csr));
auto bus = std::make_shared<lm75_test_bus>();
chip.set_left_bus(bus);
chip.set_host_bus(bus);
bus->set_write_result(static_cast<uint32_t>(-1));
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip.bit_read(0, 2, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_lm75_test, low_limitation_read_failure)
{
dev::chip_lm75 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["object_name"] = std::string("lm75_low_read_fail_test");
csr["LowTempLimitation"] = static_cast<uint16_t>(0x1000);
ASSERT_TRUE(chip.init(csr));
auto bus = std::make_shared<lm75_test_bus>();
chip.set_left_bus(bus);
chip.set_host_bus(bus);
bus->set_write_result(0);
bus->set_read_result(static_cast<uint32_t>(-1));
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip.bit_read(0, 2, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_lm75_test, low_limitation_readback_mismatch)
{
dev::chip_lm75 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["object_name"] = std::string("lm75_low_mismatch_test");
csr["LowTempLimitation"] = static_cast<uint16_t>(0x1000);
ASSERT_TRUE(chip.init(csr));
auto bus = std::make_shared<lm75_test_bus>();
chip.set_left_bus(bus);
chip.set_host_bus(bus);
bus->set_write_result(0);
bus->set_read_result(0);
bus->enqueue_read_payload({0xAA, 0xBB});
bus->enqueue_read_payload({0x19, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = chip.bit_read(0, 2, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
}
TEST_F(chip_lm75_test, chip_test_success)
{
auto bus = bind_test_bus();
bus->set_write_result(0);
bus->set_read_result(0);
bus->enqueue_read_payload({0x55, 0x00});
uint32_t result = 0;
int32_t ret = m_chip.chip_test(&result);
EXPECT_EQ(ret, HAS_OK);
EXPECT_EQ(result, 1);
EXPECT_EQ(bus->write_call_count(), 1);
EXPECT_EQ(bus->read_call_count(), 1);
}
TEST_F(chip_lm75_test, chip_test_write_failed)
{
auto bus = bind_test_bus();
bus->set_write_result(static_cast<uint32_t>(-1));
uint32_t result = 0;
int32_t ret = m_chip.chip_test(&result);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_lm75_test, chip_test_read_failed)
{
auto bus = bind_test_bus();
bus->set_write_result(0);
bus->set_read_result(static_cast<uint32_t>(-1));
uint32_t result = 0;
int32_t ret = m_chip.chip_test(&result);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_lm75_test, chip_test_data_mismatch)
{
auto bus = bind_test_bus();
bus->set_write_result(0);
bus->set_read_result(0);
bus->enqueue_read_payload({0xAA, 0x00});
uint32_t result = 0;
int32_t ret = m_chip.chip_test(&result);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_lm75_test, chip_test_uses_correct_register_offset)
{
auto bus = bind_test_bus();
bus->set_write_result(0);
bus->set_read_result(0);
bus->enqueue_read_payload({0x55, 0x00});
uint32_t result = 0;
m_chip.chip_test(&result);
EXPECT_EQ(bus->last_access().offset, 2u);
}
TEST_F(chip_lm75_test, chip_test_throws_exception)
{
auto bus = bind_test_bus();
bus->set_throw_on_write(true, "forced exception");
uint32_t result = 0;
int32_t ret = m_chip.chip_test(&result);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_lm75_test, bit_read_temperature_register_length_1)
{
auto bus = bind_test_bus();
bus->set_read_result(0);
bus->enqueue_read_payload({0x19, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_read(0, 1, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_EQ(out_buffer.size(), 1u);
EXPECT_EQ(out_buffer[0], 0x19);
}
TEST_F(chip_lm75_test, bit_read_temperature_register_length_2)
{
auto bus = bind_test_bus();
bus->set_read_result(0);
bus->enqueue_read_payload({0x19, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_read(0, 2, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_EQ(out_buffer.size(), 2u);
EXPECT_EQ(out_buffer[0], 0x19);
EXPECT_EQ(out_buffer[1], 0x00);
}
TEST_F(chip_lm75_test, bit_read_other_register)
{
auto bus = bind_test_bus();
bus->set_read_result(0);
bus->enqueue_read_payload({0x55, 0xAA});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.bit_read(2, 2, 0xFFFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
}
TEST_F(chip_lm75_test, bit_read_invalid_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.bit_read(0, 3, 0xFF, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_lm75_test, bit_read_throws_when_bus_is_missing)
{
dev::chip_lm75 chip_without_bus;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
ASSERT_TRUE(chip_without_bus.init(csr));
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_THROW(chip_without_bus.bit_read(0, 2, 0xFF, in_buffer, out_buffer, error), mc::invalid_op_exception);
}
TEST_F(chip_lm75_test, block_read_success_length_2)
{
auto bus = bind_test_bus();
bus->set_read_result(0);
bus->enqueue_read_payload({0x19, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.block_read(0, 2, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(error.empty());
}
TEST_F(chip_lm75_test, block_read_success_length_1)
{
auto bus = bind_test_bus();
bus->set_read_result(0);
bus->enqueue_read_payload({0x19});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.block_read(0, 1, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(error.empty());
}
TEST_F(chip_lm75_test, block_read_invalid_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(0, 3, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_lm75_test, block_read_throws_when_bus_is_missing)
{
dev::chip_lm75 chip_without_bus;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
ASSERT_TRUE(chip_without_bus.init(csr));
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_THROW(chip_without_bus.block_read(0, 2, in_buffer, out_buffer, error), mc::invalid_op_exception);
}
TEST_F(chip_lm75_test, block_write_success)
{
auto bus = bind_test_bus();
bus->set_write_result(0);
std::vector<uint8_t> in_buffer = {0x55, 0x00};
std::vector<uint8_t> out_buffer;
std::string error;
int32_t ret = m_chip.block_write(2, in_buffer, out_buffer, error);
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(error.empty());
}
TEST_F(chip_lm75_test, block_write_throws_when_bus_is_missing)
{
dev::chip_lm75 chip_without_bus;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
ASSERT_TRUE(chip_without_bus.init(csr));
std::vector<uint8_t> in_buffer = {0x55, 0x00};
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_THROW(chip_without_bus.block_write(2, in_buffer, out_buffer, error), mc::invalid_op_exception);
}
}