* 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 <internal/bus/bus_base/bus.h>
#include <internal/chip/chip_pca9545/pca9545.h>
#include <internal/hasdef.h>
#include <mc/dict.h>
#include <gtest/gtest.h>
#include <memory>
#include <string>
#include <vector>
namespace {
class mock_i2c_bus : public dev::bus_base {
public:
uint32_t read(ACCESS_DATA_S& input) override
{
++m_read_count;
return m_read_result;
}
uint32_t write(ACCESS_DATA_S& input) override
{
++m_write_count;
m_last_write_data = input.in_buffer;
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 set_write_result(int32_t r)
{
m_write_result = r;
}
const std::vector<uint8_t>& last_write_data() const
{
return m_last_write_data;
}
int m_read_count = 0;
int m_write_count = 0;
private:
uint8_t m_id = 0;
int32_t m_read_result = HAS_OK;
int32_t m_write_result = HAS_OK;
std::vector<uint8_t> m_last_write_data;
};
class chip_pca9545_test : public ::testing::Test {
protected:
void SetUp() override
{
m_bus = std::make_shared<mock_i2c_bus>();
m_bus->set_id(0);
m_chip = std::make_shared<dev::chip_pca9545>();
m_chip->set_left_bus(m_bus);
m_chip->set_host_bus(m_bus);
}
std::shared_ptr<mock_i2c_bus> m_bus;
std::shared_ptr<dev::chip_pca9545> m_chip;
};
TEST_F(chip_pca9545_test, init_default)
{
mc::mutable_dict csr;
csr["object_name"] = "test_pca9545";
EXPECT_TRUE(m_chip->init(csr));
}
TEST_F(chip_pca9545_test, init_with_channel_num)
{
mc::mutable_dict csr;
csr["object_name"] = "test_pca9545";
csr["ChannelNum"] = static_cast<uint8_t>(4);
EXPECT_TRUE(m_chip->init(csr));
}
TEST_F(chip_pca9545_test, init_fails_on_invalid_csr)
{
mc::mutable_dict csr;
csr["object_name"] = "test_pca9545";
csr["ChannelNum"] = "not_a_number";
EXPECT_FALSE(m_chip->init(csr));
}
TEST_F(chip_pca9545_test, chip_reset_no_ref_returns_ok)
{
int32_t ret = m_chip->chip_reset();
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(m_bus->last_write_data().empty());
}
TEST_F(chip_pca9545_test, chip_reset_no_ref_ignores_bus_error)
{
m_bus->set_write_result(HAS_ERR);
int32_t ret = m_chip->chip_reset();
EXPECT_EQ(ret, HAS_OK);
EXPECT_TRUE(m_bus->last_write_data().empty());
}
TEST_F(chip_pca9545_test, open_channel_selects_correct_channel)
{
m_bus->set_id(5);
int32_t ret = m_chip->open_channel(m_bus);
EXPECT_EQ(ret, HAS_OK);
ASSERT_FALSE(m_bus->last_write_data().empty());
EXPECT_EQ(m_bus->last_write_data()[0], 1 << 5);
}
TEST_F(chip_pca9545_test, open_channel_channel_0)
{
m_bus->set_id(0);
int32_t ret = m_chip->open_channel(m_bus);
EXPECT_EQ(ret, HAS_OK);
EXPECT_EQ(m_bus->last_write_data()[0], 1 << 0);
}
TEST_F(chip_pca9545_test, open_channel_null_bus_throws)
{
EXPECT_THROW(m_chip->open_channel(nullptr), mc::invalid_op_exception);
}
TEST_F(chip_pca9545_test, open_channel_invalid_id_throws)
{
m_bus->set_id(8);
EXPECT_THROW(m_chip->open_channel(m_bus), mc::invalid_op_exception);
}
TEST_F(chip_pca9545_test, open_channel_write_fails_throws)
{
m_bus->set_write_result(HAS_ERR);
EXPECT_THROW(m_chip->open_channel(m_bus), mc::invalid_op_exception);
}
TEST_F(chip_pca9545_test, close_channel_writes_zero)
{
int32_t ret = m_chip->close_channel(m_bus);
EXPECT_EQ(ret, HAS_OK);
ASSERT_FALSE(m_bus->last_write_data().empty());
EXPECT_EQ(m_bus->last_write_data()[0], 0x00);
}
TEST_F(chip_pca9545_test, close_channel_write_fails)
{
m_bus->set_write_result(HAS_ERR);
int32_t ret = m_chip->close_channel(m_bus);
EXPECT_EQ(ret, HAS_ERR);
}
}