1 #include <endian.h>
2 #include <libpldm/base.h>
3 #include <libpldm/entity.h>
4 #include <libpldm/platform.h>
5 #include <libpldm/pldm_types.h>
6
7 #include <array>
8 #include <cerrno>
9 #include <cstddef>
10 #include <cstdint>
11 #include <cstring>
12 #include <vector>
13
14 #include "msgbuf.h"
15
16 #include <gtest/gtest.h>
17
18 constexpr auto hdrSize = sizeof(pldm_msg_hdr);
19
TEST(StateEffecterPdr,testIncorrectInvocations)20 TEST(StateEffecterPdr, testIncorrectInvocations)
21 {
22 struct state_effecter_possible_states possible_states{};
23 struct pldm_state_effecter_pdr effecter{};
24 size_t actual_size;
25 int rc;
26
27 /* effecter can't be NULL */
28 rc = encode_state_effecter_pdr(NULL, 0, &possible_states, 1, &actual_size);
29 EXPECT_EQ(rc, PLDM_ERROR);
30
31 /* possible states size can't be NULL */
32 rc = encode_state_effecter_pdr(&effecter, sizeof(effecter), NULL, 0,
33 &actual_size);
34 EXPECT_EQ(rc, PLDM_ERROR);
35
36 /* possible states size can't be too large */
37 rc = encode_state_effecter_pdr(&effecter, sizeof(effecter),
38 &possible_states, SIZE_MAX, &actual_size);
39 EXPECT_EQ(rc, PLDM_ERROR);
40
41 /* actual size can't be NULL */
42 rc = encode_state_effecter_pdr(&effecter, sizeof(effecter),
43 &possible_states, 0, NULL);
44 EXPECT_EQ(rc, PLDM_ERROR);
45
46 /* allocation size can't be less than effecter size with possible states */
47 rc = encode_state_effecter_pdr(&effecter, 0, &possible_states, 1,
48 &actual_size);
49 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
50
51 /* disallow mismatches between recorded possible state size and provided
52 * possible state size */
53 effecter.composite_effecter_count = 1;
54 rc = encode_state_effecter_pdr(&effecter, sizeof(effecter),
55 &possible_states, 1, &actual_size);
56 EXPECT_EQ(rc, PLDM_ERROR);
57 EXPECT_EQ(actual_size, 0);
58 }
59
TEST(StateEffecterPdr,testReasonableInvocations)60 TEST(StateEffecterPdr, testReasonableInvocations)
61 {
62 struct state_effecter_possible_states possible_states{};
63 struct pldm_state_effecter_pdr effecter{};
64 size_t actual_size;
65 int rc;
66
67 /* Accept 0 possible states */
68 rc = encode_state_effecter_pdr(&effecter, sizeof(effecter),
69 &possible_states, 0, &actual_size);
70 EXPECT_EQ(rc, PLDM_SUCCESS);
71 EXPECT_EQ(actual_size, sizeof(effecter) - sizeof(effecter.possible_states));
72 }
73
TEST(SetStateEffecterStates,testEncodeResponse)74 TEST(SetStateEffecterStates, testEncodeResponse)
75 {
76 std::array<uint8_t,
77 sizeof(pldm_msg_hdr) + PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
78 responseMsg{};
79 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
80 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
81 uint8_t completionCode = 0;
82
83 auto rc = encode_set_state_effecter_states_resp(0, PLDM_SUCCESS, response);
84
85 EXPECT_EQ(rc, PLDM_SUCCESS);
86 EXPECT_EQ(completionCode, response->payload[0]);
87 }
88
TEST(SetStateEffecterStates,testEncodeRequest)89 TEST(SetStateEffecterStates, testEncodeRequest)
90 {
91 std::array<uint8_t,
92 sizeof(pldm_msg_hdr) + PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES>
93 requestMsg{};
94 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
95 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
96
97 uint16_t effecterId = 0x0a;
98 uint8_t compEffecterCnt = 0x2;
99 std::array<set_effecter_state_field, 8> stateField{};
100 stateField[0] = {PLDM_REQUEST_SET, 2};
101 stateField[1] = {PLDM_REQUEST_SET, 3};
102
103 auto rc = encode_set_state_effecter_states_req(
104 0, effecterId, compEffecterCnt, stateField.data(), request);
105
106 EXPECT_EQ(rc, PLDM_SUCCESS);
107 EXPECT_EQ(effecterId, request->payload[0]);
108 EXPECT_EQ(compEffecterCnt, request->payload[sizeof(effecterId)]);
109 EXPECT_EQ(stateField[0].set_request,
110 request->payload[sizeof(effecterId) + sizeof(compEffecterCnt)]);
111 EXPECT_EQ(stateField[0].effecter_state,
112 request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
113 sizeof(stateField[0].set_request)]);
114 EXPECT_EQ(stateField[1].set_request,
115 request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
116 sizeof(stateField[0])]);
117 EXPECT_EQ(stateField[1].effecter_state,
118 request->payload[sizeof(effecterId) + sizeof(compEffecterCnt) +
119 sizeof(stateField[0]) +
120 sizeof(stateField[1].set_request)]);
121 }
122
TEST(SetStateEffecterStates,testGoodDecodeResponse)123 TEST(SetStateEffecterStates, testGoodDecodeResponse)
124 {
125 std::array<uint8_t, hdrSize + PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
126 responseMsg{};
127
128 uint8_t retcompletion_code = 0;
129
130 responseMsg[hdrSize] = PLDM_SUCCESS;
131
132 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
133 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
134
135 auto rc = decode_set_state_effecter_states_resp(
136 response, responseMsg.size() - hdrSize, &retcompletion_code);
137
138 EXPECT_EQ(rc, PLDM_SUCCESS);
139 EXPECT_EQ(PLDM_SUCCESS, retcompletion_code);
140 }
141
TEST(SetStateEffecterStates,testGoodDecodeRequest)142 TEST(SetStateEffecterStates, testGoodDecodeRequest)
143 {
144 std::array<uint8_t, hdrSize + PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES>
145 requestMsg{};
146
147 uint16_t effecterId = 0x32;
148 uint16_t effecterIdLE = htole16(effecterId);
149 uint8_t compEffecterCnt = 0x2;
150
151 std::array<set_effecter_state_field, 8> stateField{};
152 stateField[0] = {PLDM_REQUEST_SET, 3};
153 stateField[1] = {PLDM_REQUEST_SET, 4};
154
155 uint16_t retEffecterId = 0;
156 uint8_t retCompEffecterCnt = 0;
157
158 std::array<set_effecter_state_field, 8> retStateField{};
159
160 memcpy(requestMsg.data() + hdrSize, &effecterIdLE, sizeof(effecterIdLE));
161 memcpy(requestMsg.data() + sizeof(effecterIdLE) + hdrSize, &compEffecterCnt,
162 sizeof(compEffecterCnt));
163 memcpy(requestMsg.data() + sizeof(effecterIdLE) + sizeof(compEffecterCnt) +
164 hdrSize,
165 &stateField, sizeof(stateField));
166
167 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
168 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
169
170 auto rc = decode_set_state_effecter_states_req(
171 request, requestMsg.size() - hdrSize, &retEffecterId,
172 &retCompEffecterCnt, retStateField.data());
173
174 EXPECT_EQ(rc, PLDM_SUCCESS);
175 EXPECT_EQ(effecterId, retEffecterId);
176 EXPECT_EQ(retCompEffecterCnt, compEffecterCnt);
177 EXPECT_EQ(retStateField[0].set_request, stateField[0].set_request);
178 EXPECT_EQ(retStateField[0].effecter_state, stateField[0].effecter_state);
179 EXPECT_EQ(retStateField[1].set_request, stateField[1].set_request);
180 EXPECT_EQ(retStateField[1].effecter_state, stateField[1].effecter_state);
181 }
182
TEST(SetStateEffecterStates,testBadDecodeRequest)183 TEST(SetStateEffecterStates, testBadDecodeRequest)
184 {
185 const struct pldm_msg* msg = NULL;
186
187 auto rc = decode_set_state_effecter_states_req(msg, sizeof(*msg), NULL,
188 NULL, NULL);
189
190 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
191 }
192
TEST(SetStateEffecterStates,testBadDecodeResponse)193 TEST(SetStateEffecterStates, testBadDecodeResponse)
194 {
195 std::array<uint8_t, PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES>
196 responseMsg{};
197
198 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
199 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
200
201 auto rc = decode_set_state_effecter_states_resp(response,
202 responseMsg.size(), NULL);
203
204 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
205 }
206
TEST(GetPDR,testGoodEncodeResponse)207 TEST(GetPDR, testGoodEncodeResponse)
208 {
209 uint8_t completionCode = 0;
210 uint32_t nextRecordHndl = 0x12;
211 uint32_t nextDataTransferHndl = 0x13;
212 uint8_t transferFlag = PLDM_END;
213 uint16_t respCnt = 0x5;
214 std::vector<uint8_t> recordData{1, 2, 3, 4, 5};
215 uint8_t transferCRC = 6;
216
217 // + size of record data and transfer CRC
218 std::vector<uint8_t> responseMsg(hdrSize + PLDM_GET_PDR_MIN_RESP_BYTES +
219 recordData.size() + 1);
220 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
221 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
222
223 auto rc = encode_get_pdr_resp(0, PLDM_SUCCESS, nextRecordHndl,
224 nextDataTransferHndl, transferFlag, respCnt,
225 recordData.data(), transferCRC, response);
226
227 EXPECT_EQ(rc, PLDM_SUCCESS);
228 struct pldm_get_pdr_resp* resp =
229 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
230 reinterpret_cast<struct pldm_get_pdr_resp*>(response->payload);
231
232 EXPECT_EQ(completionCode, resp->completion_code);
233 EXPECT_EQ(nextRecordHndl, le32toh(resp->next_record_handle));
234 EXPECT_EQ(nextDataTransferHndl, le32toh(resp->next_data_transfer_handle));
235 EXPECT_EQ(transferFlag, resp->transfer_flag);
236 EXPECT_EQ(respCnt, le16toh(resp->response_count));
237 EXPECT_EQ(0,
238 memcmp(recordData.data(), resp->record_data, recordData.size()));
239 EXPECT_EQ(*(response->payload + sizeof(pldm_get_pdr_resp) - 1 +
240 recordData.size()),
241 transferCRC);
242
243 transferFlag = PLDM_START_AND_END; // No CRC in this case
244 responseMsg.resize(responseMsg.size() - sizeof(transferCRC));
245 rc = encode_get_pdr_resp(0, PLDM_SUCCESS, nextRecordHndl,
246 nextDataTransferHndl, transferFlag, respCnt,
247 recordData.data(), transferCRC, response);
248 EXPECT_EQ(rc, PLDM_SUCCESS);
249 }
250
TEST(GetPDR,testBadEncodeResponse)251 TEST(GetPDR, testBadEncodeResponse)
252 {
253 uint32_t nextRecordHndl = 0x12;
254 uint32_t nextDataTransferHndl = 0x13;
255 uint8_t transferFlag = PLDM_START_AND_END;
256 uint16_t respCnt = 0x5;
257 std::vector<uint8_t> recordData{1, 2, 3, 4, 5};
258 uint8_t transferCRC = 0;
259
260 auto rc = encode_get_pdr_resp(0, PLDM_SUCCESS, nextRecordHndl,
261 nextDataTransferHndl, transferFlag, respCnt,
262 recordData.data(), transferCRC, nullptr);
263
264 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
265 }
266
TEST(GetPDR,testGoodDecodeRequest)267 TEST(GetPDR, testGoodDecodeRequest)
268 {
269 std::array<uint8_t, hdrSize + PLDM_GET_PDR_REQ_BYTES> requestMsg{};
270
271 uint32_t recordHndl = 0x32;
272 uint32_t dataTransferHndl = 0x11;
273 uint8_t transferOpFlag = PLDM_GET_FIRSTPART;
274 uint16_t requestCnt = 0x5;
275 uint16_t recordChangeNum = 0x01;
276
277 uint32_t retRecordHndl = 0;
278 uint32_t retDataTransferHndl = 0;
279 uint8_t retTransferOpFlag = 0;
280 uint16_t retRequestCnt = 0;
281 uint16_t retRecordChangeNum = 0;
282
283 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
284 auto req = reinterpret_cast<pldm_msg*>(requestMsg.data());
285 struct pldm_get_pdr_req* request =
286 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
287 reinterpret_cast<struct pldm_get_pdr_req*>(req->payload);
288
289 request->record_handle = htole32(recordHndl);
290 request->data_transfer_handle = htole32(dataTransferHndl);
291 request->transfer_op_flag = transferOpFlag;
292 request->request_count = htole16(requestCnt);
293 request->record_change_number = htole16(recordChangeNum);
294
295 auto rc = decode_get_pdr_req(
296 req, requestMsg.size() - hdrSize, &retRecordHndl, &retDataTransferHndl,
297 &retTransferOpFlag, &retRequestCnt, &retRecordChangeNum);
298
299 EXPECT_EQ(rc, PLDM_SUCCESS);
300 EXPECT_EQ(retRecordHndl, recordHndl);
301 EXPECT_EQ(retDataTransferHndl, dataTransferHndl);
302 EXPECT_EQ(retTransferOpFlag, transferOpFlag);
303 EXPECT_EQ(retRequestCnt, requestCnt);
304 EXPECT_EQ(retRecordChangeNum, recordChangeNum);
305 }
306
TEST(GetPDR,testBadDecodeRequest)307 TEST(GetPDR, testBadDecodeRequest)
308 {
309 std::array<uint8_t, PLDM_GET_PDR_REQ_BYTES> requestMsg{};
310 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
311 auto req = reinterpret_cast<pldm_msg*>(requestMsg.data());
312
313 auto rc = decode_get_pdr_req(req, requestMsg.size(), NULL, NULL, NULL, NULL,
314 NULL);
315
316 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
317 }
318
TEST(GetPDR,testGoodEncodeRequest)319 TEST(GetPDR, testGoodEncodeRequest)
320 {
321 uint32_t record_hndl = 0;
322 uint32_t data_transfer_hndl = 0;
323 uint8_t transfer_op_flag = PLDM_GET_FIRSTPART;
324 uint16_t request_cnt = 20;
325 uint16_t record_chg_num = 0;
326
327 std::vector<uint8_t> requestMsg(hdrSize + PLDM_GET_PDR_REQ_BYTES);
328 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
329 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
330
331 auto rc = encode_get_pdr_req(0, record_hndl, data_transfer_hndl,
332 transfer_op_flag, request_cnt, record_chg_num,
333 request, PLDM_GET_PDR_REQ_BYTES);
334 EXPECT_EQ(rc, PLDM_SUCCESS);
335 struct pldm_get_pdr_req* req =
336 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
337 reinterpret_cast<struct pldm_get_pdr_req*>(request->payload);
338 EXPECT_EQ(record_hndl, le32toh(req->record_handle));
339 EXPECT_EQ(data_transfer_hndl, le32toh(req->data_transfer_handle));
340 EXPECT_EQ(transfer_op_flag, req->transfer_op_flag);
341 EXPECT_EQ(request_cnt, le16toh(req->request_count));
342 EXPECT_EQ(record_chg_num, le16toh(req->record_change_number));
343 }
344
TEST(GetPDR,testBadEncodeRequest)345 TEST(GetPDR, testBadEncodeRequest)
346 {
347 uint32_t record_hndl = 0;
348 uint32_t data_transfer_hndl = 0;
349 uint8_t transfer_op_flag = PLDM_GET_FIRSTPART;
350 uint16_t request_cnt = 32;
351 uint16_t record_chg_num = 0;
352
353 std::vector<uint8_t> requestMsg(hdrSize + PLDM_GET_PDR_REQ_BYTES);
354 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
355 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
356
357 auto rc = encode_get_pdr_req(0, record_hndl, data_transfer_hndl,
358 transfer_op_flag, request_cnt, record_chg_num,
359 nullptr, PLDM_GET_PDR_REQ_BYTES);
360 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
361
362 rc = encode_get_pdr_req(0, record_hndl, data_transfer_hndl,
363 transfer_op_flag, request_cnt, record_chg_num,
364 request, PLDM_GET_PDR_REQ_BYTES + 1);
365 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
366 }
367
TEST(GetPDR,testGoodDecodeResponse)368 TEST(GetPDR, testGoodDecodeResponse)
369 {
370 const char* recordData = "123456789";
371 uint8_t completionCode = PLDM_SUCCESS;
372 uint32_t nextRecordHndl = 0;
373 uint32_t nextDataTransferHndl = 0;
374 uint8_t transferFlag = PLDM_END;
375 constexpr uint16_t respCnt = 9;
376 uint8_t transferCRC = 96;
377 size_t recordDataLength = 32;
378 std::array<uint8_t, hdrSize + PLDM_GET_PDR_MIN_RESP_BYTES + respCnt +
379 sizeof(transferCRC)>
380 responseMsg{};
381
382 uint8_t retCompletionCode = 0;
383 uint8_t retRecordData[32] = {0};
384 uint32_t retNextRecordHndl = 0;
385 uint32_t retNextDataTransferHndl = 0;
386 uint8_t retTransferFlag = 0;
387 uint16_t retRespCnt = 0;
388 uint8_t retTransferCRC = 0;
389
390 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
391 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
392 struct pldm_get_pdr_resp* resp =
393 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
394 reinterpret_cast<struct pldm_get_pdr_resp*>(response->payload);
395 resp->completion_code = completionCode;
396 resp->next_record_handle = htole32(nextRecordHndl);
397 resp->next_data_transfer_handle = htole32(nextDataTransferHndl);
398 resp->transfer_flag = transferFlag;
399 resp->response_count = htole16(respCnt);
400 memcpy(resp->record_data, recordData, respCnt);
401 response->payload[PLDM_GET_PDR_MIN_RESP_BYTES + respCnt] = transferCRC;
402
403 auto rc = decode_get_pdr_resp(
404 response, responseMsg.size() - hdrSize, &retCompletionCode,
405 &retNextRecordHndl, &retNextDataTransferHndl, &retTransferFlag,
406 &retRespCnt, retRecordData, recordDataLength, &retTransferCRC);
407 EXPECT_EQ(rc, PLDM_SUCCESS);
408 EXPECT_EQ(retCompletionCode, completionCode);
409 EXPECT_EQ(retNextRecordHndl, nextRecordHndl);
410 EXPECT_EQ(retNextDataTransferHndl, nextDataTransferHndl);
411 EXPECT_EQ(retTransferFlag, transferFlag);
412 EXPECT_EQ(retRespCnt, respCnt);
413 EXPECT_EQ(retTransferCRC, transferCRC);
414 EXPECT_EQ(0, memcmp(recordData, resp->record_data, respCnt));
415 }
416
TEST(GetPDR,testBadDecodeResponse)417 TEST(GetPDR, testBadDecodeResponse)
418 {
419 const char* recordData = "123456789";
420 uint8_t completionCode = PLDM_SUCCESS;
421 uint32_t nextRecordHndl = 0;
422 uint32_t nextDataTransferHndl = 0;
423 uint8_t transferFlag = PLDM_END;
424 constexpr uint16_t respCnt = 9;
425 uint8_t transferCRC = 96;
426 size_t recordDataLength = respCnt - 1;
427 std::array<uint8_t, hdrSize + PLDM_GET_PDR_MIN_RESP_BYTES + respCnt +
428 sizeof(transferCRC)>
429 responseMsg{};
430
431 uint8_t retCompletionCode = 0;
432 uint8_t retRecordData[32] = {0};
433 uint32_t retNextRecordHndl = 0;
434 uint32_t retNextDataTransferHndl = 0;
435 uint8_t retTransferFlag = 0;
436 uint16_t retRespCnt = 0;
437 uint8_t retTransferCRC = 0;
438
439 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
440 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
441 struct pldm_get_pdr_resp* resp =
442 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
443 reinterpret_cast<struct pldm_get_pdr_resp*>(response->payload);
444 resp->completion_code = completionCode;
445 resp->next_record_handle = htole32(nextRecordHndl);
446 resp->next_data_transfer_handle = htole32(nextDataTransferHndl);
447 resp->transfer_flag = transferFlag;
448 resp->response_count = htole16(respCnt);
449 memcpy(resp->record_data, recordData, respCnt);
450 response->payload[PLDM_GET_PDR_MIN_RESP_BYTES + respCnt] = transferCRC;
451
452 auto rc = decode_get_pdr_resp(response, responseMsg.size() - hdrSize, NULL,
453 NULL, NULL, NULL, NULL, NULL, 0, NULL);
454 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
455
456 rc = decode_get_pdr_resp(
457 response, responseMsg.size() - hdrSize - 1, &retCompletionCode,
458 &retNextRecordHndl, &retNextDataTransferHndl, &retTransferFlag,
459 &retRespCnt, retRecordData, recordDataLength, &retTransferCRC);
460 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
461 }
462
463 #ifdef LIBPLDM_API_TESTING
TEST(GetPDR,testGoodDecodeResponseSafe)464 TEST(GetPDR, testGoodDecodeResponseSafe)
465 {
466 static const char recordData[] = "123456789";
467
468 alignas(pldm_msg) unsigned char data[sizeof(pldm_msg_hdr) +
469 PLDM_GET_PDR_MIN_RESP_BYTES +
470 sizeof(recordData) - 1 + 1];
471 PLDM_MSGBUF_DEFINE_P(buf);
472 int rc;
473
474 pldm_msg* msg = new (data) pldm_msg;
475
476 rc = pldm_msgbuf_init_errno(buf, PLDM_GET_PDR_MIN_RESP_BYTES, msg->payload,
477 sizeof(data) - sizeof(msg->hdr));
478 ASSERT_EQ(rc, 0);
479
480 pldm_msgbuf_insert_uint8(buf, PLDM_SUCCESS);
481 pldm_msgbuf_insert_uint32(buf, 0);
482 pldm_msgbuf_insert_uint32(buf, 0);
483 pldm_msgbuf_insert_uint8(buf, PLDM_END);
484 pldm_msgbuf_insert_uint16(buf, sizeof(recordData) - 1);
485 rc = pldm_msgbuf_insert_array_char(buf, sizeof(recordData) - 1, recordData,
486 sizeof(recordData) - 1);
487 ASSERT_EQ(rc, 0);
488 pldm_msgbuf_insert_uint8(buf, 96);
489 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
490
491 alignas(pldm_get_pdr_resp) unsigned char
492 resp_data[sizeof(pldm_get_pdr_resp) + sizeof(recordData) - 1];
493 pldm_get_pdr_resp* resp = new (resp_data) pldm_get_pdr_resp;
494 uint8_t crc;
495 rc = decode_get_pdr_resp_safe(msg, sizeof(data) - sizeof(msg->hdr), resp,
496 sizeof(resp_data) - sizeof(*resp), &crc);
497 ASSERT_EQ(rc, 0);
498 EXPECT_EQ(resp->completion_code, PLDM_SUCCESS);
499 EXPECT_EQ(resp->next_record_handle, 0);
500 EXPECT_EQ(resp->next_data_transfer_handle, 0);
501 EXPECT_EQ(resp->transfer_flag, PLDM_END);
502 ASSERT_EQ(resp->response_count, sizeof(recordData) - 1);
503 EXPECT_EQ(crc, 96);
504 EXPECT_EQ(0, memcmp(recordData, resp->record_data, resp->response_count));
505 }
506 #endif
507
508 #ifdef LIBPLDM_API_TESTING
TEST(GetPDR,testBadDecodeResponseSafeTrivial)509 TEST(GetPDR, testBadDecodeResponseSafeTrivial)
510 {
511 pldm_get_pdr_resp resp;
512 uint8_t crc;
513 int rc;
514
515 rc = decode_get_pdr_resp_safe(nullptr, PLDM_GET_PDR_MIN_RESP_BYTES, &resp,
516 sizeof(resp), &crc);
517 EXPECT_EQ(rc, -EINVAL);
518
519 alignas(pldm_msg) unsigned char
520 msg_data[sizeof(pldm_msg_hdr) + PLDM_GET_PDR_MIN_RESP_BYTES];
521 pldm_msg* msg = new (msg_data) pldm_msg;
522 rc = decode_get_pdr_resp_safe(msg, PLDM_GET_PDR_MIN_RESP_BYTES, nullptr,
523 sizeof(resp), &crc);
524 EXPECT_EQ(rc, -EINVAL);
525
526 rc = decode_get_pdr_resp_safe(msg, PLDM_GET_PDR_MIN_RESP_BYTES, &resp,
527 sizeof(resp), nullptr);
528 EXPECT_EQ(rc, -EINVAL);
529
530 msg->payload[0] = PLDM_ERROR_INVALID_DATA;
531 rc = decode_get_pdr_resp_safe(msg, 1, &resp, sizeof(resp), &crc);
532 EXPECT_EQ(rc, 0);
533 EXPECT_EQ(resp.completion_code, PLDM_ERROR_INVALID_DATA);
534 }
535 #endif
536
537 #ifdef LIBPLDM_API_TESTING
TEST(GetPDRRepositoryInfo,testGoodEncodeRequest)538 TEST(GetPDRRepositoryInfo, testGoodEncodeRequest)
539 {
540 pldm_msg request{};
541
542 auto rc = encode_get_pdr_repository_info_req(0, &request,
543 sizeof(struct pldm_msg));
544 ASSERT_EQ(rc, PLDM_SUCCESS);
545 }
546 #endif
547
548 #ifdef LIBPLDM_API_TESTING
TEST(GetPDRRepositoryInfo,testBadEncodeRequest)549 TEST(GetPDRRepositoryInfo, testBadEncodeRequest)
550 {
551 auto rc =
552 encode_get_pdr_repository_info_req(0, nullptr, sizeof(struct pldm_msg));
553 EXPECT_EQ(rc, -EINVAL);
554 }
555 #endif
556
TEST(GetPDRRepositoryInfo,testGoodEncodeResponse)557 TEST(GetPDRRepositoryInfo, testGoodEncodeResponse)
558 {
559 uint8_t completionCode = 0;
560 uint8_t repositoryState = PLDM_AVAILABLE;
561 uint8_t updateTime[PLDM_TIMESTAMP104_SIZE] = {0};
562 uint8_t oemUpdateTime[PLDM_TIMESTAMP104_SIZE] = {0};
563 uint32_t recordCount = 100;
564 uint32_t repositorySize = 100;
565 uint32_t largestRecordSize = UINT32_MAX;
566 uint8_t dataTransferHandleTimeout = PLDM_NO_TIMEOUT;
567
568 std::vector<uint8_t> responseMsg(hdrSize +
569 PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES);
570 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
571 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
572
573 auto rc = encode_get_pdr_repository_info_resp(
574 0, PLDM_SUCCESS, repositoryState, updateTime, oemUpdateTime,
575 recordCount, repositorySize, largestRecordSize,
576 dataTransferHandleTimeout, response);
577
578 EXPECT_EQ(rc, PLDM_SUCCESS);
579 struct pldm_pdr_repository_info_resp* resp =
580 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
581 reinterpret_cast<struct pldm_pdr_repository_info_resp*>(
582 response->payload);
583
584 EXPECT_EQ(completionCode, resp->completion_code);
585 EXPECT_EQ(repositoryState, resp->repository_state);
586 EXPECT_EQ(0, memcmp(updateTime, resp->update_time, PLDM_TIMESTAMP104_SIZE));
587 EXPECT_EQ(0, memcmp(oemUpdateTime, resp->oem_update_time,
588 PLDM_TIMESTAMP104_SIZE));
589 EXPECT_EQ(recordCount, le32toh(resp->record_count));
590 EXPECT_EQ(repositorySize, le32toh(resp->repository_size));
591 EXPECT_EQ(largestRecordSize, le32toh(resp->largest_record_size));
592 EXPECT_EQ(dataTransferHandleTimeout, resp->data_transfer_handle_timeout);
593 }
594
TEST(GetPDRRepositoryInfo,testBadEncodeResponse)595 TEST(GetPDRRepositoryInfo, testBadEncodeResponse)
596 {
597 uint8_t repositoryState = PLDM_AVAILABLE;
598 uint8_t updateTime[PLDM_TIMESTAMP104_SIZE] = {0};
599 uint8_t oemUpdateTime[PLDM_TIMESTAMP104_SIZE] = {0};
600 uint32_t recordCount = 100;
601 uint32_t repositorySize = 100;
602 uint32_t largestRecordSize = UINT32_MAX;
603 uint8_t dataTransferHandleTimeout = PLDM_NO_TIMEOUT;
604
605 auto rc = encode_get_pdr_repository_info_resp(
606 0, PLDM_SUCCESS, repositoryState, updateTime, oemUpdateTime,
607 recordCount, repositorySize, largestRecordSize,
608 dataTransferHandleTimeout, nullptr);
609 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
610 }
611
TEST(GetPDRRepositoryInfo,testGoodDecodeResponse)612 TEST(GetPDRRepositoryInfo, testGoodDecodeResponse)
613 {
614 uint8_t completionCode = PLDM_SUCCESS;
615 uint8_t repositoryState = PLDM_AVAILABLE;
616 uint8_t updateTime[PLDM_TIMESTAMP104_SIZE] = {0};
617 uint8_t oemUpdateTime[PLDM_TIMESTAMP104_SIZE] = {0};
618 uint32_t recordCount = 100;
619 uint32_t repositorySize = 100;
620 uint32_t largestRecordSize = UINT32_MAX;
621 uint8_t dataTransferHandleTimeout = PLDM_NO_TIMEOUT;
622
623 std::array<uint8_t, hdrSize + PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES>
624 responseMsg{};
625 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
626 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
627 struct pldm_pdr_repository_info_resp* resp =
628 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
629 reinterpret_cast<struct pldm_pdr_repository_info_resp*>(
630 response->payload);
631 resp->completion_code = completionCode;
632 resp->repository_state = repositoryState;
633 memcpy(resp->update_time, updateTime, PLDM_TIMESTAMP104_SIZE);
634 memcpy(resp->oem_update_time, oemUpdateTime, PLDM_TIMESTAMP104_SIZE);
635 resp->record_count = htole32(recordCount);
636 resp->repository_size = htole32(repositorySize);
637 resp->largest_record_size = htole32(largestRecordSize);
638 resp->data_transfer_handle_timeout = dataTransferHandleTimeout;
639
640 uint8_t retCompletionCode = 0;
641 uint8_t retRepositoryState = 0;
642 uint8_t retUpdateTime[PLDM_TIMESTAMP104_SIZE] = {0};
643 uint8_t retOemUpdateTime[PLDM_TIMESTAMP104_SIZE] = {0};
644 uint32_t retRecordCount = 0;
645 uint32_t retRepositorySize = 0;
646 uint32_t retLargestRecordSize = 0;
647 uint8_t retDataTransferHandleTimeout = 0;
648
649 auto rc = decode_get_pdr_repository_info_resp(
650 response, responseMsg.size() - hdrSize, &retCompletionCode,
651 &retRepositoryState, retUpdateTime, retOemUpdateTime, &retRecordCount,
652 &retRepositorySize, &retLargestRecordSize,
653 &retDataTransferHandleTimeout);
654
655 EXPECT_EQ(rc, PLDM_SUCCESS);
656 EXPECT_EQ(completionCode, retCompletionCode);
657 EXPECT_EQ(repositoryState, retRepositoryState);
658 EXPECT_EQ(0, memcmp(updateTime, retUpdateTime, PLDM_TIMESTAMP104_SIZE));
659 EXPECT_EQ(0,
660 memcmp(oemUpdateTime, retOemUpdateTime, PLDM_TIMESTAMP104_SIZE));
661 EXPECT_EQ(recordCount, recordCount);
662 EXPECT_EQ(repositorySize, repositorySize);
663 EXPECT_EQ(largestRecordSize, largestRecordSize);
664 EXPECT_EQ(dataTransferHandleTimeout, dataTransferHandleTimeout);
665 }
666
TEST(GetPDRRepositoryInfo,testBadDecodeResponse)667 TEST(GetPDRRepositoryInfo, testBadDecodeResponse)
668 {
669 uint8_t completionCode = PLDM_SUCCESS;
670 uint8_t repositoryState = PLDM_AVAILABLE;
671 uint8_t updateTime[PLDM_TIMESTAMP104_SIZE] = {0};
672 uint8_t oemUpdateTime[PLDM_TIMESTAMP104_SIZE] = {0};
673 uint32_t recordCount = htole32(100);
674 uint32_t repositorySize = htole32(100);
675 uint32_t largestRecordSize = htole32(UINT32_MAX);
676 uint8_t dataTransferHandleTimeout = PLDM_NO_TIMEOUT;
677
678 std::array<uint8_t, hdrSize + PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES>
679 responseMsg{};
680 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
681 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
682 struct pldm_pdr_repository_info_resp* resp =
683 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
684 reinterpret_cast<struct pldm_pdr_repository_info_resp*>(
685 response->payload);
686 resp->completion_code = completionCode;
687 resp->repository_state = repositoryState;
688 memcpy(resp->update_time, updateTime, PLDM_TIMESTAMP104_SIZE);
689 memcpy(resp->oem_update_time, oemUpdateTime, PLDM_TIMESTAMP104_SIZE);
690 resp->record_count = recordCount;
691 resp->repository_size = repositorySize;
692 resp->largest_record_size = largestRecordSize;
693 resp->data_transfer_handle_timeout = dataTransferHandleTimeout;
694
695 uint8_t retCompletionCode = 0;
696 uint8_t retRepositoryState = 0;
697 uint8_t retUpdateTime[PLDM_TIMESTAMP104_SIZE] = {0};
698 uint8_t retOemUpdateTime[PLDM_TIMESTAMP104_SIZE] = {0};
699 uint32_t retRecordCount = 0;
700 uint32_t retRepositorySize = 0;
701 uint32_t retLargestRecordSize = 0;
702 uint8_t retDataTransferHandleTimeout = 0;
703
704 auto rc = decode_get_pdr_repository_info_resp(
705 response, responseMsg.size() - hdrSize, NULL, NULL, NULL, NULL, NULL,
706 NULL, NULL, NULL);
707 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
708
709 rc = decode_get_pdr_repository_info_resp(
710 response, responseMsg.size() - hdrSize - 1, &retCompletionCode,
711 &retRepositoryState, retUpdateTime, retOemUpdateTime, &retRecordCount,
712 &retRepositorySize, &retLargestRecordSize,
713 &retDataTransferHandleTimeout);
714 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
715
716 resp->repository_state = PLDM_FAILED + 1;
717 rc = decode_get_pdr_repository_info_resp(
718 response, responseMsg.size() - hdrSize, &retCompletionCode,
719 &retRepositoryState, retUpdateTime, retOemUpdateTime, &retRecordCount,
720 &retRepositorySize, &retLargestRecordSize,
721 &retDataTransferHandleTimeout);
722 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
723 }
724
725 #ifdef LIBPLDM_API_TESTING
TEST(GetPDRRepositoryInfo,testGoodDecodeResponseSafe)726 TEST(GetPDRRepositoryInfo, testGoodDecodeResponseSafe)
727 {
728 alignas(pldm_msg) unsigned char
729 data[sizeof(pldm_msg_hdr) + PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES];
730 uint8_t updateTime[PLDM_TIMESTAMP104_SIZE] = {0};
731 uint8_t oemUpdateTime[PLDM_TIMESTAMP104_SIZE] = {0};
732 PLDM_MSGBUF_DEFINE_P(buf);
733 int rc;
734
735 pldm_msg* msg = new (data) pldm_msg;
736
737 rc = pldm_msgbuf_init_errno(buf, PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES,
738 msg->payload, sizeof(data) - sizeof(msg->hdr));
739 ASSERT_EQ(rc, 0);
740 pldm_msgbuf_insert_uint8(buf, PLDM_SUCCESS);
741 pldm_msgbuf_insert_uint8(buf, PLDM_AVAILABLE);
742 rc = pldm_msgbuf_insert_array_uint8(buf, PLDM_TIMESTAMP104_SIZE, updateTime,
743 sizeof(updateTime));
744 ASSERT_EQ(rc, 0);
745 rc = pldm_msgbuf_insert_array_uint8(buf, PLDM_TIMESTAMP104_SIZE,
746 oemUpdateTime, sizeof(oemUpdateTime));
747 ASSERT_EQ(rc, 0);
748 pldm_msgbuf_insert_uint32(buf, 100);
749 pldm_msgbuf_insert_uint32(buf, 100);
750 pldm_msgbuf_insert_uint32(buf, UINT32_MAX);
751 pldm_msgbuf_insert_uint8(buf, PLDM_NO_TIMEOUT);
752 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
753
754 struct pldm_pdr_repository_info_resp resp;
755 rc = decode_get_pdr_repository_info_resp_safe(
756 msg, sizeof(data) - sizeof(msg->hdr), &resp);
757
758 EXPECT_EQ(rc, 0);
759 EXPECT_EQ(PLDM_SUCCESS, resp.completion_code);
760 EXPECT_EQ(PLDM_AVAILABLE, resp.repository_state);
761 EXPECT_EQ(0,
762 memcmp(updateTime, resp.update_time, sizeof(resp.update_time)));
763 EXPECT_EQ(0, memcmp(oemUpdateTime, resp.oem_update_time,
764 sizeof(resp.oem_update_time)));
765 EXPECT_EQ(100, resp.record_count);
766 EXPECT_EQ(100, resp.repository_size);
767 EXPECT_EQ(UINT32_MAX, resp.largest_record_size);
768 EXPECT_EQ(PLDM_NO_TIMEOUT, resp.data_transfer_handle_timeout);
769 }
770 #endif
771
772 #ifdef LIBPLDM_API_TESTING
TEST(GetPDRRepositoryInfo,testBadDecodeResponseSafeTrivial)773 TEST(GetPDRRepositoryInfo, testBadDecodeResponseSafeTrivial)
774 {
775 struct pldm_pdr_repository_info_resp resp;
776 int rc;
777
778 rc = decode_get_pdr_repository_info_resp_safe(
779 nullptr, PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES, &resp);
780 EXPECT_EQ(rc, -EINVAL);
781
782 alignas(pldm_msg) unsigned char
783 msg_data[sizeof(pldm_msg) - 1 +
784 PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES];
785 pldm_msg* msg = new (msg_data) pldm_msg;
786 rc = decode_get_pdr_repository_info_resp_safe(msg, 0, &resp);
787 EXPECT_EQ(rc, -EOVERFLOW);
788
789 rc = decode_get_pdr_repository_info_resp_safe(
790 msg, PLDM_GET_PDR_REPOSITORY_INFO_RESP_BYTES, nullptr);
791 EXPECT_EQ(rc, -EINVAL);
792
793 msg->payload[0] = PLDM_ERROR_INVALID_DATA;
794 rc = decode_get_pdr_repository_info_resp_safe(msg, 1, &resp);
795 EXPECT_EQ(rc, 0);
796 EXPECT_EQ(resp.completion_code, PLDM_ERROR_INVALID_DATA);
797 }
798 #endif
799
TEST(SetNumericEffecterValue,testGoodDecodeRequest)800 TEST(SetNumericEffecterValue, testGoodDecodeRequest)
801 {
802 std::array<uint8_t,
803 hdrSize + PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES + 3>
804 requestMsg{};
805
806 uint16_t effecter_id = 32768;
807 uint8_t effecter_data_size = PLDM_EFFECTER_DATA_SIZE_UINT32;
808 uint32_t effecter_value = 123456789;
809
810 uint16_t reteffecter_id;
811 uint8_t reteffecter_data_size;
812 uint8_t reteffecter_value[4];
813
814 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
815 auto req = reinterpret_cast<pldm_msg*>(requestMsg.data());
816 struct pldm_set_numeric_effecter_value_req* request =
817 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
818 reinterpret_cast<struct pldm_set_numeric_effecter_value_req*>(
819 req->payload);
820
821 request->effecter_id = htole16(effecter_id);
822 request->effecter_data_size = effecter_data_size;
823 uint32_t effecter_value_le = htole32(effecter_value);
824 memcpy(request->effecter_value, &effecter_value_le,
825 sizeof(effecter_value_le));
826
827 auto rc = decode_set_numeric_effecter_value_req(
828 req, requestMsg.size() - hdrSize, &reteffecter_id,
829 &reteffecter_data_size, reteffecter_value);
830
831 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
832 uint32_t value = *(reinterpret_cast<uint32_t*>(reteffecter_value));
833 EXPECT_EQ(rc, PLDM_SUCCESS);
834 EXPECT_EQ(reteffecter_id, effecter_id);
835 EXPECT_EQ(reteffecter_data_size, effecter_data_size);
836 EXPECT_EQ(value, effecter_value);
837 }
838
TEST(SetNumericEffecterValue,testBadDecodeRequest)839 TEST(SetNumericEffecterValue, testBadDecodeRequest)
840 {
841 std::array<uint8_t, hdrSize + PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES>
842 requestMsg{};
843
844 auto rc = decode_set_numeric_effecter_value_req(
845 NULL, requestMsg.size() - hdrSize, NULL, NULL, NULL);
846 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
847
848 uint16_t effecter_id = 0x10;
849 uint8_t effecter_data_size = PLDM_EFFECTER_DATA_SIZE_UINT8;
850 uint8_t effecter_value = 1;
851
852 uint16_t reteffecter_id;
853 uint8_t reteffecter_data_size;
854 uint8_t reteffecter_value[4];
855
856 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
857 auto req = reinterpret_cast<pldm_msg*>(requestMsg.data());
858 struct pldm_set_numeric_effecter_value_req* request =
859 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
860 reinterpret_cast<struct pldm_set_numeric_effecter_value_req*>(
861 req->payload);
862
863 request->effecter_id = effecter_id;
864 request->effecter_data_size = effecter_data_size;
865 memcpy(request->effecter_value, &effecter_value, sizeof(effecter_value));
866
867 rc = decode_set_numeric_effecter_value_req(
868 req, requestMsg.size() - hdrSize - 1, &reteffecter_id,
869 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
870 &reteffecter_data_size, reinterpret_cast<uint8_t*>(&reteffecter_value));
871 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
872 }
873
TEST(SetNumericEffecterValue,testGoodEncodeRequest)874 TEST(SetNumericEffecterValue, testGoodEncodeRequest)
875 {
876 uint16_t effecter_id = 0;
877 uint8_t effecter_data_size = PLDM_EFFECTER_DATA_SIZE_UINT16;
878 uint16_t effecter_value = 65534;
879
880 std::vector<uint8_t> requestMsg(
881 hdrSize + PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES + 1);
882 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
883 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
884
885 auto rc = encode_set_numeric_effecter_value_req(
886 0, effecter_id, effecter_data_size,
887 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
888 reinterpret_cast<uint8_t*>(&effecter_value), request,
889 PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES + 1);
890 EXPECT_EQ(rc, PLDM_SUCCESS);
891
892 struct pldm_set_numeric_effecter_value_req* req =
893 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
894 reinterpret_cast<struct pldm_set_numeric_effecter_value_req*>(
895 request->payload);
896 EXPECT_EQ(effecter_id, req->effecter_id);
897 EXPECT_EQ(effecter_data_size, req->effecter_data_size);
898 uint16_t* val = (uint16_t*)req->effecter_value;
899 *val = le16toh(*val);
900 EXPECT_EQ(effecter_value, *val);
901 }
902
TEST(SetNumericEffecterValue,testBadEncodeRequest)903 TEST(SetNumericEffecterValue, testBadEncodeRequest)
904 {
905 std::vector<uint8_t> requestMsg(
906 hdrSize + PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES);
907 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
908 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
909
910 auto rc = encode_set_numeric_effecter_value_req(
911 0, 0, 0, NULL, NULL, PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES);
912 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
913
914 uint16_t effecter_value;
915 rc = encode_set_numeric_effecter_value_req(
916 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
917 0, 0, 6, reinterpret_cast<uint8_t*>(&effecter_value), request,
918 PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES);
919 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
920 }
921
TEST(SetNumericEffecterValue,testGoodDecodeResponse)922 TEST(SetNumericEffecterValue, testGoodDecodeResponse)
923 {
924 std::array<uint8_t, hdrSize + PLDM_SET_NUMERIC_EFFECTER_VALUE_RESP_BYTES>
925 responseMsg{};
926
927 uint8_t completion_code = 0xa0;
928
929 uint8_t retcompletion_code;
930
931 memcpy(responseMsg.data() + hdrSize, &completion_code,
932 sizeof(completion_code));
933
934 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
935 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
936
937 auto rc = decode_set_numeric_effecter_value_resp(
938 response, responseMsg.size() - hdrSize, &retcompletion_code);
939
940 EXPECT_EQ(rc, PLDM_SUCCESS);
941 EXPECT_EQ(completion_code, retcompletion_code);
942 }
943
TEST(SetNumericEffecterValue,testBadDecodeResponse)944 TEST(SetNumericEffecterValue, testBadDecodeResponse)
945 {
946 std::array<uint8_t, PLDM_SET_NUMERIC_EFFECTER_VALUE_RESP_BYTES>
947 responseMsg{};
948
949 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
950 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
951
952 auto rc = decode_set_numeric_effecter_value_resp(response,
953 responseMsg.size(), NULL);
954
955 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
956 }
957
TEST(SetNumericEffecterValue,testGoodEncodeResponse)958 TEST(SetNumericEffecterValue, testGoodEncodeResponse)
959 {
960 std::array<uint8_t, sizeof(pldm_msg_hdr) +
961 PLDM_SET_NUMERIC_EFFECTER_VALUE_RESP_BYTES>
962 responseMsg{};
963 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
964 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
965 uint8_t completionCode = 0;
966
967 auto rc = encode_set_numeric_effecter_value_resp(
968 0, PLDM_SUCCESS, response, PLDM_SET_NUMERIC_EFFECTER_VALUE_RESP_BYTES);
969
970 EXPECT_EQ(rc, PLDM_SUCCESS);
971 EXPECT_EQ(completionCode, response->payload[0]);
972 }
973
TEST(SetNumericEffecterValue,testBadEncodeResponse)974 TEST(SetNumericEffecterValue, testBadEncodeResponse)
975 {
976 auto rc = encode_set_numeric_effecter_value_resp(
977 0, PLDM_SUCCESS, NULL, PLDM_SET_NUMERIC_EFFECTER_VALUE_RESP_BYTES);
978 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
979 }
980
TEST(GetStateSensorReadings,testGoodEncodeResponse)981 TEST(GetStateSensorReadings, testGoodEncodeResponse)
982 {
983 std::array<uint8_t, hdrSize +
984 PLDM_GET_STATE_SENSOR_READINGS_MIN_RESP_BYTES +
985 sizeof(get_sensor_state_field) * 2>
986 responseMsg{};
987
988 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
989 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
990 uint8_t completionCode = 0;
991 uint8_t comp_sensorCnt = 0x2;
992
993 std::array<get_sensor_state_field, 2> stateField{};
994 stateField[0] = {PLDM_SENSOR_ENABLED, PLDM_SENSOR_NORMAL,
995 PLDM_SENSOR_WARNING, PLDM_SENSOR_UNKNOWN};
996 stateField[1] = {PLDM_SENSOR_FAILED, PLDM_SENSOR_UPPERFATAL,
997 PLDM_SENSOR_UPPERCRITICAL, PLDM_SENSOR_FATAL};
998
999 auto rc = encode_get_state_sensor_readings_resp(
1000 0, PLDM_SUCCESS, comp_sensorCnt, stateField.data(), response);
1001
1002 struct pldm_get_state_sensor_readings_resp* resp =
1003 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1004 reinterpret_cast<struct pldm_get_state_sensor_readings_resp*>(
1005 response->payload);
1006
1007 EXPECT_EQ(rc, PLDM_SUCCESS);
1008 EXPECT_EQ(completionCode, resp->completion_code);
1009 EXPECT_EQ(comp_sensorCnt, resp->comp_sensor_count);
1010 EXPECT_EQ(stateField[0].sensor_op_state, resp->field->sensor_op_state);
1011 EXPECT_EQ(stateField[0].present_state, resp->field->present_state);
1012 EXPECT_EQ(stateField[0].previous_state, resp->field->previous_state);
1013 EXPECT_EQ(stateField[0].event_state, resp->field->event_state);
1014 EXPECT_EQ(stateField[1].sensor_op_state, resp->field[1].sensor_op_state);
1015 EXPECT_EQ(stateField[1].present_state, resp->field[1].present_state);
1016 EXPECT_EQ(stateField[1].previous_state, resp->field[1].previous_state);
1017 EXPECT_EQ(stateField[1].event_state, resp->field[1].event_state);
1018 }
1019
TEST(GetStateSensorReadings,testBadEncodeResponse)1020 TEST(GetStateSensorReadings, testBadEncodeResponse)
1021 {
1022 auto rc = encode_get_state_sensor_readings_resp(0, PLDM_SUCCESS, 0, nullptr,
1023 nullptr);
1024
1025 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1026 }
1027
TEST(GetStateSensorReadings,testGoodDecodeResponse)1028 TEST(GetStateSensorReadings, testGoodDecodeResponse)
1029 {
1030 std::array<uint8_t, hdrSize +
1031 PLDM_GET_STATE_SENSOR_READINGS_MIN_RESP_BYTES +
1032 sizeof(get_sensor_state_field) * 2>
1033 responseMsg{};
1034
1035 uint8_t completionCode = 0;
1036 uint8_t comp_sensorCnt = 2;
1037
1038 std::array<get_sensor_state_field, 2> stateField{};
1039 stateField[0] = {PLDM_SENSOR_DISABLED, PLDM_SENSOR_UNKNOWN,
1040 PLDM_SENSOR_UNKNOWN, PLDM_SENSOR_UNKNOWN};
1041 stateField[1] = {PLDM_SENSOR_ENABLED, PLDM_SENSOR_LOWERFATAL,
1042 PLDM_SENSOR_LOWERCRITICAL, PLDM_SENSOR_WARNING};
1043
1044 uint8_t retcompletion_code = 0;
1045 uint8_t retcomp_sensorCnt = 0;
1046 std::array<get_sensor_state_field, 2> retstateField{};
1047
1048 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1049 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1050 struct pldm_get_state_sensor_readings_resp* resp =
1051 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1052 reinterpret_cast<struct pldm_get_state_sensor_readings_resp*>(
1053 response->payload);
1054
1055 resp->completion_code = completionCode;
1056 resp->comp_sensor_count = comp_sensorCnt;
1057 memcpy(resp->field, &stateField,
1058 (sizeof(get_sensor_state_field) * comp_sensorCnt));
1059
1060 auto rc = decode_get_state_sensor_readings_resp(
1061 response, responseMsg.size() - hdrSize, &retcompletion_code,
1062 &retcomp_sensorCnt, retstateField.data());
1063
1064 EXPECT_EQ(rc, PLDM_SUCCESS);
1065 EXPECT_EQ(completionCode, retcompletion_code);
1066 EXPECT_EQ(comp_sensorCnt, retcomp_sensorCnt);
1067 EXPECT_EQ(stateField[0].sensor_op_state, retstateField[0].sensor_op_state);
1068 EXPECT_EQ(stateField[0].present_state, retstateField[0].present_state);
1069 EXPECT_EQ(stateField[0].previous_state, retstateField[0].previous_state);
1070 EXPECT_EQ(stateField[0].event_state, retstateField[0].event_state);
1071 EXPECT_EQ(stateField[1].sensor_op_state, retstateField[1].sensor_op_state);
1072 EXPECT_EQ(stateField[1].present_state, retstateField[1].present_state);
1073 EXPECT_EQ(stateField[1].previous_state, retstateField[1].previous_state);
1074 EXPECT_EQ(stateField[1].event_state, retstateField[1].event_state);
1075 }
1076
TEST(GetStateSensorReadings,testBadDecodeResponse)1077 TEST(GetStateSensorReadings, testBadDecodeResponse)
1078 {
1079 std::array<uint8_t, hdrSize +
1080 PLDM_GET_STATE_SENSOR_READINGS_MIN_RESP_BYTES +
1081 sizeof(get_sensor_state_field) * 2>
1082 responseMsg{};
1083
1084 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1085 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1086
1087 auto rc = decode_get_state_sensor_readings_resp(
1088 response, responseMsg.size() - hdrSize, nullptr, nullptr, nullptr);
1089
1090 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1091
1092 uint8_t completionCode = 0;
1093 uint8_t comp_sensorCnt = 1;
1094
1095 std::array<get_sensor_state_field, 1> stateField{};
1096 stateField[0] = {PLDM_SENSOR_ENABLED, PLDM_SENSOR_UPPERFATAL,
1097 PLDM_SENSOR_UPPERCRITICAL, PLDM_SENSOR_WARNING};
1098
1099 uint8_t retcompletion_code = 0;
1100 uint8_t retcomp_sensorCnt = 0;
1101 std::array<get_sensor_state_field, 1> retstateField{};
1102
1103 struct pldm_get_state_sensor_readings_resp* resp =
1104 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1105 reinterpret_cast<struct pldm_get_state_sensor_readings_resp*>(
1106 response->payload);
1107
1108 resp->completion_code = completionCode;
1109 resp->comp_sensor_count = comp_sensorCnt;
1110 memcpy(resp->field, &stateField,
1111 (sizeof(get_sensor_state_field) * comp_sensorCnt));
1112
1113 rc = decode_get_state_sensor_readings_resp(
1114 response, responseMsg.size() - hdrSize, &retcompletion_code,
1115 &retcomp_sensorCnt, retstateField.data());
1116
1117 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1118 }
1119
TEST(GetStateSensorReadings,testGoodEncodeRequest)1120 TEST(GetStateSensorReadings, testGoodEncodeRequest)
1121 {
1122 std::array<uint8_t, hdrSize + PLDM_GET_STATE_SENSOR_READINGS_REQ_BYTES>
1123 requestMsg{};
1124
1125 uint16_t sensorId = 0xab;
1126 bitfield8_t sensorRearm;
1127 sensorRearm.byte = 0x03;
1128
1129 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1130 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1131 auto rc = encode_get_state_sensor_readings_req(0, sensorId, sensorRearm, 0,
1132 request);
1133
1134 struct pldm_get_state_sensor_readings_req* req =
1135 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1136 reinterpret_cast<struct pldm_get_state_sensor_readings_req*>(
1137 request->payload);
1138
1139 EXPECT_EQ(rc, PLDM_SUCCESS);
1140 EXPECT_EQ(sensorId, le16toh(req->sensor_id));
1141 EXPECT_EQ(sensorRearm.byte, req->sensor_rearm.byte);
1142 }
1143
TEST(GetStateSensorReadings,testBadEncodeRequest)1144 TEST(GetStateSensorReadings, testBadEncodeRequest)
1145 {
1146 bitfield8_t sensorRearm;
1147 sensorRearm.byte = 0x0;
1148
1149 auto rc =
1150 encode_get_state_sensor_readings_req(0, 0, sensorRearm, 0, nullptr);
1151
1152 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1153 }
1154
TEST(GetStateSensorReadings,testGoodDecodeRequest)1155 TEST(GetStateSensorReadings, testGoodDecodeRequest)
1156 {
1157 std::array<uint8_t, hdrSize + PLDM_GET_STATE_SENSOR_READINGS_REQ_BYTES>
1158 requestMsg{};
1159
1160 uint16_t sensorId = 0xcd;
1161 bitfield8_t sensorRearm;
1162 sensorRearm.byte = 0x10;
1163
1164 uint16_t retsensorId;
1165 bitfield8_t retsensorRearm;
1166 uint8_t retreserved;
1167
1168 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1169 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1170
1171 struct pldm_get_state_sensor_readings_req* req =
1172 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1173 reinterpret_cast<struct pldm_get_state_sensor_readings_req*>(
1174 request->payload);
1175
1176 req->sensor_id = htole16(sensorId);
1177 req->sensor_rearm.byte = sensorRearm.byte;
1178
1179 auto rc = decode_get_state_sensor_readings_req(
1180 request, requestMsg.size() - hdrSize, &retsensorId, &retsensorRearm,
1181 &retreserved);
1182
1183 EXPECT_EQ(rc, PLDM_SUCCESS);
1184 EXPECT_EQ(sensorId, retsensorId);
1185 EXPECT_EQ(sensorRearm.byte, retsensorRearm.byte);
1186 EXPECT_EQ(0, retreserved);
1187 }
1188
TEST(GetStateSensorReadings,testBadDecodeRequest)1189 TEST(GetStateSensorReadings, testBadDecodeRequest)
1190 {
1191 std::array<uint8_t, hdrSize + PLDM_GET_STATE_SENSOR_READINGS_REQ_BYTES>
1192 requestMsg{};
1193
1194 auto rc = decode_get_state_sensor_readings_req(
1195 nullptr, requestMsg.size() - hdrSize, nullptr, nullptr, nullptr);
1196
1197 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1198 uint16_t sensorId = 0x11;
1199 bitfield8_t sensorRearm;
1200 sensorRearm.byte = 0x04;
1201
1202 uint16_t retsensorId;
1203 bitfield8_t retsensorRearm;
1204 uint8_t retreserved;
1205
1206 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1207 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1208
1209 struct pldm_get_state_sensor_readings_req* req =
1210 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1211 reinterpret_cast<struct pldm_get_state_sensor_readings_req*>(
1212 request->payload);
1213
1214 req->sensor_id = htole16(sensorId);
1215 req->sensor_rearm.byte = sensorRearm.byte;
1216
1217 rc = decode_get_state_sensor_readings_req(
1218 request, requestMsg.size() - hdrSize - 1, &retsensorId, &retsensorRearm,
1219 &retreserved);
1220
1221 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1222 }
1223
TEST(EventMessageBufferSize,testGoodEventMessageBufferSizeRequest)1224 TEST(EventMessageBufferSize, testGoodEventMessageBufferSizeRequest)
1225 {
1226 uint8_t eventBufferSize = 32;
1227
1228 std::array<uint8_t, hdrSize + PLDM_EVENT_MESSAGE_BUFFER_SIZE_REQ_BYTES>
1229 requestMsg{};
1230 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1231 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1232
1233 auto rc = encode_event_message_buffer_size_req(0, eventBufferSize, request);
1234
1235 EXPECT_EQ(rc, PLDM_SUCCESS);
1236 }
1237
TEST(EventMessageBufferSize,testGoodEventMessageBufferSizeResponse)1238 TEST(EventMessageBufferSize, testGoodEventMessageBufferSizeResponse)
1239 {
1240 uint8_t completionCode = PLDM_SUCCESS;
1241 uint16_t terminusMaxBufferSize = 256;
1242
1243 std::array<uint8_t, hdrSize + PLDM_EVENT_MESSAGE_BUFFER_SIZE_RESP_BYTES>
1244 responseMsg{};
1245
1246 uint8_t retCompletionCode;
1247 uint16_t retMaxBufferSize = 0;
1248
1249 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1250 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1251 struct pldm_event_message_buffer_size_resp* resp =
1252 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1253 reinterpret_cast<struct pldm_event_message_buffer_size_resp*>(
1254 response->payload);
1255
1256 resp->completion_code = completionCode;
1257 resp->terminus_max_buffer_size = terminusMaxBufferSize;
1258
1259 auto rc = decode_event_message_buffer_size_resp(
1260 response, responseMsg.size() - hdrSize, &retCompletionCode,
1261 &retMaxBufferSize);
1262
1263 EXPECT_EQ(rc, PLDM_SUCCESS);
1264 EXPECT_EQ(retCompletionCode, completionCode);
1265 EXPECT_EQ(terminusMaxBufferSize, retMaxBufferSize);
1266 }
1267
TEST(EventMessageBufferSize,testBadEventMessageBufferSizeResponse)1268 TEST(EventMessageBufferSize, testBadEventMessageBufferSizeResponse)
1269 {
1270 uint8_t completionCode = PLDM_SUCCESS;
1271 uint16_t terminusMaxBufferSize = 256;
1272
1273 std::array<uint8_t, hdrSize + PLDM_EVENT_MESSAGE_BUFFER_SIZE_RESP_BYTES>
1274 responseMsg{};
1275
1276 uint8_t retCompletionCode;
1277 uint16_t retMaxBufferSize = 0;
1278
1279 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1280 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1281 struct pldm_event_message_buffer_size_resp* resp =
1282 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1283 reinterpret_cast<struct pldm_event_message_buffer_size_resp*>(
1284 response->payload);
1285 resp->completion_code = completionCode;
1286 resp->terminus_max_buffer_size = terminusMaxBufferSize;
1287
1288 auto rc =
1289 decode_event_message_buffer_size_resp(response, 0, nullptr, nullptr);
1290 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1291
1292 rc = decode_event_message_buffer_size_resp(
1293 response, responseMsg.size(), &retCompletionCode, &retMaxBufferSize);
1294 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1295 }
1296
TEST(PlatformEventMessageSupported,testGoodEncodeRequest)1297 TEST(PlatformEventMessageSupported, testGoodEncodeRequest)
1298 {
1299 uint8_t formatVersion = 0x01;
1300
1301 std::array<uint8_t, hdrSize + PLDM_EVENT_MESSAGE_SUPPORTED_REQ_BYTES>
1302 requestMsg{};
1303
1304 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1305 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1306
1307 auto rc = encode_event_message_supported_req(0, formatVersion, request);
1308
1309 struct pldm_event_message_supported_req* req =
1310 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1311 reinterpret_cast<struct pldm_event_message_supported_req*>(
1312 request->payload);
1313
1314 EXPECT_EQ(rc, PLDM_SUCCESS);
1315 EXPECT_EQ(formatVersion, req->format_version);
1316 }
1317
TEST(PlatformEventMessageSupported,testBadEncodeRequest)1318 TEST(PlatformEventMessageSupported, testBadEncodeRequest)
1319 {
1320 uint8_t eventData = 34;
1321 uint8_t formatVersion = 0x0;
1322
1323 std::array<uint8_t, hdrSize + PLDM_EVENT_MESSAGE_SUPPORTED_REQ_BYTES +
1324 sizeof(eventData)>
1325 requestMsg{};
1326 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1327 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1328
1329 auto rc = encode_event_message_supported_req(0, formatVersion, request);
1330 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1331
1332 rc = encode_event_message_supported_req(0, formatVersion, nullptr);
1333 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1334 }
1335
TEST(PlatformEventMessageSupported,testGoodDecodeRespond)1336 TEST(PlatformEventMessageSupported, testGoodDecodeRespond)
1337 {
1338 uint8_t completionCode = PLDM_SUCCESS;
1339 uint8_t synchConfiguration = PLDM_MESSAGE_TYPE_SYNCHRONOUS;
1340 bitfield8_t synchConfigSupported;
1341 synchConfigSupported.byte = 0xe;
1342 uint8_t numberEventClassReturned = 0x3;
1343 std::vector<uint8_t> eventClass{0x0, 0x5, 0xfa};
1344 constexpr uint8_t eventClassCount = 3;
1345
1346 std::array<uint8_t, hdrSize + PLDM_EVENT_MESSAGE_SUPPORTED_MIN_RESP_BYTES +
1347 eventClassCount>
1348 responseMsg{};
1349
1350 uint8_t retCompletionCode;
1351 uint8_t retSynchConfig = 0;
1352 uint8_t retNumberEventClass = 0;
1353 bitfield8_t retSynchConfigSupport;
1354 uint8_t retEventClass[eventClassCount] = {0};
1355
1356 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1357 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1358 struct pldm_event_message_supported_resp* resp =
1359 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1360 reinterpret_cast<struct pldm_event_message_supported_resp*>(
1361 response->payload);
1362
1363 resp->completion_code = completionCode;
1364 resp->synchrony_configuration = synchConfiguration;
1365 resp->synchrony_configuration_supported.byte = synchConfigSupported.byte;
1366 resp->number_event_class_returned = numberEventClassReturned;
1367 memcpy(resp->event_class, eventClass.data(), numberEventClassReturned);
1368
1369 auto rc = decode_event_message_supported_resp(
1370 response, responseMsg.size() - hdrSize, &retCompletionCode,
1371 &retSynchConfig, &retSynchConfigSupport, &retNumberEventClass,
1372 retEventClass, eventClassCount);
1373
1374 EXPECT_EQ(rc, PLDM_SUCCESS);
1375 EXPECT_EQ(retCompletionCode, completionCode);
1376 EXPECT_EQ(retSynchConfig, synchConfiguration);
1377 EXPECT_EQ(retNumberEventClass, numberEventClassReturned);
1378 EXPECT_EQ(retSynchConfigSupport.byte, synchConfigSupported.byte);
1379 EXPECT_EQ(0, memcmp(eventClass.data(), resp->event_class,
1380 numberEventClassReturned));
1381 }
1382
TEST(PlatformEventMessageSupported,testBadSynchConfiguration)1383 TEST(PlatformEventMessageSupported, testBadSynchConfiguration)
1384 {
1385 uint8_t completionCode = PLDM_SUCCESS;
1386 uint8_t synchConfiguration = 0x4;
1387 bitfield8_t synchConfigSupported;
1388 synchConfigSupported.byte = 0xe;
1389 uint8_t numberEventClassReturned = 0x3;
1390 std::vector<uint8_t> eventClass{0x0, 0x5, 0xfa};
1391 constexpr uint8_t eventClassCount = 3;
1392
1393 std::array<uint8_t, hdrSize + PLDM_EVENT_MESSAGE_SUPPORTED_MIN_RESP_BYTES +
1394 eventClassCount>
1395 responseMsg{};
1396
1397 uint8_t retCompletionCode;
1398 uint8_t retSynchConfig = 0;
1399 uint8_t retNumberEventClass = 0;
1400 bitfield8_t retSynchConfigSupport;
1401 uint8_t retEventClass[eventClassCount] = {0};
1402
1403 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1404 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1405 struct pldm_event_message_supported_resp* resp =
1406 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1407 reinterpret_cast<struct pldm_event_message_supported_resp*>(
1408 response->payload);
1409
1410 resp->completion_code = completionCode;
1411 resp->synchrony_configuration = synchConfiguration;
1412 resp->synchrony_configuration_supported.byte = synchConfigSupported.byte;
1413 resp->number_event_class_returned = numberEventClassReturned;
1414 memcpy(resp->event_class, eventClass.data(), numberEventClassReturned);
1415
1416 auto rc = decode_event_message_supported_resp(
1417 response, responseMsg.size() - hdrSize, &retCompletionCode,
1418 &retSynchConfig, &retSynchConfigSupport, &retNumberEventClass,
1419 retEventClass, eventClassCount);
1420
1421 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1422 }
1423
TEST(PlatformEventMessageSupported,testBadDecodeRespond)1424 TEST(PlatformEventMessageSupported, testBadDecodeRespond)
1425 {
1426 uint8_t completionCode = PLDM_SUCCESS;
1427 uint8_t synchConfiguration = PLDM_MESSAGE_TYPE_SYNCHRONOUS;
1428 bitfield8_t synchConfigSupported;
1429 synchConfigSupported.byte = 0xe;
1430 uint8_t numberEventClassReturned = 0x3;
1431 std::vector<uint8_t> eventClass{0x0, 0x5, 0xfa};
1432 constexpr uint8_t eventClassCount = 3;
1433
1434 std::array<uint8_t, hdrSize + PLDM_EVENT_MESSAGE_SUPPORTED_MIN_RESP_BYTES +
1435 eventClassCount>
1436 responseMsg{};
1437
1438 uint8_t retCompletionCode;
1439 uint8_t retSynchConfig = 0;
1440 uint8_t retNumberEventClass = 0;
1441 bitfield8_t retSynchConfigSupport;
1442 uint8_t retEventClass[eventClassCount] = {0};
1443
1444 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1445 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1446 struct pldm_event_message_supported_resp* resp =
1447 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1448 reinterpret_cast<struct pldm_event_message_supported_resp*>(
1449 response->payload);
1450 resp->completion_code = completionCode;
1451 resp->synchrony_configuration = synchConfiguration;
1452 resp->synchrony_configuration_supported.byte = synchConfigSupported.byte;
1453 resp->number_event_class_returned = numberEventClassReturned;
1454 memcpy(resp->event_class, eventClass.data(), numberEventClassReturned);
1455
1456 auto rc = decode_event_message_supported_resp(response, 0, nullptr, nullptr,
1457 nullptr, nullptr, nullptr, 0);
1458 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1459
1460 rc = decode_event_message_supported_resp(
1461 response, PLDM_EVENT_MESSAGE_SUPPORTED_MIN_RESP_BYTES - 1,
1462 &retCompletionCode, &retSynchConfig, &retSynchConfigSupport,
1463 &retNumberEventClass, retEventClass, eventClassCount);
1464 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1465
1466 rc = decode_event_message_supported_resp(
1467 response, responseMsg.size() - hdrSize, &retCompletionCode,
1468 &retSynchConfig, &retSynchConfigSupport, &retNumberEventClass,
1469 retEventClass, 1);
1470 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1471 }
1472
TEST(PollForPlatformEventMessage,testGoodEncodeRequestFirstPart)1473 TEST(PollForPlatformEventMessage, testGoodEncodeRequestFirstPart)
1474 {
1475 uint8_t formatVersion = 0x01;
1476 uint8_t transferOperationFlag = PLDM_GET_FIRSTPART;
1477 uint32_t dataTransferHandle = 0xaabbccdd;
1478 uint16_t eventIdToAcknowledge = PLDM_PLATFORM_EVENT_ID_NULL;
1479
1480 PLDM_MSG_DEFINE_P(request, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1481
1482 auto rc = encode_poll_for_platform_event_message_req(
1483 0, formatVersion, transferOperationFlag, dataTransferHandle,
1484 eventIdToAcknowledge, request,
1485 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1486 EXPECT_EQ(rc, PLDM_SUCCESS);
1487
1488 PLDM_MSGBUF_DEFINE_P(buf);
1489 rc = pldm_msgbuf_init_errno(
1490 buf, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES, request->payload,
1491 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1492 ASSERT_EQ(rc, 0);
1493
1494 uint8_t retFormatVersion;
1495 uint8_t retTransferOperationFlag;
1496 uint32_t retDataTransferHandle;
1497 uint16_t retEventIdToAcknowledge;
1498
1499 pldm_msgbuf_extract_uint8(buf, retFormatVersion);
1500 pldm_msgbuf_extract_uint8(buf, retTransferOperationFlag);
1501 pldm_msgbuf_extract_uint32(buf, retDataTransferHandle);
1502 pldm_msgbuf_extract_uint16(buf, retEventIdToAcknowledge);
1503 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
1504
1505 EXPECT_EQ(retFormatVersion, formatVersion);
1506 EXPECT_EQ(retTransferOperationFlag, transferOperationFlag);
1507 EXPECT_EQ(retDataTransferHandle, dataTransferHandle);
1508 EXPECT_EQ(retEventIdToAcknowledge, eventIdToAcknowledge);
1509 }
1510
TEST(PollForPlatformEventMessage,testGoodEncodeRequestNextPart)1511 TEST(PollForPlatformEventMessage, testGoodEncodeRequestNextPart)
1512 {
1513 uint8_t formatVersion = 0x01;
1514 uint8_t transferOperationFlag = PLDM_GET_NEXTPART;
1515 uint32_t dataTransferHandle = 0xaabbccdd;
1516 uint16_t eventIdToAcknowledge = PLDM_PLATFORM_EVENT_ID_FRAGMENT;
1517
1518 PLDM_MSG_DEFINE_P(request, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1519
1520 auto rc = encode_poll_for_platform_event_message_req(
1521 0, formatVersion, transferOperationFlag, dataTransferHandle,
1522 eventIdToAcknowledge, request,
1523 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1524 EXPECT_EQ(rc, PLDM_SUCCESS);
1525
1526 PLDM_MSGBUF_DEFINE_P(buf);
1527 rc = pldm_msgbuf_init_errno(
1528 buf, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES, request->payload,
1529 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1530 ASSERT_EQ(rc, 0);
1531
1532 uint8_t retFormatVersion;
1533 uint8_t retTransferOperationFlag;
1534 uint32_t retDataTransferHandle;
1535 uint16_t retEventIdToAcknowledge;
1536
1537 pldm_msgbuf_extract_uint8(buf, retFormatVersion);
1538 pldm_msgbuf_extract_uint8(buf, retTransferOperationFlag);
1539 pldm_msgbuf_extract_uint32(buf, retDataTransferHandle);
1540 pldm_msgbuf_extract_uint16(buf, retEventIdToAcknowledge);
1541 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
1542
1543 EXPECT_EQ(retFormatVersion, formatVersion);
1544 EXPECT_EQ(retTransferOperationFlag, transferOperationFlag);
1545 EXPECT_EQ(retDataTransferHandle, dataTransferHandle);
1546 EXPECT_EQ(retEventIdToAcknowledge, eventIdToAcknowledge);
1547 }
1548
TEST(PollForPlatformEventMessage,testGoodEncodeRequestAckOnly)1549 TEST(PollForPlatformEventMessage, testGoodEncodeRequestAckOnly)
1550 {
1551 uint8_t formatVersion = 0x01;
1552 uint8_t transferOperationFlag = PLDM_ACKNOWLEDGEMENT_ONLY;
1553 uint32_t dataTransferHandle = 0xaabbccdd;
1554 uint16_t eventIdToAcknowledge = 0x1234;
1555
1556 PLDM_MSG_DEFINE_P(request, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1557
1558 auto rc = encode_poll_for_platform_event_message_req(
1559 0, formatVersion, transferOperationFlag, dataTransferHandle,
1560 eventIdToAcknowledge, request,
1561 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1562 EXPECT_EQ(rc, PLDM_SUCCESS);
1563
1564 PLDM_MSGBUF_DEFINE_P(buf);
1565 rc = pldm_msgbuf_init_errno(
1566 buf, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES, request->payload,
1567 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1568 ASSERT_EQ(rc, 0);
1569
1570 uint8_t retFormatVersion;
1571 uint8_t retTransferOperationFlag;
1572 uint32_t retDataTransferHandle;
1573 uint16_t retEventIdToAcknowledge;
1574
1575 pldm_msgbuf_extract_uint8(buf, retFormatVersion);
1576 pldm_msgbuf_extract_uint8(buf, retTransferOperationFlag);
1577 pldm_msgbuf_extract_uint32(buf, retDataTransferHandle);
1578 pldm_msgbuf_extract_uint16(buf, retEventIdToAcknowledge);
1579 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
1580
1581 EXPECT_EQ(retFormatVersion, formatVersion);
1582 EXPECT_EQ(retTransferOperationFlag, transferOperationFlag);
1583 EXPECT_EQ(retDataTransferHandle, dataTransferHandle);
1584 EXPECT_EQ(retEventIdToAcknowledge, eventIdToAcknowledge);
1585 }
1586
TEST(PollForPlatformEventMessage,testBadEncodeRequest)1587 TEST(PollForPlatformEventMessage, testBadEncodeRequest)
1588 {
1589 uint8_t formatVersion = 0x01;
1590 uint8_t transferOperationFlag = PLDM_GET_FIRSTPART;
1591 uint32_t dataTransferHandle = 0xaabbccdd;
1592 uint16_t eventIdToAcknowledge = 0x1234;
1593
1594 PLDM_MSG_DEFINE_P(request, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1595
1596 auto rc = encode_poll_for_platform_event_message_req(
1597 0, formatVersion, transferOperationFlag, dataTransferHandle,
1598 eventIdToAcknowledge, nullptr,
1599 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1600 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1601
1602 transferOperationFlag = PLDM_GET_FIRSTPART;
1603 eventIdToAcknowledge = PLDM_PLATFORM_EVENT_ID_FRAGMENT;
1604 rc = encode_poll_for_platform_event_message_req(
1605 0, formatVersion, transferOperationFlag, dataTransferHandle,
1606 eventIdToAcknowledge, request,
1607 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1608 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1609
1610 transferOperationFlag = PLDM_GET_NEXTPART;
1611 eventIdToAcknowledge = 0x1234;
1612 rc = encode_poll_for_platform_event_message_req(
1613 0, formatVersion, transferOperationFlag, dataTransferHandle,
1614 eventIdToAcknowledge, request,
1615 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1616 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1617
1618 transferOperationFlag = PLDM_GET_NEXTPART;
1619 eventIdToAcknowledge = PLDM_PLATFORM_EVENT_ID_NULL;
1620 rc = encode_poll_for_platform_event_message_req(
1621 0, formatVersion, transferOperationFlag, dataTransferHandle,
1622 eventIdToAcknowledge, request,
1623 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1624 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1625
1626 transferOperationFlag = PLDM_ACKNOWLEDGEMENT_ONLY;
1627 eventIdToAcknowledge = PLDM_PLATFORM_EVENT_ID_NULL;
1628 rc = encode_poll_for_platform_event_message_req(
1629 0, formatVersion, transferOperationFlag, dataTransferHandle,
1630 eventIdToAcknowledge, request,
1631 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1632 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1633
1634 transferOperationFlag = PLDM_ACKNOWLEDGEMENT_ONLY;
1635 eventIdToAcknowledge = PLDM_PLATFORM_EVENT_ID_FRAGMENT;
1636 rc = encode_poll_for_platform_event_message_req(
1637 0, formatVersion, transferOperationFlag, dataTransferHandle,
1638 eventIdToAcknowledge, request,
1639 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1640 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1641
1642 transferOperationFlag = PLDM_ACKNOWLEDGEMENT_ONLY + 1;
1643 eventIdToAcknowledge = PLDM_PLATFORM_EVENT_ID_FRAGMENT;
1644 rc = encode_poll_for_platform_event_message_req(
1645 0, formatVersion, transferOperationFlag, dataTransferHandle,
1646 eventIdToAcknowledge, request,
1647 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_REQ_BYTES);
1648 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1649 }
1650
TEST(PollForPlatformEventMessage,testGoodDecodeRespond)1651 TEST(PollForPlatformEventMessage, testGoodDecodeRespond)
1652 {
1653 uint8_t completionCode = PLDM_SUCCESS;
1654 uint8_t tId = 0x9;
1655 uint16_t eventId = 159;
1656 uint32_t nextDataTransferHandle = 0x11223344;
1657 uint8_t transferFlag = PLDM_START_AND_END;
1658 uint8_t eventClass = 0x5;
1659 uint8_t eventData[5] = {0x55, 0x44, 0x33, 0x22, 0x11};
1660 constexpr uint32_t eventDataSize = 0x00000005;
1661 uint32_t eventDataIntegrityChecksum = 0x66778899;
1662
1663 std::vector<uint8_t> responseMsg{
1664 0x1,
1665 0x0,
1666 0x0,
1667 PLDM_SUCCESS,
1668 0x9, // tid
1669 159,
1670 0x0, // event id
1671 0x44,
1672 0x33,
1673 0x22,
1674 0x11, // next_data_transfer_handle
1675 PLDM_START_AND_END, // transfer_flag
1676 0x05, // event class
1677 0x05,
1678 0x00,
1679 0x00,
1680 0x00, // event_data_size
1681 0x55,
1682 0x44,
1683 0x33,
1684 0x22,
1685 0x11, // event_data[5]
1686 0x99,
1687 0x88,
1688 0x77,
1689 0x66 // event_data_integrity_checksum
1690 };
1691 const uint32_t respMsgLen = 23;
1692
1693 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1694 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1695
1696 uint8_t retCompletionCode;
1697 uint8_t retTid = 0;
1698 uint16_t retEventId = 0;
1699 uint32_t retNextDataTransferHandle = 0;
1700 uint8_t retTransferFlag = 0;
1701 uint8_t retEventClass = 0;
1702 uint32_t retEventDataSize = 0;
1703 uint8_t* retEventData = nullptr;
1704 uint32_t retEventDataIntegrityChecksum = 0;
1705
1706 auto rc = decode_poll_for_platform_event_message_resp(
1707 response, respMsgLen, &retCompletionCode, &retTid, &retEventId,
1708 &retNextDataTransferHandle, &retTransferFlag, &retEventClass,
1709 &retEventDataSize, (void**)&retEventData,
1710 &retEventDataIntegrityChecksum);
1711
1712 EXPECT_EQ(rc, PLDM_SUCCESS);
1713 EXPECT_EQ(retCompletionCode, completionCode);
1714 EXPECT_EQ(retTid, tId);
1715 EXPECT_EQ(retEventId, eventId);
1716 EXPECT_EQ(retNextDataTransferHandle, nextDataTransferHandle);
1717 EXPECT_EQ(retTransferFlag, transferFlag);
1718 EXPECT_EQ(retEventClass, eventClass);
1719 EXPECT_EQ(retEventDataSize, eventDataSize);
1720 EXPECT_EQ(retEventDataIntegrityChecksum, eventDataIntegrityChecksum);
1721 EXPECT_EQ(0, memcmp(eventData, retEventData, eventDataSize));
1722 }
1723
TEST(PollForPlatformEventMessage,testGoodDecodeAckOnlyRespond)1724 TEST(PollForPlatformEventMessage, testGoodDecodeAckOnlyRespond)
1725 {
1726 uint8_t completionCode = PLDM_SUCCESS;
1727 uint8_t tId = 0x9;
1728 uint16_t eventId = 0xffff;
1729
1730 std::vector<uint8_t> responseMsg{
1731 0x1, 0x0, 0x0, PLDM_SUCCESS,
1732 0x9, // tid
1733 0xff,
1734 0xff // event id
1735 };
1736 const uint32_t respMsgLen = 4;
1737
1738 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1739 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1740
1741 uint8_t retCompletionCode;
1742 uint8_t retTid = 0;
1743 uint16_t retEventId = 0;
1744 uint32_t retNextDataTransferHandle = 0;
1745 uint8_t retTransferFlag = 0;
1746 uint8_t retEventClass = 0;
1747 uint32_t retEventDataSize = 0;
1748 uint8_t* retEventData = nullptr;
1749 uint32_t retEventDataIntegrityChecksum = 0;
1750
1751 auto rc = decode_poll_for_platform_event_message_resp(
1752 response, respMsgLen, &retCompletionCode, &retTid, &retEventId,
1753 &retNextDataTransferHandle, &retTransferFlag, &retEventClass,
1754 &retEventDataSize, (void**)&retEventData,
1755 &retEventDataIntegrityChecksum);
1756
1757 EXPECT_EQ(rc, PLDM_SUCCESS);
1758 EXPECT_EQ(retCompletionCode, completionCode);
1759 EXPECT_EQ(retTid, tId);
1760 EXPECT_EQ(retEventId, eventId);
1761
1762 eventId = 0x0000;
1763 responseMsg[5] = 0x00;
1764 responseMsg[6] = 0x00;
1765 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1766 response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1767
1768 rc = decode_poll_for_platform_event_message_resp(
1769 response, respMsgLen, &retCompletionCode, &retTid, &retEventId,
1770 &retNextDataTransferHandle, &retTransferFlag, &retEventClass,
1771 &retEventDataSize, (void**)&retEventData,
1772 &retEventDataIntegrityChecksum);
1773
1774 EXPECT_EQ(rc, PLDM_SUCCESS);
1775 EXPECT_EQ(retCompletionCode, completionCode);
1776 EXPECT_EQ(retTid, tId);
1777 EXPECT_EQ(retEventId, eventId);
1778 }
1779
TEST(PollForPlatformEventMessage,testBadDecodeRespond)1780 TEST(PollForPlatformEventMessage, testBadDecodeRespond)
1781 {
1782 std::vector<uint8_t> responseMsg{
1783 0x1,
1784 0x0,
1785 0x0,
1786 PLDM_SUCCESS,
1787 0x9, // tid
1788 159,
1789 0x0, // event id
1790 0x44,
1791 0x33,
1792 0x22,
1793 0x11, // next_data_transfer_handle
1794 PLDM_START_AND_END, // transfer_flag
1795 0x05, // event class
1796 0x05,
1797 0x00,
1798 0x00,
1799 0x00, // event_data_size
1800 0x55,
1801 0x44,
1802 0x33,
1803 0x22,
1804 0x11, // event_data[5]
1805 0x99,
1806 0x88,
1807 0x77,
1808 0x66 // event_data_integrity_checksum
1809 };
1810 // const uint32_t respMsgLen = 23;
1811
1812 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1813 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
1814
1815 auto rc = decode_poll_for_platform_event_message_resp(
1816 nullptr, 0, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
1817 nullptr, nullptr, nullptr);
1818
1819 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1820
1821 uint8_t retCompletionCode;
1822 uint8_t retTid = 0;
1823 uint16_t retEventId = 0;
1824 uint32_t retNextDataTransferHandle = 0;
1825 uint8_t retTransferFlag = 0;
1826 uint8_t retEventClass = 0;
1827 uint32_t retEventDataSize = 0;
1828 uint8_t* retEventData = nullptr;
1829 uint32_t retEventDataIntegrityChecksum = 0;
1830
1831 rc = decode_poll_for_platform_event_message_resp(
1832 response, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES - 1,
1833 &retCompletionCode, &retTid, &retEventId, &retNextDataTransferHandle,
1834 &retTransferFlag, &retEventClass, &retEventDataSize,
1835 (void**)&retEventData, &retEventDataIntegrityChecksum);
1836
1837 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
1838 }
1839
TEST(PollForPlatformEventMessage,testGoodDecodeRequestFirstPart)1840 TEST(PollForPlatformEventMessage, testGoodDecodeRequestFirstPart)
1841 {
1842 uint8_t formatVersion = 0x1;
1843 uint8_t transferOperationFlag = PLDM_GET_FIRSTPART;
1844 uint32_t dataTransferHandle = 0x11223344;
1845 uint16_t eventIdToAcknowledge = PLDM_PLATFORM_EVENT_ID_NULL;
1846 std::vector<uint8_t> requestMsg{0x1, 0x0, 0x0, 0x1, PLDM_GET_FIRSTPART,
1847 0x44, 0x33, 0x22, 0x11, 0x00,
1848 0x00};
1849 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1850 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1851
1852 uint8_t retFormatVersion;
1853 uint8_t retTransferOperationFlag;
1854 uint32_t retDataTransferHandle;
1855 uint16_t retEventIdToAcknowledge;
1856
1857 auto rc = decode_poll_for_platform_event_message_req(
1858 request, requestMsg.size() - hdrSize, &retFormatVersion,
1859 &retTransferOperationFlag, &retDataTransferHandle,
1860 &retEventIdToAcknowledge);
1861
1862 EXPECT_EQ(rc, PLDM_SUCCESS);
1863 EXPECT_EQ(retFormatVersion, formatVersion);
1864 EXPECT_EQ(retTransferOperationFlag, transferOperationFlag);
1865 EXPECT_EQ(retDataTransferHandle, dataTransferHandle);
1866 EXPECT_EQ(retEventIdToAcknowledge, eventIdToAcknowledge);
1867 }
1868
TEST(PollForPlatformEventMessage,testGoodDecodeRequestNextPart)1869 TEST(PollForPlatformEventMessage, testGoodDecodeRequestNextPart)
1870 {
1871 uint8_t formatVersion = 0x1;
1872 uint8_t transferOperationFlag = PLDM_GET_NEXTPART;
1873 uint32_t dataTransferHandle = 0x11223344;
1874 uint16_t eventIdToAcknowledge = PLDM_PLATFORM_EVENT_ID_FRAGMENT;
1875 std::vector<uint8_t> requestMsg{0x1, 0x0, 0x0, 0x1, PLDM_GET_NEXTPART,
1876 0x44, 0x33, 0x22, 0x11, 0xff,
1877 0xff};
1878 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1879 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1880
1881 uint8_t retFormatVersion;
1882 uint8_t retTransferOperationFlag;
1883 uint32_t retDataTransferHandle;
1884 uint16_t retEventIdToAcknowledge;
1885
1886 auto rc = decode_poll_for_platform_event_message_req(
1887 request, requestMsg.size() - hdrSize, &retFormatVersion,
1888 &retTransferOperationFlag, &retDataTransferHandle,
1889 &retEventIdToAcknowledge);
1890
1891 EXPECT_EQ(rc, PLDM_SUCCESS);
1892 EXPECT_EQ(retFormatVersion, formatVersion);
1893 EXPECT_EQ(retTransferOperationFlag, transferOperationFlag);
1894 EXPECT_EQ(retDataTransferHandle, dataTransferHandle);
1895 EXPECT_EQ(retEventIdToAcknowledge, eventIdToAcknowledge);
1896 }
1897
TEST(PollForPlatformEventMessage,testGoodDecodeRequestAck)1898 TEST(PollForPlatformEventMessage, testGoodDecodeRequestAck)
1899 {
1900 uint8_t formatVersion = 0x1;
1901 uint8_t transferOperationFlag = PLDM_ACKNOWLEDGEMENT_ONLY;
1902 uint32_t dataTransferHandle = 0x11223344;
1903 uint16_t eventIdToAcknowledge = 0x1234;
1904 std::vector<uint8_t> requestMsg{
1905 0x1, 0x0, 0x0, 0x1, PLDM_ACKNOWLEDGEMENT_ONLY, 0x44, 0x33,
1906 0x22, 0x11, 0x34, 0x12};
1907 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1908 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1909
1910 uint8_t retFormatVersion;
1911 uint8_t retTransferOperationFlag;
1912 uint32_t retDataTransferHandle;
1913 uint16_t retEventIdToAcknowledge;
1914
1915 auto rc = decode_poll_for_platform_event_message_req(
1916 request, requestMsg.size() - hdrSize, &retFormatVersion,
1917 &retTransferOperationFlag, &retDataTransferHandle,
1918 &retEventIdToAcknowledge);
1919
1920 EXPECT_EQ(rc, PLDM_SUCCESS);
1921 EXPECT_EQ(retFormatVersion, formatVersion);
1922 EXPECT_EQ(retTransferOperationFlag, transferOperationFlag);
1923 EXPECT_EQ(retDataTransferHandle, dataTransferHandle);
1924 EXPECT_EQ(retEventIdToAcknowledge, eventIdToAcknowledge);
1925 }
1926
TEST(PollForPlatformEventMessage,testBadDecodeRequest)1927 TEST(PollForPlatformEventMessage, testBadDecodeRequest)
1928 {
1929 /*
1930 * transfer_operation_flag is PLDM_GET_FIRSTPART and
1931 * event_id_to_acknowledge is not PLDM_PLATFORM_EVENT_ID_NULL
1932 */
1933 std::vector<uint8_t> requestMsg{0x1, 0x0, 0x0, 0x1, PLDM_GET_FIRSTPART,
1934 0x44, 0x33, 0x22, 0x11, 0x66,
1935 0x55};
1936 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
1937 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
1938
1939 uint8_t retFormatVersion;
1940 uint8_t retTransferOperationFlag;
1941 uint32_t retDataTransferHandle;
1942 uint16_t retEventIdToAcknowledge;
1943
1944 auto rc = decode_poll_for_platform_event_message_req(
1945 NULL, requestMsg.size() - hdrSize, &retFormatVersion,
1946 &retTransferOperationFlag, &retDataTransferHandle,
1947 &retEventIdToAcknowledge);
1948 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1949
1950 /*
1951 * transfer_operation_flag is not PLDM_GET_FIRSTPART or PLDM_GET_NEXTPART or
1952 * PLDM_ACKNOWLEDGEMENT_ONLY
1953 */
1954
1955 requestMsg[4] = PLDM_ACKNOWLEDGEMENT_ONLY + 1;
1956
1957 rc = decode_poll_for_platform_event_message_req(
1958 request, requestMsg.size() - hdrSize, &retFormatVersion,
1959 &retTransferOperationFlag, &retDataTransferHandle,
1960 &retEventIdToAcknowledge);
1961
1962 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1963
1964 /*
1965 * transfer_operation_flag is PLDM_GET_NEXTPART and
1966 * event_id_to_acknowledge is not PLDM_PLATFORM_EVENT_ID_FRAGMENT
1967 */
1968 requestMsg[4] = PLDM_GET_NEXTPART;
1969 requestMsg[9] = 0x11;
1970 requestMsg[10] = 0x22;
1971
1972 rc = decode_poll_for_platform_event_message_req(
1973 request, requestMsg.size() - hdrSize, &retFormatVersion,
1974 &retTransferOperationFlag, &retDataTransferHandle,
1975 &retEventIdToAcknowledge);
1976
1977 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1978
1979 /*
1980 * transfer_operation_flag is PLDM_ACKNOWLEDGEMENT_ONLY and
1981 * event_id_to_acknowledge is PLDM_PLATFORM_EVENT_ID_FRAGMENT
1982 */
1983 requestMsg[4] = PLDM_ACKNOWLEDGEMENT_ONLY;
1984 requestMsg[9] = 0xff;
1985 requestMsg[10] = 0xff;
1986
1987 rc = decode_poll_for_platform_event_message_req(
1988 request, requestMsg.size() - hdrSize, &retFormatVersion,
1989 &retTransferOperationFlag, &retDataTransferHandle,
1990 &retEventIdToAcknowledge);
1991
1992 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
1993
1994 /*
1995 * transfer_operation_flag is PLDM_ACKNOWLEDGEMENT_ONLY and
1996 * event_id_to_acknowledge is PLDM_PLATFORM_EVENT_ID_NULL
1997 */
1998 requestMsg[4] = PLDM_ACKNOWLEDGEMENT_ONLY;
1999 requestMsg[9] = 0x00;
2000 requestMsg[10] = 0x00;
2001
2002 rc = decode_poll_for_platform_event_message_req(
2003 request, requestMsg.size() - hdrSize, &retFormatVersion,
2004 &retTransferOperationFlag, &retDataTransferHandle,
2005 &retEventIdToAcknowledge);
2006
2007 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2008 }
2009
TEST(PollForPlatformEventMessage,testGoodEncodeResposeP1)2010 TEST(PollForPlatformEventMessage, testGoodEncodeResposeP1)
2011 {
2012 uint8_t completionCode = PLDM_SUCCESS;
2013 uint8_t instance_id = 0;
2014 uint8_t tId = 0x9;
2015 uint16_t eventId = 0x1;
2016 uint32_t nextDataTransferHandle = 0xffff;
2017 uint8_t transferFlag = PLDM_END;
2018 uint8_t eventClass = 0x5;
2019 constexpr uint32_t eventDataSize = 9;
2020 uint8_t pEventData[eventDataSize] = {0x31, 0x32, 0x33, 0x34, 0x35,
2021 0x36, 0x37, 0x38, 0x39};
2022 uint32_t eventDataIntegrityChecksum = 0x11223344;
2023 constexpr size_t payloadLength =
2024 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_RESP_BYTES + eventDataSize + 4;
2025
2026 std::array<uint8_t, hdrSize + payloadLength> responseMsg{};
2027 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2028 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
2029
2030 auto rc = encode_poll_for_platform_event_message_resp(
2031 instance_id, completionCode, tId, eventId, nextDataTransferHandle,
2032 transferFlag, eventClass, eventDataSize, pEventData,
2033 eventDataIntegrityChecksum, response, payloadLength);
2034 EXPECT_EQ(rc, PLDM_SUCCESS);
2035
2036 PLDM_MSGBUF_DEFINE_P(buf);
2037 rc = pldm_msgbuf_init_errno(
2038 buf, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES,
2039 response->payload, payloadLength);
2040 ASSERT_EQ(rc, 0);
2041
2042 uint8_t retCompletionCode;
2043 uint8_t retTid = 0;
2044 uint16_t retEventId = 0;
2045 uint32_t retNextDataTransferHandle = 0;
2046 uint8_t retTransferFlag = 0;
2047 uint8_t retEventClass = 0;
2048 uint32_t retEventDataSize = 0;
2049 uint8_t retEventData[payloadLength] = {0};
2050 uint32_t retEventDataIntegrityChecksum = 0;
2051
2052 pldm_msgbuf_extract_uint8(buf, retCompletionCode);
2053 pldm_msgbuf_extract_uint8(buf, retTid);
2054 pldm_msgbuf_extract_uint16(buf, retEventId);
2055 pldm_msgbuf_extract_uint32(buf, retNextDataTransferHandle);
2056 pldm_msgbuf_extract_uint8(buf, retTransferFlag);
2057 pldm_msgbuf_extract_uint8(buf, retEventClass);
2058 pldm_msgbuf_extract_uint32(buf, retEventDataSize);
2059 rc = pldm_msgbuf_extract_array_uint8(buf, retEventDataSize, retEventData,
2060 sizeof(retEventData));
2061 ASSERT_EQ(rc, 0);
2062 pldm_msgbuf_extract_uint32(buf, retEventDataIntegrityChecksum);
2063 ASSERT_EQ(pldm_msgbuf_complete(buf), 0);
2064
2065 EXPECT_EQ(rc, PLDM_SUCCESS);
2066 EXPECT_EQ(retCompletionCode, completionCode);
2067 EXPECT_EQ(retTid, tId);
2068 EXPECT_EQ(retEventId, eventId);
2069 EXPECT_EQ(retNextDataTransferHandle, nextDataTransferHandle);
2070 EXPECT_EQ(retTransferFlag, transferFlag);
2071 EXPECT_EQ(retEventClass, eventClass);
2072 EXPECT_EQ(retEventDataSize, eventDataSize);
2073 EXPECT_EQ(retEventDataIntegrityChecksum, eventDataIntegrityChecksum);
2074 EXPECT_EQ(0, memcmp(pEventData, retEventData, eventDataSize));
2075 }
2076
TEST(PollForPlatformEventMessage,testGoodEncodeResposeP2)2077 TEST(PollForPlatformEventMessage, testGoodEncodeResposeP2)
2078 {
2079 uint8_t completionCode = PLDM_SUCCESS;
2080 uint8_t instance_id = 0;
2081 uint8_t tId = 0x9;
2082 uint16_t eventId = 0x0000;
2083 constexpr size_t payloadLength =
2084 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES;
2085
2086 std::array<uint8_t, hdrSize + payloadLength> responseMsg{};
2087 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2088 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
2089
2090 auto rc = encode_poll_for_platform_event_message_resp(
2091 instance_id, completionCode, tId, eventId, 0, 0, 0, 0, NULL, 0,
2092 response, payloadLength);
2093 EXPECT_EQ(rc, PLDM_SUCCESS);
2094
2095 PLDM_MSGBUF_DEFINE_P(buf);
2096 rc = pldm_msgbuf_init_errno(
2097 buf, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES,
2098 response->payload, payloadLength);
2099 ASSERT_EQ(rc, 0);
2100
2101 uint8_t retCompletionCode;
2102 uint8_t retTid = 0;
2103 uint16_t retEventId = 0;
2104
2105 pldm_msgbuf_extract_uint8(buf, retCompletionCode);
2106 pldm_msgbuf_extract_uint8(buf, retTid);
2107 pldm_msgbuf_extract_uint16(buf, retEventId);
2108 ASSERT_EQ(pldm_msgbuf_complete(buf), 0);
2109
2110 EXPECT_EQ(rc, PLDM_SUCCESS);
2111 EXPECT_EQ(retCompletionCode, completionCode);
2112 EXPECT_EQ(retTid, tId);
2113 EXPECT_EQ(retEventId, eventId);
2114 }
2115
TEST(PollForPlatformEventMessage,testGoodEncodeResposeP3)2116 TEST(PollForPlatformEventMessage, testGoodEncodeResposeP3)
2117 {
2118 uint8_t completionCode = PLDM_SUCCESS;
2119 uint8_t instance_id = 0;
2120 uint8_t tId = 0x9;
2121 uint16_t eventId = 0xffff;
2122 constexpr size_t payloadLength =
2123 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES;
2124
2125 std::array<uint8_t, hdrSize + payloadLength> responseMsg{};
2126 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2127 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
2128
2129 auto rc = encode_poll_for_platform_event_message_resp(
2130 instance_id, completionCode, tId, eventId, 0, 0, 0, 0, NULL, 0,
2131 response, payloadLength);
2132 EXPECT_EQ(rc, PLDM_SUCCESS);
2133
2134 PLDM_MSGBUF_DEFINE_P(buf);
2135 rc = pldm_msgbuf_init_errno(
2136 buf, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES,
2137 response->payload, payloadLength);
2138 ASSERT_EQ(rc, 0);
2139
2140 uint8_t retCompletionCode;
2141 uint8_t retTid = 0;
2142 uint16_t retEventId = 0;
2143
2144 pldm_msgbuf_extract_uint8(buf, retCompletionCode);
2145 pldm_msgbuf_extract_uint8(buf, retTid);
2146 pldm_msgbuf_extract_uint16(buf, retEventId);
2147 ASSERT_EQ(pldm_msgbuf_complete(buf), PLDM_SUCCESS);
2148
2149 EXPECT_EQ(rc, PLDM_SUCCESS);
2150 EXPECT_EQ(retCompletionCode, completionCode);
2151 EXPECT_EQ(retTid, tId);
2152 EXPECT_EQ(retEventId, eventId);
2153 }
2154
TEST(PollForPlatformEventMessage,testGoodEncodeResposeP4)2155 TEST(PollForPlatformEventMessage, testGoodEncodeResposeP4)
2156 {
2157 uint8_t completionCode = PLDM_SUCCESS;
2158 uint8_t instance_id = 0;
2159 uint8_t tId = 0x9;
2160 uint16_t eventId = 0x1;
2161 uint32_t nextDataTransferHandle = 0xffff;
2162 uint8_t transferFlag = PLDM_END;
2163 uint8_t eventClass = 0x5;
2164 constexpr uint32_t eventDataSize = 0;
2165 uint32_t eventDataIntegrityChecksum = 0x11223344;
2166 size_t payloadLength =
2167 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_RESP_BYTES + eventDataSize + 4;
2168
2169 std::array<uint8_t, hdrSize +
2170 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_RESP_BYTES +
2171 eventDataSize + 4>
2172 responseMsg{};
2173 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2174 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
2175
2176 auto rc = encode_poll_for_platform_event_message_resp(
2177 instance_id, completionCode, tId, eventId, nextDataTransferHandle,
2178 transferFlag, eventClass, eventDataSize, NULL,
2179 eventDataIntegrityChecksum, response, payloadLength);
2180 EXPECT_EQ(rc, PLDM_SUCCESS);
2181
2182 PLDM_MSGBUF_DEFINE_P(buf);
2183 rc = pldm_msgbuf_init_errno(
2184 buf, PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_MIN_RESP_BYTES,
2185 response->payload, payloadLength);
2186 ASSERT_EQ(rc, 0);
2187
2188 uint8_t retCompletionCode;
2189 uint8_t retTid = 0;
2190 uint16_t retEventId = 0;
2191 uint32_t retNextDataTransferHandle = 0;
2192 uint8_t retTransferFlag = 0;
2193 uint8_t retEventClass = 0;
2194 uint32_t retEventDataSize = 0;
2195 uint32_t retEventDataIntegrityChecksum = 0;
2196
2197 pldm_msgbuf_extract_uint8(buf, retCompletionCode);
2198 pldm_msgbuf_extract_uint8(buf, retTid);
2199 pldm_msgbuf_extract_uint16(buf, retEventId);
2200 pldm_msgbuf_extract_uint32(buf, retNextDataTransferHandle);
2201 pldm_msgbuf_extract_uint8(buf, retTransferFlag);
2202 pldm_msgbuf_extract_uint8(buf, retEventClass);
2203 pldm_msgbuf_extract_uint32(buf, retEventDataSize);
2204 pldm_msgbuf_extract_uint32(buf, retEventDataIntegrityChecksum);
2205 EXPECT_EQ(pldm_msgbuf_complete(buf), 0);
2206
2207 EXPECT_EQ(rc, PLDM_SUCCESS);
2208 EXPECT_EQ(retCompletionCode, completionCode);
2209 EXPECT_EQ(retTid, tId);
2210 EXPECT_EQ(retEventId, eventId);
2211 EXPECT_EQ(retNextDataTransferHandle, nextDataTransferHandle);
2212 EXPECT_EQ(retTransferFlag, transferFlag);
2213 EXPECT_EQ(retEventClass, eventClass);
2214 EXPECT_EQ(retEventDataSize, eventDataSize);
2215 EXPECT_EQ(retEventDataIntegrityChecksum, eventDataIntegrityChecksum);
2216 }
2217
TEST(PollForPlatformEventMessage,testBadEncodeResponse)2218 TEST(PollForPlatformEventMessage, testBadEncodeResponse)
2219 {
2220 uint8_t completionCode = PLDM_SUCCESS;
2221 uint8_t instance_id = 0;
2222 uint8_t tId = 0x9;
2223 uint16_t eventId = 0x1;
2224 uint32_t nextDataTransferHandle = 0xffff;
2225 uint8_t transferFlag = 0x0;
2226 uint8_t eventClass = 0x5;
2227 const uint32_t eventDataSize = 0;
2228 uint32_t eventDataIntegrityChecksum = 0x11223344;
2229 constexpr size_t payloadLength =
2230 PLDM_POLL_FOR_PLATFORM_EVENT_MESSAGE_RESP_BYTES + eventDataSize + 4;
2231
2232 std::array<uint8_t, hdrSize + payloadLength> responseMsg{};
2233 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2234 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
2235
2236 auto rc = encode_poll_for_platform_event_message_resp(
2237 instance_id, completionCode, tId, eventId, nextDataTransferHandle,
2238 transferFlag, eventClass, eventDataSize, NULL,
2239 eventDataIntegrityChecksum, NULL, payloadLength);
2240
2241 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2242
2243 rc = encode_poll_for_platform_event_message_resp(
2244 instance_id, completionCode, tId, eventId, nextDataTransferHandle,
2245 transferFlag, eventClass, 1, NULL, eventDataIntegrityChecksum, response,
2246 payloadLength);
2247 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2248 }
2249
TEST(PlatformEventMessage,testGoodStateSensorDecodeRequest)2250 TEST(PlatformEventMessage, testGoodStateSensorDecodeRequest)
2251 {
2252 std::array<uint8_t,
2253 hdrSize + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
2254 PLDM_PLATFORM_EVENT_MESSAGE_STATE_SENSOR_STATE_REQ_BYTES>
2255 requestMsg{};
2256
2257 uint8_t retFormatVersion = 0;
2258 uint8_t retTid = 0;
2259 uint8_t retEventClass = 0;
2260 size_t retEventDataOffset = 0;
2261
2262 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2263 auto req = reinterpret_cast<pldm_msg*>(requestMsg.data());
2264 struct pldm_platform_event_message_req* request =
2265 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2266 reinterpret_cast<struct pldm_platform_event_message_req*>(req->payload);
2267
2268 uint8_t formatVersion = 0x01;
2269 uint8_t tid = 0x02;
2270 // Sensor Event
2271 uint8_t eventClass = 0x00;
2272
2273 request->format_version = formatVersion;
2274 request->tid = tid;
2275 request->event_class = eventClass;
2276 size_t eventDataOffset =
2277 sizeof(formatVersion) + sizeof(tid) + sizeof(eventClass);
2278
2279 auto rc = decode_platform_event_message_req(
2280 req, requestMsg.size() - hdrSize, &retFormatVersion, &retTid,
2281 &retEventClass, &retEventDataOffset);
2282
2283 EXPECT_EQ(rc, PLDM_SUCCESS);
2284 EXPECT_EQ(retFormatVersion, formatVersion);
2285 EXPECT_EQ(retTid, tid);
2286 EXPECT_EQ(retEventClass, eventClass);
2287 EXPECT_EQ(retEventDataOffset, eventDataOffset);
2288 }
2289
TEST(PlatformEventMessage,testBadDecodeRequest)2290 TEST(PlatformEventMessage, testBadDecodeRequest)
2291 {
2292 const struct pldm_msg* msg = NULL;
2293 std::array<uint8_t,
2294 hdrSize + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
2295 PLDM_PLATFORM_EVENT_MESSAGE_STATE_SENSOR_STATE_REQ_BYTES - 1>
2296 requestMsg{};
2297 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2298 auto req = reinterpret_cast<pldm_msg*>(requestMsg.data());
2299 uint8_t retFormatVersion;
2300 uint8_t retTid = 0;
2301 uint8_t retEventClass = 0;
2302 size_t retEventDataOffset;
2303
2304 auto rc = decode_platform_event_message_req(msg, sizeof(*msg), NULL, NULL,
2305 NULL, NULL);
2306 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2307
2308 rc = decode_platform_event_message_req(
2309 req,
2310 requestMsg.size() - hdrSize -
2311 PLDM_PLATFORM_EVENT_MESSAGE_STATE_SENSOR_STATE_REQ_BYTES,
2312 &retFormatVersion, &retTid, &retEventClass, &retEventDataOffset);
2313 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
2314 }
2315
TEST(PlatformEventMessage,testGoodEncodeResponse)2316 TEST(PlatformEventMessage, testGoodEncodeResponse)
2317 {
2318 std::array<uint8_t,
2319 hdrSize + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
2320 PLDM_PLATFORM_EVENT_MESSAGE_STATE_SENSOR_STATE_REQ_BYTES - 1>
2321 responseMsg{};
2322 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2323 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
2324 uint8_t completionCode = 0;
2325 uint8_t instanceId = 0x01;
2326 uint8_t platformEventStatus = 0x01;
2327
2328 auto rc = encode_platform_event_message_resp(instanceId, PLDM_SUCCESS,
2329 platformEventStatus, response);
2330
2331 EXPECT_EQ(rc, PLDM_SUCCESS);
2332 EXPECT_EQ(completionCode, response->payload[0]);
2333 EXPECT_EQ(platformEventStatus, response->payload[1]);
2334 }
2335
TEST(PlatformEventMessage,testBadEncodeResponse)2336 TEST(PlatformEventMessage, testBadEncodeResponse)
2337 {
2338 auto rc = encode_platform_event_message_resp(0, PLDM_SUCCESS, 1, NULL);
2339 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2340 }
2341
TEST(PlatformEventMessage,testGoodEncodeRequest)2342 TEST(PlatformEventMessage, testGoodEncodeRequest)
2343 {
2344 static constexpr const uint8_t formatVersion = 0x01;
2345 static constexpr const uint8_t eventClass = 0x00;
2346 static constexpr const uint8_t eventData = 34;
2347 static constexpr const uint8_t Tid = 0x03;
2348 struct pldm_platform_event_message_req req;
2349 PLDM_MSGBUF_DEFINE_P(buf);
2350 size_t len;
2351 void* data;
2352
2353 PLDM_MSG_DEFINE_P(request, PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
2354 sizeof(eventData));
2355
2356 /* Test with the minimum event type value */
2357 auto rc = encode_platform_event_message_req(
2358 0, formatVersion, Tid, eventClass, &eventData, sizeof(eventData),
2359 request, sizeof(eventData) + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES);
2360 ASSERT_EQ(rc, PLDM_SUCCESS);
2361
2362 rc = pldm_msgbuf_init_errno(
2363 buf, PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES, request->payload,
2364 PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES + sizeof(eventData));
2365 ASSERT_EQ(rc, 0);
2366
2367 pldm_msgbuf_extract_uint8(buf, req.format_version);
2368 pldm_msgbuf_extract_uint8(buf, req.tid);
2369 pldm_msgbuf_extract_uint8(buf, req.event_class);
2370 data = nullptr;
2371 pldm_msgbuf_span_remaining(buf, &data, &len);
2372 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
2373
2374 EXPECT_EQ(formatVersion, req.format_version);
2375 EXPECT_EQ(Tid, req.tid);
2376 EXPECT_EQ(eventClass, req.event_class);
2377 ASSERT_EQ(sizeof(eventData), len);
2378 EXPECT_EQ(0, memcmp(&eventData, data, len));
2379
2380 /* Test with the maximum event type value */
2381 rc = encode_platform_event_message_req(
2382 0, formatVersion, Tid, PLDM_CPER_EVENT, &eventData, sizeof(eventData),
2383 request, sizeof(eventData) + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES);
2384 ASSERT_EQ(rc, PLDM_SUCCESS);
2385
2386 rc = pldm_msgbuf_init_errno(
2387 buf, PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES, request->payload,
2388 PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES + sizeof(eventData));
2389 ASSERT_EQ(rc, 0);
2390
2391 pldm_msgbuf_extract_uint8(buf, req.format_version);
2392 pldm_msgbuf_extract_uint8(buf, req.tid);
2393 pldm_msgbuf_extract_uint8(buf, req.event_class);
2394
2395 data = nullptr;
2396 pldm_msgbuf_span_remaining(buf, &data, &len);
2397 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0);
2398
2399 EXPECT_EQ(formatVersion, req.format_version);
2400 EXPECT_EQ(Tid, req.tid);
2401 EXPECT_EQ(PLDM_CPER_EVENT, req.event_class);
2402 ASSERT_EQ(sizeof(eventData), len);
2403 EXPECT_EQ(0, memcmp(&eventData, data, len));
2404 }
2405
TEST(PlatformEventMessage,testBadEncodeRequest)2406 TEST(PlatformEventMessage, testBadEncodeRequest)
2407 {
2408 uint8_t Tid = 0x03;
2409 uint8_t eventClass = 0x00;
2410 uint8_t eventData = 34;
2411 uint8_t formatVersion = 0x01;
2412 static constexpr const size_t payloadLen =
2413 PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES + sizeof(eventData);
2414
2415 PLDM_MSG_DEFINE_P(request, payloadLen);
2416
2417 auto rc = encode_platform_event_message_req(
2418 0, formatVersion, Tid, eventClass, &eventData, sizeof(eventData),
2419 nullptr, payloadLen);
2420 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2421
2422 rc = encode_platform_event_message_req(0, 0, Tid, eventClass, &eventData,
2423 sizeof(eventData), request,
2424 payloadLen);
2425 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2426
2427 rc = encode_platform_event_message_req(0, formatVersion, Tid, eventClass,
2428 nullptr, 0, request, payloadLen);
2429 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2430
2431 rc = encode_platform_event_message_req(0, formatVersion, Tid, eventClass,
2432 &eventData, sizeof(eventData),
2433 request, 0);
2434 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
2435
2436 rc = encode_platform_event_message_req(
2437 0, formatVersion, Tid, PLDM_CPER_EVENT + 1, &eventData,
2438 sizeof(eventData), request, payloadLen);
2439 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2440 }
2441
TEST(PlatformEventMessage,testGoodDecodeResponse)2442 TEST(PlatformEventMessage, testGoodDecodeResponse)
2443 {
2444 std::array<uint8_t, hdrSize + PLDM_PLATFORM_EVENT_MESSAGE_RESP_BYTES>
2445 responseMsg{};
2446
2447 uint8_t completionCode = PLDM_SUCCESS;
2448 uint8_t platformEventStatus = 0x01;
2449
2450 uint8_t retcompletionCode;
2451 uint8_t retplatformEventStatus;
2452
2453 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2454 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
2455 struct pldm_platform_event_message_resp* resp =
2456 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2457 reinterpret_cast<struct pldm_platform_event_message_resp*>(
2458 response->payload);
2459
2460 resp->completion_code = completionCode;
2461 resp->platform_event_status = platformEventStatus;
2462
2463 auto rc = decode_platform_event_message_resp(
2464 response, responseMsg.size() - hdrSize, &retcompletionCode,
2465 &retplatformEventStatus);
2466
2467 EXPECT_EQ(rc, PLDM_SUCCESS);
2468 EXPECT_EQ(completionCode, retcompletionCode);
2469 EXPECT_EQ(platformEventStatus, retplatformEventStatus);
2470 }
2471
TEST(PlatformEventMessage,testBadDecodeResponse)2472 TEST(PlatformEventMessage, testBadDecodeResponse)
2473 {
2474 std::array<uint8_t, hdrSize + PLDM_PLATFORM_EVENT_MESSAGE_RESP_BYTES>
2475 responseMsg{};
2476
2477 uint8_t completionCode = PLDM_SUCCESS;
2478 uint8_t platformEventStatus = 0x01;
2479
2480 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2481 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
2482 struct pldm_platform_event_message_resp* resp =
2483 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2484 reinterpret_cast<struct pldm_platform_event_message_resp*>(
2485 response->payload);
2486 resp->completion_code = completionCode;
2487 resp->platform_event_status = platformEventStatus;
2488
2489 auto rc = decode_platform_event_message_resp(
2490 nullptr, responseMsg.size() - hdrSize, nullptr, nullptr);
2491
2492 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2493
2494 rc = decode_platform_event_message_resp(
2495 response, responseMsg.size() - hdrSize - 1, &completionCode,
2496 &platformEventStatus);
2497
2498 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
2499 }
2500
TEST(PlatformEventMessage,testGoodSensorEventDataDecodeRequest)2501 TEST(PlatformEventMessage, testGoodSensorEventDataDecodeRequest)
2502 {
2503 std::array<uint8_t, PLDM_SENSOR_EVENT_SENSOR_OP_STATE_DATA_LENGTH +
2504 PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES>
2505 eventDataArr{};
2506 uint16_t sensorId = 0x1234;
2507 uint8_t sensorEventClassType = PLDM_SENSOR_OP_STATE;
2508
2509 struct pldm_sensor_event_data* eventData =
2510 (struct pldm_sensor_event_data*)eventDataArr.data();
2511 eventData->sensor_id = sensorId;
2512 eventData->sensor_event_class_type = sensorEventClassType;
2513
2514 size_t retSensorOpDataOffset;
2515 uint16_t retSensorId = 0;
2516 uint8_t retSensorEventClassType;
2517 size_t sensorOpDataOffset = sizeof(sensorId) + sizeof(sensorEventClassType);
2518 auto rc = decode_sensor_event_data(
2519 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2520 reinterpret_cast<uint8_t*>(eventData), eventDataArr.size(),
2521 &retSensorId, &retSensorEventClassType, &retSensorOpDataOffset);
2522 EXPECT_EQ(rc, PLDM_SUCCESS);
2523 EXPECT_EQ(retSensorId, sensorId);
2524 EXPECT_EQ(retSensorEventClassType, sensorEventClassType);
2525 EXPECT_EQ(retSensorOpDataOffset, sensorOpDataOffset);
2526 }
2527
TEST(PlatformEventMessage,testBadSensorEventDataDecodeRequest)2528 TEST(PlatformEventMessage, testBadSensorEventDataDecodeRequest)
2529 {
2530
2531 std::array<uint8_t, PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_MAX_DATA_LENGTH +
2532 PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES>
2533 eventDataArr{};
2534
2535 struct pldm_sensor_event_data* eventData =
2536 (struct pldm_sensor_event_data*)eventDataArr.data();
2537
2538 size_t retSensorOpDataOffset;
2539 uint16_t retSensorId = 0;
2540 uint8_t retSensorEventClassType;
2541 auto rc = decode_sensor_event_data(NULL, eventDataArr.size(), &retSensorId,
2542 &retSensorEventClassType,
2543 &retSensorOpDataOffset);
2544 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2545
2546 rc = decode_sensor_event_data(
2547 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2548 reinterpret_cast<uint8_t*>(eventDataArr.data()),
2549 eventDataArr.size() -
2550 PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_MAX_DATA_LENGTH,
2551 &retSensorId, &retSensorEventClassType, &retSensorOpDataOffset);
2552 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
2553
2554 eventData->sensor_event_class_type = PLDM_SENSOR_OP_STATE;
2555
2556 rc = decode_sensor_event_data(
2557 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2558 reinterpret_cast<uint8_t*>(eventDataArr.data()), eventDataArr.size(),
2559 &retSensorId, &retSensorEventClassType, &retSensorOpDataOffset);
2560 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
2561
2562 eventData->sensor_event_class_type = PLDM_STATE_SENSOR_STATE;
2563 rc = decode_sensor_event_data(
2564 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2565 reinterpret_cast<uint8_t*>(eventDataArr.data()), eventDataArr.size(),
2566 &retSensorId, &retSensorEventClassType, &retSensorOpDataOffset);
2567 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
2568
2569 eventData->sensor_event_class_type = PLDM_NUMERIC_SENSOR_STATE;
2570 rc = decode_sensor_event_data(
2571 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2572 reinterpret_cast<uint8_t*>(eventDataArr.data()),
2573 eventDataArr.size() + 1, &retSensorId, &retSensorEventClassType,
2574 &retSensorOpDataOffset);
2575 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
2576 }
2577
TEST(PlatformEventMessage,testGoodPldmMsgPollEventDataDecodeRequest)2578 TEST(PlatformEventMessage, testGoodPldmMsgPollEventDataDecodeRequest)
2579 {
2580 std::array<uint8_t, PLDM_PLATFORM_EVENT_MESSAGE_FORMAT_VERSION +
2581 PLDM_PLATFORM_EVENT_MESSAGE_EVENT_ID +
2582 PLDM_PLATFORM_EVENT_MESSAGE_TRANFER_HANDLE>
2583 eventData{
2584 0x1, // version
2585 0x88, 0x77, // Event Id
2586 0x44, 0x33, 0x22, 0x11 // Transfer Handle
2587 };
2588
2589 uint8_t formatVersion = 0x01;
2590 uint16_t eventID = 0x7788;
2591 uint32_t dataTransferHandle = 0x11223344;
2592
2593 struct pldm_message_poll_event poll_event = {};
2594
2595 auto rc = decode_pldm_message_poll_event_data(
2596 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2597 reinterpret_cast<uint8_t*>(eventData.data()), eventData.size(),
2598 &poll_event);
2599
2600 EXPECT_EQ(rc, PLDM_SUCCESS);
2601 EXPECT_EQ(poll_event.format_version, formatVersion);
2602 EXPECT_EQ(poll_event.event_id, eventID);
2603 EXPECT_EQ(poll_event.data_transfer_handle, dataTransferHandle);
2604 }
2605
TEST(PlatformEventMessage,testBadPldmMsgPollEventDataDecodeRequest)2606 TEST(PlatformEventMessage, testBadPldmMsgPollEventDataDecodeRequest)
2607 {
2608
2609 std::array<uint8_t, PLDM_PLATFORM_EVENT_MESSAGE_FORMAT_VERSION +
2610 PLDM_PLATFORM_EVENT_MESSAGE_EVENT_ID +
2611 PLDM_PLATFORM_EVENT_MESSAGE_TRANFER_HANDLE>
2612 eventData{
2613 0x1, // version
2614 0x88, 0x77, // Event Id
2615 0x44, 0x33, 0x22, 0x11 // Transfer Handle
2616 };
2617
2618 struct pldm_message_poll_event poll_event = {};
2619
2620 auto rc = decode_pldm_message_poll_event_data(NULL, eventData.size(),
2621 &poll_event);
2622 EXPECT_EQ(rc, -EINVAL);
2623
2624 rc = decode_pldm_message_poll_event_data(
2625 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2626 reinterpret_cast<uint8_t*>(eventData.data()), eventData.size(), NULL);
2627 EXPECT_EQ(rc, -EINVAL);
2628
2629 rc = decode_pldm_message_poll_event_data(
2630 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2631 reinterpret_cast<uint8_t*>(eventData.data()), eventData.size() - 1,
2632 &poll_event);
2633 EXPECT_EQ(rc, -EOVERFLOW);
2634
2635 // Event id is 0x0000
2636 eventData[1] = 0x00;
2637 eventData[2] = 0x00;
2638 rc = decode_pldm_message_poll_event_data(
2639 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2640 reinterpret_cast<uint8_t*>(eventData.data()), eventData.size(),
2641 &poll_event);
2642
2643 EXPECT_EQ(rc, -EPROTO);
2644
2645 // Event id is 0xffff
2646 eventData[1] = 0xff;
2647 eventData[2] = 0xff;
2648 rc = decode_pldm_message_poll_event_data(
2649 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2650 reinterpret_cast<uint8_t*>(eventData.data()), eventData.size(),
2651 &poll_event);
2652
2653 EXPECT_EQ(rc, -EPROTO);
2654 }
2655
2656 #ifdef LIBPLDM_API_TESTING
TEST(PlatformEventMessage,testGoodPldmMsgPollEventDataEncode)2657 TEST(PlatformEventMessage, testGoodPldmMsgPollEventDataEncode)
2658 {
2659 std::array<uint8_t, PLDM_PLATFORM_EVENT_MESSAGE_FORMAT_VERSION +
2660 PLDM_PLATFORM_EVENT_MESSAGE_EVENT_ID +
2661 PLDM_PLATFORM_EVENT_MESSAGE_TRANFER_HANDLE>
2662 eventData{};
2663
2664 struct pldm_message_poll_event poll_event = {};
2665 poll_event.format_version = 0x01;
2666 poll_event.event_id = 0x7788;
2667 poll_event.data_transfer_handle = 0x11223344;
2668
2669 int rc = encode_pldm_message_poll_event_data(
2670 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2671 &poll_event, reinterpret_cast<uint8_t*>(eventData.data()),
2672 eventData.size());
2673
2674 EXPECT_EQ(rc, PLDM_SUCCESS);
2675
2676 PLDM_MSGBUF_DEFINE_P(buf);
2677
2678 rc = pldm_msgbuf_init_errno(
2679 buf, PLDM_MSG_POLL_EVENT_LENGTH,
2680 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2681 reinterpret_cast<uint8_t*>(eventData.data()), eventData.size());
2682 ASSERT_EQ(rc, 0);
2683
2684 uint8_t retFormatVersion;
2685 uint16_t reteventID;
2686 uint32_t retDataTransferHandle;
2687
2688 pldm_msgbuf_extract_uint8(buf, retFormatVersion);
2689 pldm_msgbuf_extract_uint16(buf, reteventID);
2690 pldm_msgbuf_extract_uint32(buf, retDataTransferHandle);
2691 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), PLDM_SUCCESS);
2692
2693 EXPECT_EQ(retFormatVersion, poll_event.format_version);
2694 EXPECT_EQ(reteventID, poll_event.event_id);
2695 EXPECT_EQ(retDataTransferHandle, poll_event.data_transfer_handle);
2696 }
2697 #endif
2698
2699 #ifdef LIBPLDM_API_TESTING
TEST(PlatformEventMessage,testBadPldmMsgPollEventDataEncode)2700 TEST(PlatformEventMessage, testBadPldmMsgPollEventDataEncode)
2701 {
2702 std::array<uint8_t, PLDM_PLATFORM_EVENT_MESSAGE_FORMAT_VERSION +
2703 PLDM_PLATFORM_EVENT_MESSAGE_EVENT_ID +
2704 PLDM_PLATFORM_EVENT_MESSAGE_TRANFER_HANDLE>
2705 eventData{};
2706
2707 struct pldm_message_poll_event poll_event = {};
2708 poll_event.format_version = 0x01;
2709 poll_event.event_id = 0x7788;
2710 poll_event.data_transfer_handle = 0x11223344;
2711
2712 int rc = encode_pldm_message_poll_event_data(&poll_event, NULL,
2713 eventData.size());
2714 EXPECT_EQ(rc, -EINVAL);
2715
2716 poll_event.event_id = 0x0000;
2717 rc = encode_pldm_message_poll_event_data(
2718 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2719 &poll_event, reinterpret_cast<uint8_t*>(eventData.data()),
2720 eventData.size());
2721 EXPECT_EQ(rc, -EPROTO);
2722
2723 poll_event.event_id = 0xffff;
2724 rc = encode_pldm_message_poll_event_data(
2725 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2726 &poll_event, reinterpret_cast<uint8_t*>(eventData.data()),
2727 eventData.size());
2728 EXPECT_EQ(rc, -EPROTO);
2729 }
2730 #endif
2731
TEST(PlatformEventMessage,testGoodSensorOpEventDataDecodeRequest)2732 TEST(PlatformEventMessage, testGoodSensorOpEventDataDecodeRequest)
2733 {
2734 std::array<uint8_t, PLDM_SENSOR_EVENT_SENSOR_OP_STATE_DATA_LENGTH>
2735 eventDataArr{};
2736
2737 struct pldm_sensor_event_sensor_op_state* sensorData =
2738 (struct pldm_sensor_event_sensor_op_state*)eventDataArr.data();
2739 uint8_t presentState = PLDM_SENSOR_ENABLED;
2740 uint8_t previousState = PLDM_SENSOR_INITIALIZING;
2741 sensorData->present_op_state = presentState;
2742 sensorData->previous_op_state = previousState;
2743
2744 uint8_t retPresentState;
2745 uint8_t retPreviousState;
2746 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2747 auto rc = decode_sensor_op_data(reinterpret_cast<uint8_t*>(sensorData),
2748 eventDataArr.size(), &retPresentState,
2749 &retPreviousState);
2750 EXPECT_EQ(rc, PLDM_SUCCESS);
2751 EXPECT_EQ(retPresentState, presentState);
2752 EXPECT_EQ(retPreviousState, previousState);
2753 }
2754
TEST(PlatformEventMessage,testBadSensorOpEventDataDecodeRequest)2755 TEST(PlatformEventMessage, testBadSensorOpEventDataDecodeRequest)
2756 {
2757 uint8_t presentOpState;
2758 uint8_t previousOpState;
2759 size_t sensorDataLength = PLDM_SENSOR_EVENT_SENSOR_OP_STATE_DATA_LENGTH;
2760 auto rc = decode_sensor_op_data(NULL, sensorDataLength, &presentOpState,
2761 &previousOpState);
2762 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2763
2764 std::array<uint8_t, PLDM_SENSOR_EVENT_SENSOR_OP_STATE_DATA_LENGTH>
2765 sensorData{};
2766 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2767 rc = decode_sensor_op_data(reinterpret_cast<uint8_t*>(sensorData.data()),
2768 sensorDataLength + 1, &presentOpState,
2769 &previousOpState);
2770 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2771
2772 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2773 rc = decode_sensor_op_data(reinterpret_cast<uint8_t*>(sensorData.data()),
2774 sensorDataLength, nullptr, &previousOpState);
2775 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2776 }
2777
TEST(PlatformEventMessage,testGoodSensorStateEventDataDecodeRequest)2778 TEST(PlatformEventMessage, testGoodSensorStateEventDataDecodeRequest)
2779 {
2780 std::array<uint8_t, PLDM_SENSOR_EVENT_STATE_SENSOR_STATE_DATA_LENGTH>
2781 eventDataArr{};
2782
2783 struct pldm_sensor_event_state_sensor_state* sensorData =
2784 (struct pldm_sensor_event_state_sensor_state*)eventDataArr.data();
2785 uint8_t sensorOffset = 0x02;
2786 uint8_t eventState = PLDM_SENSOR_SHUTTINGDOWN;
2787 uint8_t previousEventState = PLDM_SENSOR_INTEST;
2788 sensorData->sensor_offset = sensorOffset;
2789 sensorData->event_state = eventState;
2790 sensorData->previous_event_state = previousEventState;
2791
2792 uint8_t retSensorOffset;
2793 uint8_t retEventState;
2794 uint8_t retPreviousState;
2795 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2796 auto rc = decode_state_sensor_data(reinterpret_cast<uint8_t*>(sensorData),
2797 eventDataArr.size(), &retSensorOffset,
2798 &retEventState, &retPreviousState);
2799 EXPECT_EQ(rc, PLDM_SUCCESS);
2800 EXPECT_EQ(retSensorOffset, sensorOffset);
2801 EXPECT_EQ(retEventState, eventState);
2802 EXPECT_EQ(retPreviousState, previousEventState);
2803 }
2804
TEST(PlatformEventMessage,testBadStateSensorEventDataDecodeRequest)2805 TEST(PlatformEventMessage, testBadStateSensorEventDataDecodeRequest)
2806 {
2807 uint8_t sensorOffset;
2808 uint8_t eventState;
2809 uint8_t previousEventState;
2810 size_t sensorDataLength = PLDM_SENSOR_EVENT_STATE_SENSOR_STATE_DATA_LENGTH;
2811 auto rc = decode_state_sensor_data(NULL, sensorDataLength, &sensorOffset,
2812 &eventState, &previousEventState);
2813 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2814
2815 std::array<uint8_t, PLDM_SENSOR_EVENT_STATE_SENSOR_STATE_DATA_LENGTH>
2816 sensorData{};
2817 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2818 rc = decode_state_sensor_data(reinterpret_cast<uint8_t*>(sensorData.data()),
2819 sensorDataLength - 1, &sensorOffset,
2820 &eventState, &previousEventState);
2821 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
2822
2823 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2824 rc = decode_state_sensor_data(reinterpret_cast<uint8_t*>(sensorData.data()),
2825 sensorDataLength, &sensorOffset, nullptr,
2826 &previousEventState);
2827 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2828 }
2829
TEST(PlatformEventMessage,testGoodNumericSensorEventDataDecodeRequest)2830 TEST(PlatformEventMessage, testGoodNumericSensorEventDataDecodeRequest)
2831 {
2832 std::array<uint8_t, PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_MAX_DATA_LENGTH>
2833 eventDataArr{};
2834 struct pldm_sensor_event_numeric_sensor_state* sensorData =
2835 (struct pldm_sensor_event_numeric_sensor_state*)eventDataArr.data();
2836
2837 size_t sensorDataLength =
2838 PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_32BIT_DATA_LENGTH;
2839 uint8_t eventState = PLDM_SENSOR_SHUTTINGDOWN;
2840 uint8_t previousEventState = PLDM_SENSOR_INTEST;
2841 uint8_t sensorDataSize = PLDM_SENSOR_DATA_SIZE_UINT32;
2842 uint32_t presentReading = 305441741;
2843 sensorData->event_state = eventState;
2844 sensorData->previous_event_state = previousEventState;
2845 sensorData->sensor_data_size = sensorDataSize;
2846 {
2847 uint32_t presentReadingLE = htole32(presentReading);
2848 memcpy(&sensorData->present_reading, &presentReadingLE,
2849 sizeof(presentReadingLE));
2850 }
2851
2852 uint8_t retEventState;
2853 uint8_t retPreviousEventState;
2854 uint8_t retSensorDataSize;
2855 uint32_t retPresentReading;
2856
2857 auto rc = decode_numeric_sensor_data(
2858 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2859 reinterpret_cast<uint8_t*>(sensorData), sensorDataLength,
2860 &retEventState, &retPreviousEventState, &retSensorDataSize,
2861 &retPresentReading);
2862 EXPECT_EQ(rc, PLDM_SUCCESS);
2863 EXPECT_EQ(retEventState, eventState);
2864 EXPECT_EQ(retPreviousEventState, previousEventState);
2865 EXPECT_EQ(retSensorDataSize, sensorDataSize);
2866 EXPECT_EQ(retPresentReading, presentReading);
2867
2868 int16_t presentReadingNew = -31432;
2869 {
2870 int16_t presentReadingNewLE = htole16(presentReadingNew);
2871 memcpy(&sensorData->present_reading, &presentReadingNewLE,
2872 sizeof(presentReadingNewLE));
2873 }
2874 sensorDataSize = PLDM_SENSOR_DATA_SIZE_SINT16;
2875 sensorData->sensor_data_size = sensorDataSize;
2876 sensorDataLength = PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_16BIT_DATA_LENGTH;
2877
2878 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2879 rc = decode_numeric_sensor_data(reinterpret_cast<uint8_t*>(sensorData),
2880 sensorDataLength, &retEventState,
2881 &retPreviousEventState, &retSensorDataSize,
2882 &retPresentReading);
2883 EXPECT_EQ(rc, PLDM_SUCCESS);
2884 EXPECT_EQ(retEventState, eventState);
2885 EXPECT_EQ(retPreviousEventState, previousEventState);
2886 EXPECT_EQ(retSensorDataSize, sensorDataSize);
2887 EXPECT_EQ(static_cast<int16_t>(retPresentReading), presentReadingNew);
2888 }
2889
TEST(PlatformEventMessage,testBadNumericSensorEventDataDecodeRequest)2890 TEST(PlatformEventMessage, testBadNumericSensorEventDataDecodeRequest)
2891 {
2892 uint8_t eventState;
2893 uint8_t previousEventState;
2894 uint8_t sensorDataSize;
2895 uint32_t presentReading;
2896 size_t sensorDataLength =
2897 PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_MAX_DATA_LENGTH;
2898 auto rc = decode_numeric_sensor_data(NULL, sensorDataLength, &eventState,
2899 &previousEventState, &sensorDataSize,
2900 &presentReading);
2901 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2902
2903 std::array<uint8_t, PLDM_SENSOR_EVENT_NUMERIC_SENSOR_STATE_MAX_DATA_LENGTH>
2904 sensorData{};
2905 rc = decode_numeric_sensor_data(
2906 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2907 reinterpret_cast<uint8_t*>(sensorData.data()), sensorDataLength - 1,
2908 &eventState, &previousEventState, &sensorDataSize, &presentReading);
2909 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2910
2911 struct pldm_sensor_event_numeric_sensor_state* numericSensorData =
2912 (struct pldm_sensor_event_numeric_sensor_state*)sensorData.data();
2913 numericSensorData->sensor_data_size = PLDM_SENSOR_DATA_SIZE_UINT8;
2914 rc = decode_numeric_sensor_data(
2915 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2916 reinterpret_cast<uint8_t*>(sensorData.data()), sensorDataLength,
2917 &eventState, &previousEventState, &sensorDataSize, &presentReading);
2918 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2919
2920 numericSensorData->sensor_data_size = PLDM_SENSOR_DATA_SIZE_UINT16;
2921 rc = decode_numeric_sensor_data(
2922 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2923 reinterpret_cast<uint8_t*>(sensorData.data()), sensorDataLength,
2924 &eventState, &previousEventState, &sensorDataSize, &presentReading);
2925 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2926 }
2927
TEST(GetNumericEffecterValue,testGoodEncodeRequest)2928 TEST(GetNumericEffecterValue, testGoodEncodeRequest)
2929 {
2930 std::vector<uint8_t> requestMsg(hdrSize +
2931 PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES);
2932
2933 uint16_t effecter_id = 0xab01;
2934
2935 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2936 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
2937
2938 auto rc = encode_get_numeric_effecter_value_req(0, effecter_id, request);
2939
2940 struct pldm_get_numeric_effecter_value_req* req =
2941 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2942 reinterpret_cast<struct pldm_get_numeric_effecter_value_req*>(
2943 request->payload);
2944
2945 EXPECT_EQ(rc, PLDM_SUCCESS);
2946 EXPECT_EQ(effecter_id, le16toh(req->effecter_id));
2947 }
2948
TEST(GetNumericEffecterValue,testBadEncodeRequest)2949 TEST(GetNumericEffecterValue, testBadEncodeRequest)
2950 {
2951 std::vector<uint8_t> requestMsg(
2952 hdrSize + PLDM_SET_NUMERIC_EFFECTER_VALUE_MIN_REQ_BYTES);
2953
2954 auto rc = encode_get_numeric_effecter_value_req(0, 0, nullptr);
2955 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2956 }
2957
TEST(GetNumericEffecterValue,testGoodDecodeRequest)2958 TEST(GetNumericEffecterValue, testGoodDecodeRequest)
2959 {
2960 std::array<uint8_t, hdrSize + PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES>
2961 requestMsg{};
2962
2963 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2964 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
2965 struct pldm_get_numeric_effecter_value_req* req =
2966 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2967 reinterpret_cast<struct pldm_get_numeric_effecter_value_req*>(
2968 request->payload);
2969
2970 uint16_t effecter_id = 0x12ab;
2971 req->effecter_id = htole16(effecter_id);
2972
2973 uint16_t reteffecter_id;
2974
2975 auto rc = decode_get_numeric_effecter_value_req(
2976 request, requestMsg.size() - hdrSize, &reteffecter_id);
2977
2978 EXPECT_EQ(rc, PLDM_SUCCESS);
2979 EXPECT_EQ(effecter_id, reteffecter_id);
2980 }
2981
TEST(GetNumericEffecterValue,testBadDecodeRequest)2982 TEST(GetNumericEffecterValue, testBadDecodeRequest)
2983 {
2984 std::array<uint8_t, hdrSize + PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES>
2985 requestMsg{};
2986
2987 auto rc = decode_get_numeric_effecter_value_req(
2988 nullptr, requestMsg.size() - hdrSize, nullptr);
2989
2990 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
2991
2992 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2993 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
2994 struct pldm_set_numeric_effecter_value_req* req =
2995 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
2996 reinterpret_cast<struct pldm_set_numeric_effecter_value_req*>(
2997 request->payload);
2998
2999 uint16_t effecter_id = 0x1a;
3000 req->effecter_id = htole16(effecter_id);
3001 uint16_t reteffecter_id;
3002
3003 rc = decode_get_numeric_effecter_value_req(
3004 request, requestMsg.size() - hdrSize - 1, &reteffecter_id);
3005
3006 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
3007 }
3008
TEST(GetNumericEffecterValue,testGoodEncodeResponse)3009 TEST(GetNumericEffecterValue, testGoodEncodeResponse)
3010 {
3011 uint8_t completionCode = 0;
3012 uint8_t effecter_dataSize = PLDM_EFFECTER_DATA_SIZE_UINT32;
3013 uint8_t effecter_operState = EFFECTER_OPER_STATE_ENABLED_NOUPDATEPENDING;
3014 uint32_t pendingValue = 0x12345678;
3015 uint32_t presentValue = 0xabcdef11;
3016 uint32_t val_pending;
3017 uint32_t val_present;
3018
3019 std::array<uint8_t,
3020 hdrSize + PLDM_GET_NUMERIC_EFFECTER_VALUE_MIN_RESP_BYTES + 6>
3021 responseMsg{};
3022 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3023 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
3024
3025 auto rc = encode_get_numeric_effecter_value_resp(
3026 0, completionCode, effecter_dataSize, effecter_operState,
3027 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3028 reinterpret_cast<uint8_t*>(&pendingValue),
3029 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3030 reinterpret_cast<uint8_t*>(&presentValue), response,
3031 responseMsg.size() - hdrSize);
3032
3033 struct pldm_get_numeric_effecter_value_resp* resp =
3034 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3035 reinterpret_cast<struct pldm_get_numeric_effecter_value_resp*>(
3036 response->payload);
3037
3038 memcpy(&val_pending, &resp->pending_and_present_values[0],
3039 sizeof(val_pending));
3040 val_pending = le32toh(val_pending);
3041 memcpy(&val_present, &resp->pending_and_present_values[4],
3042 sizeof(val_present));
3043 val_present = le32toh(val_present);
3044
3045 EXPECT_EQ(rc, PLDM_SUCCESS);
3046 EXPECT_EQ(effecter_dataSize, resp->effecter_data_size);
3047 EXPECT_EQ(effecter_operState, resp->effecter_oper_state);
3048 EXPECT_EQ(pendingValue, val_pending);
3049 EXPECT_EQ(presentValue, val_present);
3050 }
3051
TEST(GetNumericEffecterValue,testBadEncodeResponse)3052 TEST(GetNumericEffecterValue, testBadEncodeResponse)
3053 {
3054 std::array<uint8_t,
3055 hdrSize + PLDM_GET_NUMERIC_EFFECTER_VALUE_MIN_RESP_BYTES + 2>
3056 responseMsg{};
3057 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3058 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
3059
3060 uint8_t pendingValue = 0x01;
3061 uint8_t presentValue = 0x02;
3062
3063 auto rc = encode_get_numeric_effecter_value_resp(
3064 0, PLDM_SUCCESS, 0, 0, nullptr, nullptr, nullptr,
3065 responseMsg.size() - hdrSize);
3066 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3067
3068 rc = encode_get_numeric_effecter_value_resp(
3069 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3070 0, PLDM_SUCCESS, 6, 9, reinterpret_cast<uint8_t*>(&pendingValue),
3071 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3072 reinterpret_cast<uint8_t*>(&presentValue), response,
3073 responseMsg.size() - hdrSize);
3074 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3075
3076 uint8_t effecter_dataSize = PLDM_EFFECTER_DATA_SIZE_UINT8;
3077 uint8_t effecter_operState = EFFECTER_OPER_STATE_FAILED;
3078
3079 rc = encode_get_numeric_effecter_value_resp(
3080 0, PLDM_SUCCESS, effecter_dataSize, effecter_operState,
3081 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3082 reinterpret_cast<uint8_t*>(&pendingValue),
3083 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3084 reinterpret_cast<uint8_t*>(&presentValue), response,
3085 responseMsg.size() - hdrSize);
3086 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
3087 }
3088
TEST(GetNumericEffecterValue,testGoodDecodeResponse)3089 TEST(GetNumericEffecterValue, testGoodDecodeResponse)
3090 {
3091 std::array<uint8_t,
3092 hdrSize + PLDM_GET_NUMERIC_EFFECTER_VALUE_MIN_RESP_BYTES + 2>
3093 responseMsg{};
3094
3095 uint8_t completionCode = 0;
3096 uint8_t effecter_dataSize = PLDM_EFFECTER_DATA_SIZE_UINT16;
3097 uint8_t effecter_operState = EFFECTER_OPER_STATE_ENABLED_NOUPDATEPENDING;
3098 uint16_t pendingValue = 0x4321;
3099 uint16_t presentValue = 0xdcba;
3100
3101 uint8_t retcompletionCode;
3102 uint8_t reteffecter_dataSize;
3103 uint8_t reteffecter_operState;
3104 uint8_t retpendingValue[2];
3105 uint8_t retpresentValue[2];
3106
3107 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3108 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
3109 struct pldm_get_numeric_effecter_value_resp* resp =
3110 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3111 reinterpret_cast<struct pldm_get_numeric_effecter_value_resp*>(
3112 response->payload);
3113
3114 resp->completion_code = completionCode;
3115 resp->effecter_data_size = effecter_dataSize;
3116 resp->effecter_oper_state = effecter_operState;
3117
3118 uint16_t pendingValue_le = htole16(pendingValue);
3119 memcpy(resp->pending_and_present_values, &pendingValue_le,
3120 sizeof(pendingValue_le));
3121 uint16_t presentValue_le = htole16(presentValue);
3122 memcpy(&resp->pending_and_present_values[2], &presentValue_le,
3123 sizeof(presentValue_le));
3124
3125 auto rc = decode_get_numeric_effecter_value_resp(
3126 response, responseMsg.size() - hdrSize, &retcompletionCode,
3127 &reteffecter_dataSize, &reteffecter_operState, retpendingValue,
3128 retpresentValue);
3129
3130 EXPECT_EQ(rc, PLDM_SUCCESS);
3131 EXPECT_EQ(completionCode, retcompletionCode);
3132 EXPECT_EQ(effecter_dataSize, reteffecter_dataSize);
3133 EXPECT_EQ(effecter_operState, reteffecter_operState);
3134 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3135 EXPECT_EQ(pendingValue, *(reinterpret_cast<uint16_t*>(retpendingValue)));
3136 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3137 EXPECT_EQ(presentValue, *(reinterpret_cast<uint16_t*>(retpresentValue)));
3138 }
3139
TEST(GetNumericEffecterValue,testBadDecodeResponse)3140 TEST(GetNumericEffecterValue, testBadDecodeResponse)
3141 {
3142 std::array<uint8_t,
3143 hdrSize + PLDM_GET_NUMERIC_EFFECTER_VALUE_MIN_RESP_BYTES + 6>
3144 responseMsg{};
3145
3146 auto rc = decode_get_numeric_effecter_value_resp(
3147 nullptr, responseMsg.size() - hdrSize, nullptr, nullptr, nullptr,
3148 nullptr, nullptr);
3149
3150 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3151
3152 uint8_t completionCode = 0;
3153 uint8_t effecter_dataSize = PLDM_EFFECTER_DATA_SIZE_SINT16;
3154 uint8_t effecter_operState = EFFECTER_OPER_STATE_DISABLED;
3155 uint16_t pendingValue = 0x5678;
3156 uint16_t presentValue = 0xcdef;
3157
3158 uint8_t retcompletionCode;
3159 uint8_t reteffecter_dataSize;
3160 uint8_t reteffecter_operState;
3161 uint8_t retpendingValue[2];
3162 uint8_t retpresentValue[2];
3163
3164 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3165 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
3166 struct pldm_get_numeric_effecter_value_resp* resp =
3167 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3168 reinterpret_cast<struct pldm_get_numeric_effecter_value_resp*>(
3169 response->payload);
3170
3171 resp->completion_code = completionCode;
3172 resp->effecter_data_size = effecter_dataSize;
3173 resp->effecter_oper_state = effecter_operState;
3174
3175 uint16_t pendingValue_le = htole16(pendingValue);
3176 memcpy(resp->pending_and_present_values, &pendingValue_le,
3177 sizeof(pendingValue_le));
3178 uint16_t presentValue_le = htole16(presentValue);
3179 memcpy(&resp->pending_and_present_values[2], &presentValue_le,
3180 sizeof(presentValue_le));
3181
3182 rc = decode_get_numeric_effecter_value_resp(
3183 response, responseMsg.size() - hdrSize, &retcompletionCode,
3184 &reteffecter_dataSize, &reteffecter_operState, retpendingValue,
3185 retpresentValue);
3186
3187 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3188 }
3189
TEST(PldmPDRRepositoryChgEventEvent,testGoodDecodeRequest)3190 TEST(PldmPDRRepositoryChgEventEvent, testGoodDecodeRequest)
3191 {
3192 const uint8_t eventDataFormat = FORMAT_IS_PDR_HANDLES;
3193 const uint8_t numberOfChangeRecords = 2;
3194 uint8_t eventDataOperation1 = PLDM_RECORDS_DELETED;
3195 const uint8_t numberOfChangeEntries1 = 2;
3196 std::array<uint32_t, numberOfChangeEntries1> changeRecordArr1{
3197 {0x00000000, 0x12345678}};
3198 uint8_t eventDataOperation2 = PLDM_RECORDS_ADDED;
3199 const uint8_t numberOfChangeEntries2 = 5;
3200 std::array<uint32_t, numberOfChangeEntries2> changeRecordArr2{
3201 {0x01234567, 0x11223344, 0x45678901, 0x21222324, 0x98765432}};
3202 std::array<uint8_t, PLDM_PDR_REPOSITORY_CHG_EVENT_MIN_LENGTH +
3203 PLDM_PDR_REPOSITORY_CHANGE_RECORD_MIN_LENGTH *
3204 numberOfChangeRecords +
3205 (numberOfChangeEntries1 + numberOfChangeEntries2) *
3206 sizeof(uint32_t)>
3207 eventDataArr{};
3208
3209 struct pldm_pdr_repository_chg_event_data* eventData =
3210 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3211 reinterpret_cast<struct pldm_pdr_repository_chg_event_data*>(
3212 eventDataArr.data());
3213 eventData->event_data_format = eventDataFormat;
3214 eventData->number_of_change_records = numberOfChangeRecords;
3215 struct pldm_pdr_repository_change_record_data* changeRecord1 =
3216 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3217 reinterpret_cast<struct pldm_pdr_repository_change_record_data*>(
3218 eventData->change_records);
3219 changeRecord1->event_data_operation = eventDataOperation1;
3220 changeRecord1->number_of_change_entries = numberOfChangeEntries1;
3221 memcpy(changeRecord1->change_entry, &changeRecordArr1[0],
3222 changeRecordArr1.size() * sizeof(uint32_t));
3223 struct pldm_pdr_repository_change_record_data* changeRecord2 =
3224 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3225 reinterpret_cast<struct pldm_pdr_repository_change_record_data*>(
3226 eventData->change_records +
3227 PLDM_PDR_REPOSITORY_CHANGE_RECORD_MIN_LENGTH +
3228 (changeRecordArr1.size() * sizeof(uint32_t)));
3229 changeRecord2->event_data_operation = eventDataOperation2;
3230 changeRecord2->number_of_change_entries = numberOfChangeEntries2;
3231 memcpy(changeRecord2->change_entry, &changeRecordArr2[0],
3232 changeRecordArr2.size() * sizeof(uint32_t));
3233
3234 uint8_t retEventDataFormat{};
3235 uint8_t retNumberOfChangeRecords{};
3236 size_t retChangeRecordDataOffset{0};
3237 auto rc = decode_pldm_pdr_repository_chg_event_data(
3238 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3239 reinterpret_cast<const uint8_t*>(eventData), eventDataArr.size(),
3240 &retEventDataFormat, &retNumberOfChangeRecords,
3241 &retChangeRecordDataOffset);
3242 EXPECT_EQ(rc, PLDM_SUCCESS);
3243 EXPECT_EQ(retEventDataFormat, FORMAT_IS_PDR_HANDLES);
3244 EXPECT_EQ(retNumberOfChangeRecords, numberOfChangeRecords);
3245
3246 const uint8_t* changeRecordData =
3247 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3248 reinterpret_cast<const uint8_t*>(changeRecord1);
3249 size_t changeRecordDataSize =
3250 eventDataArr.size() - PLDM_PDR_REPOSITORY_CHG_EVENT_MIN_LENGTH;
3251 uint8_t retEventDataOperation;
3252 uint8_t retNumberOfChangeEntries;
3253 size_t retChangeEntryDataOffset;
3254
3255 rc = decode_pldm_pdr_repository_change_record_data(
3256 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3257 reinterpret_cast<const uint8_t*>(changeRecordData),
3258 changeRecordDataSize, &retEventDataOperation, &retNumberOfChangeEntries,
3259 &retChangeEntryDataOffset);
3260 EXPECT_EQ(rc, PLDM_SUCCESS);
3261 EXPECT_EQ(retEventDataOperation, eventDataOperation1);
3262 EXPECT_EQ(retNumberOfChangeEntries, numberOfChangeEntries1);
3263 changeRecordData += retChangeEntryDataOffset;
3264 EXPECT_EQ(0, memcmp(changeRecordData, &changeRecordArr1[0],
3265 sizeof(uint32_t) * retNumberOfChangeEntries));
3266
3267 changeRecordData += sizeof(uint32_t) * retNumberOfChangeEntries;
3268 changeRecordDataSize -= sizeof(uint32_t) * retNumberOfChangeEntries -
3269 PLDM_PDR_REPOSITORY_CHANGE_RECORD_MIN_LENGTH;
3270 rc = decode_pldm_pdr_repository_change_record_data(
3271 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3272 reinterpret_cast<const uint8_t*>(changeRecordData),
3273 changeRecordDataSize, &retEventDataOperation, &retNumberOfChangeEntries,
3274 &retChangeEntryDataOffset);
3275 EXPECT_EQ(rc, PLDM_SUCCESS);
3276 EXPECT_EQ(retEventDataOperation, eventDataOperation2);
3277 EXPECT_EQ(retNumberOfChangeEntries, numberOfChangeEntries2);
3278 changeRecordData += retChangeEntryDataOffset;
3279 EXPECT_EQ(0, memcmp(changeRecordData, &changeRecordArr2[0],
3280 sizeof(uint32_t) * retNumberOfChangeEntries));
3281 }
3282
TEST(PldmPDRRepositoryChgEventEvent,testBadDecodeRequest)3283 TEST(PldmPDRRepositoryChgEventEvent, testBadDecodeRequest)
3284 {
3285 uint8_t eventDataFormat{};
3286 uint8_t numberOfChangeRecords{};
3287 size_t changeRecordDataOffset{};
3288 auto rc = decode_pldm_pdr_repository_chg_event_data(
3289 NULL, 0, &eventDataFormat, &numberOfChangeRecords,
3290 &changeRecordDataOffset);
3291 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3292
3293 std::array<uint8_t, 2> eventData{};
3294 rc = decode_pldm_pdr_repository_chg_event_data(
3295 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3296 reinterpret_cast<const uint8_t*>(eventData.data()), 0, &eventDataFormat,
3297 &numberOfChangeRecords, &changeRecordDataOffset);
3298 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
3299
3300 uint8_t eventDataOperation{};
3301 uint8_t numberOfChangeEntries{};
3302 size_t changeEntryDataOffset{};
3303 rc = decode_pldm_pdr_repository_change_record_data(
3304 NULL, 0, &eventDataOperation, &numberOfChangeEntries,
3305 &changeEntryDataOffset);
3306 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3307
3308 std::array<uint8_t, 2> changeRecord{};
3309 rc = decode_pldm_pdr_repository_change_record_data(
3310 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3311 reinterpret_cast<const uint8_t*>(changeRecord.data()), 0,
3312 &eventDataOperation, &numberOfChangeEntries, &changeEntryDataOffset);
3313 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
3314 }
3315
TEST(GetSensorReading,testGoodEncodeRequest)3316 TEST(GetSensorReading, testGoodEncodeRequest)
3317 {
3318 std::array<uint8_t, hdrSize + PLDM_GET_SENSOR_READING_REQ_BYTES>
3319 requestMsg{};
3320
3321 uint16_t sensorId = 0x1234;
3322 bool8_t rearmEventState = 0x01;
3323
3324 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3325 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
3326 auto rc =
3327 encode_get_sensor_reading_req(0, sensorId, rearmEventState, request);
3328
3329 struct pldm_get_sensor_reading_req* req =
3330 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3331 reinterpret_cast<struct pldm_get_sensor_reading_req*>(request->payload);
3332
3333 EXPECT_EQ(rc, PLDM_SUCCESS);
3334 EXPECT_EQ(sensorId, le16toh(req->sensor_id));
3335 EXPECT_EQ(rearmEventState, req->rearm_event_state);
3336 }
3337
TEST(GetSensorReading,testBadEncodeRequest)3338 TEST(GetSensorReading, testBadEncodeRequest)
3339 {
3340 auto rc = encode_get_sensor_reading_req(0, 0, 0, nullptr);
3341
3342 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3343 }
3344
TEST(GetSensorReading,testGoodDecodeRequest)3345 TEST(GetSensorReading, testGoodDecodeRequest)
3346 {
3347 std::array<uint8_t, hdrSize + PLDM_GET_SENSOR_READING_REQ_BYTES>
3348 requestMsg{};
3349
3350 uint16_t sensorId = 0xabcd;
3351 bool8_t rearmEventState = 0xa;
3352
3353 uint16_t retsensorId;
3354 bool8_t retrearmEventState;
3355
3356 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3357 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
3358
3359 struct pldm_get_sensor_reading_req* req =
3360 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3361 reinterpret_cast<struct pldm_get_sensor_reading_req*>(request->payload);
3362
3363 req->sensor_id = htole16(sensorId);
3364 req->rearm_event_state = rearmEventState;
3365
3366 auto rc =
3367 decode_get_sensor_reading_req(request, requestMsg.size() - hdrSize,
3368 &retsensorId, &retrearmEventState);
3369
3370 EXPECT_EQ(rc, PLDM_SUCCESS);
3371 EXPECT_EQ(sensorId, retsensorId);
3372 EXPECT_EQ(rearmEventState, retrearmEventState);
3373 }
3374
TEST(GetSensorReading,testBadDecodeRequest)3375 TEST(GetSensorReading, testBadDecodeRequest)
3376 {
3377 std::array<uint8_t, hdrSize + PLDM_GET_SENSOR_READING_REQ_BYTES>
3378 requestMsg{};
3379
3380 auto rc = decode_get_sensor_reading_req(
3381 nullptr, requestMsg.size() - hdrSize, nullptr, nullptr);
3382 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3383
3384 uint16_t sensorId = 0xabcd;
3385 bool8_t rearmEventState = 0xa;
3386
3387 uint16_t retsensorId;
3388 bool8_t retrearmEventState;
3389
3390 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3391 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
3392
3393 struct pldm_get_sensor_reading_req* req =
3394 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3395 reinterpret_cast<struct pldm_get_sensor_reading_req*>(request->payload);
3396
3397 req->sensor_id = htole16(sensorId);
3398 req->rearm_event_state = rearmEventState;
3399
3400 rc = decode_get_sensor_reading_req(request, requestMsg.size() - hdrSize - 1,
3401 &retsensorId, &retrearmEventState);
3402
3403 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
3404 }
3405
TEST(GetSensorReading,testGoodEncodeResponse)3406 TEST(GetSensorReading, testGoodEncodeResponse)
3407 {
3408 std::array<uint8_t, hdrSize + PLDM_GET_SENSOR_READING_MIN_RESP_BYTES>
3409 responseMsg{};
3410
3411 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3412 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
3413
3414 uint8_t completionCode = 0;
3415 uint8_t sensor_dataSize = PLDM_EFFECTER_DATA_SIZE_UINT8;
3416 uint8_t sensor_operationalState = PLDM_SENSOR_ENABLED;
3417 uint8_t sensor_event_messageEnable = PLDM_NO_EVENT_GENERATION;
3418 uint8_t presentState = PLDM_SENSOR_NORMAL;
3419 uint8_t previousState = PLDM_SENSOR_WARNING;
3420 uint8_t eventState = PLDM_SENSOR_UPPERWARNING;
3421 uint8_t presentReading = 0x21;
3422
3423 auto rc = encode_get_sensor_reading_resp(
3424 0, completionCode, sensor_dataSize, sensor_operationalState,
3425 sensor_event_messageEnable, presentState, previousState, eventState,
3426 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3427 reinterpret_cast<uint8_t*>(&presentReading), response,
3428 responseMsg.size() - hdrSize);
3429
3430 struct pldm_get_sensor_reading_resp* resp =
3431 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3432 reinterpret_cast<struct pldm_get_sensor_reading_resp*>(
3433 response->payload);
3434
3435 EXPECT_EQ(rc, PLDM_SUCCESS);
3436 EXPECT_EQ(completionCode, resp->completion_code);
3437 EXPECT_EQ(sensor_dataSize, resp->sensor_data_size);
3438 EXPECT_EQ(sensor_operationalState, resp->sensor_operational_state);
3439 EXPECT_EQ(sensor_event_messageEnable, resp->sensor_event_message_enable);
3440 EXPECT_EQ(presentState, resp->present_state);
3441 EXPECT_EQ(previousState, resp->previous_state);
3442 EXPECT_EQ(eventState, resp->event_state);
3443 EXPECT_EQ(presentReading,
3444 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3445 *(reinterpret_cast<uint8_t*>(&resp->present_reading[0])));
3446 }
3447
TEST(GetSensorReading,testBadEncodeResponse)3448 TEST(GetSensorReading, testBadEncodeResponse)
3449 {
3450 std::array<uint8_t, hdrSize + PLDM_GET_SENSOR_READING_MIN_RESP_BYTES + 3>
3451 responseMsg{};
3452
3453 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3454 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
3455
3456 uint8_t presentReading = 0x1;
3457
3458 auto rc = encode_get_sensor_reading_resp(0, PLDM_SUCCESS, 0, 0, 0, 0, 0, 0,
3459 nullptr, nullptr,
3460 responseMsg.size() - hdrSize);
3461 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3462
3463 rc = encode_get_sensor_reading_resp(
3464 0, PLDM_SUCCESS, 6, 1, 1, 1, 1, 1,
3465 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3466 reinterpret_cast<uint8_t*>(&presentReading), response,
3467 responseMsg.size() - hdrSize);
3468 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3469
3470 uint8_t sensor_dataSize = PLDM_EFFECTER_DATA_SIZE_UINT8;
3471
3472 rc = encode_get_sensor_reading_resp(
3473 0, PLDM_SUCCESS, sensor_dataSize, 1, 1, 1, 1, 1,
3474 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3475 reinterpret_cast<uint8_t*>(&presentReading), response,
3476 responseMsg.size() - hdrSize);
3477 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
3478 }
3479
TEST(GetSensorReading,testGoodDecodeResponse)3480 TEST(GetSensorReading, testGoodDecodeResponse)
3481 {
3482 std::array<uint8_t, hdrSize + PLDM_GET_SENSOR_READING_MIN_RESP_BYTES + 3>
3483 responseMsg{};
3484
3485 uint8_t completionCode = 0;
3486 uint8_t sensor_dataSize = PLDM_EFFECTER_DATA_SIZE_UINT32;
3487 uint8_t sensor_operationalState = PLDM_SENSOR_STATUSUNKOWN;
3488 uint8_t sensor_event_messageEnable = PLDM_EVENTS_ENABLED;
3489 uint8_t presentState = PLDM_SENSOR_CRITICAL;
3490 uint8_t previousState = PLDM_SENSOR_UPPERCRITICAL;
3491 uint8_t eventState = PLDM_SENSOR_WARNING;
3492 uint32_t presentReading = 0xabcdef11;
3493
3494 uint8_t retcompletionCode;
3495 uint8_t retsensor_dataSize = PLDM_SENSOR_DATA_SIZE_UINT32;
3496 uint8_t retsensor_operationalState;
3497 uint8_t retsensor_event_messageEnable;
3498 uint8_t retpresentState;
3499 uint8_t retpreviousState;
3500 uint8_t reteventState;
3501 uint8_t retpresentReading[4];
3502
3503 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3504 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
3505 struct pldm_get_sensor_reading_resp* resp =
3506 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3507 reinterpret_cast<struct pldm_get_sensor_reading_resp*>(
3508 response->payload);
3509
3510 resp->completion_code = completionCode;
3511 resp->sensor_data_size = sensor_dataSize;
3512 resp->sensor_operational_state = sensor_operationalState;
3513 resp->sensor_event_message_enable = sensor_event_messageEnable;
3514 resp->present_state = presentState;
3515 resp->previous_state = previousState;
3516 resp->event_state = eventState;
3517
3518 uint32_t presentReading_le = htole32(presentReading);
3519 memcpy(resp->present_reading, &presentReading_le,
3520 sizeof(presentReading_le));
3521
3522 auto rc = decode_get_sensor_reading_resp(
3523 response, responseMsg.size() - hdrSize, &retcompletionCode,
3524 &retsensor_dataSize, &retsensor_operationalState,
3525 &retsensor_event_messageEnable, &retpresentState, &retpreviousState,
3526 &reteventState, retpresentReading);
3527
3528 EXPECT_EQ(rc, PLDM_SUCCESS);
3529 EXPECT_EQ(completionCode, retcompletionCode);
3530 EXPECT_EQ(sensor_dataSize, retsensor_dataSize);
3531 EXPECT_EQ(sensor_operationalState, retsensor_operationalState);
3532 EXPECT_EQ(sensor_event_messageEnable, retsensor_event_messageEnable);
3533 EXPECT_EQ(presentState, retpresentState);
3534 EXPECT_EQ(previousState, retpreviousState);
3535 EXPECT_EQ(eventState, reteventState);
3536 EXPECT_EQ(presentReading,
3537 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3538 *(reinterpret_cast<uint32_t*>(retpresentReading)));
3539 }
3540
TEST(GetSensorReading,testBadDecodeResponse)3541 TEST(GetSensorReading, testBadDecodeResponse)
3542 {
3543 std::array<uint8_t, hdrSize + PLDM_GET_SENSOR_READING_MIN_RESP_BYTES + 1>
3544 responseMsg{};
3545
3546 auto rc = decode_get_sensor_reading_resp(
3547 nullptr, responseMsg.size() - hdrSize, nullptr, nullptr, nullptr,
3548 nullptr, nullptr, nullptr, nullptr, nullptr);
3549
3550 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3551
3552 uint8_t completionCode = 0;
3553 uint8_t sensor_dataSize = PLDM_EFFECTER_DATA_SIZE_UINT8;
3554 uint8_t sensor_operationalState = PLDM_SENSOR_INTEST;
3555 uint8_t sensor_event_messageEnable = PLDM_EVENTS_DISABLED;
3556 uint8_t presentState = PLDM_SENSOR_FATAL;
3557 uint8_t previousState = PLDM_SENSOR_UPPERFATAL;
3558 uint8_t eventState = PLDM_SENSOR_WARNING;
3559 uint8_t presentReading = 0xa;
3560
3561 uint8_t retcompletionCode;
3562 uint8_t retsensor_dataSize = PLDM_SENSOR_DATA_SIZE_SINT16;
3563 uint8_t retsensor_operationalState;
3564 uint8_t retsensor_event_messageEnable;
3565 uint8_t retpresent_state;
3566 uint8_t retprevious_state;
3567 uint8_t retevent_state;
3568 uint8_t retpresentReading;
3569
3570 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3571 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
3572 struct pldm_get_sensor_reading_resp* resp =
3573 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3574 reinterpret_cast<struct pldm_get_sensor_reading_resp*>(
3575 response->payload);
3576
3577 resp->completion_code = completionCode;
3578 resp->sensor_data_size = sensor_dataSize;
3579 resp->sensor_operational_state = sensor_operationalState;
3580 resp->sensor_event_message_enable = sensor_event_messageEnable;
3581 resp->present_state = presentState;
3582 resp->previous_state = previousState;
3583 resp->event_state = eventState;
3584 resp->present_reading[0] = presentReading;
3585
3586 rc = decode_get_sensor_reading_resp(
3587 response, responseMsg.size() - hdrSize, &retcompletionCode,
3588 &retsensor_dataSize, &retsensor_operationalState,
3589 &retsensor_event_messageEnable, &retpresent_state, &retprevious_state,
3590 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3591 &retevent_state, reinterpret_cast<uint8_t*>(&retpresentReading));
3592
3593 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3594 }
3595
3596 #ifdef LIBPLDM_API_TESTING
TEST(SetNumericSensorEnable,testDecodeRequest)3597 TEST(SetNumericSensorEnable, testDecodeRequest)
3598 {
3599 int rc;
3600 struct pldm_set_numeric_sensor_enable_req decoded;
3601
3602 const std::array<uint8_t, hdrSize + 5> req
3603 // PLDM header
3604 {
3605 PLDM_PLATFORM, 0x80, PLDM_SET_NUMERIC_SENSOR_ENABLE,
3606 0x67, 0x45, // sensor ID 0x4567
3607 0x00, // sensorOperationalState
3608 0x01, // sensorEventMessageEnable
3609 0x00, // extra
3610 };
3611
3612 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3613 auto msg = reinterpret_cast<const pldm_msg*>(req.data());
3614
3615 // Good decode
3616 rc = decode_set_numeric_sensor_enable_req(msg, 4, &decoded);
3617 EXPECT_EQ(rc, 0);
3618 EXPECT_EQ(decoded.sensor_id, 0x4567);
3619 EXPECT_EQ(decoded.op_state, PLDM_SENSOR_ENABLED);
3620 EXPECT_EQ(decoded.event_enable, PLDM_EVENTS_DISABLED);
3621
3622 // Fail short
3623 rc = decode_set_numeric_sensor_enable_req(msg, 3, &decoded);
3624 EXPECT_EQ(rc, -EOVERFLOW);
3625 // Fail long
3626 rc = decode_set_numeric_sensor_enable_req(msg, 5, &decoded);
3627 EXPECT_EQ(rc, -EBADMSG);
3628 }
3629 #endif // LIBPLDM_API_TESTING
3630
3631 #ifdef LIBPLDM_API_TESTING
TEST(SetNumericSensorEnable,testDecodeInvalidOpRequest)3632 TEST(SetNumericSensorEnable, testDecodeInvalidOpRequest)
3633 {
3634 int rc;
3635 struct pldm_set_numeric_sensor_enable_req decoded;
3636
3637 const std::array<uint8_t, hdrSize + 4> req
3638 // PLDM header
3639 {
3640 PLDM_PLATFORM, 0x80, PLDM_SET_NUMERIC_SENSOR_ENABLE,
3641 0x67, 0x45, // sensor ID 0x4567
3642 0x30, // Invalid sensorOperationalState
3643 0x01, // sensorEventMessageEnable
3644 };
3645
3646 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3647 auto msg = reinterpret_cast<const pldm_msg*>(req.data());
3648
3649 rc = decode_set_numeric_sensor_enable_req(msg, 4, &decoded);
3650 EXPECT_EQ(rc, -EPROTO);
3651 }
3652 #endif // LIBPLDM_API_TESTING
3653
3654 #ifdef LIBPLDM_API_TESTING
TEST(SetNumericSensorEnable,testDecodeInvalidEventRequest)3655 TEST(SetNumericSensorEnable, testDecodeInvalidEventRequest)
3656 {
3657 int rc;
3658 struct pldm_set_numeric_sensor_enable_req decoded;
3659
3660 const std::array<uint8_t, hdrSize + 4> req
3661 // PLDM header
3662 {
3663 PLDM_PLATFORM, 0x80, PLDM_SET_NUMERIC_SENSOR_ENABLE,
3664 0x67, 0x45, // sensor ID 0x4567
3665 0x00, // sensorOperationalState
3666 0x77, // Invalid sensorEventMessageEnable
3667 };
3668
3669 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3670 auto msg = reinterpret_cast<const pldm_msg*>(req.data());
3671
3672 rc = decode_set_numeric_sensor_enable_req(msg, 4, &decoded);
3673 EXPECT_EQ(rc, -EPROTO);
3674 }
3675 #endif // LIBPLDM_API_TESTING
3676
3677 #ifdef LIBPLDM_API_TESTING
TEST(SetStateSensorEnables,testDecodeRequest)3678 TEST(SetStateSensorEnables, testDecodeRequest)
3679 {
3680 int rc;
3681 struct pldm_set_state_sensor_enables_req decoded;
3682
3683 const std::array<uint8_t, hdrSize + 8> req
3684 // PLDM header
3685 {
3686 PLDM_PLATFORM, 0x80, PLDM_SET_STATE_SENSOR_ENABLES,
3687 0x67, 0x45, // sensor ID 0x4567
3688 0x02, // count
3689 0x01, 0x00, // field 0
3690 0x02, 0x01, // field 1
3691 0x00, // extra byte
3692 };
3693
3694 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3695 auto msg = reinterpret_cast<const pldm_msg*>(req.data());
3696
3697 // Good decode
3698 rc = decode_set_state_sensor_enables_req(msg, 7, &decoded);
3699 EXPECT_EQ(rc, 0);
3700 EXPECT_EQ(decoded.sensor_id, 0x4567);
3701 EXPECT_EQ(decoded.field_count, 2);
3702 EXPECT_EQ(decoded.fields[0].op_state, PLDM_SET_SENSOR_DISABLED);
3703 EXPECT_EQ(decoded.fields[0].event_enable, PLDM_NO_EVENT_GENERATION);
3704 EXPECT_EQ(decoded.fields[1].op_state, PLDM_SET_SENSOR_UNAVAILABLE);
3705 EXPECT_EQ(decoded.fields[1].event_enable, PLDM_EVENTS_DISABLED);
3706
3707 // Short message
3708 rc = decode_set_state_sensor_enables_req(msg, 6, &decoded);
3709 EXPECT_EQ(rc, -EOVERFLOW);
3710
3711 // Overlength message
3712 rc = decode_set_state_sensor_enables_req(msg, 8, &decoded);
3713 EXPECT_EQ(rc, -EBADMSG);
3714 }
3715 #endif // LIBPLDM_API_TESTING
3716
3717 #ifdef LIBPLDM_API_TESTING
TEST(SetStateSensorEnables,testDecodeInvalidOpRequest)3718 TEST(SetStateSensorEnables, testDecodeInvalidOpRequest)
3719 {
3720 int rc;
3721 struct pldm_set_state_sensor_enables_req decoded;
3722
3723 const std::array<uint8_t, hdrSize + 7> req
3724 // PLDM header
3725 {
3726 PLDM_PLATFORM, 0x80, PLDM_SET_STATE_SENSOR_ENABLES,
3727 0x67, 0x45, // sensor ID 0x4567
3728 0x02, // count
3729 0x01, 0x00, // field 0
3730 0x99, 0x01, // field 1 invalid op
3731 };
3732
3733 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3734 auto msg = reinterpret_cast<const pldm_msg*>(req.data());
3735
3736 rc = decode_set_state_sensor_enables_req(msg, 7, &decoded);
3737 EXPECT_EQ(rc, -EPROTO);
3738 }
3739 #endif // LIBPLDM_API_TESTING
3740
3741 #ifdef LIBPLDM_API_TESTING
TEST(SetStateSensorEnables,testDecodeInvalidEventRequest)3742 TEST(SetStateSensorEnables, testDecodeInvalidEventRequest)
3743 {
3744 int rc;
3745 struct pldm_set_state_sensor_enables_req decoded;
3746
3747 const std::array<uint8_t, hdrSize + 7> req
3748 // PLDM header
3749 {
3750 PLDM_PLATFORM, 0x80, PLDM_SET_STATE_SENSOR_ENABLES,
3751 0x67, 0x45, // sensor ID 0x4567
3752 0x02, // count
3753 0x01, 0x00, // field 0
3754 0x00, 0x77, // field 1 invalid event
3755 };
3756
3757 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3758 auto msg = reinterpret_cast<const pldm_msg*>(req.data());
3759
3760 rc = decode_set_state_sensor_enables_req(msg, 7, &decoded);
3761 EXPECT_EQ(rc, -EPROTO);
3762 }
3763 #endif // LIBPLDM_API_TESTING
3764
3765 #ifdef LIBPLDM_API_TESTING
TEST(GetEventReceiver,testGoodEncodeRequest)3766 TEST(GetEventReceiver, testGoodEncodeRequest)
3767 {
3768 std::array<uint8_t, hdrSize> requestMsg{};
3769 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3770 auto request = new (requestMsg.data()) pldm_msg;
3771 auto rc =
3772 encode_get_event_receiver_req(0, request, sizeof(struct pldm_msg));
3773 ASSERT_EQ(rc, 0);
3774 }
3775 #endif
3776
3777 #ifdef LIBPLDM_API_TESTING
TEST(GetEventReceiver,testBadEncodeRequest)3778 TEST(GetEventReceiver, testBadEncodeRequest)
3779 {
3780 auto rc =
3781 encode_get_event_receiver_req(0, nullptr, sizeof(struct pldm_msg));
3782 EXPECT_EQ(rc, -EINVAL);
3783 }
3784 #endif
3785
3786 #ifdef LIBPLDM_API_TESTING
TEST(GetEventReceiver,testGoodEncodeResponse)3787 TEST(GetEventReceiver, testGoodEncodeResponse)
3788 {
3789 struct pldm_get_event_receiver_resp request_event_receiver_values;
3790 request_event_receiver_values.completion_code = 0;
3791 request_event_receiver_values.transport_protocol_type =
3792 PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP;
3793 request_event_receiver_values.event_receiver_address.mctp_eid = 84;
3794 size_t payload_lenght = PLDM_GET_EVENT_RECEIVER_MIN_RESP_BYTES + 1;
3795 std::array<uint8_t, hdrSize + sizeof(pldm_get_event_receiver_resp)>
3796 responseMsg{};
3797 auto response = new (responseMsg.data()) pldm_msg;
3798 auto rc = encode_get_event_receiver_resp(0, &request_event_receiver_values,
3799 response, &payload_lenght);
3800 EXPECT_EQ(rc, 0);
3801 }
3802 #endif
3803
3804 #ifdef LIBPLDM_API_TESTING
TEST(GetEventReceiver,testBadEncodeResponse)3805 TEST(GetEventReceiver, testBadEncodeResponse)
3806 {
3807 std::array<uint8_t, hdrSize + sizeof(pldm_get_event_receiver_resp)>
3808 responseMsg{};
3809 auto response = new (responseMsg.data()) pldm_msg;
3810 struct pldm_get_event_receiver_resp request_event_receiver_values;
3811 request_event_receiver_values.completion_code = 0;
3812 request_event_receiver_values.transport_protocol_type =
3813 PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP;
3814 request_event_receiver_values.event_receiver_address.mctp_eid = 64;
3815 size_t payload_lenght = PLDM_GET_EVENT_RECEIVER_MIN_RESP_BYTES;
3816 // msg can not be null
3817 auto rc = encode_get_event_receiver_resp(0, &request_event_receiver_values,
3818 nullptr, &payload_lenght);
3819 EXPECT_EQ(rc, -EINVAL);
3820 // unsupported protocol
3821 request_event_receiver_values.transport_protocol_type = 1;
3822 rc = encode_get_event_receiver_resp(0, &request_event_receiver_values,
3823 response, &payload_lenght);
3824 EXPECT_EQ(rc, -ENOTSUP);
3825 }
3826 #endif
3827
3828 #ifdef LIBPLDM_API_TESTING
TEST(GetEventReceiver,testGoodDecodeResponse)3829 TEST(GetEventReceiver, testGoodDecodeResponse)
3830 {
3831 struct pldm_get_event_receiver_resp request_event_receiver_values;
3832 request_event_receiver_values.completion_code = 0;
3833 request_event_receiver_values.transport_protocol_type =
3834 PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP;
3835 request_event_receiver_values.event_receiver_address.mctp_eid = 34;
3836 size_t payload_lenght = PLDM_GET_EVENT_RECEIVER_MIN_RESP_BYTES + 1;
3837 struct pldm_get_event_receiver_resp decoded_resp;
3838 std::array<uint8_t, hdrSize + sizeof(pldm_get_event_receiver_resp)>
3839 responseMsg{};
3840 auto response = new (responseMsg.data()) pldm_msg;
3841 auto rc = encode_get_event_receiver_resp(0, &request_event_receiver_values,
3842 response, &payload_lenght);
3843 EXPECT_EQ(rc, 0);
3844 rc = decode_get_event_receiver_resp(
3845 response, PLDM_GET_EVENT_RECEIVER_MIN_RESP_BYTES + 1, &decoded_resp);
3846 EXPECT_EQ(rc, 0);
3847 EXPECT_EQ(decoded_resp.completion_code, PLDM_SUCCESS);
3848 EXPECT_EQ(decoded_resp.transport_protocol_type,
3849 request_event_receiver_values.transport_protocol_type);
3850 EXPECT_EQ(decoded_resp.event_receiver_address.mctp_eid,
3851 request_event_receiver_values.event_receiver_address.mctp_eid);
3852 }
3853 #endif
3854
3855 #ifdef LIBPLDM_API_TESTING
TEST(GetEventReceiver,testBadDecodeResponse)3856 TEST(GetEventReceiver, testBadDecodeResponse)
3857 {
3858 struct pldm_get_event_receiver_resp decoded_resp;
3859 struct pldm_get_event_receiver_resp expected_resp;
3860 expected_resp.completion_code = 0;
3861 expected_resp.transport_protocol_type = PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP;
3862 expected_resp.event_receiver_address.mctp_eid = 34;
3863 std::array<uint8_t, hdrSize + sizeof(pldm_get_event_receiver_resp)>
3864 responseMsg{};
3865 auto response = new (responseMsg.data()) pldm_msg;
3866 size_t payload_lenght = PLDM_GET_EVENT_RECEIVER_MIN_RESP_BYTES + 1;
3867 auto rc = encode_get_event_receiver_resp(0, &expected_resp, response,
3868 &payload_lenght);
3869 EXPECT_EQ(rc, 0);
3870 // message can not be null
3871 rc = decode_get_event_receiver_resp(
3872 nullptr, responseMsg.size() - sizeof(pldm_msg_hdr), &decoded_resp);
3873 EXPECT_EQ(rc, -EINVAL);
3874 // Allocated less than expected
3875 rc = decode_get_event_receiver_resp(
3876 response, PLDM_GET_EVENT_RECEIVER_MIN_RESP_BYTES - 1, &decoded_resp);
3877 EXPECT_EQ(rc, -EOVERFLOW);
3878 // Not supported protocol
3879 size_t transport_protocol_type_offset = hdrSize + 1;
3880 // Manually modify the transport_protocol_type to a not supported one
3881 responseMsg[transport_protocol_type_offset] = 1;
3882 rc = decode_get_event_receiver_resp(
3883 response, responseMsg.size() - sizeof(pldm_msg_hdr), &decoded_resp);
3884 EXPECT_EQ(rc, -ENOTSUP);
3885 }
3886 #endif
3887
TEST(SetEventReceiver,testGoodEncodeRequest)3888 TEST(SetEventReceiver, testGoodEncodeRequest)
3889 {
3890 uint8_t eventMessageGlobalEnable =
3891 PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC_KEEP_ALIVE;
3892 uint8_t transportProtocolType = PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP;
3893 uint8_t eventReceiverAddressInfo = 0x08;
3894 uint16_t heartbeatTimer = 0x78;
3895
3896 std::vector<uint8_t> requestMsg(hdrSize +
3897 PLDM_SET_EVENT_RECEIVER_REQ_BYTES);
3898 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3899 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
3900
3901 auto rc = encode_set_event_receiver_req(
3902 0, eventMessageGlobalEnable, transportProtocolType,
3903 eventReceiverAddressInfo, heartbeatTimer, request);
3904
3905 EXPECT_EQ(rc, PLDM_SUCCESS);
3906 struct pldm_set_event_receiver_req* req =
3907 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3908 reinterpret_cast<struct pldm_set_event_receiver_req*>(request->payload);
3909 EXPECT_EQ(eventMessageGlobalEnable, req->event_message_global_enable);
3910 EXPECT_EQ(transportProtocolType, req->transport_protocol_type);
3911 EXPECT_EQ(eventReceiverAddressInfo, req->event_receiver_address_info);
3912 EXPECT_EQ(heartbeatTimer, le16toh(req->heartbeat_timer));
3913 }
3914
TEST(SetEventReceiver,testBadEncodeRequest)3915 TEST(SetEventReceiver, testBadEncodeRequest)
3916 {
3917 uint8_t eventMessageGlobalEnable =
3918 PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC_KEEP_ALIVE;
3919 uint8_t transportProtocolType = PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP;
3920 uint8_t eventReceiverAddressInfo = 0x08;
3921 uint16_t heartbeatTimer = 0;
3922
3923 std::vector<uint8_t> requestMsg(hdrSize +
3924 PLDM_SET_EVENT_RECEIVER_REQ_BYTES);
3925 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3926 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
3927
3928 auto rc = encode_set_event_receiver_req(
3929 0, eventMessageGlobalEnable, transportProtocolType,
3930 eventReceiverAddressInfo, heartbeatTimer, request);
3931
3932 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3933 }
3934
TEST(SetEventReceiver,testGoodDecodeResponse)3935 TEST(SetEventReceiver, testGoodDecodeResponse)
3936 {
3937 std::array<uint8_t, hdrSize + PLDM_SET_EVENT_RECEIVER_RESP_BYTES>
3938 responseMsg{};
3939
3940 uint8_t retcompletion_code = 0;
3941 responseMsg[hdrSize] = PLDM_SUCCESS;
3942
3943 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3944 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
3945 auto rc = decode_set_event_receiver_resp(
3946 response, responseMsg.size() - sizeof(pldm_msg_hdr),
3947 &retcompletion_code);
3948
3949 EXPECT_EQ(rc, PLDM_SUCCESS);
3950 EXPECT_EQ(PLDM_SUCCESS, retcompletion_code);
3951 }
3952
TEST(SetEventReceiver,testBadDecodeResponse)3953 TEST(SetEventReceiver, testBadDecodeResponse)
3954 {
3955 std::array<uint8_t, hdrSize + PLDM_SET_EVENT_RECEIVER_RESP_BYTES>
3956 responseMsg{};
3957 uint8_t retcompletion_code = 0;
3958 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3959 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
3960
3961 auto rc = decode_set_event_receiver_resp(
3962 response, responseMsg.size() - sizeof(pldm_msg_hdr), NULL);
3963
3964 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3965
3966 rc = decode_set_event_receiver_resp(
3967 nullptr, responseMsg.size() - sizeof(pldm_msg_hdr),
3968 &retcompletion_code);
3969
3970 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3971 }
3972
TEST(SetEventReceiver,testGoodEncodeResponse)3973 TEST(SetEventReceiver, testGoodEncodeResponse)
3974 {
3975 std::array<uint8_t,
3976 sizeof(pldm_msg_hdr) + PLDM_SET_EVENT_RECEIVER_RESP_BYTES>
3977 responseMsg{};
3978 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
3979 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
3980 uint8_t completionCode = 0;
3981
3982 auto rc = encode_set_event_receiver_resp(0, PLDM_SUCCESS, response);
3983
3984 EXPECT_EQ(rc, PLDM_SUCCESS);
3985 EXPECT_EQ(completionCode, response->payload[0]);
3986 }
3987
TEST(SetEventReceiver,testBadEncodeResponse)3988 TEST(SetEventReceiver, testBadEncodeResponse)
3989 {
3990 auto rc = encode_set_event_receiver_resp(0, PLDM_SUCCESS, NULL);
3991 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
3992 }
3993
TEST(SetEventReceiver,testGoodDecodeRequest)3994 TEST(SetEventReceiver, testGoodDecodeRequest)
3995 {
3996
3997 std::array<uint8_t, hdrSize + PLDM_SET_EVENT_RECEIVER_REQ_BYTES>
3998 requestMsg{};
3999
4000 uint8_t eventMessageGlobalEnable =
4001 PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC_KEEP_ALIVE;
4002 uint8_t transportProtocolType = PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP;
4003 uint8_t eventReceiverAddressInfo = 0x08;
4004 uint16_t heartbeatTimer = 0x78;
4005
4006 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
4007 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
4008 struct pldm_set_event_receiver_req* req =
4009 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
4010 reinterpret_cast<struct pldm_set_event_receiver_req*>(request->payload);
4011
4012 req->event_message_global_enable = eventMessageGlobalEnable;
4013 req->transport_protocol_type = transportProtocolType;
4014 req->event_receiver_address_info = eventReceiverAddressInfo;
4015 req->heartbeat_timer = htole16(heartbeatTimer);
4016
4017 uint8_t reteventMessageGlobalEnable;
4018 uint8_t rettransportProtocolType;
4019 uint8_t reteventReceiverAddressInfo;
4020 uint16_t retheartbeatTimer;
4021 auto rc = decode_set_event_receiver_req(
4022 request, requestMsg.size() - hdrSize, &reteventMessageGlobalEnable,
4023 &rettransportProtocolType, &reteventReceiverAddressInfo,
4024 &retheartbeatTimer);
4025
4026 EXPECT_EQ(rc, PLDM_SUCCESS);
4027 EXPECT_EQ(eventMessageGlobalEnable, reteventMessageGlobalEnable);
4028 EXPECT_EQ(transportProtocolType, rettransportProtocolType);
4029 EXPECT_EQ(eventReceiverAddressInfo, reteventReceiverAddressInfo);
4030 EXPECT_EQ(heartbeatTimer, retheartbeatTimer);
4031
4032 eventMessageGlobalEnable = PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC;
4033 req->event_message_global_enable = eventMessageGlobalEnable;
4034 rc = decode_set_event_receiver_req(
4035 request, PLDM_SET_EVENT_RECEIVER_MIN_REQ_BYTES,
4036 &reteventMessageGlobalEnable, &rettransportProtocolType,
4037 &reteventReceiverAddressInfo, &retheartbeatTimer);
4038 EXPECT_EQ(rc, PLDM_SUCCESS);
4039 EXPECT_EQ(eventMessageGlobalEnable, reteventMessageGlobalEnable);
4040 EXPECT_EQ(transportProtocolType, rettransportProtocolType);
4041 EXPECT_EQ(eventReceiverAddressInfo, reteventReceiverAddressInfo);
4042 }
4043
TEST(SetEventReceiver,testBadDecodeRequest)4044 TEST(SetEventReceiver, testBadDecodeRequest)
4045 {
4046 std::array<uint8_t, hdrSize + PLDM_SET_EVENT_RECEIVER_REQ_BYTES>
4047 requestMsg{};
4048
4049 auto rc = decode_set_event_receiver_req(NULL, requestMsg.size() - hdrSize,
4050 NULL, NULL, NULL, NULL);
4051 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
4052
4053 uint8_t eventMessageGlobalEnable =
4054 PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC_KEEP_ALIVE;
4055 uint8_t transportProtocolType = PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP;
4056 uint8_t eventReceiverAddressInfo = 0x08;
4057 uint16_t heartbeatTimer = 0x78;
4058
4059 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
4060 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
4061 struct pldm_set_event_receiver_req* req =
4062 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
4063 reinterpret_cast<struct pldm_set_event_receiver_req*>(request->payload);
4064
4065 req->event_message_global_enable = eventMessageGlobalEnable;
4066 req->transport_protocol_type = transportProtocolType;
4067 req->event_receiver_address_info = eventReceiverAddressInfo;
4068 req->heartbeat_timer = htole16(heartbeatTimer);
4069
4070 uint8_t reteventMessageGlobalEnable;
4071 uint8_t rettransportProtocolType;
4072 uint8_t reteventReceiverAddressInfo;
4073 uint16_t retheartbeatTimer;
4074
4075 rc = decode_set_event_receiver_req(
4076 request, requestMsg.size() - hdrSize - 1, &reteventMessageGlobalEnable,
4077 &rettransportProtocolType, &reteventReceiverAddressInfo,
4078 &retheartbeatTimer);
4079 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
4080
4081 req->event_message_global_enable = PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC;
4082 rc = decode_set_event_receiver_req(
4083 request, PLDM_SET_EVENT_RECEIVER_MIN_REQ_BYTES - 1,
4084 &reteventMessageGlobalEnable, &rettransportProtocolType,
4085 &reteventReceiverAddressInfo, &retheartbeatTimer);
4086 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
4087
4088 req->event_message_global_enable =
4089 PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC_KEEP_ALIVE;
4090 req->heartbeat_timer = 0;
4091 rc = decode_set_event_receiver_req(
4092 request, PLDM_SET_EVENT_RECEIVER_REQ_BYTES,
4093 &reteventMessageGlobalEnable, &rettransportProtocolType,
4094 &reteventReceiverAddressInfo, &retheartbeatTimer);
4095 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
4096 }
4097
TEST(decodeNumericSensorPdrData,Uint8Test)4098 TEST(decodeNumericSensorPdrData, Uint8Test)
4099 {
4100 std::vector<uint8_t> pdr1{
4101 0x1,
4102 0x0,
4103 0x0,
4104 0x0, // record handle
4105 0x1, // PDRHeaderVersion
4106 PLDM_NUMERIC_SENSOR_PDR, // PDRType
4107 0x0,
4108 0x0, // recordChangeNumber
4109 PLDM_PDR_NUMERIC_SENSOR_PDR_MIN_LENGTH,
4110 0, // dataLength
4111 0,
4112 0, // PLDMTerminusHandle
4113 0x1,
4114 0x0, // sensorID=1
4115 PLDM_ENTITY_POWER_SUPPLY,
4116 0, // entityType=Power Supply(120)
4117 1,
4118 0, // entityInstanceNumber
4119 1,
4120 0, // containerID=1
4121 PLDM_NO_INIT, // sensorInit
4122 false, // sensorAuxiliaryNamesPDR
4123 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
4124 0, // unitModifier
4125 0, // rateUnit
4126 0, // baseOEMUnitHandle
4127 0, // auxUnit
4128 0, // auxUnitModifier
4129 0, // auxRateUnit
4130 0, // rel
4131 0, // auxOEMUnitHandle
4132 true, // isLinear
4133 PLDM_SENSOR_DATA_SIZE_UINT8, // sensorDataSize
4134 0,
4135 0,
4136 0xc0,
4137 0x3f, // resolution=1.5
4138 0,
4139 0,
4140 0x80,
4141 0x3f, // offset=1.0
4142 0,
4143 0, // accuracy
4144 0, // plusTolerance
4145 0, // minusTolerance
4146 3, // hysteresis = 3
4147 0, // supportedThresholds
4148 0, // thresholdAndHysteresisVolatility
4149 0,
4150 0,
4151 0x80,
4152 0x3f, // stateTransistionInterval=1.0
4153 0,
4154 0,
4155 0x80,
4156 0x3f, // updateInverval=1.0
4157 255, // maxReadable
4158 0, // minReadable
4159 PLDM_RANGE_FIELD_FORMAT_UINT8, // rangeFieldFormat
4160 0, // rangeFieldsupport
4161 50, // nominalValue = 50
4162 60, // normalMax = 60
4163 40, // normalMin = 40
4164 70, // warningHigh = 70
4165 30, // warningLow = 30
4166 80, // criticalHigh = 80
4167 20, // criticalLow = 20
4168 90, // fatalHigh = 90
4169 10 // fatalLow = 10
4170 };
4171
4172 struct pldm_numeric_sensor_value_pdr decodedPdr;
4173 auto rc =
4174 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
4175 EXPECT_EQ(PLDM_SUCCESS, rc);
4176 EXPECT_EQ(1, decodedPdr.hdr.record_handle);
4177 EXPECT_EQ(1, decodedPdr.hdr.version);
4178 EXPECT_EQ(PLDM_NUMERIC_SENSOR_PDR, decodedPdr.hdr.type);
4179 EXPECT_EQ(0, decodedPdr.hdr.record_change_num);
4180 EXPECT_EQ(PLDM_PDR_NUMERIC_SENSOR_PDR_MIN_LENGTH, decodedPdr.hdr.length);
4181 EXPECT_EQ(1, decodedPdr.sensor_id);
4182 EXPECT_EQ(PLDM_ENTITY_POWER_SUPPLY, decodedPdr.entity_type);
4183 EXPECT_EQ(1, decodedPdr.entity_instance_num);
4184 EXPECT_EQ(1, decodedPdr.container_id);
4185 EXPECT_EQ(PLDM_NO_INIT, decodedPdr.sensor_init);
4186 EXPECT_EQ(false, decodedPdr.sensor_auxiliary_names_pdr);
4187 EXPECT_EQ(PLDM_SENSOR_UNIT_DEGRESS_C, decodedPdr.base_unit);
4188 EXPECT_EQ(0, decodedPdr.unit_modifier);
4189 EXPECT_EQ(0, decodedPdr.rate_unit);
4190 EXPECT_EQ(0, decodedPdr.base_oem_unit_handle);
4191 EXPECT_EQ(0, decodedPdr.aux_unit);
4192 EXPECT_EQ(0, decodedPdr.aux_unit_modifier);
4193 EXPECT_EQ(0, decodedPdr.aux_rate_unit);
4194 EXPECT_EQ(0, decodedPdr.rel);
4195 EXPECT_EQ(0, decodedPdr.aux_oem_unit_handle);
4196 EXPECT_EQ(true, decodedPdr.is_linear);
4197 EXPECT_EQ(PLDM_SENSOR_DATA_SIZE_UINT8, decodedPdr.sensor_data_size);
4198 EXPECT_FLOAT_EQ(1.5f, decodedPdr.resolution);
4199 EXPECT_FLOAT_EQ(1.0f, decodedPdr.offset);
4200 EXPECT_EQ(0, decodedPdr.accuracy);
4201 EXPECT_EQ(0, decodedPdr.plus_tolerance);
4202 EXPECT_EQ(0, decodedPdr.minus_tolerance);
4203 EXPECT_EQ(3, decodedPdr.hysteresis.value_u8);
4204 EXPECT_EQ(0, decodedPdr.supported_thresholds.byte);
4205 EXPECT_EQ(0, decodedPdr.threshold_and_hysteresis_volatility.byte);
4206 EXPECT_FLOAT_EQ(1.0f, decodedPdr.state_transition_interval);
4207 EXPECT_FLOAT_EQ(1.0f, decodedPdr.update_interval);
4208 EXPECT_EQ(255, decodedPdr.max_readable.value_u8);
4209 EXPECT_EQ(0, decodedPdr.min_readable.value_u8);
4210 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_UINT8, decodedPdr.range_field_format);
4211 EXPECT_EQ(0, decodedPdr.range_field_support.byte);
4212 EXPECT_EQ(50, decodedPdr.nominal_value.value_u8);
4213 EXPECT_EQ(60, decodedPdr.normal_max.value_u8);
4214 EXPECT_EQ(40, decodedPdr.normal_min.value_u8);
4215 EXPECT_EQ(70, decodedPdr.warning_high.value_u8);
4216 EXPECT_EQ(30, decodedPdr.warning_low.value_u8);
4217 EXPECT_EQ(80, decodedPdr.critical_high.value_u8);
4218 EXPECT_EQ(20, decodedPdr.critical_low.value_u8);
4219 EXPECT_EQ(90, decodedPdr.fatal_high.value_u8);
4220 EXPECT_EQ(10, decodedPdr.fatal_low.value_u8);
4221 }
4222
TEST(decodeNumericSensorPdrData,Sint8Test)4223 TEST(decodeNumericSensorPdrData, Sint8Test)
4224 {
4225 std::vector<uint8_t> pdr1{
4226 0x1,
4227 0x0,
4228 0x0,
4229 0x0, // record handle
4230 0x1, // PDRHeaderVersion
4231 PLDM_NUMERIC_SENSOR_PDR, // PDRType
4232 0x0,
4233 0x0, // recordChangeNumber
4234 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH +
4235 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH +
4236 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH,
4237 0, // dataLength
4238 0,
4239 0, // PLDMTerminusHandle
4240 0x1,
4241 0x0, // sensorID=1
4242 PLDM_ENTITY_POWER_SUPPLY,
4243 0, // entityType=Power Supply(120)
4244 1,
4245 0, // entityInstanceNumber
4246 0x1,
4247 0x0, // containerID=1
4248 PLDM_NO_INIT, // sensorInit
4249 false, // sensorAuxiliaryNamesPDR
4250 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
4251 0, // unitModifier
4252 0, // rateUnit
4253 0, // baseOEMUnitHandle
4254 0, // auxUnit
4255 0, // auxUnitModifier
4256 0, // auxRateUnit
4257 0, // rel
4258 0, // auxOEMUnitHandle
4259 true, // isLinear
4260 PLDM_RANGE_FIELD_FORMAT_SINT8, // sensorDataSize
4261 0,
4262 0,
4263 0,
4264 0, // resolution
4265 0,
4266 0,
4267 0,
4268 0, // offset
4269 0,
4270 0, // accuracy
4271 0, // plusTolerance
4272 0, // minusTolerance
4273 3, // hysteresis = 3
4274 0, // supportedThresholds
4275 0, // thresholdAndHysteresisVolatility
4276 0,
4277 0,
4278 0x80,
4279 0x3f, // stateTransistionInterval=1.0
4280 0,
4281 0,
4282 0x80,
4283 0x3f, // updateInverval=1.0
4284 0x64, // maxReadable = 100
4285 0x9c, // minReadable = -100
4286 PLDM_RANGE_FIELD_FORMAT_SINT8, // rangeFieldFormat
4287 0, // rangeFieldsupport
4288 0, // nominalValue = 0
4289 5, // normalMax = 5
4290 0xfb, // normalMin = -5
4291 10, // warningHigh = 10
4292 0xf6, // warningLow = -10
4293 20, // criticalHigh = 20
4294 0xec, // criticalLow = -20
4295 30, // fatalHigh = 30
4296 0xe2 // fatalLow = -30
4297 };
4298
4299 struct pldm_numeric_sensor_value_pdr decodedPdr;
4300 auto rc =
4301 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
4302 EXPECT_EQ(PLDM_SUCCESS, rc);
4303
4304 EXPECT_EQ(PLDM_SENSOR_DATA_SIZE_SINT8, decodedPdr.sensor_data_size);
4305 EXPECT_EQ(100, decodedPdr.max_readable.value_s8);
4306 EXPECT_EQ(-100, decodedPdr.min_readable.value_s8);
4307 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_SINT8, decodedPdr.range_field_format);
4308 EXPECT_EQ(0, decodedPdr.nominal_value.value_s8);
4309 EXPECT_EQ(5, decodedPdr.normal_max.value_s8);
4310 EXPECT_EQ(-5, decodedPdr.normal_min.value_s8);
4311 EXPECT_EQ(10, decodedPdr.warning_high.value_s8);
4312 EXPECT_EQ(-10, decodedPdr.warning_low.value_s8);
4313 EXPECT_EQ(20, decodedPdr.critical_high.value_s8);
4314 EXPECT_EQ(-20, decodedPdr.critical_low.value_s8);
4315 EXPECT_EQ(30, decodedPdr.fatal_high.value_s8);
4316 EXPECT_EQ(-30, decodedPdr.fatal_low.value_s8);
4317 }
4318
TEST(decodeNumericSensorPdrData,Uint16Test)4319 TEST(decodeNumericSensorPdrData, Uint16Test)
4320 {
4321 std::vector<uint8_t> pdr1{
4322 0x1,
4323 0x0,
4324 0x0,
4325 0x0, // record handle
4326 0x1, // PDRHeaderVersion
4327 PLDM_NUMERIC_SENSOR_PDR, // PDRType
4328 0x0,
4329 0x0, // recordChangeNumber
4330 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH +
4331 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH * 2 +
4332 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 2,
4333 0, // dataLength
4334 0,
4335 0, // PLDMTerminusHandle
4336 0x1,
4337 0x0, // sensorID=1
4338 PLDM_ENTITY_POWER_SUPPLY,
4339 0, // entityType=Power Supply(120)
4340 1,
4341 0, // entityInstanceNumber
4342 0x1,
4343 0x0, // containerID=1
4344 PLDM_NO_INIT, // sensorInit
4345 false, // sensorAuxiliaryNamesPDR
4346 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
4347 0, // unitModifier
4348 0, // rateUnit
4349 0, // baseOEMUnitHandle
4350 0, // auxUnit
4351 0, // auxUnitModifier
4352 0, // auxRateUnit
4353 0, // rel
4354 0, // auxOEMUnitHandle
4355 true, // isLinear
4356 PLDM_SENSOR_DATA_SIZE_UINT16, // sensorDataSize
4357 0,
4358 0,
4359 0,
4360 0, // resolution
4361 0,
4362 0,
4363 0,
4364 0, // offset
4365 0,
4366 0, // accuracy
4367 0, // plusTolerance
4368 0, // minusTolerance
4369 3,
4370 0, // hysteresis = 3
4371 0, // supportedThresholds
4372 0, // thresholdAndHysteresisVolatility
4373 0,
4374 0,
4375 0x80,
4376 0x3f, // stateTransistionInterval=1.0
4377 0,
4378 0,
4379 0x80,
4380 0x3f, // updateInverval=1.0
4381 0,
4382 0x10, // maxReadable = 4096
4383 0,
4384 0, // minReadable = 0
4385 PLDM_RANGE_FIELD_FORMAT_UINT16, // rangeFieldFormat
4386 0, // rangeFieldsupport
4387 0x88,
4388 0x13, // nominalValue = 5,000
4389 0x70,
4390 0x17, // normalMax = 6,000
4391 0xa0,
4392 0x0f, // normalMin = 4,000
4393 0x58,
4394 0x1b, // warningHigh = 7,000
4395 0xb8,
4396 0x0b, // warningLow = 3,000
4397 0x40,
4398 0x1f, // criticalHigh = 8,000
4399 0xd0,
4400 0x07, // criticalLow = 2,000
4401 0x28,
4402 0x23, // fatalHigh = 9,000
4403 0xe8,
4404 0x03 // fatalLow = 1,000
4405 };
4406
4407 struct pldm_numeric_sensor_value_pdr decodedPdr;
4408 auto rc =
4409 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
4410 EXPECT_EQ(PLDM_SUCCESS, rc);
4411
4412 EXPECT_EQ(PLDM_SENSOR_DATA_SIZE_UINT16, decodedPdr.sensor_data_size);
4413 EXPECT_EQ(4096, decodedPdr.max_readable.value_u16);
4414 EXPECT_EQ(0, decodedPdr.min_readable.value_u16);
4415 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_UINT16, decodedPdr.range_field_format);
4416 EXPECT_EQ(5000, decodedPdr.nominal_value.value_u16);
4417 EXPECT_EQ(6000, decodedPdr.normal_max.value_u16);
4418 EXPECT_EQ(4000, decodedPdr.normal_min.value_u16);
4419 EXPECT_EQ(7000, decodedPdr.warning_high.value_u16);
4420 EXPECT_EQ(3000, decodedPdr.warning_low.value_u16);
4421 EXPECT_EQ(8000, decodedPdr.critical_high.value_u16);
4422 EXPECT_EQ(2000, decodedPdr.critical_low.value_u16);
4423 EXPECT_EQ(9000, decodedPdr.fatal_high.value_u16);
4424 EXPECT_EQ(1000, decodedPdr.fatal_low.value_u16);
4425 }
4426
TEST(decodeNumericSensorPdrData,Sint16Test)4427 TEST(decodeNumericSensorPdrData, Sint16Test)
4428 {
4429 std::vector<uint8_t> pdr1{
4430 0x1,
4431 0x0,
4432 0x0,
4433 0x0, // record handle
4434 0x1, // PDRHeaderVersion
4435 PLDM_NUMERIC_SENSOR_PDR, // PDRType
4436 0x0,
4437 0x0, // recordChangeNumber
4438 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH +
4439 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH * 2 +
4440 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 2,
4441 0, // dataLength
4442 0,
4443 0, // PLDMTerminusHandle
4444 0x1,
4445 0x0, // sensorID=1
4446 PLDM_ENTITY_POWER_SUPPLY,
4447 0, // entityType=Power Supply(120)
4448 1,
4449 0, // entityInstanceNumber
4450 0x1,
4451 0x0, // containerID=1
4452 PLDM_NO_INIT, // sensorInit
4453 false, // sensorAuxiliaryNamesPDR
4454 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
4455 0, // unitModifier
4456 0, // rateUnit
4457 0, // baseOEMUnitHandle
4458 0, // auxUnit
4459 0, // auxUnitModifier
4460 0, // auxRateUnit
4461 0, // rel
4462 0, // auxOEMUnitHandle
4463 true, // isLinear
4464 PLDM_SENSOR_DATA_SIZE_SINT16, // sensorDataSize
4465 0,
4466 0,
4467 0,
4468 0, // resolution
4469 0,
4470 0,
4471 0,
4472 0, // offset
4473 0,
4474 0, // accuracy
4475 0, // plusTolerance
4476 0, // minusTolerance
4477 3,
4478 0, // hysteresis
4479 0, // supportedThresholds
4480 0, // thresholdAndHysteresisVolatility
4481 0,
4482 0,
4483 0x80,
4484 0x3f, // stateTransistionInterval=1.0
4485 0,
4486 0,
4487 0x80,
4488 0x3f, // updateInverval=1.0
4489 0xe8,
4490 0x03, // maxReadable = 1000
4491 0x18,
4492 0xfc, // minReadable = -1000
4493 PLDM_RANGE_FIELD_FORMAT_SINT16, // rangeFieldFormat
4494 0, // rangeFieldsupport
4495 0,
4496 0, // nominalValue = 0
4497 0xf4,
4498 0x01, // normalMax = 500
4499 0x0c,
4500 0xfe, // normalMin = -500
4501 0xe8,
4502 0x03, // warningHigh = 1,000
4503 0x18,
4504 0xfc, // warningLow = -1,000
4505 0xd0,
4506 0x07, // criticalHigh = 2,000
4507 0x30,
4508 0xf8, // criticalLow = -2,000
4509 0xb8,
4510 0x0b, // fatalHigh = 3,000
4511 0x48,
4512 0xf4 // fatalLow = -3,000
4513 };
4514
4515 struct pldm_numeric_sensor_value_pdr decodedPdr;
4516 auto rc =
4517 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
4518 EXPECT_EQ(PLDM_SUCCESS, rc);
4519
4520 EXPECT_EQ(PLDM_SENSOR_DATA_SIZE_SINT16, decodedPdr.sensor_data_size);
4521 EXPECT_EQ(1000, decodedPdr.max_readable.value_s16);
4522 EXPECT_EQ(-1000, decodedPdr.min_readable.value_s16);
4523 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_SINT16, decodedPdr.range_field_format);
4524 EXPECT_EQ(0, decodedPdr.nominal_value.value_s16);
4525 EXPECT_EQ(500, decodedPdr.normal_max.value_s16);
4526 EXPECT_EQ(-500, decodedPdr.normal_min.value_s16);
4527 EXPECT_EQ(1000, decodedPdr.warning_high.value_s16);
4528 EXPECT_EQ(-1000, decodedPdr.warning_low.value_s16);
4529 EXPECT_EQ(2000, decodedPdr.critical_high.value_s16);
4530 EXPECT_EQ(-2000, decodedPdr.critical_low.value_s16);
4531 EXPECT_EQ(3000, decodedPdr.fatal_high.value_s16);
4532 EXPECT_EQ(-3000, decodedPdr.fatal_low.value_s16);
4533 }
4534
TEST(decodeNumericSensorPdrData,Uint32Test)4535 TEST(decodeNumericSensorPdrData, Uint32Test)
4536 {
4537 std::vector<uint8_t> pdr1{
4538 0x1,
4539 0x0,
4540 0x0,
4541 0x0, // record handle
4542 0x1, // PDRHeaderVersion
4543 PLDM_NUMERIC_SENSOR_PDR, // PDRType
4544 0x0,
4545 0x0, // recordChangeNumber
4546 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH +
4547 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH * 4 +
4548 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 4,
4549 0, // dataLength
4550 0,
4551 0, // PLDMTerminusHandle
4552 0x1,
4553 0x0, // sensorID=1
4554 PLDM_ENTITY_POWER_SUPPLY,
4555 0, // entityType=Power Supply(120)
4556 1,
4557 0, // entityInstanceNumber
4558 0x1,
4559 0x0, // containerID=1
4560 PLDM_NO_INIT, // sensorInit
4561 false, // sensorAuxiliaryNamesPDR
4562 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
4563 0, // unitModifier
4564 0, // rateUnit
4565 0, // baseOEMUnitHandle
4566 0, // auxUnit
4567 0, // auxUnitModifier
4568 0, // auxRateUnit
4569 0, // rel
4570 0, // auxOEMUnitHandle
4571 true, // isLinear
4572 PLDM_SENSOR_DATA_SIZE_UINT32, // sensorDataSize
4573 0,
4574 0,
4575 0,
4576 0, // resolution
4577 0,
4578 0,
4579 0,
4580 0, // offset
4581 0,
4582 0, // accuracy
4583 0, // plusTolerance
4584 0, // minusTolerance
4585 3,
4586 0,
4587 0,
4588 0, // hysteresis
4589 0, // supportedThresholds
4590 0, // thresholdAndHysteresisVolatility
4591 0,
4592 0,
4593 0x80,
4594 0x3f, // stateTransistionInterval=1.0
4595 0,
4596 0,
4597 0x80,
4598 0x3f, // updateInverval=1.0
4599 0,
4600 0x10,
4601 0,
4602 0, // maxReadable = 4096
4603 0,
4604 0,
4605 0,
4606 0, // minReadable = 0
4607 PLDM_RANGE_FIELD_FORMAT_UINT32, // rangeFieldFormat
4608 0, // rangeFieldsupport
4609 0x40,
4610 0x4b,
4611 0x4c,
4612 0x00, // nominalValue = 5,000,000
4613 0x80,
4614 0x8d,
4615 0x5b,
4616 0x00, // normalMax = 6,000,000
4617 0x00,
4618 0x09,
4619 0x3d,
4620 0x00, // normalMin = 4,000,000
4621 0xc0,
4622 0xcf,
4623 0x6a,
4624 0x00, // warningHigh = 7,000,000
4625 0xc0,
4626 0xc6,
4627 0x2d,
4628 0x00, // warningLow = 3,000,000
4629 0x00,
4630 0x12,
4631 0x7a,
4632 0x00, // criticalHigh = 8,000,000
4633 0x80,
4634 0x84,
4635 0x1e,
4636 0x00, // criticalLow = 2,000,000
4637 0x40,
4638 0x54,
4639 0x89,
4640 0x00, // fatalHigh = 9,000,000
4641 0x40,
4642 0x42,
4643 0x0f,
4644 0x00 // fatalLow = 1,000,000
4645 };
4646
4647 struct pldm_numeric_sensor_value_pdr decodedPdr;
4648 auto rc =
4649 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
4650 EXPECT_EQ(PLDM_SUCCESS, rc);
4651
4652 EXPECT_EQ(PLDM_SENSOR_DATA_SIZE_UINT32, decodedPdr.sensor_data_size);
4653 EXPECT_EQ(4096, decodedPdr.max_readable.value_u32);
4654 EXPECT_EQ(0, decodedPdr.min_readable.value_u32);
4655 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_UINT32, decodedPdr.range_field_format);
4656 EXPECT_EQ(5000000, decodedPdr.nominal_value.value_u32);
4657 EXPECT_EQ(6000000, decodedPdr.normal_max.value_u32);
4658 EXPECT_EQ(4000000, decodedPdr.normal_min.value_u32);
4659 EXPECT_EQ(7000000, decodedPdr.warning_high.value_u32);
4660 EXPECT_EQ(3000000, decodedPdr.warning_low.value_u32);
4661 EXPECT_EQ(8000000, decodedPdr.critical_high.value_u32);
4662 EXPECT_EQ(2000000, decodedPdr.critical_low.value_u32);
4663 EXPECT_EQ(9000000, decodedPdr.fatal_high.value_u32);
4664 EXPECT_EQ(1000000, decodedPdr.fatal_low.value_u32);
4665 }
4666
TEST(decodeNumericSensorPdrData,Sint32Test)4667 TEST(decodeNumericSensorPdrData, Sint32Test)
4668 {
4669 std::vector<uint8_t> pdr1{
4670 0x1,
4671 0x0,
4672 0x0,
4673 0x0, // record handle
4674 0x1, // PDRHeaderVersion
4675 PLDM_NUMERIC_SENSOR_PDR, // PDRType
4676 0x0,
4677 0x0, // recordChangeNumber
4678 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH +
4679 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH * 4 +
4680 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 4,
4681 0, // dataLength
4682 0,
4683 0, // PLDMTerminusHandle
4684 0x1,
4685 0x0, // sensorID=1
4686 PLDM_ENTITY_POWER_SUPPLY,
4687 0, // entityType=Power Supply(120)
4688 1,
4689 0, // entityInstanceNumber
4690 0x1,
4691 0x0, // containerID=1
4692 PLDM_NO_INIT, // sensorInit
4693 false, // sensorAuxiliaryNamesPDR
4694 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
4695 0, // unitModifier
4696 0, // rateUnit
4697 0, // baseOEMUnitHandle
4698 0, // auxUnit
4699 0, // auxUnitModifier
4700 0, // auxRateUnit
4701 0, // rel
4702 0, // auxOEMUnitHandle
4703 true, // isLinear
4704 PLDM_SENSOR_DATA_SIZE_SINT32, // sensorDataSize
4705 0,
4706 0,
4707 0,
4708 0, // resolution
4709 0,
4710 0,
4711 0,
4712 0, // offset
4713 0,
4714 0, // accuracy
4715 0, // plusTolerance
4716 0, // minusTolerance
4717 3,
4718 0,
4719 0,
4720 0, // hysteresis
4721 0, // supportedThresholds
4722 0, // thresholdAndHysteresisVolatility
4723 0,
4724 0,
4725 0x80,
4726 0x3f, // stateTransistionInterval=1.0
4727 0,
4728 0,
4729 0x80,
4730 0x3f, // updateInverval=1.0
4731 0xa0,
4732 0x86,
4733 0x01,
4734 0x00, // maxReadable = 100000
4735 0x60,
4736 0x79,
4737 0xfe,
4738 0xff, // minReadable = -10000
4739 PLDM_RANGE_FIELD_FORMAT_SINT32, // rangeFieldFormat
4740 0, // rangeFieldsupport
4741 0,
4742 0,
4743 0,
4744 0, // nominalValue = 0
4745 0x20,
4746 0xa1,
4747 0x07,
4748 0x00, // normalMax = 500,000
4749 0xe0,
4750 0x5e,
4751 0xf8,
4752 0xff, // normalMin = -500,000
4753 0x40,
4754 0x42,
4755 0x0f,
4756 0x00, // warningHigh = 1,000,000
4757 0xc0,
4758 0xbd,
4759 0xf0,
4760 0xff, // warningLow = -1,000,000
4761 0x80,
4762 0x84,
4763 0x1e,
4764 0x00, // criticalHigh = 2,000,000
4765 0x80,
4766 0x7b,
4767 0xe1,
4768 0xff, // criticalLow = -2,000,000
4769 0xc0,
4770 0xc6,
4771 0x2d,
4772 0x00, // fatalHigh = 3,000,000
4773 0x40,
4774 0x39,
4775 0xd2,
4776 0xff // fatalLow = -3,000,000
4777 };
4778
4779 struct pldm_numeric_sensor_value_pdr decodedPdr;
4780 auto rc =
4781 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
4782 EXPECT_EQ(PLDM_SUCCESS, rc);
4783
4784 EXPECT_EQ(PLDM_SENSOR_DATA_SIZE_SINT32, decodedPdr.sensor_data_size);
4785 EXPECT_EQ(100000, decodedPdr.max_readable.value_s32);
4786 EXPECT_EQ(-100000, decodedPdr.min_readable.value_s32);
4787 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_SINT32, decodedPdr.range_field_format);
4788 EXPECT_EQ(0, decodedPdr.nominal_value.value_s32);
4789 EXPECT_EQ(500000, decodedPdr.normal_max.value_s32);
4790 EXPECT_EQ(-500000, decodedPdr.normal_min.value_s32);
4791 EXPECT_EQ(1000000, decodedPdr.warning_high.value_s32);
4792 EXPECT_EQ(-1000000, decodedPdr.warning_low.value_s32);
4793 EXPECT_EQ(2000000, decodedPdr.critical_high.value_s32);
4794 EXPECT_EQ(-2000000, decodedPdr.critical_low.value_s32);
4795 EXPECT_EQ(3000000, decodedPdr.fatal_high.value_s32);
4796 EXPECT_EQ(-3000000, decodedPdr.fatal_low.value_s32);
4797 }
4798
TEST(decodeNumericSensorPdrData,Real32Test)4799 TEST(decodeNumericSensorPdrData, Real32Test)
4800 {
4801 std::vector<uint8_t> pdr1{
4802 0x1,
4803 0x0,
4804 0x0,
4805 0x0, // record handle
4806 0x1, // PDRHeaderVersion
4807 PLDM_NUMERIC_SENSOR_PDR, // PDRType
4808 0x0,
4809 0x0, // recordChangeNumber
4810 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH +
4811 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH * 4 +
4812 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 4,
4813 0, // dataLength
4814 0,
4815 0, // PLDMTerminusHandle
4816 0x1,
4817 0x0, // sensorID=1
4818 PLDM_ENTITY_POWER_SUPPLY,
4819 0, // entityType=Power Supply(120)
4820 1,
4821 0, // entityInstanceNumber
4822 0x1,
4823 0x0, // containerID=1
4824 PLDM_NO_INIT, // sensorInit
4825 false, // sensorAuxiliaryNamesPDR
4826 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
4827 0, // unitModifier
4828 0, // rateUnit
4829 0, // baseOEMUnitHandle
4830 0, // auxUnit
4831 0, // auxUnitModifier
4832 0, // auxRateUnit
4833 0, // rel
4834 0, // auxOEMUnitHandle
4835 true, // isLinear
4836 PLDM_SENSOR_DATA_SIZE_SINT32, // sensorDataSize
4837 0,
4838 0,
4839 0,
4840 0, // resolution
4841 0,
4842 0,
4843 0,
4844 0, // offset
4845 0,
4846 0, // accuracy
4847 0, // plusTolerance
4848 0, // minusTolerance
4849 3,
4850 0,
4851 0,
4852 0, // hysteresis
4853 0, // supportedThresholds
4854 0, // thresholdAndHysteresisVolatility
4855 0,
4856 0,
4857 0x80,
4858 0x3f, // stateTransistionInterval=1.0
4859 0,
4860 0,
4861 0x80,
4862 0x3f, // updateInverval=1.0
4863 0xa0,
4864 0x86,
4865 0x01,
4866 0x00, // maxReadable = 100000
4867 0x60,
4868 0x79,
4869 0xfe,
4870 0xff, // minReadable = -10000
4871 PLDM_RANGE_FIELD_FORMAT_REAL32, // rangeFieldFormat
4872 0, // rangeFieldsupport
4873 0,
4874 0,
4875 0,
4876 0, // nominalValue = 0.0
4877 0x33,
4878 0x33,
4879 0x48,
4880 0x42, // normalMax = 50.05
4881 0x33,
4882 0x33,
4883 0x48,
4884 0xc2, // normalMin = -50.05
4885 0x83,
4886 0x00,
4887 0xc8,
4888 0x42, // warningHigh = 100.001
4889 0x83,
4890 0x00,
4891 0xc8,
4892 0xc2, // warningLow = -100.001
4893 0x83,
4894 0x00,
4895 0x48,
4896 0x43, // criticalHigh = 200.002
4897 0x83,
4898 0x00,
4899 0x48,
4900 0xc3, // criticalLow = -200.002
4901 0x62,
4902 0x00,
4903 0x96,
4904 0x43, // fatalHigh = 300.003
4905 0x62,
4906 0x00,
4907 0x96,
4908 0xc3 // fatalLow = -300.003
4909 };
4910
4911 struct pldm_numeric_sensor_value_pdr decodedPdr;
4912 auto rc =
4913 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
4914 EXPECT_EQ(PLDM_SUCCESS, rc);
4915
4916 EXPECT_EQ(PLDM_SENSOR_DATA_SIZE_SINT32, decodedPdr.sensor_data_size);
4917 EXPECT_EQ(100000, decodedPdr.max_readable.value_s32);
4918 EXPECT_EQ(-100000, decodedPdr.min_readable.value_s32);
4919 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_REAL32, decodedPdr.range_field_format);
4920 EXPECT_FLOAT_EQ(0, decodedPdr.nominal_value.value_f32);
4921 EXPECT_FLOAT_EQ(50.05f, decodedPdr.normal_max.value_f32);
4922 EXPECT_FLOAT_EQ(-50.05f, decodedPdr.normal_min.value_f32);
4923 EXPECT_FLOAT_EQ(100.001f, decodedPdr.warning_high.value_f32);
4924 EXPECT_FLOAT_EQ(-100.001f, decodedPdr.warning_low.value_f32);
4925 EXPECT_FLOAT_EQ(200.002f, decodedPdr.critical_high.value_f32);
4926 EXPECT_FLOAT_EQ(-200.002f, decodedPdr.critical_low.value_f32);
4927 EXPECT_FLOAT_EQ(300.003f, decodedPdr.fatal_high.value_f32);
4928 EXPECT_FLOAT_EQ(-300.003f, decodedPdr.fatal_low.value_f32);
4929 }
4930
TEST(decodeNumericSensorPdrDataDeathTest,InvalidSizeTest)4931 TEST(decodeNumericSensorPdrDataDeathTest, InvalidSizeTest)
4932 {
4933 // A corrupted PDR. The data after plusTolerance missed.
4934 std::vector<uint8_t> pdr1{
4935 0x1,
4936 0x0,
4937 0x0,
4938 0x0, // record handle
4939 0x1, // PDRHeaderVersion
4940 PLDM_NUMERIC_SENSOR_PDR, // PDRType
4941 0x0,
4942 0x0, // recordChangeNumber
4943 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH,
4944 0, // dataLength
4945 0,
4946 0, // PLDMTerminusHandle
4947 0x1,
4948 0x0, // sensorID=1
4949 PLDM_ENTITY_POWER_SUPPLY,
4950 0, // entityType=Power Supply(120)
4951 1,
4952 0, // entityInstanceNumber
4953 0x1,
4954 0x0, // containerID=1
4955 PLDM_NO_INIT, // sensorInit
4956 false, // sensorAuxiliaryNamesPDR
4957 2, // baseUint(2)=degrees C
4958 0, // unitModifier
4959 0, // rateUnit
4960 0, // baseOEMUnitHandle
4961 0, // auxUnit
4962 0, // auxUnitModifier
4963 0, // auxRateUnit
4964 0, // rel
4965 0, // auxOEMUnitHandle
4966 true, // isLinear
4967 PLDM_SENSOR_DATA_SIZE_UINT8, // sensorDataSize
4968 0,
4969 0,
4970 0,
4971 0, // resolution
4972 0,
4973 0,
4974 0,
4975 0, // offset
4976 0,
4977 0, // accuracy
4978 0 // plusTolerance
4979 };
4980
4981 struct pldm_numeric_sensor_value_pdr decodedPdr;
4982 int rc =
4983 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
4984 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
4985 }
4986
4987 #ifdef LIBPLDM_API_TESTING
TEST(decodeNumericEffecterPdrData,Uint8Test)4988 TEST(decodeNumericEffecterPdrData, Uint8Test)
4989 {
4990 std::vector<uint8_t> pdr1{
4991 0x1,
4992 0x0,
4993 0x0,
4994 0x0, // record handle
4995 0x1, // PDRHeaderVersion
4996 PLDM_NUMERIC_EFFECTER_PDR, // PDRType
4997 0x0,
4998 0x0, // recordChangeNumber
4999 PLDM_PDR_NUMERIC_EFFECTER_PDR_MIN_LENGTH,
5000 0, // dataLength
5001 0,
5002 0, // PLDMTerminusHandle
5003 0x1,
5004 0x0, // effecterID=1
5005 PLDM_ENTITY_POWER_SUPPLY,
5006 0, // entityType=Power Supply(120)
5007 1,
5008 0, // entityInstanceNumber
5009 1,
5010 0, // containerID=1
5011 0x2,
5012 0x0, // effecter_semantic_id=2
5013 PLDM_NO_INIT, // effecterInit
5014 false, // effecterAuxiliaryNames
5015 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
5016 0, // unitModifier
5017 0, // rateUnit
5018 0, // baseOEMUnitHandle
5019 0, // auxUnit
5020 0, // auxUnitModifier
5021 4, // auxRateUnit
5022 0, // auxOEMUnitHandle
5023 true, // isLinear
5024 PLDM_EFFECTER_DATA_SIZE_UINT8, // effecterDataSize
5025 0,
5026 0,
5027 0xc0,
5028 0x3f, // resolution=1.5
5029 0,
5030 0,
5031 0x80,
5032 0x3f, // offset=1.0
5033 0,
5034 0, // accuracy
5035 0, // plusTolerance
5036 0, // minusTolerance
5037 0,
5038 0,
5039 0x80,
5040 0x3f, // stateTransistionInterval=1.0
5041 0,
5042 0,
5043 0x80,
5044 0x3f, // transition_interval=1.0
5045 255, // maxSetdable
5046 0, // minSetable
5047 PLDM_RANGE_FIELD_FORMAT_UINT8, // rangeFieldFormat
5048 0x1f, // rangeFieldsupport
5049 50, // nominalValue = 50
5050 60, // normalMax = 60
5051 40, // normalMin = 40
5052 90, // rated_max = 90
5053 10 // rated_min = 10
5054 };
5055
5056 struct pldm_numeric_effecter_value_pdr decodedPdr;
5057 auto rc =
5058 decode_numeric_effecter_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
5059 EXPECT_EQ(PLDM_SUCCESS, rc);
5060 EXPECT_EQ(1, decodedPdr.hdr.record_handle);
5061 EXPECT_EQ(1, decodedPdr.hdr.version);
5062 EXPECT_EQ(PLDM_NUMERIC_EFFECTER_PDR, decodedPdr.hdr.type);
5063 EXPECT_EQ(0, decodedPdr.hdr.record_change_num);
5064 EXPECT_EQ(PLDM_PDR_NUMERIC_EFFECTER_PDR_MIN_LENGTH, decodedPdr.hdr.length);
5065 EXPECT_EQ(1, decodedPdr.effecter_id);
5066 EXPECT_EQ(PLDM_ENTITY_POWER_SUPPLY, decodedPdr.entity_type);
5067 EXPECT_EQ(1, decodedPdr.entity_instance);
5068 EXPECT_EQ(1, decodedPdr.container_id);
5069 EXPECT_EQ(2, decodedPdr.effecter_semantic_id);
5070 EXPECT_EQ(PLDM_NO_INIT, decodedPdr.effecter_init);
5071 EXPECT_EQ(false, decodedPdr.effecter_auxiliary_names);
5072 EXPECT_EQ(PLDM_SENSOR_UNIT_DEGRESS_C, decodedPdr.base_unit);
5073 EXPECT_EQ(0, decodedPdr.unit_modifier);
5074 EXPECT_EQ(0, decodedPdr.rate_unit);
5075 EXPECT_EQ(0, decodedPdr.base_oem_unit_handle);
5076 EXPECT_EQ(0, decodedPdr.aux_unit);
5077 EXPECT_EQ(0, decodedPdr.aux_unit_modifier);
5078 EXPECT_EQ(4, decodedPdr.aux_rate_unit);
5079 EXPECT_EQ(0, decodedPdr.aux_oem_unit_handle);
5080 EXPECT_EQ(true, decodedPdr.is_linear);
5081 EXPECT_EQ(PLDM_EFFECTER_DATA_SIZE_UINT8, decodedPdr.effecter_data_size);
5082 EXPECT_FLOAT_EQ(1.5f, decodedPdr.resolution);
5083 EXPECT_FLOAT_EQ(1.0f, decodedPdr.offset);
5084 EXPECT_EQ(0, decodedPdr.accuracy);
5085 EXPECT_EQ(0, decodedPdr.plus_tolerance);
5086 EXPECT_EQ(0, decodedPdr.minus_tolerance);
5087 EXPECT_FLOAT_EQ(1.0f, decodedPdr.state_transition_interval);
5088 EXPECT_FLOAT_EQ(1.0f, decodedPdr.transition_interval);
5089 EXPECT_EQ(255, decodedPdr.max_settable.value_u8);
5090 EXPECT_EQ(0, decodedPdr.min_settable.value_u8);
5091 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_UINT8, decodedPdr.range_field_format);
5092 EXPECT_EQ(0x1f, decodedPdr.range_field_support.byte);
5093 EXPECT_EQ(50, decodedPdr.nominal_value.value_u8);
5094 EXPECT_EQ(60, decodedPdr.normal_max.value_u8);
5095 EXPECT_EQ(40, decodedPdr.normal_min.value_u8);
5096 EXPECT_EQ(90, decodedPdr.rated_max.value_u8);
5097 EXPECT_EQ(10, decodedPdr.rated_min.value_u8);
5098 }
5099 #endif
5100
5101 #ifdef LIBPLDM_API_TESTING
TEST(decodeNumericEffecterPdrData,Sint8Test)5102 TEST(decodeNumericEffecterPdrData, Sint8Test)
5103 {
5104 std::vector<uint8_t> pdr1{
5105 0x1,
5106 0x0,
5107 0x0,
5108 0x0, // record handle
5109 0x1, // PDRHeaderVersion
5110 PLDM_NUMERIC_EFFECTER_PDR, // PDRType
5111 0x0,
5112 0x0, // recordChangeNumber
5113 PLDM_PDR_NUMERIC_EFFECTER_PDR_FIXED_LENGTH +
5114 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_EFFECTER_DATA_SIZE_MIN_LENGTH +
5115 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_RANGE_FIELD_MIN_LENGTH,
5116 0, // dataLength
5117 0,
5118 0, // PLDMTerminusHandle
5119 0x1,
5120 0x0, // effecterID=1
5121 PLDM_ENTITY_POWER_SUPPLY,
5122 0, // entityType=Power Supply(120)
5123 1,
5124 0, // entityInstanceNumber
5125 0x1,
5126 0x0, // containerID=1
5127 0x2,
5128 0x0, // effecter_semantic_id=2
5129 PLDM_NO_INIT, // effecterInit
5130 false, // effecterAuxiliaryNames
5131 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
5132 0, // unitModifier
5133 0, // rateUnit
5134 0, // baseOEMUnitHandle
5135 0, // auxUnit
5136 0, // auxUnitModifier
5137 0, // auxRateUnit
5138 0, // auxOEMUnitHandle
5139 true, // isLinear
5140 PLDM_RANGE_FIELD_FORMAT_SINT8, // effecterDataSize
5141 0,
5142 0,
5143 0,
5144 0, // resolution
5145 0,
5146 0,
5147 0,
5148 0, // offset
5149 0,
5150 0, // accuracy
5151 0, // plusTolerance
5152 0, // minusTolerance
5153 0,
5154 0,
5155 0x80,
5156 0x3f, // stateTransistionInterval=1.0
5157 0,
5158 0,
5159 0x80,
5160 0x3f, // transition_interval=1.0
5161 0x64, // maxSetdable = 100
5162 0x9c, // minSetable = -100
5163 PLDM_RANGE_FIELD_FORMAT_SINT8, // rangeFieldFormat
5164 0x1f, // rangeFieldsupport
5165 0, // nominalValue = 0
5166 5, // normalMax = 5
5167 0xfb, // normalMin = -5
5168 30, // rated_max = 30
5169 0xe2 // rated_min = -30
5170 };
5171
5172 struct pldm_numeric_effecter_value_pdr decodedPdr;
5173 auto rc =
5174 decode_numeric_effecter_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
5175 EXPECT_EQ(PLDM_SUCCESS, rc);
5176
5177 EXPECT_EQ(PLDM_EFFECTER_DATA_SIZE_SINT8, decodedPdr.effecter_data_size);
5178 EXPECT_EQ(100, decodedPdr.max_settable.value_s8);
5179 EXPECT_EQ(-100, decodedPdr.min_settable.value_s8);
5180 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_SINT8, decodedPdr.range_field_format);
5181 EXPECT_EQ(0x1f, decodedPdr.range_field_support.byte);
5182 EXPECT_EQ(0, decodedPdr.nominal_value.value_s8);
5183 EXPECT_EQ(5, decodedPdr.normal_max.value_s8);
5184 EXPECT_EQ(-5, decodedPdr.normal_min.value_s8);
5185 EXPECT_EQ(30, decodedPdr.rated_max.value_s8);
5186 EXPECT_EQ(-30, decodedPdr.rated_min.value_s8);
5187 }
5188 #endif
5189
5190 #ifdef LIBPLDM_API_TESTING
TEST(decodeNumericEffecterPdrData,Uint16Test)5191 TEST(decodeNumericEffecterPdrData, Uint16Test)
5192 {
5193 std::vector<uint8_t> pdr1{
5194 0x1,
5195 0x0,
5196 0x0,
5197 0x0, // record handle
5198 0x1, // PDRHeaderVersion
5199 PLDM_NUMERIC_EFFECTER_PDR, // PDRType
5200 0x0,
5201 0x0, // recordChangeNumber
5202 PLDM_PDR_NUMERIC_EFFECTER_PDR_FIXED_LENGTH +
5203 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_EFFECTER_DATA_SIZE_MIN_LENGTH *
5204 2 +
5205 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 2,
5206 0, // dataLength
5207 0,
5208 0, // PLDMTerminusHandle
5209 0x1,
5210 0x0, // effecterID=1
5211 PLDM_ENTITY_POWER_SUPPLY,
5212 0, // entityType=Power Supply(120)
5213 1,
5214 0, // entityInstanceNumber
5215 0x1,
5216 0x0, // containerID=1
5217 0x2,
5218 0x0, // effecter_semantic_id=2
5219 PLDM_NO_INIT, // effecterInit
5220 false, // effecterAuxiliaryNames
5221 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
5222 0, // unitModifier
5223 0, // rateUnit
5224 0, // baseOEMUnitHandle
5225 0, // auxUnit
5226 0, // auxUnitModifier
5227 0, // auxRateUnit
5228 0, // auxOEMUnitHandle
5229 true, // isLinear
5230 PLDM_EFFECTER_DATA_SIZE_UINT16, // effecterDataSize
5231 0,
5232 0,
5233 0,
5234 0, // resolution
5235 0,
5236 0,
5237 0,
5238 0, // offset
5239 0,
5240 0, // accuracy
5241 0, // plusTolerance
5242 0, // minusTolerance
5243 0,
5244 0,
5245 0x80,
5246 0x3f, // stateTransistionInterval=1.0
5247 0,
5248 0,
5249 0x80,
5250 0x3f, // transition_interval=1.0
5251 0,
5252 0x10, // maxSetdable = 4096
5253 0,
5254 0, // minSetable = 0
5255 PLDM_RANGE_FIELD_FORMAT_UINT16, // rangeFieldFormat
5256 0x1f, // rangeFieldsupport
5257 0x88,
5258 0x13, // nominalValue = 5,000
5259 0x70,
5260 0x17, // normalMax = 6,000
5261 0xa0,
5262 0x0f, // normalMin = 4,000
5263 0x28,
5264 0x23, // rated_max = 9,000
5265 0xe8,
5266 0x03 // rated_min = 1,000
5267 };
5268
5269 struct pldm_numeric_effecter_value_pdr decodedPdr;
5270 auto rc =
5271 decode_numeric_effecter_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
5272 EXPECT_EQ(PLDM_SUCCESS, rc);
5273
5274 EXPECT_EQ(PLDM_EFFECTER_DATA_SIZE_UINT16, decodedPdr.effecter_data_size);
5275 EXPECT_EQ(4096, decodedPdr.max_settable.value_u16);
5276 EXPECT_EQ(0, decodedPdr.min_settable.value_u16);
5277 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_UINT16, decodedPdr.range_field_format);
5278 EXPECT_EQ(0x1f, decodedPdr.range_field_support.byte);
5279 EXPECT_EQ(5000, decodedPdr.nominal_value.value_u16);
5280 EXPECT_EQ(6000, decodedPdr.normal_max.value_u16);
5281 EXPECT_EQ(4000, decodedPdr.normal_min.value_u16);
5282 EXPECT_EQ(9000, decodedPdr.rated_max.value_u16);
5283 EXPECT_EQ(1000, decodedPdr.rated_min.value_u16);
5284 }
5285 #endif
5286
5287 #ifdef LIBPLDM_API_TESTING
TEST(decodeNumericEffecterPdrData,Sint16Test)5288 TEST(decodeNumericEffecterPdrData, Sint16Test)
5289 {
5290 std::vector<uint8_t> pdr1{
5291 0x1,
5292 0x0,
5293 0x0,
5294 0x0, // record handle
5295 0x1, // PDRHeaderVersion
5296 PLDM_NUMERIC_EFFECTER_PDR, // PDRType
5297 0x0,
5298 0x0, // recordChangeNumber
5299 PLDM_PDR_NUMERIC_EFFECTER_PDR_FIXED_LENGTH +
5300 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_EFFECTER_DATA_SIZE_MIN_LENGTH *
5301 2 +
5302 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 2,
5303 0, // dataLength
5304 0,
5305 0, // PLDMTerminusHandle
5306 0x1,
5307 0x0, // effecterID=1
5308 PLDM_ENTITY_POWER_SUPPLY,
5309 0, // entityType=Power Supply(120)
5310 1,
5311 0, // entityInstanceNumber
5312 0x1,
5313 0x0, // containerID=1
5314 0x2,
5315 0x0, // effecter_semantic_id=2
5316 PLDM_NO_INIT, // effecterInit
5317 false, // effecterAuxiliaryNames
5318 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
5319 0, // unitModifier
5320 0, // rateUnit
5321 0, // baseOEMUnitHandle
5322 0, // auxUnit
5323 0, // auxUnitModifier
5324 0, // auxRateUnit
5325 0, // auxOEMUnitHandle
5326 true, // isLinear
5327 PLDM_EFFECTER_DATA_SIZE_SINT16, // effecterDataSize
5328 0,
5329 0,
5330 0,
5331 0, // resolution
5332 0,
5333 0,
5334 0,
5335 0, // offset
5336 0,
5337 0, // accuracy
5338 0, // plusTolerance
5339 0, // minusTolerance
5340 0,
5341 0,
5342 0x80,
5343 0x3f, // stateTransistionInterval=1.0
5344 0,
5345 0,
5346 0x80,
5347 0x3f, // transition_interval=1.0
5348 0xe8,
5349 0x03, // maxSetdable = 1000
5350 0x18,
5351 0xfc, // minSetable = -1000
5352 PLDM_RANGE_FIELD_FORMAT_SINT16, // rangeFieldFormat
5353 0x1f, // rangeFieldsupport
5354 0,
5355 0, // nominalValue = 0
5356 0xf4,
5357 0x01, // normalMax = 500
5358 0x0c,
5359 0xfe, // normalMin = -500
5360 0xb8,
5361 0x0b, // rated_max = 3,000
5362 0x48,
5363 0xf4 // rated_min = -3,000
5364 };
5365
5366 struct pldm_numeric_effecter_value_pdr decodedPdr;
5367 auto rc =
5368 decode_numeric_effecter_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
5369 EXPECT_EQ(PLDM_SUCCESS, rc);
5370
5371 EXPECT_EQ(PLDM_EFFECTER_DATA_SIZE_SINT16, decodedPdr.effecter_data_size);
5372 EXPECT_EQ(1000, decodedPdr.max_settable.value_s16);
5373 EXPECT_EQ(-1000, decodedPdr.min_settable.value_s16);
5374 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_SINT16, decodedPdr.range_field_format);
5375 EXPECT_EQ(0x1f, decodedPdr.range_field_support.byte);
5376 EXPECT_EQ(0, decodedPdr.nominal_value.value_s16);
5377 EXPECT_EQ(500, decodedPdr.normal_max.value_s16);
5378 EXPECT_EQ(-500, decodedPdr.normal_min.value_s16);
5379 EXPECT_EQ(3000, decodedPdr.rated_max.value_s16);
5380 EXPECT_EQ(-3000, decodedPdr.rated_min.value_s16);
5381 }
5382 #endif
5383
5384 #ifdef LIBPLDM_API_TESTING
TEST(decodeNumericEffecterPdrData,Uint32Test)5385 TEST(decodeNumericEffecterPdrData, Uint32Test)
5386 {
5387 std::vector<uint8_t> pdr1{
5388 0x1,
5389 0x0,
5390 0x0,
5391 0x0, // record handle
5392 0x1, // PDRHeaderVersion
5393 PLDM_NUMERIC_EFFECTER_PDR, // PDRType
5394 0x0,
5395 0x0, // recordChangeNumber
5396 PLDM_PDR_NUMERIC_EFFECTER_PDR_FIXED_LENGTH +
5397 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_EFFECTER_DATA_SIZE_MIN_LENGTH *
5398 4 +
5399 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 4,
5400 0, // dataLength
5401 0,
5402 0, // PLDMTerminusHandle
5403 0x1,
5404 0x0, // effecterID=1
5405 PLDM_ENTITY_POWER_SUPPLY,
5406 0, // entityType=Power Supply(120)
5407 1,
5408 0, // entityInstanceNumber
5409 0x1,
5410 0x0, // containerID=1
5411 0x2,
5412 0x0, // effecter_semantic_id=2
5413 PLDM_NO_INIT, // effecterInit
5414 false, // effecterAuxiliaryNames
5415 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
5416 0, // unitModifier
5417 0, // rateUnit
5418 0, // baseOEMUnitHandle
5419 0, // auxUnit
5420 0, // auxUnitModifier
5421 0, // auxRateUnit
5422 0, // auxOEMUnitHandle
5423 true, // isLinear
5424 PLDM_EFFECTER_DATA_SIZE_UINT32, // effecterDataSize
5425 0,
5426 0,
5427 0,
5428 0, // resolution
5429 0,
5430 0,
5431 0,
5432 0, // offset
5433 0,
5434 0, // accuracy
5435 0, // plusTolerance
5436 0, // minusTolerance
5437 0,
5438 0,
5439 0x80,
5440 0x3f, // stateTransistionInterval=1.0
5441 0,
5442 0,
5443 0x80,
5444 0x3f, // transition_interval=1.0
5445 0,
5446 0x10,
5447 0,
5448 0, // maxSetdable = 4096
5449 0,
5450 0,
5451 0,
5452 0, // minSetable = 0
5453 PLDM_RANGE_FIELD_FORMAT_UINT32, // rangeFieldFormat
5454 0x1f, // rangeFieldsupport
5455 0x40,
5456 0x4b,
5457 0x4c,
5458 0x00, // nominalValue = 5,000,000
5459 0x80,
5460 0x8d,
5461 0x5b,
5462 0x00, // normalMax = 6,000,000
5463 0x00,
5464 0x09,
5465 0x3d,
5466 0x00, // normalMin = 4,000,000
5467 0x40,
5468 0x54,
5469 0x89,
5470 0x00, // rated_max = 9,000,000
5471 0x40,
5472 0x42,
5473 0x0f,
5474 0x00 // rated_min = 1,000,000
5475 };
5476
5477 struct pldm_numeric_effecter_value_pdr decodedPdr;
5478 auto rc =
5479 decode_numeric_effecter_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
5480 EXPECT_EQ(PLDM_SUCCESS, rc);
5481
5482 EXPECT_EQ(PLDM_EFFECTER_DATA_SIZE_UINT32, decodedPdr.effecter_data_size);
5483 EXPECT_EQ(4096, decodedPdr.max_settable.value_u32);
5484 EXPECT_EQ(0, decodedPdr.min_settable.value_u32);
5485 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_UINT32, decodedPdr.range_field_format);
5486 EXPECT_EQ(0x1f, decodedPdr.range_field_support.byte);
5487 EXPECT_EQ(5000000, decodedPdr.nominal_value.value_u32);
5488 EXPECT_EQ(6000000, decodedPdr.normal_max.value_u32);
5489 EXPECT_EQ(4000000, decodedPdr.normal_min.value_u32);
5490 EXPECT_EQ(9000000, decodedPdr.rated_max.value_u32);
5491 EXPECT_EQ(1000000, decodedPdr.rated_min.value_u32);
5492 }
5493 #endif
5494
5495 #ifdef LIBPLDM_API_TESTING
TEST(decodeNumericEffecterPdrData,Sint32Test)5496 TEST(decodeNumericEffecterPdrData, Sint32Test)
5497 {
5498 std::vector<uint8_t> pdr1{
5499 0x1,
5500 0x0,
5501 0x0,
5502 0x0, // record handle
5503 0x1, // PDRHeaderVersion
5504 PLDM_NUMERIC_EFFECTER_PDR, // PDRType
5505 0x0,
5506 0x0, // recordChangeNumber
5507 PLDM_PDR_NUMERIC_EFFECTER_PDR_FIXED_LENGTH +
5508 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_EFFECTER_DATA_SIZE_MIN_LENGTH *
5509 4 +
5510 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 4,
5511 0, // dataLength
5512 0,
5513 0, // PLDMTerminusHandle
5514 0x1,
5515 0x0, // effecterID=1
5516 PLDM_ENTITY_POWER_SUPPLY,
5517 0, // entityType=Power Supply(120)
5518 1,
5519 0, // entityInstanceNumber
5520 0x1,
5521 0x0, // containerID=1
5522 0x2,
5523 0x0, // effecter_semantic_id=2
5524 PLDM_NO_INIT, // effecterInit
5525 false, // effecterAuxiliaryNames
5526 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
5527 0, // unitModifier
5528 0, // rateUnit
5529 0, // baseOEMUnitHandle
5530 0, // auxUnit
5531 0, // auxUnitModifier
5532 0, // auxRateUnit
5533 0, // auxOEMUnitHandle
5534 true, // isLinear
5535 PLDM_EFFECTER_DATA_SIZE_SINT32, // effecterDataSize
5536 0,
5537 0,
5538 0,
5539 0, // resolution
5540 0,
5541 0,
5542 0,
5543 0, // offset
5544 0,
5545 0, // accuracy
5546 0, // plusTolerance
5547 0, // minusTolerance
5548 0,
5549 0,
5550 0x80,
5551 0x3f, // stateTransistionInterval=1.0
5552 0,
5553 0,
5554 0x80,
5555 0x3f, // transition_interval=1.0
5556 0xa0,
5557 0x86,
5558 0x01,
5559 0x00, // maxSetdable = 100000
5560 0x60,
5561 0x79,
5562 0xfe,
5563 0xff, // minSetable = -10000
5564 PLDM_RANGE_FIELD_FORMAT_SINT32, // rangeFieldFormat
5565 0x1f, // rangeFieldsupport
5566 0,
5567 0,
5568 0,
5569 0, // nominalValue = 0
5570 0x20,
5571 0xa1,
5572 0x07,
5573 0x00, // normalMax = 500,000
5574 0xe0,
5575 0x5e,
5576 0xf8,
5577 0xff, // normalMin = -500,000
5578 0xc0,
5579 0xc6,
5580 0x2d,
5581 0x00, // rated_max = 3,000,000
5582 0x40,
5583 0x39,
5584 0xd2,
5585 0xff // rated_min = -3,000,000
5586 };
5587
5588 struct pldm_numeric_effecter_value_pdr decodedPdr;
5589 auto rc =
5590 decode_numeric_effecter_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
5591 EXPECT_EQ(PLDM_SUCCESS, rc);
5592 EXPECT_EQ(PLDM_EFFECTER_DATA_SIZE_SINT32, decodedPdr.effecter_data_size);
5593 EXPECT_EQ(100000, decodedPdr.max_settable.value_s32);
5594 EXPECT_EQ(-100000, decodedPdr.min_settable.value_s32);
5595 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_SINT32, decodedPdr.range_field_format);
5596 EXPECT_EQ(0x1f, decodedPdr.range_field_support.byte);
5597 EXPECT_EQ(0, decodedPdr.nominal_value.value_s32);
5598 EXPECT_EQ(500000, decodedPdr.normal_max.value_s32);
5599 EXPECT_EQ(-500000, decodedPdr.normal_min.value_s32);
5600 EXPECT_EQ(3000000, decodedPdr.rated_max.value_s32);
5601 EXPECT_EQ(-3000000, decodedPdr.rated_min.value_s32);
5602 }
5603 #endif
5604
5605 #ifdef LIBPLDM_API_TESTING
TEST(decodeNumericEffecterPdrData,Real32Test)5606 TEST(decodeNumericEffecterPdrData, Real32Test)
5607 {
5608 std::vector<uint8_t> pdr1{
5609 0x1,
5610 0x0,
5611 0x0,
5612 0x0, // record handle
5613 0x1, // PDRHeaderVersion
5614 PLDM_NUMERIC_EFFECTER_PDR, // PDRType
5615 0x0,
5616 0x0, // recordChangeNumber
5617 PLDM_PDR_NUMERIC_EFFECTER_PDR_FIXED_LENGTH +
5618 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_EFFECTER_DATA_SIZE_MIN_LENGTH *
5619 4 +
5620 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 4,
5621 0, // dataLength
5622 0,
5623
5624 0, // PLDMTerminusHandle
5625 0x1,
5626 0x0, // effecterID=1
5627 PLDM_ENTITY_POWER_SUPPLY,
5628 0, // entityType=Power Supply(120)
5629 1,
5630 0, // entityInstanceNumber
5631 0x1,
5632 0x0, // containerID=1
5633 0x2,
5634 0x0, // effecter_semantic_id=2
5635 PLDM_NO_INIT, // effecterInit
5636 false, // effecterAuxiliaryNames
5637 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C
5638 0, // unitModifier
5639 0, // rateUnit
5640 0, // baseOEMUnitHandle
5641 0, // auxUnit
5642 0, // auxUnitModifier
5643 0, // auxRateUnit
5644 0, // auxOEMUnitHandle
5645 true, // isLinear
5646 PLDM_EFFECTER_DATA_SIZE_SINT32, // effecterDataSize
5647 0,
5648 0,
5649 0,
5650 0, // resolution
5651 0,
5652 0,
5653 0,
5654 0, // offset
5655 0,
5656 0, // accuracy
5657 0, // plusTolerance
5658 0, // minusTolerance
5659 0,
5660 0,
5661 0x80,
5662 0x3f, // stateTransistionInterval=1.0
5663 0,
5664 0,
5665 0x80,
5666 0x3f, // transition_interval=1.0
5667 0xa0,
5668 0x86,
5669 0x01,
5670 0x00, // maxSetdable = 100000
5671 0x60,
5672 0x79,
5673 0xfe,
5674 0xff, // minSetable = -10000
5675 PLDM_RANGE_FIELD_FORMAT_REAL32, // rangeFieldFormat
5676 0x1f, // rangeFieldsupport
5677 0,
5678 0,
5679 0,
5680 0, // nominalValue = 0.0
5681 0x33,
5682 0x33,
5683 0x48,
5684 0x42, // normalMax = 50.05
5685 0x33,
5686 0x33,
5687 0x48,
5688 0xc2, // normalMin = -50.05
5689 0x62,
5690 0x00,
5691 0x96,
5692 0x43, // rated_max = 300.003
5693 0x62,
5694 0x00,
5695 0x96,
5696 0xc3 // rated_min = -300.003
5697 };
5698
5699 struct pldm_numeric_effecter_value_pdr decodedPdr;
5700 auto rc =
5701 decode_numeric_effecter_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr);
5702 EXPECT_EQ(PLDM_SUCCESS, rc);
5703
5704 EXPECT_EQ(PLDM_EFFECTER_DATA_SIZE_SINT32, decodedPdr.effecter_data_size);
5705 EXPECT_FLOAT_EQ(1.0f, decodedPdr.state_transition_interval);
5706 EXPECT_FLOAT_EQ(1.0f, decodedPdr.transition_interval);
5707 EXPECT_EQ(100000, decodedPdr.max_settable.value_s32);
5708 EXPECT_EQ(-100000, decodedPdr.min_settable.value_s32);
5709 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_REAL32, decodedPdr.range_field_format);
5710 EXPECT_EQ(0x1f, decodedPdr.range_field_support.byte);
5711 EXPECT_FLOAT_EQ(0, decodedPdr.nominal_value.value_f32);
5712 EXPECT_FLOAT_EQ(50.05f, decodedPdr.normal_max.value_f32);
5713 EXPECT_FLOAT_EQ(-50.05f, decodedPdr.normal_min.value_f32);
5714 EXPECT_FLOAT_EQ(300.003f, decodedPdr.rated_max.value_f32);
5715 EXPECT_FLOAT_EQ(-300.003f, decodedPdr.rated_min.value_f32);
5716 }
5717 #endif
5718
TEST(GetStateEffecterStates,testEncodeAndDecodeRequest)5719 TEST(GetStateEffecterStates, testEncodeAndDecodeRequest)
5720 {
5721 std::array<uint8_t, hdrSize + PLDM_GET_STATE_EFFECTER_STATES_REQ_BYTES>
5722 requestMsg{};
5723
5724 constexpr std::array<uint8_t,
5725 hdrSize + PLDM_GET_STATE_EFFECTER_STATES_REQ_BYTES>
5726 expectedRequestMsg{
5727 {0x80, PLDM_PLATFORM, PLDM_GET_STATE_EFFECTER_STATES, 1, 0xab}};
5728
5729 constexpr uint16_t effecter_id = 0xab01;
5730
5731 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
5732 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
5733
5734 auto rc = encode_get_state_effecter_states_req(
5735 0, effecter_id, request, PLDM_GET_STATE_EFFECTER_STATES_REQ_BYTES);
5736
5737 EXPECT_EQ(rc, PLDM_SUCCESS);
5738 EXPECT_EQ(requestMsg, expectedRequestMsg);
5739
5740 uint16_t ret_effecter_id;
5741
5742 rc = decode_get_state_effecter_states_req(
5743 request, requestMsg.size() - hdrSize, &ret_effecter_id);
5744
5745 EXPECT_EQ(rc, PLDM_SUCCESS);
5746 EXPECT_EQ(effecter_id, ret_effecter_id);
5747
5748 // Test invalid length decode request
5749
5750 rc = decode_get_state_effecter_states_req(
5751 request, requestMsg.size() - hdrSize - 1, &ret_effecter_id);
5752
5753 EXPECT_EQ(rc, -EOVERFLOW);
5754 }
5755
TEST(GetStateEffecterStates,testBadEncodeRequest)5756 TEST(GetStateEffecterStates, testBadEncodeRequest)
5757 {
5758 std::vector<uint8_t> requestMsg(hdrSize +
5759 PLDM_GET_STATE_EFFECTER_STATES_REQ_BYTES);
5760
5761 auto rc = encode_get_state_effecter_states_req(
5762 0, 0, nullptr, PLDM_GET_STATE_EFFECTER_STATES_REQ_BYTES);
5763 EXPECT_EQ(rc, -EINVAL);
5764 }
5765
TEST(GetStateEffecterStates,testBadDecodeRequest)5766 TEST(GetStateEffecterStates, testBadDecodeRequest)
5767 {
5768 std::array<uint8_t, hdrSize + PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES>
5769 requestMsg{};
5770
5771 auto rc = decode_get_state_effecter_states_req(
5772 nullptr, requestMsg.size() - hdrSize, nullptr);
5773
5774 EXPECT_EQ(rc, -EINVAL);
5775 }
5776
TEST(GetStateEffecterStates,testEncodeAndDecodeResponse)5777 TEST(GetStateEffecterStates, testEncodeAndDecodeResponse)
5778 {
5779 constexpr uint8_t comp_effecterCnt = 0x2;
5780 constexpr uint8_t completionCode = 0;
5781 std::array<uint8_t,
5782 hdrSize + PLDM_GET_STATE_EFFECTER_STATES_MIN_RESP_BYTES +
5783 PLDM_GET_EFFECTER_STATE_FIELD_SIZE * comp_effecterCnt>
5784 expectedResponseMsg{{0, PLDM_PLATFORM, PLDM_GET_STATE_EFFECTER_STATES,
5785 completionCode, comp_effecterCnt,
5786 EFFECTER_OPER_STATE_ENABLED_NOUPDATEPENDING, 2, 2,
5787 EFFECTER_OPER_STATE_ENABLED_UPDATEPENDING, 2, 3}};
5788
5789 decltype(expectedResponseMsg) responseMsg{};
5790
5791 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
5792 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
5793
5794 std::array<get_effecter_state_field, comp_effecterCnt> stateField{
5795 {{EFFECTER_OPER_STATE_ENABLED_NOUPDATEPENDING, 2, 2},
5796 {EFFECTER_OPER_STATE_ENABLED_UPDATEPENDING, 2, 3}}};
5797
5798 struct pldm_get_state_effecter_states_resp resp_fields{
5799 PLDM_SUCCESS, comp_effecterCnt, {stateField[0], stateField[1]}};
5800
5801 auto rc = encode_get_state_effecter_states_resp(
5802 0, &resp_fields, response, responseMsg.size() - hdrSize);
5803
5804 EXPECT_EQ(rc, PLDM_SUCCESS);
5805 EXPECT_EQ(expectedResponseMsg, responseMsg);
5806
5807 struct pldm_get_state_effecter_states_resp ret_resp_fields;
5808
5809 rc = decode_get_state_effecter_states_resp(
5810 response, responseMsg.size() - hdrSize, &ret_resp_fields);
5811
5812 EXPECT_EQ(rc, PLDM_SUCCESS);
5813 EXPECT_EQ(completionCode, ret_resp_fields.completion_code);
5814 EXPECT_EQ(comp_effecterCnt, ret_resp_fields.comp_effecter_count);
5815 EXPECT_EQ(stateField[0].effecter_op_state,
5816 ret_resp_fields.field[0].effecter_op_state);
5817 EXPECT_EQ(stateField[0].pending_state,
5818 ret_resp_fields.field[0].pending_state);
5819 EXPECT_EQ(stateField[0].present_state,
5820 ret_resp_fields.field[0].present_state);
5821 EXPECT_EQ(stateField[1].effecter_op_state,
5822 ret_resp_fields.field[1].effecter_op_state);
5823 EXPECT_EQ(stateField[1].pending_state,
5824 ret_resp_fields.field[1].pending_state);
5825 EXPECT_EQ(stateField[1].present_state,
5826 ret_resp_fields.field[1].present_state);
5827
5828 // Test invalid length decode
5829
5830 rc = decode_get_state_effecter_states_resp(
5831 response,
5832 responseMsg.size() - hdrSize + PLDM_GET_EFFECTER_STATE_FIELD_SIZE,
5833 &ret_resp_fields);
5834
5835 EXPECT_EQ(rc, -EBADMSG);
5836 }
5837
TEST(GetStateEffecterStates,testBadEncodeResponse)5838 TEST(GetStateEffecterStates, testBadEncodeResponse)
5839 {
5840 struct pldm_get_state_effecter_states_resp resp{PLDM_SUCCESS, 0, {}};
5841 auto rc = decode_get_state_effecter_states_resp(nullptr, 0, &resp);
5842
5843 EXPECT_EQ(rc, -EINVAL);
5844 }
5845
TEST(GetStateEffecterStates,testBadDecodeResponse)5846 TEST(GetStateEffecterStates, testBadDecodeResponse)
5847 {
5848 std::array<uint8_t, hdrSize +
5849 PLDM_GET_STATE_EFFECTER_STATES_MIN_RESP_BYTES +
5850 PLDM_GET_EFFECTER_STATE_FIELD_SIZE * 2>
5851 responseMsg{};
5852
5853 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
5854 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data());
5855
5856 auto rc = decode_get_state_effecter_states_resp(
5857 response, responseMsg.size() - hdrSize, nullptr);
5858
5859 EXPECT_EQ(rc, -EINVAL);
5860 }
5861
str16len(char16_t * startptr)5862 [[maybe_unused]] static size_t str16len(char16_t* startptr)
5863 {
5864 char16_t* endptr = startptr;
5865 while (*endptr)
5866 {
5867 endptr++;
5868 }
5869 return endptr - startptr;
5870 }
5871
TEST(decodeEntityAuxNamePdrData,GoodTest)5872 TEST(decodeEntityAuxNamePdrData, GoodTest)
5873 {
5874 std::vector<uint8_t> pdr1{
5875 // Common PDR Header
5876 0x1, 0x0, 0x0, 0x0, // record handle
5877 0x1, // PDRHeaderVersion
5878 PLDM_ENTITY_AUXILIARY_NAMES_PDR, // PDRType
5879 0x1,
5880 0x0, // recordChangeNumber
5881 0x27,
5882 0, // dataLength
5883 /* Entity Auxiliary Names PDR Data*/
5884 3,
5885 0, // entityType system software
5886 0x1,
5887 0x0, // Entity instance number =1
5888 PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID,
5889 0, // Overal system
5890 0, // shared Name Count one name only
5891 03, // nameStringCount
5892 0x65, 0x6e, 0x00, // Language Tag "en"
5893 0x00, 0x53, 0x00, 0x30, 0x00, 0x53, 0x00, 0x00, // Entity Name "S0S"
5894 0x66, 0x6e, 0x00, // Language Tag "en"
5895 0x00, 0x53, 0x00, 0x31, 0x00, 0x00, // Entity Name "S1"
5896 0x67, 0x6e, 0x00, // Language Tag "en"
5897 0x00, 0x52, 0x00, 0x52, 0x00, 0x33, 0x00, 0x00 // Entity Name "RR3"
5898 };
5899
5900 const char expectTag0[] = {0x65, 0x6e, 0x00};
5901 const char expectTag1[] = {0x66, 0x6e, 0x00};
5902 const char expectTag2[] = {0x67, 0x6e, 0x00};
5903 const char expectName0[] = {0x00, 0x53, 0x00, 0x30, 0x00, 0x53, 0x00, 0x00};
5904 const char expectName1[] = {0x00, 0x53, 0x00, 0x31, 0x00, 0x00};
5905 const char expectName2[] = {0x00, 0x52, 0x00, 0x52, 0x00, 0x33, 0x00, 0x00};
5906 auto names_offset = sizeof(struct pldm_pdr_hdr) +
5907 PLDM_PDR_ENTITY_AUXILIARY_NAME_PDR_MIN_LENGTH;
5908 auto names_size = pdr1.size() - names_offset;
5909 size_t length = 0;
5910
5911 size_t decodedPdrSize =
5912 sizeof(struct pldm_entity_auxiliary_names_pdr) + names_size;
5913 auto decodedPdr =
5914 (struct pldm_entity_auxiliary_names_pdr*)malloc(decodedPdrSize);
5915 EXPECT_NE(nullptr, decodedPdr);
5916
5917 auto rc = decode_entity_auxiliary_names_pdr(pdr1.data(), pdr1.size(),
5918 decodedPdr, decodedPdrSize);
5919
5920 EXPECT_EQ(0, rc);
5921 EXPECT_EQ(1, decodedPdr->hdr.record_handle);
5922 EXPECT_EQ(1, decodedPdr->hdr.version);
5923 EXPECT_EQ(PLDM_ENTITY_AUXILIARY_NAMES_PDR, decodedPdr->hdr.type);
5924 EXPECT_EQ(1, decodedPdr->hdr.record_change_num);
5925 EXPECT_EQ(pdr1.size() - sizeof(struct pldm_pdr_hdr),
5926 decodedPdr->hdr.length);
5927 EXPECT_EQ(3, decodedPdr->container.entity_type);
5928 EXPECT_EQ(1, decodedPdr->container.entity_instance_num);
5929 EXPECT_EQ(PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID,
5930 decodedPdr->container.entity_container_id);
5931 EXPECT_EQ(0, decodedPdr->shared_name_count);
5932 EXPECT_EQ(3, decodedPdr->name_string_count);
5933
5934 decodedPdr->names = (struct pldm_entity_auxiliary_name*)calloc(
5935 decodedPdr->name_string_count,
5936 sizeof(struct pldm_entity_auxiliary_name));
5937 EXPECT_NE(nullptr, decodedPdr->names);
5938
5939 rc = decode_pldm_entity_auxiliary_names_pdr_index(decodedPdr);
5940 EXPECT_EQ(0, rc);
5941
5942 length = strlen(decodedPdr->names[0].tag);
5943 EXPECT_EQ(strlen(expectTag0), length);
5944 EXPECT_EQ(strncmp(expectTag0, decodedPdr->names[0].tag, length + 1), 0);
5945
5946 // NOLINTBEGIN(clang-analyzer-unix.Malloc)
5947 ASSERT_EQ(0,
5948 (uintptr_t)decodedPdr->names[0].name & (alignof(char16_t) - 1));
5949 // NOLINTEND(clang-analyzer-unix.Malloc)
5950 length = str16len((char16_t*)decodedPdr->names[0].name);
5951 EXPECT_EQ(str16len((char16_t*)expectName0), length);
5952 EXPECT_EQ(3, str16len((char16_t*)expectName0));
5953 EXPECT_EQ(memcmp(expectName0, decodedPdr->names[0].name,
5954 sizeof(char16_t) * (length + 1)),
5955 0);
5956
5957 length = strlen(decodedPdr->names[1].tag);
5958 EXPECT_EQ(strlen(expectTag1), length);
5959 EXPECT_EQ(strncmp(expectTag1, decodedPdr->names[1].tag, length + 1), 0);
5960
5961 // NOLINTBEGIN(clang-analyzer-unix.Malloc)
5962 ASSERT_EQ(0,
5963 (uintptr_t)decodedPdr->names[1].name & (alignof(char16_t) - 1));
5964 // NOLINTEND(clang-analyzer-unix.Malloc)
5965 length = str16len((char16_t*)decodedPdr->names[1].name);
5966 EXPECT_EQ(str16len((char16_t*)expectName1), length);
5967 EXPECT_EQ(2, str16len((char16_t*)expectName1));
5968 EXPECT_EQ(memcmp(expectName1, decodedPdr->names[1].name,
5969 sizeof(char16_t) * (length + 1)),
5970 0);
5971
5972 length = strlen(decodedPdr->names[2].tag);
5973 EXPECT_EQ(strlen(expectTag2), length);
5974 EXPECT_EQ(strncmp(expectTag2, decodedPdr->names[2].tag, length + 1), 0);
5975
5976 // NOLINTBEGIN(clang-analyzer-unix.Malloc)
5977 ASSERT_EQ(0,
5978 (uintptr_t)decodedPdr->names[2].name & (alignof(char16_t) - 1));
5979 // NOLINTEND(clang-analyzer-unix.Malloc)
5980 length = str16len((char16_t*)decodedPdr->names[2].name);
5981 EXPECT_EQ(str16len((char16_t*)expectName2), length);
5982 EXPECT_EQ(3, str16len((char16_t*)expectName2));
5983 EXPECT_EQ(memcmp(expectName2, decodedPdr->names[2].name,
5984 sizeof(char16_t) * (length + 1)),
5985 0);
5986
5987 free(decodedPdr->names);
5988 free(decodedPdr);
5989 }
5990
TEST(decodeEntityAuxNamePdrData,BadTest)5991 TEST(decodeEntityAuxNamePdrData, BadTest)
5992 {
5993 std::vector<uint8_t> pdr1{
5994 // Common PDR Header
5995 0x1, 0x0, 0x0, 0x0, // record handle
5996 0x1, // PDRHeaderVersion
5997 PLDM_ENTITY_AUXILIARY_NAMES_PDR, // PDRType
5998 0x1,
5999 0x0, // recordChangeNumber
6000 0x25, // correct size is 0x27, input invalid size
6001 0, // dataLength
6002 /* Entity Auxiliary Names PDR Data*/
6003 3,
6004 0, // entityType system software
6005 0x1,
6006 0x0, // Entity instance number =1
6007 PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID,
6008 0, // Overal system
6009 0, // shared Name Count one name only
6010 0, // Invalid nameStringCount
6011 0x65, 0x6e, 0x00, // Language Tag "en"
6012 0x00, 0x53, 0x00, 0x30, 0x00, 0x53, 0x00, 0x00, // Entity Name "S0S"
6013 0x66, 0x6e, 0x00, // Language Tag "en"
6014 0x00, 0x53, 0x00, 0x31, 0x00, 0x00, // Entity Name "S1"
6015 0x67, 0x6e, 0x00, // Language Tag "en"
6016 0x00, 0x52, 0x00, 0x52, 0x00, 0x33, 0x00, 0x00 // Entity Name "RR3"
6017 };
6018
6019 auto names_offset = sizeof(struct pldm_pdr_hdr) +
6020 PLDM_PDR_ENTITY_AUXILIARY_NAME_PDR_MIN_LENGTH;
6021 auto names_size = pdr1.size() - names_offset;
6022
6023 size_t decodedPdrSize =
6024 sizeof(struct pldm_entity_auxiliary_names_pdr) + names_size;
6025 auto decodedPdr =
6026 (struct pldm_entity_auxiliary_names_pdr*)malloc(decodedPdrSize);
6027
6028 auto rc = decode_entity_auxiliary_names_pdr(pdr1.data(), pdr1.size(),
6029 decodedPdr, decodedPdrSize);
6030
6031 EXPECT_EQ(-EBADMSG, rc);
6032 free(decodedPdr);
6033 }
6034
TEST(PlatformEventMessage,testGoodCperEventDataDecodeRequest)6035 TEST(PlatformEventMessage, testGoodCperEventDataDecodeRequest)
6036 {
6037 constexpr const size_t eventDataSize = 4;
6038 constexpr const size_t eventSize =
6039 PLDM_PLATFORM_CPER_EVENT_MIN_LENGTH + eventDataSize;
6040 std::array<uint8_t, eventSize> eventData{
6041 0x1, // format version
6042 0x0, // format type
6043 0x4, 0x0, // event data length
6044 0x44, 0x33, 0x22, 0x11 // data
6045 };
6046
6047 uint8_t expectedFormatVersion = 1;
6048 uint8_t expectedFormatType = 0;
6049 uint16_t expectedEventDataLength = 4;
6050 uint8_t expectCperEventData[] = {0x44, 0x33, 0x22, 0x11};
6051
6052 size_t cperEventSize =
6053 sizeof(struct pldm_platform_cper_event) + eventDataSize;
6054 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
6055 auto cper_event = reinterpret_cast<struct pldm_platform_cper_event*>(
6056 malloc(cperEventSize));
6057
6058 auto rc = decode_pldm_platform_cper_event(
6059 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
6060 reinterpret_cast<const void*>(eventData.data()), eventData.size(),
6061 cper_event, cperEventSize);
6062
6063 EXPECT_EQ(rc, 0);
6064 EXPECT_EQ(cper_event->format_version, expectedFormatVersion);
6065 EXPECT_EQ(cper_event->format_type, expectedFormatType);
6066 EXPECT_EQ(cper_event->event_data_length, expectedEventDataLength);
6067
6068 auto cperEventData = pldm_platform_cper_event_event_data(cper_event);
6069 EXPECT_NE(cperEventData, nullptr);
6070 if (cperEventData)
6071 {
6072 EXPECT_EQ(0, memcmp(expectCperEventData, cperEventData,
6073 expectedEventDataLength));
6074 }
6075
6076 free(cper_event);
6077 }
6078
TEST(PlatformEventMessage,testBadCperEventDataDecodeRequest)6079 TEST(PlatformEventMessage, testBadCperEventDataDecodeRequest)
6080 {
6081
6082 constexpr const size_t eventDataSize = 4;
6083 constexpr const size_t eventSize =
6084 PLDM_PLATFORM_CPER_EVENT_MIN_LENGTH + eventDataSize;
6085 std::array<uint8_t, eventSize> eventData{
6086 0x1, // format version
6087 0x0, // format type
6088 0x4, 0x0, // event data length
6089 0x44, 0x33, 0x22, 0x11 // data
6090 };
6091
6092 size_t cperEventSize =
6093 sizeof(struct pldm_platform_cper_event) + eventDataSize;
6094 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
6095 auto cperEvent = reinterpret_cast<struct pldm_platform_cper_event*>(
6096 malloc(cperEventSize));
6097
6098 auto rc = decode_pldm_platform_cper_event(NULL, eventData.size(), cperEvent,
6099 cperEventSize);
6100 EXPECT_EQ(rc, -EINVAL);
6101
6102 rc = decode_pldm_platform_cper_event(
6103 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
6104 reinterpret_cast<const void*>(eventData.data()), eventData.size(), NULL,
6105 cperEventSize);
6106 EXPECT_EQ(rc, -EINVAL);
6107
6108 rc = decode_pldm_platform_cper_event(
6109 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
6110 reinterpret_cast<uint8_t*>(eventData.data()), eventData.size() - 1,
6111 cperEvent, cperEventSize);
6112 EXPECT_EQ(rc, -EOVERFLOW);
6113
6114 rc = decode_pldm_platform_cper_event(
6115 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
6116 reinterpret_cast<uint8_t*>(eventData.data()), eventData.size(),
6117 cperEvent, cperEventSize - 1);
6118 EXPECT_EQ(rc, -EOVERFLOW);
6119
6120 rc = decode_pldm_platform_cper_event(
6121 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
6122 reinterpret_cast<uint8_t*>(eventData.data()), eventData.size(),
6123 cperEvent, cperEventSize + 1);
6124 EXPECT_EQ(rc, 0);
6125
6126 // Invalid CPER Event Format Type
6127 eventData[1] = 0x2;
6128 rc = decode_pldm_platform_cper_event(
6129 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
6130 reinterpret_cast<const void*>(eventData.data()), eventData.size(),
6131 cperEvent, cperEventSize);
6132
6133 EXPECT_EQ(rc, -EPROTO);
6134
6135 // Invalid cper event data size
6136 eventData[1] = 0x1;
6137 eventData[2] = 3;
6138 rc = decode_pldm_platform_cper_event(
6139 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
6140 reinterpret_cast<const void*>(eventData.data()), eventData.size(),
6141 cperEvent, cperEventSize);
6142
6143 EXPECT_EQ(rc, -EBADMSG);
6144
6145 eventData[2] = 5;
6146 rc = decode_pldm_platform_cper_event(
6147 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
6148 reinterpret_cast<const void*>(eventData.data()), eventData.size(),
6149 cperEvent, cperEventSize);
6150
6151 EXPECT_EQ(rc, -EOVERFLOW);
6152
6153 free(cperEvent);
6154 }
6155
6156 #ifdef LIBPLDM_API_TESTING
TEST(decodePldmFileDescriptorPdr,oemFileClassificationPresentTest)6157 TEST(decodePldmFileDescriptorPdr, oemFileClassificationPresentTest)
6158 {
6159 std::vector<uint8_t> pdr1{
6160 // Common PDR Header
6161 0x01, 0x0, 0x0, 0x0, // Record Handle
6162 0x01, // PDR Header Version
6163 PLDM_FILE_DESCRIPTOR_PDR, // PDRType
6164 0x01, 0x00, // Record Change Number
6165 0x2A, 0x00, // Data Length = 42 bytes
6166 /* PLDM File Descriptor PDR Data*/
6167 0x01, 0x00, // Terminus Handle = 0x01
6168 0x01, 0x00, // File Identifier = 0x01
6169 0x09, 0x00, // Entity Type = Physical | Device File
6170 0x01, 0x00, // Entity instance number = 1
6171 PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID,
6172 0, // Container ID = Overall system
6173 0x02, 0, // Supper Dir File Identifier = 0x0002
6174 0x01, // File Classification = 0x01 (BootLog)
6175 0x01, // OEM File Classification = 0x01
6176 0x15, 0x00, // File Capabilities = 0x0015
6177 0xff, 0xff, 0xff, 0xff, // File Version = 0xffffffff (Unversioned)
6178 0x00, 0x28, 0x00, 0x00, // File Maximum Size = 10KB
6179 0x02, // File Maximum File Descriptor count = 2
6180 0x06, // File Name Length = 6
6181 0x46, 0x69, 0x6C, 0x65, 0x31,
6182 0x00, // File Name = "File1\NULL"
6183 0x09, // OEM File Classification Name Length = 9
6184 0x4F, 0x45, 0x4D, 0x20, 0x46, 0x69, 0x6C, 0x65,
6185 0x00 // OEM File Classification Name = "OEM File\NULL"
6186 };
6187
6188 const char expectFileName[] = "File1";
6189 const char expectOEMClassificationName[] = "OEM File";
6190
6191 struct pldm_file_descriptor_pdr decodedPdr = {};
6192
6193 auto rc =
6194 decode_pldm_file_descriptor_pdr(pdr1.data(), pdr1.size(), &decodedPdr);
6195
6196 ASSERT_EQ(0, rc);
6197 EXPECT_EQ(1, decodedPdr.terminus_handle);
6198 EXPECT_EQ(1, decodedPdr.file_identifier);
6199 EXPECT_EQ(9, decodedPdr.container.entity_type);
6200 EXPECT_EQ(1, decodedPdr.container.entity_instance_num);
6201 EXPECT_EQ(PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID,
6202 decodedPdr.container.entity_container_id);
6203 EXPECT_EQ(2, decodedPdr.superior_directory_file_identifier);
6204 EXPECT_EQ(1, decodedPdr.file_classification);
6205 EXPECT_EQ(1, decodedPdr.oem_file_classification);
6206 EXPECT_EQ(21, decodedPdr.file_capabilities.value);
6207 EXPECT_EQ(0xff, decodedPdr.file_version.alpha);
6208 EXPECT_EQ(0xff, decodedPdr.file_version.update);
6209 EXPECT_EQ(0xff, decodedPdr.file_version.minor);
6210 EXPECT_EQ(0xff, decodedPdr.file_version.major);
6211 EXPECT_EQ(10240, decodedPdr.file_maximum_size);
6212 EXPECT_EQ(2, decodedPdr.file_maximum_file_descriptor_count);
6213 EXPECT_EQ(6, decodedPdr.file_name.length);
6214
6215 EXPECT_EQ(memcmp(expectFileName, decodedPdr.file_name.ptr,
6216 sizeof(char) * decodedPdr.file_name.length),
6217 0);
6218
6219 if (decodedPdr.oem_file_classification)
6220 {
6221 EXPECT_EQ(9, decodedPdr.oem_file_classification_name.length);
6222 EXPECT_EQ(memcmp(expectOEMClassificationName,
6223 decodedPdr.oem_file_classification_name.ptr,
6224 sizeof(char) *
6225 decodedPdr.oem_file_classification_name.length),
6226 0);
6227 }
6228 }
6229 #endif
6230
6231 #ifdef LIBPLDM_API_TESTING
TEST(decodePldmFileDescriptorPdr,BadTestUnAllocatedPtrParams)6232 TEST(decodePldmFileDescriptorPdr, BadTestUnAllocatedPtrParams)
6233 {
6234 int rc;
6235 std::vector<uint8_t> pdr1{
6236 // Common PDR Header
6237 0x01, 0x0, 0x0, 0x0, // Record Handle
6238 0x01, // PDR Header Version
6239 PLDM_FILE_DESCRIPTOR_PDR, // PDRType
6240 0x01, 0x00, // Record Change Number
6241 0x20, 0x00, // Data Length = 32 bytes
6242 /* PLDM File Descriptor PDR Data*/
6243 0x01, 0x00, // Terminus Handle = 0x01
6244 0x01, 0x00, // File Identifier = 0x01
6245 0x09, 0x00, // Entity Type = Physical | Device File
6246 0x01, 0x00, // Entity instance number = 1
6247 PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID,
6248 0, // Container ID = Overall system
6249 0x02, 0, // Supper Dir File Identifier = 0x0002
6250 0x01, // File Classification = 0x01 (BootLog)
6251 0x00, // OEM File Classification = 0x00
6252 0x15, 0x00, // File Capabilities = 0x0015
6253 0xff, 0xff, 0xff, 0xff, // File Version = 0xffffffff (Unversioned)
6254 0x00, 0x28, 0x00, 0x00, // File Maximum Size = 10KB
6255 0x02, // File Maximum File Descriptor count = 2
6256 0x06, // File Name Length = 6
6257 0x46, 0x69, 0x6C, 0x65, 0x31,
6258 0x00, // File Name = "File1\NULL"
6259 };
6260
6261 struct pldm_file_descriptor_pdr decodedPdr = {};
6262
6263 rc = decode_pldm_file_descriptor_pdr(nullptr, pdr1.size(), &decodedPdr);
6264 EXPECT_EQ(-EINVAL, rc);
6265
6266 rc = decode_pldm_file_descriptor_pdr(pdr1.data(), pdr1.size(), nullptr);
6267 EXPECT_EQ(-EINVAL, rc);
6268 }
6269 #endif
6270
6271 #ifdef LIBPLDM_API_TESTING
TEST(decodePldmFileDescriptorPdr,BadTestInvalidExpectedParamLength)6272 TEST(decodePldmFileDescriptorPdr, BadTestInvalidExpectedParamLength)
6273 {
6274 int rc;
6275
6276 std::vector<uint8_t> pdr1{
6277 // Common PDR Header
6278 0x01, 0x0, 0x0, 0x0, // Record Handle
6279 0x01, // PDR Header Version
6280 PLDM_FILE_DESCRIPTOR_PDR, // PDRType
6281 0x01, 0x00, // Record Change Number
6282 0x20, 0x00, // Data Length = 32 bytes
6283 /* PLDM File Descriptor PDR Data*/
6284 0x01, 0x00, // Terminus Handle = 0x01
6285 0x01, 0x00, // File Identifier = 0x01
6286 0x09, 0x00, // Entity Type = Physical | Device File
6287 0x01, 0x00, // Entity instance number = 1
6288 PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID,
6289 0, // Container ID = Overall system
6290 0x02, 0, // Supper Dir File Identifier = 0x0002
6291 0x01, // File Classification = 0x01 (BootLog)
6292 0x00, // OEM File Classification = 0x00
6293 0x15, 0x00, // File Capabilities = 0x0015
6294 0xff, 0xff, 0xff, 0xff, // File Version = 0xffffffff (Unversioned)
6295 0x00, 0x28, 0x00, 0x00, // File Maximum Size = 10KB
6296 0x02, // File Maximum File Descriptor count = 2
6297 0x06, // File Name Length = 6
6298 0x46, 0x69, 0x6C, 0x65, 0x31,
6299 0x00, // File Name = "File1\NULL"
6300 };
6301
6302 struct pldm_file_descriptor_pdr decodedPdr = {};
6303
6304 /* Expect error: Invalid input data length*/
6305 rc = decode_pldm_file_descriptor_pdr(pdr1.data(), 1, &decodedPdr);
6306 EXPECT_EQ(-EOVERFLOW, rc);
6307 }
6308 #endif
6309
6310 #ifdef LIBPLDM_API_TESTING
TEST(decodePldmFileDescriptorPdr,BadTestDataBufferOverLength)6311 TEST(decodePldmFileDescriptorPdr, BadTestDataBufferOverLength)
6312 {
6313 int rc;
6314
6315 /*Un-matched File Name Length*/
6316 std::vector<uint8_t> pdr1{
6317 // Common PDR Header
6318 0x01, 0x0, 0x0, 0x0, // Record Handle
6319 0x01, // PDR Header Version
6320 PLDM_FILE_DESCRIPTOR_PDR, // PDRType
6321 0x01, 0x00, // Record Change Number
6322 0x20, 0x00, // Data Length = 32 bytes
6323 /* PLDM File Descriptor PDR Data*/
6324 0x01, 0x00, // Terminus Handle = 0x01
6325 0x01, 0x00, // File Identifier = 0x01
6326 0x09, 0x00, // Entity Type = Physical | Device File
6327 0x01, 0x00, // Entity instance number = 1
6328 PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID,
6329 0, // Container ID = Overall system
6330 0x02, 0, // Supper Dir File Identifier = 0x0002
6331 0x01, // File Classification = 0x01 (BootLog)
6332 0x00, // OEM File Classification = 0x00
6333 0x15, 0x00, // File Capabilities = 0x0015
6334 0xff, 0xff, 0xff, 0xff, // File Version = 0xffffffff (Unversioned)
6335 0x00, 0x28, 0x00, 0x00, // File Maximum Size = 10KB
6336 0x02, // File Maximum File Descriptor count = 2
6337 0x05, // File Name Length = 5
6338 0x46, 0x69, 0x6C, 0x65, 0x31,
6339 0x00, // File Name = "File1\NULL"
6340 };
6341
6342 struct pldm_file_descriptor_pdr decodedPdr = {};
6343
6344 /*
6345 * Expect error: The original length of the data buffer is larger than
6346 * the target extract length.
6347 */
6348 rc = decode_pldm_file_descriptor_pdr(pdr1.data(), pdr1.size(), &decodedPdr);
6349 EXPECT_EQ(-EBADMSG, rc);
6350 }
6351
TEST(decodePldmFileDescriptorPdr,BadTestDataBufferUnderLength)6352 TEST(decodePldmFileDescriptorPdr, BadTestDataBufferUnderLength)
6353 {
6354 int rc;
6355
6356 /*Un-matched OEM File Classification Name Length*/
6357 std::vector<uint8_t> pdr1{
6358 // Common PDR Header
6359 0x01, 0x0, 0x0, 0x0, // Record Handle
6360 0x01, // PDR Header Version
6361 PLDM_FILE_DESCRIPTOR_PDR, // PDRType
6362 0x01, 0x00, // Record Change Number
6363 0x2A, 0x00, // Data Length = 42 bytes
6364 /* PLDM File Descriptor PDR Data*/
6365 0x01, 0x00, // Terminus Handle = 0x01
6366 0x01, 0x00, // File Identifier = 0x01
6367 0x09, 0x00, // Entity Type = Physical | Device File
6368 0x01, 0x00, // Entity instance number = 1
6369 PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID,
6370 0, // Container ID = Overall system
6371 0x02, 0, // Supper Dir File Identifier = 0x0002
6372 0x01, // File Classification = 0x01 (BootLog)
6373 0x01, // OEM File Classification = 0x01
6374 0x15, 0x00, // File Capabilities = 0x0015
6375 0xff, 0xff, 0xff, 0xff, // File Version = 0xffffffff (Unversioned)
6376 0x00, 0x28, 0x00, 0x00, // File Maximum Size = 10KB
6377 0x02, // File Maximum File Descriptor count = 2
6378 0x06, // File Name Length = 6
6379 0x46, 0x69, 0x6C, 0x65, 0x31,
6380 0x00, // File Name = "File1\NULL"
6381 0x0B, // OEM File Classification Name Length = 11
6382 0x4F, 0x45, 0x4D, 0x20, 0x46, 0x69, 0x6C, 0x65,
6383 0x00 // OEM File Classification Name = "OEM File\NULL"
6384 };
6385
6386 struct pldm_file_descriptor_pdr decodedPdr = {};
6387
6388 /*
6389 * Expect error: The original length of the data buffer is smaller than
6390 * the target extract length.
6391 */
6392 rc = decode_pldm_file_descriptor_pdr(pdr1.data(), pdr1.size(), &decodedPdr);
6393 EXPECT_EQ(-EOVERFLOW, rc);
6394 }
6395 #endif
6396