1 #include "common/test/mocked_utils.hpp"
2 #include "common/utils.hpp"
3 #include "libpldmresponder/event_parser.hpp"
4 #include "libpldmresponder/pdr.hpp"
5 #include "libpldmresponder/pdr_utils.hpp"
6 #include "libpldmresponder/platform.hpp"
7 #include "libpldmresponder/platform_numeric_effecter.hpp"
8 #include "libpldmresponder/platform_state_effecter.hpp"
9 #include "libpldmresponder/platform_state_sensor.hpp"
10 
11 #include <sdbusplus/test/sdbus_mock.hpp>
12 #include <sdeventplus/event.hpp>
13 
14 #include <iostream>
15 
16 using namespace pldm::pdr;
17 using namespace pldm::utils;
18 using namespace pldm::responder;
19 using namespace pldm::responder::platform;
20 using namespace pldm::responder::pdr;
21 using namespace pldm::responder::pdr_utils;
22 
23 using ::testing::_;
24 using ::testing::Return;
25 using ::testing::StrEq;
26 
27 TEST(getPDR, testGoodPath)
28 {
29     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
30         requestPayload{};
31     auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
32     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
33 
34     struct pldm_get_pdr_req* request =
35         reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
36     request->request_count = 100;
37 
38     MockdBusHandler mockedUtils;
39     EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
40         .Times(5)
41         .WillRepeatedly(Return("foo.bar"));
42 
43     auto pdrRepo = pldm_pdr_init();
44     auto event = sdeventplus::Event::get_default();
45     Handler handler(&mockedUtils, "./pdr_jsons/state_effecter/good", pdrRepo,
46                     nullptr, nullptr, nullptr, nullptr, event);
47     Repo repo(pdrRepo);
48     ASSERT_EQ(repo.empty(), false);
49     auto response = handler.getPDR(req, requestPayloadLength);
50     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
51 
52     struct pldm_get_pdr_resp* resp =
53         reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
54     ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
55     ASSERT_EQ(2, resp->next_record_handle);
56     ASSERT_EQ(true, resp->response_count != 0);
57 
58     pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(resp->record_data);
59     ASSERT_EQ(hdr->record_handle, 1);
60     ASSERT_EQ(hdr->version, 1);
61 
62     pldm_pdr_destroy(pdrRepo);
63 }
64 
65 TEST(getPDR, testShortRead)
66 {
67     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
68         requestPayload{};
69     auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
70     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
71 
72     struct pldm_get_pdr_req* request =
73         reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
74     request->request_count = 1;
75 
76     MockdBusHandler mockedUtils;
77     EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
78         .Times(5)
79         .WillRepeatedly(Return("foo.bar"));
80 
81     auto pdrRepo = pldm_pdr_init();
82     auto event = sdeventplus::Event::get_default();
83     Handler handler(&mockedUtils, "./pdr_jsons/state_effecter/good", pdrRepo,
84                     nullptr, nullptr, nullptr, nullptr, event);
85     Repo repo(pdrRepo);
86     ASSERT_EQ(repo.empty(), false);
87     auto response = handler.getPDR(req, requestPayloadLength);
88     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
89     struct pldm_get_pdr_resp* resp =
90         reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
91     ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
92     ASSERT_EQ(1, resp->response_count);
93     pldm_pdr_destroy(pdrRepo);
94 }
95 
96 TEST(getPDR, testBadRecordHandle)
97 {
98     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
99         requestPayload{};
100     auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
101     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
102 
103     struct pldm_get_pdr_req* request =
104         reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
105     request->record_handle = 100000;
106     request->request_count = 1;
107 
108     MockdBusHandler mockedUtils;
109     EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
110         .Times(5)
111         .WillRepeatedly(Return("foo.bar"));
112 
113     auto pdrRepo = pldm_pdr_init();
114     auto event = sdeventplus::Event::get_default();
115     Handler handler(&mockedUtils, "./pdr_jsons/state_effecter/good", pdrRepo,
116                     nullptr, nullptr, nullptr, nullptr, event);
117     Repo repo(pdrRepo);
118     ASSERT_EQ(repo.empty(), false);
119     auto response = handler.getPDR(req, requestPayloadLength);
120     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
121 
122     ASSERT_EQ(responsePtr->payload[0], PLDM_PLATFORM_INVALID_RECORD_HANDLE);
123 
124     pldm_pdr_destroy(pdrRepo);
125 }
126 
127 TEST(getPDR, testNoNextRecord)
128 {
129     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
130         requestPayload{};
131     auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
132     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
133 
134     struct pldm_get_pdr_req* request =
135         reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
136     request->record_handle = 1;
137 
138     MockdBusHandler mockedUtils;
139     EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
140         .Times(5)
141         .WillRepeatedly(Return("foo.bar"));
142 
143     auto pdrRepo = pldm_pdr_init();
144     auto event = sdeventplus::Event::get_default();
145     Handler handler(&mockedUtils, "./pdr_jsons/state_effecter/good", pdrRepo,
146                     nullptr, nullptr, nullptr, nullptr, event);
147     Repo repo(pdrRepo);
148     ASSERT_EQ(repo.empty(), false);
149     auto response = handler.getPDR(req, requestPayloadLength);
150     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
151     struct pldm_get_pdr_resp* resp =
152         reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
153     ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
154     ASSERT_EQ(2, resp->next_record_handle);
155 
156     pldm_pdr_destroy(pdrRepo);
157 }
158 
159 TEST(getPDR, testFindPDR)
160 {
161     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
162         requestPayload{};
163     auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
164     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
165 
166     struct pldm_get_pdr_req* request =
167         reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
168     request->request_count = 100;
169 
170     MockdBusHandler mockedUtils;
171     EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
172         .Times(5)
173         .WillRepeatedly(Return("foo.bar"));
174 
175     auto pdrRepo = pldm_pdr_init();
176     auto event = sdeventplus::Event::get_default();
177     Handler handler(&mockedUtils, "./pdr_jsons/state_effecter/good", pdrRepo,
178                     nullptr, nullptr, nullptr, nullptr, event);
179     Repo repo(pdrRepo);
180     ASSERT_EQ(repo.empty(), false);
181     auto response = handler.getPDR(req, requestPayloadLength);
182 
183     // Let's try to find a PDR of type stateEffecter (= 11) and entity type =
184     // 100
185     bool found = false;
186     uint32_t handle = 0; // start asking for PDRs from recordHandle 0
187     while (!found)
188     {
189         request->record_handle = handle;
190         auto response = handler.getPDR(req, requestPayloadLength);
191         auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
192         struct pldm_get_pdr_resp* resp =
193             reinterpret_cast<struct pldm_get_pdr_resp*>(responsePtr->payload);
194         ASSERT_EQ(PLDM_SUCCESS, resp->completion_code);
195 
196         handle = resp->next_record_handle; // point to the next pdr in case
197                                            // current is not what we want
198 
199         pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(resp->record_data);
200         std::cerr << "PDR next record handle " << handle << "\n";
201         std::cerr << "PDR type " << hdr->type << "\n";
202         if (hdr->type == PLDM_STATE_EFFECTER_PDR)
203         {
204             pldm_state_effecter_pdr* pdr =
205                 reinterpret_cast<pldm_state_effecter_pdr*>(resp->record_data);
206             std::cerr << "PDR entity type " << pdr->entity_type << "\n";
207             if (pdr->entity_type == 100)
208             {
209                 found = true;
210                 // Rest of the PDR can be accessed as need be
211                 break;
212             }
213         }
214         if (!resp->next_record_handle) // no more records
215         {
216             break;
217         }
218     }
219     ASSERT_EQ(found, true);
220 
221     pldm_pdr_destroy(pdrRepo);
222 }
223 
224 TEST(setStateEffecterStatesHandler, testGoodRequest)
225 {
226     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
227         requestPayload{};
228     auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
229     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
230 
231     MockdBusHandler mockedUtils;
232     EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
233         .Times(5)
234         .WillRepeatedly(Return("foo.bar"));
235 
236     auto inPDRRepo = pldm_pdr_init();
237     auto outPDRRepo = pldm_pdr_init();
238     Repo outRepo(outPDRRepo);
239     auto event = sdeventplus::Event::get_default();
240     Handler handler(&mockedUtils, "./pdr_jsons/state_effecter/good", inPDRRepo,
241                     nullptr, nullptr, nullptr, nullptr, event);
242     handler.getPDR(req, requestPayloadLength);
243     Repo inRepo(inPDRRepo);
244     getRepoByType(inRepo, outRepo, PLDM_STATE_EFFECTER_PDR);
245     pdr_utils::PdrEntry e;
246     auto record1 = pdr::getRecordByHandle(outRepo, 2, e);
247     ASSERT_NE(record1, nullptr);
248     pldm_state_effecter_pdr* pdr =
249         reinterpret_cast<pldm_state_effecter_pdr*>(e.data);
250     EXPECT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR);
251 
252     std::vector<set_effecter_state_field> stateField;
253     stateField.push_back({PLDM_REQUEST_SET, 1});
254     stateField.push_back({PLDM_REQUEST_SET, 1});
255     std::string value = "xyz.openbmc_project.Foo.Bar.V1";
256     PropertyValue propertyValue = value;
257 
258     DBusMapping dbusMapping{"/foo/bar", "xyz.openbmc_project.Foo.Bar",
259                             "propertyName", "string"};
260 
261     EXPECT_CALL(mockedUtils, setDbusProperty(dbusMapping, propertyValue))
262         .Times(2);
263     auto rc = platform_state_effecter::setStateEffecterStatesHandler<
264         MockdBusHandler, Handler>(mockedUtils, handler, 0x1, stateField);
265     ASSERT_EQ(rc, 0);
266 
267     pldm_pdr_destroy(inPDRRepo);
268     pldm_pdr_destroy(outPDRRepo);
269 }
270 
271 TEST(setStateEffecterStatesHandler, testBadRequest)
272 {
273     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REQ_BYTES>
274         requestPayload{};
275     auto req = reinterpret_cast<pldm_msg*>(requestPayload.data());
276     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
277 
278     MockdBusHandler mockedUtils;
279     EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
280         .Times(5)
281         .WillRepeatedly(Return("foo.bar"));
282 
283     auto inPDRRepo = pldm_pdr_init();
284     auto outPDRRepo = pldm_pdr_init();
285     Repo outRepo(outPDRRepo);
286     auto event = sdeventplus::Event::get_default();
287     Handler handler(&mockedUtils, "./pdr_jsons/state_effecter/good", inPDRRepo,
288                     nullptr, nullptr, nullptr, nullptr, event);
289     handler.getPDR(req, requestPayloadLength);
290     Repo inRepo(inPDRRepo);
291     getRepoByType(inRepo, outRepo, PLDM_STATE_EFFECTER_PDR);
292     pdr_utils::PdrEntry e;
293     auto record1 = pdr::getRecordByHandle(outRepo, 2, e);
294     ASSERT_NE(record1, nullptr);
295     pldm_state_effecter_pdr* pdr =
296         reinterpret_cast<pldm_state_effecter_pdr*>(e.data);
297     EXPECT_EQ(pdr->hdr.type, PLDM_STATE_EFFECTER_PDR);
298 
299     std::vector<set_effecter_state_field> stateField;
300     stateField.push_back({PLDM_REQUEST_SET, 3});
301     stateField.push_back({PLDM_REQUEST_SET, 4});
302 
303     auto rc = platform_state_effecter::setStateEffecterStatesHandler<
304         MockdBusHandler, Handler>(mockedUtils, handler, 0x1, stateField);
305     ASSERT_EQ(rc, PLDM_PLATFORM_SET_EFFECTER_UNSUPPORTED_SENSORSTATE);
306 
307     rc = platform_state_effecter::setStateEffecterStatesHandler<MockdBusHandler,
308                                                                 Handler>(
309         mockedUtils, handler, 0x9, stateField);
310     ASSERT_EQ(rc, PLDM_PLATFORM_INVALID_EFFECTER_ID);
311 
312     stateField.push_back({PLDM_REQUEST_SET, 4});
313     rc = platform_state_effecter::setStateEffecterStatesHandler<MockdBusHandler,
314                                                                 Handler>(
315         mockedUtils, handler, 0x1, stateField);
316     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
317 
318     pldm_pdr_destroy(inPDRRepo);
319     pldm_pdr_destroy(outPDRRepo);
320 }
321 
322 TEST(setNumericEffecterValueHandler, testGoodRequest)
323 {
324     MockdBusHandler mockedUtils;
325     EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
326         .Times(5)
327         .WillRepeatedly(Return("foo.bar"));
328 
329     auto inPDRRepo = pldm_pdr_init();
330     auto numericEffecterPdrRepo = pldm_pdr_init();
331     Repo numericEffecterPDRs(numericEffecterPdrRepo);
332     auto event = sdeventplus::Event::get_default();
333     Handler handler(&mockedUtils, "./pdr_jsons/state_effecter/good", inPDRRepo,
334                     nullptr, nullptr, nullptr, nullptr, event);
335     Repo inRepo(inPDRRepo);
336     getRepoByType(inRepo, numericEffecterPDRs, PLDM_NUMERIC_EFFECTER_PDR);
337 
338     pdr_utils::PdrEntry e;
339     auto record4 = pdr::getRecordByHandle(numericEffecterPDRs, 4, e);
340     ASSERT_NE(record4, nullptr);
341 
342     pldm_numeric_effecter_value_pdr* pdr =
343         reinterpret_cast<pldm_numeric_effecter_value_pdr*>(e.data);
344     EXPECT_EQ(pdr->hdr.type, PLDM_NUMERIC_EFFECTER_PDR);
345 
346     uint16_t effecterId = 3;
347     uint32_t effecterValue = 2100000000; // 2036-07-18 21:20:00
348     PropertyValue propertyValue = static_cast<uint64_t>(effecterValue);
349 
350     DBusMapping dbusMapping{"/foo/bar", "xyz.openbmc_project.Foo.Bar",
351                             "propertyName", "uint64_t"};
352     EXPECT_CALL(mockedUtils, setDbusProperty(dbusMapping, propertyValue))
353         .Times(1);
354 
355     auto rc = platform_numeric_effecter::setNumericEffecterValueHandler<
356         MockdBusHandler, Handler>(
357         mockedUtils, handler, effecterId, PLDM_EFFECTER_DATA_SIZE_UINT32,
358         reinterpret_cast<uint8_t*>(&effecterValue), 4);
359     ASSERT_EQ(rc, 0);
360 
361     pldm_pdr_destroy(inPDRRepo);
362     pldm_pdr_destroy(numericEffecterPdrRepo);
363 }
364 
365 TEST(setNumericEffecterValueHandler, testBadRequest)
366 {
367     MockdBusHandler mockedUtils;
368     EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
369         .Times(5)
370         .WillRepeatedly(Return("foo.bar"));
371 
372     auto inPDRRepo = pldm_pdr_init();
373     auto numericEffecterPdrRepo = pldm_pdr_init();
374     Repo numericEffecterPDRs(numericEffecterPdrRepo);
375     auto event = sdeventplus::Event::get_default();
376     Handler handler(&mockedUtils, "./pdr_jsons/state_effecter/good", inPDRRepo,
377                     nullptr, nullptr, nullptr, nullptr, event);
378     Repo inRepo(inPDRRepo);
379     getRepoByType(inRepo, numericEffecterPDRs, PLDM_NUMERIC_EFFECTER_PDR);
380 
381     pdr_utils::PdrEntry e;
382     auto record4 = pdr::getRecordByHandle(numericEffecterPDRs, 4, e);
383     ASSERT_NE(record4, nullptr);
384 
385     pldm_numeric_effecter_value_pdr* pdr =
386         reinterpret_cast<pldm_numeric_effecter_value_pdr*>(e.data);
387     EXPECT_EQ(pdr->hdr.type, PLDM_NUMERIC_EFFECTER_PDR);
388 
389     uint16_t effecterId = 3;
390     uint64_t effecterValue = 9876543210;
391     auto rc = platform_numeric_effecter::setNumericEffecterValueHandler<
392         MockdBusHandler, Handler>(
393         mockedUtils, handler, effecterId, PLDM_EFFECTER_DATA_SIZE_SINT32,
394         reinterpret_cast<uint8_t*>(&effecterValue), 3);
395     ASSERT_EQ(rc, PLDM_ERROR_INVALID_DATA);
396 
397     pldm_pdr_destroy(inPDRRepo);
398     pldm_pdr_destroy(numericEffecterPdrRepo);
399 }
400 
401 TEST(parseStateSensor, allScenarios)
402 {
403     // Sample state sensor with SensorID - 1, EntityType - Processor Module(67)
404     // State Set ID - Operational Running Status(11), Supported States - 3,4
405     std::vector<uint8_t> sample1PDR{0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00,
406                                     0x00, 0x17, 0x00, 0x00, 0x00, 0x01, 0x00,
407                                     0x43, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
408                                     0x00, 0x01, 0x0b, 0x00, 0x01, 0x18};
409 
410     const auto& [terminusHandle1, sensorID1,
411                  sensorInfo1] = parseStateSensorPDR(sample1PDR);
412     const auto& [containerID1, entityType1,
413                  entityInstance1] = std::get<0>(sensorInfo1);
414     const auto& states1 = std::get<1>(sensorInfo1);
415     CompositeSensorStates statesCmp1{{3u, 4u}};
416 
417     ASSERT_EQ(le16toh(terminusHandle1), 0u);
418     ASSERT_EQ(le16toh(sensorID1), 1u);
419     ASSERT_EQ(le16toh(containerID1), 0u);
420     ASSERT_EQ(le16toh(entityType1), 67u);
421     ASSERT_EQ(le16toh(entityInstance1), 1u);
422     ASSERT_EQ(states1, statesCmp1);
423 
424     // Sample state sensor with SensorID - 2, EntityType - System Firmware(31)
425     // State Set ID - Availability(2), Supported States - 3,4,9,10,11,13
426     std::vector<uint8_t> sample2PDR{0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00,
427                                     0x00, 0x17, 0x00, 0x00, 0x00, 0x02, 0x00,
428                                     0x1F, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
429                                     0x00, 0x01, 0x02, 0x00, 0x02, 0x18, 0x2E};
430 
431     const auto& [terminusHandle2, sensorID2,
432                  sensorInfo2] = parseStateSensorPDR(sample2PDR);
433     const auto& [containerID2, entityType2,
434                  entityInstance2] = std::get<0>(sensorInfo2);
435     const auto& states2 = std::get<1>(sensorInfo2);
436     CompositeSensorStates statesCmp2{{3u, 4u, 9u, 10u, 11u, 13u}};
437 
438     ASSERT_EQ(le16toh(terminusHandle2), 0u);
439     ASSERT_EQ(le16toh(sensorID2), 2u);
440     ASSERT_EQ(le16toh(containerID2), 0u);
441     ASSERT_EQ(le16toh(entityType2), 31u);
442     ASSERT_EQ(le16toh(entityInstance2), 1u);
443     ASSERT_EQ(states2, statesCmp2);
444 
445     // Sample state sensor with SensorID - 3, EntityType - Virtual Machine
446     // Manager(33), Composite State Sensor -2 , State Set ID - Link State(33),
447     // Supported States - 1,2, State Set ID - Configuration State(15),
448     // Supported States - 1,2,3,4
449     std::vector<uint8_t> sample3PDR{
450         0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00, 0x17, 0x00, 0x00,
451         0x00, 0x03, 0x00, 0x21, 0x00, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00,
452         0x02, 0x21, 0x00, 0x01, 0x06, 0x0F, 0x00, 0x01, 0x1E};
453 
454     const auto& [terminusHandle3, sensorID3,
455                  sensorInfo3] = parseStateSensorPDR(sample3PDR);
456     const auto& [containerID3, entityType3,
457                  entityInstance3] = std::get<0>(sensorInfo3);
458     const auto& states3 = std::get<1>(sensorInfo3);
459     CompositeSensorStates statesCmp3{{1u, 2u}, {1u, 2u, 3u, 4u}};
460 
461     ASSERT_EQ(le16toh(terminusHandle3), 0u);
462     ASSERT_EQ(le16toh(sensorID3), 3u);
463     ASSERT_EQ(le16toh(containerID3), 1u);
464     ASSERT_EQ(le16toh(entityType3), 33u);
465     ASSERT_EQ(le16toh(entityInstance3), 2u);
466     ASSERT_EQ(states3, statesCmp3);
467 }
468 
469 TEST(StateSensorHandler, allScenarios)
470 {
471     using namespace pldm::responder::events;
472 
473     StateSensorHandler handler{"./event_jsons/good"};
474     constexpr uint8_t eventState0 = 0;
475     constexpr uint8_t eventState1 = 1;
476     constexpr uint8_t eventState2 = 2;
477     constexpr uint8_t eventState3 = 3;
478 
479     // Event Entry 1
480     {
481         StateSensorEntry entry{1, 64, 1, 0};
482         const auto& [dbusMapping, eventStateMap] = handler.getEventInfo(entry);
483         DBusMapping mapping{"/xyz/abc/def",
484                             "xyz.openbmc_project.example1.value", "value1",
485                             "string"};
486         ASSERT_EQ(mapping == dbusMapping, true);
487 
488         const auto& propValue0 = eventStateMap.at(eventState0);
489         const auto& propValue1 = eventStateMap.at(eventState1);
490         const auto& propValue2 = eventStateMap.at(eventState2);
491         PropertyValue value0{std::in_place_type<std::string>,
492                              "xyz.openbmc_project.State.Normal"};
493         PropertyValue value1{std::in_place_type<std::string>,
494                              "xyz.openbmc_project.State.Critical"};
495         PropertyValue value2{std::in_place_type<std::string>,
496                              "xyz.openbmc_project.State.Fatal"};
497         ASSERT_EQ(value0 == propValue0, true);
498         ASSERT_EQ(value1 == propValue1, true);
499         ASSERT_EQ(value2 == propValue2, true);
500     }
501 
502     // Event Entry 2
503     {
504         StateSensorEntry entry{1, 64, 1, 1};
505         const auto& [dbusMapping, eventStateMap] = handler.getEventInfo(entry);
506         DBusMapping mapping{"/xyz/abc/def",
507                             "xyz.openbmc_project.example2.value", "value2",
508                             "uint8_t"};
509         ASSERT_EQ(mapping == dbusMapping, true);
510 
511         const auto& propValue0 = eventStateMap.at(eventState2);
512         const auto& propValue1 = eventStateMap.at(eventState3);
513         PropertyValue value0{std::in_place_type<uint8_t>, 9};
514         PropertyValue value1{std::in_place_type<uint8_t>, 10};
515         ASSERT_EQ(value0 == propValue0, true);
516         ASSERT_EQ(value1 == propValue1, true);
517     }
518 
519     // Event Entry 3
520     {
521         StateSensorEntry entry{2, 67, 2, 0};
522         const auto& [dbusMapping, eventStateMap] = handler.getEventInfo(entry);
523         DBusMapping mapping{"/xyz/abc/ghi",
524                             "xyz.openbmc_project.example3.value", "value3",
525                             "bool"};
526         ASSERT_EQ(mapping == dbusMapping, true);
527 
528         const auto& propValue0 = eventStateMap.at(eventState0);
529         const auto& propValue1 = eventStateMap.at(eventState1);
530         PropertyValue value0{std::in_place_type<bool>, false};
531         PropertyValue value1{std::in_place_type<bool>, true};
532         ASSERT_EQ(value0 == propValue0, true);
533         ASSERT_EQ(value1 == propValue1, true);
534     }
535 
536     // Invalid Entry
537     {
538         StateSensorEntry entry{0, 0, 0, 0};
539         ASSERT_THROW(handler.getEventInfo(entry), std::out_of_range);
540     }
541 }
542 
543 TEST(TerminusLocatorPDR, BMCTerminusLocatorPDR)
544 {
545     auto inPDRRepo = pldm_pdr_init();
546     auto outPDRRepo = pldm_pdr_init();
547     Repo outRepo(outPDRRepo);
548     MockdBusHandler mockedUtils;
549     auto event = sdeventplus::Event::get_default();
550     Handler handler(&mockedUtils, "", inPDRRepo, nullptr, nullptr, nullptr,
551                     nullptr, event);
552     Repo inRepo(inPDRRepo);
553     getRepoByType(inRepo, outRepo, PLDM_TERMINUS_LOCATOR_PDR);
554 
555     // 1 BMC terminus locator PDR in the PDR repository
556     ASSERT_EQ(outRepo.getRecordCount(), 1);
557 
558     pdr_utils::PdrEntry entry;
559     auto record = pdr::getRecordByHandle(outRepo, 1, entry);
560     ASSERT_NE(record, nullptr);
561 
562     auto pdr = reinterpret_cast<const pldm_terminus_locator_pdr*>(entry.data);
563     EXPECT_EQ(pdr->hdr.record_handle, 1);
564     EXPECT_EQ(pdr->hdr.version, 1);
565     EXPECT_EQ(pdr->hdr.type, PLDM_TERMINUS_LOCATOR_PDR);
566     EXPECT_EQ(pdr->hdr.record_change_num, 0);
567     EXPECT_EQ(pdr->hdr.length,
568               sizeof(pldm_terminus_locator_pdr) - sizeof(pldm_pdr_hdr));
569     EXPECT_EQ(pdr->terminus_handle, TERMINUS_HANDLE);
570     EXPECT_EQ(pdr->validity, PLDM_TL_PDR_VALID);
571     EXPECT_EQ(pdr->tid, TERMINUS_ID);
572     EXPECT_EQ(pdr->container_id, 0);
573     EXPECT_EQ(pdr->terminus_locator_type, PLDM_TERMINUS_LOCATOR_TYPE_MCTP_EID);
574     EXPECT_EQ(pdr->terminus_locator_value_size,
575               sizeof(pldm_terminus_locator_type_mctp_eid));
576     auto locatorValue =
577         reinterpret_cast<const pldm_terminus_locator_type_mctp_eid*>(
578             pdr->terminus_locator_value);
579     EXPECT_EQ(locatorValue->eid, BmcMctpEid);
580     pldm_pdr_destroy(inPDRRepo);
581     pldm_pdr_destroy(outPDRRepo);
582 }
583 
584 TEST(getStateSensorReadingsHandler, testGoodRequest)
585 {
586     MockdBusHandler mockedUtils;
587     EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
588         .Times(1)
589         .WillRepeatedly(Return("foo.bar"));
590 
591     auto inPDRRepo = pldm_pdr_init();
592     auto outPDRRepo = pldm_pdr_init();
593     Repo outRepo(outPDRRepo);
594     auto event = sdeventplus::Event::get_default();
595     Handler handler(&mockedUtils, "./pdr_jsons/state_sensor/good", inPDRRepo,
596                     nullptr, nullptr, nullptr, nullptr, event);
597     Repo inRepo(inPDRRepo);
598     getRepoByType(inRepo, outRepo, PLDM_STATE_SENSOR_PDR);
599     pdr_utils::PdrEntry e;
600     auto record = pdr::getRecordByHandle(outRepo, 2, e);
601     ASSERT_NE(record, nullptr);
602     pldm_state_sensor_pdr* pdr =
603         reinterpret_cast<pldm_state_sensor_pdr*>(e.data);
604     EXPECT_EQ(pdr->hdr.type, PLDM_STATE_SENSOR_PDR);
605 
606     std::vector<get_sensor_state_field> stateField;
607     uint8_t compSensorCnt{};
608     uint8_t sensorRearmCnt = 1;
609 
610     MockdBusHandler handlerObj;
611     EXPECT_CALL(handlerObj,
612                 getDbusPropertyVariant(StrEq("/foo/bar"), StrEq("propertyName"),
613                                        StrEq("xyz.openbmc_project.Foo.Bar")))
614         .WillOnce(Return(
615             PropertyValue(std::string("xyz.openbmc_project.Foo.Bar.V0"))));
616 
617     auto rc = platform_state_sensor::getStateSensorReadingsHandler<
618         MockdBusHandler, Handler>(handlerObj, handler, 0x1, sensorRearmCnt,
619                                   compSensorCnt, stateField);
620     ASSERT_EQ(rc, 0);
621     ASSERT_EQ(compSensorCnt, 1);
622     ASSERT_EQ(stateField[0].sensor_op_state, PLDM_SENSOR_UNAVAILABLE);
623     ASSERT_EQ(stateField[0].present_state, PLDM_SENSOR_NORMAL);
624     ASSERT_EQ(stateField[0].previous_state, PLDM_SENSOR_UNKNOWN);
625     ASSERT_EQ(stateField[0].event_state, PLDM_SENSOR_UNKNOWN);
626 
627     pldm_pdr_destroy(inPDRRepo);
628     pldm_pdr_destroy(outPDRRepo);
629 }
630 
631 TEST(getStateSensorReadingsHandler, testBadRequest)
632 {
633     MockdBusHandler mockedUtils;
634     EXPECT_CALL(mockedUtils, getService(StrEq("/foo/bar"), _))
635         .Times(1)
636         .WillRepeatedly(Return("foo.bar"));
637 
638     auto inPDRRepo = pldm_pdr_init();
639     auto outPDRRepo = pldm_pdr_init();
640     Repo outRepo(outPDRRepo);
641     auto event = sdeventplus::Event::get_default();
642     Handler handler(&mockedUtils, "./pdr_jsons/state_sensor/good", inPDRRepo,
643                     nullptr, nullptr, nullptr, nullptr, event);
644     Repo inRepo(inPDRRepo);
645     getRepoByType(inRepo, outRepo, PLDM_STATE_SENSOR_PDR);
646     pdr_utils::PdrEntry e;
647     auto record = pdr::getRecordByHandle(outRepo, 2, e);
648     ASSERT_NE(record, nullptr);
649     pldm_state_sensor_pdr* pdr =
650         reinterpret_cast<pldm_state_sensor_pdr*>(e.data);
651     EXPECT_EQ(pdr->hdr.type, PLDM_STATE_SENSOR_PDR);
652 
653     std::vector<get_sensor_state_field> stateField;
654     uint8_t compSensorCnt{};
655     uint8_t sensorRearmCnt = 3;
656 
657     MockdBusHandler handlerObj;
658     auto rc = platform_state_sensor::getStateSensorReadingsHandler<
659         MockdBusHandler, Handler>(handlerObj, handler, 0x1, sensorRearmCnt,
660                                   compSensorCnt, stateField);
661     ASSERT_EQ(rc, PLDM_PLATFORM_REARM_UNAVAILABLE_IN_PRESENT_STATE);
662 
663     pldm_pdr_destroy(inPDRRepo);
664     pldm_pdr_destroy(outPDRRepo);
665 }
666