1 #include <endian.h> 2 #include <libpldm/pdr.h> 3 #include <libpldm/platform.h> 4 #include <msgbuf.h> 5 6 #include <array> 7 #include <cstdint> 8 #include <cstdlib> 9 #include <cstring> 10 #include <memory> 11 #include <vector> 12 13 #include <gtest/gtest.h> 14 15 typedef struct pldm_association_pdr_test 16 { 17 uint32_t record_handle; 18 uint8_t version; 19 uint8_t type; 20 uint16_t record_change_num; 21 uint16_t length; 22 uint16_t container_id; 23 uint8_t association_type; 24 uint8_t num_children; 25 26 inline bool operator==(pldm_association_pdr_test pdr) const 27 { 28 return (record_handle == pdr.record_handle) && (type == pdr.type) && 29 (length == pdr.length) && (container_id == pdr.container_id) && 30 (association_type == pdr.association_type) && 31 (num_children == pdr.num_children); 32 } 33 } pldm_association_pdr_test; 34 35 typedef struct pldm_entity_test 36 { 37 uint16_t entity_type; 38 uint16_t entity_instance_num; 39 uint16_t entity_container_id; 40 41 inline bool operator==(pldm_entity_test entity) const 42 { 43 return (entity_type == entity.entity_type) && 44 (entity_instance_num == entity.entity_instance_num) && 45 (entity_container_id == entity.entity_container_id); 46 } 47 } pldm_entity_test; 48 49 static void getEntity(struct pldm_msgbuf* buf, pldm_entity_test& entity) 50 { 51 pldm_msgbuf_extract_uint16(buf, entity.entity_type); 52 pldm_msgbuf_extract_uint16(buf, entity.entity_instance_num); 53 pldm_msgbuf_extract_uint16(buf, entity.entity_container_id); 54 } 55 56 static void 57 getAssociationPdrDetails(struct pldm_msgbuf* buf, 58 pldm_association_pdr_test& association_pdr_test) 59 { 60 pldm_msgbuf_extract_uint32(buf, association_pdr_test.record_handle); 61 pldm_msgbuf_extract_uint8(buf, association_pdr_test.version); 62 pldm_msgbuf_extract_uint8(buf, association_pdr_test.type); 63 pldm_msgbuf_extract_uint16(buf, association_pdr_test.record_change_num); 64 pldm_msgbuf_extract_uint16(buf, association_pdr_test.length); 65 66 pldm_msgbuf_extract_uint16(buf, association_pdr_test.container_id); 67 pldm_msgbuf_extract_uint8(buf, association_pdr_test.association_type); 68 } 69 70 static void 71 verifyEntityAssociationPdr(struct pldm_msgbuf* buf, 72 const pldm_association_pdr_test& association_pdr, 73 const pldm_entity_test& container_entity1, 74 const pldm_entity_test& child_entity1) 75 { 76 struct pldm_entity_test container_entity = {}; 77 struct pldm_entity_test child_entity = {}; 78 pldm_association_pdr_test association_pdr_test{}; 79 80 getAssociationPdrDetails(buf, association_pdr_test); 81 getEntity(buf, container_entity); 82 pldm_msgbuf_extract_uint8(buf, association_pdr_test.num_children); 83 getEntity(buf, child_entity); 84 85 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 86 87 EXPECT_TRUE(association_pdr_test == association_pdr); 88 EXPECT_TRUE(container_entity == container_entity1); 89 EXPECT_TRUE(child_entity == child_entity1); 90 } 91 92 TEST(PDRAccess, testInit) 93 { 94 auto repo = pldm_pdr_init(); 95 EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u); 96 EXPECT_EQ(pldm_pdr_get_repo_size(repo), 0u); 97 pldm_pdr_destroy(repo); 98 } 99 100 TEST(PDRUpdate, testAdd) 101 { 102 auto repo = pldm_pdr_init(); 103 104 std::array<uint8_t, 10> data{}; 105 uint32_t handle = 0; 106 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &handle), 107 0); 108 EXPECT_EQ(handle, 1u); 109 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 110 EXPECT_EQ(pldm_pdr_get_repo_size(repo), data.size()); 111 112 handle = 0; 113 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &handle), 114 0); 115 EXPECT_EQ(handle, 2u); 116 117 handle = 0; 118 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &handle), 119 0); 120 EXPECT_EQ(handle, 3u); 121 122 handle = 0xdeeddeedu; 123 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &handle), 124 0); 125 EXPECT_EQ(handle, 0xdeeddeed); 126 EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u); 127 EXPECT_EQ(pldm_pdr_get_repo_size(repo), data.size() * 4u); 128 129 pldm_pdr_destroy(repo); 130 } 131 132 TEST(PDRRemoveByTerminus, testRemoveByTerminus) 133 { 134 std::array<uint8_t, 10> data{}; 135 136 auto repo = pldm_pdr_init(); 137 138 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 139 pldm_pdr_remove_pdrs_by_terminus_handle(repo, 1); 140 EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u); 141 pldm_pdr_destroy(repo); 142 143 repo = pldm_pdr_init(); 144 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 2, NULL), 0); 145 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 146 EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u); 147 pldm_pdr_remove_pdrs_by_terminus_handle(repo, 1); 148 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 149 pldm_pdr_destroy(repo); 150 151 repo = pldm_pdr_init(); 152 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 153 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 2, NULL), 0); 154 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 2, NULL), 0); 155 EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u); 156 pldm_pdr_remove_pdrs_by_terminus_handle(repo, 2); 157 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 158 pldm_pdr_destroy(repo); 159 160 repo = pldm_pdr_init(); 161 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 162 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 2, NULL), 0); 163 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 164 EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u); 165 pldm_pdr_remove_remote_pdrs(repo); 166 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 167 pldm_pdr_remove_pdrs_by_terminus_handle(repo, 1); 168 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 169 pldm_pdr_remove_pdrs_by_terminus_handle(repo, 2); 170 EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u); 171 pldm_pdr_destroy(repo); 172 } 173 174 TEST(PDRUpdate, testRemove) 175 { 176 std::array<uint8_t, 10> data{}; 177 178 auto repo = pldm_pdr_init(); 179 pldm_pdr_remove_remote_pdrs(repo); 180 EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u); 181 pldm_pdr_destroy(repo); 182 183 repo = pldm_pdr_init(); 184 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 185 pldm_pdr_remove_remote_pdrs(repo); 186 EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u); 187 pldm_pdr_destroy(repo); 188 189 repo = pldm_pdr_init(); 190 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 191 pldm_pdr_remove_remote_pdrs(repo); 192 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 193 pldm_pdr_destroy(repo); 194 195 repo = pldm_pdr_init(); 196 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 197 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 198 pldm_pdr_remove_remote_pdrs(repo); 199 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 200 pldm_pdr_destroy(repo); 201 202 repo = pldm_pdr_init(); 203 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 204 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 205 pldm_pdr_remove_remote_pdrs(repo); 206 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 207 pldm_pdr_destroy(repo); 208 209 repo = pldm_pdr_init(); 210 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 211 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 212 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 213 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 214 pldm_pdr_remove_remote_pdrs(repo); 215 EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u); 216 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 217 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 218 EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u); 219 pldm_pdr_destroy(repo); 220 221 repo = pldm_pdr_init(); 222 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 223 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 224 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 225 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 226 pldm_pdr_remove_remote_pdrs(repo); 227 EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u); 228 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 229 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 230 EXPECT_EQ(pldm_pdr_get_record_count(repo), 6u); 231 pldm_pdr_destroy(repo); 232 233 repo = pldm_pdr_init(); 234 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 235 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 236 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 237 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 238 pldm_pdr_remove_remote_pdrs(repo); 239 EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u); 240 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 241 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 242 EXPECT_EQ(pldm_pdr_get_record_count(repo), 5u); 243 pldm_pdr_destroy(repo); 244 245 repo = pldm_pdr_init(); 246 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 247 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 248 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 249 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 250 pldm_pdr_remove_remote_pdrs(repo); 251 EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u); 252 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 253 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 254 EXPECT_EQ(pldm_pdr_get_record_count(repo), 5u); 255 pldm_pdr_destroy(repo); 256 257 repo = pldm_pdr_init(); 258 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 259 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 260 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 261 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 262 pldm_pdr_remove_remote_pdrs(repo); 263 EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u); 264 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 265 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 266 EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u); 267 pldm_pdr_destroy(repo); 268 269 repo = pldm_pdr_init(); 270 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 271 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 272 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 273 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 274 pldm_pdr_remove_remote_pdrs(repo); 275 EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u); 276 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 277 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 278 EXPECT_EQ(pldm_pdr_get_record_count(repo), 5u); 279 pldm_pdr_destroy(repo); 280 281 repo = pldm_pdr_init(); 282 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 283 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 284 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 285 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 286 pldm_pdr_remove_remote_pdrs(repo); 287 EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u); 288 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 289 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 290 EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u); 291 pldm_pdr_destroy(repo); 292 293 repo = pldm_pdr_init(); 294 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 295 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 296 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 297 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 298 pldm_pdr_remove_remote_pdrs(repo); 299 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 300 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 301 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 302 EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u); 303 pldm_pdr_destroy(repo); 304 305 repo = pldm_pdr_init(); 306 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 307 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 308 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 309 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 310 pldm_pdr_remove_remote_pdrs(repo); 311 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 312 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 313 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 314 EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u); 315 pldm_pdr_destroy(repo); 316 317 repo = pldm_pdr_init(); 318 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 319 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 320 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 321 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 322 pldm_pdr_remove_remote_pdrs(repo); 323 EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u); 324 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 325 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 326 EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u); 327 pldm_pdr_destroy(repo); 328 329 repo = pldm_pdr_init(); 330 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 331 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 332 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, NULL), 0); 333 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, NULL), 0); 334 pldm_pdr_remove_remote_pdrs(repo); 335 EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u); 336 uint32_t handle = 0; 337 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &handle), 338 0); 339 EXPECT_EQ(handle, 3u); 340 handle = 0; 341 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, &handle), 342 0); 343 EXPECT_EQ(handle, 4u); 344 EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u); 345 pldm_pdr_destroy(repo); 346 } 347 348 TEST(PDRAccess, testGet) 349 { 350 auto repo = pldm_pdr_init(); 351 352 std::array<uint32_t, 10> in{100, 345, 3, 6, 89, 0, 11, 45, 23434, 123123}; 353 uint32_t handle = 1; 354 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 355 EXPECT_EQ(pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in.data()), 356 sizeof(in), false, 1, &handle), 357 0); 358 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 359 EXPECT_EQ(pldm_pdr_get_repo_size(repo), sizeof(in)); 360 uint32_t size{}; 361 uint32_t nextRecHdl{}; 362 uint8_t* outData = nullptr; 363 auto hdl = pldm_pdr_find_record(repo, 0, &outData, &size, &nextRecHdl); 364 EXPECT_NE(hdl, nullptr); 365 EXPECT_EQ(size, sizeof(in)); 366 EXPECT_EQ(nextRecHdl, 0u); 367 EXPECT_EQ(memcmp(outData, in.data(), sizeof(in)), 0); 368 outData = nullptr; 369 370 auto hdl2 = pldm_pdr_find_record(repo, 1, &outData, &size, &nextRecHdl); 371 EXPECT_EQ(hdl, hdl2); 372 EXPECT_NE(hdl, nullptr); 373 EXPECT_EQ(size, sizeof(in)); 374 EXPECT_EQ(nextRecHdl, 0u); 375 EXPECT_EQ(memcmp(outData, in.data(), sizeof(in)), 0); 376 outData = nullptr; 377 378 hdl = pldm_pdr_find_record(repo, htole32(0xdeaddead), &outData, &size, 379 &nextRecHdl); 380 EXPECT_EQ(hdl, nullptr); 381 EXPECT_EQ(size, 0u); 382 EXPECT_EQ(nextRecHdl, 0u); 383 EXPECT_EQ(outData, nullptr); 384 outData = nullptr; 385 386 std::array<uint32_t, 10> in2{1000, 3450, 30, 60, 890, 387 0, 110, 450, 234034, 123123}; 388 handle = 2; 389 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 390 EXPECT_EQ(pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in2.data()), 391 sizeof(in2), false, 1, &handle), 392 0); 393 handle = 3; 394 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 395 EXPECT_EQ(pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in2.data()), 396 sizeof(in2), false, 1, &handle), 397 0); 398 handle = 4; 399 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 400 EXPECT_EQ(pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in2.data()), 401 sizeof(in2), true, 1, &handle), 402 0); 403 EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u); 404 EXPECT_EQ(pldm_pdr_get_repo_size(repo), sizeof(in2) * 4); 405 hdl = pldm_pdr_find_record(repo, 0, &outData, &size, &nextRecHdl); 406 EXPECT_NE(hdl, nullptr); 407 EXPECT_EQ(size, sizeof(in)); 408 EXPECT_EQ(nextRecHdl, 2u); 409 EXPECT_EQ(memcmp(outData, in.data(), sizeof(in)), 0); 410 outData = nullptr; 411 hdl2 = pldm_pdr_find_record(repo, 1, &outData, &size, &nextRecHdl); 412 EXPECT_EQ(hdl, hdl2); 413 EXPECT_NE(hdl, nullptr); 414 EXPECT_EQ(size, sizeof(in)); 415 EXPECT_EQ(nextRecHdl, 2u); 416 EXPECT_EQ(memcmp(outData, in.data(), sizeof(in)), 0); 417 outData = nullptr; 418 hdl = pldm_pdr_find_record(repo, 2, &outData, &size, &nextRecHdl); 419 EXPECT_NE(hdl, nullptr); 420 EXPECT_EQ(size, sizeof(in2)); 421 EXPECT_EQ(nextRecHdl, 3u); 422 EXPECT_EQ(memcmp(outData, in2.data(), sizeof(in2)), 0); 423 outData = nullptr; 424 hdl = pldm_pdr_find_record(repo, 3, &outData, &size, &nextRecHdl); 425 EXPECT_NE(hdl, nullptr); 426 EXPECT_EQ(pldm_pdr_record_is_remote(hdl), false); 427 EXPECT_EQ(size, sizeof(in2)); 428 EXPECT_EQ(nextRecHdl, 4u); 429 EXPECT_EQ(memcmp(outData, in2.data(), sizeof(in2)), 0); 430 outData = nullptr; 431 hdl = pldm_pdr_find_record(repo, 4, &outData, &size, &nextRecHdl); 432 EXPECT_NE(hdl, nullptr); 433 EXPECT_EQ(pldm_pdr_record_is_remote(hdl), true); 434 EXPECT_EQ(size, sizeof(in2)); 435 EXPECT_EQ(nextRecHdl, 0u); 436 EXPECT_EQ(memcmp(outData, in2.data(), sizeof(in2)), 0); 437 outData = nullptr; 438 439 pldm_pdr_destroy(repo); 440 } 441 442 TEST(PDRAccess, testGetNext) 443 { 444 auto repo = pldm_pdr_init(); 445 446 std::array<uint32_t, 10> in{100, 345, 3, 6, 89, 0, 11, 45, 23434, 123123}; 447 uint32_t handle = 1; 448 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 449 EXPECT_EQ(pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in.data()), 450 sizeof(in), false, 1, &handle), 451 0); 452 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 453 EXPECT_EQ(pldm_pdr_get_repo_size(repo), sizeof(in)); 454 uint32_t size{}; 455 uint32_t nextRecHdl{}; 456 uint8_t* outData = nullptr; 457 auto hdl = pldm_pdr_find_record(repo, 0, &outData, &size, &nextRecHdl); 458 EXPECT_NE(hdl, nullptr); 459 EXPECT_EQ(size, sizeof(in)); 460 EXPECT_EQ(nextRecHdl, 0u); 461 EXPECT_EQ(memcmp(outData, in.data(), sizeof(in)), 0); 462 outData = nullptr; 463 464 std::array<uint32_t, 10> in2{1000, 3450, 30, 60, 890, 465 0, 110, 450, 234034, 123123}; 466 handle = 2; 467 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 468 EXPECT_EQ(pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in2.data()), 469 sizeof(in2), false, 1, &handle), 470 0); 471 handle = 3; 472 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 473 EXPECT_EQ(pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in2.data()), 474 sizeof(in2), false, 1, &handle), 475 0); 476 handle = 4; 477 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 478 EXPECT_EQ(pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in2.data()), 479 sizeof(in2), false, 1, &handle), 480 0); 481 EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u); 482 EXPECT_EQ(pldm_pdr_get_repo_size(repo), sizeof(in2) * 4); 483 hdl = pldm_pdr_get_next_record(repo, hdl, &outData, &size, &nextRecHdl); 484 EXPECT_NE(hdl, nullptr); 485 EXPECT_EQ(size, sizeof(in2)); 486 EXPECT_EQ(nextRecHdl, 3u); 487 EXPECT_EQ(memcmp(outData, in2.data(), sizeof(in2)), 0); 488 outData = nullptr; 489 hdl = pldm_pdr_get_next_record(repo, hdl, &outData, &size, &nextRecHdl); 490 EXPECT_NE(hdl, nullptr); 491 EXPECT_EQ(size, sizeof(in2)); 492 EXPECT_EQ(nextRecHdl, 4u); 493 EXPECT_EQ(memcmp(outData, in2.data(), sizeof(in2)), 0); 494 outData = nullptr; 495 hdl = pldm_pdr_get_next_record(repo, hdl, &outData, &size, &nextRecHdl); 496 EXPECT_NE(hdl, nullptr); 497 EXPECT_EQ(size, sizeof(in2)); 498 EXPECT_EQ(nextRecHdl, 0u); 499 EXPECT_EQ(memcmp(outData, in2.data(), sizeof(in2)), 0); 500 outData = nullptr; 501 502 pldm_pdr_destroy(repo); 503 } 504 505 TEST(PDRAccess, testFindByType) 506 { 507 auto repo = pldm_pdr_init(); 508 509 std::array<uint8_t, sizeof(pldm_pdr_hdr)> data{}; 510 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 511 pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(data.data()); 512 hdr->type = 1; 513 uint32_t first = 0; 514 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &first), 515 0); 516 hdr->type = 2; 517 uint32_t second = 0; 518 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &second), 519 0); 520 hdr->type = 3; 521 uint32_t third = 0; 522 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &third), 523 0); 524 hdr->type = 4; 525 uint32_t fourth = 0; 526 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &fourth), 527 0); 528 529 uint8_t* outData = nullptr; 530 uint32_t size{}; 531 auto firstRec = 532 pldm_pdr_find_record_by_type(repo, 1, nullptr, &outData, &size); 533 EXPECT_EQ(pldm_pdr_get_record_handle(repo, firstRec), first); 534 outData = nullptr; 535 auto secondRec = 536 pldm_pdr_find_record_by_type(repo, 2, nullptr, &outData, &size); 537 EXPECT_EQ(pldm_pdr_get_record_handle(repo, secondRec), second); 538 outData = nullptr; 539 auto thirdRec = 540 pldm_pdr_find_record_by_type(repo, 3, nullptr, &outData, &size); 541 EXPECT_EQ(pldm_pdr_get_record_handle(repo, thirdRec), third); 542 outData = nullptr; 543 auto fourthRec = 544 pldm_pdr_find_record_by_type(repo, 4, nullptr, &outData, &size); 545 EXPECT_EQ(pldm_pdr_get_record_handle(repo, fourthRec), fourth); 546 outData = nullptr; 547 auto fifthRec = 548 pldm_pdr_find_record_by_type(repo, 5, nullptr, &outData, &size); 549 EXPECT_EQ(fifthRec, nullptr); 550 EXPECT_EQ(outData, nullptr); 551 EXPECT_EQ(size, 0u); 552 553 auto rec = 554 pldm_pdr_find_record_by_type(repo, 3, secondRec, &outData, &size); 555 EXPECT_EQ(pldm_pdr_get_record_handle(repo, rec), third); 556 outData = nullptr; 557 rec = pldm_pdr_find_record_by_type(repo, 4, secondRec, &outData, &size); 558 EXPECT_EQ(pldm_pdr_get_record_handle(repo, rec), fourth); 559 outData = nullptr; 560 rec = pldm_pdr_find_record_by_type(repo, 2, firstRec, &outData, &size); 561 EXPECT_EQ(pldm_pdr_get_record_handle(repo, rec), second); 562 outData = nullptr; 563 564 pldm_pdr_destroy(repo); 565 } 566 567 TEST(PDRUpdate, testAddFruRecordSet) 568 { 569 auto repo = pldm_pdr_init(); 570 571 uint32_t handle = 0; 572 EXPECT_EQ(pldm_pdr_add_fru_record_set(repo, 1, 10, 1, 0, 100, &handle), 0); 573 EXPECT_EQ(handle, 1u); 574 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 575 EXPECT_EQ(pldm_pdr_get_repo_size(repo), 576 sizeof(pldm_pdr_hdr) + sizeof(pldm_pdr_fru_record_set)); 577 uint32_t size{}; 578 uint32_t nextRecHdl{}; 579 uint8_t* outData = nullptr; 580 auto hdl = pldm_pdr_find_record(repo, 0, &outData, &size, &nextRecHdl); 581 EXPECT_NE(hdl, nullptr); 582 EXPECT_EQ(size, sizeof(pldm_pdr_hdr) + sizeof(pldm_pdr_fru_record_set)); 583 EXPECT_EQ(nextRecHdl, 0u); 584 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 585 pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(outData); 586 EXPECT_EQ(hdr->version, 1u); 587 EXPECT_EQ(hdr->type, PLDM_PDR_FRU_RECORD_SET); 588 EXPECT_EQ(hdr->length, htole16(sizeof(pldm_pdr_fru_record_set))); 589 EXPECT_EQ(hdr->record_handle, htole32(1)); 590 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 591 pldm_pdr_fru_record_set* fru = reinterpret_cast<pldm_pdr_fru_record_set*>( 592 outData + sizeof(pldm_pdr_hdr)); 593 EXPECT_EQ(fru->terminus_handle, htole16(1)); 594 EXPECT_EQ(fru->fru_rsi, htole16(10)); 595 EXPECT_EQ(fru->entity_type, htole16(1)); 596 EXPECT_EQ(fru->entity_instance_num, htole16(0)); 597 EXPECT_EQ(fru->container_id, htole16(100)); 598 outData = nullptr; 599 600 handle = 0; 601 EXPECT_EQ(pldm_pdr_add_fru_record_set(repo, 2, 11, 2, 1, 101, &handle), 0); 602 EXPECT_EQ(handle, 2u); 603 EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u); 604 EXPECT_EQ(pldm_pdr_get_repo_size(repo), 605 2 * (sizeof(pldm_pdr_hdr) + sizeof(pldm_pdr_fru_record_set))); 606 hdl = pldm_pdr_find_record(repo, 2, &outData, &size, &nextRecHdl); 607 EXPECT_NE(hdl, nullptr); 608 EXPECT_EQ(size, sizeof(pldm_pdr_hdr) + sizeof(pldm_pdr_fru_record_set)); 609 EXPECT_EQ(nextRecHdl, 0u); 610 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 611 hdr = reinterpret_cast<pldm_pdr_hdr*>(outData); 612 EXPECT_EQ(hdr->version, 1u); 613 EXPECT_EQ(hdr->type, PLDM_PDR_FRU_RECORD_SET); 614 EXPECT_EQ(hdr->length, htole16(sizeof(pldm_pdr_fru_record_set))); 615 EXPECT_EQ(hdr->record_handle, htole32(2)); 616 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 617 fru = reinterpret_cast<pldm_pdr_fru_record_set*>(outData + 618 sizeof(pldm_pdr_hdr)); 619 EXPECT_EQ(fru->terminus_handle, htole16(2)); 620 EXPECT_EQ(fru->fru_rsi, htole16(11)); 621 EXPECT_EQ(fru->entity_type, htole16(2)); 622 EXPECT_EQ(fru->entity_instance_num, htole16(1)); 623 EXPECT_EQ(fru->container_id, htole16(101)); 624 outData = nullptr; 625 626 hdl = pldm_pdr_find_record(repo, 1, &outData, &size, &nextRecHdl); 627 EXPECT_NE(hdl, nullptr); 628 EXPECT_EQ(size, sizeof(pldm_pdr_hdr) + sizeof(pldm_pdr_fru_record_set)); 629 EXPECT_EQ(nextRecHdl, 2u); 630 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 631 hdr = reinterpret_cast<pldm_pdr_hdr*>(outData); 632 EXPECT_EQ(hdr->version, 1u); 633 EXPECT_EQ(hdr->type, PLDM_PDR_FRU_RECORD_SET); 634 EXPECT_EQ(hdr->length, htole16(sizeof(pldm_pdr_fru_record_set))); 635 EXPECT_EQ(hdr->record_handle, htole32(1)); 636 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 637 fru = reinterpret_cast<pldm_pdr_fru_record_set*>(outData + 638 sizeof(pldm_pdr_hdr)); 639 EXPECT_EQ(fru->terminus_handle, htole16(1)); 640 EXPECT_EQ(fru->fru_rsi, htole16(10)); 641 EXPECT_EQ(fru->entity_type, htole16(1)); 642 EXPECT_EQ(fru->entity_instance_num, htole16(0)); 643 EXPECT_EQ(fru->container_id, htole16(100)); 644 outData = nullptr; 645 646 pldm_pdr_destroy(repo); 647 } 648 649 TEST(PDRUpdate, tesFindtFruRecordSet) 650 { 651 auto repo = pldm_pdr_init(); 652 653 uint16_t terminusHdl{}; 654 uint16_t entityType{}; 655 uint16_t entityInstanceNum{}; 656 uint16_t containerId{}; 657 uint32_t first = 1; 658 EXPECT_EQ(pldm_pdr_add_fru_record_set(repo, 1, 1, 1, 0, 100, &first), 0); 659 uint32_t second = 2; 660 EXPECT_EQ(pldm_pdr_add_fru_record_set(repo, 1, 2, 1, 1, 100, &second), 0); 661 uint32_t third = 3; 662 EXPECT_EQ(pldm_pdr_add_fru_record_set(repo, 1, 3, 1, 2, 100, &third), 0); 663 EXPECT_EQ(first, pldm_pdr_get_record_handle( 664 repo, pldm_pdr_fru_record_set_find_by_rsi( 665 repo, 1, &terminusHdl, &entityType, 666 &entityInstanceNum, &containerId))); 667 EXPECT_EQ(second, pldm_pdr_get_record_handle( 668 repo, pldm_pdr_fru_record_set_find_by_rsi( 669 repo, 2, &terminusHdl, &entityType, 670 &entityInstanceNum, &containerId))); 671 EXPECT_EQ(third, pldm_pdr_get_record_handle( 672 repo, pldm_pdr_fru_record_set_find_by_rsi( 673 repo, 3, &terminusHdl, &entityType, 674 &entityInstanceNum, &containerId))); 675 EXPECT_EQ(terminusHdl, 1u); 676 EXPECT_EQ(entityType, 1u); 677 EXPECT_EQ(entityInstanceNum, 2u); 678 EXPECT_EQ(containerId, 100u); 679 EXPECT_EQ(nullptr, pldm_pdr_fru_record_set_find_by_rsi( 680 repo, 4, &terminusHdl, &entityType, 681 &entityInstanceNum, &containerId)); 682 683 pldm_pdr_destroy(repo); 684 } 685 686 #ifdef LIBPLDM_API_TESTING 687 TEST(PDRUpdate, testFindLastInRange) 688 { 689 auto repo = pldm_pdr_init(); 690 691 std::array<uint8_t, 10> data{}; 692 uint32_t handle1 = 0; 693 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &handle1), 694 0); 695 uint32_t handle2 = 23; 696 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &handle2), 697 0); 698 uint32_t handle3 = 77; 699 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &handle3), 700 0); 701 uint32_t handle4 = 16777325; 702 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, &handle4), 703 0); 704 uint32_t handle5 = 16777344; 705 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), true, 1, &handle5), 706 0); 707 708 auto rec1 = pldm_pdr_find_last_in_range(repo, 0, 100); 709 auto rec2 = pldm_pdr_find_last_in_range(repo, 16777300, 33554431); 710 EXPECT_NE(rec1, nullptr); 711 EXPECT_NE(rec2, nullptr); 712 EXPECT_NE(handle1, pldm_pdr_get_record_handle(repo, rec1)); 713 EXPECT_NE(handle2, pldm_pdr_get_record_handle(repo, rec1)); 714 EXPECT_EQ(handle3, pldm_pdr_get_record_handle(repo, rec1)); 715 EXPECT_NE(handle4, pldm_pdr_get_record_handle(repo, rec2)); 716 EXPECT_EQ(handle5, pldm_pdr_get_record_handle(repo, rec2)); 717 718 pldm_pdr_destroy(repo); 719 } 720 #endif 721 722 #ifdef LIBPLDM_API_TESTING 723 TEST(PDRAccess, testRemoveBySensorIDDecodeFailure) 724 { 725 auto repo = pldm_pdr_init(); 726 ASSERT_NE(repo, nullptr); 727 728 // Create a deliberately undersized PDR record 729 size_t invalidPdrSize = sizeof(pldm_state_sensor_pdr) - 4; // Invalid size 730 std::vector<uint8_t> entry(invalidPdrSize, 0); 731 pldm_state_sensor_pdr* pdr = new (entry.data()) pldm_state_sensor_pdr; 732 pdr->hdr.type = PLDM_STATE_SENSOR_PDR; 733 pdr->sensor_id = 50; // random ID 734 735 uint32_t record_handle = 0; 736 EXPECT_EQ(pldm_pdr_add(repo, entry.data(), entry.size(), false, 1, 737 &record_handle), 738 0); 739 // Attempt to delete the malformed record by effecter_id 740 uint32_t removed_record_handle = 0; 741 int rc = 742 pldm_pdr_delete_by_sensor_id(repo, 50, false, &removed_record_handle); 743 744 // We expect a failure from decode_pldm_state_effecter_pdr 745 EXPECT_NE(rc, 0); 746 EXPECT_EQ(pldm_pdr_get_record_count(repo), 747 1u); // Record remains in the repo 748 749 pldm_pdr_destroy(repo); 750 } 751 #endif 752 753 #ifdef LIBPLDM_API_TESTING 754 TEST(PDRAccess, testRemoveBySensorID) 755 { 756 auto repo = pldm_pdr_init(); 757 ASSERT_NE(repo, nullptr); 758 759 size_t pdrSize = 0; 760 pdrSize = 761 sizeof(pldm_state_sensor_pdr) + sizeof(state_sensor_possible_states); 762 std::vector<uint8_t> entry{}; 763 entry.resize(pdrSize); 764 765 pldm_state_sensor_pdr* pdr = new (entry.data()) pldm_state_sensor_pdr; 766 767 pdr->hdr.type = PLDM_STATE_SENSOR_PDR; 768 pdr->sensor_id = 1; 769 uint32_t handle = 1; 770 EXPECT_EQ(pldm_pdr_add(repo, entry.data(), entry.size(), false, 1, &handle), 771 0); 772 773 pdr->sensor_id = 2; 774 handle = 2; 775 EXPECT_EQ(pldm_pdr_add(repo, entry.data(), entry.size(), false, 1, &handle), 776 0); 777 778 pdr->sensor_id = 10; 779 handle = 0; 780 EXPECT_EQ(pldm_pdr_add(repo, entry.data(), entry.size(), false, 1, &handle), 781 0); 782 783 pdr->sensor_id = 20; 784 handle = 10; 785 EXPECT_EQ(pldm_pdr_add(repo, entry.data(), entry.size(), false, 1, &handle), 786 0); 787 788 EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u); 789 790 uint32_t removed_record_handle{}; 791 int rc = 792 pldm_pdr_delete_by_sensor_id(repo, 1, false, &removed_record_handle); 793 EXPECT_EQ(rc, 0); 794 EXPECT_EQ(removed_record_handle, 1); 795 EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u); 796 797 // Error case where the effceter ID is not present in the repo 798 uint32_t removed_rec_handle{}; 799 rc = pldm_pdr_delete_by_sensor_id(repo, 15, false, &removed_rec_handle); 800 EXPECT_EQ(rc, -ENOENT); 801 EXPECT_EQ(removed_rec_handle, 0); 802 EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u); 803 804 rc = pldm_pdr_delete_by_sensor_id(repo, 10, false, &removed_record_handle); 805 EXPECT_EQ(rc, 0); 806 EXPECT_EQ(removed_record_handle, 3); 807 EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u); 808 809 pldm_pdr_destroy(repo); 810 } 811 #endif 812 813 #ifdef LIBPLDM_API_TESTING 814 TEST(PDRAccess, testGetTerminusHandle) 815 { 816 817 auto repo = pldm_pdr_init(); 818 819 pldm_pdr_hdr hdr; 820 821 hdr.type = 1; 822 uint16_t firstTerminusHandle = 1; 823 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 824 EXPECT_EQ(pldm_pdr_add(repo, reinterpret_cast<const uint8_t*>(&hdr), 825 sizeof(hdr), false, firstTerminusHandle, NULL), 826 0); 827 828 hdr.type = 2; 829 uint16_t secondTerminusHandle = 2; 830 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 831 EXPECT_EQ(pldm_pdr_add(repo, reinterpret_cast<const uint8_t*>(&hdr), 832 sizeof(hdr), true, secondTerminusHandle, NULL), 833 0); 834 835 hdr.type = 3; 836 uint16_t thirdTerminusHandle = 3; 837 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 838 EXPECT_EQ(pldm_pdr_add(repo, reinterpret_cast<const uint8_t*>(&hdr), 839 sizeof(hdr), true, thirdTerminusHandle, NULL), 840 0); 841 842 uint8_t* outData = nullptr; 843 uint32_t size{}; 844 845 auto firstRec = 846 pldm_pdr_find_record_by_type(repo, 1, nullptr, &outData, &size); 847 EXPECT_EQ(pldm_pdr_get_terminus_handle(repo, firstRec), 848 firstTerminusHandle); 849 outData = nullptr; 850 851 auto secondRec = 852 pldm_pdr_find_record_by_type(repo, 2, nullptr, &outData, &size); 853 EXPECT_EQ(pldm_pdr_get_terminus_handle(repo, secondRec), 854 secondTerminusHandle); 855 outData = nullptr; 856 857 auto thirdRec = 858 pldm_pdr_find_record_by_type(repo, 3, nullptr, &outData, &size); 859 EXPECT_EQ(pldm_pdr_get_terminus_handle(repo, thirdRec), 860 thirdTerminusHandle); 861 outData = nullptr; 862 863 pldm_pdr_destroy(repo); 864 } 865 #endif 866 867 TEST(PDRAccess, testRemoveByRecordHandle) 868 { 869 std::array<uint8_t, sizeof(pldm_pdr_hdr)> data{}; 870 871 auto repo = pldm_pdr_init(); 872 uint32_t first = 0; 873 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &first), 874 0); 875 876 uint32_t second = 0; 877 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &second), 878 0); 879 880 uint32_t third = 0; 881 EXPECT_EQ(pldm_pdr_add(repo, data.data(), data.size(), false, 1, &third), 882 0); 883 884 EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u); 885 886 int rc = pldm_pdr_delete_by_record_handle(repo, 1, false); 887 EXPECT_EQ(rc, 0); 888 EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u); 889 890 rc = pldm_pdr_delete_by_record_handle(repo, 2, false); 891 EXPECT_EQ(rc, 0); 892 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 893 894 pldm_pdr_destroy(repo); 895 } 896 897 #ifdef LIBPLDM_API_TESTING 898 TEST(PDRAccess, testRemoveByEffecterIDDecodeFailure) 899 { 900 auto repo = pldm_pdr_init(); 901 ASSERT_NE(repo, nullptr); 902 903 // Create a deliberately undersized PDR record 904 size_t invalidPdrSize = sizeof(pldm_state_effecter_pdr) - 5; // Invalid size 905 std::vector<uint8_t> entry(invalidPdrSize, 0); 906 pldm_state_effecter_pdr* pdr = new (entry.data()) pldm_state_effecter_pdr; 907 pdr->hdr.type = PLDM_STATE_EFFECTER_PDR; 908 pdr->effecter_id = 99; // random ID 909 910 uint32_t record_handle = 0; 911 EXPECT_EQ(pldm_pdr_add(repo, entry.data(), entry.size(), false, 1, 912 &record_handle), 913 0); 914 915 // Attempt to delete the malformed record by effecter_id 916 uint32_t removed_record_handle = 0; 917 int rc = 918 pldm_pdr_delete_by_effecter_id(repo, 99, false, &removed_record_handle); 919 920 // We expect a failure from decode_pldm_state_effecter_pdr 921 EXPECT_NE(rc, 0); 922 EXPECT_EQ(pldm_pdr_get_record_count(repo), 923 1u); // Record remains in the repo 924 pldm_pdr_destroy(repo); 925 } 926 #endif 927 928 #ifdef LIBPLDM_API_TESTING 929 TEST(PDRAccess, testRemoveByEffecterID) 930 { 931 auto repo = pldm_pdr_init(); 932 ASSERT_NE(repo, nullptr); 933 934 size_t pdrSize = 0; 935 pdrSize = sizeof(pldm_state_effecter_pdr) + 936 sizeof(state_effecter_possible_states); 937 std::vector<uint8_t> entry{}; 938 entry.resize(pdrSize); 939 940 pldm_state_effecter_pdr* pdr = new (entry.data()) pldm_state_effecter_pdr; 941 pdr->hdr.type = PLDM_STATE_EFFECTER_PDR; 942 943 pdr->effecter_id = 1; 944 uint32_t first = 0; 945 EXPECT_EQ(pldm_pdr_add(repo, entry.data(), entry.size(), false, 1, &first), 946 0); 947 948 pdr->effecter_id = 2; 949 uint32_t second = 0; 950 EXPECT_EQ(pldm_pdr_add(repo, entry.data(), entry.size(), false, 1, &second), 951 0); 952 953 pdr->effecter_id = 10; 954 uint32_t third = 0; 955 EXPECT_EQ(pldm_pdr_add(repo, entry.data(), entry.size(), false, 1, &third), 956 0); 957 958 pdr->effecter_id = 20; 959 uint32_t fourth = 0; 960 EXPECT_EQ(pldm_pdr_add(repo, entry.data(), entry.size(), false, 1, &fourth), 961 0); 962 963 EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u); 964 965 uint32_t removed_record_handle{}; 966 int rc = 967 pldm_pdr_delete_by_effecter_id(repo, 1, false, &removed_record_handle); 968 EXPECT_EQ(rc, 0); 969 EXPECT_EQ(removed_record_handle, 1); 970 EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u); 971 972 // Error case where the effceter ID is not present in the repo 973 uint32_t removed_rec_handle{}; 974 rc = pldm_pdr_delete_by_effecter_id(repo, 15, false, &removed_rec_handle); 975 EXPECT_EQ(rc, 0); 976 EXPECT_EQ(removed_rec_handle, 0); 977 EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u); 978 979 rc = 980 pldm_pdr_delete_by_effecter_id(repo, 20, false, &removed_record_handle); 981 EXPECT_EQ(rc, 0); 982 EXPECT_EQ(removed_record_handle, 4); 983 EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u); 984 985 pldm_pdr_destroy(repo); 986 } 987 #endif 988 989 TEST(EntityAssociationPDR, testInit) 990 { 991 auto tree = pldm_entity_association_tree_init(); 992 EXPECT_NE(tree, nullptr); 993 pldm_entity_association_tree_destroy(tree); 994 } 995 996 TEST(EntityAssociationPDR, testBuild) 997 { 998 // 1 999 // | 1000 // 2--3--4 1001 // | 1002 // 5--6--7 1003 // | | 1004 // 9 8 1005 1006 pldm_entity entities[9]{}; 1007 1008 entities[0].entity_type = 1; 1009 entities[1].entity_type = 2; 1010 entities[2].entity_type = 2; 1011 entities[3].entity_type = 3; 1012 entities[4].entity_type = 4; 1013 entities[5].entity_type = 5; 1014 entities[6].entity_type = 5; 1015 entities[7].entity_type = 6; 1016 entities[8].entity_type = 7; 1017 1018 auto tree = pldm_entity_association_tree_init(); 1019 1020 auto l1 = pldm_entity_association_tree_add( 1021 tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1022 EXPECT_NE(l1, nullptr); 1023 auto l2a = pldm_entity_association_tree_add( 1024 tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1025 EXPECT_NE(l2a, nullptr); 1026 auto l2b = pldm_entity_association_tree_add( 1027 tree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1028 EXPECT_NE(l2b, nullptr); 1029 auto l2c = pldm_entity_association_tree_add( 1030 tree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1031 EXPECT_NE(l2c, nullptr); 1032 auto l3a = pldm_entity_association_tree_add( 1033 tree, &entities[4], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1034 EXPECT_NE(l3a, nullptr); 1035 auto l3b = pldm_entity_association_tree_add( 1036 tree, &entities[5], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1037 EXPECT_NE(l3b, nullptr); 1038 auto l3c = pldm_entity_association_tree_add( 1039 tree, &entities[6], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1040 EXPECT_NE(l3b, nullptr); 1041 auto l4a = pldm_entity_association_tree_add( 1042 tree, &entities[7], 0xffff, l3a, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1043 EXPECT_NE(l4a, nullptr); 1044 auto l4b = pldm_entity_association_tree_add( 1045 tree, &entities[8], 0xffff, l3b, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1046 EXPECT_NE(l4b, nullptr); 1047 1048 EXPECT_EQ(pldm_entity_is_node_parent(l1), true); 1049 EXPECT_EQ(pldm_entity_is_node_parent(l2a), true); 1050 EXPECT_EQ(pldm_entity_is_node_parent(l3a), true); 1051 EXPECT_EQ(pldm_entity_is_node_parent(l3b), true); 1052 1053 EXPECT_EQ(pldm_entity_is_node_parent(l2b), false); 1054 EXPECT_EQ(pldm_entity_is_node_parent(l2c), false); 1055 EXPECT_EQ(pldm_entity_is_node_parent(l3c), false); 1056 EXPECT_EQ(pldm_entity_is_node_parent(l4a), false); 1057 EXPECT_EQ(pldm_entity_is_node_parent(l4b), false); 1058 1059 EXPECT_EQ(pldm_entity_is_exist_parent(l1), false); 1060 1061 pldm_entity nodeL1 = pldm_entity_extract(l1); 1062 pldm_entity parentL2a = pldm_entity_get_parent(l2a); 1063 pldm_entity parentL2b = pldm_entity_get_parent(l2b); 1064 pldm_entity parentL2c = pldm_entity_get_parent(l2c); 1065 EXPECT_EQ(pldm_entity_is_exist_parent(l2a), true); 1066 EXPECT_EQ(pldm_entity_is_exist_parent(l2b), true); 1067 EXPECT_EQ(pldm_entity_is_exist_parent(l2c), true); 1068 EXPECT_EQ(parentL2a.entity_type, nodeL1.entity_type); 1069 EXPECT_EQ(parentL2a.entity_instance_num, nodeL1.entity_instance_num); 1070 EXPECT_EQ(parentL2a.entity_container_id, nodeL1.entity_container_id); 1071 EXPECT_EQ(parentL2b.entity_type, nodeL1.entity_type); 1072 EXPECT_EQ(parentL2b.entity_instance_num, nodeL1.entity_instance_num); 1073 EXPECT_EQ(parentL2b.entity_container_id, nodeL1.entity_container_id); 1074 EXPECT_EQ(parentL2c.entity_type, nodeL1.entity_type); 1075 EXPECT_EQ(parentL2c.entity_instance_num, nodeL1.entity_instance_num); 1076 EXPECT_EQ(parentL2c.entity_container_id, nodeL1.entity_container_id); 1077 1078 pldm_entity nodeL2a = pldm_entity_extract(l2a); 1079 pldm_entity parentL3a = pldm_entity_get_parent(l3a); 1080 pldm_entity parentL3b = pldm_entity_get_parent(l3b); 1081 pldm_entity parentL3c = pldm_entity_get_parent(l3c); 1082 EXPECT_EQ(pldm_entity_is_exist_parent(l3a), true); 1083 EXPECT_EQ(pldm_entity_is_exist_parent(l3b), true); 1084 EXPECT_EQ(pldm_entity_is_exist_parent(l3c), true); 1085 EXPECT_EQ(parentL3a.entity_type, nodeL2a.entity_type); 1086 EXPECT_EQ(parentL3a.entity_instance_num, nodeL2a.entity_instance_num); 1087 EXPECT_EQ(parentL3a.entity_container_id, nodeL2a.entity_container_id); 1088 EXPECT_EQ(parentL3b.entity_type, nodeL2a.entity_type); 1089 EXPECT_EQ(parentL3b.entity_instance_num, nodeL2a.entity_instance_num); 1090 EXPECT_EQ(parentL3b.entity_container_id, nodeL2a.entity_container_id); 1091 EXPECT_EQ(parentL3c.entity_type, nodeL2a.entity_type); 1092 EXPECT_EQ(parentL3c.entity_instance_num, nodeL2a.entity_instance_num); 1093 EXPECT_EQ(parentL3c.entity_container_id, nodeL2a.entity_container_id); 1094 1095 pldm_entity nodeL3a = pldm_entity_extract(l3a); 1096 pldm_entity parentL4a = pldm_entity_get_parent(l4a); 1097 EXPECT_EQ(pldm_entity_is_exist_parent(l4a), true); 1098 EXPECT_EQ(parentL4a.entity_type, nodeL3a.entity_type); 1099 EXPECT_EQ(parentL4a.entity_instance_num, nodeL3a.entity_instance_num); 1100 EXPECT_EQ(parentL4a.entity_container_id, nodeL3a.entity_container_id); 1101 1102 pldm_entity nodeL3b = pldm_entity_extract(l3b); 1103 pldm_entity parentL4b = pldm_entity_get_parent(l4b); 1104 EXPECT_EQ(pldm_entity_is_exist_parent(l4b), true); 1105 EXPECT_EQ(parentL4b.entity_type, nodeL3b.entity_type); 1106 EXPECT_EQ(parentL4b.entity_instance_num, nodeL3b.entity_instance_num); 1107 EXPECT_EQ(parentL4b.entity_container_id, nodeL3b.entity_container_id); 1108 1109 size_t num{}; 1110 pldm_entity* out = nullptr; 1111 pldm_entity_association_tree_visit(tree, &out, &num); 1112 EXPECT_EQ(num, 9u); 1113 1114 EXPECT_EQ(out[0].entity_type, 1u); 1115 EXPECT_EQ(out[0].entity_instance_num, 1u); 1116 EXPECT_EQ(out[0].entity_container_id, 0u); 1117 1118 EXPECT_EQ(out[1].entity_type, 2u); 1119 EXPECT_EQ(out[1].entity_instance_num, 1u); 1120 EXPECT_EQ(out[1].entity_container_id, 1u); 1121 EXPECT_EQ(out[2].entity_type, 2u); 1122 EXPECT_EQ(out[2].entity_instance_num, 2u); 1123 EXPECT_EQ(out[2].entity_container_id, 1u); 1124 EXPECT_EQ(out[3].entity_type, 3u); 1125 EXPECT_EQ(out[3].entity_instance_num, 1u); 1126 EXPECT_EQ(out[3].entity_container_id, 1u); 1127 1128 EXPECT_EQ(out[4].entity_type, 4u); 1129 EXPECT_EQ(out[4].entity_instance_num, 1u); 1130 EXPECT_EQ(out[4].entity_container_id, 2u); 1131 EXPECT_EQ(out[5].entity_type, 5u); 1132 EXPECT_EQ(out[5].entity_instance_num, 1u); 1133 EXPECT_EQ(out[5].entity_container_id, 2u); 1134 EXPECT_EQ(out[6].entity_type, 5u); 1135 EXPECT_EQ(out[6].entity_instance_num, 2u); 1136 EXPECT_EQ(out[6].entity_container_id, 2u); 1137 1138 EXPECT_EQ(out[7].entity_type, 7u); 1139 EXPECT_EQ(out[7].entity_instance_num, 1u); 1140 EXPECT_EQ(out[7].entity_container_id, 4u); 1141 EXPECT_EQ(out[8].entity_type, 6u); 1142 EXPECT_EQ(out[8].entity_instance_num, 1u); 1143 EXPECT_EQ(out[8].entity_container_id, 3u); 1144 1145 free(out); 1146 1147 pldm_entity p1 = pldm_entity_extract(l1); 1148 EXPECT_EQ(p1.entity_type, 1u); 1149 EXPECT_EQ(p1.entity_instance_num, 1u); 1150 EXPECT_EQ(p1.entity_container_id, 0u); 1151 1152 pldm_entity p2a = pldm_entity_extract(l2a); 1153 EXPECT_EQ(p2a.entity_type, 2u); 1154 EXPECT_EQ(p2a.entity_instance_num, 1u); 1155 EXPECT_EQ(p2a.entity_container_id, 1u); 1156 pldm_entity p2b = pldm_entity_extract(l2b); 1157 EXPECT_EQ(p2b.entity_type, 2u); 1158 EXPECT_EQ(p2b.entity_instance_num, 2u); 1159 EXPECT_EQ(p2b.entity_container_id, 1u); 1160 pldm_entity p2c = pldm_entity_extract(l2c); 1161 EXPECT_EQ(p2c.entity_type, 3u); 1162 EXPECT_EQ(p2c.entity_instance_num, 1u); 1163 EXPECT_EQ(p2c.entity_container_id, 1u); 1164 1165 pldm_entity p3a = pldm_entity_extract(l3a); 1166 EXPECT_EQ(p3a.entity_type, 4u); 1167 EXPECT_EQ(p3a.entity_instance_num, 1u); 1168 EXPECT_EQ(p3a.entity_container_id, 2u); 1169 pldm_entity p3b = pldm_entity_extract(l3b); 1170 EXPECT_EQ(p3b.entity_type, 5u); 1171 EXPECT_EQ(p3b.entity_instance_num, 1u); 1172 EXPECT_EQ(p3b.entity_container_id, 2u); 1173 pldm_entity p3c = pldm_entity_extract(l3c); 1174 EXPECT_EQ(p3c.entity_type, 5u); 1175 EXPECT_EQ(p3c.entity_instance_num, 2u); 1176 EXPECT_EQ(p3c.entity_container_id, 2u); 1177 1178 pldm_entity p4a = pldm_entity_extract(l4a); 1179 EXPECT_EQ(p4a.entity_type, 6u); 1180 EXPECT_EQ(p4a.entity_instance_num, 1u); 1181 EXPECT_EQ(p4a.entity_container_id, 3u); 1182 pldm_entity p4b = pldm_entity_extract(l4b); 1183 EXPECT_EQ(p4b.entity_type, 7u); 1184 EXPECT_EQ(p4b.entity_instance_num, 1u); 1185 EXPECT_EQ(p4b.entity_container_id, 4u); 1186 1187 pldm_entity_association_tree_destroy(tree); 1188 } 1189 1190 #if LIBPLDM_API_TESTING 1191 TEST(EntityAssociationPDR, findAndAddRemotePDR) 1192 { 1193 // Tree - 1 1194 // 1195 // 11521(1,0) 1196 // | 1197 // 45 (1,1) 1198 // | 1199 // 64 (1,2) 1200 // | 1201 // ------------------ 1202 // | | 1203 // 67(0,3) 67(1,3) 1204 // | | 1205 // 135(0,4) 135(0,5) 1206 // | | 1207 // 32903(0,6) 32903(0,7) 1208 1209 pldm_entity entities[9]{}; 1210 entities[0].entity_type = 11521; 1211 entities[1].entity_type = 45; 1212 entities[2].entity_type = 64; 1213 entities[3].entity_type = 67; 1214 entities[4].entity_type = 67; 1215 entities[5].entity_type = 135; 1216 entities[5].entity_container_id = 2; 1217 entities[6].entity_type = 135; 1218 entities[6].entity_container_id = 3; 1219 entities[7].entity_type = 32903; 1220 entities[8].entity_type = 32903; 1221 auto tree = pldm_entity_association_tree_init(); 1222 auto l1 = pldm_entity_association_tree_add_entity( 1223 tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_LOGICAL, 1224 false, true, 0xffff); 1225 EXPECT_NE(l1, nullptr); 1226 auto l2 = pldm_entity_association_tree_add_entity( 1227 tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false, 1228 false, 0xffff); 1229 EXPECT_NE(l2, nullptr); 1230 auto l3 = pldm_entity_association_tree_add_entity( 1231 tree, &entities[2], 0xffff, l2, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false, 1232 true, 0xffff); 1233 EXPECT_NE(l3, nullptr); 1234 auto l4a = pldm_entity_association_tree_add_entity( 1235 tree, &entities[3], 0, l3, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false, 1236 false, 0xffff); 1237 EXPECT_NE(l4a, nullptr); 1238 auto l4b = pldm_entity_association_tree_add_entity( 1239 tree, &entities[4], 1, l3, PLDM_ENTITY_ASSOCIAION_PHYSICAL, true, true, 1240 0xffff); 1241 EXPECT_NE(l4b, nullptr); 1242 auto l5a = pldm_entity_association_tree_add_entity( 1243 tree, &entities[5], 0, l4a, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false, 1244 false, 0xffff); 1245 EXPECT_NE(l5a, nullptr); 1246 auto l5b = pldm_entity_association_tree_add_entity( 1247 tree, &entities[6], 0, l4b, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false, 1248 false, 0xffff); 1249 EXPECT_NE(l5b, nullptr); 1250 pldm_entity entity{}; 1251 entity.entity_type = 135; 1252 entity.entity_instance_num = 0; 1253 entity.entity_container_id = 2; 1254 auto result1 = pldm_entity_association_tree_find(tree, &entity); 1255 EXPECT_EQ(result1, l5a); 1256 EXPECT_EQ(entities[5].entity_container_id, 2); 1257 auto l6a = pldm_entity_association_tree_add_entity( 1258 tree, &entities[7], 0, result1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false, 1259 false, 0xffff); 1260 EXPECT_NE(l6a, nullptr); 1261 entity.entity_type = 135; 1262 entity.entity_instance_num = 0; 1263 entity.entity_container_id = 3; 1264 auto result2 = pldm_entity_association_tree_find(tree, &entity); 1265 EXPECT_NE(result2, l5b); 1266 EXPECT_EQ(entities[6].entity_container_id, 3); 1267 auto l7a = pldm_entity_association_tree_add_entity( 1268 tree, &entities[8], 0, result2, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false, 1269 false, 0xffff); 1270 EXPECT_EQ(l7a, nullptr); 1271 pldm_entity_association_tree_destroy(tree); 1272 } 1273 #endif 1274 1275 TEST(EntityAssociationPDR, testSpecialTrees) 1276 { 1277 pldm_entity entities[3]{}; 1278 1279 entities[0].entity_type = 1; 1280 entities[1].entity_type = 2; 1281 entities[2].entity_type = 1; 1282 1283 // A 1284 auto tree = pldm_entity_association_tree_init(); 1285 auto node = pldm_entity_association_tree_add( 1286 tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1287 EXPECT_NE(node, nullptr); 1288 size_t num{}; 1289 pldm_entity* out = nullptr; 1290 pldm_entity_association_tree_visit(tree, &out, &num); 1291 EXPECT_EQ(num, 1u); 1292 EXPECT_EQ(out[0].entity_type, 1u); 1293 EXPECT_EQ(out[0].entity_instance_num, 1u); 1294 EXPECT_EQ(out[0].entity_container_id, 0u); 1295 free(out); 1296 pldm_entity_association_tree_destroy(tree); 1297 1298 // A-A-A 1299 tree = pldm_entity_association_tree_init(); 1300 node = pldm_entity_association_tree_add(tree, &entities[0], 0xffff, nullptr, 1301 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1302 EXPECT_NE(node, nullptr); 1303 node = pldm_entity_association_tree_add(tree, &entities[1], 0xffff, nullptr, 1304 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1305 EXPECT_NE(node, nullptr); 1306 node = pldm_entity_association_tree_add(tree, &entities[2], 0xffff, nullptr, 1307 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1308 EXPECT_NE(node, nullptr); 1309 pldm_entity_association_tree_visit(tree, &out, &num); 1310 EXPECT_EQ(num, 3u); 1311 EXPECT_EQ(out[0].entity_type, 1u); 1312 EXPECT_EQ(out[0].entity_instance_num, 1u); 1313 EXPECT_EQ(out[0].entity_container_id, 0u); 1314 EXPECT_EQ(out[1].entity_type, 1u); 1315 EXPECT_EQ(out[1].entity_instance_num, 2u); 1316 EXPECT_EQ(out[1].entity_container_id, 0u); 1317 EXPECT_EQ(out[2].entity_type, 2u); 1318 EXPECT_EQ(out[2].entity_instance_num, 1u); 1319 EXPECT_EQ(out[2].entity_container_id, 0u); 1320 free(out); 1321 pldm_entity_association_tree_destroy(tree); 1322 1323 // A 1324 // | 1325 // A 1326 // | 1327 // A 1328 tree = pldm_entity_association_tree_init(); 1329 node = pldm_entity_association_tree_add(tree, &entities[0], 0xffff, nullptr, 1330 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1331 EXPECT_NE(node, nullptr); 1332 auto node1 = pldm_entity_association_tree_add( 1333 tree, &entities[1], 0xffff, node, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1334 EXPECT_NE(node1, nullptr); 1335 auto node2 = pldm_entity_association_tree_add( 1336 tree, &entities[2], 0xffff, node1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1337 EXPECT_NE(node2, nullptr); 1338 pldm_entity_association_tree_visit(tree, &out, &num); 1339 EXPECT_EQ(num, 3u); 1340 EXPECT_EQ(out[0].entity_type, 1u); 1341 EXPECT_EQ(out[0].entity_instance_num, 1u); 1342 EXPECT_EQ(out[0].entity_container_id, 0u); 1343 EXPECT_EQ(out[1].entity_type, 2u); 1344 EXPECT_EQ(out[1].entity_instance_num, 1u); 1345 EXPECT_EQ(out[1].entity_container_id, 1u); 1346 EXPECT_EQ(out[2].entity_type, 1u); 1347 EXPECT_EQ(out[2].entity_instance_num, 1u); 1348 EXPECT_EQ(out[2].entity_container_id, 2u); 1349 free(out); 1350 pldm_entity_association_tree_destroy(tree); 1351 1352 // A-A 1353 // | 1354 // A-A 1355 tree = pldm_entity_association_tree_init(); 1356 node = pldm_entity_association_tree_add(tree, &entities[0], 0xffff, nullptr, 1357 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1358 EXPECT_NE(node, nullptr); 1359 node = pldm_entity_association_tree_add(tree, &entities[0], 0xffff, nullptr, 1360 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1361 EXPECT_NE(node, nullptr); 1362 node1 = pldm_entity_association_tree_add(tree, &entities[1], 0xffff, node, 1363 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1364 EXPECT_NE(node1, nullptr); 1365 node2 = pldm_entity_association_tree_add(tree, &entities[2], 0xffff, node, 1366 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1367 EXPECT_NE(node2, nullptr); 1368 pldm_entity_association_tree_visit(tree, &out, &num); 1369 EXPECT_EQ(num, 4u); 1370 EXPECT_EQ(out[0].entity_type, 1u); 1371 EXPECT_EQ(out[0].entity_instance_num, 1u); 1372 EXPECT_EQ(out[0].entity_container_id, 0u); 1373 EXPECT_EQ(out[1].entity_type, 1u); 1374 EXPECT_EQ(out[1].entity_instance_num, 2u); 1375 EXPECT_EQ(out[1].entity_container_id, 0u); 1376 EXPECT_EQ(out[2].entity_type, 2u); 1377 EXPECT_EQ(out[2].entity_instance_num, 1u); 1378 EXPECT_EQ(out[2].entity_container_id, 1u); 1379 EXPECT_EQ(out[3].entity_type, 1u); 1380 EXPECT_EQ(out[3].entity_instance_num, 1u); 1381 EXPECT_EQ(out[3].entity_container_id, 1u); 1382 free(out); 1383 pldm_entity_association_tree_destroy(tree); 1384 } 1385 1386 TEST(EntityAssociationPDR, testPDR) 1387 { 1388 // e = entity type, c = container id, i = instance num 1389 1390 // INPUT 1391 // 1(e=1)--1a(e=2) 1392 // | 1393 // 2(e=2)--3(e=2)--4(e=2)--5(e=3) 1394 // | 1395 // 6(e=4)--7(e=5)--8(e=5)--9(e=5) 1396 // | | 1397 // 11(e=6) 10(e=7) 1398 1399 // Expected OUTPUT 1400 // 1(e=1,c=0,i=1) 1401 // | 1402 // 2(e=2,c=1,i=1)--3(e=2,c=1,i=2)--4(e=3,c=1,i=1)--5(e=3,c=1,i=2) 1403 // | 1404 // 6(e=4,c=2,i=1)--7(e=5,c=2,i=1)--8(e=5,c=2,i=2)--9(e=5,c=2,i=3) 1405 // | | 1406 // 10(e=6,c=3,i=1) 11(e=7,c=4,i=1) 1407 pldm_entity entities[11]{}; 1408 1409 entities[0].entity_type = 1; 1410 entities[1].entity_type = 2; 1411 entities[2].entity_type = 3; 1412 entities[3].entity_type = 2; 1413 entities[4].entity_type = 3; 1414 entities[5].entity_type = 4; 1415 entities[6].entity_type = 5; 1416 entities[7].entity_type = 5; 1417 entities[8].entity_type = 5; 1418 entities[9].entity_type = 6; 1419 entities[10].entity_type = 7; 1420 1421 auto tree = pldm_entity_association_tree_init(); 1422 1423 auto l1 = pldm_entity_association_tree_add( 1424 tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1425 EXPECT_NE(l1, nullptr); 1426 auto l1a = pldm_entity_association_tree_add( 1427 tree, &entities[1], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1428 EXPECT_NE(l1a, nullptr); 1429 1430 auto l2a = pldm_entity_association_tree_add( 1431 tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1432 EXPECT_NE(l2a, nullptr); 1433 auto l2b = pldm_entity_association_tree_add(tree, &entities[2], 0xffff, l1, 1434 PLDM_ENTITY_ASSOCIAION_LOGICAL); 1435 EXPECT_NE(l2b, nullptr); 1436 auto l2c = pldm_entity_association_tree_add( 1437 tree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1438 EXPECT_NE(l2c, nullptr); 1439 auto l2d = pldm_entity_association_tree_add(tree, &entities[4], 0xffff, l1, 1440 PLDM_ENTITY_ASSOCIAION_LOGICAL); 1441 EXPECT_NE(l2d, nullptr); 1442 1443 auto l3a = pldm_entity_association_tree_add( 1444 tree, &entities[5], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1445 EXPECT_NE(l3a, nullptr); 1446 auto l3b = pldm_entity_association_tree_add( 1447 tree, &entities[6], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1448 EXPECT_NE(l3b, nullptr); 1449 auto l3c = pldm_entity_association_tree_add(tree, &entities[7], 0xffff, l2a, 1450 PLDM_ENTITY_ASSOCIAION_LOGICAL); 1451 EXPECT_NE(l3c, nullptr); 1452 auto l3d = pldm_entity_association_tree_add(tree, &entities[8], 0xffff, l2a, 1453 PLDM_ENTITY_ASSOCIAION_LOGICAL); 1454 EXPECT_NE(l3d, nullptr); 1455 1456 auto l4a = pldm_entity_association_tree_add( 1457 tree, &entities[9], 0xffff, l3a, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1458 EXPECT_NE(l4a, nullptr); 1459 auto l4b = pldm_entity_association_tree_add( 1460 tree, &entities[10], 0xffff, l3b, PLDM_ENTITY_ASSOCIAION_LOGICAL); 1461 EXPECT_NE(l4b, nullptr); 1462 1463 EXPECT_EQ(pldm_entity_get_num_children(l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL), 1464 2); 1465 EXPECT_EQ(pldm_entity_get_num_children(l1, PLDM_ENTITY_ASSOCIAION_LOGICAL), 1466 2); 1467 EXPECT_EQ( 1468 pldm_entity_get_num_children(l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL), 2); 1469 EXPECT_EQ( 1470 pldm_entity_get_num_children(l3b, PLDM_ENTITY_ASSOCIAION_PHYSICAL), 0); 1471 EXPECT_EQ(pldm_entity_get_num_children(l3b, PLDM_ENTITY_ASSOCIAION_LOGICAL), 1472 1); 1473 1474 auto repo = pldm_pdr_init(); 1475 int rc = pldm_entity_association_pdr_add(tree, repo, false, 1); 1476 ASSERT_EQ(rc, 0); 1477 1478 EXPECT_EQ(pldm_pdr_get_record_count(repo), 6u); 1479 1480 uint32_t currRecHandle{}; 1481 uint32_t nextRecHandle{}; 1482 uint8_t* data = nullptr; 1483 uint32_t size{}; 1484 uint32_t commonSize = sizeof(struct pldm_pdr_hdr) + sizeof(uint16_t) + 1485 sizeof(uint8_t) + sizeof(pldm_entity) + 1486 sizeof(uint8_t); 1487 1488 pldm_pdr_find_record(repo, currRecHandle, &data, &size, &nextRecHandle); 1489 EXPECT_EQ(size, commonSize + (pldm_entity_get_num_children( 1490 l1, PLDM_ENTITY_ASSOCIAION_LOGICAL) * 1491 sizeof(pldm_entity))); 1492 uint8_t* start = data; 1493 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1494 pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(start); 1495 EXPECT_EQ(le32toh(hdr->record_handle), 1u); 1496 EXPECT_EQ(hdr->type, PLDM_PDR_ENTITY_ASSOCIATION); 1497 EXPECT_EQ(le16toh(hdr->length), size - sizeof(struct pldm_pdr_hdr)); 1498 start += sizeof(pldm_pdr_hdr); 1499 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1500 uint16_t* containerId = reinterpret_cast<uint16_t*>(start); 1501 EXPECT_EQ(le16toh(*containerId), 1u); 1502 start += sizeof(uint16_t); 1503 EXPECT_EQ(*start, PLDM_ENTITY_ASSOCIAION_LOGICAL); 1504 start += sizeof(uint8_t); 1505 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1506 pldm_entity* entity = reinterpret_cast<pldm_entity*>(start); 1507 EXPECT_EQ(le16toh(entity->entity_type), 1u); 1508 EXPECT_EQ(le16toh(entity->entity_instance_num), 1u); 1509 EXPECT_EQ(le16toh(entity->entity_container_id), 0u); 1510 start += sizeof(pldm_entity); 1511 EXPECT_EQ(*start, 1512 pldm_entity_get_num_children(l1, PLDM_ENTITY_ASSOCIAION_LOGICAL)); 1513 start += sizeof(uint8_t); 1514 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1515 entity = reinterpret_cast<pldm_entity*>(start); 1516 EXPECT_EQ(le16toh(entity->entity_type), 3u); 1517 EXPECT_EQ(le16toh(entity->entity_instance_num), 1u); 1518 EXPECT_EQ(le16toh(entity->entity_container_id), 1u); 1519 start += sizeof(pldm_entity); 1520 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1521 entity = reinterpret_cast<pldm_entity*>(start); 1522 EXPECT_EQ(le16toh(entity->entity_type), 3u); 1523 EXPECT_EQ(le16toh(entity->entity_instance_num), 2u); 1524 EXPECT_EQ(le16toh(entity->entity_container_id), 1u); 1525 1526 currRecHandle = nextRecHandle; 1527 1528 pldm_pdr_find_record(repo, currRecHandle, &data, &size, &nextRecHandle); 1529 EXPECT_EQ(size, commonSize + (pldm_entity_get_num_children( 1530 l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL) * 1531 sizeof(pldm_entity))); 1532 start = data; 1533 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1534 hdr = reinterpret_cast<pldm_pdr_hdr*>(start); 1535 EXPECT_EQ(le32toh(hdr->record_handle), 2u); 1536 EXPECT_EQ(hdr->type, PLDM_PDR_ENTITY_ASSOCIATION); 1537 EXPECT_EQ(le16toh(hdr->length), size - sizeof(struct pldm_pdr_hdr)); 1538 start += sizeof(pldm_pdr_hdr); 1539 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1540 containerId = reinterpret_cast<uint16_t*>(start); 1541 EXPECT_EQ(le16toh(*containerId), 1u); 1542 start += sizeof(uint16_t); 1543 EXPECT_EQ(*start, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1544 start += sizeof(uint8_t); 1545 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1546 entity = reinterpret_cast<pldm_entity*>(start); 1547 EXPECT_EQ(le16toh(entity->entity_type), 1u); 1548 EXPECT_EQ(le16toh(entity->entity_instance_num), 1u); 1549 EXPECT_EQ(le16toh(entity->entity_container_id), 0u); 1550 start += sizeof(pldm_entity); 1551 EXPECT_EQ(*start, pldm_entity_get_num_children( 1552 l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL)); 1553 start += sizeof(uint8_t); 1554 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1555 entity = reinterpret_cast<pldm_entity*>(start); 1556 EXPECT_EQ(le16toh(entity->entity_type), 2u); 1557 EXPECT_EQ(le16toh(entity->entity_instance_num), 1u); 1558 EXPECT_EQ(le16toh(entity->entity_container_id), 1u); 1559 start += sizeof(pldm_entity); 1560 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1561 entity = reinterpret_cast<pldm_entity*>(start); 1562 EXPECT_EQ(le16toh(entity->entity_type), 2u); 1563 EXPECT_EQ(le16toh(entity->entity_instance_num), 2u); 1564 EXPECT_EQ(le16toh(entity->entity_container_id), 1u); 1565 1566 currRecHandle = nextRecHandle; 1567 1568 pldm_pdr_find_record(repo, currRecHandle, &data, &size, &nextRecHandle); 1569 EXPECT_EQ(size, commonSize + (pldm_entity_get_num_children( 1570 l2a, PLDM_ENTITY_ASSOCIAION_LOGICAL) * 1571 sizeof(pldm_entity))); 1572 start = data; 1573 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1574 hdr = reinterpret_cast<pldm_pdr_hdr*>(start); 1575 EXPECT_EQ(le32toh(hdr->record_handle), 3u); 1576 EXPECT_EQ(hdr->type, PLDM_PDR_ENTITY_ASSOCIATION); 1577 EXPECT_EQ(le16toh(hdr->length), size - sizeof(struct pldm_pdr_hdr)); 1578 start += sizeof(pldm_pdr_hdr); 1579 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1580 containerId = reinterpret_cast<uint16_t*>(start); 1581 EXPECT_EQ(le16toh(*containerId), 2u); 1582 start += sizeof(uint16_t); 1583 EXPECT_EQ(*start, PLDM_ENTITY_ASSOCIAION_LOGICAL); 1584 start += sizeof(uint8_t); 1585 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1586 entity = reinterpret_cast<pldm_entity*>(start); 1587 EXPECT_EQ(le16toh(entity->entity_type), 2u); 1588 EXPECT_EQ(le16toh(entity->entity_instance_num), 1u); 1589 EXPECT_EQ(le16toh(entity->entity_container_id), 1u); 1590 start += sizeof(pldm_entity); 1591 EXPECT_EQ(*start, pldm_entity_get_num_children( 1592 l2a, PLDM_ENTITY_ASSOCIAION_LOGICAL)); 1593 start += sizeof(uint8_t); 1594 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1595 entity = reinterpret_cast<pldm_entity*>(start); 1596 EXPECT_EQ(le16toh(entity->entity_type), 5); 1597 EXPECT_EQ(le16toh(entity->entity_instance_num), 2u); 1598 EXPECT_EQ(le16toh(entity->entity_container_id), 2u); 1599 start += sizeof(pldm_entity); 1600 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1601 entity = reinterpret_cast<pldm_entity*>(start); 1602 EXPECT_EQ(le16toh(entity->entity_type), 5u); 1603 EXPECT_EQ(le16toh(entity->entity_instance_num), 3u); 1604 EXPECT_EQ(le16toh(entity->entity_container_id), 2u); 1605 1606 currRecHandle = nextRecHandle; 1607 1608 pldm_pdr_find_record(repo, currRecHandle, &data, &size, &nextRecHandle); 1609 EXPECT_EQ(size, commonSize + (pldm_entity_get_num_children( 1610 l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL) * 1611 sizeof(pldm_entity))); 1612 start = data; 1613 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1614 hdr = reinterpret_cast<pldm_pdr_hdr*>(start); 1615 EXPECT_EQ(le32toh(hdr->record_handle), 4u); 1616 EXPECT_EQ(hdr->type, PLDM_PDR_ENTITY_ASSOCIATION); 1617 EXPECT_EQ(le16toh(hdr->length), size - sizeof(struct pldm_pdr_hdr)); 1618 start += sizeof(pldm_pdr_hdr); 1619 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1620 containerId = reinterpret_cast<uint16_t*>(start); 1621 EXPECT_EQ(le16toh(*containerId), 2u); 1622 start += sizeof(uint16_t); 1623 EXPECT_EQ(*start, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1624 start += sizeof(uint8_t); 1625 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1626 entity = reinterpret_cast<pldm_entity*>(start); 1627 EXPECT_EQ(le16toh(entity->entity_type), 2u); 1628 EXPECT_EQ(le16toh(entity->entity_instance_num), 1u); 1629 EXPECT_EQ(le16toh(entity->entity_container_id), 1u); 1630 start += sizeof(pldm_entity); 1631 EXPECT_EQ(*start, pldm_entity_get_num_children( 1632 l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL)); 1633 start += sizeof(uint8_t); 1634 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1635 entity = reinterpret_cast<pldm_entity*>(start); 1636 EXPECT_EQ(le16toh(entity->entity_type), 4u); 1637 EXPECT_EQ(le16toh(entity->entity_instance_num), 1u); 1638 EXPECT_EQ(le16toh(entity->entity_container_id), 2u); 1639 start += sizeof(pldm_entity); 1640 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1641 entity = reinterpret_cast<pldm_entity*>(start); 1642 EXPECT_EQ(le16toh(entity->entity_type), 5u); 1643 EXPECT_EQ(le16toh(entity->entity_instance_num), 1u); 1644 EXPECT_EQ(le16toh(entity->entity_container_id), 2u); 1645 1646 currRecHandle = nextRecHandle; 1647 1648 pldm_pdr_find_record(repo, currRecHandle, &data, &size, &nextRecHandle); 1649 EXPECT_EQ(size, commonSize + (pldm_entity_get_num_children( 1650 l3a, PLDM_ENTITY_ASSOCIAION_PHYSICAL) * 1651 sizeof(pldm_entity))); 1652 start = data; 1653 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1654 hdr = reinterpret_cast<pldm_pdr_hdr*>(start); 1655 EXPECT_EQ(le32toh(hdr->record_handle), 5u); 1656 EXPECT_EQ(hdr->type, PLDM_PDR_ENTITY_ASSOCIATION); 1657 EXPECT_EQ(le16toh(hdr->length), size - sizeof(struct pldm_pdr_hdr)); 1658 start += sizeof(pldm_pdr_hdr); 1659 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1660 containerId = reinterpret_cast<uint16_t*>(start); 1661 EXPECT_EQ(le16toh(*containerId), 3u); 1662 start += sizeof(uint16_t); 1663 EXPECT_EQ(*start, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1664 start += sizeof(uint8_t); 1665 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1666 entity = reinterpret_cast<pldm_entity*>(start); 1667 EXPECT_EQ(le16toh(entity->entity_type), 4u); 1668 EXPECT_EQ(le16toh(entity->entity_instance_num), 1u); 1669 EXPECT_EQ(le16toh(entity->entity_container_id), 2u); 1670 start += sizeof(pldm_entity); 1671 EXPECT_EQ(*start, pldm_entity_get_num_children( 1672 l3a, PLDM_ENTITY_ASSOCIAION_PHYSICAL)); 1673 start += sizeof(uint8_t); 1674 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1675 entity = reinterpret_cast<pldm_entity*>(start); 1676 EXPECT_EQ(le16toh(entity->entity_type), 6u); 1677 EXPECT_EQ(le16toh(entity->entity_instance_num), 1u); 1678 EXPECT_EQ(le16toh(entity->entity_container_id), 3u); 1679 1680 currRecHandle = nextRecHandle; 1681 1682 pldm_pdr_find_record(repo, currRecHandle, &data, &size, &nextRecHandle); 1683 EXPECT_EQ(size, commonSize + (pldm_entity_get_num_children( 1684 l3b, PLDM_ENTITY_ASSOCIAION_LOGICAL) * 1685 sizeof(pldm_entity))); 1686 start = data; 1687 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1688 hdr = reinterpret_cast<pldm_pdr_hdr*>(start); 1689 EXPECT_EQ(le32toh(hdr->record_handle), 6u); 1690 EXPECT_EQ(hdr->type, PLDM_PDR_ENTITY_ASSOCIATION); 1691 EXPECT_EQ(le16toh(hdr->length), size - sizeof(struct pldm_pdr_hdr)); 1692 start += sizeof(pldm_pdr_hdr); 1693 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1694 containerId = reinterpret_cast<uint16_t*>(start); 1695 EXPECT_EQ(le16toh(*containerId), 4u); 1696 start += sizeof(uint16_t); 1697 EXPECT_EQ(*start, PLDM_ENTITY_ASSOCIAION_LOGICAL); 1698 start += sizeof(uint8_t); 1699 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1700 entity = reinterpret_cast<pldm_entity*>(start); 1701 EXPECT_EQ(le16toh(entity->entity_type), 5u); 1702 EXPECT_EQ(le16toh(entity->entity_instance_num), 1u); 1703 EXPECT_EQ(le16toh(entity->entity_container_id), 2u); 1704 start += sizeof(pldm_entity); 1705 EXPECT_EQ(*start, pldm_entity_get_num_children( 1706 l3b, PLDM_ENTITY_ASSOCIAION_LOGICAL)); 1707 start += sizeof(uint8_t); 1708 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1709 entity = reinterpret_cast<pldm_entity*>(start); 1710 EXPECT_EQ(le16toh(entity->entity_type), 7u); 1711 EXPECT_EQ(le16toh(entity->entity_instance_num), 1u); 1712 EXPECT_EQ(le16toh(entity->entity_container_id), 4u); 1713 1714 EXPECT_EQ(nextRecHandle, 0u); 1715 1716 pldm_pdr_destroy(repo); 1717 pldm_entity_association_tree_destroy(tree); 1718 } 1719 1720 TEST(EntityAssociationPDR, testPDRWithRecordHandle) 1721 { 1722 // e = entity type, c = container id, i = instance num 1723 1724 // INPUT 1725 // 1(e=1) 1726 // | 1727 // 2(e=2)--3(e=2) 1728 1729 // Expected OUTPUT 1730 // 1(e=1,c=0,i=1) 1731 // | 1732 // 2(e=2,c=1,i=1)--3(e=2,c=1,i=2) 1733 1734 pldm_entity entities[3] = {{1, 1, 0}, {2, 1, 1}, {3, 1, 1}}; 1735 pldm_entity_test testEntities[3] = {{1, 1, 0}, {2, 1, 1}, {3, 1, 1}}; 1736 1737 auto tree = pldm_entity_association_tree_init(); 1738 1739 auto l1 = pldm_entity_association_tree_add( 1740 tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1741 ASSERT_NE(l1, nullptr); 1742 1743 auto l2a = pldm_entity_association_tree_add( 1744 tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1745 ASSERT_NE(l2a, nullptr); 1746 pldm_entity_association_tree_add(tree, &entities[2], 0xffff, l1, 1747 PLDM_ENTITY_ASSOCIAION_LOGICAL); 1748 auto repo = pldm_pdr_init(); 1749 pldm_entity* l_entities = entities; 1750 1751 pldm_entity_node* node = nullptr; 1752 pldm_find_entity_ref_in_tree(tree, entities[0], &node); 1753 1754 ASSERT_NE(node, nullptr); 1755 1756 int numEntities = 3; 1757 pldm_entity_association_pdr_add_from_node_with_record_handle( 1758 node, repo, &l_entities, numEntities, true, 1, (10)); 1759 1760 EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u); 1761 1762 uint32_t currRecHandle{}; 1763 uint32_t nextRecHandle{}; 1764 uint8_t* data = nullptr; 1765 uint32_t size{}; 1766 1767 pldm_pdr_find_record(repo, currRecHandle, &data, &size, &nextRecHandle); 1768 1769 struct pldm_msgbuf _buf; 1770 struct pldm_msgbuf* buf = &_buf; 1771 1772 auto rc = 1773 pldm_msgbuf_init_errno(buf, 1774 (sizeof(struct pldm_pdr_hdr) + 1775 sizeof(struct pldm_pdr_entity_association)), 1776 data, size); 1777 ASSERT_EQ(rc, 0); 1778 1779 pldm_association_pdr_test association_pdr = pldm_association_pdr_test{ 1780 10, 1781 1, 1782 PLDM_PDR_ENTITY_ASSOCIATION, 1783 1, 1784 static_cast<uint16_t>(size - sizeof(struct pldm_pdr_hdr)), 1785 1, 1786 PLDM_ENTITY_ASSOCIAION_LOGICAL, 1787 1}; 1788 1789 verifyEntityAssociationPdr(buf, association_pdr, testEntities[0], 1790 testEntities[2]); 1791 1792 currRecHandle = nextRecHandle; 1793 pldm_pdr_find_record(repo, currRecHandle, &data, &size, &nextRecHandle); 1794 rc = pldm_msgbuf_init_errno(buf, 1795 (sizeof(struct pldm_pdr_hdr) + 1796 sizeof(struct pldm_pdr_entity_association)), 1797 data, size); 1798 ASSERT_EQ(rc, 0); 1799 1800 pldm_association_pdr_test association_pdr1 = pldm_association_pdr_test{ 1801 11, 1802 1, 1803 PLDM_PDR_ENTITY_ASSOCIATION, 1804 1, 1805 static_cast<uint16_t>(size - sizeof(struct pldm_pdr_hdr)), 1806 1, 1807 PLDM_ENTITY_ASSOCIAION_PHYSICAL, 1808 1}; 1809 1810 verifyEntityAssociationPdr(buf, association_pdr1, testEntities[0], 1811 testEntities[1]); 1812 1813 pldm_pdr_destroy(repo); 1814 pldm_entity_association_tree_destroy(tree); 1815 } 1816 1817 TEST(EntityAssociationPDR, testFind) 1818 { 1819 // 1 1820 // | 1821 // 2--3--4 1822 // | 1823 // 5--6--7 1824 // | | 1825 // 8 9 1826 1827 pldm_entity entities[9]{}; 1828 1829 entities[0].entity_type = 1; 1830 entities[1].entity_type = 2; 1831 entities[2].entity_type = 2; 1832 entities[3].entity_type = 3; 1833 entities[4].entity_type = 4; 1834 entities[5].entity_type = 5; 1835 entities[6].entity_type = 5; 1836 entities[7].entity_type = 6; 1837 entities[8].entity_type = 7; 1838 1839 auto tree = pldm_entity_association_tree_init(); 1840 1841 auto l1 = pldm_entity_association_tree_add( 1842 tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1843 EXPECT_NE(l1, nullptr); 1844 auto l2a = pldm_entity_association_tree_add( 1845 tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1846 EXPECT_NE(l2a, nullptr); 1847 auto l2b = pldm_entity_association_tree_add( 1848 tree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1849 EXPECT_NE(l2b, nullptr); 1850 auto l2c = pldm_entity_association_tree_add( 1851 tree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1852 EXPECT_NE(l2c, nullptr); 1853 auto l3a = pldm_entity_association_tree_add( 1854 tree, &entities[4], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1855 EXPECT_NE(l3a, nullptr); 1856 auto l3b = pldm_entity_association_tree_add( 1857 tree, &entities[5], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1858 EXPECT_NE(l3b, nullptr); 1859 auto l3c = pldm_entity_association_tree_add( 1860 tree, &entities[6], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1861 EXPECT_NE(l3c, nullptr); 1862 auto l4a = pldm_entity_association_tree_add( 1863 tree, &entities[7], 0xffff, l3a, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1864 EXPECT_NE(l4a, nullptr); 1865 auto l4b = pldm_entity_association_tree_add( 1866 tree, &entities[8], 0xffff, l3b, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1867 EXPECT_NE(l4b, nullptr); 1868 1869 pldm_entity entity{}; 1870 1871 entity.entity_type = 1; 1872 entity.entity_instance_num = 1; 1873 auto result = pldm_entity_association_tree_find(tree, &entity); 1874 EXPECT_EQ(result, l1); 1875 EXPECT_EQ(entity.entity_container_id, 0); 1876 1877 entity.entity_type = 2; 1878 entity.entity_instance_num = 1; 1879 result = pldm_entity_association_tree_find(tree, &entity); 1880 EXPECT_EQ(result, l2a); 1881 EXPECT_EQ(entity.entity_container_id, 1); 1882 entity.entity_type = 2; 1883 entity.entity_instance_num = 2; 1884 result = pldm_entity_association_tree_find(tree, &entity); 1885 EXPECT_EQ(result, l2b); 1886 EXPECT_EQ(entity.entity_container_id, 1); 1887 entity.entity_type = 3; 1888 entity.entity_instance_num = 1; 1889 result = pldm_entity_association_tree_find(tree, &entity); 1890 EXPECT_EQ(result, l2c); 1891 EXPECT_EQ(entity.entity_container_id, 1); 1892 1893 entity.entity_type = 7; 1894 entity.entity_instance_num = 1; 1895 result = pldm_entity_association_tree_find(tree, &entity); 1896 EXPECT_EQ(result, l4b); 1897 EXPECT_EQ(entity.entity_container_id, 4); 1898 1899 pldm_entity_association_tree_destroy(tree); 1900 } 1901 1902 #ifdef LIBPLDM_API_TESTING 1903 TEST(EntityAssociationPDR, testCopyTree) 1904 { 1905 pldm_entity entities[4]{}; 1906 int rc; 1907 1908 entities[0].entity_type = 1; 1909 entities[1].entity_type = 2; 1910 entities[2].entity_type = 2; 1911 entities[3].entity_type = 3; 1912 1913 auto orgTree = pldm_entity_association_tree_init(); 1914 auto newTree = pldm_entity_association_tree_init(); 1915 auto l1 = 1916 pldm_entity_association_tree_add(orgTree, &entities[0], 0xffff, nullptr, 1917 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1918 EXPECT_NE(l1, nullptr); 1919 auto l2a = pldm_entity_association_tree_add( 1920 orgTree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1921 EXPECT_NE(l2a, nullptr); 1922 auto l2b = pldm_entity_association_tree_add( 1923 orgTree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1924 EXPECT_NE(l2b, nullptr); 1925 auto l2c = pldm_entity_association_tree_add( 1926 orgTree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 1927 EXPECT_NE(l2c, nullptr); 1928 size_t orgNum{}; 1929 pldm_entity* orgOut = nullptr; 1930 pldm_entity_association_tree_visit(orgTree, &orgOut, &orgNum); 1931 EXPECT_EQ(orgNum, 4u); 1932 1933 rc = pldm_entity_association_tree_copy_root_check(orgTree, newTree); 1934 ASSERT_EQ(rc, 0); 1935 size_t newNum{}; 1936 pldm_entity* newOut = nullptr; 1937 pldm_entity_association_tree_visit(newTree, &newOut, &newNum); 1938 EXPECT_EQ(newNum, orgNum); 1939 EXPECT_EQ(newOut[0].entity_type, 1u); 1940 EXPECT_EQ(newOut[0].entity_instance_num, 1u); 1941 EXPECT_EQ(newOut[0].entity_container_id, 0u); 1942 free(orgOut); 1943 free(newOut); 1944 pldm_entity_association_tree_destroy(orgTree); 1945 pldm_entity_association_tree_destroy(newTree); 1946 } 1947 #endif 1948 1949 TEST(EntityAssociationPDR, testExtract) 1950 { 1951 std::vector<uint8_t> pdr{}; 1952 pdr.resize(sizeof(pldm_pdr_hdr) + sizeof(pldm_pdr_entity_association) + 1953 sizeof(pldm_entity) * 4); 1954 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1955 pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(pdr.data()); 1956 hdr->type = PLDM_PDR_ENTITY_ASSOCIATION; 1957 hdr->length = 1958 htole16(sizeof(pldm_pdr_entity_association) + sizeof(pldm_entity) * 4); 1959 1960 pldm_pdr_entity_association* e = 1961 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 1962 reinterpret_cast<pldm_pdr_entity_association*>(pdr.data() + 1963 sizeof(pldm_pdr_hdr)); 1964 e->container_id = htole16(1); 1965 e->num_children = 5; 1966 e->container.entity_type = htole16(1); 1967 e->container.entity_instance_num = htole16(1); 1968 e->container.entity_container_id = htole16(0); 1969 1970 pldm_entity* entity = e->children; 1971 entity->entity_type = htole16(2); 1972 entity->entity_instance_num = htole16(1); 1973 entity->entity_container_id = htole16(1); 1974 ++entity; 1975 entity->entity_type = htole16(3); 1976 entity->entity_instance_num = htole16(1); 1977 entity->entity_container_id = htole16(1); 1978 ++entity; 1979 entity->entity_type = htole16(4); 1980 entity->entity_instance_num = htole16(1); 1981 entity->entity_container_id = htole16(1); 1982 ++entity; 1983 entity->entity_type = htole16(5); 1984 entity->entity_instance_num = htole16(1); 1985 entity->entity_container_id = htole16(1); 1986 ++entity; 1987 entity->entity_type = htole16(6); 1988 entity->entity_instance_num = htole16(1); 1989 entity->entity_container_id = htole16(1); 1990 1991 size_t num{}; 1992 pldm_entity* out = nullptr; 1993 pldm_entity_association_pdr_extract(pdr.data(), pdr.size(), &num, &out); 1994 EXPECT_EQ(num, (unsigned)e->num_children + 1); 1995 EXPECT_EQ(out[0].entity_type, 1u); 1996 EXPECT_EQ(out[0].entity_instance_num, 1u); 1997 EXPECT_EQ(out[0].entity_container_id, 0u); 1998 EXPECT_EQ(out[1].entity_type, 2u); 1999 EXPECT_EQ(out[1].entity_instance_num, 1u); 2000 EXPECT_EQ(out[1].entity_container_id, 1u); 2001 EXPECT_EQ(out[2].entity_type, 3u); 2002 EXPECT_EQ(out[2].entity_instance_num, 1u); 2003 EXPECT_EQ(out[2].entity_container_id, 1u); 2004 EXPECT_EQ(out[3].entity_type, 4u); 2005 EXPECT_EQ(out[3].entity_instance_num, 1u); 2006 EXPECT_EQ(out[3].entity_container_id, 1u); 2007 EXPECT_EQ(out[4].entity_type, 5u); 2008 EXPECT_EQ(out[4].entity_instance_num, 1u); 2009 EXPECT_EQ(out[4].entity_container_id, 1u); 2010 EXPECT_EQ(out[5].entity_type, 6u); 2011 EXPECT_EQ(out[5].entity_instance_num, 1u); 2012 EXPECT_EQ(out[5].entity_container_id, 1u); 2013 2014 free(out); 2015 } 2016 2017 TEST(EntityAssociationPDR, testGetChildren) 2018 { 2019 pldm_entity entities[4]{}; 2020 entities[0].entity_type = 1; 2021 entities[1].entity_type = 2; 2022 entities[2].entity_type = 2; 2023 entities[3].entity_type = 3; 2024 2025 auto tree = pldm_entity_association_tree_init(); 2026 auto l1 = pldm_entity_association_tree_add( 2027 tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2028 EXPECT_NE(l1, nullptr); 2029 auto l2a = pldm_entity_association_tree_add( 2030 tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2031 EXPECT_NE(l2a, nullptr); 2032 auto l2b = pldm_entity_association_tree_add( 2033 tree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2034 EXPECT_NE(l2b, nullptr); 2035 auto l2c = pldm_entity_association_tree_add( 2036 tree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2037 EXPECT_NE(l2c, nullptr); 2038 2039 pldm_entity et1; 2040 et1.entity_type = 2; 2041 et1.entity_instance_num = 1; 2042 EXPECT_EQ(true, pldm_is_current_parent_child(l1, &et1)); 2043 2044 pldm_entity et2; 2045 et2.entity_type = 2; 2046 et2.entity_instance_num = 2; 2047 EXPECT_EQ(true, pldm_is_current_parent_child(l1, &et2)); 2048 2049 pldm_entity et3; 2050 et3.entity_type = 2; 2051 et3.entity_instance_num = 3; 2052 EXPECT_EQ(false, pldm_is_current_parent_child(l1, &et3)); 2053 2054 pldm_entity_association_tree_destroy(tree); 2055 } 2056 2057 TEST(EntityAssociationPDR, testEntityInstanceNumber) 2058 { 2059 pldm_entity entities[9]{}; 2060 2061 entities[0].entity_type = 1; 2062 entities[1].entity_type = 2; 2063 entities[2].entity_type = 2; 2064 entities[3].entity_type = 2; 2065 entities[4].entity_type = 2; 2066 entities[5].entity_type = 2; 2067 entities[6].entity_type = 2; 2068 entities[7].entity_type = 3; 2069 entities[8].entity_type = 3; 2070 2071 auto tree = pldm_entity_association_tree_init(); 2072 auto repo = pldm_pdr_init(); 2073 2074 uint16_t terminusHdl{}; 2075 uint16_t entityType{}; 2076 uint16_t entityInstanceNum{}; 2077 uint16_t containerId{}; 2078 2079 auto node = pldm_entity_association_tree_add( 2080 tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2081 EXPECT_NE(node, nullptr); 2082 2083 auto l1 = pldm_entity_association_tree_add(tree, &entities[1], 63, node, 2084 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2085 uint32_t first = 1; 2086 EXPECT_EQ(pldm_pdr_add_fru_record_set(repo, 1, 1, entities[1].entity_type, 2087 entities[1].entity_instance_num, 2088 entities[1].entity_container_id, 2089 &first), 2090 0); 2091 EXPECT_NE(l1, nullptr); 2092 EXPECT_EQ(entities[1].entity_instance_num, 63); 2093 EXPECT_EQ(first, pldm_pdr_get_record_handle( 2094 repo, pldm_pdr_fru_record_set_find_by_rsi( 2095 repo, 1, &terminusHdl, &entityType, 2096 &entityInstanceNum, &containerId))); 2097 EXPECT_EQ(entityType, 2); 2098 EXPECT_EQ(entityInstanceNum, 63); 2099 2100 auto l2 = pldm_entity_association_tree_add(tree, &entities[2], 37, node, 2101 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2102 uint32_t second = 2; 2103 EXPECT_EQ(pldm_pdr_add_fru_record_set(repo, 1, 2, entities[2].entity_type, 2104 entities[2].entity_instance_num, 2105 entities[2].entity_container_id, 2106 &second), 2107 0); 2108 EXPECT_NE(l2, nullptr); 2109 EXPECT_EQ(entities[2].entity_instance_num, 37); 2110 EXPECT_EQ(second, pldm_pdr_get_record_handle( 2111 repo, pldm_pdr_fru_record_set_find_by_rsi( 2112 repo, 2, &terminusHdl, &entityType, 2113 &entityInstanceNum, &containerId))); 2114 EXPECT_EQ(entityType, 2); 2115 EXPECT_EQ(entityInstanceNum, 37); 2116 2117 auto l3 = pldm_entity_association_tree_add(tree, &entities[3], 44, node, 2118 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2119 uint32_t third = 3; 2120 EXPECT_EQ(pldm_pdr_add_fru_record_set(repo, 1, 3, entities[3].entity_type, 2121 entities[3].entity_instance_num, 2122 entities[3].entity_container_id, 2123 &third), 2124 0); 2125 EXPECT_NE(l3, nullptr); 2126 EXPECT_EQ(entities[3].entity_instance_num, 44); 2127 EXPECT_EQ(third, pldm_pdr_get_record_handle( 2128 repo, pldm_pdr_fru_record_set_find_by_rsi( 2129 repo, 3, &terminusHdl, &entityType, 2130 &entityInstanceNum, &containerId))); 2131 EXPECT_EQ(entityType, 2); 2132 EXPECT_EQ(entityInstanceNum, 44); 2133 2134 auto l4 = pldm_entity_association_tree_add(tree, &entities[4], 89, node, 2135 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2136 uint32_t fourth = 4; 2137 EXPECT_EQ(pldm_pdr_add_fru_record_set(repo, 1, 4, entities[4].entity_type, 2138 entities[4].entity_instance_num, 2139 entities[4].entity_container_id, 2140 &fourth), 2141 0); 2142 EXPECT_NE(l4, nullptr); 2143 EXPECT_EQ(entities[4].entity_instance_num, 89); 2144 EXPECT_EQ(fourth, pldm_pdr_get_record_handle( 2145 repo, pldm_pdr_fru_record_set_find_by_rsi( 2146 repo, 4, &terminusHdl, &entityType, 2147 &entityInstanceNum, &containerId))); 2148 EXPECT_EQ(entityType, 2); 2149 EXPECT_EQ(entityInstanceNum, 89); 2150 2151 auto l5 = pldm_entity_association_tree_add(tree, &entities[5], 0xffff, node, 2152 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2153 uint32_t fifth = 5; 2154 EXPECT_EQ(pldm_pdr_add_fru_record_set(repo, 1, 5, entities[5].entity_type, 2155 entities[5].entity_instance_num, 2156 entities[5].entity_container_id, 2157 &fifth), 2158 0); 2159 EXPECT_NE(l5, nullptr); 2160 EXPECT_EQ(entities[5].entity_instance_num, 90); 2161 EXPECT_EQ(fifth, pldm_pdr_get_record_handle( 2162 repo, pldm_pdr_fru_record_set_find_by_rsi( 2163 repo, 5, &terminusHdl, &entityType, 2164 &entityInstanceNum, &containerId))); 2165 EXPECT_EQ(entityType, 2); 2166 EXPECT_EQ(entityInstanceNum, 90); 2167 2168 auto l6 = pldm_entity_association_tree_add(tree, &entities[6], 90, node, 2169 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2170 EXPECT_EQ(l6, nullptr); 2171 2172 auto l7 = pldm_entity_association_tree_add(tree, &entities[7], 100, l1, 2173 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2174 uint32_t seventh = 7; 2175 EXPECT_EQ(pldm_pdr_add_fru_record_set(repo, 1, 7, entities[7].entity_type, 2176 entities[7].entity_instance_num, 2177 entities[7].entity_container_id, 2178 &seventh), 2179 0); 2180 EXPECT_NE(l7, nullptr); 2181 EXPECT_EQ(entities[7].entity_instance_num, 100); 2182 EXPECT_EQ(seventh, pldm_pdr_get_record_handle( 2183 repo, pldm_pdr_fru_record_set_find_by_rsi( 2184 repo, 7, &terminusHdl, &entityType, 2185 &entityInstanceNum, &containerId))); 2186 EXPECT_EQ(entityType, 3); 2187 EXPECT_EQ(entityInstanceNum, 100); 2188 2189 auto l8 = pldm_entity_association_tree_add(tree, &entities[8], 100, l2, 2190 PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2191 uint32_t eighth = 8; 2192 EXPECT_EQ(pldm_pdr_add_fru_record_set(repo, 1, 8, entities[8].entity_type, 2193 entities[8].entity_instance_num, 2194 entities[8].entity_container_id, 2195 &eighth), 2196 0); 2197 EXPECT_NE(l8, nullptr); 2198 EXPECT_EQ(entities[8].entity_instance_num, 100); 2199 EXPECT_EQ(eighth, pldm_pdr_get_record_handle( 2200 repo, pldm_pdr_fru_record_set_find_by_rsi( 2201 repo, 8, &terminusHdl, &entityType, 2202 &entityInstanceNum, &containerId))); 2203 EXPECT_EQ(entityType, 3); 2204 EXPECT_EQ(entityInstanceNum, 100); 2205 2206 pldm_pdr_destroy(repo); 2207 pldm_entity_association_tree_destroy(tree); 2208 } 2209 2210 #ifdef LIBPLDM_API_TESTING 2211 TEST(EntityAssociationPDR, testFindChildContainerID) 2212 { 2213 pldm_entity entities[3]{}; 2214 entities[0].entity_type = 1; 2215 entities[1].entity_type = 2; 2216 entities[2].entity_type = 3; 2217 entities[1].entity_container_id = 2; 2218 entities[1].entity_instance_num = 1; 2219 2220 auto tree = pldm_entity_association_tree_init(); 2221 auto l1 = pldm_entity_association_tree_add_entity( 2222 tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_LOGICAL, 2223 false, true, 0xffff); 2224 2225 EXPECT_NE(l1, nullptr); 2226 auto l2 = pldm_entity_association_tree_add_entity( 2227 tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false, 2228 false, 0xffff); 2229 EXPECT_NE(l2, nullptr); 2230 auto l3 = pldm_entity_association_tree_add_entity( 2231 tree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false, 2232 true, 0xffff); 2233 EXPECT_NE(l3, nullptr); 2234 2235 EXPECT_EQ(pldm_entity_get_num_children(l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL), 2236 2); 2237 2238 auto repo = pldm_pdr_init(); 2239 int rc = pldm_entity_association_pdr_add(tree, repo, false, 1); 2240 ASSERT_EQ(rc, 0); 2241 2242 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 2243 2244 uint16_t container_id{}; 2245 pldm_pdr_find_child_container_id_index_range_exclude( 2246 repo, 1, 1, 0, 0x01000000, 0x01ffffff, &container_id); 2247 EXPECT_EQ(container_id, 2); 2248 2249 uint16_t container_id1{}; 2250 pldm_pdr_find_child_container_id_index_range_exclude( 2251 repo, 1, 1, 0, 0x00000001, 0x00ffffff, &container_id1); 2252 EXPECT_EQ(container_id1, 0); 2253 2254 pldm_pdr_destroy(repo); 2255 pldm_entity_association_tree_destroy(tree); 2256 } 2257 #endif 2258 2259 TEST(EntityAssociationPDR, testNodeAddCheck) 2260 { 2261 // pldm_entity entities[4]{}; 2262 pldm_entity* entities = (pldm_entity*)malloc(sizeof(pldm_entity) * 4); 2263 entities[0].entity_type = 1; 2264 entities[1].entity_type = 2; 2265 entities[2].entity_type = 2; 2266 entities[3].entity_type = 3; 2267 2268 auto tree = pldm_entity_association_tree_init(); 2269 2270 auto l1 = pldm_entity_association_tree_add( 2271 tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2272 EXPECT_NE(l1, nullptr); 2273 auto l2a = pldm_entity_association_tree_add( 2274 tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2275 EXPECT_NE(l2a, nullptr); 2276 auto l2b = pldm_entity_association_tree_add( 2277 tree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2278 EXPECT_NE(l2b, nullptr); 2279 auto l2c = pldm_entity_association_tree_add( 2280 tree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2281 EXPECT_NE(l2c, nullptr); 2282 2283 auto repo = pldm_pdr_init(); 2284 2285 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2286 l1, repo, &entities, 4, false, 1, 0), 2287 0); 2288 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2289 l1, repo, &entities, 4, false, 1, 2), 2290 0); 2291 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2292 l1, repo, &entities, 4, false, 1, 23), 2293 0); 2294 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2295 l1, repo, &entities, 4, false, 1, 34), 2296 0); 2297 2298 EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u); 2299 2300 uint8_t* outData = nullptr; 2301 uint32_t size{}; 2302 uint32_t nextRecHdl{}; 2303 auto hdl = pldm_pdr_find_record(repo, 0, &outData, &size, &nextRecHdl); 2304 EXPECT_NE(hdl, nullptr); 2305 2306 outData = nullptr; 2307 auto hdl1 = pldm_pdr_find_record(repo, 2, &outData, &size, &nextRecHdl); 2308 EXPECT_NE(hdl1, nullptr); 2309 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 2310 pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(outData); 2311 EXPECT_EQ(hdr->record_handle, 2); 2312 2313 outData = nullptr; 2314 auto hdl2 = pldm_pdr_find_record(repo, 23, &outData, &size, &nextRecHdl); 2315 EXPECT_NE(hdl2, nullptr); 2316 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 2317 pldm_pdr_hdr* hdr1 = reinterpret_cast<pldm_pdr_hdr*>(outData); 2318 EXPECT_EQ(hdr1->record_handle, 23); 2319 2320 outData = nullptr; 2321 auto hdl3 = pldm_pdr_find_record(repo, 3, &outData, &size, &nextRecHdl); 2322 EXPECT_EQ(hdl3, nullptr); 2323 2324 free(entities); 2325 pldm_pdr_destroy(repo); 2326 pldm_entity_association_tree_destroy(tree); 2327 } 2328 2329 #ifdef LIBPLDM_API_TESTING 2330 TEST(EntityAssociationPDR, testAddContainedEntityRemotePDR) 2331 { 2332 // pldm_entity entities[5]{}; 2333 pldm_entity* entities = (pldm_entity*)malloc(sizeof(pldm_entity) * 5); 2334 entities[0].entity_type = 1; 2335 entities[1].entity_type = 2; 2336 entities[2].entity_type = 3; 2337 entities[3].entity_type = 4; 2338 entities[4].entity_type = 5; 2339 2340 auto tree = pldm_entity_association_tree_init(); 2341 auto l1 = pldm_entity_association_tree_add( 2342 tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2343 EXPECT_NE(l1, nullptr); 2344 auto l2a = pldm_entity_association_tree_add( 2345 tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2346 EXPECT_NE(l2a, nullptr); 2347 auto l2b = pldm_entity_association_tree_add( 2348 tree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2349 EXPECT_NE(l2b, nullptr); 2350 auto l2c = pldm_entity_association_tree_add( 2351 tree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2352 EXPECT_NE(l2c, nullptr); 2353 auto l3a = pldm_entity_association_tree_add( 2354 tree, &entities[4], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2355 EXPECT_NE(l3a, nullptr); 2356 2357 auto repo = pldm_pdr_init(); 2358 2359 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2360 l1, repo, &entities, 5, false, 1, 0), 2361 0); 2362 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2363 l1, repo, &entities, 5, false, 1, 2), 2364 0); 2365 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2366 l1, repo, &entities, 5, false, 1, 23), 2367 0); 2368 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2369 l1, repo, &entities, 5, false, 1, 34), 2370 0); 2371 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2372 l2a, repo, &entities, 5, false, 1, 3), 2373 0); 2374 2375 pldm_entity entity1[1]; 2376 entity1[0].entity_type = 2; 2377 2378 EXPECT_EQ(pldm_entity_association_pdr_add_contained_entity_to_remote_pdr( 2379 repo, &entity1[0], 2), 2380 0); 2381 2382 free(entities); 2383 pldm_pdr_destroy(repo); 2384 pldm_entity_association_tree_destroy(tree); 2385 } 2386 #endif 2387 2388 #ifdef LIBPLDM_API_TESTING 2389 TEST(EntityAssociationPDR, testAddContainedEntityNew) 2390 { 2391 // pldm_entity entities[5]{}; 2392 pldm_entity* entities = (pldm_entity*)malloc(sizeof(pldm_entity) * 5); 2393 entities[0].entity_type = 1; 2394 entities[1].entity_type = 2; 2395 entities[2].entity_type = 3; 2396 entities[3].entity_type = 4; 2397 entities[4].entity_type = 5; 2398 2399 auto tree = pldm_entity_association_tree_init(); 2400 auto l1 = pldm_entity_association_tree_add( 2401 tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2402 EXPECT_NE(l1, nullptr); 2403 auto l2a = pldm_entity_association_tree_add( 2404 tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2405 EXPECT_NE(l2a, nullptr); 2406 auto l2b = pldm_entity_association_tree_add( 2407 tree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2408 EXPECT_NE(l2b, nullptr); 2409 auto l2c = pldm_entity_association_tree_add( 2410 tree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2411 EXPECT_NE(l2c, nullptr); 2412 auto l3a = pldm_entity_association_tree_add( 2413 tree, &entities[4], 0xffff, l2a, PLDM_ENTITY_ASSOCIAION_PHYSICAL); 2414 EXPECT_NE(l3a, nullptr); 2415 2416 auto repo = pldm_pdr_init(); 2417 2418 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2419 l1, repo, &entities, 5, false, 1, 0), 2420 0); 2421 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2422 l1, repo, &entities, 5, false, 1, 2), 2423 0); 2424 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2425 l1, repo, &entities, 5, false, 1, 23), 2426 0); 2427 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2428 l1, repo, &entities, 5, false, 1, 34), 2429 0); 2430 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2431 l2a, repo, &entities, 5, false, 1, 3), 2432 0); 2433 2434 uint32_t updated_record_handle = 0; 2435 2436 pldm_entity entity2[1]{}; 2437 entity2[0].entity_type = 4; 2438 2439 pldm_entity entity3[1]{}; 2440 entity3[0].entity_type = 4; 2441 2442 EXPECT_EQ(pldm_entity_association_pdr_create_new( 2443 repo, 34, &entity2[0], &entity3[0], &updated_record_handle), 2444 0); 2445 2446 EXPECT_EQ(updated_record_handle, 35); 2447 2448 free(entities); 2449 pldm_pdr_destroy(repo); 2450 pldm_entity_association_tree_destroy(tree); 2451 } 2452 #endif 2453 2454 #ifdef LIBPLDM_API_TESTING 2455 TEST(EntityAssociationPDR, testRemoveContainedEntity) 2456 { 2457 struct pldm_entity entities[4] = { 2458 {.entity_type = 1, .entity_instance_num = 1, .entity_container_id = 2}, 2459 {.entity_type = 2, .entity_instance_num = 1, .entity_container_id = 2}, 2460 {.entity_type = 3, .entity_instance_num = 3, .entity_container_id = 3}, 2461 {.entity_type = 4, .entity_instance_num = 1, .entity_container_id = 2}}; 2462 struct pldm_entity* base = entities; 2463 2464 auto tree = pldm_entity_association_tree_init(); 2465 auto l1 = pldm_entity_association_tree_add_entity( 2466 tree, &entities[0], 0xffff, nullptr, PLDM_ENTITY_ASSOCIAION_LOGICAL, 2467 false, true, 0xffff); 2468 2469 EXPECT_NE(l1, nullptr); 2470 auto l2 = pldm_entity_association_tree_add_entity( 2471 tree, &entities[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false, 2472 false, 0xffff); 2473 EXPECT_NE(l2, nullptr); 2474 auto l3 = pldm_entity_association_tree_add_entity( 2475 tree, &entities[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false, 2476 true, 0xffff); 2477 EXPECT_NE(l3, nullptr); 2478 auto l4 = pldm_entity_association_tree_add_entity( 2479 tree, &entities[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, false, 2480 true, 0xffff); 2481 EXPECT_NE(l4, nullptr); 2482 2483 EXPECT_EQ(pldm_entity_get_num_children(l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL), 2484 3); 2485 2486 auto repo = pldm_pdr_init(); 2487 2488 EXPECT_EQ(pldm_entity_association_pdr_add_from_node_with_record_handle( 2489 l1, repo, &base, 4, false, 1, 3), 2490 0); 2491 2492 EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u); 2493 2494 // Remove first contained entity from the entity association PDR 2495 uint32_t removed_record_handle{}; 2496 struct pldm_entity entity[1] = { 2497 {.entity_type = 4, .entity_instance_num = 1, .entity_container_id = 2}}; 2498 2499 EXPECT_EQ(pldm_entity_association_pdr_remove_contained_entity( 2500 repo, entity, false, &removed_record_handle), 2501 0); 2502 EXPECT_EQ(removed_record_handle, 3); 2503 2504 // Remove second contained entity from the entity association PDR 2505 removed_record_handle = 0; 2506 EXPECT_EQ(pldm_entity_association_pdr_remove_contained_entity( 2507 repo, &entities[1], false, &removed_record_handle), 2508 0); 2509 EXPECT_EQ(removed_record_handle, 3); 2510 2511 // Remove third contained entity from the entity association PDR 2512 removed_record_handle = 0; 2513 EXPECT_EQ(pldm_entity_association_pdr_remove_contained_entity( 2514 repo, &entities[2], false, &removed_record_handle), 2515 0); 2516 EXPECT_EQ(removed_record_handle, 3); 2517 2518 // As all the contained entities are removed the entity association PDR 2519 // also gets deleted 2520 EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u); 2521 2522 pldm_pdr_destroy(repo); 2523 pldm_entity_association_tree_destroy(tree); 2524 } 2525 #endif 2526 2527 #ifdef LIBPLDM_API_TESTING 2528 TEST(PDRUpdate, testRemoveFruRecord) 2529 { 2530 auto repo = pldm_pdr_init(); 2531 2532 uint32_t record_handle = 1; 2533 int rc = pldm_pdr_add_fru_record_set(repo, 1, 1, 1, 0, 100, &record_handle); 2534 EXPECT_EQ(rc, 0); 2535 record_handle = 2; 2536 rc = pldm_pdr_add_fru_record_set(repo, 1, 2, 1, 1, 100, &record_handle); 2537 EXPECT_EQ(rc, 0); 2538 record_handle = 3; 2539 rc = pldm_pdr_add_fru_record_set(repo, 1, 3, 1, 2, 100, &record_handle); 2540 EXPECT_EQ(rc, 0); 2541 EXPECT_EQ(pldm_pdr_get_record_count(repo), 3); 2542 2543 uint32_t removed_record_handle{}; 2544 rc = pldm_pdr_remove_fru_record_set_by_rsi(repo, 2, false, 2545 &removed_record_handle); 2546 EXPECT_EQ(rc, 0); 2547 EXPECT_EQ(removed_record_handle, 2); 2548 EXPECT_EQ(pldm_pdr_get_record_count(repo), 2); 2549 2550 uint16_t terminusHdl{}; 2551 uint16_t entityType{}; 2552 uint16_t entityInstanceNum{}; 2553 uint16_t containerId{}; 2554 auto record = pldm_pdr_fru_record_set_find_by_rsi( 2555 repo, 1, &terminusHdl, &entityType, &entityInstanceNum, &containerId); 2556 EXPECT_NE(record, nullptr); 2557 record_handle = pldm_pdr_get_record_handle(repo, record); 2558 EXPECT_EQ(record_handle, 1); 2559 2560 record = pldm_pdr_fru_record_set_find_by_rsi( 2561 repo, 3, &terminusHdl, &entityType, &entityInstanceNum, &containerId); 2562 EXPECT_NE(record, nullptr); 2563 record_handle = pldm_pdr_get_record_handle(repo, record); 2564 EXPECT_EQ(record_handle, 3); 2565 2566 record = pldm_pdr_fru_record_set_find_by_rsi( 2567 repo, 2, &terminusHdl, &entityType, &entityInstanceNum, &containerId); 2568 EXPECT_EQ(record, nullptr); 2569 2570 rc = pldm_pdr_remove_fru_record_set_by_rsi(repo, 1, false, 2571 &removed_record_handle); 2572 EXPECT_EQ(rc, 0); 2573 EXPECT_EQ(removed_record_handle, 1); 2574 2575 // remove the same record again 2576 removed_record_handle = 5; 2577 rc = pldm_pdr_remove_fru_record_set_by_rsi(repo, 1, false, 2578 &removed_record_handle); 2579 EXPECT_EQ(rc, 0); 2580 EXPECT_NE(removed_record_handle, 1); 2581 EXPECT_EQ(removed_record_handle, 5); 2582 2583 rc = pldm_pdr_remove_fru_record_set_by_rsi(repo, 3, false, 2584 &removed_record_handle); 2585 EXPECT_EQ(rc, 0); 2586 EXPECT_EQ(removed_record_handle, 3); 2587 2588 EXPECT_EQ(pldm_pdr_get_record_count(repo), 0); 2589 2590 pldm_pdr_destroy(repo); 2591 } 2592 #endif 2593 2594 #ifdef LIBPLDM_API_TESTING 2595 TEST(EntityAssociationPDR, testDeleteNode) 2596 { 2597 std::unique_ptr<pldm_entity, decltype(&free)> entities( 2598 (pldm_entity*)malloc(sizeof(pldm_entity) * 4), &free); 2599 ASSERT_NE(entities, nullptr); 2600 2601 entities.get()[0].entity_type = 1; 2602 2603 entities.get()[1].entity_type = 2; 2604 entities.get()[1].entity_instance_num = 1; 2605 entities.get()[1].entity_container_id = 2; 2606 2607 entities.get()[2].entity_type = 3; 2608 entities.get()[2].entity_instance_num = 1; 2609 entities.get()[2].entity_container_id = 2; 2610 2611 entities.get()[3].entity_type = 4; 2612 entities.get()[3].entity_instance_num = 1; 2613 entities.get()[3].entity_container_id = 2; 2614 2615 auto tree = pldm_entity_association_tree_init(); 2616 ASSERT_NE(tree, nullptr); 2617 2618 auto l1 = pldm_entity_association_tree_add_entity( 2619 tree, &entities.get()[0], 0xffff, nullptr, 2620 PLDM_ENTITY_ASSOCIAION_LOGICAL, false, true, 0xffff); 2621 ASSERT_NE(l1, nullptr); 2622 2623 auto l2 = pldm_entity_association_tree_add_entity( 2624 tree, &entities.get()[1], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, 2625 false, false, 0xffff); 2626 ASSERT_NE(l2, nullptr); 2627 2628 auto l3 = pldm_entity_association_tree_add_entity( 2629 tree, &entities.get()[2], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, 2630 false, true, 0xffff); 2631 ASSERT_NE(l3, nullptr); 2632 2633 auto l4 = pldm_entity_association_tree_add_entity( 2634 tree, &entities.get()[3], 0xffff, l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL, 2635 false, true, 0xffff); 2636 ASSERT_NE(l4, nullptr); 2637 2638 EXPECT_EQ(pldm_entity_get_num_children(l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL), 2639 3); 2640 2641 pldm_entity entity{}; 2642 entity.entity_type = 4; 2643 entity.entity_instance_num = 1; 2644 entity.entity_container_id = 2; 2645 2646 pldm_entity_association_tree_delete_node(tree, &entity); 2647 EXPECT_EQ(pldm_entity_get_num_children(l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL), 2648 2); 2649 2650 entity.entity_type = 3; 2651 entity.entity_instance_num = 1; 2652 entity.entity_container_id = 2; 2653 2654 pldm_entity_association_tree_delete_node(tree, &entity); 2655 EXPECT_EQ(pldm_entity_get_num_children(l1, PLDM_ENTITY_ASSOCIAION_PHYSICAL), 2656 1); 2657 2658 pldm_entity_association_tree_destroy(tree); 2659 } 2660 #endif 2661