1 #include "libpldm/base.h"
2 #include "libpldm/bios.h"
3 #include "libpldm/fru.h"
4 #include "libpldm/platform.h"
5
6 #include "common/instance_id.hpp"
7 #include "common/types.hpp"
8 #include "mock_terminus_manager.hpp"
9 #include "platform-mc/terminus_manager.hpp"
10 #include "requester/handler.hpp"
11 #include "requester/mctp_endpoint_discovery.hpp"
12 #include "requester/request.hpp"
13 #include "test/test_instance_id.hpp"
14
15 #include <sdbusplus/timer.hpp>
16 #include <sdeventplus/event.hpp>
17
18 #include <gmock/gmock.h>
19 #include <gtest/gtest.h>
20
21 using ::testing::AtLeast;
22 using ::testing::Between;
23 using ::testing::Exactly;
24 using ::testing::NiceMock;
25 using ::testing::Return;
26
27 class TerminusManagerTest : public testing::Test
28 {
29 protected:
TerminusManagerTest()30 TerminusManagerTest() :
31 bus(pldm::utils::DBusHandler::getBus()),
32 event(sdeventplus::Event::get_default()), instanceIdDb(),
33 reqHandler(pldmTransport, event, instanceIdDb, false,
34 std::chrono::seconds(1), 2, std::chrono::milliseconds(100)),
35 terminusManager(event, reqHandler, instanceIdDb, termini, nullptr,
36 pldm::BmcMctpEid),
37 mockTerminusManager(event, reqHandler, instanceIdDb, termini, nullptr)
38 {}
39
40 PldmTransport* pldmTransport = nullptr;
41 sdbusplus::bus_t& bus;
42 sdeventplus::Event event;
43 TestInstanceIdDb instanceIdDb;
44 pldm::requester::Handler<pldm::requester::Request> reqHandler;
45 pldm::platform_mc::TerminusManager terminusManager;
46 pldm::platform_mc::MockTerminusManager mockTerminusManager;
47 std::map<pldm_tid_t, std::shared_ptr<pldm::platform_mc::Terminus>> termini;
48 };
49
TEST_F(TerminusManagerTest,mapTidTest)50 TEST_F(TerminusManagerTest, mapTidTest)
51 {
52 pldm::MctpInfo mctpInfo1(8, "", "", 0);
53
54 auto mappedTid1 = terminusManager.mapTid(mctpInfo1);
55 EXPECT_NE(mappedTid1, std::nullopt);
56
57 auto tid1 = terminusManager.toTid(mctpInfo1);
58 EXPECT_NE(tid1, std::nullopt);
59
60 auto mctpInfo2 = terminusManager.toMctpInfo(tid1.value());
61 EXPECT_EQ(mctpInfo1, mctpInfo2.value());
62
63 auto ret = terminusManager.unmapTid(tid1.value());
64 EXPECT_EQ(ret, true);
65
66 tid1 = terminusManager.toTid(mctpInfo1);
67 EXPECT_EQ(tid1, std::nullopt);
68 }
69
TEST_F(TerminusManagerTest,negativeMapTidTest)70 TEST_F(TerminusManagerTest, negativeMapTidTest)
71 {
72 // map null EID(0) to TID
73 pldm::MctpInfo m0(0, "", "", 0);
74 auto mappedTid = terminusManager.mapTid(m0);
75 EXPECT_EQ(mappedTid, std::nullopt);
76
77 // map broadcast EID(0xff) to TID
78 pldm::MctpInfo m1(0xff, "", "", 0);
79 mappedTid = terminusManager.mapTid(m1);
80 EXPECT_EQ(mappedTid, std::nullopt);
81
82 // map EID to tid which has been assigned
83 pldm::MctpInfo m2(9, "", "", 1);
84 pldm::MctpInfo m3(10, "", "", 1);
85 auto mappedTid2 = terminusManager.mapTid(m2);
86 auto mappedTid3 = terminusManager.storeTerminusInfo(m3, mappedTid2.value());
87 EXPECT_NE(mappedTid2, std::nullopt);
88 EXPECT_EQ(mappedTid3, std::nullopt);
89
90 // map two mctpInfo with same EID but different network Id
91 pldm::MctpInfo m4(12, "", "", 1);
92 pldm::MctpInfo m5(12, "", "", 2);
93 auto mappedTid4 = terminusManager.mapTid(m4);
94 auto mappedTid5 = terminusManager.mapTid(m5);
95 EXPECT_NE(mappedTid4.value(), mappedTid5.value());
96
97 // map same mctpInfo twice
98 pldm::MctpInfo m6(12, "", "", 3);
99 auto mappedTid6 = terminusManager.mapTid(m6);
100 auto mappedTid6_1 = terminusManager.mapTid(m6);
101 EXPECT_EQ(mappedTid6.value(), mappedTid6_1.value());
102
103 // look up an unmapped MctpInfo to TID
104 pldm::MctpInfo m7(1, "", "", 0);
105 auto mappedTid7 = terminusManager.toTid(m7);
106 EXPECT_EQ(mappedTid7, std::nullopt);
107
108 // look up reserved TID(0)
109 auto mappedEid = terminusManager.toMctpInfo(0);
110 EXPECT_EQ(mappedEid, std::nullopt);
111
112 // look up reserved TID(0xff)
113 mappedEid = terminusManager.toMctpInfo(0xff);
114 EXPECT_EQ(mappedEid, std::nullopt);
115
116 // look up an unmapped TID
117 terminusManager.unmapTid(1);
118 mappedEid = terminusManager.toMctpInfo(1);
119 EXPECT_EQ(mappedEid, std::nullopt);
120
121 // unmap reserved TID(0)
122 auto ret = terminusManager.unmapTid(0);
123 EXPECT_EQ(ret, false);
124
125 // unmap reserved TID(0)
126 ret = terminusManager.unmapTid(0xff);
127 EXPECT_EQ(ret, false);
128 }
129
TEST_F(TerminusManagerTest,discoverMctpTerminusTest)130 TEST_F(TerminusManagerTest, discoverMctpTerminusTest)
131 {
132 const size_t getTidRespLen = PLDM_GET_TID_RESP_BYTES;
133 const size_t setTidRespLen = PLDM_SET_TID_RESP_BYTES;
134 const size_t getPldmTypesRespLen = PLDM_GET_TYPES_RESP_BYTES;
135
136 // 0.discover a mctp list
137 auto rc = mockTerminusManager.clearQueuedResponses();
138 EXPECT_EQ(rc, PLDM_SUCCESS);
139
140 std::array<uint8_t, sizeof(pldm_msg_hdr) + getTidRespLen> getTidResp0{
141 0x00, 0x02, 0x02, 0x00, 0x00};
142 rc = mockTerminusManager.enqueueResponse(
143 reinterpret_cast<pldm_msg*>(getTidResp0.data()), sizeof(getTidResp0));
144 EXPECT_EQ(rc, PLDM_SUCCESS);
145 std::array<uint8_t, sizeof(pldm_msg_hdr) + setTidRespLen> setTidResp0{
146 0x00, 0x02, 0x01, 0x00};
147 rc = mockTerminusManager.enqueueResponse(
148 reinterpret_cast<pldm_msg*>(setTidResp0.data()), sizeof(setTidResp0));
149 EXPECT_EQ(rc, PLDM_SUCCESS);
150 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPldmTypesRespLen>
151 getPldmTypesResp0{0x00, 0x02, 0x04, 0x00, 0x01, 0x00,
152 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
153 rc = mockTerminusManager.enqueueResponse(
154 reinterpret_cast<pldm_msg*>(getPldmTypesResp0.data()),
155 sizeof(getPldmTypesResp0));
156 EXPECT_EQ(rc, PLDM_SUCCESS);
157
158 pldm::MctpInfos mctpInfos{};
159 mctpInfos.emplace_back(pldm::MctpInfo(12, "", "", 1));
160 mockTerminusManager.discoverMctpTerminus(mctpInfos);
161 EXPECT_EQ(1, termini.size());
162
163 // 1.discover the same mctp list again
164 rc = mockTerminusManager.clearQueuedResponses();
165 EXPECT_EQ(rc, PLDM_SUCCESS);
166
167 std::array<uint8_t, sizeof(pldm_msg_hdr) + getTidRespLen> getTidResp1{
168 0x00, 0x02, 0x02, 0x00, 0x01};
169 rc = mockTerminusManager.enqueueResponse(
170 reinterpret_cast<pldm_msg*>(getTidResp1.data()), sizeof(getTidResp1));
171 EXPECT_EQ(rc, PLDM_SUCCESS);
172 rc = mockTerminusManager.enqueueResponse(
173 reinterpret_cast<pldm_msg*>(setTidResp0.data()), sizeof(setTidResp0));
174 EXPECT_EQ(rc, PLDM_SUCCESS);
175 rc = mockTerminusManager.enqueueResponse(
176 reinterpret_cast<pldm_msg*>(getPldmTypesResp0.data()),
177 sizeof(getPldmTypesResp0));
178 EXPECT_EQ(rc, PLDM_SUCCESS);
179
180 mockTerminusManager.discoverMctpTerminus(mctpInfos);
181 EXPECT_EQ(1, termini.size());
182
183 // 2.discover an empty mctp list
184 rc = mockTerminusManager.clearQueuedResponses();
185 EXPECT_EQ(rc, PLDM_SUCCESS);
186
187 mockTerminusManager.removeMctpTerminus(mctpInfos);
188 EXPECT_EQ(0, termini.size());
189 }
190
TEST_F(TerminusManagerTest,negativeDiscoverMctpTerminusTest)191 TEST_F(TerminusManagerTest, negativeDiscoverMctpTerminusTest)
192 {
193 const size_t getTidRespLen = PLDM_GET_TID_RESP_BYTES;
194 const size_t setTidRespLen = PLDM_SET_TID_RESP_BYTES;
195 const size_t getPldmTypesRespLen = PLDM_GET_TYPES_RESP_BYTES;
196
197 // 0.terminus returns reserved tid
198 std::array<uint8_t, sizeof(pldm_msg_hdr) + getTidRespLen> getTidResp0{
199 0x00, 0x02, 0x02, 0x00, PLDM_TID_RESERVED};
200 auto rc = mockTerminusManager.enqueueResponse(
201 reinterpret_cast<pldm_msg*>(getTidResp0.data()), sizeof(getTidResp0));
202 EXPECT_EQ(rc, PLDM_SUCCESS);
203
204 pldm::MctpInfos mctpInfos{};
205 mctpInfos.emplace_back(pldm::MctpInfo(12, "", "", 1));
206 mockTerminusManager.discoverMctpTerminus(mctpInfos);
207 EXPECT_EQ(0, termini.size());
208
209 // 1.terminus return cc=pldm_error for set tid
210 std::array<uint8_t, sizeof(pldm_msg_hdr) + getTidRespLen> getTidResp1{
211 0x00, 0x02, 0x02, 0x00, 0x00};
212 std::array<uint8_t, sizeof(pldm_msg_hdr) + setTidRespLen> setTidResp1{
213 0x00, 0x02, 0x01, PLDM_ERROR};
214
215 rc = mockTerminusManager.enqueueResponse(
216 reinterpret_cast<pldm_msg*>(getTidResp1.data()), sizeof(getTidResp1));
217 EXPECT_EQ(rc, PLDM_SUCCESS);
218 rc = mockTerminusManager.enqueueResponse(
219 reinterpret_cast<pldm_msg*>(setTidResp1.data()), sizeof(setTidResp1));
220 EXPECT_EQ(rc, PLDM_SUCCESS);
221 mockTerminusManager.removeMctpTerminus(mctpInfos);
222 EXPECT_EQ(0, termini.size());
223
224 // 2.terminus return cc=unsupported_pldm_cmd for set tid cmd and return
225 // cc=pldm_error for get pldm types cmd
226 std::array<uint8_t, sizeof(pldm_msg_hdr) + getTidRespLen> getTidResp2{
227 0x00, 0x02, 0x02, 0x00, 0x00};
228 std::array<uint8_t, sizeof(pldm_msg_hdr) + setTidRespLen> setTidResp2{
229 0x00, 0x02, 0x01, PLDM_ERROR_UNSUPPORTED_PLDM_CMD};
230 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPldmTypesRespLen>
231 getPldmTypesResp2{0x00, 0x02, 0x04, PLDM_ERROR, 0x01, 0x00,
232 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
233 rc = mockTerminusManager.enqueueResponse(
234 reinterpret_cast<pldm_msg*>(getTidResp2.data()), sizeof(getTidResp2));
235 EXPECT_EQ(rc, PLDM_SUCCESS);
236 rc = mockTerminusManager.enqueueResponse(
237 reinterpret_cast<pldm_msg*>(setTidResp2.data()), sizeof(setTidResp2));
238 EXPECT_EQ(rc, PLDM_SUCCESS);
239
240 rc = mockTerminusManager.enqueueResponse(
241 reinterpret_cast<pldm_msg*>(getPldmTypesResp2.data()),
242 sizeof(getPldmTypesResp2));
243 EXPECT_EQ(rc, PLDM_SUCCESS);
244 mockTerminusManager.removeMctpTerminus(mctpInfos);
245 EXPECT_EQ(0, termini.size());
246 }
247
TEST_F(TerminusManagerTest,doesSupportTypeTest)248 TEST_F(TerminusManagerTest, doesSupportTypeTest)
249 {
250 const size_t getTidRespLen = PLDM_GET_TID_RESP_BYTES;
251 const size_t setTidRespLen = PLDM_SET_TID_RESP_BYTES;
252 const size_t getPldmTypesRespLen = PLDM_GET_TYPES_RESP_BYTES;
253
254 // 0.discover a mctp list
255 auto rc = mockTerminusManager.clearQueuedResponses();
256 EXPECT_EQ(rc, PLDM_SUCCESS);
257
258 std::array<uint8_t, sizeof(pldm_msg_hdr) + getTidRespLen> getTidResp0{
259 0x00, 0x02, 0x02, 0x00, 0x00};
260 rc = mockTerminusManager.enqueueResponse(
261 reinterpret_cast<pldm_msg*>(getTidResp0.data()), sizeof(getTidResp0));
262 EXPECT_EQ(rc, PLDM_SUCCESS);
263
264 std::array<uint8_t, sizeof(pldm_msg_hdr) + setTidRespLen> setTidResp0{
265 0x00, 0x02, 0x01, 0x00};
266 rc = mockTerminusManager.enqueueResponse(
267 reinterpret_cast<pldm_msg*>(setTidResp0.data()), sizeof(setTidResp0));
268 EXPECT_EQ(rc, PLDM_SUCCESS);
269
270 uint8_t supportedType1Byte =
271 (1 << (PLDM_BASE % 8)) + (1 << (PLDM_PLATFORM % 8)) +
272 (1 << (PLDM_BIOS % 8)) + (1 << (PLDM_FRU % 8));
273 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPldmTypesRespLen>
274 getPldmTypesResp0{0x00, 0x02, 0x04, 0x00, supportedType1Byte,
275 0x00, 0x00, 0x00, 0x00, 0x00,
276 0x00, 0x00};
277 rc = mockTerminusManager.enqueueResponse(
278 reinterpret_cast<pldm_msg*>(getPldmTypesResp0.data()),
279 sizeof(getPldmTypesResp0));
280 EXPECT_EQ(rc, PLDM_SUCCESS);
281
282 pldm::MctpInfos mctpInfos{};
283 mctpInfos.emplace_back(pldm::MctpInfo(12, "", "", 1));
284 mockTerminusManager.discoverMctpTerminus(mctpInfos);
285 EXPECT_EQ(1, termini.size());
286
287 EXPECT_EQ(true, termini.contains(1));
288 EXPECT_EQ(false, termini.contains(0));
289 EXPECT_EQ(false, termini.contains(2));
290
291 EXPECT_EQ(true, termini[1]->doesSupportType(PLDM_BASE));
292 EXPECT_EQ(true, termini[1]->doesSupportType(PLDM_PLATFORM));
293 EXPECT_EQ(true, termini[1]->doesSupportType(PLDM_BIOS));
294 EXPECT_EQ(true, termini[1]->doesSupportType(PLDM_FRU));
295 EXPECT_EQ(false, termini[1]->doesSupportType(PLDM_FWUP));
296 EXPECT_EQ(false, termini[1]->doesSupportType(PLDM_OEM));
297 }
298
TEST_F(TerminusManagerTest,doesSupportCommandTest)299 TEST_F(TerminusManagerTest, doesSupportCommandTest)
300 {
301 const size_t getTidRespLen = PLDM_GET_TID_RESP_BYTES;
302 const size_t setTidRespLen = PLDM_SET_TID_RESP_BYTES;
303 const size_t getPldmTypesRespLen = PLDM_GET_TYPES_RESP_BYTES;
304 const size_t getPldmCommandRespLen = PLDM_GET_COMMANDS_RESP_BYTES;
305
306 // 0.discover a mctp list
307 auto rc = mockTerminusManager.clearQueuedResponses();
308 EXPECT_EQ(rc, PLDM_SUCCESS);
309
310 std::array<uint8_t, sizeof(pldm_msg_hdr) + getTidRespLen> getTidResp0{
311 0x00, 0x02, 0x02, 0x00, 0x00};
312 rc = mockTerminusManager.enqueueResponse(
313 reinterpret_cast<pldm_msg*>(getTidResp0.data()), sizeof(getTidResp0));
314 EXPECT_EQ(rc, PLDM_SUCCESS);
315
316 std::array<uint8_t, sizeof(pldm_msg_hdr) + setTidRespLen> setTidResp0{
317 0x00, 0x02, 0x01, 0x00};
318 rc = mockTerminusManager.enqueueResponse(
319 reinterpret_cast<pldm_msg*>(setTidResp0.data()), sizeof(setTidResp0));
320 EXPECT_EQ(rc, PLDM_SUCCESS);
321
322 uint8_t byte0 = (1 << (PLDM_BASE % 8)) + (1 << (PLDM_PLATFORM % 8)) +
323 (1 << (PLDM_BIOS % 8)) + (1 << (PLDM_FRU % 8));
324 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPldmTypesRespLen>
325 getPldmTypesResp0{0x00, 0x02, 0x04, 0x00, byte0, 0x00,
326 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
327 rc = mockTerminusManager.enqueueResponse(
328 reinterpret_cast<pldm_msg*>(getPldmTypesResp0.data()),
329 sizeof(getPldmTypesResp0));
330 EXPECT_EQ(rc, PLDM_SUCCESS);
331
332 /* Response GetPLDMCommand BASE, CC=0,
333 * SetTID/GetTID/GetPLDMTypes/GetPLDMCommands */
334 byte0 = (1 << (PLDM_SET_TID % 8)) + (1 << (PLDM_GET_TID % 8)) +
335 (1 << (PLDM_GET_PLDM_TYPES % 8)) +
336 (1 << (PLDM_GET_PLDM_COMMANDS % 8));
337 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPldmCommandRespLen>
338 getPldmCommandBaseResp0{
339 0x00, 0x02, 0x05, 0x00, byte0, 0x00, 0x00, 0x00, 0x00,
340 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
341 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
342 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
343 rc = mockTerminusManager.enqueueResponse(
344 reinterpret_cast<pldm_msg*>(getPldmCommandBaseResp0.data()),
345 sizeof(getPldmCommandBaseResp0));
346 EXPECT_EQ(rc, PLDM_SUCCESS);
347
348 /* Response GetPLDMCommand PLATFORM, CC=0,
349 * SetEventReceiver/PlatformEventMessage/GetSensorReading/SetNumericEffecterValue/GetNumericEffecterValue/GetPDR
350 */
351 /* byte0 command from 0x00 to 0x07 */
352 byte0 = (1 << (PLDM_SET_EVENT_RECEIVER % 8)); // byte0 = 0x10
353 /* byte1 command from 0x08 to 0xf */
354 uint8_t byte1 = (1 << (PLDM_PLATFORM_EVENT_MESSAGE % 8)) +
355 (1 << (PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE % 8)) +
356 (1 << (PLDM_EVENT_MESSAGE_SUPPORTED % 8)) +
357 (1 << (PLDM_EVENT_MESSAGE_BUFFER_SIZE % 8)); // byte1 = 0x3c
358 /* byte2 command from 0x10 to 0x17 */
359 uint8_t byte2 = (1 << (PLDM_GET_SENSOR_READING % 8)); // byte2 = 0x02
360 /* byte3 command from 0x18 to 0x1f */
361 /* byte4 command from 0x20 to 0x27 */
362 uint8_t byte4 = (1 << (PLDM_GET_STATE_SENSOR_READINGS % 8)); // byte4 = 0x02
363 /* byte5 command from 0x28 to 0x2f */
364 /* byte6 command from 0x30 to 0x37 */
365 uint8_t byte6 =
366 (1 << (PLDM_SET_NUMERIC_EFFECTER_VALUE % 8)) +
367 (1 << (PLDM_GET_NUMERIC_EFFECTER_VALUE % 8)); // byte6 = 0x06
368 /* byte7 command from 0x38 to 0x3f */
369 uint8_t byte7 = (0 << (PLDM_SET_STATE_EFFECTER_STATES % 8)); // byte7 = 0
370 /* byte8 command from 0x40 to 0x47 */
371 /* byte9 command from 0x48 to 0x4f */
372 /* byte10 command from 0x50 to 0x57 */
373 uint8_t byte10 = (1 << (PLDM_GET_PDR_REPOSITORY_INFO % 8)) +
374 (1 << (PLDM_GET_PDR % 8)); // byte10 = 0x03
375 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPldmCommandRespLen>
376 getPldmCommandPlatResp0{
377 0x00, 0x02, 0x05, 0x00, byte0, byte1, byte2, 0x00, byte4,
378 0x00, byte6, byte7, 0x00, 0x00, byte10, 0x00, 0x00, 0x00,
379 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
380 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
381 rc = mockTerminusManager.enqueueResponse(
382 reinterpret_cast<pldm_msg*>(getPldmCommandPlatResp0.data()),
383 sizeof(getPldmCommandPlatResp0));
384 EXPECT_EQ(rc, PLDM_SUCCESS);
385
386 /* Response GetPLDMCommand BIOS, CC=0, GetDateTime/SetDateTime */
387 /* byte0 command from 1 to 7 */
388 byte0 = (0 << (PLDM_GET_BIOS_TABLE % 8)) +
389 (0 << (PLDM_SET_BIOS_TABLE % 8)) +
390 (0 << (PLDM_SET_BIOS_ATTRIBUTE_CURRENT_VALUE % 8));
391 /* byte1 command from 8 to 15 */
392 byte1 = (0 << (PLDM_GET_BIOS_ATTRIBUTE_CURRENT_VALUE_BY_HANDLE % 8)) +
393 (1 << (PLDM_GET_DATE_TIME % 8)) + (1 << (PLDM_SET_DATE_TIME % 8));
394 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPldmCommandRespLen>
395 getPldmCommandBiosResp0{
396 0x00, 0x02, 0x05, 0x00, byte0, byte1, 0x00, 0x00, 0x00,
397 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
398 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
399 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
400 rc = mockTerminusManager.enqueueResponse(
401 reinterpret_cast<pldm_msg*>(getPldmCommandBiosResp0.data()),
402 sizeof(getPldmCommandBiosResp0));
403 EXPECT_EQ(rc, PLDM_SUCCESS);
404
405 /* Response GetPLDMCommand FRU, CC=0,
406 * GetFRURecordTableMetadata/GetFRURecordTable */
407 /* byte0 command from 1 to 7 */
408 byte0 = (1 << (PLDM_GET_FRU_RECORD_TABLE_METADATA % 8)) +
409 (1 << (PLDM_GET_FRU_RECORD_TABLE % 8)) +
410 (0 << (PLDM_SET_FRU_RECORD_TABLE % 8)) +
411 (0 << (PLDM_GET_FRU_RECORD_BY_OPTION % 8));
412 /* byte0 command from 8 to 15 */
413 byte1 = 0;
414 std::array<uint8_t, sizeof(pldm_msg_hdr) + getPldmCommandRespLen>
415 getPldmCommandFruResp0{
416 0x00, 0x02, 0x05, 0x00, byte0, 0x00, 0x00, 0x00, 0x00,
417 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
418 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
419 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
420 rc = mockTerminusManager.enqueueResponse(
421 reinterpret_cast<pldm_msg*>(getPldmCommandFruResp0.data()),
422 sizeof(getPldmCommandFruResp0));
423 EXPECT_EQ(rc, PLDM_SUCCESS);
424
425 pldm::MctpInfos mctpInfos{};
426 mctpInfos.emplace_back(pldm::MctpInfo(12, "", "", 1));
427 mockTerminusManager.discoverMctpTerminus(mctpInfos);
428 EXPECT_EQ(1, termini.size());
429 EXPECT_EQ(true, termini.contains(1));
430 EXPECT_EQ(false, termini.contains(0));
431 EXPECT_EQ(false, termini.contains(2));
432
433 EXPECT_EQ(true, termini[1]->doesSupportType(PLDM_BASE));
434 EXPECT_EQ(true, termini[1]->doesSupportType(PLDM_PLATFORM));
435 EXPECT_EQ(true, termini[1]->doesSupportType(PLDM_BIOS));
436 EXPECT_EQ(true, termini[1]->doesSupportType(PLDM_FRU));
437 /* Check PLDM Base commands */
438 EXPECT_EQ(true, termini[1]->doesSupportCommand(PLDM_BASE, PLDM_SET_TID));
439 EXPECT_EQ(true, termini[1]->doesSupportCommand(PLDM_BASE, PLDM_GET_TID));
440 EXPECT_EQ(false,
441 termini[1]->doesSupportCommand(PLDM_BASE, PLDM_GET_PLDM_VERSION));
442 EXPECT_EQ(true,
443 termini[1]->doesSupportCommand(PLDM_BASE, PLDM_GET_PLDM_TYPES));
444
445 EXPECT_EQ(true, termini[1]->doesSupportCommand(PLDM_BASE,
446 PLDM_GET_PLDM_COMMANDS));
447 EXPECT_EQ(false, termini[1]->doesSupportCommand(PLDM_BASE,
448 PLDM_MULTIPART_RECEIVE));
449
450 /* Check PLDM Platform commands */
451 EXPECT_EQ(true, termini[1]->doesSupportCommand(PLDM_PLATFORM,
452 PLDM_SET_EVENT_RECEIVER));
453 EXPECT_EQ(true, termini[1]->doesSupportCommand(
454 PLDM_PLATFORM, PLDM_PLATFORM_EVENT_MESSAGE));
455 EXPECT_EQ(true, termini[1]->doesSupportCommand(
456 PLDM_PLATFORM, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE));
457 EXPECT_EQ(true, termini[1]->doesSupportCommand(
458 PLDM_PLATFORM, PLDM_EVENT_MESSAGE_SUPPORTED));
459 EXPECT_EQ(true, termini[1]->doesSupportCommand(
460 PLDM_PLATFORM, PLDM_EVENT_MESSAGE_BUFFER_SIZE));
461 EXPECT_EQ(true, termini[1]->doesSupportCommand(PLDM_PLATFORM,
462 PLDM_GET_SENSOR_READING));
463 EXPECT_EQ(true, termini[1]->doesSupportCommand(
464 PLDM_PLATFORM, PLDM_GET_STATE_SENSOR_READINGS));
465 EXPECT_EQ(true, termini[1]->doesSupportCommand(
466 PLDM_PLATFORM, PLDM_SET_NUMERIC_EFFECTER_VALUE));
467 EXPECT_EQ(true, termini[1]->doesSupportCommand(
468 PLDM_PLATFORM, PLDM_GET_NUMERIC_EFFECTER_VALUE));
469 EXPECT_EQ(false, termini[1]->doesSupportCommand(
470 PLDM_PLATFORM, PLDM_SET_STATE_EFFECTER_STATES));
471 EXPECT_EQ(true, termini[1]->doesSupportCommand(
472 PLDM_PLATFORM, PLDM_GET_PDR_REPOSITORY_INFO));
473 EXPECT_EQ(true,
474 termini[1]->doesSupportCommand(PLDM_PLATFORM, PLDM_GET_PDR));
475
476 /* Check PLDM Bios commands */
477 EXPECT_EQ(false,
478 termini[1]->doesSupportCommand(PLDM_BIOS, PLDM_GET_BIOS_TABLE));
479 EXPECT_EQ(false,
480 termini[1]->doesSupportCommand(PLDM_BIOS, PLDM_SET_BIOS_TABLE));
481 EXPECT_EQ(false, termini[1]->doesSupportCommand(
482 PLDM_BIOS, PLDM_SET_BIOS_ATTRIBUTE_CURRENT_VALUE));
483 EXPECT_EQ(false,
484 termini[1]->doesSupportCommand(
485 PLDM_BIOS, PLDM_GET_BIOS_ATTRIBUTE_CURRENT_VALUE_BY_HANDLE));
486 EXPECT_EQ(true,
487 termini[1]->doesSupportCommand(PLDM_BIOS, PLDM_GET_DATE_TIME));
488 EXPECT_EQ(true,
489 termini[1]->doesSupportCommand(PLDM_BIOS, PLDM_SET_DATE_TIME));
490
491 /* Check PLDM Fru commands */
492 EXPECT_EQ(true, termini[1]->doesSupportCommand(
493 PLDM_FRU, PLDM_GET_FRU_RECORD_TABLE_METADATA));
494 EXPECT_EQ(true, termini[1]->doesSupportCommand(PLDM_FRU,
495 PLDM_GET_FRU_RECORD_TABLE));
496 EXPECT_EQ(false, termini[1]->doesSupportCommand(PLDM_FRU,
497 PLDM_SET_FRU_RECORD_TABLE));
498 EXPECT_EQ(false, termini[1]->doesSupportCommand(
499 PLDM_FRU, PLDM_GET_FRU_RECORD_BY_OPTION));
500 }
501