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