test/power_rail/max34451_utility_unittest.cpp

#include "include/power_rail/max34451_utility.hpp"

#include "gtest/gtest.h"

TEST(Max34451Test, CheckPowerRailFault)
{
    EXPECT_TRUE(max34451::checkPowerRailFault(0x20, true));
    EXPECT_FALSE(max34451::checkPowerRailFault(0x20, false));
    EXPECT_TRUE(max34451::checkPowerRailFault(0x10, false));
    EXPECT_TRUE(max34451::checkPowerRailFault(0x10, true));
    EXPECT_FALSE(max34451::checkPowerRailFault(0x00, false));
    EXPECT_FALSE(max34451::checkPowerRailFault(0x00, true));
}

TEST(Max34451Test, GetWordAndLog)
{
    std::vector<uint8_t> data = {0x12, 0x34};
    std::stringstream logStream;

    uint16_t result = max34451::getWordAndLog(logStream, data, 0, 1,
                                              "TestLabel: ");

    EXPECT_EQ(result, 0x1234);
    EXPECT_EQ(logStream.str(), "TestLabel: 0x1234\n");
}

TEST(Max34451Test, LoadConfig)
{
    max34451::Max34451Logger logger;

    std::ofstream tempFile("test_config.json");
    tempFile << R"({
        "Bus": "1",
        "Address": "0x1A",
        "Source": "TestSource",
        "IncludeWarnings": true,
        "Registers": {
            "MfrChannelConfigReg": "0xAA",
            "MfrPsenConfigReg": "0xBB",
            "MfrPwmConfigReg": "0xCC",
            "MfrNvFaultLogReg": "0xDD",
            "MfrNvLogConfigReg": "0xEE",
            "StatusWordReg": "0xFF",
            "StatusCmlReg": "0x11",
            "StatusMfrSpecificReg": "0x22"
        },
        "FaultLogConfig": {
            "Command": "0x03",
            "Offset": "5"
        },
        "EnableBits": {
            "ForceLog": "1",
            "ClearLog": ["2", "3"]
        },
        "SequencerRegisters": [{
            "PageToPowerRailMap": {
                "0": "Rail1",
                "1": "Rail2"
            }
        }],
        "RailPriority": ["Rail1", "Rail2"]
    })";
    tempFile.close();

    logger.loadConfig("test_config.json");

    EXPECT_EQ(logger.bus, 1);
    EXPECT_EQ(logger.address, 0x1A);
    EXPECT_EQ(logger.source, "TestSource");
    EXPECT_TRUE(logger.includeWarnings);
    EXPECT_EQ(logger.mfrChannelConfigReg, 0xAA);
    EXPECT_EQ(logger.mfrPsenConfigReg, 0xBB);
    EXPECT_EQ(logger.mfrPwmConfigReg, 0xCC);
    EXPECT_EQ(logger.mfrNvFaultLogReg, 0xDD);
    EXPECT_EQ(logger.mfrNvLogConfigReg, 0xEE);
    EXPECT_EQ(logger.statusWordReg, 0xFF);
    EXPECT_EQ(logger.statusCmlReg, 0x11);
    EXPECT_EQ(logger.statusMfrSpecificReg, 0x22);
    EXPECT_EQ(logger.faultLogCommand, 0x03);
    EXPECT_EQ(logger.faultLogOffset, 5);
    EXPECT_EQ(logger.forceLogBit, 1);
    EXPECT_EQ(logger.clearLogBits.size(), 2);
    EXPECT_EQ(logger.clearLogBits[0], 2);
    EXPECT_EQ(logger.clearLogBits[1], 3);
    EXPECT_EQ(logger.sequencerRegisters.size(), 1);
    EXPECT_EQ(logger.railPriority.size(), 2);
    EXPECT_EQ(logger.railPriority[0], "Rail1");
    EXPECT_EQ(logger.railPriority[1], "Rail2");
}

TEST(Max34451Test, Max34451PowerRailParser)
{
    max34451::Max34451Logger logger;
    logger.faultLogOffset = 0;
    logger.includeWarnings = true;

    json sequencerReg = {
        {max34451::kPageToPowerRailMap, {{"0", "Rail1"}, {"1", "Rail2"}}}};
    logger.sequencerRegisters.push_back(sequencerReg);

    std::vector<uint8_t> faultLog = {0x20, 0x10};

    std::stringstream logStream;

    max34451::max34451PowerRailParser(logger, faultLog, logStream);

    std::string expectedOutput = "    \"Rail1\"\n    \"Rail2\"\n";
    EXPECT_EQ(logStream.str(), expectedOutput);
}