* 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_ads78/ads78.h>
#include <mc/dict.h>
#include <mc/exception.h>
#include <cstring>
#include <deque>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>
namespace {
class ads78_test_bus : public dev::bus_base {
public:
ads78_test_bus() = default;
~ads78_test_bus() override = default;
uint32_t read(ACCESS_DATA_S& input) override
{
++m_read_call_count;
if (m_throw_on_read) {
throw std::runtime_error(m_exception_message);
}
m_last_access = input;
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;
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);
}
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;
}
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;
std::string m_exception_message = "mock read exception";
int m_read_call_count = 0;
int m_write_call_count = 0;
ACCESS_DATA_S m_last_access = {};
};
class chip_ads78_test : public ::testing::Test {
protected:
void SetUp() override
{
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x50);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["object_name"] = std::string("ads78_test");
ASSERT_TRUE(m_chip.init(csr));
}
std::shared_ptr<ads78_test_bus> bind_test_bus()
{
auto bus = std::make_shared<ads78_test_bus>();
m_chip.set_left_bus(bus);
m_chip.set_host_bus(bus);
return bus;
}
dev::chip_ads78 m_chip;
};
TEST_F(chip_ads78_test, init_success_with_minimal_config)
{
dev::chip_ads78 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
EXPECT_TRUE(chip.init(csr));
}
TEST_F(chip_ads78_test, init_success_with_full_config)
{
dev::chip_ads78 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x50);
csr["OffsetWidth"] = static_cast<uint8_t>(1);
csr["AddrWidth"] = static_cast<uint8_t>(1);
csr["WriteTmout"] = static_cast<uint32_t>(100);
csr["ReadTmout"] = static_cast<uint32_t>(100);
csr["object_name"] = std::string("ads78_full_test");
EXPECT_TRUE(chip.init(csr));
}
TEST_F(chip_ads78_test, bit_read_channel_0_success)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x08, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(bus->last_access().offset, 0x84U);
}
TEST_F(chip_ads78_test, bit_read_channel_1_success)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x08, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(1, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(bus->last_access().offset, 0xC4U);
}
TEST_F(chip_ads78_test, bit_read_channel_2_success)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x08, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(2, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(bus->last_access().offset, 0x94U);
}
TEST_F(chip_ads78_test, bit_read_channel_3_success)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x08, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(3, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(bus->last_access().offset, 0xD4U);
}
TEST_F(chip_ads78_test, bit_read_channel_4_success)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x08, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(4, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(bus->last_access().offset, 0xA4U);
}
TEST_F(chip_ads78_test, bit_read_channel_5_success)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x08, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(5, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(bus->last_access().offset, 0xE4U);
}
TEST_F(chip_ads78_test, bit_read_channel_6_success)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x08, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(6, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(bus->last_access().offset, 0xB4U);
}
TEST_F(chip_ads78_test, bit_read_channel_7_success)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x08, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(7, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(bus->last_access().offset, 0xF4U);
}
TEST_F(chip_ads78_test, bit_read_converts_zero_adc_value)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x00, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(out_buffer[0], 0);
EXPECT_EQ(out_buffer[1], 0);
}
TEST_F(chip_ads78_test, bit_read_converts_max_adc_value)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x0F, 0xFF});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(out_buffer[0], 0xC3);
EXPECT_EQ(out_buffer[1], 0x09);
}
TEST_F(chip_ads78_test, bit_read_converts_mid_scale_adc_value)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x08, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(out_buffer[0], 0xE2);
EXPECT_EQ(out_buffer[1], 0x04);
}
TEST_F(chip_ads78_test, bit_read_throws_when_bus_is_missing)
{
dev::chip_ads78 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, 0, in_buffer, out_buffer, error), mc::invalid_op_exception);
}
TEST_F(chip_ads78_test, bit_read_returns_error_for_invalid_channel_8)
{
auto bus = bind_test_bus();
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(8, 2, 0, in_buffer, out_buffer, error), HAS_ERR);
EXPECT_NE(error.find("invalid channel"), std::string::npos);
EXPECT_EQ(bus->read_call_count(), 0);
}
TEST_F(chip_ads78_test, bit_read_returns_error_for_invalid_channel_100)
{
auto bus = bind_test_bus();
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(100, 2, 0, in_buffer, out_buffer, error), HAS_ERR);
EXPECT_FALSE(error.empty());
EXPECT_EQ(bus->read_call_count(), 0);
}
TEST_F(chip_ads78_test, bit_read_returns_error_when_bus_read_fails)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_ERR);
bus->enqueue_read_payload({0x00, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(1, 2, 0, in_buffer, out_buffer, error), HAS_ERR);
EXPECT_NE(error.find("read operation failed"), std::string::npos);
EXPECT_EQ(bus->read_call_count(), 1);
}
TEST_F(chip_ads78_test, bit_read_returns_error_when_data_is_insufficient)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x08});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(2, 2, 0, in_buffer, out_buffer, error), HAS_ERR);
EXPECT_NE(error.find("insufficient data"), std::string::npos);
}
TEST_F(chip_ads78_test, bit_read_handles_bus_exception)
{
auto bus = bind_test_bus();
bus->set_throw_on_read(true, "forced failure");
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(3, 2, 0, in_buffer, out_buffer, error), HAS_ERR);
EXPECT_FALSE(error.empty());
}
TEST_F(chip_ads78_test, bit_read_handles_empty_response)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_ERR);
EXPECT_NE(error.find("insufficient data"), std::string::npos);
}
TEST_F(chip_ads78_test, bit_read_converts_quarter_scale_adc_value)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x04, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(out_buffer[0], 0x71);
EXPECT_EQ(out_buffer[1], 0x02);
}
TEST_F(chip_ads78_test, bit_read_converts_three_quarter_scale_adc_value)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x0C, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(out_buffer[0], 0x53);
EXPECT_EQ(out_buffer[1], 0x07);
}
TEST_F(chip_ads78_test, bit_read_converts_small_adc_value)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x00, 0x10});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_EQ(out_buffer[0], 0x09);
EXPECT_EQ(out_buffer[1], 0x00);
}
TEST_F(chip_ads78_test, bit_read_all_channels_independently)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
for (int ch = 0; ch < 8; ch++) {
bus->enqueue_read_payload({0x08, 0x00});
out_buffer.clear();
EXPECT_EQ(m_chip.bit_read(ch, 2, 0, in_buffer, out_buffer, error), HAS_OK);
EXPECT_FALSE(error.empty() && out_buffer.empty());
}
}
TEST_F(chip_ads78_test, destructor_is_default)
{
auto bus = bind_test_bus();
bus->set_read_result(HAS_OK);
bus->enqueue_read_payload({0x08, 0x00});
std::vector<uint8_t> in_buffer;
std::vector<uint8_t> out_buffer;
std::string error;
{
dev::chip_ads78 chip;
mc::mutable_dict csr;
csr["Address"] = static_cast<uint32_t>(0x48);
chip.init(csr);
chip.set_left_bus(bus);
chip.set_host_bus(bus);
EXPECT_EQ(chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
}
}
}