1 /** 2 * Copyright © 2019 IBM Corporation 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #include "action_environment.hpp" 17 #include "device.hpp" 18 #include "i2c_interface.hpp" 19 #include "id_map.hpp" 20 #include "mocked_i2c_interface.hpp" 21 #include "rule.hpp" 22 23 #include <cstddef> // for size_t 24 #include <exception> 25 #include <memory> 26 #include <stdexcept> 27 #include <utility> 28 #include <vector> 29 30 #include <gtest/gtest.h> 31 32 using namespace phosphor::power::regulators; 33 34 TEST(ActionEnvironmentTests, Constructor) 35 { 36 // Create IDMap 37 IDMap idMap{}; 38 39 // Create Device and add to IDMap 40 std::unique_ptr<i2c::I2CInterface> i2cInterface = 41 i2c::create(1, 0x70, i2c::I2CInterface::InitialState::CLOSED); 42 Device reg1{"regulator1", true, "/system/chassis/motherboard/reg1", 43 std::move(i2cInterface)}; 44 idMap.addDevice(reg1); 45 46 // Verify object state after constructor 47 try 48 { 49 ActionEnvironment env{idMap, "regulator1"}; 50 EXPECT_EQ(env.getDevice().getID(), "regulator1"); 51 EXPECT_EQ(env.getDeviceID(), "regulator1"); 52 EXPECT_EQ(env.getRuleDepth(), 0); 53 EXPECT_THROW(env.getVolts(), std::logic_error); 54 EXPECT_EQ(env.hasVolts(), false); 55 } 56 catch (const std::exception& error) 57 { 58 ADD_FAILURE() << "Should not have caught exception."; 59 } 60 } 61 62 TEST(ActionEnvironmentTests, DecrementRuleDepth) 63 { 64 IDMap idMap{}; 65 ActionEnvironment env{idMap, ""}; 66 EXPECT_EQ(env.getRuleDepth(), 0); 67 env.incrementRuleDepth("set_voltage_rule"); 68 env.incrementRuleDepth("set_voltage_rule"); 69 EXPECT_EQ(env.getRuleDepth(), 2); 70 env.decrementRuleDepth(); 71 EXPECT_EQ(env.getRuleDepth(), 1); 72 env.decrementRuleDepth(); 73 EXPECT_EQ(env.getRuleDepth(), 0); 74 env.decrementRuleDepth(); 75 EXPECT_EQ(env.getRuleDepth(), 0); 76 } 77 78 TEST(ActionEnvironmentTests, GetDevice) 79 { 80 // Create IDMap 81 IDMap idMap{}; 82 83 // Create Device and add to IDMap 84 std::unique_ptr<i2c::I2CInterface> i2cInterface = 85 i2c::create(1, 0x70, i2c::I2CInterface::InitialState::CLOSED); 86 Device reg1{"regulator1", true, "/system/chassis/motherboard/reg1", 87 std::move(i2cInterface)}; 88 idMap.addDevice(reg1); 89 90 ActionEnvironment env{idMap, "regulator1"}; 91 92 // Test where current device ID is in the IDMap 93 try 94 { 95 Device& device = env.getDevice(); 96 EXPECT_EQ(device.getID(), "regulator1"); 97 EXPECT_EQ(&device, ®1); 98 } 99 catch (const std::exception& error) 100 { 101 ADD_FAILURE() << "Should not have caught exception."; 102 } 103 104 // Test where current device ID is not in the IDMap 105 env.setDeviceID("regulator2"); 106 try 107 { 108 env.getDevice(); 109 ADD_FAILURE() << "Should not have reached this line."; 110 } 111 catch (const std::invalid_argument& ia_error) 112 { 113 EXPECT_STREQ(ia_error.what(), 114 "Unable to find device with ID \"regulator2\""); 115 } 116 catch (const std::exception& error) 117 { 118 ADD_FAILURE() << "Should not have caught exception."; 119 } 120 } 121 122 TEST(ActionEnvironmentTests, GetDeviceID) 123 { 124 IDMap idMap{}; 125 ActionEnvironment env{idMap, ""}; 126 EXPECT_EQ(env.getDeviceID(), ""); 127 env.setDeviceID("regulator1"); 128 EXPECT_EQ(env.getDeviceID(), "regulator1"); 129 } 130 131 TEST(ActionEnvironmentTests, GetRule) 132 { 133 // Create IDMap 134 IDMap idMap{}; 135 Rule setVoltageRule{"set_voltage_rule", 136 std::vector<std::unique_ptr<Action>>{}}; 137 idMap.addRule(setVoltageRule); 138 139 ActionEnvironment env{idMap, ""}; 140 141 // Test where rule ID is in the IDMap 142 try 143 { 144 Rule& rule = env.getRule("set_voltage_rule"); 145 EXPECT_EQ(rule.getID(), "set_voltage_rule"); 146 EXPECT_EQ(&rule, &setVoltageRule); 147 } 148 catch (const std::exception& error) 149 { 150 ADD_FAILURE() << "Should not have caught exception."; 151 } 152 153 // Test where rule ID is not in the IDMap 154 try 155 { 156 env.getRule("set_voltage_rule2"); 157 ADD_FAILURE() << "Should not have reached this line."; 158 } 159 catch (const std::invalid_argument& ia_error) 160 { 161 EXPECT_STREQ(ia_error.what(), 162 "Unable to find rule with ID \"set_voltage_rule2\""); 163 } 164 catch (const std::exception& error) 165 { 166 ADD_FAILURE() << "Should not have caught exception."; 167 } 168 } 169 170 TEST(ActionEnvironmentTests, GetRuleDepth) 171 { 172 IDMap idMap{}; 173 ActionEnvironment env{idMap, ""}; 174 EXPECT_EQ(env.getRuleDepth(), 0); 175 env.incrementRuleDepth("set_voltage_rule"); 176 EXPECT_EQ(env.getRuleDepth(), 1); 177 env.incrementRuleDepth("set_voltage_rule"); 178 EXPECT_EQ(env.getRuleDepth(), 2); 179 env.decrementRuleDepth(); 180 EXPECT_EQ(env.getRuleDepth(), 1); 181 env.decrementRuleDepth(); 182 EXPECT_EQ(env.getRuleDepth(), 0); 183 } 184 185 TEST(ActionEnvironmentTests, GetVolts) 186 { 187 IDMap idMap{}; 188 ActionEnvironment env{idMap, ""}; 189 EXPECT_EQ(env.hasVolts(), false); 190 191 // Test where a volts value has not been set 192 try 193 { 194 env.getVolts(); 195 } 196 catch (const std::logic_error& l_error) 197 { 198 EXPECT_STREQ(l_error.what(), "No volts value has been set."); 199 } 200 catch (const std::exception& error) 201 { 202 ADD_FAILURE() << "Should not have caught exception."; 203 } 204 205 // Test where a volts value has been set 206 env.setVolts(1.31); 207 try 208 { 209 double volts = env.getVolts(); 210 EXPECT_EQ(volts, 1.31); 211 } 212 catch (const std::exception& error) 213 { 214 ADD_FAILURE() << "Should not have caught exception."; 215 } 216 } 217 218 TEST(ActionEnvironmentTests, HasVolts) 219 { 220 IDMap idMap{}; 221 ActionEnvironment env{idMap, ""}; 222 EXPECT_EQ(env.hasVolts(), false); 223 env.setVolts(1.31); 224 EXPECT_EQ(env.hasVolts(), true); 225 } 226 227 TEST(ActionEnvironmentTests, IncrementRuleDepth) 228 { 229 IDMap idMap{}; 230 ActionEnvironment env{idMap, ""}; 231 EXPECT_EQ(env.getRuleDepth(), 0); 232 233 // Test where rule depth has not exceeded maximum 234 try 235 { 236 for (size_t i = 1; i <= env.maxRuleDepth; ++i) 237 { 238 env.incrementRuleDepth("set_voltage_rule"); 239 EXPECT_EQ(env.getRuleDepth(), i); 240 } 241 } 242 catch (const std::exception& error) 243 { 244 ADD_FAILURE() << "Should not have caught exception."; 245 } 246 247 // Test where rule depth has exceeded maximum 248 try 249 { 250 env.incrementRuleDepth("set_voltage_rule"); 251 } 252 catch (const std::runtime_error& r_error) 253 { 254 EXPECT_STREQ(r_error.what(), 255 "Maximum rule depth exceeded by rule set_voltage_rule."); 256 } 257 catch (const std::exception& error) 258 { 259 ADD_FAILURE() << "Should not have caught exception."; 260 } 261 } 262 263 TEST(ActionEnvironmentTests, SetDeviceID) 264 { 265 IDMap idMap{}; 266 ActionEnvironment env{idMap, "regulator1"}; 267 EXPECT_EQ(env.getDeviceID(), "regulator1"); 268 env.setDeviceID("regulator2"); 269 EXPECT_EQ(env.getDeviceID(), "regulator2"); 270 } 271 272 TEST(ActionEnvironmentTests, SetVolts) 273 { 274 try 275 { 276 IDMap idMap{}; 277 ActionEnvironment env{idMap, ""}; 278 EXPECT_EQ(env.hasVolts(), false); 279 env.setVolts(2.35); 280 EXPECT_EQ(env.hasVolts(), true); 281 EXPECT_EQ(env.getVolts(), 2.35); 282 } 283 catch (const std::exception& error) 284 { 285 ADD_FAILURE() << "Should not have caught exception."; 286 } 287 } 288