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