1 #include "common/instance_id.hpp"
2 #include "mock_terminus_manager.hpp"
3 #include "platform-mc/platform_manager.hpp"
4 #include "test/test_instance_id.hpp"
5 
6 #include <sdeventplus/event.hpp>
7 
8 #include <bitset>
9 
10 #include <gtest/gtest.h>
11 
12 class PlatformManagerTest : public testing::Test
13 {
14   protected:
PlatformManagerTest()15     PlatformManagerTest() :
16         bus(pldm::utils::DBusHandler::getBus()),
17         event(sdeventplus::Event::get_default()), instanceIdDb(),
18         reqHandler(pldmTransport, event, instanceIdDb, false,
19                    std::chrono::seconds(1), 2, std::chrono::milliseconds(100)),
20         mockTerminusManager(event, reqHandler, instanceIdDb, termini, nullptr),
21         platformManager(mockTerminusManager, termini)
22     {}
23 
24     PldmTransport* pldmTransport = nullptr;
25     sdbusplus::bus_t& bus;
26     sdeventplus::Event event;
27     TestInstanceIdDb instanceIdDb;
28     pldm::requester::Handler<pldm::requester::Request> reqHandler;
29     pldm::platform_mc::MockTerminusManager mockTerminusManager;
30     pldm::platform_mc::PlatformManager platformManager;
31     std::map<pldm_tid_t, std::shared_ptr<pldm::platform_mc::Terminus>> termini;
32 };
33 
TEST_F(PlatformManagerTest,initTerminusTest)34 TEST_F(PlatformManagerTest, initTerminusTest)
35 {
36     // Add terminus
37     auto mappedTid = mockTerminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
38     auto tid = mappedTid.value();
39     termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
40         tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
41     auto terminus = termini[tid];
42 
43     /* Set supported command by terminus */
44     auto size = PLDM_MAX_TYPES * (PLDM_MAX_CMDS_PER_TYPE / 8);
45     std::vector<uint8_t> pldmCmds(size);
46     uint8_t type = PLDM_PLATFORM;
47     uint8_t cmd = PLDM_GET_PDR;
48     auto idx = type * (PLDM_MAX_CMDS_PER_TYPE / 8) + (cmd / 8);
49     pldmCmds[idx] = pldmCmds[idx] | (1 << (cmd % 8));
50     cmd = PLDM_GET_PDR_REPOSITORY_INFO;
51     idx = type * (PLDM_MAX_CMDS_PER_TYPE / 8) + (cmd / 8);
52     pldmCmds[idx] = pldmCmds[idx] | (1 << (cmd % 8));
53     termini[tid]->setSupportedCommands(pldmCmds);
54 
55     // queue getPDRRepositoryInfo response
56     const size_t getPDRRepositoryInfoLen =
57         PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES;
58     std::array<uint8_t, sizeof(pldm_msg_hdr) + getPDRRepositoryInfoLen>
59         getPDRRepositoryInfoResp{
60             0x0, 0x02, 0x50, PLDM_SUCCESS,
61             0x0,                                     // repositoryState
62             0x0, 0x0,  0x0,  0x0,          0x0, 0x0, 0x0,
63             0x0, 0x0,  0x0,  0x0,          0x0, 0x0, // updateTime
64             0x0, 0x0,  0x0,  0x0,          0x0, 0x0, 0x0,
65             0x0, 0x0,  0x0,  0x0,          0x0, 0x0, // OEMUpdateTime
66             2,   0x0,  0x0,  0x0,                    // recordCount
67             0x0, 0x1,  0x0,  0x0,                    // repositorySize
68             59,  0x0,  0x0,  0x0,                    // largestRecordSize
69             0x0 // dataTransferHandleTimeout
70         };
71     auto rc = mockTerminusManager.enqueueResponse(
72         reinterpret_cast<pldm_msg*>(getPDRRepositoryInfoResp.data()),
73         sizeof(getPDRRepositoryInfoResp));
74     EXPECT_EQ(rc, PLDM_SUCCESS);
75 
76     // queue getPDR responses
77     const size_t getPdrRespLen = 81;
78     std::array<uint8_t, sizeof(pldm_msg_hdr) + getPdrRespLen> getPdrResp{
79         0x0, 0x02, 0x51, PLDM_SUCCESS, 0x1, 0x0, 0x0, 0x0, // nextRecordHandle
80         0x0, 0x0, 0x0, 0x0, // nextDataTransferHandle
81         0x5,                // transferFlag
82         69, 0x0,            // responseCount
83         // numeric Sensor PDR
84         0x0, 0x0, 0x0,
85         0x0,                     // record handle
86         0x1,                     // PDRHeaderVersion
87         PLDM_NUMERIC_SENSOR_PDR, // PDRType
88         0x0,
89         0x0,                     // recordChangeNumber
90         PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH +
91             PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH +
92             PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH,
93         0,                             // dataLength
94         0,
95         0,                             // PLDMTerminusHandle
96         0x1,
97         0x0,                           // sensorID=1
98         120,
99         0,                             // entityType=Power Supply(120)
100         1,
101         0,                             // entityInstanceNumber
102         0x1,
103         0x0,                           // containerID=1
104         PLDM_NO_INIT,                  // sensorInit
105         false,                         // sensorAuxiliaryNamesPDR
106         PLDM_SENSOR_UNIT_DEGRESS_C,    // baseUint(2)=degrees C
107         1,                             // unitModifier = 1
108         0,                             // rateUnit
109         0,                             // baseOEMUnitHandle
110         0,                             // auxUnit
111         0,                             // auxUnitModifier
112         0,                             // auxRateUnit
113         0,                             // rel
114         0,                             // auxOEMUnitHandle
115         true,                          // isLinear
116         PLDM_SENSOR_DATA_SIZE_UINT8,   // sensorDataSize
117         0, 0, 0xc0,
118         0x3f,                          // resolution=1.5
119         0, 0, 0x80,
120         0x3f,                          // offset=1.0
121         0,
122         0,                             // accuracy
123         0,                             // plusTolerance
124         0,                             // minusTolerance
125         2,                             // hysteresis
126         0,                             // supportedThresholds
127         0,                             // thresholdAndHysteresisVolatility
128         0, 0, 0x80,
129         0x3f,                          // stateTransistionInterval=1.0
130         0, 0, 0x80,
131         0x3f,                          // updateInverval=1.0
132         255,                           // maxReadable
133         0,                             // minReadable
134         PLDM_RANGE_FIELD_FORMAT_UINT8, // rangeFieldFormat
135         0,                             // rangeFieldsupport
136         0,                             // nominalValue
137         0,                             // normalMax
138         0,                             // normalMin
139         0,                             // warningHigh
140         0,                             // warningLow
141         0,                             // criticalHigh
142         0,                             // criticalLow
143         0,                             // fatalHigh
144         0                              // fatalLow
145     };
146     rc = mockTerminusManager.enqueueResponse(
147         reinterpret_cast<pldm_msg*>(getPdrResp.data()), sizeof(getPdrResp));
148     EXPECT_EQ(rc, PLDM_SUCCESS);
149 
150     const size_t getPdrAuxNameRespLen = 39;
151     std::array<uint8_t, sizeof(pldm_msg_hdr) + getPdrAuxNameRespLen>
152         getPdrAuxNameResp{
153             0x0, 0x02, 0x51, PLDM_SUCCESS, 0x0, 0x0, 0x0,
154             0x0,                // nextRecordHandle
155             0x0, 0x0, 0x0, 0x0, // nextDataTransferHandle
156             0x5,                // transferFlag
157             0x1b, 0x0,          // responseCount
158             // Common PDR Header
159             0x1, 0x0, 0x0,
160             0x0,                             // record handle
161             0x1,                             // PDRHeaderVersion
162             PLDM_ENTITY_AUXILIARY_NAMES_PDR, // PDRType
163             0x1,
164             0x0,                             // recordChangeNumber
165             0x11,
166             0,                               // dataLength
167             /* Entity Auxiliary Names PDR Data*/
168             3,
169             0x80, // entityType system software
170             0x1,
171             0x0,  // Entity instance number =1
172             0,
173             0,    // Overall system
174             0,    // shared Name Count one name only
175             01,   // nameStringCount
176             0x65, 0x6e, 0x00,
177             0x00, // Language Tag "en"
178             0x53, 0x00, 0x30, 0x00,
179             0x00  // Entity Name "S0"
180         };
181     rc = mockTerminusManager.enqueueResponse(
182         reinterpret_cast<pldm_msg*>(getPdrAuxNameResp.data()),
183         sizeof(getPdrAuxNameResp));
184     EXPECT_EQ(rc, PLDM_SUCCESS);
185 
186     stdexec::sync_wait(platformManager.initTerminus());
187     EXPECT_EQ(true, terminus->initialized);
188     EXPECT_EQ(2, terminus->pdrs.size());
189     EXPECT_EQ(1, terminus->numericSensors.size());
190     EXPECT_EQ("S0", terminus->getTerminusName().value());
191 }
192 
TEST_F(PlatformManagerTest,parseTerminusNameTest)193 TEST_F(PlatformManagerTest, parseTerminusNameTest)
194 {
195     // Add terminus
196     auto mappedTid = mockTerminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
197     auto tid = mappedTid.value();
198     termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
199         tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
200     auto terminus = termini[tid];
201 
202     /* Set supported command by terminus */
203     auto size = PLDM_MAX_TYPES * (PLDM_MAX_CMDS_PER_TYPE / 8);
204     std::vector<uint8_t> pldmCmds(size);
205     uint8_t type = PLDM_PLATFORM;
206     uint8_t cmd = PLDM_GET_PDR;
207     auto idx = type * (PLDM_MAX_CMDS_PER_TYPE / 8) + (cmd / 8);
208     pldmCmds[idx] = pldmCmds[idx] | (1 << (cmd % 8));
209     cmd = PLDM_GET_PDR_REPOSITORY_INFO;
210     idx = type * (PLDM_MAX_CMDS_PER_TYPE / 8) + (cmd / 8);
211     pldmCmds[idx] = pldmCmds[idx] | (1 << (cmd % 8));
212     termini[tid]->setSupportedCommands(pldmCmds);
213 
214     // queue getPDRRepositoryInfo response
215     const size_t getPDRRepositoryInfoLen =
216         PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES;
217     std::array<uint8_t, sizeof(pldm_msg_hdr) + getPDRRepositoryInfoLen>
218         getPDRRepositoryInfoResp{
219             0x0, 0x02, 0x50, PLDM_SUCCESS,
220             0x0,                                     // repositoryState
221             0x0, 0x0,  0x0,  0x0,          0x0, 0x0, 0x0,
222             0x0, 0x0,  0x0,  0x0,          0x0, 0x0, // updateTime
223             0x0, 0x0,  0x0,  0x0,          0x0, 0x0, 0x0,
224             0x0, 0x0,  0x0,  0x0,          0x0, 0x0, // OEMUpdateTime
225             2,   0x0,  0x0,  0x0,                    // recordCount
226             0x0, 0x1,  0x0,  0x0,                    // repositorySize
227             59,  0x0,  0x0,  0x0,                    // largestRecordSize
228             0x0 // dataTransferHandleTimeout
229         };
230     auto rc = mockTerminusManager.enqueueResponse(
231         reinterpret_cast<pldm_msg*>(getPDRRepositoryInfoResp.data()),
232         sizeof(getPDRRepositoryInfoResp));
233     EXPECT_EQ(rc, PLDM_SUCCESS);
234 
235     // queue getPDR responses
236     const size_t getPdrRespLen = 81;
237     std::array<uint8_t, sizeof(pldm_msg_hdr) + getPdrRespLen> getPdrResp{
238         0x0, 0x02, 0x51, PLDM_SUCCESS, 0x1, 0x0, 0x0, 0x0, // nextRecordHandle
239         0x0, 0x0, 0x0, 0x0, // nextDataTransferHandle
240         0x5,                // transferFlag
241         69, 0x0,            // responseCount
242         // numeric Sensor PDR
243         0x0, 0x0, 0x0,
244         0x0,                     // record handle
245         0x1,                     // PDRHeaderVersion
246         PLDM_NUMERIC_SENSOR_PDR, // PDRType
247         0x0,
248         0x0,                     // recordChangeNumber
249         PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH +
250             PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH +
251             PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH,
252         0,                             // dataLength
253         0,
254         0,                             // PLDMTerminusHandle
255         0x1,
256         0x0,                           // sensorID=1
257         120,
258         0,                             // entityType=Power Supply(120)
259         1,
260         0,                             // entityInstanceNumber
261         0x1,
262         0x0,                           // containerID=1
263         PLDM_NO_INIT,                  // sensorInit
264         false,                         // sensorAuxiliaryNamesPDR
265         PLDM_SENSOR_UNIT_DEGRESS_C,    // baseUint(2)=degrees C
266         1,                             // unitModifier = 1
267         0,                             // rateUnit
268         0,                             // baseOEMUnitHandle
269         0,                             // auxUnit
270         0,                             // auxUnitModifier
271         0,                             // auxRateUnit
272         0,                             // rel
273         0,                             // auxOEMUnitHandle
274         true,                          // isLinear
275         PLDM_SENSOR_DATA_SIZE_UINT8,   // sensorDataSize
276         0, 0, 0xc0,
277         0x3f,                          // resolution=1.5
278         0, 0, 0x80,
279         0x3f,                          // offset=1.0
280         0,
281         0,                             // accuracy
282         0,                             // plusTolerance
283         0,                             // minusTolerance
284         2,                             // hysteresis
285         0,                             // supportedThresholds
286         0,                             // thresholdAndHysteresisVolatility
287         0, 0, 0x80,
288         0x3f,                          // stateTransistionInterval=1.0
289         0, 0, 0x80,
290         0x3f,                          // updateInverval=1.0
291         255,                           // maxReadable
292         0,                             // minReadable
293         PLDM_RANGE_FIELD_FORMAT_UINT8, // rangeFieldFormat
294         0,                             // rangeFieldsupport
295         0,                             // nominalValue
296         0,                             // normalMax
297         0,                             // normalMin
298         0,                             // warningHigh
299         0,                             // warningLow
300         0,                             // criticalHigh
301         0,                             // criticalLow
302         0,                             // fatalHigh
303         0                              // fatalLow
304     };
305     rc = mockTerminusManager.enqueueResponse(
306         reinterpret_cast<pldm_msg*>(getPdrResp.data()), sizeof(getPdrResp));
307     EXPECT_EQ(rc, PLDM_SUCCESS);
308 
309     const size_t getPdrAuxNameRespLen = 39;
310     std::array<uint8_t, sizeof(pldm_msg_hdr) + getPdrAuxNameRespLen>
311         getPdrAuxNameResp{
312             0x0, 0x02, 0x51, PLDM_SUCCESS, 0x0, 0x0, 0x0,
313             0x0,                // nextRecordHandle
314             0x0, 0x0, 0x0, 0x0, // nextDataTransferHandle
315             0x5,                // transferFlag
316             0x1b, 0x0,          // responseCount
317             // Common PDR Header
318             0x1, 0x0, 0x0,
319             0x0,                             // record handle
320             0x1,                             // PDRHeaderVersion
321             PLDM_ENTITY_AUXILIARY_NAMES_PDR, // PDRType
322             0x1,
323             0x0,                             // recordChangeNumber
324             0x11,
325             0,                               // dataLength
326             /* Entity Auxiliary Names PDR Data*/
327             3,
328             0x80, // entityType system software
329             0x1,
330             0x0,  // Entity instance number =1
331             0,
332             0,    // Overall system
333             0,    // shared Name Count one name only
334             01,   // nameStringCount
335             0x65, 0x6e, 0x00,
336             0x00, // Language Tag "en"
337             0x53, 0x00, 0x30, 0x00,
338             0x00  // Entity Name "S0"
339         };
340     rc = mockTerminusManager.enqueueResponse(
341         reinterpret_cast<pldm_msg*>(getPdrAuxNameResp.data()),
342         sizeof(getPdrAuxNameResp));
343     EXPECT_EQ(rc, PLDM_SUCCESS);
344 
345     stdexec::sync_wait(platformManager.initTerminus());
346     EXPECT_EQ(true, terminus->initialized);
347     EXPECT_EQ(2, terminus->pdrs.size());
348     EXPECT_EQ("S0", terminus->getTerminusName().value());
349 }
350 
TEST_F(PlatformManagerTest,initTerminusDontSupportGetPDRTest)351 TEST_F(PlatformManagerTest, initTerminusDontSupportGetPDRTest)
352 {
353     // Add terminus
354     auto mappedTid = mockTerminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
355     auto tid = mappedTid.value();
356     termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
357         tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
358     auto terminus = termini[tid];
359 
360     /* Set supported command by terminus */
361     auto size = PLDM_MAX_TYPES * (PLDM_MAX_CMDS_PER_TYPE / 8);
362     std::vector<uint8_t> pldmCmds(size);
363     uint8_t type = PLDM_PLATFORM;
364     uint8_t cmd = PLDM_GET_PDR_REPOSITORY_INFO;
365     auto idx = type * (PLDM_MAX_CMDS_PER_TYPE / 8) + (cmd / 8);
366     pldmCmds[idx] = pldmCmds[idx] | (1 << (cmd % 8));
367     termini[tid]->setSupportedCommands(pldmCmds);
368 
369     // queue getPDRRepositoryInfo response
370     const size_t getPDRRepositoryInfoLen =
371         PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES;
372     std::array<uint8_t, sizeof(pldm_msg_hdr) + getPDRRepositoryInfoLen>
373         getPDRRepositoryInfoResp{
374             0x0, 0x02, 0x50, PLDM_SUCCESS,
375             0x0,                                     // repositoryState
376             0x0, 0x0,  0x0,  0x0,          0x0, 0x0, 0x0,
377             0x0, 0x0,  0x0,  0x0,          0x0, 0x0, // updateTime
378             0x0, 0x0,  0x0,  0x0,          0x0, 0x0, 0x0,
379             0x0, 0x0,  0x0,  0x0,          0x0, 0x0, // OEMUpdateTime
380             1,   0x0,  0x0,  0x0,                    // recordCount
381             0x0, 0x1,  0x0,  0x0,                    // repositorySize
382             59,  0x0,  0x0,  0x0,                    // largestRecordSize
383             0x0 // dataTransferHandleTimeout
384         };
385     auto rc = mockTerminusManager.enqueueResponse(
386         reinterpret_cast<pldm_msg*>(getPDRRepositoryInfoResp.data()),
387         sizeof(getPDRRepositoryInfoResp));
388     EXPECT_EQ(rc, PLDM_SUCCESS);
389 
390     // queue getPDR responses
391     const size_t getPdrRespLen = 81;
392     std::array<uint8_t, sizeof(pldm_msg_hdr) + getPdrRespLen> getPdrResp{
393         0x0, 0x02, 0x51, PLDM_SUCCESS, 0x0, 0x0, 0x0, 0x0, // nextRecordHandle
394         0x0, 0x0, 0x0, 0x0, // nextDataTransferHandle
395         0x5,                // transferFlag
396         69, 0x0,            // responseCount
397         // numeric Sensor PDR
398         0x1, 0x0, 0x0,
399         0x0,                     // record handle
400         0x1,                     // PDRHeaderVersion
401         PLDM_NUMERIC_SENSOR_PDR, // PDRType
402         0x0,
403         0x0,                     // recordChangeNumber
404         PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH +
405             PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH +
406             PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH,
407         0,                             // dataLength
408         0,
409         0,                             // PLDMTerminusHandle
410         0x1,
411         0x0,                           // sensorID=1
412         120,
413         0,                             // entityType=Power Supply(120)
414         1,
415         0,                             // entityInstanceNumber
416         0x1,
417         0x0,                           // containerID=1
418         PLDM_NO_INIT,                  // sensorInit
419         false,                         // sensorAuxiliaryNamesPDR
420         PLDM_SENSOR_UNIT_DEGRESS_C,    // baseUint(2)=degrees C
421         1,                             // unitModifier = 1
422         0,                             // rateUnit
423         0,                             // baseOEMUnitHandle
424         0,                             // auxUnit
425         0,                             // auxUnitModifier
426         0,                             // auxRateUnit
427         0,                             // rel
428         0,                             // auxOEMUnitHandle
429         true,                          // isLinear
430         PLDM_SENSOR_DATA_SIZE_UINT8,   // sensorDataSize
431         0, 0, 0xc0,
432         0x3f,                          // resolution=1.5
433         0, 0, 0x80,
434         0x3f,                          // offset=1.0
435         0,
436         0,                             // accuracy
437         0,                             // plusTolerance
438         0,                             // minusTolerance
439         2,                             // hysteresis
440         0,                             // supportedThresholds
441         0,                             // thresholdAndHysteresisVolatility
442         0, 0, 0x80,
443         0x3f,                          // stateTransistionInterval=1.0
444         0, 0, 0x80,
445         0x3f,                          // updateInverval=1.0
446         255,                           // maxReadable
447         0,                             // minReadable
448         PLDM_RANGE_FIELD_FORMAT_UINT8, // rangeFieldFormat
449         0,                             // rangeFieldsupport
450         0,                             // nominalValue
451         0,                             // normalMax
452         0,                             // normalMin
453         0,                             // warningHigh
454         0,                             // warningLow
455         0,                             // criticalHigh
456         0,                             // criticalLow
457         0,                             // fatalHigh
458         0                              // fatalLow
459     };
460     rc = mockTerminusManager.enqueueResponse(
461         reinterpret_cast<pldm_msg*>(getPdrResp.data()), sizeof(getPdrResp));
462     EXPECT_EQ(rc, PLDM_SUCCESS);
463 
464     stdexec::sync_wait(platformManager.initTerminus());
465     EXPECT_EQ(true, terminus->initialized);
466     EXPECT_EQ(0, terminus->pdrs.size());
467 }
468 
TEST_F(PlatformManagerTest,negativeInitTerminusTest1)469 TEST_F(PlatformManagerTest, negativeInitTerminusTest1)
470 {
471     // terminus doesn't Type2 support
472     auto mappedTid = mockTerminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
473     auto tid = mappedTid.value();
474     termini[tid] =
475         std::make_shared<pldm::platform_mc::Terminus>(tid, 1 << PLDM_BASE);
476     auto terminus = termini[tid];
477 
478     stdexec::sync_wait(platformManager.initTerminus());
479     EXPECT_EQ(true, terminus->initialized);
480     EXPECT_EQ(0, terminus->pdrs.size());
481     EXPECT_EQ(0, terminus->numericSensors.size());
482 }
483 
TEST_F(PlatformManagerTest,negativeInitTerminusTest2)484 TEST_F(PlatformManagerTest, negativeInitTerminusTest2)
485 {
486     // terminus responses error
487     auto mappedTid = mockTerminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
488     auto tid = mappedTid.value();
489     termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
490         tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
491     auto terminus = termini[tid];
492 
493     // queue getPDRRepositoryInfo response cc=PLDM_ERROR
494     const size_t getPDRRepositoryInfoLen = 1;
495     std::array<uint8_t, sizeof(pldm_msg_hdr) + getPDRRepositoryInfoLen>
496         getPDRRepositoryInfoResp{0x0, 0x02, 0x50, PLDM_ERROR};
497     auto rc = mockTerminusManager.enqueueResponse(
498         reinterpret_cast<pldm_msg*>(getPDRRepositoryInfoResp.data()),
499         sizeof(getPDRRepositoryInfoResp));
500     EXPECT_EQ(rc, PLDM_SUCCESS);
501 
502     // queue getPDR responses cc=PLDM_ERROR
503     const size_t getPdrRespLen = 1;
504     std::array<uint8_t, sizeof(pldm_msg_hdr) + getPdrRespLen> getPdrResp{
505         0x0, 0x02, 0x51, PLDM_ERROR};
506     rc = mockTerminusManager.enqueueResponse(
507         reinterpret_cast<pldm_msg*>(getPdrResp.data()), sizeof(getPdrResp));
508     EXPECT_EQ(rc, PLDM_SUCCESS);
509 
510     stdexec::sync_wait(platformManager.initTerminus());
511     EXPECT_EQ(true, terminus->initialized);
512     EXPECT_EQ(0, terminus->pdrs.size());
513     EXPECT_EQ(0, terminus->numericSensors.size());
514 }
515