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