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