Gitiles
Code Review Sign In
gerrit.openbmc.org / openbmc / pldm / 1170a5476169033f24c199899b403774c08f3bbf / . / platform-mc / test / platform_manager_test.cpp
blob: 8afad3517fa750d11ac47df5560e381a23fb840a [file] [log] [blame]
Gilbert Chende2a1322022-05-24 15:35:21 +0100[diff] [blame]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
12class PlatformManagerTest : public testing::Test
13{
14 protected:
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
34TEST_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 1, 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(
Thu Nguyen98831af2024-07-30 09:51:00 +0000[diff] [blame]72 reinterpret_cast<pldm_msg*>(getPDRRepositoryInfoResp.data()),
Gilbert Chende2a1322022-05-24 15:35:21 +0100[diff] [blame]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, 0x0, 0x0, 0x0, 0x0, // nextRecordHandle
80 0x0, 0x0, 0x0, 0x0, // nextDataTransferHandle
81 0x5, // transferFlag
82 69, 0x0, // responseCount
83 // numeric Sensor PDR
84 0x1, 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 };
Thu Nguyen98831af2024-07-30 09:51:00 +0000[diff] [blame]146 rc = mockTerminusManager.enqueueResponse(
147 reinterpret_cast<pldm_msg*>(getPdrResp.data()), sizeof(getPdrResp));
Gilbert Chende2a1322022-05-24 15:35:21 +0100[diff] [blame]148 EXPECT_EQ(rc, PLDM_SUCCESS);
149
150 stdexec::sync_wait(platformManager.initTerminus());
151 EXPECT_EQ(true, terminus->initialized);
152 EXPECT_EQ(1, terminus->pdrs.size());
153}
154
Thu Nguyenb8cf46b2024-06-15 02:44:35 +0000[diff] [blame]155TEST_F(PlatformManagerTest, parseTerminusNameTest)
156{
157 // Add terminus
158 auto mappedTid = mockTerminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
159 auto tid = mappedTid.value();
160 termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
161 tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
162 auto terminus = termini[tid];
163
164 /* Set supported command by terminus */
165 auto size = PLDM_MAX_TYPES * (PLDM_MAX_CMDS_PER_TYPE / 8);
166 std::vector<uint8_t> pldmCmds(size);
167 uint8_t type = PLDM_PLATFORM;
168 uint8_t cmd = PLDM_GET_PDR;
169 auto idx = type * (PLDM_MAX_CMDS_PER_TYPE / 8) + (cmd / 8);
170 pldmCmds[idx] = pldmCmds[idx] | (1 << (cmd % 8));
171 cmd = PLDM_GET_PDR_REPOSITORY_INFO;
172 idx = type * (PLDM_MAX_CMDS_PER_TYPE / 8) + (cmd / 8);
173 pldmCmds[idx] = pldmCmds[idx] | (1 << (cmd % 8));
174 termini[tid]->setSupportedCommands(pldmCmds);
175
176 // queue getPDRRepositoryInfo response
177 const size_t getPDRRepositoryInfoLen =
178 PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES;
179 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPDRRepositoryInfoLen>
180 getPDRRepositoryInfoResp{
181 0x0, 0x02, 0x50, PLDM_SUCCESS,
182 0x0, // repositoryState
183 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
184 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, // updateTime
185 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
186 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, // OEMUpdateTime
187 2, 0x0, 0x0, 0x0, // recordCount
188 0x0, 0x1, 0x0, 0x0, // repositorySize
189 59, 0x0, 0x0, 0x0, // largestRecordSize
190 0x0 // dataTransferHandleTimeout
191 };
192 auto rc = mockTerminusManager.enqueueResponse(
193 reinterpret_cast<pldm_msg*>(getPDRRepositoryInfoResp.data()),
194 sizeof(getPDRRepositoryInfoResp));
195 EXPECT_EQ(rc, PLDM_SUCCESS);
196
197 // queue getPDR responses
198 const size_t getPdrRespLen = 81;
199 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPdrRespLen> getPdrResp{
200 0x0, 0x02, 0x51, PLDM_SUCCESS, 0x1, 0x0, 0x0, 0x0, // nextRecordHandle
201 0x0, 0x0, 0x0, 0x0, // nextDataTransferHandle
202 0x5, // transferFlag
203 69, 0x0, // responseCount
204 // numeric Sensor PDR
205 0x0, 0x0, 0x0,
206 0x0, // record handle
207 0x1, // PDRHeaderVersion
208 PLDM_NUMERIC_SENSOR_PDR, // PDRType
209 0x0,
210 0x0, // recordChangeNumber
211 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH +
212 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH +
213 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH,
214 0, // dataLength
215 0,
216 0, // PLDMTerminusHandle
217 0x1,
218 0x0, // sensorID=1
219 120,
220 0, // entityType=Power Supply(120)
221 1,
222 0, // entityInstanceNumber
223 0x1,
224 0x0, // containerID=1
225 PLDM_NO_INIT, // sensorInit
226 false, // sensorAuxiliaryNamesPDR
227 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
228 1, // unitModifier = 1
229 0, // rateUnit
230 0, // baseOEMUnitHandle
231 0, // auxUnit
232 0, // auxUnitModifier
233 0, // auxRateUnit
234 0, // rel
235 0, // auxOEMUnitHandle
236 true, // isLinear
237 PLDM_SENSOR_DATA_SIZE_UINT8, // sensorDataSize
238 0, 0, 0xc0,
239 0x3f, // resolution=1.5
240 0, 0, 0x80,
241 0x3f, // offset=1.0
242 0,
243 0, // accuracy
244 0, // plusTolerance
245 0, // minusTolerance
246 2, // hysteresis
247 0, // supportedThresholds
248 0, // thresholdAndHysteresisVolatility
249 0, 0, 0x80,
250 0x3f, // stateTransistionInterval=1.0
251 0, 0, 0x80,
252 0x3f, // updateInverval=1.0
253 255, // maxReadable
254 0, // minReadable
255 PLDM_RANGE_FIELD_FORMAT_UINT8, // rangeFieldFormat
256 0, // rangeFieldsupport
257 0, // nominalValue
258 0, // normalMax
259 0, // normalMin
260 0, // warningHigh
261 0, // warningLow
262 0, // criticalHigh
263 0, // criticalLow
264 0, // fatalHigh
265 0 // fatalLow
266 };
267 rc = mockTerminusManager.enqueueResponse(
268 reinterpret_cast<pldm_msg*>(getPdrResp.data()), sizeof(getPdrResp));
269 EXPECT_EQ(rc, PLDM_SUCCESS);
270
271 const size_t getPdrAuxNameRespLen = 39;
272 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPdrAuxNameRespLen>
273 getPdrAuxNameResp{
274 0x0, 0x02, 0x51, PLDM_SUCCESS, 0x0, 0x0, 0x0,
275 0x0, // nextRecordHandle
276 0x0, 0x0, 0x0, 0x0, // nextDataTransferHandle
277 0x5, // transferFlag
278 0x1b, 0x0, // responseCount
279 // Common PDR Header
280 0x1, 0x0, 0x0,
281 0x0, // record handle
282 0x1, // PDRHeaderVersion
283 PLDM_ENTITY_AUXILIARY_NAMES_PDR, // PDRType
284 0x1,
285 0x0, // recordChangeNumber
286 0x11,
287 0, // dataLength
288 /* Entity Auxiliary Names PDR Data*/
289 3,
290 0x80, // entityType system software
291 0x1,
292 0x0, // Entity instance number =1
293 0,
294 0, // Overal system
295 0, // shared Name Count one name only
296 01, // nameStringCount
297 0x65, 0x6e, 0x00,
298 0x00, // Language Tag "en"
299 0x53, 0x00, 0x30, 0x00,
300 0x00 // Entity Name "S0"
301 };
302 rc = mockTerminusManager.enqueueResponse(
303 reinterpret_cast<pldm_msg*>(getPdrAuxNameResp.data()),
304 sizeof(getPdrAuxNameResp));
305 EXPECT_EQ(rc, PLDM_SUCCESS);
306
307 stdexec::sync_wait(platformManager.initTerminus());
308 EXPECT_EQ(true, terminus->initialized);
309 EXPECT_EQ(2, terminus->pdrs.size());
310 EXPECT_EQ("S0", terminus->getTerminusName());
311}
312
Gilbert Chende2a1322022-05-24 15:35:21 +0100[diff] [blame]313TEST_F(PlatformManagerTest, initTerminusDontSupportGetPDRTest)
314{
315 // Add terminus
316 auto mappedTid = mockTerminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
317 auto tid = mappedTid.value();
318 termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
319 tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
320 auto terminus = termini[tid];
321
322 /* Set supported command by terminus */
323 auto size = PLDM_MAX_TYPES * (PLDM_MAX_CMDS_PER_TYPE / 8);
324 std::vector<uint8_t> pldmCmds(size);
325 uint8_t type = PLDM_PLATFORM;
326 uint8_t cmd = PLDM_GET_PDR_REPOSITORY_INFO;
327 auto idx = type * (PLDM_MAX_CMDS_PER_TYPE / 8) + (cmd / 8);
328 pldmCmds[idx] = pldmCmds[idx] | (1 << (cmd % 8));
329 termini[tid]->setSupportedCommands(pldmCmds);
330
331 // queue getPDRRepositoryInfo response
332 const size_t getPDRRepositoryInfoLen =
333 PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES;
334 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPDRRepositoryInfoLen>
335 getPDRRepositoryInfoResp{
336 0x0, 0x02, 0x50, PLDM_SUCCESS,
337 0x0, // repositoryState
338 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
339 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, // updateTime
340 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
341 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, // OEMUpdateTime
342 1, 0x0, 0x0, 0x0, // recordCount
343 0x0, 0x1, 0x0, 0x0, // repositorySize
344 59, 0x0, 0x0, 0x0, // largestRecordSize
345 0x0 // dataTransferHandleTimeout
346 };
347 auto rc = mockTerminusManager.enqueueResponse(
Thu Nguyen98831af2024-07-30 09:51:00 +0000[diff] [blame]348 reinterpret_cast<pldm_msg*>(getPDRRepositoryInfoResp.data()),
Gilbert Chende2a1322022-05-24 15:35:21 +0100[diff] [blame]349 sizeof(getPDRRepositoryInfoResp));
350 EXPECT_EQ(rc, PLDM_SUCCESS);
351
352 // queue getPDR responses
353 const size_t getPdrRespLen = 81;
354 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPdrRespLen> getPdrResp{
355 0x0, 0x02, 0x51, PLDM_SUCCESS, 0x0, 0x0, 0x0, 0x0, // nextRecordHandle
356 0x0, 0x0, 0x0, 0x0, // nextDataTransferHandle
357 0x5, // transferFlag
358 69, 0x0, // responseCount
359 // numeric Sensor PDR
360 0x1, 0x0, 0x0,
361 0x0, // record handle
362 0x1, // PDRHeaderVersion
363 PLDM_NUMERIC_SENSOR_PDR, // PDRType
364 0x0,
365 0x0, // recordChangeNumber
366 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH +
367 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH +
368 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH,
369 0, // dataLength
370 0,
371 0, // PLDMTerminusHandle
372 0x1,
373 0x0, // sensorID=1
374 120,
375 0, // entityType=Power Supply(120)
376 1,
377 0, // entityInstanceNumber
378 0x1,
379 0x0, // containerID=1
380 PLDM_NO_INIT, // sensorInit
381 false, // sensorAuxiliaryNamesPDR
382 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
383 1, // unitModifier = 1
384 0, // rateUnit
385 0, // baseOEMUnitHandle
386 0, // auxUnit
387 0, // auxUnitModifier
388 0, // auxRateUnit
389 0, // rel
390 0, // auxOEMUnitHandle
391 true, // isLinear
392 PLDM_SENSOR_DATA_SIZE_UINT8, // sensorDataSize
393 0, 0, 0xc0,
394 0x3f, // resolution=1.5
395 0, 0, 0x80,
396 0x3f, // offset=1.0
397 0,
398 0, // accuracy
399 0, // plusTolerance
400 0, // minusTolerance
401 2, // hysteresis
402 0, // supportedThresholds
403 0, // thresholdAndHysteresisVolatility
404 0, 0, 0x80,
405 0x3f, // stateTransistionInterval=1.0
406 0, 0, 0x80,
407 0x3f, // updateInverval=1.0
408 255, // maxReadable
409 0, // minReadable
410 PLDM_RANGE_FIELD_FORMAT_UINT8, // rangeFieldFormat
411 0, // rangeFieldsupport
412 0, // nominalValue
413 0, // normalMax
414 0, // normalMin
415 0, // warningHigh
416 0, // warningLow
417 0, // criticalHigh
418 0, // criticalLow
419 0, // fatalHigh
420 0 // fatalLow
421 };
Thu Nguyen98831af2024-07-30 09:51:00 +0000[diff] [blame]422 rc = mockTerminusManager.enqueueResponse(
423 reinterpret_cast<pldm_msg*>(getPdrResp.data()), sizeof(getPdrResp));
Gilbert Chende2a1322022-05-24 15:35:21 +0100[diff] [blame]424 EXPECT_EQ(rc, PLDM_SUCCESS);
425
426 stdexec::sync_wait(platformManager.initTerminus());
427 EXPECT_EQ(true, terminus->initialized);
428 EXPECT_EQ(0, terminus->pdrs.size());
429}
430
431TEST_F(PlatformManagerTest, negativeInitTerminusTest1)
432{
433 // terminus doesn't Type2 support
434 auto mappedTid = mockTerminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
435 auto tid = mappedTid.value();
436 termini[tid] =
437 std::make_shared<pldm::platform_mc::Terminus>(tid, 1 << PLDM_BASE);
438 auto terminus = termini[tid];
439
440 stdexec::sync_wait(platformManager.initTerminus());
441 EXPECT_EQ(true, terminus->initialized);
442 EXPECT_EQ(0, terminus->pdrs.size());
443}
444
445TEST_F(PlatformManagerTest, negativeInitTerminusTest2)
446{
447 // terminus responses error
448 auto mappedTid = mockTerminusManager.mapTid(pldm::MctpInfo(10, "", "", 1));
449 auto tid = mappedTid.value();
450 termini[tid] = std::make_shared<pldm::platform_mc::Terminus>(
451 tid, 1 << PLDM_BASE | 1 << PLDM_PLATFORM);
452 auto terminus = termini[tid];
453
454 // queue getPDRRepositoryInfo response cc=PLDM_ERROR
455 const size_t getPDRRepositoryInfoLen = 1;
456 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPDRRepositoryInfoLen>
457 getPDRRepositoryInfoResp{0x0, 0x02, 0x50, PLDM_ERROR};
458 auto rc = mockTerminusManager.enqueueResponse(
Thu Nguyen98831af2024-07-30 09:51:00 +0000[diff] [blame]459 reinterpret_cast<pldm_msg*>(getPDRRepositoryInfoResp.data()),
Gilbert Chende2a1322022-05-24 15:35:21 +0100[diff] [blame]460 sizeof(getPDRRepositoryInfoResp));
461 EXPECT_EQ(rc, PLDM_SUCCESS);
462
463 // queue getPDR responses cc=PLDM_ERROR
464 const size_t getPdrRespLen = 1;
465 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPdrRespLen> getPdrResp{
466 0x0, 0x02, 0x51, PLDM_ERROR};
Thu Nguyen98831af2024-07-30 09:51:00 +0000[diff] [blame]467 rc = mockTerminusManager.enqueueResponse(
468 reinterpret_cast<pldm_msg*>(getPdrResp.data()), sizeof(getPdrResp));
Gilbert Chende2a1322022-05-24 15:35:21 +0100[diff] [blame]469 EXPECT_EQ(rc, PLDM_SUCCESS);
470
471 stdexec::sync_wait(platformManager.initTerminus());
472 EXPECT_EQ(true, terminus->initialized);
473 EXPECT_EQ(0, terminus->pdrs.size());
474}