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