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