/** * Copyright © 2020 IBM Corporation * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "action.hpp" #include "chassis.hpp" #include "configuration.hpp" #include "device.hpp" #include "i2c_interface.hpp" #include "i2c_write_byte_action.hpp" #include "journal.hpp" #include "mock_action.hpp" #include "mock_journal.hpp" #include "mocked_i2c_interface.hpp" #include "pmbus_utils.hpp" #include "pmbus_write_vout_command_action.hpp" #include "presence_detection.hpp" #include "rail.hpp" #include "rule.hpp" #include "system.hpp" #include #include #include #include #include #include #include using namespace phosphor::power::regulators; using namespace phosphor::power::regulators::pmbus_utils; using ::testing::Return; using ::testing::Throw; using ::testing::TypedEq; TEST(ConfigurationTests, Constructor) { // Test where volts value specified { std::optional volts{1.3}; std::vector> actions{}; actions.push_back(std::make_unique()); actions.push_back(std::make_unique()); Configuration configuration(volts, std::move(actions)); EXPECT_EQ(configuration.getVolts().has_value(), true); EXPECT_EQ(configuration.getVolts().value(), 1.3); EXPECT_EQ(configuration.getActions().size(), 2); } // Test where volts value not specified { std::optional volts{}; std::vector> actions{}; actions.push_back(std::make_unique()); Configuration configuration(volts, std::move(actions)); EXPECT_EQ(configuration.getVolts().has_value(), false); EXPECT_EQ(configuration.getActions().size(), 1); } } // Test for execute(System&, Chassis&, Device&) TEST(ConfigurationTests, ExecuteForDevice) { // Test where works: Volts value not specified { // Create I2CWriteByteAction with register 0x7C and value 0x0A std::unique_ptr action = std::make_unique(0x7C, 0x0A); // Create mock I2CInterface. Expect action to write 0x0A to 0x7C. std::unique_ptr i2cInterface = std::make_unique(); EXPECT_CALL(*i2cInterface, isOpen).Times(1).WillOnce(Return(true)); EXPECT_CALL(*i2cInterface, write(TypedEq(0x7C), TypedEq(0x0A))) .Times(1); // Create Configuration with no volts value specified std::optional volts{}; std::vector> actions{}; actions.emplace_back(std::move(action)); std::unique_ptr configuration = std::make_unique(volts, std::move(actions)); Configuration* configurationPtr = configuration.get(); // Create Device that contains Configuration std::unique_ptr presenceDetection{}; std::unique_ptr device = std::make_unique( "vdd_reg", true, "/system/chassis/motherboard/reg2", std::move(i2cInterface), std::move(presenceDetection), std::move(configuration)); Device* devicePtr = device.get(); // Create Chassis that contains Device std::vector> devices{}; devices.emplace_back(std::move(device)); std::unique_ptr chassis = std::make_unique(1, std::move(devices)); Chassis* chassisPtr = chassis.get(); // Create System that contains Chassis std::vector> rules{}; std::vector> chassisVec{}; chassisVec.emplace_back(std::move(chassis)); System system{std::move(rules), std::move(chassisVec)}; // Execute Configuration journal::clear(); configurationPtr->execute(system, *chassisPtr, *devicePtr); std::vector expectedDebugMessages{"Configuring vdd_reg"}; EXPECT_EQ(journal::getDebugMessages(), expectedDebugMessages); EXPECT_EQ(journal::getErrMessages().size(), 0); } // Test where works: Volts value specified { // Create PMBusWriteVoutCommandAction. Do not specify a volts value // because it will get a value of 1.3V from the // ActionEnvironment/Configuration. Specify a -8 exponent. // Linear format volts value = (1.3 / 2^(-8)) = 332.8 = 333 = 0x014D. std::optional volts{}; std::unique_ptr action = std::make_unique( volts, pmbus_utils::VoutDataFormat::linear, -8, false); // Create mock I2CInterface. Expect action to write 0x014D to // VOUT_COMMAND (command/register 0x21). std::unique_ptr i2cInterface = std::make_unique(); EXPECT_CALL(*i2cInterface, isOpen).Times(1).WillOnce(Return(true)); EXPECT_CALL(*i2cInterface, write(TypedEq(0x21), TypedEq(0x014D))) .Times(1); // Create Configuration with volts value 1.3V std::vector> actions{}; actions.emplace_back(std::move(action)); std::unique_ptr configuration = std::make_unique(1.3, std::move(actions)); Configuration* configurationPtr = configuration.get(); // Create Device that contains Configuration std::unique_ptr presenceDetection{}; std::unique_ptr device = std::make_unique( "vdd_reg", true, "/system/chassis/motherboard/reg2", std::move(i2cInterface), std::move(presenceDetection), std::move(configuration)); Device* devicePtr = device.get(); // Create Chassis that contains Device std::vector> devices{}; devices.emplace_back(std::move(device)); std::unique_ptr chassis = std::make_unique(1, std::move(devices)); Chassis* chassisPtr = chassis.get(); // Create System that contains Chassis std::vector> rules{}; std::vector> chassisVec{}; chassisVec.emplace_back(std::move(chassis)); System system{std::move(rules), std::move(chassisVec)}; // Execute Configuration journal::clear(); configurationPtr->execute(system, *chassisPtr, *devicePtr); std::vector expectedDebugMessages{ "Configuring vdd_reg: volts=1.300000"}; EXPECT_EQ(journal::getDebugMessages(), expectedDebugMessages); EXPECT_EQ(journal::getErrMessages().size(), 0); } // Test where fails { // Create I2CWriteByteAction with register 0x7C and value 0x0A std::unique_ptr action = std::make_unique(0x7C, 0x0A); // Create mock I2CInterface. write() throws an I2CException. std::unique_ptr i2cInterface = std::make_unique(); EXPECT_CALL(*i2cInterface, isOpen).Times(1).WillOnce(Return(true)); EXPECT_CALL(*i2cInterface, write(TypedEq(0x7C), TypedEq(0x0A))) .Times(1) .WillOnce(Throw( i2c::I2CException{"Failed to write byte", "/dev/i2c-1", 0x70})); // Create Configuration with no volts value specified std::optional volts{}; std::vector> actions{}; actions.emplace_back(std::move(action)); std::unique_ptr configuration = std::make_unique(volts, std::move(actions)); Configuration* configurationPtr = configuration.get(); // Create Device that contains Configuration std::unique_ptr presenceDetection{}; std::unique_ptr device = std::make_unique( "vdd_reg", true, "/system/chassis/motherboard/reg2", std::move(i2cInterface), std::move(presenceDetection), std::move(configuration)); Device* devicePtr = device.get(); // Create Chassis that contains Device std::vector> devices{}; devices.emplace_back(std::move(device)); std::unique_ptr chassis = std::make_unique(1, std::move(devices)); Chassis* chassisPtr = chassis.get(); // Create System that contains Chassis std::vector> rules{}; std::vector> chassisVec{}; chassisVec.emplace_back(std::move(chassis)); System system{std::move(rules), std::move(chassisVec)}; // Execute Configuration journal::clear(); configurationPtr->execute(system, *chassisPtr, *devicePtr); std::vector expectedDebugMessages{"Configuring vdd_reg"}; EXPECT_EQ(journal::getDebugMessages(), expectedDebugMessages); std::vector expectedErrMessages{ "I2CException: Failed to write byte: bus /dev/i2c-1, addr 0x70", "ActionError: i2c_write_byte: { register: 0x7C, value: 0xA, mask: " "0xFF }", "Unable to configure vdd_reg"}; EXPECT_EQ(journal::getErrMessages(), expectedErrMessages); } } // Test for execute(System&, Chassis&, Device&, Rail&) TEST(ConfigurationTests, ExecuteForRail) { // Test where works: Volts value not specified { // Create I2CWriteByteAction with register 0x7C and value 0x0A std::unique_ptr action = std::make_unique(0x7C, 0x0A); // Create mock I2CInterface. Expect action to write 0x0A to 0x7C. std::unique_ptr i2cInterface = std::make_unique(); EXPECT_CALL(*i2cInterface, isOpen).Times(1).WillOnce(Return(true)); EXPECT_CALL(*i2cInterface, write(TypedEq(0x7C), TypedEq(0x0A))) .Times(1); // Create Configuration with no volts value specified std::optional volts{}; std::vector> actions{}; actions.emplace_back(std::move(action)); std::unique_ptr configuration = std::make_unique(volts, std::move(actions)); Configuration* configurationPtr = configuration.get(); // Create Rail that contains Configuration std::unique_ptr rail = std::make_unique("vio2", std::move(configuration)); Rail* railPtr = rail.get(); // Create Device that contains Rail std::unique_ptr presenceDetection{}; std::unique_ptr deviceConfiguration{}; std::vector> rails{}; rails.emplace_back(std::move(rail)); std::unique_ptr device = std::make_unique( "reg1", true, "/system/chassis/motherboard/reg1", std::move(i2cInterface), std::move(presenceDetection), std::move(deviceConfiguration), std::move(rails)); Device* devicePtr = device.get(); // Create Chassis that contains Device std::vector> devices{}; devices.emplace_back(std::move(device)); std::unique_ptr chassis = std::make_unique(1, std::move(devices)); Chassis* chassisPtr = chassis.get(); // Create System that contains Chassis std::vector> rules{}; std::vector> chassisVec{}; chassisVec.emplace_back(std::move(chassis)); System system{std::move(rules), std::move(chassisVec)}; // Execute Configuration journal::clear(); configurationPtr->execute(system, *chassisPtr, *devicePtr, *railPtr); std::vector expectedDebugMessages{"Configuring vio2"}; EXPECT_EQ(journal::getDebugMessages(), expectedDebugMessages); EXPECT_EQ(journal::getErrMessages().size(), 0); } // Test where works: Volts value specified { // Create PMBusWriteVoutCommandAction. Do not specify a volts value // because it will get a value of 1.3V from the // ActionEnvironment/Configuration. Specify a -8 exponent. // Linear format volts value = (1.3 / 2^(-8)) = 332.8 = 333 = 0x014D. std::optional volts{}; std::unique_ptr action = std::make_unique( volts, pmbus_utils::VoutDataFormat::linear, -8, false); // Create mock I2CInterface. Expect action to write 0x014D to // VOUT_COMMAND (command/register 0x21). std::unique_ptr i2cInterface = std::make_unique(); EXPECT_CALL(*i2cInterface, isOpen).Times(1).WillOnce(Return(true)); EXPECT_CALL(*i2cInterface, write(TypedEq(0x21), TypedEq(0x014D))) .Times(1); // Create Configuration with volts value 1.3V std::vector> actions{}; actions.emplace_back(std::move(action)); std::unique_ptr configuration = std::make_unique(1.3, std::move(actions)); Configuration* configurationPtr = configuration.get(); // Create Rail that contains Configuration std::unique_ptr rail = std::make_unique("vio2", std::move(configuration)); Rail* railPtr = rail.get(); // Create Device that contains Rail std::unique_ptr presenceDetection{}; std::unique_ptr deviceConfiguration{}; std::vector> rails{}; rails.emplace_back(std::move(rail)); std::unique_ptr device = std::make_unique( "reg1", true, "/system/chassis/motherboard/reg1", std::move(i2cInterface), std::move(presenceDetection), std::move(deviceConfiguration), std::move(rails)); Device* devicePtr = device.get(); // Create Chassis that contains Device std::vector> devices{}; devices.emplace_back(std::move(device)); std::unique_ptr chassis = std::make_unique(1, std::move(devices)); Chassis* chassisPtr = chassis.get(); // Create System that contains Chassis std::vector> rules{}; std::vector> chassisVec{}; chassisVec.emplace_back(std::move(chassis)); System system{std::move(rules), std::move(chassisVec)}; // Execute Configuration journal::clear(); configurationPtr->execute(system, *chassisPtr, *devicePtr, *railPtr); std::vector expectedDebugMessages{ "Configuring vio2: volts=1.300000"}; EXPECT_EQ(journal::getDebugMessages(), expectedDebugMessages); EXPECT_EQ(journal::getErrMessages().size(), 0); } // Test where fails { // Create I2CWriteByteAction with register 0x7C and value 0x0A std::unique_ptr action = std::make_unique(0x7C, 0x0A); // Create mock I2CInterface. write() throws an I2CException. std::unique_ptr i2cInterface = std::make_unique(); EXPECT_CALL(*i2cInterface, isOpen).Times(1).WillOnce(Return(true)); EXPECT_CALL(*i2cInterface, write(TypedEq(0x7C), TypedEq(0x0A))) .Times(1) .WillOnce(Throw( i2c::I2CException{"Failed to write byte", "/dev/i2c-1", 0x70})); // Create Configuration with no volts value specified std::optional volts{}; std::vector> actions{}; actions.emplace_back(std::move(action)); std::unique_ptr configuration = std::make_unique(volts, std::move(actions)); Configuration* configurationPtr = configuration.get(); // Create Rail that contains Configuration std::unique_ptr rail = std::make_unique("vio2", std::move(configuration)); Rail* railPtr = rail.get(); // Create Device that contains Rail std::unique_ptr presenceDetection{}; std::unique_ptr deviceConfiguration{}; std::vector> rails{}; rails.emplace_back(std::move(rail)); std::unique_ptr device = std::make_unique( "reg1", true, "/system/chassis/motherboard/reg1", std::move(i2cInterface), std::move(presenceDetection), std::move(deviceConfiguration), std::move(rails)); Device* devicePtr = device.get(); // Create Chassis that contains Device std::vector> devices{}; devices.emplace_back(std::move(device)); std::unique_ptr chassis = std::make_unique(1, std::move(devices)); Chassis* chassisPtr = chassis.get(); // Create System that contains Chassis std::vector> rules{}; std::vector> chassisVec{}; chassisVec.emplace_back(std::move(chassis)); System system{std::move(rules), std::move(chassisVec)}; // Execute Configuration journal::clear(); configurationPtr->execute(system, *chassisPtr, *devicePtr, *railPtr); std::vector expectedDebugMessages{"Configuring vio2"}; EXPECT_EQ(journal::getDebugMessages(), expectedDebugMessages); std::vector expectedErrMessages{ "I2CException: Failed to write byte: bus /dev/i2c-1, addr 0x70", "ActionError: i2c_write_byte: { register: 0x7C, value: 0xA, mask: " "0xFF }", "Unable to configure vio2"}; EXPECT_EQ(journal::getErrMessages(), expectedErrMessages); } } TEST(ConfigurationTests, GetActions) { std::optional volts{1.3}; std::vector> actions{}; MockAction* action1 = new MockAction{}; actions.push_back(std::unique_ptr{action1}); MockAction* action2 = new MockAction{}; actions.push_back(std::unique_ptr{action2}); Configuration configuration(volts, std::move(actions)); EXPECT_EQ(configuration.getActions().size(), 2); EXPECT_EQ(configuration.getActions()[0].get(), action1); EXPECT_EQ(configuration.getActions()[1].get(), action2); } TEST(ConfigurationTests, GetVolts) { // Test where volts value specified { std::optional volts{3.2}; std::vector> actions{}; actions.push_back(std::make_unique()); Configuration configuration(volts, std::move(actions)); EXPECT_EQ(configuration.getVolts().has_value(), true); EXPECT_EQ(configuration.getVolts().value(), 3.2); } // Test where volts value not specified { std::optional volts{}; std::vector> actions{}; actions.push_back(std::make_unique()); Configuration configuration(volts, std::move(actions)); EXPECT_EQ(configuration.getVolts().has_value(), false); } }