1 #include "common/test/mocked_utils.hpp" 2 #include "common/utils.hpp" 3 #include "host-bmc/utils.hpp" 4 #include "libpldmresponder/event_parser.hpp" 5 #include "libpldmresponder/fru.hpp" 6 #include "libpldmresponder/pdr.hpp" 7 #include "libpldmresponder/pdr_utils.hpp" 8 #include "libpldmresponder/platform.hpp" 9 #include "oem/ibm/libpldmresponder/collect_slot_vpd.hpp" 10 #include "oem/ibm/libpldmresponder/inband_code_update.hpp" 11 #include "oem/ibm/libpldmresponder/oem_ibm_handler.hpp" 12 #include "oem/ibm/libpldmresponder/utils.hpp" 13 #include "test/test_instance_id.hpp" 14 15 #include <libpldm/entity.h> 16 #include <libpldm/oem/ibm/entity.h> 17 #include <libpldm/pdr.h> 18 19 #include <nlohmann/json.hpp> 20 #include <phosphor-logging/lg2.hpp> 21 #include <sdeventplus/event.hpp> 22 23 #include <filesystem> 24 #include <fstream> 25 26 using namespace pldm::utils; 27 using namespace pldm::responder; 28 using namespace pldm::responder::pdr; 29 using namespace pldm::responder::pdr_utils; 30 using namespace pldm::responder::oem_ibm_platform; 31 using ::testing::Return; 32 using ::testing::ReturnRef; 33 34 class MockOemUtilsHandler : public oem_ibm_utils::Handler 35 { 36 public: 37 MockOemUtilsHandler(const pldm::utils::DBusHandler* dBusIntf) : 38 oem_ibm_utils::Handler(dBusIntf) 39 {} 40 }; 41 42 class MockCodeUpdate : public CodeUpdate 43 { 44 public: 45 MockCodeUpdate(const pldm::utils::DBusHandler* dBusIntf) : 46 CodeUpdate(dBusIntf) 47 {} 48 49 MOCK_METHOD(void, setVersions, (), (override)); 50 }; 51 52 class MockSlotHandler : public SlotHandler 53 { 54 public: 55 MockSlotHandler(const sdeventplus::Event& event, pldm_pdr* repo) : 56 SlotHandler(event, repo) 57 {} 58 }; 59 60 class MockOemPlatformHandler : public oem_ibm_platform::Handler 61 { 62 public: 63 MockOemPlatformHandler(const pldm::utils::DBusHandler* dBusIntf, 64 pldm::responder::CodeUpdate* codeUpdate, 65 pldm::responder::SlotHandler* slotHandler, 66 int mctp_fd, uint8_t mctp_eid, 67 pldm::InstanceIdDb& instanceIdDb, 68 sdeventplus::Event& event) : 69 oem_ibm_platform::Handler(dBusIntf, codeUpdate, slotHandler, mctp_fd, 70 mctp_eid, instanceIdDb, event, nullptr) 71 {} 72 MOCK_METHOD(uint16_t, getNextEffecterId, ()); 73 MOCK_METHOD(uint16_t, getNextSensorId, ()); 74 MOCK_METHOD((const AssociatedEntityMap&), getAssociateEntityMap, (), 75 (override)); 76 }; 77 78 TEST(OemSetStateEffecterStatesHandler, testGoodRequest) 79 { 80 uint16_t entityID_ = PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE; 81 uint16_t stateSetId_ = PLDM_OEM_IBM_BOOT_STATE; 82 uint16_t entityInstance_ = 0; 83 uint16_t containerId_ = 0; 84 uint8_t compSensorCnt_ = 1; 85 uint16_t effecterId = 0xA; 86 uint16_t sensorId = 0x1; 87 TestInstanceIdDb instanceIdDb; 88 89 sdbusplus::bus_t bus(sdbusplus::bus::new_default()); 90 auto event = sdeventplus::Event::get_default(); 91 std::vector<get_sensor_state_field> stateField; 92 93 auto mockDbusHandler = std::make_unique<MockdBusHandler>(); 94 std::unique_ptr<CodeUpdate> mockCodeUpdate = 95 std::make_unique<MockCodeUpdate>(mockDbusHandler.get()); 96 std::unique_ptr<MockOemPlatformHandler> oemPlatformHandler = 97 std::make_unique<MockOemPlatformHandler>( 98 mockDbusHandler.get(), mockCodeUpdate.get(), nullptr, 0x1, 0x9, 99 instanceIdDb, event); 100 101 const AssociatedEntityMap associateMap = {}; 102 EXPECT_CALL(*oemPlatformHandler, getAssociateEntityMap()) 103 .WillRepeatedly(ReturnRef(associateMap)); 104 105 auto rc = oemPlatformHandler->getOemStateSensorReadingsHandler( 106 entityID_, entityInstance_, containerId_, stateSetId_, compSensorCnt_, 107 sensorId, stateField); 108 109 ASSERT_EQ(rc, PLDM_SUCCESS); 110 ASSERT_EQ(stateField.size(), 1); 111 ASSERT_EQ(stateField[0].event_state, tSideNum); 112 ASSERT_EQ(stateField[0].sensor_op_state, PLDM_SENSOR_ENABLED); 113 ASSERT_EQ(stateField[0].present_state, PLDM_SENSOR_UNKNOWN); 114 ASSERT_EQ(stateField[0].previous_state, PLDM_SENSOR_UNKNOWN); 115 116 entityInstance_ = 1; 117 118 std::vector<get_sensor_state_field> stateField1; 119 rc = oemPlatformHandler->getOemStateSensorReadingsHandler( 120 entityID_, entityInstance_, containerId_, stateSetId_, compSensorCnt_, 121 sensorId, stateField1); 122 ASSERT_EQ(rc, PLDM_SUCCESS); 123 ASSERT_EQ(stateField1.size(), 1); 124 ASSERT_EQ(stateField1[0].event_state, tSideNum); 125 126 entityInstance_ = 2; 127 rc = oemPlatformHandler->getOemStateSensorReadingsHandler( 128 entityID_, entityInstance_, containerId_, stateSetId_, compSensorCnt_, 129 sensorId, stateField1); 130 ASSERT_EQ(rc, PLDM_SUCCESS); 131 ASSERT_EQ(stateField1[0].event_state, PLDM_SENSOR_UNKNOWN); 132 133 entityID_ = 40; 134 stateSetId_ = 50; 135 rc = oemPlatformHandler->getOemStateSensorReadingsHandler( 136 entityID_, entityInstance_, containerId_, stateSetId_, compSensorCnt_, 137 sensorId, stateField1); 138 ASSERT_EQ(rc, PLDM_PLATFORM_INVALID_STATE_VALUE); 139 140 entityID_ = PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE; 141 entityInstance_ = 0; 142 stateSetId_ = PLDM_OEM_IBM_BOOT_STATE; 143 compSensorCnt_ = 1; 144 145 std::vector<set_effecter_state_field> setEffecterStateField; 146 setEffecterStateField.push_back({PLDM_REQUEST_SET, pSideNum}); 147 148 rc = oemPlatformHandler->oemSetStateEffecterStatesHandler( 149 entityID_, entityInstance_, stateSetId_, compSensorCnt_, 150 setEffecterStateField, effecterId); 151 ASSERT_EQ(rc, PLDM_SUCCESS); 152 153 entityInstance_ = 2; 154 rc = oemPlatformHandler->oemSetStateEffecterStatesHandler( 155 entityID_, entityInstance_, stateSetId_, compSensorCnt_, 156 setEffecterStateField, effecterId); 157 ASSERT_EQ(rc, PLDM_PLATFORM_INVALID_STATE_VALUE); 158 159 entityID_ = 34; 160 stateSetId_ = 99; 161 entityInstance_ = 0; 162 rc = oemPlatformHandler->oemSetStateEffecterStatesHandler( 163 entityID_, entityInstance_, stateSetId_, compSensorCnt_, 164 setEffecterStateField, effecterId); 165 ASSERT_EQ(rc, PLDM_PLATFORM_SET_EFFECTER_UNSUPPORTED_SENSORSTATE); 166 } 167 168 TEST(EncodeCodeUpdateEvent, testGoodRequest) 169 { 170 size_t sensorEventSize = PLDM_SENSOR_EVENT_DATA_MIN_LENGTH + 1; 171 std::vector<uint8_t> sensorEventDataVec{}; 172 sensorEventDataVec.resize(sensorEventSize); 173 174 auto eventData = reinterpret_cast<struct pldm_sensor_event_data*>( 175 sensorEventDataVec.data()); 176 eventData->sensor_id = 0xA; 177 eventData->sensor_event_class_type = PLDM_SENSOR_OP_STATE; 178 179 auto opStateSensorEventData = 180 reinterpret_cast<struct pldm_sensor_event_sensor_op_state*>( 181 sensorEventDataVec.data()); 182 opStateSensorEventData->present_op_state = uint8_t(CodeUpdateState::START); 183 opStateSensorEventData->previous_op_state = uint8_t(CodeUpdateState::END); 184 185 std::vector<uint8_t> requestMsg( 186 sizeof(pldm_msg_hdr) + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES + 187 sensorEventDataVec.size()); 188 189 auto rc = 190 encodeEventMsg(PLDM_SENSOR_EVENT, sensorEventDataVec, requestMsg, 0x1); 191 192 EXPECT_EQ(rc, PLDM_SUCCESS); 193 } 194 195 TEST(EncodeCodeUpdate, testBadRequest) 196 { 197 std::vector<uint8_t> requestMsg; 198 std::vector<uint8_t> sensorEventDataVec{}; 199 200 auto rc = 201 encodeEventMsg(PLDM_SENSOR_EVENT, sensorEventDataVec, requestMsg, 0x1); 202 203 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 204 } 205 206 TEST(clearDirPath, testClearDirPath) 207 { 208 char dirPath[] = "/tmp/testClearDir/"; 209 fs::path dir(dirPath); 210 fs::create_directories(dir); 211 struct stat buffer; 212 ASSERT_EQ(stat(dirPath, &buffer), 0); 213 char filePath[] = "/tmp/testClearDir/file.txt"; 214 std::ofstream file(filePath); 215 ASSERT_EQ(stat(filePath, &buffer), 0); 216 217 auto mockDbusHandler = std::make_unique<MockdBusHandler>(); 218 std::unique_ptr<CodeUpdate> mockCodeUpdate = 219 std::make_unique<MockCodeUpdate>(mockDbusHandler.get()); 220 221 mockCodeUpdate->clearDirPath(dirPath); 222 ASSERT_EQ(stat(filePath, &buffer), -1); 223 ASSERT_EQ(stat(dirPath, &buffer), 0); 224 } 225 226 TEST(generateStateEffecterOEMPDR, testGoodRequest) 227 { 228 const AssociatedEntityMap associateMap = {}; 229 auto inPDRRepo = pldm_pdr_init(); 230 sdbusplus::bus_t bus(sdbusplus::bus::new_default()); 231 TestInstanceIdDb instanceIdDb; 232 auto mockDbusHandler = std::make_unique<MockdBusHandler>(); 233 auto event = sdeventplus::Event::get_default(); 234 std::unique_ptr<CodeUpdate> mockCodeUpdate = 235 std::make_unique<MockCodeUpdate>(mockDbusHandler.get()); 236 std::unique_ptr<MockOemPlatformHandler> mockoemPlatformHandler = 237 std::make_unique<MockOemPlatformHandler>( 238 mockDbusHandler.get(), mockCodeUpdate.get(), nullptr, 0x1, 0x9, 239 instanceIdDb, event); 240 Repo inRepo(inPDRRepo); 241 242 EXPECT_CALL(*mockoemPlatformHandler, getAssociateEntityMap()) 243 .WillRepeatedly(ReturnRef(associateMap)); 244 245 mockoemPlatformHandler->buildOEMPDR(inRepo); 246 ASSERT_EQ(inRepo.empty(), false); 247 248 pdr_utils::PdrEntry e; 249 250 // Test for effecter number 1, for current boot side state 251 auto record1 = pdr::getRecordByHandle(inRepo, 1, e); 252 ASSERT_NE(record1, nullptr); 253 254 pldm_state_effecter_pdr* pdr = 255 reinterpret_cast<pldm_state_effecter_pdr*>(e.data); 256 257 ASSERT_EQ(pdr->hdr.record_handle, 1); 258 ASSERT_EQ(pdr->hdr.version, 1); 259 ASSERT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR); 260 ASSERT_EQ(pdr->hdr.record_change_num, 0); 261 ASSERT_EQ(pdr->hdr.length, 16); 262 ASSERT_EQ(pdr->terminus_handle, TERMINUS_HANDLE); 263 ASSERT_EQ(pdr->entity_type, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE); 264 ASSERT_EQ(pdr->entity_instance, 0); 265 ASSERT_EQ(pdr->container_id, 1); 266 ASSERT_EQ(pdr->effecter_semantic_id, 0); 267 ASSERT_EQ(pdr->effecter_init, PLDM_NO_INIT); 268 ASSERT_EQ(pdr->has_description_pdr, false); 269 ASSERT_EQ(pdr->composite_effecter_count, 1); 270 state_effecter_possible_states* states = 271 reinterpret_cast<state_effecter_possible_states*>(pdr->possible_states); 272 ASSERT_EQ(states->state_set_id, 32769); 273 ASSERT_EQ(states->possible_states_size, 2); 274 bitfield8_t bf1{}; 275 bf1.byte = 6; 276 ASSERT_EQ(states->states[0].byte, bf1.byte); 277 278 // Test for effecter number 2, for next boot side state 279 auto record2 = pdr::getRecordByHandle(inRepo, 2, e); 280 ASSERT_NE(record2, nullptr); 281 282 pdr = reinterpret_cast<pldm_state_effecter_pdr*>(e.data); 283 284 ASSERT_EQ(pdr->hdr.record_handle, 2); 285 ASSERT_EQ(pdr->hdr.version, 1); 286 ASSERT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR); 287 ASSERT_EQ(pdr->hdr.record_change_num, 0); 288 ASSERT_EQ(pdr->hdr.length, 16); 289 ASSERT_EQ(pdr->terminus_handle, TERMINUS_HANDLE); 290 ASSERT_EQ(pdr->entity_type, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE); 291 ASSERT_EQ(pdr->entity_instance, 1); 292 ASSERT_EQ(pdr->container_id, 1); 293 ASSERT_EQ(pdr->effecter_semantic_id, 0); 294 ASSERT_EQ(pdr->effecter_init, PLDM_NO_INIT); 295 ASSERT_EQ(pdr->has_description_pdr, false); 296 ASSERT_EQ(pdr->composite_effecter_count, 1); 297 states = 298 reinterpret_cast<state_effecter_possible_states*>(pdr->possible_states); 299 ASSERT_EQ(states->state_set_id, 32769); 300 ASSERT_EQ(states->possible_states_size, 2); 301 bitfield8_t bf2{}; 302 bf2.byte = 6; 303 ASSERT_EQ(states->states[0].byte, bf2.byte); 304 305 // Test for effecter number 3, for firmware update state control 306 auto record3 = pdr::getRecordByHandle(inRepo, 3, e); 307 ASSERT_NE(record3, nullptr); 308 309 pdr = reinterpret_cast<pldm_state_effecter_pdr*>(e.data); 310 311 ASSERT_EQ(pdr->hdr.record_handle, 3); 312 ASSERT_EQ(pdr->hdr.version, 1); 313 ASSERT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR); 314 ASSERT_EQ(pdr->hdr.record_change_num, 0); 315 ASSERT_EQ(pdr->hdr.length, 16); 316 ASSERT_EQ(pdr->terminus_handle, TERMINUS_HANDLE); 317 ASSERT_EQ(pdr->entity_type, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE); 318 ASSERT_EQ(pdr->entity_instance, 0); 319 ASSERT_EQ(pdr->container_id, 1); 320 ASSERT_EQ(pdr->effecter_semantic_id, 0); 321 ASSERT_EQ(pdr->effecter_init, PLDM_NO_INIT); 322 ASSERT_EQ(pdr->has_description_pdr, false); 323 ASSERT_EQ(pdr->composite_effecter_count, 1); 324 states = 325 reinterpret_cast<state_effecter_possible_states*>(pdr->possible_states); 326 ASSERT_EQ(states->state_set_id, 32768); 327 ASSERT_EQ(states->possible_states_size, 2); 328 bitfield8_t bf3{}; 329 bf3.byte = 126; 330 ASSERT_EQ(states->states[0].byte, bf3.byte); 331 332 pldm_pdr_destroy(inPDRRepo); 333 } 334 335 TEST(generateStateSensorOEMPDR, testGoodRequest) 336 { 337 const AssociatedEntityMap associateMap = {}; 338 auto inPDRRepo = pldm_pdr_init(); 339 sdbusplus::bus_t bus(sdbusplus::bus::new_default()); 340 TestInstanceIdDb instanceIdDb; 341 342 auto mockDbusHandler = std::make_unique<MockdBusHandler>(); 343 auto event = sdeventplus::Event::get_default(); 344 std::unique_ptr<CodeUpdate> mockCodeUpdate = 345 std::make_unique<MockCodeUpdate>(mockDbusHandler.get()); 346 std::unique_ptr<MockOemPlatformHandler> mockoemPlatformHandler = 347 std::make_unique<MockOemPlatformHandler>( 348 mockDbusHandler.get(), mockCodeUpdate.get(), nullptr, 0x1, 0x9, 349 instanceIdDb, event); 350 EXPECT_CALL(*mockoemPlatformHandler, getAssociateEntityMap()) 351 .WillRepeatedly(ReturnRef(associateMap)); 352 Repo inRepo(inPDRRepo); 353 mockoemPlatformHandler->buildOEMPDR(inRepo); 354 ASSERT_EQ(inRepo.empty(), false); 355 356 pdr_utils::PdrEntry e; 357 358 // Test for sensor number 1, for current boot side state 359 auto record1 = pdr::getRecordByHandle(inRepo, 5, e); 360 ASSERT_NE(record1, nullptr); 361 362 pldm_state_sensor_pdr* pdr = 363 reinterpret_cast<pldm_state_sensor_pdr*>(e.data); 364 365 ASSERT_EQ(pdr->hdr.record_handle, 5); 366 ASSERT_EQ(pdr->hdr.version, 1); 367 ASSERT_EQ(pdr->hdr.type, PLDM_STATE_SENSOR_PDR); 368 ASSERT_EQ(pdr->hdr.record_change_num, 0); 369 ASSERT_EQ(pdr->hdr.length, 14); 370 ASSERT_EQ(pdr->terminus_handle, TERMINUS_HANDLE); 371 ASSERT_EQ(pdr->entity_type, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE); 372 ASSERT_EQ(pdr->entity_instance, 0); 373 ASSERT_EQ(pdr->container_id, 1); 374 ASSERT_EQ(pdr->sensor_init, PLDM_NO_INIT); 375 ASSERT_EQ(pdr->sensor_auxiliary_names_pdr, false); 376 ASSERT_EQ(pdr->composite_sensor_count, 1); 377 state_sensor_possible_states* states = 378 reinterpret_cast<state_sensor_possible_states*>(pdr->possible_states); 379 ASSERT_EQ(states->state_set_id, 32769); 380 ASSERT_EQ(states->possible_states_size, 2); 381 bitfield8_t bf1{}; 382 bf1.byte = 6; 383 ASSERT_EQ(states->states[0].byte, bf1.byte); 384 385 // Test for sensor number 2, for next boot side state 386 auto record2 = pdr::getRecordByHandle(inRepo, 6, e); 387 ASSERT_NE(record2, nullptr); 388 389 pdr = reinterpret_cast<pldm_state_sensor_pdr*>(e.data); 390 391 ASSERT_EQ(pdr->hdr.record_handle, 6); 392 ASSERT_EQ(pdr->hdr.version, 1); 393 ASSERT_EQ(pdr->hdr.type, PLDM_STATE_SENSOR_PDR); 394 ASSERT_EQ(pdr->hdr.record_change_num, 0); 395 ASSERT_EQ(pdr->hdr.length, 14); 396 ASSERT_EQ(pdr->terminus_handle, TERMINUS_HANDLE); 397 ASSERT_EQ(pdr->entity_type, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE); 398 ASSERT_EQ(pdr->entity_instance, 1); 399 ASSERT_EQ(pdr->container_id, 1); 400 ASSERT_EQ(pdr->sensor_init, PLDM_NO_INIT); 401 ASSERT_EQ(pdr->sensor_auxiliary_names_pdr, false); 402 ASSERT_EQ(pdr->composite_sensor_count, 1); 403 states = 404 reinterpret_cast<state_sensor_possible_states*>(pdr->possible_states); 405 ASSERT_EQ(states->state_set_id, 32769); 406 ASSERT_EQ(states->possible_states_size, 2); 407 bitfield8_t bf2{}; 408 bf2.byte = 6; 409 ASSERT_EQ(states->states[0].byte, bf2.byte); 410 411 // Test for sensor number 3, for firmware update state control 412 auto record3 = pdr::getRecordByHandle(inRepo, 7, e); 413 ASSERT_NE(record3, nullptr); 414 415 pdr = reinterpret_cast<pldm_state_sensor_pdr*>(e.data); 416 417 ASSERT_EQ(pdr->hdr.record_handle, 7); 418 ASSERT_EQ(pdr->hdr.version, 1); 419 ASSERT_EQ(pdr->hdr.type, PLDM_STATE_SENSOR_PDR); 420 ASSERT_EQ(pdr->hdr.record_change_num, 0); 421 ASSERT_EQ(pdr->hdr.length, 14); 422 ASSERT_EQ(pdr->terminus_handle, TERMINUS_HANDLE); 423 ASSERT_EQ(pdr->entity_type, PLDM_OEM_IBM_ENTITY_FIRMWARE_UPDATE); 424 ASSERT_EQ(pdr->entity_instance, 0); 425 ASSERT_EQ(pdr->container_id, 1); 426 ASSERT_EQ(pdr->sensor_init, PLDM_NO_INIT); 427 ASSERT_EQ(pdr->sensor_auxiliary_names_pdr, false); 428 ASSERT_EQ(pdr->composite_sensor_count, 1); 429 states = 430 reinterpret_cast<state_sensor_possible_states*>(pdr->possible_states); 431 ASSERT_EQ(states->state_set_id, 32768); 432 ASSERT_EQ(states->possible_states_size, 2); 433 bitfield8_t bf3{}; 434 bf3.byte = 126; 435 ASSERT_EQ(states->states[0].byte, bf3.byte); 436 437 pldm_pdr_destroy(inPDRRepo); 438 } 439 440 TEST(updateOemDbusPath, testgoodpath) 441 { 442 TestInstanceIdDb instanceIdDb; 443 auto mockDbusHandler = std::make_unique<MockdBusHandler>(); 444 auto event = sdeventplus::Event::get_default(); 445 std::unique_ptr<CodeUpdate> mockCodeUpdate = 446 std::make_unique<MockCodeUpdate>(mockDbusHandler.get()); 447 std::unique_ptr<oem_ibm_platform::Handler> mockoemPlatformHandler = 448 std::make_unique<MockOemPlatformHandler>( 449 mockDbusHandler.get(), mockCodeUpdate.get(), nullptr, 0x1, 0x9, 450 instanceIdDb, event); 451 std::string dbuspath = "/inventory/system1/chassis1/motherboard1/dcm0"; 452 mockoemPlatformHandler->updateOemDbusPaths(dbuspath); 453 EXPECT_EQ(dbuspath, "/inventory/system/chassis/motherboard/dcm0"); 454 455 dbuspath = "/inventory/system/chassis/socket1/motherboard/dcm0"; 456 mockoemPlatformHandler->updateOemDbusPaths(dbuspath); 457 EXPECT_EQ(dbuspath, "/inventory/system/chassis/motherboard/dcm0"); 458 } 459 460 TEST(SetCoreCount, testgoodpath) 461 { 462 pldm::utils::EntityMaps entityMaps = pldm::hostbmc::utils::parseEntityMap( 463 "../../oem/ibm/test/entitymap_test.json"); 464 MockdBusHandler mockedDbusUtils; 465 pldm_entity entities[9]{}; 466 467 entities[0].entity_type = 45; 468 entities[0].entity_container_id = 0; 469 470 entities[1].entity_type = 64; 471 entities[1].entity_container_id = 1; 472 473 entities[2].entity_type = 67; 474 entities[2].entity_container_id = 2; 475 entities[3].entity_type = 67; 476 entities[3].entity_container_id = 2; 477 478 entities[4].entity_type = 135; 479 entities[4].entity_container_id = 3; 480 entities[5].entity_type = 135; 481 entities[5].entity_container_id = 3; 482 entities[6].entity_type = 135; 483 entities[6].entity_container_id = 3; 484 entities[7].entity_type = 135; 485 entities[7].entity_container_id = 3; 486 entities[8].entity_type = 32903; 487 entities[8].entity_container_id = 3; 488 489 auto tree = pldm_entity_association_tree_init(); 490 491 auto l1 = pldm_entity_association_tree_add_entity( 492 tree, &entities[0], 1, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL, true, 493 true, 0xFFFF); 494 495 auto l2 = pldm_entity_association_tree_add_entity( 496 tree, &entities[1], 1, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, true, true, 497 0xFFFF); 498 499 auto l3a = pldm_entity_association_tree_add_entity( 500 tree, &entities[2], 0, l2, PLDM_ENTITY_ASSOCIAION_PHYSICAL, true, true, 501 0xFFFF); 502 auto l3b = pldm_entity_association_tree_add_entity( 503 tree, &entities[3], 1, l2, PLDM_ENTITY_ASSOCIAION_PHYSICAL, true, true, 504 0xFFFF); 505 506 auto l4a = pldm_entity_association_tree_add_entity( 507 tree, &entities[4], 0, l3a, PLDM_ENTITY_ASSOCIAION_PHYSICAL, true, true, 508 0xFFFF); 509 auto l4b = pldm_entity_association_tree_add_entity( 510 tree, &entities[5], 1, l3a, PLDM_ENTITY_ASSOCIAION_PHYSICAL, true, true, 511 0xFFFF); 512 513 auto l5a = pldm_entity_association_tree_add_entity( 514 tree, &entities[6], 0, l3b, PLDM_ENTITY_ASSOCIAION_PHYSICAL, true, true, 515 0xFFFF); 516 auto l5b = pldm_entity_association_tree_add_entity( 517 tree, &entities[7], 1, l3b, PLDM_ENTITY_ASSOCIAION_PHYSICAL, true, true, 518 0xFFFF); 519 520 auto l5c = pldm_entity_association_tree_add_entity( 521 tree, &entities[8], 0, l5a, PLDM_ENTITY_ASSOCIAION_PHYSICAL, true, true, 522 0xFFFF); 523 524 auto l5ca = pldm_entity_association_tree_add_entity( 525 tree, &entities[8], 0, l5b, PLDM_ENTITY_ASSOCIAION_PHYSICAL, true, true, 526 0xFFFF); 527 528 pldm::utils::EntityAssociations entityAssociations = { 529 {l1, l2}, {l2, l3a, l3b}, {l3a, l4a, l4b}, 530 {l3b, l5a, l5b}, {l5a, l5c}, {l5b, l5ca}}; 531 532 DBusMapping dbusMapping{"/foo/bar", "xyz.openbmc_project.Foo.Bar", 533 "propertyName", "uint64_t"}; 534 std::vector<std::string> cpuInterface = {"xyz.openbmc_project.Foo.Bar"}; 535 auto oemMockedUtils = 536 std::make_unique<MockOemUtilsHandler>(&mockedDbusUtils); 537 int coreCount = 538 oemMockedUtils->setCoreCount(entityAssociations, entityMaps); 539 EXPECT_EQ(coreCount, 2); 540 pldm_entity_association_tree_destroy(tree); 541 } 542