1 #include "common/utils.hpp"
2 #include "mocked_utils.hpp"
3
4 #include <libpldm/platform.h>
5 #include <linux/mctp.h>
6
7 #include <gtest/gtest.h>
8
9 using namespace pldm::utils;
10
TEST(GetInventoryObjects,testForEmptyObject)11 TEST(GetInventoryObjects, testForEmptyObject)
12 {
13 ObjectValueTree result =
14 DBusHandler::getInventoryObjects<GetManagedEmptyObject>();
15 EXPECT_TRUE(result.empty());
16 }
17
TEST(GetInventoryObjects,testForObject)18 TEST(GetInventoryObjects, testForObject)
19 {
20 std::string path = "/foo/bar";
21 std::string service = "foo.bar";
22 auto result = DBusHandler::getInventoryObjects<GetManagedObject>();
23 EXPECT_EQ(result[path].begin()->first, service);
24 auto function =
25 std::get<bool>(result[path][service][std::string("Functional")]);
26 auto model =
27 std::get<std::string>(result[path][service][std::string("Model")]);
28 EXPECT_FALSE(result.empty());
29 EXPECT_TRUE(function);
30 EXPECT_EQ(model, std::string("1234 - 00Z"));
31 }
32
TEST(printBuffer,testprintBufferGoodPath)33 TEST(printBuffer, testprintBufferGoodPath)
34 {
35 std::vector<uint8_t> buffer = {10, 12, 14, 25, 233};
36 std::ostringstream localString;
37 auto coutBuffer = std::cout.rdbuf();
38 std::cout.rdbuf(localString.rdbuf());
39 printBuffer(false, buffer);
40 std::cout.rdbuf(coutBuffer);
41 EXPECT_EQ(localString.str(), "Rx: 0a 0c 0e 19 e9 \n");
42 localString.str("");
43 localString.clear();
44 std::cerr << localString.str() << std::endl;
45 buffer = {12, 0, 200, 12, 255};
46 std::cout.rdbuf(localString.rdbuf());
47 printBuffer(true, buffer);
48 std::cout.rdbuf(coutBuffer);
49 EXPECT_EQ(localString.str(), "Tx: 0c 00 c8 0c ff \n");
50 }
51
TEST(printBuffer,testprintBufferBadPath)52 TEST(printBuffer, testprintBufferBadPath)
53 {
54 std::vector<uint8_t> buffer = {};
55 std::ostringstream localString;
56 auto coutBuffer = std::cout.rdbuf();
57 std::cout.rdbuf(localString.rdbuf());
58 printBuffer(false, buffer);
59 EXPECT_EQ(localString.str(), "");
60 printBuffer(true, buffer);
61 std::cout.rdbuf(coutBuffer);
62 EXPECT_EQ(localString.str(), "");
63 }
64
TEST(decodeDate,testGooduintToDate)65 TEST(decodeDate, testGooduintToDate)
66 {
67 uint64_t data = 20191212115959;
68 uint16_t year = 2019;
69 uint8_t month = 12;
70 uint8_t day = 12;
71 uint8_t hours = 11;
72 uint8_t minutes = 59;
73 uint8_t seconds = 59;
74
75 uint16_t retyear = 0;
76 uint8_t retmonth = 0;
77 uint8_t retday = 0;
78 uint8_t rethours = 0;
79 uint8_t retminutes = 0;
80 uint8_t retseconds = 0;
81
82 auto ret = uintToDate(data, &retyear, &retmonth, &retday, &rethours,
83 &retminutes, &retseconds);
84
85 EXPECT_EQ(ret, true);
86 EXPECT_EQ(year, retyear);
87 EXPECT_EQ(month, retmonth);
88 EXPECT_EQ(day, retday);
89 EXPECT_EQ(hours, rethours);
90 EXPECT_EQ(minutes, retminutes);
91 EXPECT_EQ(seconds, retseconds);
92 }
93
TEST(decodeDate,testBaduintToDate)94 TEST(decodeDate, testBaduintToDate)
95 {
96 uint64_t data = 10191212115959;
97
98 uint16_t retyear = 0;
99 uint8_t retmonth = 0;
100 uint8_t retday = 0;
101 uint8_t rethours = 0;
102 uint8_t retminutes = 0;
103 uint8_t retseconds = 0;
104
105 auto ret = uintToDate(data, &retyear, &retmonth, &retday, &rethours,
106 &retminutes, &retseconds);
107
108 EXPECT_EQ(ret, false);
109 }
110
TEST(parseEffecterData,testGoodDecodeEffecterData)111 TEST(parseEffecterData, testGoodDecodeEffecterData)
112 {
113 std::vector<uint8_t> effecterData = {1, 1, 0, 1};
114 uint8_t effecterCount = 2;
115 set_effecter_state_field stateField0 = {1, 1};
116 set_effecter_state_field stateField1 = {0, 1};
117
118 auto effecterField = parseEffecterData(effecterData, effecterCount);
119 EXPECT_NE(effecterField, std::nullopt);
120 EXPECT_EQ(effecterCount, effecterField->size());
121
122 std::vector<set_effecter_state_field> stateField = effecterField.value();
123 EXPECT_EQ(stateField[0].set_request, stateField0.set_request);
124 EXPECT_EQ(stateField[0].effecter_state, stateField0.effecter_state);
125 EXPECT_EQ(stateField[1].set_request, stateField1.set_request);
126 EXPECT_EQ(stateField[1].effecter_state, stateField1.effecter_state);
127 }
128
TEST(parseEffecterData,testBadDecodeEffecterData)129 TEST(parseEffecterData, testBadDecodeEffecterData)
130 {
131 std::vector<uint8_t> effecterData = {0, 1, 0, 1, 0, 1};
132 uint8_t effecterCount = 2;
133
134 auto effecterField = parseEffecterData(effecterData, effecterCount);
135
136 EXPECT_EQ(effecterField, std::nullopt);
137 }
138
TEST(FindStateEffecterPDR,testOneMatch)139 TEST(FindStateEffecterPDR, testOneMatch)
140 {
141 auto repo = pldm_pdr_init();
142 uint8_t tid = 1;
143 uint16_t entityID = 33;
144 uint16_t stateSetId = 196;
145
146 std::vector<uint8_t> pdr(
147 sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
148 sizeof(struct state_effecter_possible_states));
149
150 auto rec = new (pdr.data()) pldm_state_effecter_pdr;
151
152 auto state = new (rec->possible_states) state_effecter_possible_states;
153
154 rec->hdr.type = 11;
155 rec->hdr.record_handle = 1;
156 rec->entity_type = 33;
157 rec->container_id = 0;
158 rec->composite_effecter_count = 1;
159 state->state_set_id = 196;
160 state->possible_states_size = 1;
161
162 uint32_t handle = 0;
163 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
164
165 auto record = findStateEffecterPDR(tid, entityID, stateSetId, repo);
166
167 EXPECT_EQ(pdr, record[0]);
168
169 pldm_pdr_destroy(repo);
170 }
171
TEST(FindStateEffecterPDR,testNoMatch)172 TEST(FindStateEffecterPDR, testNoMatch)
173 {
174 auto repo = pldm_pdr_init();
175 uint8_t tid = 1;
176 uint16_t entityID = 44;
177 uint16_t stateSetId = 196;
178
179 std::vector<uint8_t> pdr(
180 sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
181 sizeof(struct state_effecter_possible_states));
182
183 auto rec = new (pdr.data()) pldm_state_effecter_pdr;
184
185 auto state = new (rec->possible_states) state_effecter_possible_states;
186
187 rec->hdr.type = 11;
188 rec->hdr.record_handle = 1;
189 rec->entity_type = 33;
190 rec->container_id = 0;
191 rec->composite_effecter_count = 1;
192 state->state_set_id = 196;
193 state->possible_states_size = 1;
194
195 uint32_t handle = 0;
196 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
197
198 auto record = findStateEffecterPDR(tid, entityID, stateSetId, repo);
199
200 EXPECT_EQ(record.empty(), true);
201
202 pldm_pdr_destroy(repo);
203 }
204
TEST(FindStateEffecterPDR,testEmptyRepo)205 TEST(FindStateEffecterPDR, testEmptyRepo)
206 {
207 auto repo = pldm_pdr_init();
208 uint8_t tid = 1;
209 uint16_t entityID = 33;
210 uint16_t stateSetId = 196;
211
212 std::vector<uint8_t> pdr(
213 sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
214 sizeof(struct state_effecter_possible_states));
215
216 auto record = findStateEffecterPDR(tid, entityID, stateSetId, repo);
217
218 EXPECT_EQ(record.empty(), true);
219
220 pldm_pdr_destroy(repo);
221 }
222
TEST(FindStateEffecterPDR,testMoreMatch)223 TEST(FindStateEffecterPDR, testMoreMatch)
224 {
225 auto repo = pldm_pdr_init();
226 uint8_t tid = 1;
227
228 std::vector<uint8_t> pdr(
229 sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
230 sizeof(struct state_effecter_possible_states));
231
232 auto rec = new (pdr.data()) pldm_state_effecter_pdr;
233
234 auto state = new (rec->possible_states) state_effecter_possible_states;
235
236 rec->hdr.type = 11;
237 rec->hdr.record_handle = 1;
238 rec->entity_type = 31;
239 rec->container_id = 0;
240 rec->composite_effecter_count = 1;
241 state->state_set_id = 129;
242 state->possible_states_size = 1;
243
244 uint32_t handle = 0;
245 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
246
247 std::vector<uint8_t> pdr_second(
248 sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
249 sizeof(struct state_effecter_possible_states));
250
251 auto rec_second = new (pdr_second.data()) pldm_state_effecter_pdr;
252
253 auto state_second = new (rec_second->possible_states)
254 state_effecter_possible_states;
255
256 rec_second->hdr.type = 11;
257 rec_second->hdr.record_handle = 2;
258 rec_second->entity_type = 31;
259 rec_second->container_id = 0;
260 rec_second->composite_effecter_count = 1;
261 state_second->state_set_id = 129;
262 state_second->possible_states_size = 1;
263
264 handle = 0;
265 ASSERT_EQ(pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), false, 1,
266 &handle),
267 0);
268
269 uint16_t entityID_ = 31;
270 uint16_t stateSetId_ = 129;
271
272 auto record = findStateEffecterPDR(tid, entityID_, stateSetId_, repo);
273
274 EXPECT_EQ(pdr, record[0]);
275 EXPECT_EQ(pdr_second, record[1]);
276
277 pldm_pdr_destroy(repo);
278 }
279
TEST(FindStateEffecterPDR,testManyNoMatch)280 TEST(FindStateEffecterPDR, testManyNoMatch)
281 {
282 auto repo = pldm_pdr_init();
283 uint8_t tid = 1;
284 uint16_t entityID = 33;
285 uint16_t stateSetId = 196;
286
287 std::vector<uint8_t> pdr(
288 sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
289 sizeof(struct state_effecter_possible_states));
290
291 auto rec = new (pdr.data()) pldm_state_effecter_pdr;
292
293 auto state = new (rec->possible_states) state_effecter_possible_states;
294
295 rec->hdr.type = 11;
296 rec->hdr.record_handle = 1;
297 rec->entity_type = 34;
298 rec->container_id = 0;
299 rec->composite_effecter_count = 1;
300 state->state_set_id = 198;
301 state->possible_states_size = 1;
302
303 uint32_t handle = 0;
304 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
305
306 std::vector<uint8_t> pdr_second(
307 sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
308 sizeof(struct state_effecter_possible_states));
309
310 auto rec_second = new (pdr_second.data()) pldm_state_effecter_pdr;
311
312 auto state_second = new (rec_second->possible_states)
313 state_effecter_possible_states;
314
315 rec_second->hdr.type = 11;
316 rec_second->hdr.record_handle = 2;
317 rec_second->entity_type = 39;
318 rec_second->container_id = 0;
319 rec_second->composite_effecter_count = 1;
320 state_second->state_set_id = 169;
321 state_second->possible_states_size = 1;
322
323 handle = 0;
324 ASSERT_EQ(pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), false, 1,
325 &handle),
326 0);
327
328 auto record = findStateEffecterPDR(tid, entityID, stateSetId, repo);
329
330 EXPECT_EQ(record.empty(), true);
331
332 pldm_pdr_destroy(repo);
333 }
334
TEST(FindStateEffecterPDR,testOneMatchOneNoMatch)335 TEST(FindStateEffecterPDR, testOneMatchOneNoMatch)
336 {
337 auto repo = pldm_pdr_init();
338 uint8_t tid = 1;
339 uint16_t entityID = 67;
340 uint16_t stateSetId = 192;
341
342 std::vector<uint8_t> pdr(
343 sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
344 sizeof(struct state_effecter_possible_states));
345
346 auto rec = new (pdr.data()) pldm_state_effecter_pdr;
347
348 auto state = new (rec->possible_states) state_effecter_possible_states;
349
350 rec->hdr.type = 11;
351 rec->hdr.record_handle = 1;
352 rec->entity_type = 32;
353 rec->container_id = 0;
354 rec->composite_effecter_count = 1;
355 state->state_set_id = 198;
356 state->possible_states_size = 1;
357
358 uint32_t handle = 0;
359 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
360
361 std::vector<uint8_t> pdr_second(
362 sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
363 sizeof(struct state_effecter_possible_states));
364
365 auto rec_second = new (pdr_second.data()) pldm_state_effecter_pdr;
366
367 auto state_second = new (rec_second->possible_states)
368 state_effecter_possible_states;
369
370 rec_second->hdr.type = 11;
371 rec_second->hdr.record_handle = 2;
372 rec_second->entity_type = 67;
373 rec_second->container_id = 0;
374 rec_second->composite_effecter_count = 1;
375 state_second->state_set_id = 192;
376 state_second->possible_states_size = 1;
377
378 handle = 0;
379 ASSERT_EQ(pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), false, 1,
380 &handle),
381 0);
382
383 auto record = findStateEffecterPDR(tid, entityID, stateSetId, repo);
384
385 EXPECT_EQ(pdr_second, record[0]);
386 EXPECT_EQ(record.size(), 1);
387
388 pldm_pdr_destroy(repo);
389 }
390
TEST(FindStateEffecterPDR,testOneMatchManyNoMatch)391 TEST(FindStateEffecterPDR, testOneMatchManyNoMatch)
392 {
393 auto repo = pldm_pdr_init();
394 uint8_t tid = 1;
395 uint16_t entityID = 67;
396 uint16_t stateSetId = 192;
397
398 std::vector<uint8_t> pdr(
399 sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
400 sizeof(struct state_effecter_possible_states));
401
402 auto rec = new (pdr.data()) pldm_state_effecter_pdr;
403
404 auto state = new (rec->possible_states) state_effecter_possible_states;
405
406 rec->hdr.type = 11;
407 rec->hdr.record_handle = 1;
408 rec->entity_type = 32;
409 rec->container_id = 0;
410 rec->composite_effecter_count = 1;
411 state->state_set_id = 198;
412 state->possible_states_size = 1;
413
414 uint32_t handle = 0;
415 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
416
417 std::vector<uint8_t> pdr_second(
418 sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
419 sizeof(struct state_effecter_possible_states));
420
421 auto rec_second = new (pdr_second.data()) pldm_state_effecter_pdr;
422
423 auto state_second = new (rec_second->possible_states)
424 state_effecter_possible_states;
425
426 rec_second->hdr.type = 11;
427 rec_second->hdr.record_handle = 2;
428 rec_second->entity_type = 67;
429 rec_second->container_id = 0;
430 rec_second->composite_effecter_count = 1;
431 state_second->state_set_id = 192;
432 state_second->possible_states_size = 1;
433
434 handle = 0;
435 ASSERT_EQ(pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), false, 1,
436 &handle),
437 0);
438
439 std::vector<uint8_t> pdr_third(
440 sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
441 sizeof(struct state_effecter_possible_states));
442
443 auto rec_third = new (pdr_third.data()) pldm_state_effecter_pdr;
444
445 auto state_third = new (rec_third->possible_states)
446 state_effecter_possible_states;
447
448 rec_third->hdr.type = 11;
449 rec_third->hdr.record_handle = 3;
450 rec_third->entity_type = 69;
451 rec_third->container_id = 0;
452 rec_third->composite_effecter_count = 1;
453 state_third->state_set_id = 199;
454 state_third->possible_states_size = 1;
455
456 auto record = findStateEffecterPDR(tid, entityID, stateSetId, repo);
457
458 EXPECT_EQ(pdr_second, record[0]);
459 EXPECT_EQ(record.size(), 1);
460
461 pldm_pdr_destroy(repo);
462 }
463
TEST(FindStateEffecterPDR,testCompositeEffecter)464 TEST(FindStateEffecterPDR, testCompositeEffecter)
465 {
466 auto repo = pldm_pdr_init();
467 uint8_t tid = 1;
468 uint16_t entityID = 67;
469 uint16_t stateSetId = 192;
470
471 std::vector<uint8_t> pdr(
472 sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
473 sizeof(struct state_effecter_possible_states) * 3);
474
475 auto rec = new (pdr.data()) pldm_state_effecter_pdr;
476 auto state_start = rec->possible_states;
477
478 auto state = new (state_start) state_effecter_possible_states;
479
480 rec->hdr.type = 11;
481 rec->hdr.record_handle = 1;
482 rec->entity_type = 67;
483 rec->container_id = 0;
484 rec->composite_effecter_count = 3;
485 state->state_set_id = 198;
486 state->possible_states_size = 1;
487
488 state_start += state->possible_states_size + sizeof(state->state_set_id) +
489 sizeof(state->possible_states_size);
490 state = new (state_start) state_effecter_possible_states;
491 state->state_set_id = 193;
492 state->possible_states_size = 1;
493
494 state_start += state->possible_states_size + sizeof(state->state_set_id) +
495 sizeof(state->possible_states_size);
496 state = new (state_start) state_effecter_possible_states;
497 state->state_set_id = 192;
498 state->possible_states_size = 1;
499
500 uint32_t handle = 0;
501 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
502
503 auto record = findStateEffecterPDR(tid, entityID, stateSetId, repo);
504
505 EXPECT_EQ(pdr, record[0]);
506
507 pldm_pdr_destroy(repo);
508 }
509
TEST(FindStateEffecterPDR,testNoMatchCompositeEffecter)510 TEST(FindStateEffecterPDR, testNoMatchCompositeEffecter)
511 {
512 auto repo = pldm_pdr_init();
513 uint8_t tid = 1;
514 uint16_t entityID = 67;
515 uint16_t stateSetId = 192;
516
517 std::vector<uint8_t> pdr(
518 sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
519 sizeof(struct state_effecter_possible_states) * 3);
520
521 auto rec = new (pdr.data()) pldm_state_effecter_pdr;
522 auto state_start = rec->possible_states;
523
524 auto state = new (state_start) state_effecter_possible_states;
525
526 rec->hdr.type = 11;
527 rec->hdr.record_handle = 1;
528 rec->entity_type = 34;
529 rec->container_id = 0;
530 rec->composite_effecter_count = 3;
531 state->state_set_id = 198;
532 state->possible_states_size = 1;
533
534 state_start += state->possible_states_size + sizeof(state->state_set_id) +
535 sizeof(state->possible_states_size);
536 state = new (state_start) state_effecter_possible_states;
537 state->state_set_id = 193;
538 state->possible_states_size = 1;
539
540 state_start += state->possible_states_size + sizeof(state->state_set_id) +
541 sizeof(state->possible_states_size);
542 state = new (state_start) state_effecter_possible_states;
543 state->state_set_id = 123;
544 state->possible_states_size = 1;
545
546 uint32_t handle = 0;
547 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
548
549 auto record = findStateEffecterPDR(tid, entityID, stateSetId, repo);
550
551 EXPECT_EQ(record.empty(), true);
552
553 pldm_pdr_destroy(repo);
554 }
555
TEST(FindStateSensorPDR,testOneMatch)556 TEST(FindStateSensorPDR, testOneMatch)
557 {
558 auto repo = pldm_pdr_init();
559 uint8_t tid = 1;
560 uint16_t entityID = 5;
561 uint16_t stateSetId = 1;
562
563 std::vector<uint8_t> pdr(
564 sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
565 sizeof(struct state_sensor_possible_states));
566
567 auto rec = new (pdr.data()) pldm_state_sensor_pdr;
568
569 auto state = new (rec->possible_states) state_sensor_possible_states;
570
571 rec->hdr.type = 4;
572 rec->hdr.record_handle = 1;
573 rec->entity_type = 5;
574 rec->container_id = 0;
575 rec->composite_sensor_count = 1;
576 state->state_set_id = 1;
577 state->possible_states_size = 1;
578
579 uint32_t handle = 0;
580 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
581
582 auto record = findStateSensorPDR(tid, entityID, stateSetId, repo);
583
584 EXPECT_EQ(pdr, record[0]);
585
586 pldm_pdr_destroy(repo);
587 }
588
TEST(FindStateSensorPDR,testNoMatch)589 TEST(FindStateSensorPDR, testNoMatch)
590 {
591 auto repo = pldm_pdr_init();
592 uint8_t tid = 1;
593 uint16_t entityID = 5;
594 uint16_t stateSetId = 1;
595
596 std::vector<uint8_t> pdr(
597 sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
598 sizeof(struct state_sensor_possible_states));
599
600 auto rec = new (pdr.data()) pldm_state_sensor_pdr;
601
602 auto state = new (rec->possible_states) state_sensor_possible_states;
603
604 rec->hdr.type = 4;
605 rec->hdr.record_handle = 1;
606 rec->entity_type = 55;
607 rec->container_id = 0;
608 rec->composite_sensor_count = 1;
609 state->state_set_id = 1;
610 state->possible_states_size = 1;
611
612 uint32_t handle = 0;
613 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
614
615 auto record = findStateSensorPDR(tid, entityID, stateSetId, repo);
616
617 EXPECT_EQ(record.empty(), true);
618
619 pldm_pdr_destroy(repo);
620 }
621
TEST(FindStateSensorPDR,testEmptyRepo)622 TEST(FindStateSensorPDR, testEmptyRepo)
623 {
624 auto repo = pldm_pdr_init();
625 uint8_t tid = 1;
626 uint16_t entityID = 5;
627 uint16_t stateSetId = 1;
628
629 std::vector<uint8_t> pdr(
630 sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
631 sizeof(struct state_sensor_possible_states));
632
633 auto record = findStateSensorPDR(tid, entityID, stateSetId, repo);
634
635 EXPECT_EQ(record.empty(), true);
636
637 pldm_pdr_destroy(repo);
638 }
639
TEST(FindStateSensorPDR,testMoreMatch)640 TEST(FindStateSensorPDR, testMoreMatch)
641 {
642 auto repo = pldm_pdr_init();
643 uint8_t tid = 1;
644
645 std::vector<uint8_t> pdr(
646 sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
647 sizeof(struct state_sensor_possible_states));
648
649 auto rec = new (pdr.data()) pldm_state_sensor_pdr;
650
651 auto state = new (rec->possible_states) state_sensor_possible_states;
652
653 rec->hdr.type = 4;
654 rec->hdr.record_handle = 1;
655 rec->entity_type = 5;
656 rec->container_id = 0;
657 rec->composite_sensor_count = 1;
658 state->state_set_id = 1;
659 state->possible_states_size = 1;
660
661 uint32_t handle = 0;
662 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
663
664 std::vector<uint8_t> pdr_second(
665 sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
666 sizeof(struct state_sensor_possible_states));
667
668 auto rec_second = new (pdr_second.data()) pldm_state_sensor_pdr;
669
670 auto state_second = new (rec_second->possible_states)
671 state_sensor_possible_states;
672
673 rec_second->hdr.type = 4;
674 rec_second->hdr.record_handle = 2;
675 rec_second->entity_type = 5;
676 rec_second->container_id = 0;
677 rec_second->composite_sensor_count = 1;
678 state_second->state_set_id = 1;
679 state_second->possible_states_size = 1;
680
681 handle = 0;
682 ASSERT_EQ(pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), false, 1,
683 &handle),
684 0);
685
686 uint16_t entityID_ = 5;
687 uint16_t stateSetId_ = 1;
688
689 auto record = findStateSensorPDR(tid, entityID_, stateSetId_, repo);
690
691 EXPECT_EQ(pdr, record[0]);
692 EXPECT_EQ(pdr_second, record[1]);
693
694 pldm_pdr_destroy(repo);
695 }
696
TEST(FindStateSensorPDR,testManyNoMatch)697 TEST(FindStateSensorPDR, testManyNoMatch)
698 {
699 auto repo = pldm_pdr_init();
700 uint8_t tid = 1;
701 uint16_t entityID = 5;
702 uint16_t stateSetId = 1;
703
704 std::vector<uint8_t> pdr(
705 sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
706 sizeof(struct state_sensor_possible_states));
707
708 auto rec = new (pdr.data()) pldm_state_sensor_pdr;
709
710 auto state = new (rec->possible_states) state_sensor_possible_states;
711
712 rec->hdr.type = 4;
713 rec->hdr.record_handle = 1;
714 rec->entity_type = 56;
715 rec->container_id = 0;
716 rec->composite_sensor_count = 1;
717 state->state_set_id = 2;
718 state->possible_states_size = 1;
719
720 uint32_t handle = 0;
721 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
722
723 std::vector<uint8_t> pdr_second(
724 sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
725 sizeof(struct state_sensor_possible_states));
726
727 auto rec_second = new (pdr_second.data()) pldm_state_sensor_pdr;
728
729 auto state_second = new (rec_second->possible_states)
730 state_sensor_possible_states;
731
732 rec_second->hdr.type = 4;
733 rec_second->hdr.record_handle = 2;
734 rec_second->entity_type = 66;
735 rec_second->container_id = 0;
736 rec_second->composite_sensor_count = 1;
737 state_second->state_set_id = 3;
738 state_second->possible_states_size = 1;
739
740 handle = 0;
741 ASSERT_EQ(pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), false, 1,
742 &handle),
743 0);
744
745 auto record = findStateSensorPDR(tid, entityID, stateSetId, repo);
746
747 EXPECT_EQ(record.empty(), true);
748
749 pldm_pdr_destroy(repo);
750 }
751
TEST(FindStateSensorPDR,testOneMatchOneNoMatch)752 TEST(FindStateSensorPDR, testOneMatchOneNoMatch)
753 {
754 auto repo = pldm_pdr_init();
755 uint8_t tid = 1;
756 uint16_t entityID = 5;
757 uint16_t stateSetId = 1;
758
759 std::vector<uint8_t> pdr(
760 sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
761 sizeof(struct state_sensor_possible_states));
762
763 auto rec = new (pdr.data()) pldm_state_sensor_pdr;
764
765 auto state = new (rec->possible_states) state_sensor_possible_states;
766
767 rec->hdr.type = 4;
768 rec->hdr.record_handle = 1;
769 rec->entity_type = 10;
770 rec->container_id = 0;
771 rec->composite_sensor_count = 1;
772 state->state_set_id = 20;
773 state->possible_states_size = 1;
774
775 uint32_t handle = 0;
776 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
777
778 std::vector<uint8_t> pdr_second(
779 sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
780 sizeof(struct state_sensor_possible_states));
781
782 auto rec_second = new (pdr_second.data()) pldm_state_sensor_pdr;
783
784 auto state_second = new (rec_second->possible_states)
785 state_sensor_possible_states;
786
787 rec_second->hdr.type = 4;
788 rec_second->hdr.record_handle = 2;
789 rec_second->entity_type = 5;
790 rec_second->container_id = 0;
791 rec_second->composite_sensor_count = 1;
792 state_second->state_set_id = 1;
793 state_second->possible_states_size = 1;
794
795 handle = 0;
796 ASSERT_EQ(pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), false, 1,
797 &handle),
798 0);
799
800 auto record = findStateSensorPDR(tid, entityID, stateSetId, repo);
801
802 EXPECT_EQ(pdr_second, record[0]);
803 EXPECT_EQ(record.size(), 1);
804
805 pldm_pdr_destroy(repo);
806 }
807
TEST(FindStateSensorPDR,testOneMatchManyNoMatch)808 TEST(FindStateSensorPDR, testOneMatchManyNoMatch)
809 {
810 auto repo = pldm_pdr_init();
811 uint8_t tid = 1;
812 uint16_t entityID = 5;
813 uint16_t stateSetId = 1;
814
815 std::vector<uint8_t> pdr(
816 sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
817 sizeof(struct state_sensor_possible_states));
818
819 auto rec = new (pdr.data()) pldm_state_sensor_pdr;
820
821 auto state = new (rec->possible_states) state_sensor_possible_states;
822
823 rec->hdr.type = 4;
824 rec->hdr.record_handle = 1;
825 rec->entity_type = 6;
826 rec->container_id = 0;
827 rec->composite_sensor_count = 1;
828 state->state_set_id = 9;
829 state->possible_states_size = 1;
830
831 uint32_t handle = 0;
832 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
833
834 std::vector<uint8_t> pdr_second(
835 sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
836 sizeof(struct state_sensor_possible_states));
837
838 auto rec_second = new (pdr_second.data()) pldm_state_sensor_pdr;
839
840 auto state_second = new (rec_second->possible_states)
841 state_sensor_possible_states;
842
843 rec_second->hdr.type = 4;
844 rec_second->hdr.record_handle = 2;
845 rec_second->entity_type = 5;
846 rec_second->container_id = 0;
847 rec_second->composite_sensor_count = 1;
848 state_second->state_set_id = 1;
849 state_second->possible_states_size = 1;
850
851 handle = 0;
852 ASSERT_EQ(pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), false, 1,
853 &handle),
854 0);
855
856 std::vector<uint8_t> pdr_third(
857 sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
858 sizeof(struct state_sensor_possible_states));
859
860 auto rec_third = new (pdr_third.data()) pldm_state_sensor_pdr;
861
862 auto state_third = new (rec_third->possible_states)
863 state_sensor_possible_states;
864
865 rec_third->hdr.type = 4;
866 rec_third->hdr.record_handle = 3;
867 rec_third->entity_type = 7;
868 rec_third->container_id = 0;
869 rec_third->composite_sensor_count = 1;
870 state_third->state_set_id = 12;
871 state_third->possible_states_size = 1;
872
873 auto record = findStateSensorPDR(tid, entityID, stateSetId, repo);
874
875 EXPECT_EQ(pdr_second, record[0]);
876 EXPECT_EQ(record.size(), 1);
877
878 pldm_pdr_destroy(repo);
879 }
880
TEST(FindStateSensorPDR,testCompositeSensor)881 TEST(FindStateSensorPDR, testCompositeSensor)
882 {
883 auto repo = pldm_pdr_init();
884 uint8_t tid = 1;
885 uint16_t entityID = 5;
886 uint16_t stateSetId = 1;
887
888 std::vector<uint8_t> pdr(
889 sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
890 sizeof(struct state_sensor_possible_states) * 3);
891
892 auto rec = new (pdr.data()) pldm_state_sensor_pdr;
893 auto state_start = rec->possible_states;
894
895 auto state = new (state_start) state_sensor_possible_states;
896
897 rec->hdr.type = 4;
898 rec->hdr.record_handle = 1;
899 rec->entity_type = 5;
900 rec->container_id = 0;
901 rec->composite_sensor_count = 3;
902 state->state_set_id = 2;
903 state->possible_states_size = 1;
904
905 state_start += state->possible_states_size + sizeof(state->state_set_id) +
906 sizeof(state->possible_states_size);
907 state = new (state_start) state_sensor_possible_states;
908
909 state->state_set_id = 7;
910 state->possible_states_size = 1;
911
912 state_start += state->possible_states_size + sizeof(state->state_set_id) +
913 sizeof(state->possible_states_size);
914 state = new (state_start) state_sensor_possible_states;
915
916 state->state_set_id = 1;
917 state->possible_states_size = 1;
918
919 uint32_t handle = 0;
920 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
921
922 auto record = findStateSensorPDR(tid, entityID, stateSetId, repo);
923
924 EXPECT_EQ(pdr, record[0]);
925
926 pldm_pdr_destroy(repo);
927 }
928
TEST(FindStateSensorPDR,testNoMatchCompositeSensor)929 TEST(FindStateSensorPDR, testNoMatchCompositeSensor)
930 {
931 auto repo = pldm_pdr_init();
932 uint8_t tid = 1;
933 uint16_t entityID = 5;
934 uint16_t stateSetId = 1;
935
936 std::vector<uint8_t> pdr(
937 sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
938 sizeof(struct state_sensor_possible_states) * 3);
939
940 auto rec = new (pdr.data()) pldm_state_sensor_pdr;
941 auto state_start = rec->possible_states;
942
943 auto state = new (state_start) state_sensor_possible_states;
944
945 rec->hdr.type = 4;
946 rec->hdr.record_handle = 1;
947 rec->entity_type = 21;
948 rec->container_id = 0;
949 rec->composite_sensor_count = 3;
950 state->state_set_id = 15;
951 state->possible_states_size = 1;
952
953 state_start += state->possible_states_size + sizeof(state->state_set_id) +
954 sizeof(state->possible_states_size);
955 state = new (state_start) state_sensor_possible_states;
956 state->state_set_id = 19;
957 state->possible_states_size = 1;
958
959 state_start += state->possible_states_size + sizeof(state->state_set_id) +
960 sizeof(state->possible_states_size);
961 state = new (state_start) state_sensor_possible_states;
962 state->state_set_id = 39;
963 state->possible_states_size = 1;
964
965 uint32_t handle = 0;
966 ASSERT_EQ(pldm_pdr_add(repo, pdr.data(), pdr.size(), false, 1, &handle), 0);
967
968 auto record = findStateSensorPDR(tid, entityID, stateSetId, repo);
969
970 EXPECT_EQ(record.empty(), true);
971
972 pldm_pdr_destroy(repo);
973 }
974
TEST(toString,allTestCases)975 TEST(toString, allTestCases)
976 {
977 variable_field buffer{};
978 constexpr std::string_view str1{};
979 auto returnStr1 = toString(buffer);
980 EXPECT_EQ(returnStr1, str1);
981
982 constexpr std::string_view str2{"0penBmc"};
983 constexpr std::array<uint8_t, 7> bufferArr1{0x30, 0x70, 0x65, 0x6e,
984 0x42, 0x6d, 0x63};
985 buffer.ptr = bufferArr1.data();
986 buffer.length = bufferArr1.size();
987 auto returnStr2 = toString(buffer);
988 EXPECT_EQ(returnStr2, str2);
989
990 constexpr std::string_view str3{"0pen mc"};
991 // \xa0 - the non-breaking space in ISO-8859-1
992 constexpr std::array<uint8_t, 7> bufferArr2{0x30, 0x70, 0x65, 0x6e,
993 0xa0, 0x6d, 0x63};
994 buffer.ptr = bufferArr2.data();
995 buffer.length = bufferArr2.size();
996 auto returnStr3 = toString(buffer);
997 EXPECT_EQ(returnStr3, str3);
998 }
999
TEST(Split,allTestCases)1000 TEST(Split, allTestCases)
1001 {
1002 std::string s1 = "aa,bb,cc,dd";
1003 auto results1 = split(s1, ",");
1004 EXPECT_EQ(results1[0], "aa");
1005 EXPECT_EQ(results1[1], "bb");
1006 EXPECT_EQ(results1[2], "cc");
1007 EXPECT_EQ(results1[3], "dd");
1008
1009 std::string s2 = "aa||bb||cc||dd";
1010 auto results2 = split(s2, "||");
1011 EXPECT_EQ(results2[0], "aa");
1012 EXPECT_EQ(results2[1], "bb");
1013 EXPECT_EQ(results2[2], "cc");
1014 EXPECT_EQ(results2[3], "dd");
1015
1016 std::string s3 = " aa || bb||cc|| dd";
1017 auto results3 = split(s3, "||", " ");
1018 EXPECT_EQ(results3[0], "aa");
1019 EXPECT_EQ(results3[1], "bb");
1020 EXPECT_EQ(results3[2], "cc");
1021 EXPECT_EQ(results3[3], "dd");
1022
1023 std::string s4 = "aa\\\\bb\\cc\\dd";
1024 auto results4 = split(s4, "\\");
1025 EXPECT_EQ(results4[0], "aa");
1026 EXPECT_EQ(results4[1], "bb");
1027 EXPECT_EQ(results4[2], "cc");
1028 EXPECT_EQ(results4[3], "dd");
1029
1030 std::string s5 = "aa\\";
1031 auto results5 = split(s5, "\\");
1032 EXPECT_EQ(results5[0], "aa");
1033 }
1034
TEST(ValidEID,allTestCases)1035 TEST(ValidEID, allTestCases)
1036 {
1037 auto rc = isValidEID(MCTP_ADDR_NULL);
1038 EXPECT_EQ(rc, false);
1039 rc = isValidEID(MCTP_ADDR_ANY);
1040 EXPECT_EQ(rc, false);
1041 rc = isValidEID(1);
1042 EXPECT_EQ(rc, false);
1043 rc = isValidEID(2);
1044 EXPECT_EQ(rc, false);
1045 rc = isValidEID(3);
1046 EXPECT_EQ(rc, false);
1047 rc = isValidEID(4);
1048 EXPECT_EQ(rc, false);
1049 rc = isValidEID(5);
1050 EXPECT_EQ(rc, false);
1051 rc = isValidEID(6);
1052 EXPECT_EQ(rc, false);
1053 rc = isValidEID(7);
1054 EXPECT_EQ(rc, false);
1055 rc = isValidEID(MCTP_START_VALID_EID);
1056 EXPECT_EQ(rc, true);
1057 rc = isValidEID(254);
1058 EXPECT_EQ(rc, true);
1059 }
1060
TEST(TrimNameForDbus,goodTest)1061 TEST(TrimNameForDbus, goodTest)
1062 {
1063 std::string name = "Name with space";
1064 std::string_view expectedName = "Name_with__space";
1065 std::string_view result = trimNameForDbus(name);
1066 EXPECT_EQ(expectedName, result);
1067 name = "Name 1\0"; // NOLINT(bugprone-string-literal-with-embedded-nul)
1068 expectedName = "Name_1";
1069 result = trimNameForDbus(name);
1070 EXPECT_EQ(expectedName, result);
1071 }
1072
TEST(dbusPropValuesToDouble,goodTest)1073 TEST(dbusPropValuesToDouble, goodTest)
1074 {
1075 double value = 0;
1076 bool ret =
1077 dbusPropValuesToDouble("uint8_t", static_cast<uint8_t>(0x12), &value);
1078 EXPECT_EQ(true, ret);
1079 EXPECT_EQ(0x12, value);
1080 ret =
1081 dbusPropValuesToDouble("int16_t", static_cast<int16_t>(0x1234), &value);
1082 EXPECT_EQ(true, ret);
1083 EXPECT_EQ(0x1234, value);
1084 ret = dbusPropValuesToDouble("uint16_t", static_cast<uint16_t>(0x8234),
1085 &value);
1086 EXPECT_EQ(true, ret);
1087 EXPECT_EQ(0x8234, value);
1088 ret = dbusPropValuesToDouble("int32_t", static_cast<int32_t>(0x12345678),
1089 &value);
1090 EXPECT_EQ(true, ret);
1091 EXPECT_EQ(0x12345678, value);
1092 ret = dbusPropValuesToDouble("uint32_t", static_cast<uint32_t>(0x82345678),
1093 &value);
1094 EXPECT_EQ(true, ret);
1095 EXPECT_EQ(0x82345678, value);
1096 ret = dbusPropValuesToDouble(
1097 "int64_t", static_cast<int64_t>(0x1234567898765432), &value);
1098 EXPECT_EQ(true, ret);
1099 EXPECT_EQ(0x1234567898765432, value);
1100 ret = dbusPropValuesToDouble(
1101 "uint64_t", static_cast<uint64_t>(0x8234567898765432), &value);
1102 EXPECT_EQ(true, ret);
1103 EXPECT_EQ(0x8234567898765432, value);
1104 ret = dbusPropValuesToDouble("double", static_cast<double>(1234.5678),
1105 &value);
1106 EXPECT_EQ(true, ret);
1107 EXPECT_EQ(1234.5678, value);
1108 }
1109
TEST(dbusPropValuesToDouble,badTest)1110 TEST(dbusPropValuesToDouble, badTest)
1111 {
1112 double value = std::numeric_limits<double>::quiet_NaN();
1113 /* Type and Data variant are different */
1114 bool ret =
1115 dbusPropValuesToDouble("uint8_t", static_cast<uint16_t>(0x12), &value);
1116 EXPECT_EQ(false, ret);
1117 /* Unsupported Types */
1118 ret = dbusPropValuesToDouble("string", static_cast<std::string>("hello"),
1119 &value);
1120 EXPECT_EQ(false, ret);
1121 ret = dbusPropValuesToDouble("bool", static_cast<bool>(true), &value);
1122 EXPECT_EQ(false, ret);
1123 ret = dbusPropValuesToDouble("vector<uint8_t>",
1124 static_cast<std::string>("hello"), &value);
1125 EXPECT_EQ(false, ret);
1126 ret = dbusPropValuesToDouble("vector<string>",
1127 static_cast<std::string>("hello"), &value);
1128 EXPECT_EQ(false, ret);
1129 /* Support Type but Data Type is unsupported */
1130 ret = dbusPropValuesToDouble("double", static_cast<std::string>("hello"),
1131 &value);
1132 EXPECT_EQ(false, ret);
1133 /* Null pointer */
1134 ret = dbusPropValuesToDouble("double", static_cast<std::string>("hello"),
1135 nullptr);
1136 EXPECT_EQ(false, ret);
1137 }
1138
TEST(FruFieldValuestring,goodTest)1139 TEST(FruFieldValuestring, goodTest)
1140 {
1141 std::vector<uint8_t> data = {0x41, 0x6d, 0x70, 0x65, 0x72, 0x65};
1142 std::string expectedString = "Ampere";
1143 auto result = fruFieldValuestring(data.data(), data.size());
1144 EXPECT_EQ(expectedString, result);
1145 }
1146
TEST(FruFieldValuestring,BadTest)1147 TEST(FruFieldValuestring, BadTest)
1148 {
1149 std::vector<uint8_t> data = {0x41, 0x6d, 0x70, 0x65, 0x72, 0x65};
1150 auto result = fruFieldValuestring(data.data(), 0);
1151 EXPECT_EQ(std::nullopt, result);
1152 result = fruFieldValuestring(nullptr, data.size());
1153 EXPECT_EQ(std::nullopt, result);
1154 }
1155
TEST(fruFieldParserU32,goodTest)1156 TEST(fruFieldParserU32, goodTest)
1157 {
1158 std::vector<uint8_t> data = {0x10, 0x12, 0x14, 0x25};
1159 uint32_t expectedU32 = 0x25141210;
1160 auto result = fruFieldParserU32(data.data(), data.size());
1161 EXPECT_EQ(expectedU32, result.value());
1162 }
1163
TEST(fruFieldParserU32,BadTest)1164 TEST(fruFieldParserU32, BadTest)
1165 {
1166 std::vector<uint8_t> data = {0x10, 0x12, 0x14, 0x25};
1167 auto result = fruFieldParserU32(data.data(), data.size() - 1);
1168 EXPECT_EQ(std::nullopt, result);
1169 result = fruFieldParserU32(nullptr, data.size());
1170 EXPECT_EQ(std::nullopt, result);
1171 }
1172