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