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(GetEventReceiver, testGoodEncodeRequest) 3598 { 3599 std::array<uint8_t, hdrSize> requestMsg{}; 3600 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 3601 auto request = new (requestMsg.data()) pldm_msg; 3602 auto rc = 3603 encode_get_event_receiver_req(0, request, sizeof(struct pldm_msg)); 3604 ASSERT_EQ(rc, 0); 3605 } 3606 #endif 3607 3608 #ifdef LIBPLDM_API_TESTING 3609 TEST(GetEventReceiver, testBadEncodeRequest) 3610 { 3611 auto rc = 3612 encode_get_event_receiver_req(0, nullptr, sizeof(struct pldm_msg)); 3613 EXPECT_EQ(rc, -EINVAL); 3614 } 3615 #endif 3616 3617 #ifdef LIBPLDM_API_TESTING 3618 TEST(GetEventReceiver, testGoodEncodeResponse) 3619 { 3620 struct pldm_get_event_receiver_resp request_event_receiver_values; 3621 request_event_receiver_values.completion_code = 0; 3622 request_event_receiver_values.transport_protocol_type = 3623 PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP; 3624 request_event_receiver_values.event_receiver_address.mctp_eid = 84; 3625 size_t payload_lenght = PLDM_GET_EVENT_RECEIVER_MIN_RESP_BYTES + 1; 3626 std::array<uint8_t, hdrSize + sizeof(pldm_get_event_receiver_resp)> 3627 responseMsg{}; 3628 auto response = new (responseMsg.data()) pldm_msg; 3629 auto rc = encode_get_event_receiver_resp(0, &request_event_receiver_values, 3630 response, &payload_lenght); 3631 EXPECT_EQ(rc, 0); 3632 } 3633 #endif 3634 3635 #ifdef LIBPLDM_API_TESTING 3636 TEST(GetEventReceiver, testBadEncodeResponse) 3637 { 3638 std::array<uint8_t, hdrSize + sizeof(pldm_get_event_receiver_resp)> 3639 responseMsg{}; 3640 auto response = new (responseMsg.data()) pldm_msg; 3641 struct pldm_get_event_receiver_resp request_event_receiver_values; 3642 request_event_receiver_values.completion_code = 0; 3643 request_event_receiver_values.transport_protocol_type = 3644 PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP; 3645 request_event_receiver_values.event_receiver_address.mctp_eid = 64; 3646 size_t payload_lenght = PLDM_GET_EVENT_RECEIVER_MIN_RESP_BYTES; 3647 // msg can not be null 3648 auto rc = encode_get_event_receiver_resp(0, &request_event_receiver_values, 3649 nullptr, &payload_lenght); 3650 EXPECT_EQ(rc, -EINVAL); 3651 // unsupported protocol 3652 request_event_receiver_values.transport_protocol_type = 1; 3653 rc = encode_get_event_receiver_resp(0, &request_event_receiver_values, 3654 response, &payload_lenght); 3655 EXPECT_EQ(rc, -ENOTSUP); 3656 } 3657 #endif 3658 3659 #ifdef LIBPLDM_API_TESTING 3660 TEST(GetEventReceiver, testGoodDecodeResponse) 3661 { 3662 struct pldm_get_event_receiver_resp request_event_receiver_values; 3663 request_event_receiver_values.completion_code = 0; 3664 request_event_receiver_values.transport_protocol_type = 3665 PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP; 3666 request_event_receiver_values.event_receiver_address.mctp_eid = 34; 3667 size_t payload_lenght = PLDM_GET_EVENT_RECEIVER_MIN_RESP_BYTES + 1; 3668 struct pldm_get_event_receiver_resp decoded_resp; 3669 std::array<uint8_t, hdrSize + sizeof(pldm_get_event_receiver_resp)> 3670 responseMsg{}; 3671 auto response = new (responseMsg.data()) pldm_msg; 3672 auto rc = encode_get_event_receiver_resp(0, &request_event_receiver_values, 3673 response, &payload_lenght); 3674 EXPECT_EQ(rc, 0); 3675 rc = decode_get_event_receiver_resp( 3676 response, PLDM_GET_EVENT_RECEIVER_MIN_RESP_BYTES + 1, &decoded_resp); 3677 EXPECT_EQ(rc, 0); 3678 EXPECT_EQ(decoded_resp.completion_code, PLDM_SUCCESS); 3679 EXPECT_EQ(decoded_resp.transport_protocol_type, 3680 request_event_receiver_values.transport_protocol_type); 3681 EXPECT_EQ(decoded_resp.event_receiver_address.mctp_eid, 3682 request_event_receiver_values.event_receiver_address.mctp_eid); 3683 } 3684 #endif 3685 3686 #ifdef LIBPLDM_API_TESTING 3687 TEST(GetEventReceiver, testBadDecodeResponse) 3688 { 3689 struct pldm_get_event_receiver_resp decoded_resp; 3690 struct pldm_get_event_receiver_resp expected_resp; 3691 expected_resp.completion_code = 0; 3692 expected_resp.transport_protocol_type = PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP; 3693 expected_resp.event_receiver_address.mctp_eid = 34; 3694 std::array<uint8_t, hdrSize + sizeof(pldm_get_event_receiver_resp)> 3695 responseMsg{}; 3696 auto response = new (responseMsg.data()) pldm_msg; 3697 size_t payload_lenght = PLDM_GET_EVENT_RECEIVER_MIN_RESP_BYTES + 1; 3698 auto rc = encode_get_event_receiver_resp(0, &expected_resp, response, 3699 &payload_lenght); 3700 EXPECT_EQ(rc, 0); 3701 // message can not be null 3702 rc = decode_get_event_receiver_resp( 3703 nullptr, responseMsg.size() - sizeof(pldm_msg_hdr), &decoded_resp); 3704 EXPECT_EQ(rc, -EINVAL); 3705 // Allocated less than expected 3706 rc = decode_get_event_receiver_resp( 3707 response, PLDM_GET_EVENT_RECEIVER_MIN_RESP_BYTES - 1, &decoded_resp); 3708 EXPECT_EQ(rc, -EOVERFLOW); 3709 // Not supported protocol 3710 size_t transport_protocol_type_offset = hdrSize + 1; 3711 // Manually modify the transport_protocol_type to a not supported one 3712 responseMsg[transport_protocol_type_offset] = 1; 3713 rc = decode_get_event_receiver_resp( 3714 response, responseMsg.size() - sizeof(pldm_msg_hdr), &decoded_resp); 3715 EXPECT_EQ(rc, -ENOTSUP); 3716 } 3717 #endif 3718 3719 TEST(SetEventReceiver, testGoodEncodeRequest) 3720 { 3721 uint8_t eventMessageGlobalEnable = 3722 PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC_KEEP_ALIVE; 3723 uint8_t transportProtocolType = PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP; 3724 uint8_t eventReceiverAddressInfo = 0x08; 3725 uint16_t heartbeatTimer = 0x78; 3726 3727 std::vector<uint8_t> requestMsg(hdrSize + 3728 PLDM_SET_EVENT_RECEIVER_REQ_BYTES); 3729 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 3730 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 3731 3732 auto rc = encode_set_event_receiver_req( 3733 0, eventMessageGlobalEnable, transportProtocolType, 3734 eventReceiverAddressInfo, heartbeatTimer, request); 3735 3736 EXPECT_EQ(rc, PLDM_SUCCESS); 3737 struct pldm_set_event_receiver_req* req = 3738 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 3739 reinterpret_cast<struct pldm_set_event_receiver_req*>(request->payload); 3740 EXPECT_EQ(eventMessageGlobalEnable, req->event_message_global_enable); 3741 EXPECT_EQ(transportProtocolType, req->transport_protocol_type); 3742 EXPECT_EQ(eventReceiverAddressInfo, req->event_receiver_address_info); 3743 EXPECT_EQ(heartbeatTimer, le16toh(req->heartbeat_timer)); 3744 } 3745 3746 TEST(SetEventReceiver, testBadEncodeRequest) 3747 { 3748 uint8_t eventMessageGlobalEnable = 3749 PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC_KEEP_ALIVE; 3750 uint8_t transportProtocolType = PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP; 3751 uint8_t eventReceiverAddressInfo = 0x08; 3752 uint16_t heartbeatTimer = 0; 3753 3754 std::vector<uint8_t> requestMsg(hdrSize + 3755 PLDM_SET_EVENT_RECEIVER_REQ_BYTES); 3756 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 3757 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 3758 3759 auto rc = encode_set_event_receiver_req( 3760 0, eventMessageGlobalEnable, transportProtocolType, 3761 eventReceiverAddressInfo, heartbeatTimer, request); 3762 3763 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 3764 } 3765 3766 TEST(SetEventReceiver, testGoodDecodeResponse) 3767 { 3768 std::array<uint8_t, hdrSize + PLDM_SET_EVENT_RECEIVER_RESP_BYTES> 3769 responseMsg{}; 3770 3771 uint8_t retcompletion_code = 0; 3772 responseMsg[hdrSize] = PLDM_SUCCESS; 3773 3774 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 3775 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 3776 auto rc = decode_set_event_receiver_resp( 3777 response, responseMsg.size() - sizeof(pldm_msg_hdr), 3778 &retcompletion_code); 3779 3780 EXPECT_EQ(rc, PLDM_SUCCESS); 3781 EXPECT_EQ(PLDM_SUCCESS, retcompletion_code); 3782 } 3783 3784 TEST(SetEventReceiver, testBadDecodeResponse) 3785 { 3786 std::array<uint8_t, hdrSize + PLDM_SET_EVENT_RECEIVER_RESP_BYTES> 3787 responseMsg{}; 3788 uint8_t retcompletion_code = 0; 3789 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 3790 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 3791 3792 auto rc = decode_set_event_receiver_resp( 3793 response, responseMsg.size() - sizeof(pldm_msg_hdr), NULL); 3794 3795 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 3796 3797 rc = decode_set_event_receiver_resp( 3798 nullptr, responseMsg.size() - sizeof(pldm_msg_hdr), 3799 &retcompletion_code); 3800 3801 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 3802 } 3803 3804 TEST(SetEventReceiver, testGoodEncodeResponse) 3805 { 3806 std::array<uint8_t, 3807 sizeof(pldm_msg_hdr) + PLDM_SET_EVENT_RECEIVER_RESP_BYTES> 3808 responseMsg{}; 3809 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 3810 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 3811 uint8_t completionCode = 0; 3812 3813 auto rc = encode_set_event_receiver_resp(0, PLDM_SUCCESS, response); 3814 3815 EXPECT_EQ(rc, PLDM_SUCCESS); 3816 EXPECT_EQ(completionCode, response->payload[0]); 3817 } 3818 3819 TEST(SetEventReceiver, testBadEncodeResponse) 3820 { 3821 auto rc = encode_set_event_receiver_resp(0, PLDM_SUCCESS, NULL); 3822 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 3823 } 3824 3825 TEST(SetEventReceiver, testGoodDecodeRequest) 3826 { 3827 3828 std::array<uint8_t, hdrSize + PLDM_SET_EVENT_RECEIVER_REQ_BYTES> 3829 requestMsg{}; 3830 3831 uint8_t eventMessageGlobalEnable = 3832 PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC_KEEP_ALIVE; 3833 uint8_t transportProtocolType = PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP; 3834 uint8_t eventReceiverAddressInfo = 0x08; 3835 uint16_t heartbeatTimer = 0x78; 3836 3837 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 3838 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 3839 struct pldm_set_event_receiver_req* req = 3840 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 3841 reinterpret_cast<struct pldm_set_event_receiver_req*>(request->payload); 3842 3843 req->event_message_global_enable = eventMessageGlobalEnable; 3844 req->transport_protocol_type = transportProtocolType; 3845 req->event_receiver_address_info = eventReceiverAddressInfo; 3846 req->heartbeat_timer = htole16(heartbeatTimer); 3847 3848 uint8_t reteventMessageGlobalEnable; 3849 uint8_t rettransportProtocolType; 3850 uint8_t reteventReceiverAddressInfo; 3851 uint16_t retheartbeatTimer; 3852 auto rc = decode_set_event_receiver_req( 3853 request, requestMsg.size() - hdrSize, &reteventMessageGlobalEnable, 3854 &rettransportProtocolType, &reteventReceiverAddressInfo, 3855 &retheartbeatTimer); 3856 3857 EXPECT_EQ(rc, PLDM_SUCCESS); 3858 EXPECT_EQ(eventMessageGlobalEnable, reteventMessageGlobalEnable); 3859 EXPECT_EQ(transportProtocolType, rettransportProtocolType); 3860 EXPECT_EQ(eventReceiverAddressInfo, reteventReceiverAddressInfo); 3861 EXPECT_EQ(heartbeatTimer, retheartbeatTimer); 3862 3863 eventMessageGlobalEnable = PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC; 3864 req->event_message_global_enable = eventMessageGlobalEnable; 3865 rc = decode_set_event_receiver_req( 3866 request, PLDM_SET_EVENT_RECEIVER_MIN_REQ_BYTES, 3867 &reteventMessageGlobalEnable, &rettransportProtocolType, 3868 &reteventReceiverAddressInfo, &retheartbeatTimer); 3869 EXPECT_EQ(rc, PLDM_SUCCESS); 3870 EXPECT_EQ(eventMessageGlobalEnable, reteventMessageGlobalEnable); 3871 EXPECT_EQ(transportProtocolType, rettransportProtocolType); 3872 EXPECT_EQ(eventReceiverAddressInfo, reteventReceiverAddressInfo); 3873 } 3874 3875 TEST(SetEventReceiver, testBadDecodeRequest) 3876 { 3877 std::array<uint8_t, hdrSize + PLDM_SET_EVENT_RECEIVER_REQ_BYTES> 3878 requestMsg{}; 3879 3880 auto rc = decode_set_event_receiver_req(NULL, requestMsg.size() - hdrSize, 3881 NULL, NULL, NULL, NULL); 3882 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 3883 3884 uint8_t eventMessageGlobalEnable = 3885 PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC_KEEP_ALIVE; 3886 uint8_t transportProtocolType = PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP; 3887 uint8_t eventReceiverAddressInfo = 0x08; 3888 uint16_t heartbeatTimer = 0x78; 3889 3890 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 3891 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 3892 struct pldm_set_event_receiver_req* req = 3893 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 3894 reinterpret_cast<struct pldm_set_event_receiver_req*>(request->payload); 3895 3896 req->event_message_global_enable = eventMessageGlobalEnable; 3897 req->transport_protocol_type = transportProtocolType; 3898 req->event_receiver_address_info = eventReceiverAddressInfo; 3899 req->heartbeat_timer = htole16(heartbeatTimer); 3900 3901 uint8_t reteventMessageGlobalEnable; 3902 uint8_t rettransportProtocolType; 3903 uint8_t reteventReceiverAddressInfo; 3904 uint16_t retheartbeatTimer; 3905 3906 rc = decode_set_event_receiver_req( 3907 request, requestMsg.size() - hdrSize - 1, &reteventMessageGlobalEnable, 3908 &rettransportProtocolType, &reteventReceiverAddressInfo, 3909 &retheartbeatTimer); 3910 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH); 3911 3912 req->event_message_global_enable = PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC; 3913 rc = decode_set_event_receiver_req( 3914 request, PLDM_SET_EVENT_RECEIVER_MIN_REQ_BYTES - 1, 3915 &reteventMessageGlobalEnable, &rettransportProtocolType, 3916 &reteventReceiverAddressInfo, &retheartbeatTimer); 3917 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH); 3918 3919 req->event_message_global_enable = 3920 PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC_KEEP_ALIVE; 3921 req->heartbeat_timer = 0; 3922 rc = decode_set_event_receiver_req( 3923 request, PLDM_SET_EVENT_RECEIVER_REQ_BYTES, 3924 &reteventMessageGlobalEnable, &rettransportProtocolType, 3925 &reteventReceiverAddressInfo, &retheartbeatTimer); 3926 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 3927 } 3928 3929 TEST(decodeNumericSensorPdrData, Uint8Test) 3930 { 3931 std::vector<uint8_t> pdr1{ 3932 0x1, 3933 0x0, 3934 0x0, 3935 0x0, // record handle 3936 0x1, // PDRHeaderVersion 3937 PLDM_NUMERIC_SENSOR_PDR, // PDRType 3938 0x0, 3939 0x0, // recordChangeNumber 3940 PLDM_PDR_NUMERIC_SENSOR_PDR_MIN_LENGTH, 3941 0, // dataLength 3942 0, 3943 0, // PLDMTerminusHandle 3944 0x1, 3945 0x0, // sensorID=1 3946 PLDM_ENTITY_POWER_SUPPLY, 3947 0, // entityType=Power Supply(120) 3948 1, 3949 0, // entityInstanceNumber 3950 1, 3951 0, // containerID=1 3952 PLDM_NO_INIT, // sensorInit 3953 false, // sensorAuxiliaryNamesPDR 3954 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C 3955 0, // unitModifier 3956 0, // rateUnit 3957 0, // baseOEMUnitHandle 3958 0, // auxUnit 3959 0, // auxUnitModifier 3960 0, // auxRateUnit 3961 0, // rel 3962 0, // auxOEMUnitHandle 3963 true, // isLinear 3964 PLDM_SENSOR_DATA_SIZE_UINT8, // sensorDataSize 3965 0, 3966 0, 3967 0xc0, 3968 0x3f, // resolution=1.5 3969 0, 3970 0, 3971 0x80, 3972 0x3f, // offset=1.0 3973 0, 3974 0, // accuracy 3975 0, // plusTolerance 3976 0, // minusTolerance 3977 3, // hysteresis = 3 3978 0, // supportedThresholds 3979 0, // thresholdAndHysteresisVolatility 3980 0, 3981 0, 3982 0x80, 3983 0x3f, // stateTransistionInterval=1.0 3984 0, 3985 0, 3986 0x80, 3987 0x3f, // updateInverval=1.0 3988 255, // maxReadable 3989 0, // minReadable 3990 PLDM_RANGE_FIELD_FORMAT_UINT8, // rangeFieldFormat 3991 0, // rangeFieldsupport 3992 50, // nominalValue = 50 3993 60, // normalMax = 60 3994 40, // normalMin = 40 3995 70, // warningHigh = 70 3996 30, // warningLow = 30 3997 80, // criticalHigh = 80 3998 20, // criticalLow = 20 3999 90, // fatalHigh = 90 4000 10 // fatalLow = 10 4001 }; 4002 4003 struct pldm_numeric_sensor_value_pdr decodedPdr; 4004 auto rc = 4005 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 4006 EXPECT_EQ(PLDM_SUCCESS, rc); 4007 EXPECT_EQ(1, decodedPdr.hdr.record_handle); 4008 EXPECT_EQ(1, decodedPdr.hdr.version); 4009 EXPECT_EQ(PLDM_NUMERIC_SENSOR_PDR, decodedPdr.hdr.type); 4010 EXPECT_EQ(0, decodedPdr.hdr.record_change_num); 4011 EXPECT_EQ(PLDM_PDR_NUMERIC_SENSOR_PDR_MIN_LENGTH, decodedPdr.hdr.length); 4012 EXPECT_EQ(1, decodedPdr.sensor_id); 4013 EXPECT_EQ(PLDM_ENTITY_POWER_SUPPLY, decodedPdr.entity_type); 4014 EXPECT_EQ(1, decodedPdr.entity_instance_num); 4015 EXPECT_EQ(1, decodedPdr.container_id); 4016 EXPECT_EQ(PLDM_NO_INIT, decodedPdr.sensor_init); 4017 EXPECT_EQ(false, decodedPdr.sensor_auxiliary_names_pdr); 4018 EXPECT_EQ(PLDM_SENSOR_UNIT_DEGRESS_C, decodedPdr.base_unit); 4019 EXPECT_EQ(0, decodedPdr.unit_modifier); 4020 EXPECT_EQ(0, decodedPdr.rate_unit); 4021 EXPECT_EQ(0, decodedPdr.base_oem_unit_handle); 4022 EXPECT_EQ(0, decodedPdr.aux_unit); 4023 EXPECT_EQ(0, decodedPdr.aux_unit_modifier); 4024 EXPECT_EQ(0, decodedPdr.aux_rate_unit); 4025 EXPECT_EQ(0, decodedPdr.rel); 4026 EXPECT_EQ(0, decodedPdr.aux_oem_unit_handle); 4027 EXPECT_EQ(true, decodedPdr.is_linear); 4028 EXPECT_EQ(PLDM_SENSOR_DATA_SIZE_UINT8, decodedPdr.sensor_data_size); 4029 EXPECT_FLOAT_EQ(1.5f, decodedPdr.resolution); 4030 EXPECT_FLOAT_EQ(1.0f, decodedPdr.offset); 4031 EXPECT_EQ(0, decodedPdr.accuracy); 4032 EXPECT_EQ(0, decodedPdr.plus_tolerance); 4033 EXPECT_EQ(0, decodedPdr.minus_tolerance); 4034 EXPECT_EQ(3, decodedPdr.hysteresis.value_u8); 4035 EXPECT_EQ(0, decodedPdr.supported_thresholds.byte); 4036 EXPECT_EQ(0, decodedPdr.threshold_and_hysteresis_volatility.byte); 4037 EXPECT_FLOAT_EQ(1.0f, decodedPdr.state_transition_interval); 4038 EXPECT_FLOAT_EQ(1.0f, decodedPdr.update_interval); 4039 EXPECT_EQ(255, decodedPdr.max_readable.value_u8); 4040 EXPECT_EQ(0, decodedPdr.min_readable.value_u8); 4041 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_UINT8, decodedPdr.range_field_format); 4042 EXPECT_EQ(0, decodedPdr.range_field_support.byte); 4043 EXPECT_EQ(50, decodedPdr.nominal_value.value_u8); 4044 EXPECT_EQ(60, decodedPdr.normal_max.value_u8); 4045 EXPECT_EQ(40, decodedPdr.normal_min.value_u8); 4046 EXPECT_EQ(70, decodedPdr.warning_high.value_u8); 4047 EXPECT_EQ(30, decodedPdr.warning_low.value_u8); 4048 EXPECT_EQ(80, decodedPdr.critical_high.value_u8); 4049 EXPECT_EQ(20, decodedPdr.critical_low.value_u8); 4050 EXPECT_EQ(90, decodedPdr.fatal_high.value_u8); 4051 EXPECT_EQ(10, decodedPdr.fatal_low.value_u8); 4052 } 4053 4054 TEST(decodeNumericSensorPdrData, Sint8Test) 4055 { 4056 std::vector<uint8_t> pdr1{ 4057 0x1, 4058 0x0, 4059 0x0, 4060 0x0, // record handle 4061 0x1, // PDRHeaderVersion 4062 PLDM_NUMERIC_SENSOR_PDR, // PDRType 4063 0x0, 4064 0x0, // recordChangeNumber 4065 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH + 4066 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH + 4067 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH, 4068 0, // dataLength 4069 0, 4070 0, // PLDMTerminusHandle 4071 0x1, 4072 0x0, // sensorID=1 4073 PLDM_ENTITY_POWER_SUPPLY, 4074 0, // entityType=Power Supply(120) 4075 1, 4076 0, // entityInstanceNumber 4077 0x1, 4078 0x0, // containerID=1 4079 PLDM_NO_INIT, // sensorInit 4080 false, // sensorAuxiliaryNamesPDR 4081 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C 4082 0, // unitModifier 4083 0, // rateUnit 4084 0, // baseOEMUnitHandle 4085 0, // auxUnit 4086 0, // auxUnitModifier 4087 0, // auxRateUnit 4088 0, // rel 4089 0, // auxOEMUnitHandle 4090 true, // isLinear 4091 PLDM_RANGE_FIELD_FORMAT_SINT8, // sensorDataSize 4092 0, 4093 0, 4094 0, 4095 0, // resolution 4096 0, 4097 0, 4098 0, 4099 0, // offset 4100 0, 4101 0, // accuracy 4102 0, // plusTolerance 4103 0, // minusTolerance 4104 3, // hysteresis = 3 4105 0, // supportedThresholds 4106 0, // thresholdAndHysteresisVolatility 4107 0, 4108 0, 4109 0x80, 4110 0x3f, // stateTransistionInterval=1.0 4111 0, 4112 0, 4113 0x80, 4114 0x3f, // updateInverval=1.0 4115 0x64, // maxReadable = 100 4116 0x9c, // minReadable = -100 4117 PLDM_RANGE_FIELD_FORMAT_SINT8, // rangeFieldFormat 4118 0, // rangeFieldsupport 4119 0, // nominalValue = 0 4120 5, // normalMax = 5 4121 0xfb, // normalMin = -5 4122 10, // warningHigh = 10 4123 0xf6, // warningLow = -10 4124 20, // criticalHigh = 20 4125 0xec, // criticalLow = -20 4126 30, // fatalHigh = 30 4127 0xe2 // fatalLow = -30 4128 }; 4129 4130 struct pldm_numeric_sensor_value_pdr decodedPdr; 4131 auto rc = 4132 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 4133 EXPECT_EQ(PLDM_SUCCESS, rc); 4134 4135 EXPECT_EQ(PLDM_SENSOR_DATA_SIZE_SINT8, decodedPdr.sensor_data_size); 4136 EXPECT_EQ(100, decodedPdr.max_readable.value_s8); 4137 EXPECT_EQ(-100, decodedPdr.min_readable.value_s8); 4138 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_SINT8, decodedPdr.range_field_format); 4139 EXPECT_EQ(0, decodedPdr.nominal_value.value_s8); 4140 EXPECT_EQ(5, decodedPdr.normal_max.value_s8); 4141 EXPECT_EQ(-5, decodedPdr.normal_min.value_s8); 4142 EXPECT_EQ(10, decodedPdr.warning_high.value_s8); 4143 EXPECT_EQ(-10, decodedPdr.warning_low.value_s8); 4144 EXPECT_EQ(20, decodedPdr.critical_high.value_s8); 4145 EXPECT_EQ(-20, decodedPdr.critical_low.value_s8); 4146 EXPECT_EQ(30, decodedPdr.fatal_high.value_s8); 4147 EXPECT_EQ(-30, decodedPdr.fatal_low.value_s8); 4148 } 4149 4150 TEST(decodeNumericSensorPdrData, Uint16Test) 4151 { 4152 std::vector<uint8_t> pdr1{ 4153 0x1, 4154 0x0, 4155 0x0, 4156 0x0, // record handle 4157 0x1, // PDRHeaderVersion 4158 PLDM_NUMERIC_SENSOR_PDR, // PDRType 4159 0x0, 4160 0x0, // recordChangeNumber 4161 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH + 4162 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH * 2 + 4163 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 2, 4164 0, // dataLength 4165 0, 4166 0, // PLDMTerminusHandle 4167 0x1, 4168 0x0, // sensorID=1 4169 PLDM_ENTITY_POWER_SUPPLY, 4170 0, // entityType=Power Supply(120) 4171 1, 4172 0, // entityInstanceNumber 4173 0x1, 4174 0x0, // containerID=1 4175 PLDM_NO_INIT, // sensorInit 4176 false, // sensorAuxiliaryNamesPDR 4177 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C 4178 0, // unitModifier 4179 0, // rateUnit 4180 0, // baseOEMUnitHandle 4181 0, // auxUnit 4182 0, // auxUnitModifier 4183 0, // auxRateUnit 4184 0, // rel 4185 0, // auxOEMUnitHandle 4186 true, // isLinear 4187 PLDM_SENSOR_DATA_SIZE_UINT16, // sensorDataSize 4188 0, 4189 0, 4190 0, 4191 0, // resolution 4192 0, 4193 0, 4194 0, 4195 0, // offset 4196 0, 4197 0, // accuracy 4198 0, // plusTolerance 4199 0, // minusTolerance 4200 3, 4201 0, // hysteresis = 3 4202 0, // supportedThresholds 4203 0, // thresholdAndHysteresisVolatility 4204 0, 4205 0, 4206 0x80, 4207 0x3f, // stateTransistionInterval=1.0 4208 0, 4209 0, 4210 0x80, 4211 0x3f, // updateInverval=1.0 4212 0, 4213 0x10, // maxReadable = 4096 4214 0, 4215 0, // minReadable = 0 4216 PLDM_RANGE_FIELD_FORMAT_UINT16, // rangeFieldFormat 4217 0, // rangeFieldsupport 4218 0x88, 4219 0x13, // nominalValue = 5,000 4220 0x70, 4221 0x17, // normalMax = 6,000 4222 0xa0, 4223 0x0f, // normalMin = 4,000 4224 0x58, 4225 0x1b, // warningHigh = 7,000 4226 0xb8, 4227 0x0b, // warningLow = 3,000 4228 0x40, 4229 0x1f, // criticalHigh = 8,000 4230 0xd0, 4231 0x07, // criticalLow = 2,000 4232 0x28, 4233 0x23, // fatalHigh = 9,000 4234 0xe8, 4235 0x03 // fatalLow = 1,000 4236 }; 4237 4238 struct pldm_numeric_sensor_value_pdr decodedPdr; 4239 auto rc = 4240 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 4241 EXPECT_EQ(PLDM_SUCCESS, rc); 4242 4243 EXPECT_EQ(PLDM_SENSOR_DATA_SIZE_UINT16, decodedPdr.sensor_data_size); 4244 EXPECT_EQ(4096, decodedPdr.max_readable.value_u16); 4245 EXPECT_EQ(0, decodedPdr.min_readable.value_u16); 4246 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_UINT16, decodedPdr.range_field_format); 4247 EXPECT_EQ(5000, decodedPdr.nominal_value.value_u16); 4248 EXPECT_EQ(6000, decodedPdr.normal_max.value_u16); 4249 EXPECT_EQ(4000, decodedPdr.normal_min.value_u16); 4250 EXPECT_EQ(7000, decodedPdr.warning_high.value_u16); 4251 EXPECT_EQ(3000, decodedPdr.warning_low.value_u16); 4252 EXPECT_EQ(8000, decodedPdr.critical_high.value_u16); 4253 EXPECT_EQ(2000, decodedPdr.critical_low.value_u16); 4254 EXPECT_EQ(9000, decodedPdr.fatal_high.value_u16); 4255 EXPECT_EQ(1000, decodedPdr.fatal_low.value_u16); 4256 } 4257 4258 TEST(decodeNumericSensorPdrData, Sint16Test) 4259 { 4260 std::vector<uint8_t> pdr1{ 4261 0x1, 4262 0x0, 4263 0x0, 4264 0x0, // record handle 4265 0x1, // PDRHeaderVersion 4266 PLDM_NUMERIC_SENSOR_PDR, // PDRType 4267 0x0, 4268 0x0, // recordChangeNumber 4269 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH + 4270 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH * 2 + 4271 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 2, 4272 0, // dataLength 4273 0, 4274 0, // PLDMTerminusHandle 4275 0x1, 4276 0x0, // sensorID=1 4277 PLDM_ENTITY_POWER_SUPPLY, 4278 0, // entityType=Power Supply(120) 4279 1, 4280 0, // entityInstanceNumber 4281 0x1, 4282 0x0, // containerID=1 4283 PLDM_NO_INIT, // sensorInit 4284 false, // sensorAuxiliaryNamesPDR 4285 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C 4286 0, // unitModifier 4287 0, // rateUnit 4288 0, // baseOEMUnitHandle 4289 0, // auxUnit 4290 0, // auxUnitModifier 4291 0, // auxRateUnit 4292 0, // rel 4293 0, // auxOEMUnitHandle 4294 true, // isLinear 4295 PLDM_SENSOR_DATA_SIZE_SINT16, // sensorDataSize 4296 0, 4297 0, 4298 0, 4299 0, // resolution 4300 0, 4301 0, 4302 0, 4303 0, // offset 4304 0, 4305 0, // accuracy 4306 0, // plusTolerance 4307 0, // minusTolerance 4308 3, 4309 0, // hysteresis 4310 0, // supportedThresholds 4311 0, // thresholdAndHysteresisVolatility 4312 0, 4313 0, 4314 0x80, 4315 0x3f, // stateTransistionInterval=1.0 4316 0, 4317 0, 4318 0x80, 4319 0x3f, // updateInverval=1.0 4320 0xe8, 4321 0x03, // maxReadable = 1000 4322 0x18, 4323 0xfc, // minReadable = -1000 4324 PLDM_RANGE_FIELD_FORMAT_SINT16, // rangeFieldFormat 4325 0, // rangeFieldsupport 4326 0, 4327 0, // nominalValue = 0 4328 0xf4, 4329 0x01, // normalMax = 500 4330 0x0c, 4331 0xfe, // normalMin = -500 4332 0xe8, 4333 0x03, // warningHigh = 1,000 4334 0x18, 4335 0xfc, // warningLow = -1,000 4336 0xd0, 4337 0x07, // criticalHigh = 2,000 4338 0x30, 4339 0xf8, // criticalLow = -2,000 4340 0xb8, 4341 0x0b, // fatalHigh = 3,000 4342 0x48, 4343 0xf4 // fatalLow = -3,000 4344 }; 4345 4346 struct pldm_numeric_sensor_value_pdr decodedPdr; 4347 auto rc = 4348 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 4349 EXPECT_EQ(PLDM_SUCCESS, rc); 4350 4351 EXPECT_EQ(PLDM_SENSOR_DATA_SIZE_SINT16, decodedPdr.sensor_data_size); 4352 EXPECT_EQ(1000, decodedPdr.max_readable.value_s16); 4353 EXPECT_EQ(-1000, decodedPdr.min_readable.value_s16); 4354 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_SINT16, decodedPdr.range_field_format); 4355 EXPECT_EQ(0, decodedPdr.nominal_value.value_s16); 4356 EXPECT_EQ(500, decodedPdr.normal_max.value_s16); 4357 EXPECT_EQ(-500, decodedPdr.normal_min.value_s16); 4358 EXPECT_EQ(1000, decodedPdr.warning_high.value_s16); 4359 EXPECT_EQ(-1000, decodedPdr.warning_low.value_s16); 4360 EXPECT_EQ(2000, decodedPdr.critical_high.value_s16); 4361 EXPECT_EQ(-2000, decodedPdr.critical_low.value_s16); 4362 EXPECT_EQ(3000, decodedPdr.fatal_high.value_s16); 4363 EXPECT_EQ(-3000, decodedPdr.fatal_low.value_s16); 4364 } 4365 4366 TEST(decodeNumericSensorPdrData, Uint32Test) 4367 { 4368 std::vector<uint8_t> pdr1{ 4369 0x1, 4370 0x0, 4371 0x0, 4372 0x0, // record handle 4373 0x1, // PDRHeaderVersion 4374 PLDM_NUMERIC_SENSOR_PDR, // PDRType 4375 0x0, 4376 0x0, // recordChangeNumber 4377 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH + 4378 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH * 4 + 4379 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 4, 4380 0, // dataLength 4381 0, 4382 0, // PLDMTerminusHandle 4383 0x1, 4384 0x0, // sensorID=1 4385 PLDM_ENTITY_POWER_SUPPLY, 4386 0, // entityType=Power Supply(120) 4387 1, 4388 0, // entityInstanceNumber 4389 0x1, 4390 0x0, // containerID=1 4391 PLDM_NO_INIT, // sensorInit 4392 false, // sensorAuxiliaryNamesPDR 4393 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C 4394 0, // unitModifier 4395 0, // rateUnit 4396 0, // baseOEMUnitHandle 4397 0, // auxUnit 4398 0, // auxUnitModifier 4399 0, // auxRateUnit 4400 0, // rel 4401 0, // auxOEMUnitHandle 4402 true, // isLinear 4403 PLDM_SENSOR_DATA_SIZE_UINT32, // sensorDataSize 4404 0, 4405 0, 4406 0, 4407 0, // resolution 4408 0, 4409 0, 4410 0, 4411 0, // offset 4412 0, 4413 0, // accuracy 4414 0, // plusTolerance 4415 0, // minusTolerance 4416 3, 4417 0, 4418 0, 4419 0, // hysteresis 4420 0, // supportedThresholds 4421 0, // thresholdAndHysteresisVolatility 4422 0, 4423 0, 4424 0x80, 4425 0x3f, // stateTransistionInterval=1.0 4426 0, 4427 0, 4428 0x80, 4429 0x3f, // updateInverval=1.0 4430 0, 4431 0x10, 4432 0, 4433 0, // maxReadable = 4096 4434 0, 4435 0, 4436 0, 4437 0, // minReadable = 0 4438 PLDM_RANGE_FIELD_FORMAT_UINT32, // rangeFieldFormat 4439 0, // rangeFieldsupport 4440 0x40, 4441 0x4b, 4442 0x4c, 4443 0x00, // nominalValue = 5,000,000 4444 0x80, 4445 0x8d, 4446 0x5b, 4447 0x00, // normalMax = 6,000,000 4448 0x00, 4449 0x09, 4450 0x3d, 4451 0x00, // normalMin = 4,000,000 4452 0xc0, 4453 0xcf, 4454 0x6a, 4455 0x00, // warningHigh = 7,000,000 4456 0xc0, 4457 0xc6, 4458 0x2d, 4459 0x00, // warningLow = 3,000,000 4460 0x00, 4461 0x12, 4462 0x7a, 4463 0x00, // criticalHigh = 8,000,000 4464 0x80, 4465 0x84, 4466 0x1e, 4467 0x00, // criticalLow = 2,000,000 4468 0x40, 4469 0x54, 4470 0x89, 4471 0x00, // fatalHigh = 9,000,000 4472 0x40, 4473 0x42, 4474 0x0f, 4475 0x00 // fatalLow = 1,000,000 4476 }; 4477 4478 struct pldm_numeric_sensor_value_pdr decodedPdr; 4479 auto rc = 4480 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 4481 EXPECT_EQ(PLDM_SUCCESS, rc); 4482 4483 EXPECT_EQ(PLDM_SENSOR_DATA_SIZE_UINT32, decodedPdr.sensor_data_size); 4484 EXPECT_EQ(4096, decodedPdr.max_readable.value_u32); 4485 EXPECT_EQ(0, decodedPdr.min_readable.value_u32); 4486 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_UINT32, decodedPdr.range_field_format); 4487 EXPECT_EQ(5000000, decodedPdr.nominal_value.value_u32); 4488 EXPECT_EQ(6000000, decodedPdr.normal_max.value_u32); 4489 EXPECT_EQ(4000000, decodedPdr.normal_min.value_u32); 4490 EXPECT_EQ(7000000, decodedPdr.warning_high.value_u32); 4491 EXPECT_EQ(3000000, decodedPdr.warning_low.value_u32); 4492 EXPECT_EQ(8000000, decodedPdr.critical_high.value_u32); 4493 EXPECT_EQ(2000000, decodedPdr.critical_low.value_u32); 4494 EXPECT_EQ(9000000, decodedPdr.fatal_high.value_u32); 4495 EXPECT_EQ(1000000, decodedPdr.fatal_low.value_u32); 4496 } 4497 4498 TEST(decodeNumericSensorPdrData, Sint32Test) 4499 { 4500 std::vector<uint8_t> pdr1{ 4501 0x1, 4502 0x0, 4503 0x0, 4504 0x0, // record handle 4505 0x1, // PDRHeaderVersion 4506 PLDM_NUMERIC_SENSOR_PDR, // PDRType 4507 0x0, 4508 0x0, // recordChangeNumber 4509 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH + 4510 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH * 4 + 4511 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 4, 4512 0, // dataLength 4513 0, 4514 0, // PLDMTerminusHandle 4515 0x1, 4516 0x0, // sensorID=1 4517 PLDM_ENTITY_POWER_SUPPLY, 4518 0, // entityType=Power Supply(120) 4519 1, 4520 0, // entityInstanceNumber 4521 0x1, 4522 0x0, // containerID=1 4523 PLDM_NO_INIT, // sensorInit 4524 false, // sensorAuxiliaryNamesPDR 4525 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C 4526 0, // unitModifier 4527 0, // rateUnit 4528 0, // baseOEMUnitHandle 4529 0, // auxUnit 4530 0, // auxUnitModifier 4531 0, // auxRateUnit 4532 0, // rel 4533 0, // auxOEMUnitHandle 4534 true, // isLinear 4535 PLDM_SENSOR_DATA_SIZE_SINT32, // sensorDataSize 4536 0, 4537 0, 4538 0, 4539 0, // resolution 4540 0, 4541 0, 4542 0, 4543 0, // offset 4544 0, 4545 0, // accuracy 4546 0, // plusTolerance 4547 0, // minusTolerance 4548 3, 4549 0, 4550 0, 4551 0, // hysteresis 4552 0, // supportedThresholds 4553 0, // thresholdAndHysteresisVolatility 4554 0, 4555 0, 4556 0x80, 4557 0x3f, // stateTransistionInterval=1.0 4558 0, 4559 0, 4560 0x80, 4561 0x3f, // updateInverval=1.0 4562 0xa0, 4563 0x86, 4564 0x01, 4565 0x00, // maxReadable = 100000 4566 0x60, 4567 0x79, 4568 0xfe, 4569 0xff, // minReadable = -10000 4570 PLDM_RANGE_FIELD_FORMAT_SINT32, // rangeFieldFormat 4571 0, // rangeFieldsupport 4572 0, 4573 0, 4574 0, 4575 0, // nominalValue = 0 4576 0x20, 4577 0xa1, 4578 0x07, 4579 0x00, // normalMax = 500,000 4580 0xe0, 4581 0x5e, 4582 0xf8, 4583 0xff, // normalMin = -500,000 4584 0x40, 4585 0x42, 4586 0x0f, 4587 0x00, // warningHigh = 1,000,000 4588 0xc0, 4589 0xbd, 4590 0xf0, 4591 0xff, // warningLow = -1,000,000 4592 0x80, 4593 0x84, 4594 0x1e, 4595 0x00, // criticalHigh = 2,000,000 4596 0x80, 4597 0x7b, 4598 0xe1, 4599 0xff, // criticalLow = -2,000,000 4600 0xc0, 4601 0xc6, 4602 0x2d, 4603 0x00, // fatalHigh = 3,000,000 4604 0x40, 4605 0x39, 4606 0xd2, 4607 0xff // fatalLow = -3,000,000 4608 }; 4609 4610 struct pldm_numeric_sensor_value_pdr decodedPdr; 4611 auto rc = 4612 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 4613 EXPECT_EQ(PLDM_SUCCESS, rc); 4614 4615 EXPECT_EQ(PLDM_SENSOR_DATA_SIZE_SINT32, decodedPdr.sensor_data_size); 4616 EXPECT_EQ(100000, decodedPdr.max_readable.value_s32); 4617 EXPECT_EQ(-100000, decodedPdr.min_readable.value_s32); 4618 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_SINT32, decodedPdr.range_field_format); 4619 EXPECT_EQ(0, decodedPdr.nominal_value.value_s32); 4620 EXPECT_EQ(500000, decodedPdr.normal_max.value_s32); 4621 EXPECT_EQ(-500000, decodedPdr.normal_min.value_s32); 4622 EXPECT_EQ(1000000, decodedPdr.warning_high.value_s32); 4623 EXPECT_EQ(-1000000, decodedPdr.warning_low.value_s32); 4624 EXPECT_EQ(2000000, decodedPdr.critical_high.value_s32); 4625 EXPECT_EQ(-2000000, decodedPdr.critical_low.value_s32); 4626 EXPECT_EQ(3000000, decodedPdr.fatal_high.value_s32); 4627 EXPECT_EQ(-3000000, decodedPdr.fatal_low.value_s32); 4628 } 4629 4630 TEST(decodeNumericSensorPdrData, Real32Test) 4631 { 4632 std::vector<uint8_t> pdr1{ 4633 0x1, 4634 0x0, 4635 0x0, 4636 0x0, // record handle 4637 0x1, // PDRHeaderVersion 4638 PLDM_NUMERIC_SENSOR_PDR, // PDRType 4639 0x0, 4640 0x0, // recordChangeNumber 4641 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH + 4642 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_SENSOR_DATA_SIZE_MIN_LENGTH * 4 + 4643 PLDM_PDR_NUMERIC_SENSOR_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 4, 4644 0, // dataLength 4645 0, 4646 0, // PLDMTerminusHandle 4647 0x1, 4648 0x0, // sensorID=1 4649 PLDM_ENTITY_POWER_SUPPLY, 4650 0, // entityType=Power Supply(120) 4651 1, 4652 0, // entityInstanceNumber 4653 0x1, 4654 0x0, // containerID=1 4655 PLDM_NO_INIT, // sensorInit 4656 false, // sensorAuxiliaryNamesPDR 4657 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C 4658 0, // unitModifier 4659 0, // rateUnit 4660 0, // baseOEMUnitHandle 4661 0, // auxUnit 4662 0, // auxUnitModifier 4663 0, // auxRateUnit 4664 0, // rel 4665 0, // auxOEMUnitHandle 4666 true, // isLinear 4667 PLDM_SENSOR_DATA_SIZE_SINT32, // sensorDataSize 4668 0, 4669 0, 4670 0, 4671 0, // resolution 4672 0, 4673 0, 4674 0, 4675 0, // offset 4676 0, 4677 0, // accuracy 4678 0, // plusTolerance 4679 0, // minusTolerance 4680 3, 4681 0, 4682 0, 4683 0, // hysteresis 4684 0, // supportedThresholds 4685 0, // thresholdAndHysteresisVolatility 4686 0, 4687 0, 4688 0x80, 4689 0x3f, // stateTransistionInterval=1.0 4690 0, 4691 0, 4692 0x80, 4693 0x3f, // updateInverval=1.0 4694 0xa0, 4695 0x86, 4696 0x01, 4697 0x00, // maxReadable = 100000 4698 0x60, 4699 0x79, 4700 0xfe, 4701 0xff, // minReadable = -10000 4702 PLDM_RANGE_FIELD_FORMAT_REAL32, // rangeFieldFormat 4703 0, // rangeFieldsupport 4704 0, 4705 0, 4706 0, 4707 0, // nominalValue = 0.0 4708 0x33, 4709 0x33, 4710 0x48, 4711 0x42, // normalMax = 50.05 4712 0x33, 4713 0x33, 4714 0x48, 4715 0xc2, // normalMin = -50.05 4716 0x83, 4717 0x00, 4718 0xc8, 4719 0x42, // warningHigh = 100.001 4720 0x83, 4721 0x00, 4722 0xc8, 4723 0xc2, // warningLow = -100.001 4724 0x83, 4725 0x00, 4726 0x48, 4727 0x43, // criticalHigh = 200.002 4728 0x83, 4729 0x00, 4730 0x48, 4731 0xc3, // criticalLow = -200.002 4732 0x62, 4733 0x00, 4734 0x96, 4735 0x43, // fatalHigh = 300.003 4736 0x62, 4737 0x00, 4738 0x96, 4739 0xc3 // fatalLow = -300.003 4740 }; 4741 4742 struct pldm_numeric_sensor_value_pdr decodedPdr; 4743 auto rc = 4744 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 4745 EXPECT_EQ(PLDM_SUCCESS, rc); 4746 4747 EXPECT_EQ(PLDM_SENSOR_DATA_SIZE_SINT32, decodedPdr.sensor_data_size); 4748 EXPECT_EQ(100000, decodedPdr.max_readable.value_s32); 4749 EXPECT_EQ(-100000, decodedPdr.min_readable.value_s32); 4750 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_REAL32, decodedPdr.range_field_format); 4751 EXPECT_FLOAT_EQ(0, decodedPdr.nominal_value.value_f32); 4752 EXPECT_FLOAT_EQ(50.05f, decodedPdr.normal_max.value_f32); 4753 EXPECT_FLOAT_EQ(-50.05f, decodedPdr.normal_min.value_f32); 4754 EXPECT_FLOAT_EQ(100.001f, decodedPdr.warning_high.value_f32); 4755 EXPECT_FLOAT_EQ(-100.001f, decodedPdr.warning_low.value_f32); 4756 EXPECT_FLOAT_EQ(200.002f, decodedPdr.critical_high.value_f32); 4757 EXPECT_FLOAT_EQ(-200.002f, decodedPdr.critical_low.value_f32); 4758 EXPECT_FLOAT_EQ(300.003f, decodedPdr.fatal_high.value_f32); 4759 EXPECT_FLOAT_EQ(-300.003f, decodedPdr.fatal_low.value_f32); 4760 } 4761 4762 TEST(decodeNumericSensorPdrDataDeathTest, InvalidSizeTest) 4763 { 4764 // A corrupted PDR. The data after plusTolerance missed. 4765 std::vector<uint8_t> pdr1{ 4766 0x1, 4767 0x0, 4768 0x0, 4769 0x0, // record handle 4770 0x1, // PDRHeaderVersion 4771 PLDM_NUMERIC_SENSOR_PDR, // PDRType 4772 0x0, 4773 0x0, // recordChangeNumber 4774 PLDM_PDR_NUMERIC_SENSOR_PDR_FIXED_LENGTH, 4775 0, // dataLength 4776 0, 4777 0, // PLDMTerminusHandle 4778 0x1, 4779 0x0, // sensorID=1 4780 PLDM_ENTITY_POWER_SUPPLY, 4781 0, // entityType=Power Supply(120) 4782 1, 4783 0, // entityInstanceNumber 4784 0x1, 4785 0x0, // containerID=1 4786 PLDM_NO_INIT, // sensorInit 4787 false, // sensorAuxiliaryNamesPDR 4788 2, // baseUint(2)=degrees C 4789 0, // unitModifier 4790 0, // rateUnit 4791 0, // baseOEMUnitHandle 4792 0, // auxUnit 4793 0, // auxUnitModifier 4794 0, // auxRateUnit 4795 0, // rel 4796 0, // auxOEMUnitHandle 4797 true, // isLinear 4798 PLDM_SENSOR_DATA_SIZE_UINT8, // sensorDataSize 4799 0, 4800 0, 4801 0, 4802 0, // resolution 4803 0, 4804 0, 4805 0, 4806 0, // offset 4807 0, 4808 0, // accuracy 4809 0 // plusTolerance 4810 }; 4811 4812 struct pldm_numeric_sensor_value_pdr decodedPdr; 4813 int rc = 4814 decode_numeric_sensor_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 4815 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH); 4816 } 4817 4818 #ifdef LIBPLDM_API_TESTING 4819 TEST(decodeNumericEffecterPdrData, Uint8Test) 4820 { 4821 std::vector<uint8_t> pdr1{ 4822 0x1, 4823 0x0, 4824 0x0, 4825 0x0, // record handle 4826 0x1, // PDRHeaderVersion 4827 PLDM_NUMERIC_EFFECTER_PDR, // PDRType 4828 0x0, 4829 0x0, // recordChangeNumber 4830 PLDM_PDR_NUMERIC_EFFECTER_PDR_MIN_LENGTH, 4831 0, // dataLength 4832 0, 4833 0, // PLDMTerminusHandle 4834 0x1, 4835 0x0, // effecterID=1 4836 PLDM_ENTITY_POWER_SUPPLY, 4837 0, // entityType=Power Supply(120) 4838 1, 4839 0, // entityInstanceNumber 4840 1, 4841 0, // containerID=1 4842 0x2, 4843 0x0, // effecter_semantic_id=2 4844 PLDM_NO_INIT, // effecterInit 4845 false, // effecterAuxiliaryNames 4846 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C 4847 0, // unitModifier 4848 0, // rateUnit 4849 0, // baseOEMUnitHandle 4850 0, // auxUnit 4851 0, // auxUnitModifier 4852 4, // auxRateUnit 4853 0, // auxOEMUnitHandle 4854 true, // isLinear 4855 PLDM_EFFECTER_DATA_SIZE_UINT8, // effecterDataSize 4856 0, 4857 0, 4858 0xc0, 4859 0x3f, // resolution=1.5 4860 0, 4861 0, 4862 0x80, 4863 0x3f, // offset=1.0 4864 0, 4865 0, // accuracy 4866 0, // plusTolerance 4867 0, // minusTolerance 4868 0, 4869 0, 4870 0x80, 4871 0x3f, // stateTransistionInterval=1.0 4872 0, 4873 0, 4874 0x80, 4875 0x3f, // transition_interval=1.0 4876 255, // maxSetdable 4877 0, // minSetable 4878 PLDM_RANGE_FIELD_FORMAT_UINT8, // rangeFieldFormat 4879 0x1f, // rangeFieldsupport 4880 50, // nominalValue = 50 4881 60, // normalMax = 60 4882 40, // normalMin = 40 4883 90, // rated_max = 90 4884 10 // rated_min = 10 4885 }; 4886 4887 struct pldm_numeric_effecter_value_pdr decodedPdr; 4888 auto rc = 4889 decode_numeric_effecter_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 4890 EXPECT_EQ(PLDM_SUCCESS, rc); 4891 EXPECT_EQ(1, decodedPdr.hdr.record_handle); 4892 EXPECT_EQ(1, decodedPdr.hdr.version); 4893 EXPECT_EQ(PLDM_NUMERIC_EFFECTER_PDR, decodedPdr.hdr.type); 4894 EXPECT_EQ(0, decodedPdr.hdr.record_change_num); 4895 EXPECT_EQ(PLDM_PDR_NUMERIC_EFFECTER_PDR_MIN_LENGTH, decodedPdr.hdr.length); 4896 EXPECT_EQ(1, decodedPdr.effecter_id); 4897 EXPECT_EQ(PLDM_ENTITY_POWER_SUPPLY, decodedPdr.entity_type); 4898 EXPECT_EQ(1, decodedPdr.entity_instance); 4899 EXPECT_EQ(1, decodedPdr.container_id); 4900 EXPECT_EQ(2, decodedPdr.effecter_semantic_id); 4901 EXPECT_EQ(PLDM_NO_INIT, decodedPdr.effecter_init); 4902 EXPECT_EQ(false, decodedPdr.effecter_auxiliary_names); 4903 EXPECT_EQ(PLDM_SENSOR_UNIT_DEGRESS_C, decodedPdr.base_unit); 4904 EXPECT_EQ(0, decodedPdr.unit_modifier); 4905 EXPECT_EQ(0, decodedPdr.rate_unit); 4906 EXPECT_EQ(0, decodedPdr.base_oem_unit_handle); 4907 EXPECT_EQ(0, decodedPdr.aux_unit); 4908 EXPECT_EQ(0, decodedPdr.aux_unit_modifier); 4909 EXPECT_EQ(4, decodedPdr.aux_rate_unit); 4910 EXPECT_EQ(0, decodedPdr.aux_oem_unit_handle); 4911 EXPECT_EQ(true, decodedPdr.is_linear); 4912 EXPECT_EQ(PLDM_EFFECTER_DATA_SIZE_UINT8, decodedPdr.effecter_data_size); 4913 EXPECT_FLOAT_EQ(1.5f, decodedPdr.resolution); 4914 EXPECT_FLOAT_EQ(1.0f, decodedPdr.offset); 4915 EXPECT_EQ(0, decodedPdr.accuracy); 4916 EXPECT_EQ(0, decodedPdr.plus_tolerance); 4917 EXPECT_EQ(0, decodedPdr.minus_tolerance); 4918 EXPECT_FLOAT_EQ(1.0f, decodedPdr.state_transition_interval); 4919 EXPECT_FLOAT_EQ(1.0f, decodedPdr.transition_interval); 4920 EXPECT_EQ(255, decodedPdr.max_settable.value_u8); 4921 EXPECT_EQ(0, decodedPdr.min_settable.value_u8); 4922 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_UINT8, decodedPdr.range_field_format); 4923 EXPECT_EQ(0x1f, decodedPdr.range_field_support.byte); 4924 EXPECT_EQ(50, decodedPdr.nominal_value.value_u8); 4925 EXPECT_EQ(60, decodedPdr.normal_max.value_u8); 4926 EXPECT_EQ(40, decodedPdr.normal_min.value_u8); 4927 EXPECT_EQ(90, decodedPdr.rated_max.value_u8); 4928 EXPECT_EQ(10, decodedPdr.rated_min.value_u8); 4929 } 4930 #endif 4931 4932 #ifdef LIBPLDM_API_TESTING 4933 TEST(decodeNumericEffecterPdrData, Sint8Test) 4934 { 4935 std::vector<uint8_t> pdr1{ 4936 0x1, 4937 0x0, 4938 0x0, 4939 0x0, // record handle 4940 0x1, // PDRHeaderVersion 4941 PLDM_NUMERIC_EFFECTER_PDR, // PDRType 4942 0x0, 4943 0x0, // recordChangeNumber 4944 PLDM_PDR_NUMERIC_EFFECTER_PDR_FIXED_LENGTH + 4945 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_EFFECTER_DATA_SIZE_MIN_LENGTH + 4946 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_RANGE_FIELD_MIN_LENGTH, 4947 0, // dataLength 4948 0, 4949 0, // PLDMTerminusHandle 4950 0x1, 4951 0x0, // effecterID=1 4952 PLDM_ENTITY_POWER_SUPPLY, 4953 0, // entityType=Power Supply(120) 4954 1, 4955 0, // entityInstanceNumber 4956 0x1, 4957 0x0, // containerID=1 4958 0x2, 4959 0x0, // effecter_semantic_id=2 4960 PLDM_NO_INIT, // effecterInit 4961 false, // effecterAuxiliaryNames 4962 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C 4963 0, // unitModifier 4964 0, // rateUnit 4965 0, // baseOEMUnitHandle 4966 0, // auxUnit 4967 0, // auxUnitModifier 4968 0, // auxRateUnit 4969 0, // auxOEMUnitHandle 4970 true, // isLinear 4971 PLDM_RANGE_FIELD_FORMAT_SINT8, // effecterDataSize 4972 0, 4973 0, 4974 0, 4975 0, // resolution 4976 0, 4977 0, 4978 0, 4979 0, // offset 4980 0, 4981 0, // accuracy 4982 0, // plusTolerance 4983 0, // minusTolerance 4984 0, 4985 0, 4986 0x80, 4987 0x3f, // stateTransistionInterval=1.0 4988 0, 4989 0, 4990 0x80, 4991 0x3f, // transition_interval=1.0 4992 0x64, // maxSetdable = 100 4993 0x9c, // minSetable = -100 4994 PLDM_RANGE_FIELD_FORMAT_SINT8, // rangeFieldFormat 4995 0x1f, // rangeFieldsupport 4996 0, // nominalValue = 0 4997 5, // normalMax = 5 4998 0xfb, // normalMin = -5 4999 30, // rated_max = 30 5000 0xe2 // rated_min = -30 5001 }; 5002 5003 struct pldm_numeric_effecter_value_pdr decodedPdr; 5004 auto rc = 5005 decode_numeric_effecter_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 5006 EXPECT_EQ(PLDM_SUCCESS, rc); 5007 5008 EXPECT_EQ(PLDM_EFFECTER_DATA_SIZE_SINT8, decodedPdr.effecter_data_size); 5009 EXPECT_EQ(100, decodedPdr.max_settable.value_s8); 5010 EXPECT_EQ(-100, decodedPdr.min_settable.value_s8); 5011 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_SINT8, decodedPdr.range_field_format); 5012 EXPECT_EQ(0x1f, decodedPdr.range_field_support.byte); 5013 EXPECT_EQ(0, decodedPdr.nominal_value.value_s8); 5014 EXPECT_EQ(5, decodedPdr.normal_max.value_s8); 5015 EXPECT_EQ(-5, decodedPdr.normal_min.value_s8); 5016 EXPECT_EQ(30, decodedPdr.rated_max.value_s8); 5017 EXPECT_EQ(-30, decodedPdr.rated_min.value_s8); 5018 } 5019 #endif 5020 5021 #ifdef LIBPLDM_API_TESTING 5022 TEST(decodeNumericEffecterPdrData, Uint16Test) 5023 { 5024 std::vector<uint8_t> pdr1{ 5025 0x1, 5026 0x0, 5027 0x0, 5028 0x0, // record handle 5029 0x1, // PDRHeaderVersion 5030 PLDM_NUMERIC_EFFECTER_PDR, // PDRType 5031 0x0, 5032 0x0, // recordChangeNumber 5033 PLDM_PDR_NUMERIC_EFFECTER_PDR_FIXED_LENGTH + 5034 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_EFFECTER_DATA_SIZE_MIN_LENGTH * 5035 2 + 5036 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 2, 5037 0, // dataLength 5038 0, 5039 0, // PLDMTerminusHandle 5040 0x1, 5041 0x0, // effecterID=1 5042 PLDM_ENTITY_POWER_SUPPLY, 5043 0, // entityType=Power Supply(120) 5044 1, 5045 0, // entityInstanceNumber 5046 0x1, 5047 0x0, // containerID=1 5048 0x2, 5049 0x0, // effecter_semantic_id=2 5050 PLDM_NO_INIT, // effecterInit 5051 false, // effecterAuxiliaryNames 5052 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C 5053 0, // unitModifier 5054 0, // rateUnit 5055 0, // baseOEMUnitHandle 5056 0, // auxUnit 5057 0, // auxUnitModifier 5058 0, // auxRateUnit 5059 0, // auxOEMUnitHandle 5060 true, // isLinear 5061 PLDM_EFFECTER_DATA_SIZE_UINT16, // effecterDataSize 5062 0, 5063 0, 5064 0, 5065 0, // resolution 5066 0, 5067 0, 5068 0, 5069 0, // offset 5070 0, 5071 0, // accuracy 5072 0, // plusTolerance 5073 0, // minusTolerance 5074 0, 5075 0, 5076 0x80, 5077 0x3f, // stateTransistionInterval=1.0 5078 0, 5079 0, 5080 0x80, 5081 0x3f, // transition_interval=1.0 5082 0, 5083 0x10, // maxSetdable = 4096 5084 0, 5085 0, // minSetable = 0 5086 PLDM_RANGE_FIELD_FORMAT_UINT16, // rangeFieldFormat 5087 0x1f, // rangeFieldsupport 5088 0x88, 5089 0x13, // nominalValue = 5,000 5090 0x70, 5091 0x17, // normalMax = 6,000 5092 0xa0, 5093 0x0f, // normalMin = 4,000 5094 0x28, 5095 0x23, // rated_max = 9,000 5096 0xe8, 5097 0x03 // rated_min = 1,000 5098 }; 5099 5100 struct pldm_numeric_effecter_value_pdr decodedPdr; 5101 auto rc = 5102 decode_numeric_effecter_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 5103 EXPECT_EQ(PLDM_SUCCESS, rc); 5104 5105 EXPECT_EQ(PLDM_EFFECTER_DATA_SIZE_UINT16, decodedPdr.effecter_data_size); 5106 EXPECT_EQ(4096, decodedPdr.max_settable.value_u16); 5107 EXPECT_EQ(0, decodedPdr.min_settable.value_u16); 5108 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_UINT16, decodedPdr.range_field_format); 5109 EXPECT_EQ(0x1f, decodedPdr.range_field_support.byte); 5110 EXPECT_EQ(5000, decodedPdr.nominal_value.value_u16); 5111 EXPECT_EQ(6000, decodedPdr.normal_max.value_u16); 5112 EXPECT_EQ(4000, decodedPdr.normal_min.value_u16); 5113 EXPECT_EQ(9000, decodedPdr.rated_max.value_u16); 5114 EXPECT_EQ(1000, decodedPdr.rated_min.value_u16); 5115 } 5116 #endif 5117 5118 #ifdef LIBPLDM_API_TESTING 5119 TEST(decodeNumericEffecterPdrData, Sint16Test) 5120 { 5121 std::vector<uint8_t> pdr1{ 5122 0x1, 5123 0x0, 5124 0x0, 5125 0x0, // record handle 5126 0x1, // PDRHeaderVersion 5127 PLDM_NUMERIC_EFFECTER_PDR, // PDRType 5128 0x0, 5129 0x0, // recordChangeNumber 5130 PLDM_PDR_NUMERIC_EFFECTER_PDR_FIXED_LENGTH + 5131 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_EFFECTER_DATA_SIZE_MIN_LENGTH * 5132 2 + 5133 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 2, 5134 0, // dataLength 5135 0, 5136 0, // PLDMTerminusHandle 5137 0x1, 5138 0x0, // effecterID=1 5139 PLDM_ENTITY_POWER_SUPPLY, 5140 0, // entityType=Power Supply(120) 5141 1, 5142 0, // entityInstanceNumber 5143 0x1, 5144 0x0, // containerID=1 5145 0x2, 5146 0x0, // effecter_semantic_id=2 5147 PLDM_NO_INIT, // effecterInit 5148 false, // effecterAuxiliaryNames 5149 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C 5150 0, // unitModifier 5151 0, // rateUnit 5152 0, // baseOEMUnitHandle 5153 0, // auxUnit 5154 0, // auxUnitModifier 5155 0, // auxRateUnit 5156 0, // auxOEMUnitHandle 5157 true, // isLinear 5158 PLDM_EFFECTER_DATA_SIZE_SINT16, // effecterDataSize 5159 0, 5160 0, 5161 0, 5162 0, // resolution 5163 0, 5164 0, 5165 0, 5166 0, // offset 5167 0, 5168 0, // accuracy 5169 0, // plusTolerance 5170 0, // minusTolerance 5171 0, 5172 0, 5173 0x80, 5174 0x3f, // stateTransistionInterval=1.0 5175 0, 5176 0, 5177 0x80, 5178 0x3f, // transition_interval=1.0 5179 0xe8, 5180 0x03, // maxSetdable = 1000 5181 0x18, 5182 0xfc, // minSetable = -1000 5183 PLDM_RANGE_FIELD_FORMAT_SINT16, // rangeFieldFormat 5184 0x1f, // rangeFieldsupport 5185 0, 5186 0, // nominalValue = 0 5187 0xf4, 5188 0x01, // normalMax = 500 5189 0x0c, 5190 0xfe, // normalMin = -500 5191 0xb8, 5192 0x0b, // rated_max = 3,000 5193 0x48, 5194 0xf4 // rated_min = -3,000 5195 }; 5196 5197 struct pldm_numeric_effecter_value_pdr decodedPdr; 5198 auto rc = 5199 decode_numeric_effecter_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 5200 EXPECT_EQ(PLDM_SUCCESS, rc); 5201 5202 EXPECT_EQ(PLDM_EFFECTER_DATA_SIZE_SINT16, decodedPdr.effecter_data_size); 5203 EXPECT_EQ(1000, decodedPdr.max_settable.value_s16); 5204 EXPECT_EQ(-1000, decodedPdr.min_settable.value_s16); 5205 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_SINT16, decodedPdr.range_field_format); 5206 EXPECT_EQ(0x1f, decodedPdr.range_field_support.byte); 5207 EXPECT_EQ(0, decodedPdr.nominal_value.value_s16); 5208 EXPECT_EQ(500, decodedPdr.normal_max.value_s16); 5209 EXPECT_EQ(-500, decodedPdr.normal_min.value_s16); 5210 EXPECT_EQ(3000, decodedPdr.rated_max.value_s16); 5211 EXPECT_EQ(-3000, decodedPdr.rated_min.value_s16); 5212 } 5213 #endif 5214 5215 #ifdef LIBPLDM_API_TESTING 5216 TEST(decodeNumericEffecterPdrData, Uint32Test) 5217 { 5218 std::vector<uint8_t> pdr1{ 5219 0x1, 5220 0x0, 5221 0x0, 5222 0x0, // record handle 5223 0x1, // PDRHeaderVersion 5224 PLDM_NUMERIC_EFFECTER_PDR, // PDRType 5225 0x0, 5226 0x0, // recordChangeNumber 5227 PLDM_PDR_NUMERIC_EFFECTER_PDR_FIXED_LENGTH + 5228 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_EFFECTER_DATA_SIZE_MIN_LENGTH * 5229 4 + 5230 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 4, 5231 0, // dataLength 5232 0, 5233 0, // PLDMTerminusHandle 5234 0x1, 5235 0x0, // effecterID=1 5236 PLDM_ENTITY_POWER_SUPPLY, 5237 0, // entityType=Power Supply(120) 5238 1, 5239 0, // entityInstanceNumber 5240 0x1, 5241 0x0, // containerID=1 5242 0x2, 5243 0x0, // effecter_semantic_id=2 5244 PLDM_NO_INIT, // effecterInit 5245 false, // effecterAuxiliaryNames 5246 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C 5247 0, // unitModifier 5248 0, // rateUnit 5249 0, // baseOEMUnitHandle 5250 0, // auxUnit 5251 0, // auxUnitModifier 5252 0, // auxRateUnit 5253 0, // auxOEMUnitHandle 5254 true, // isLinear 5255 PLDM_EFFECTER_DATA_SIZE_UINT32, // effecterDataSize 5256 0, 5257 0, 5258 0, 5259 0, // resolution 5260 0, 5261 0, 5262 0, 5263 0, // offset 5264 0, 5265 0, // accuracy 5266 0, // plusTolerance 5267 0, // minusTolerance 5268 0, 5269 0, 5270 0x80, 5271 0x3f, // stateTransistionInterval=1.0 5272 0, 5273 0, 5274 0x80, 5275 0x3f, // transition_interval=1.0 5276 0, 5277 0x10, 5278 0, 5279 0, // maxSetdable = 4096 5280 0, 5281 0, 5282 0, 5283 0, // minSetable = 0 5284 PLDM_RANGE_FIELD_FORMAT_UINT32, // rangeFieldFormat 5285 0x1f, // rangeFieldsupport 5286 0x40, 5287 0x4b, 5288 0x4c, 5289 0x00, // nominalValue = 5,000,000 5290 0x80, 5291 0x8d, 5292 0x5b, 5293 0x00, // normalMax = 6,000,000 5294 0x00, 5295 0x09, 5296 0x3d, 5297 0x00, // normalMin = 4,000,000 5298 0x40, 5299 0x54, 5300 0x89, 5301 0x00, // rated_max = 9,000,000 5302 0x40, 5303 0x42, 5304 0x0f, 5305 0x00 // rated_min = 1,000,000 5306 }; 5307 5308 struct pldm_numeric_effecter_value_pdr decodedPdr; 5309 auto rc = 5310 decode_numeric_effecter_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 5311 EXPECT_EQ(PLDM_SUCCESS, rc); 5312 5313 EXPECT_EQ(PLDM_EFFECTER_DATA_SIZE_UINT32, decodedPdr.effecter_data_size); 5314 EXPECT_EQ(4096, decodedPdr.max_settable.value_u32); 5315 EXPECT_EQ(0, decodedPdr.min_settable.value_u32); 5316 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_UINT32, decodedPdr.range_field_format); 5317 EXPECT_EQ(0x1f, decodedPdr.range_field_support.byte); 5318 EXPECT_EQ(5000000, decodedPdr.nominal_value.value_u32); 5319 EXPECT_EQ(6000000, decodedPdr.normal_max.value_u32); 5320 EXPECT_EQ(4000000, decodedPdr.normal_min.value_u32); 5321 EXPECT_EQ(9000000, decodedPdr.rated_max.value_u32); 5322 EXPECT_EQ(1000000, decodedPdr.rated_min.value_u32); 5323 } 5324 #endif 5325 5326 #ifdef LIBPLDM_API_TESTING 5327 TEST(decodeNumericEffecterPdrData, Sint32Test) 5328 { 5329 std::vector<uint8_t> pdr1{ 5330 0x1, 5331 0x0, 5332 0x0, 5333 0x0, // record handle 5334 0x1, // PDRHeaderVersion 5335 PLDM_NUMERIC_EFFECTER_PDR, // PDRType 5336 0x0, 5337 0x0, // recordChangeNumber 5338 PLDM_PDR_NUMERIC_EFFECTER_PDR_FIXED_LENGTH + 5339 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_EFFECTER_DATA_SIZE_MIN_LENGTH * 5340 4 + 5341 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 4, 5342 0, // dataLength 5343 0, 5344 0, // PLDMTerminusHandle 5345 0x1, 5346 0x0, // effecterID=1 5347 PLDM_ENTITY_POWER_SUPPLY, 5348 0, // entityType=Power Supply(120) 5349 1, 5350 0, // entityInstanceNumber 5351 0x1, 5352 0x0, // containerID=1 5353 0x2, 5354 0x0, // effecter_semantic_id=2 5355 PLDM_NO_INIT, // effecterInit 5356 false, // effecterAuxiliaryNames 5357 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C 5358 0, // unitModifier 5359 0, // rateUnit 5360 0, // baseOEMUnitHandle 5361 0, // auxUnit 5362 0, // auxUnitModifier 5363 0, // auxRateUnit 5364 0, // auxOEMUnitHandle 5365 true, // isLinear 5366 PLDM_EFFECTER_DATA_SIZE_SINT32, // effecterDataSize 5367 0, 5368 0, 5369 0, 5370 0, // resolution 5371 0, 5372 0, 5373 0, 5374 0, // offset 5375 0, 5376 0, // accuracy 5377 0, // plusTolerance 5378 0, // minusTolerance 5379 0, 5380 0, 5381 0x80, 5382 0x3f, // stateTransistionInterval=1.0 5383 0, 5384 0, 5385 0x80, 5386 0x3f, // transition_interval=1.0 5387 0xa0, 5388 0x86, 5389 0x01, 5390 0x00, // maxSetdable = 100000 5391 0x60, 5392 0x79, 5393 0xfe, 5394 0xff, // minSetable = -10000 5395 PLDM_RANGE_FIELD_FORMAT_SINT32, // rangeFieldFormat 5396 0x1f, // rangeFieldsupport 5397 0, 5398 0, 5399 0, 5400 0, // nominalValue = 0 5401 0x20, 5402 0xa1, 5403 0x07, 5404 0x00, // normalMax = 500,000 5405 0xe0, 5406 0x5e, 5407 0xf8, 5408 0xff, // normalMin = -500,000 5409 0xc0, 5410 0xc6, 5411 0x2d, 5412 0x00, // rated_max = 3,000,000 5413 0x40, 5414 0x39, 5415 0xd2, 5416 0xff // rated_min = -3,000,000 5417 }; 5418 5419 struct pldm_numeric_effecter_value_pdr decodedPdr; 5420 auto rc = 5421 decode_numeric_effecter_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 5422 EXPECT_EQ(PLDM_SUCCESS, rc); 5423 EXPECT_EQ(PLDM_EFFECTER_DATA_SIZE_SINT32, decodedPdr.effecter_data_size); 5424 EXPECT_EQ(100000, decodedPdr.max_settable.value_s32); 5425 EXPECT_EQ(-100000, decodedPdr.min_settable.value_s32); 5426 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_SINT32, decodedPdr.range_field_format); 5427 EXPECT_EQ(0x1f, decodedPdr.range_field_support.byte); 5428 EXPECT_EQ(0, decodedPdr.nominal_value.value_s32); 5429 EXPECT_EQ(500000, decodedPdr.normal_max.value_s32); 5430 EXPECT_EQ(-500000, decodedPdr.normal_min.value_s32); 5431 EXPECT_EQ(3000000, decodedPdr.rated_max.value_s32); 5432 EXPECT_EQ(-3000000, decodedPdr.rated_min.value_s32); 5433 } 5434 #endif 5435 5436 #ifdef LIBPLDM_API_TESTING 5437 TEST(decodeNumericEffecterPdrData, Real32Test) 5438 { 5439 std::vector<uint8_t> pdr1{ 5440 0x1, 5441 0x0, 5442 0x0, 5443 0x0, // record handle 5444 0x1, // PDRHeaderVersion 5445 PLDM_NUMERIC_EFFECTER_PDR, // PDRType 5446 0x0, 5447 0x0, // recordChangeNumber 5448 PLDM_PDR_NUMERIC_EFFECTER_PDR_FIXED_LENGTH + 5449 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_EFFECTER_DATA_SIZE_MIN_LENGTH * 5450 4 + 5451 PLDM_PDR_NUMERIC_EFFECTER_PDR_VARIED_RANGE_FIELD_MIN_LENGTH * 4, 5452 0, // dataLength 5453 0, 5454 5455 0, // PLDMTerminusHandle 5456 0x1, 5457 0x0, // effecterID=1 5458 PLDM_ENTITY_POWER_SUPPLY, 5459 0, // entityType=Power Supply(120) 5460 1, 5461 0, // entityInstanceNumber 5462 0x1, 5463 0x0, // containerID=1 5464 0x2, 5465 0x0, // effecter_semantic_id=2 5466 PLDM_NO_INIT, // effecterInit 5467 false, // effecterAuxiliaryNames 5468 PLDM_SENSOR_UNIT_DEGRESS_C, // baseUint(2)=degrees C 5469 0, // unitModifier 5470 0, // rateUnit 5471 0, // baseOEMUnitHandle 5472 0, // auxUnit 5473 0, // auxUnitModifier 5474 0, // auxRateUnit 5475 0, // auxOEMUnitHandle 5476 true, // isLinear 5477 PLDM_EFFECTER_DATA_SIZE_SINT32, // effecterDataSize 5478 0, 5479 0, 5480 0, 5481 0, // resolution 5482 0, 5483 0, 5484 0, 5485 0, // offset 5486 0, 5487 0, // accuracy 5488 0, // plusTolerance 5489 0, // minusTolerance 5490 0, 5491 0, 5492 0x80, 5493 0x3f, // stateTransistionInterval=1.0 5494 0, 5495 0, 5496 0x80, 5497 0x3f, // transition_interval=1.0 5498 0xa0, 5499 0x86, 5500 0x01, 5501 0x00, // maxSetdable = 100000 5502 0x60, 5503 0x79, 5504 0xfe, 5505 0xff, // minSetable = -10000 5506 PLDM_RANGE_FIELD_FORMAT_REAL32, // rangeFieldFormat 5507 0x1f, // rangeFieldsupport 5508 0, 5509 0, 5510 0, 5511 0, // nominalValue = 0.0 5512 0x33, 5513 0x33, 5514 0x48, 5515 0x42, // normalMax = 50.05 5516 0x33, 5517 0x33, 5518 0x48, 5519 0xc2, // normalMin = -50.05 5520 0x62, 5521 0x00, 5522 0x96, 5523 0x43, // rated_max = 300.003 5524 0x62, 5525 0x00, 5526 0x96, 5527 0xc3 // rated_min = -300.003 5528 }; 5529 5530 struct pldm_numeric_effecter_value_pdr decodedPdr; 5531 auto rc = 5532 decode_numeric_effecter_pdr_data(pdr1.data(), pdr1.size(), &decodedPdr); 5533 EXPECT_EQ(PLDM_SUCCESS, rc); 5534 5535 EXPECT_EQ(PLDM_EFFECTER_DATA_SIZE_SINT32, decodedPdr.effecter_data_size); 5536 EXPECT_FLOAT_EQ(1.0f, decodedPdr.state_transition_interval); 5537 EXPECT_FLOAT_EQ(1.0f, decodedPdr.transition_interval); 5538 EXPECT_EQ(100000, decodedPdr.max_settable.value_s32); 5539 EXPECT_EQ(-100000, decodedPdr.min_settable.value_s32); 5540 EXPECT_EQ(PLDM_RANGE_FIELD_FORMAT_REAL32, decodedPdr.range_field_format); 5541 EXPECT_EQ(0x1f, decodedPdr.range_field_support.byte); 5542 EXPECT_FLOAT_EQ(0, decodedPdr.nominal_value.value_f32); 5543 EXPECT_FLOAT_EQ(50.05f, decodedPdr.normal_max.value_f32); 5544 EXPECT_FLOAT_EQ(-50.05f, decodedPdr.normal_min.value_f32); 5545 EXPECT_FLOAT_EQ(300.003f, decodedPdr.rated_max.value_f32); 5546 EXPECT_FLOAT_EQ(-300.003f, decodedPdr.rated_min.value_f32); 5547 } 5548 #endif 5549 5550 TEST(GetStateEffecterStates, testEncodeAndDecodeRequest) 5551 { 5552 std::array<uint8_t, hdrSize + PLDM_GET_STATE_EFFECTER_STATES_REQ_BYTES> 5553 requestMsg{}; 5554 5555 constexpr std::array<uint8_t, 5556 hdrSize + PLDM_GET_STATE_EFFECTER_STATES_REQ_BYTES> 5557 expectedRequestMsg{ 5558 {0x80, PLDM_PLATFORM, PLDM_GET_STATE_EFFECTER_STATES, 1, 0xab}}; 5559 5560 constexpr uint16_t effecter_id = 0xab01; 5561 5562 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 5563 auto request = reinterpret_cast<pldm_msg*>(requestMsg.data()); 5564 5565 auto rc = encode_get_state_effecter_states_req( 5566 0, effecter_id, request, PLDM_GET_STATE_EFFECTER_STATES_REQ_BYTES); 5567 5568 EXPECT_EQ(rc, PLDM_SUCCESS); 5569 EXPECT_EQ(requestMsg, expectedRequestMsg); 5570 5571 uint16_t ret_effecter_id; 5572 5573 rc = decode_get_state_effecter_states_req( 5574 request, requestMsg.size() - hdrSize, &ret_effecter_id); 5575 5576 EXPECT_EQ(rc, PLDM_SUCCESS); 5577 EXPECT_EQ(effecter_id, ret_effecter_id); 5578 5579 // Test invalid length decode request 5580 5581 rc = decode_get_state_effecter_states_req( 5582 request, requestMsg.size() - hdrSize - 1, &ret_effecter_id); 5583 5584 EXPECT_EQ(rc, -EOVERFLOW); 5585 } 5586 5587 TEST(GetStateEffecterStates, testBadEncodeRequest) 5588 { 5589 std::vector<uint8_t> requestMsg(hdrSize + 5590 PLDM_GET_STATE_EFFECTER_STATES_REQ_BYTES); 5591 5592 auto rc = encode_get_state_effecter_states_req( 5593 0, 0, nullptr, PLDM_GET_STATE_EFFECTER_STATES_REQ_BYTES); 5594 EXPECT_EQ(rc, -EINVAL); 5595 } 5596 5597 TEST(GetStateEffecterStates, testBadDecodeRequest) 5598 { 5599 std::array<uint8_t, hdrSize + PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES> 5600 requestMsg{}; 5601 5602 auto rc = decode_get_state_effecter_states_req( 5603 nullptr, requestMsg.size() - hdrSize, nullptr); 5604 5605 EXPECT_EQ(rc, -EINVAL); 5606 } 5607 5608 TEST(GetStateEffecterStates, testEncodeAndDecodeResponse) 5609 { 5610 constexpr uint8_t comp_effecterCnt = 0x2; 5611 constexpr uint8_t completionCode = 0; 5612 std::array<uint8_t, 5613 hdrSize + PLDM_GET_STATE_EFFECTER_STATES_MIN_RESP_BYTES + 5614 PLDM_GET_EFFECTER_STATE_FIELD_SIZE * comp_effecterCnt> 5615 expectedResponseMsg{{0, PLDM_PLATFORM, PLDM_GET_STATE_EFFECTER_STATES, 5616 completionCode, comp_effecterCnt, 5617 EFFECTER_OPER_STATE_ENABLED_NOUPDATEPENDING, 2, 2, 5618 EFFECTER_OPER_STATE_ENABLED_UPDATEPENDING, 2, 3}}; 5619 5620 decltype(expectedResponseMsg) responseMsg{}; 5621 5622 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 5623 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 5624 5625 std::array<get_effecter_state_field, comp_effecterCnt> stateField{ 5626 {{EFFECTER_OPER_STATE_ENABLED_NOUPDATEPENDING, 2, 2}, 5627 {EFFECTER_OPER_STATE_ENABLED_UPDATEPENDING, 2, 3}}}; 5628 5629 struct pldm_get_state_effecter_states_resp resp_fields{ 5630 PLDM_SUCCESS, comp_effecterCnt, {stateField[0], stateField[1]}}; 5631 5632 auto rc = encode_get_state_effecter_states_resp( 5633 0, &resp_fields, response, responseMsg.size() - hdrSize); 5634 5635 EXPECT_EQ(rc, PLDM_SUCCESS); 5636 EXPECT_EQ(expectedResponseMsg, responseMsg); 5637 5638 struct pldm_get_state_effecter_states_resp ret_resp_fields; 5639 5640 rc = decode_get_state_effecter_states_resp( 5641 response, responseMsg.size() - hdrSize, &ret_resp_fields); 5642 5643 EXPECT_EQ(rc, PLDM_SUCCESS); 5644 EXPECT_EQ(completionCode, ret_resp_fields.completion_code); 5645 EXPECT_EQ(comp_effecterCnt, ret_resp_fields.comp_effecter_count); 5646 EXPECT_EQ(stateField[0].effecter_op_state, 5647 ret_resp_fields.field[0].effecter_op_state); 5648 EXPECT_EQ(stateField[0].pending_state, 5649 ret_resp_fields.field[0].pending_state); 5650 EXPECT_EQ(stateField[0].present_state, 5651 ret_resp_fields.field[0].present_state); 5652 EXPECT_EQ(stateField[1].effecter_op_state, 5653 ret_resp_fields.field[1].effecter_op_state); 5654 EXPECT_EQ(stateField[1].pending_state, 5655 ret_resp_fields.field[1].pending_state); 5656 EXPECT_EQ(stateField[1].present_state, 5657 ret_resp_fields.field[1].present_state); 5658 5659 // Test invalid length decode 5660 5661 rc = decode_get_state_effecter_states_resp( 5662 response, 5663 responseMsg.size() - hdrSize + PLDM_GET_EFFECTER_STATE_FIELD_SIZE, 5664 &ret_resp_fields); 5665 5666 EXPECT_EQ(rc, -EBADMSG); 5667 } 5668 5669 TEST(GetStateEffecterStates, testBadEncodeResponse) 5670 { 5671 struct pldm_get_state_effecter_states_resp resp{PLDM_SUCCESS, 0, {}}; 5672 auto rc = decode_get_state_effecter_states_resp(nullptr, 0, &resp); 5673 5674 EXPECT_EQ(rc, -EINVAL); 5675 } 5676 5677 TEST(GetStateEffecterStates, testBadDecodeResponse) 5678 { 5679 std::array<uint8_t, hdrSize + 5680 PLDM_GET_STATE_EFFECTER_STATES_MIN_RESP_BYTES + 5681 PLDM_GET_EFFECTER_STATE_FIELD_SIZE * 2> 5682 responseMsg{}; 5683 5684 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 5685 auto response = reinterpret_cast<pldm_msg*>(responseMsg.data()); 5686 5687 auto rc = decode_get_state_effecter_states_resp( 5688 response, responseMsg.size() - hdrSize, nullptr); 5689 5690 EXPECT_EQ(rc, -EINVAL); 5691 } 5692 5693 [[maybe_unused]] static size_t str16len(char16_t* startptr) 5694 { 5695 char16_t* endptr = startptr; 5696 while (*endptr) 5697 { 5698 endptr++; 5699 } 5700 return endptr - startptr; 5701 } 5702 5703 TEST(decodeEntityAuxNamePdrData, GoodTest) 5704 { 5705 std::vector<uint8_t> pdr1{ 5706 // Common PDR Header 5707 0x1, 0x0, 0x0, 0x0, // record handle 5708 0x1, // PDRHeaderVersion 5709 PLDM_ENTITY_AUXILIARY_NAMES_PDR, // PDRType 5710 0x1, 5711 0x0, // recordChangeNumber 5712 0x27, 5713 0, // dataLength 5714 /* Entity Auxiliary Names PDR Data*/ 5715 3, 5716 0, // entityType system software 5717 0x1, 5718 0x0, // Entity instance number =1 5719 PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID, 5720 0, // Overal system 5721 0, // shared Name Count one name only 5722 03, // nameStringCount 5723 0x65, 0x6e, 0x00, // Language Tag "en" 5724 0x00, 0x53, 0x00, 0x30, 0x00, 0x53, 0x00, 0x00, // Entity Name "S0S" 5725 0x66, 0x6e, 0x00, // Language Tag "en" 5726 0x00, 0x53, 0x00, 0x31, 0x00, 0x00, // Entity Name "S1" 5727 0x67, 0x6e, 0x00, // Language Tag "en" 5728 0x00, 0x52, 0x00, 0x52, 0x00, 0x33, 0x00, 0x00 // Entity Name "RR3" 5729 }; 5730 5731 const char expectTag0[] = {0x65, 0x6e, 0x00}; 5732 const char expectTag1[] = {0x66, 0x6e, 0x00}; 5733 const char expectTag2[] = {0x67, 0x6e, 0x00}; 5734 const char expectName0[] = {0x00, 0x53, 0x00, 0x30, 0x00, 0x53, 0x00, 0x00}; 5735 const char expectName1[] = {0x00, 0x53, 0x00, 0x31, 0x00, 0x00}; 5736 const char expectName2[] = {0x00, 0x52, 0x00, 0x52, 0x00, 0x33, 0x00, 0x00}; 5737 auto names_offset = sizeof(struct pldm_pdr_hdr) + 5738 PLDM_PDR_ENTITY_AUXILIARY_NAME_PDR_MIN_LENGTH; 5739 auto names_size = pdr1.size() - names_offset; 5740 size_t length = 0; 5741 5742 size_t decodedPdrSize = 5743 sizeof(struct pldm_entity_auxiliary_names_pdr) + names_size; 5744 auto decodedPdr = 5745 (struct pldm_entity_auxiliary_names_pdr*)malloc(decodedPdrSize); 5746 EXPECT_NE(nullptr, decodedPdr); 5747 5748 auto rc = decode_entity_auxiliary_names_pdr(pdr1.data(), pdr1.size(), 5749 decodedPdr, decodedPdrSize); 5750 5751 EXPECT_EQ(0, rc); 5752 EXPECT_EQ(1, decodedPdr->hdr.record_handle); 5753 EXPECT_EQ(1, decodedPdr->hdr.version); 5754 EXPECT_EQ(PLDM_ENTITY_AUXILIARY_NAMES_PDR, decodedPdr->hdr.type); 5755 EXPECT_EQ(1, decodedPdr->hdr.record_change_num); 5756 EXPECT_EQ(pdr1.size() - sizeof(struct pldm_pdr_hdr), 5757 decodedPdr->hdr.length); 5758 EXPECT_EQ(3, decodedPdr->container.entity_type); 5759 EXPECT_EQ(1, decodedPdr->container.entity_instance_num); 5760 EXPECT_EQ(PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID, 5761 decodedPdr->container.entity_container_id); 5762 EXPECT_EQ(0, decodedPdr->shared_name_count); 5763 EXPECT_EQ(3, decodedPdr->name_string_count); 5764 5765 decodedPdr->names = (struct pldm_entity_auxiliary_name*)calloc( 5766 decodedPdr->name_string_count, 5767 sizeof(struct pldm_entity_auxiliary_name)); 5768 EXPECT_NE(nullptr, decodedPdr->names); 5769 5770 rc = decode_pldm_entity_auxiliary_names_pdr_index(decodedPdr); 5771 EXPECT_EQ(0, rc); 5772 5773 length = strlen(decodedPdr->names[0].tag); 5774 EXPECT_EQ(strlen(expectTag0), length); 5775 EXPECT_EQ(strncmp(expectTag0, decodedPdr->names[0].tag, length + 1), 0); 5776 5777 // NOLINTBEGIN(clang-analyzer-unix.Malloc) 5778 ASSERT_EQ(0, 5779 (uintptr_t)decodedPdr->names[0].name & (alignof(char16_t) - 1)); 5780 // NOLINTEND(clang-analyzer-unix.Malloc) 5781 length = str16len((char16_t*)decodedPdr->names[0].name); 5782 EXPECT_EQ(str16len((char16_t*)expectName0), length); 5783 EXPECT_EQ(3, str16len((char16_t*)expectName0)); 5784 EXPECT_EQ(memcmp(expectName0, decodedPdr->names[0].name, 5785 sizeof(char16_t) * (length + 1)), 5786 0); 5787 5788 length = strlen(decodedPdr->names[1].tag); 5789 EXPECT_EQ(strlen(expectTag1), length); 5790 EXPECT_EQ(strncmp(expectTag1, decodedPdr->names[1].tag, length + 1), 0); 5791 5792 // NOLINTBEGIN(clang-analyzer-unix.Malloc) 5793 ASSERT_EQ(0, 5794 (uintptr_t)decodedPdr->names[1].name & (alignof(char16_t) - 1)); 5795 // NOLINTEND(clang-analyzer-unix.Malloc) 5796 length = str16len((char16_t*)decodedPdr->names[1].name); 5797 EXPECT_EQ(str16len((char16_t*)expectName1), length); 5798 EXPECT_EQ(2, str16len((char16_t*)expectName1)); 5799 EXPECT_EQ(memcmp(expectName1, decodedPdr->names[1].name, 5800 sizeof(char16_t) * (length + 1)), 5801 0); 5802 5803 length = strlen(decodedPdr->names[2].tag); 5804 EXPECT_EQ(strlen(expectTag2), length); 5805 EXPECT_EQ(strncmp(expectTag2, decodedPdr->names[2].tag, length + 1), 0); 5806 5807 // NOLINTBEGIN(clang-analyzer-unix.Malloc) 5808 ASSERT_EQ(0, 5809 (uintptr_t)decodedPdr->names[2].name & (alignof(char16_t) - 1)); 5810 // NOLINTEND(clang-analyzer-unix.Malloc) 5811 length = str16len((char16_t*)decodedPdr->names[2].name); 5812 EXPECT_EQ(str16len((char16_t*)expectName2), length); 5813 EXPECT_EQ(3, str16len((char16_t*)expectName2)); 5814 EXPECT_EQ(memcmp(expectName2, decodedPdr->names[2].name, 5815 sizeof(char16_t) * (length + 1)), 5816 0); 5817 5818 free(decodedPdr->names); 5819 free(decodedPdr); 5820 } 5821 5822 TEST(decodeEntityAuxNamePdrData, BadTest) 5823 { 5824 std::vector<uint8_t> pdr1{ 5825 // Common PDR Header 5826 0x1, 0x0, 0x0, 0x0, // record handle 5827 0x1, // PDRHeaderVersion 5828 PLDM_ENTITY_AUXILIARY_NAMES_PDR, // PDRType 5829 0x1, 5830 0x0, // recordChangeNumber 5831 0x25, // correct size is 0x27, input invalid size 5832 0, // dataLength 5833 /* Entity Auxiliary Names PDR Data*/ 5834 3, 5835 0, // entityType system software 5836 0x1, 5837 0x0, // Entity instance number =1 5838 PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID, 5839 0, // Overal system 5840 0, // shared Name Count one name only 5841 0, // Invalid nameStringCount 5842 0x65, 0x6e, 0x00, // Language Tag "en" 5843 0x00, 0x53, 0x00, 0x30, 0x00, 0x53, 0x00, 0x00, // Entity Name "S0S" 5844 0x66, 0x6e, 0x00, // Language Tag "en" 5845 0x00, 0x53, 0x00, 0x31, 0x00, 0x00, // Entity Name "S1" 5846 0x67, 0x6e, 0x00, // Language Tag "en" 5847 0x00, 0x52, 0x00, 0x52, 0x00, 0x33, 0x00, 0x00 // Entity Name "RR3" 5848 }; 5849 5850 auto names_offset = sizeof(struct pldm_pdr_hdr) + 5851 PLDM_PDR_ENTITY_AUXILIARY_NAME_PDR_MIN_LENGTH; 5852 auto names_size = pdr1.size() - names_offset; 5853 5854 size_t decodedPdrSize = 5855 sizeof(struct pldm_entity_auxiliary_names_pdr) + names_size; 5856 auto decodedPdr = 5857 (struct pldm_entity_auxiliary_names_pdr*)malloc(decodedPdrSize); 5858 5859 auto rc = decode_entity_auxiliary_names_pdr(pdr1.data(), pdr1.size(), 5860 decodedPdr, decodedPdrSize); 5861 5862 EXPECT_EQ(-EBADMSG, rc); 5863 free(decodedPdr); 5864 } 5865 5866 TEST(PlatformEventMessage, testGoodCperEventDataDecodeRequest) 5867 { 5868 constexpr const size_t eventDataSize = 4; 5869 constexpr const size_t eventSize = 5870 PLDM_PLATFORM_CPER_EVENT_MIN_LENGTH + eventDataSize; 5871 std::array<uint8_t, eventSize> eventData{ 5872 0x1, // format version 5873 0x0, // format type 5874 0x4, 0x0, // event data length 5875 0x44, 0x33, 0x22, 0x11 // data 5876 }; 5877 5878 uint8_t expectedFormatVersion = 1; 5879 uint8_t expectedFormatType = 0; 5880 uint16_t expectedEventDataLength = 4; 5881 uint8_t expectCperEventData[] = {0x44, 0x33, 0x22, 0x11}; 5882 5883 size_t cperEventSize = 5884 sizeof(struct pldm_platform_cper_event) + eventDataSize; 5885 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 5886 auto cper_event = reinterpret_cast<struct pldm_platform_cper_event*>( 5887 malloc(cperEventSize)); 5888 5889 auto rc = decode_pldm_platform_cper_event( 5890 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 5891 reinterpret_cast<const void*>(eventData.data()), eventData.size(), 5892 cper_event, cperEventSize); 5893 5894 EXPECT_EQ(rc, 0); 5895 EXPECT_EQ(cper_event->format_version, expectedFormatVersion); 5896 EXPECT_EQ(cper_event->format_type, expectedFormatType); 5897 EXPECT_EQ(cper_event->event_data_length, expectedEventDataLength); 5898 5899 auto cperEventData = pldm_platform_cper_event_event_data(cper_event); 5900 EXPECT_NE(cperEventData, nullptr); 5901 if (cperEventData) 5902 { 5903 EXPECT_EQ(0, memcmp(expectCperEventData, cperEventData, 5904 expectedEventDataLength)); 5905 } 5906 5907 free(cper_event); 5908 } 5909 5910 TEST(PlatformEventMessage, testBadCperEventDataDecodeRequest) 5911 { 5912 5913 constexpr const size_t eventDataSize = 4; 5914 constexpr const size_t eventSize = 5915 PLDM_PLATFORM_CPER_EVENT_MIN_LENGTH + eventDataSize; 5916 std::array<uint8_t, eventSize> eventData{ 5917 0x1, // format version 5918 0x0, // format type 5919 0x4, 0x0, // event data length 5920 0x44, 0x33, 0x22, 0x11 // data 5921 }; 5922 5923 size_t cperEventSize = 5924 sizeof(struct pldm_platform_cper_event) + eventDataSize; 5925 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 5926 auto cperEvent = reinterpret_cast<struct pldm_platform_cper_event*>( 5927 malloc(cperEventSize)); 5928 5929 auto rc = decode_pldm_platform_cper_event(NULL, eventData.size(), cperEvent, 5930 cperEventSize); 5931 EXPECT_EQ(rc, -EINVAL); 5932 5933 rc = decode_pldm_platform_cper_event( 5934 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 5935 reinterpret_cast<const void*>(eventData.data()), eventData.size(), NULL, 5936 cperEventSize); 5937 EXPECT_EQ(rc, -EINVAL); 5938 5939 rc = decode_pldm_platform_cper_event( 5940 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 5941 reinterpret_cast<uint8_t*>(eventData.data()), eventData.size() - 1, 5942 cperEvent, cperEventSize); 5943 EXPECT_EQ(rc, -EOVERFLOW); 5944 5945 rc = decode_pldm_platform_cper_event( 5946 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 5947 reinterpret_cast<uint8_t*>(eventData.data()), eventData.size(), 5948 cperEvent, cperEventSize - 1); 5949 EXPECT_EQ(rc, -EOVERFLOW); 5950 5951 rc = decode_pldm_platform_cper_event( 5952 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 5953 reinterpret_cast<uint8_t*>(eventData.data()), eventData.size(), 5954 cperEvent, cperEventSize + 1); 5955 EXPECT_EQ(rc, 0); 5956 5957 // Invalid CPER Event Format Type 5958 eventData[1] = 0x2; 5959 rc = decode_pldm_platform_cper_event( 5960 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 5961 reinterpret_cast<const void*>(eventData.data()), eventData.size(), 5962 cperEvent, cperEventSize); 5963 5964 EXPECT_EQ(rc, -EPROTO); 5965 5966 // Invalid cper event data size 5967 eventData[1] = 0x1; 5968 eventData[2] = 3; 5969 rc = decode_pldm_platform_cper_event( 5970 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 5971 reinterpret_cast<const void*>(eventData.data()), eventData.size(), 5972 cperEvent, cperEventSize); 5973 5974 EXPECT_EQ(rc, -EBADMSG); 5975 5976 eventData[2] = 5; 5977 rc = decode_pldm_platform_cper_event( 5978 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast) 5979 reinterpret_cast<const void*>(eventData.data()), eventData.size(), 5980 cperEvent, cperEventSize); 5981 5982 EXPECT_EQ(rc, -EOVERFLOW); 5983 5984 free(cperEvent); 5985 } 5986 5987 #ifdef LIBPLDM_API_TESTING 5988 TEST(decodePldmFileDescriptorPdr, oemFileClassificationPresentTest) 5989 { 5990 std::vector<uint8_t> pdr1{ 5991 // Common PDR Header 5992 0x01, 0x0, 0x0, 0x0, // Record Handle 5993 0x01, // PDR Header Version 5994 PLDM_FILE_DESCRIPTOR_PDR, // PDRType 5995 0x01, 0x00, // Record Change Number 5996 0x2A, 0x00, // Data Length = 42 bytes 5997 /* PLDM File Descriptor PDR Data*/ 5998 0x01, 0x00, // Terminus Handle = 0x01 5999 0x01, 0x00, // File Identifier = 0x01 6000 0x09, 0x00, // Entity Type = Physical | Device File 6001 0x01, 0x00, // Entity instance number = 1 6002 PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID, 6003 0, // Container ID = Overall system 6004 0x02, 0, // Supper Dir File Identifier = 0x0002 6005 0x01, // File Classification = 0x01 (BootLog) 6006 0x01, // OEM File Classification = 0x01 6007 0x15, 0x00, // File Capabilities = 0x0015 6008 0xff, 0xff, 0xff, 0xff, // File Version = 0xffffffff (Unversioned) 6009 0x00, 0x28, 0x00, 0x00, // File Maximum Size = 10KB 6010 0x02, // File Maximum File Descriptor count = 2 6011 0x06, // File Name Length = 6 6012 0x46, 0x69, 0x6C, 0x65, 0x31, 6013 0x00, // File Name = "File1\NULL" 6014 0x09, // OEM File Classification Name Length = 9 6015 0x4F, 0x45, 0x4D, 0x20, 0x46, 0x69, 0x6C, 0x65, 6016 0x00 // OEM File Classification Name = "OEM File\NULL" 6017 }; 6018 6019 const char expectFileName[] = "File1"; 6020 const char expectOEMClassificationName[] = "OEM File"; 6021 6022 struct pldm_file_descriptor_pdr decodedPdr = {}; 6023 6024 auto rc = 6025 decode_pldm_file_descriptor_pdr(pdr1.data(), pdr1.size(), &decodedPdr); 6026 6027 ASSERT_EQ(0, rc); 6028 EXPECT_EQ(1, decodedPdr.terminus_handle); 6029 EXPECT_EQ(1, decodedPdr.file_identifier); 6030 EXPECT_EQ(9, decodedPdr.container.entity_type); 6031 EXPECT_EQ(1, decodedPdr.container.entity_instance_num); 6032 EXPECT_EQ(PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID, 6033 decodedPdr.container.entity_container_id); 6034 EXPECT_EQ(2, decodedPdr.superior_directory_file_identifier); 6035 EXPECT_EQ(1, decodedPdr.file_classification); 6036 EXPECT_EQ(1, decodedPdr.oem_file_classification); 6037 EXPECT_EQ(21, decodedPdr.file_capabilities.value); 6038 EXPECT_EQ(0xff, decodedPdr.file_version.alpha); 6039 EXPECT_EQ(0xff, decodedPdr.file_version.update); 6040 EXPECT_EQ(0xff, decodedPdr.file_version.minor); 6041 EXPECT_EQ(0xff, decodedPdr.file_version.major); 6042 EXPECT_EQ(10240, decodedPdr.file_maximum_size); 6043 EXPECT_EQ(2, decodedPdr.file_maximum_file_descriptor_count); 6044 EXPECT_EQ(6, decodedPdr.file_name.length); 6045 6046 EXPECT_EQ(memcmp(expectFileName, decodedPdr.file_name.ptr, 6047 sizeof(char) * decodedPdr.file_name.length), 6048 0); 6049 6050 if (decodedPdr.oem_file_classification) 6051 { 6052 EXPECT_EQ(9, decodedPdr.oem_file_classification_name.length); 6053 EXPECT_EQ(memcmp(expectOEMClassificationName, 6054 decodedPdr.oem_file_classification_name.ptr, 6055 sizeof(char) * 6056 decodedPdr.oem_file_classification_name.length), 6057 0); 6058 } 6059 } 6060 #endif 6061 6062 #ifdef LIBPLDM_API_TESTING 6063 TEST(decodePldmFileDescriptorPdr, BadTestUnAllocatedPtrParams) 6064 { 6065 int rc; 6066 std::vector<uint8_t> pdr1{ 6067 // Common PDR Header 6068 0x01, 0x0, 0x0, 0x0, // Record Handle 6069 0x01, // PDR Header Version 6070 PLDM_FILE_DESCRIPTOR_PDR, // PDRType 6071 0x01, 0x00, // Record Change Number 6072 0x20, 0x00, // Data Length = 32 bytes 6073 /* PLDM File Descriptor PDR Data*/ 6074 0x01, 0x00, // Terminus Handle = 0x01 6075 0x01, 0x00, // File Identifier = 0x01 6076 0x09, 0x00, // Entity Type = Physical | Device File 6077 0x01, 0x00, // Entity instance number = 1 6078 PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID, 6079 0, // Container ID = Overall system 6080 0x02, 0, // Supper Dir File Identifier = 0x0002 6081 0x01, // File Classification = 0x01 (BootLog) 6082 0x00, // OEM File Classification = 0x00 6083 0x15, 0x00, // File Capabilities = 0x0015 6084 0xff, 0xff, 0xff, 0xff, // File Version = 0xffffffff (Unversioned) 6085 0x00, 0x28, 0x00, 0x00, // File Maximum Size = 10KB 6086 0x02, // File Maximum File Descriptor count = 2 6087 0x06, // File Name Length = 6 6088 0x46, 0x69, 0x6C, 0x65, 0x31, 6089 0x00, // File Name = "File1\NULL" 6090 }; 6091 6092 struct pldm_file_descriptor_pdr decodedPdr = {}; 6093 6094 rc = decode_pldm_file_descriptor_pdr(nullptr, pdr1.size(), &decodedPdr); 6095 EXPECT_EQ(-EINVAL, rc); 6096 6097 rc = decode_pldm_file_descriptor_pdr(pdr1.data(), pdr1.size(), nullptr); 6098 EXPECT_EQ(-EINVAL, rc); 6099 } 6100 #endif 6101 6102 #ifdef LIBPLDM_API_TESTING 6103 TEST(decodePldmFileDescriptorPdr, BadTestInvalidExpectedParamLength) 6104 { 6105 int rc; 6106 6107 std::vector<uint8_t> pdr1{ 6108 // Common PDR Header 6109 0x01, 0x0, 0x0, 0x0, // Record Handle 6110 0x01, // PDR Header Version 6111 PLDM_FILE_DESCRIPTOR_PDR, // PDRType 6112 0x01, 0x00, // Record Change Number 6113 0x20, 0x00, // Data Length = 32 bytes 6114 /* PLDM File Descriptor PDR Data*/ 6115 0x01, 0x00, // Terminus Handle = 0x01 6116 0x01, 0x00, // File Identifier = 0x01 6117 0x09, 0x00, // Entity Type = Physical | Device File 6118 0x01, 0x00, // Entity instance number = 1 6119 PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID, 6120 0, // Container ID = Overall system 6121 0x02, 0, // Supper Dir File Identifier = 0x0002 6122 0x01, // File Classification = 0x01 (BootLog) 6123 0x00, // OEM File Classification = 0x00 6124 0x15, 0x00, // File Capabilities = 0x0015 6125 0xff, 0xff, 0xff, 0xff, // File Version = 0xffffffff (Unversioned) 6126 0x00, 0x28, 0x00, 0x00, // File Maximum Size = 10KB 6127 0x02, // File Maximum File Descriptor count = 2 6128 0x06, // File Name Length = 6 6129 0x46, 0x69, 0x6C, 0x65, 0x31, 6130 0x00, // File Name = "File1\NULL" 6131 }; 6132 6133 struct pldm_file_descriptor_pdr decodedPdr = {}; 6134 6135 /* Expect error: Invalid input data length*/ 6136 rc = decode_pldm_file_descriptor_pdr(pdr1.data(), 1, &decodedPdr); 6137 EXPECT_EQ(-EOVERFLOW, rc); 6138 } 6139 #endif 6140 6141 #ifdef LIBPLDM_API_TESTING 6142 TEST(decodePldmFileDescriptorPdr, BadTestDataBufferOverLength) 6143 { 6144 int rc; 6145 6146 /*Un-matched File Name Length*/ 6147 std::vector<uint8_t> pdr1{ 6148 // Common PDR Header 6149 0x01, 0x0, 0x0, 0x0, // Record Handle 6150 0x01, // PDR Header Version 6151 PLDM_FILE_DESCRIPTOR_PDR, // PDRType 6152 0x01, 0x00, // Record Change Number 6153 0x20, 0x00, // Data Length = 32 bytes 6154 /* PLDM File Descriptor PDR Data*/ 6155 0x01, 0x00, // Terminus Handle = 0x01 6156 0x01, 0x00, // File Identifier = 0x01 6157 0x09, 0x00, // Entity Type = Physical | Device File 6158 0x01, 0x00, // Entity instance number = 1 6159 PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID, 6160 0, // Container ID = Overall system 6161 0x02, 0, // Supper Dir File Identifier = 0x0002 6162 0x01, // File Classification = 0x01 (BootLog) 6163 0x00, // OEM File Classification = 0x00 6164 0x15, 0x00, // File Capabilities = 0x0015 6165 0xff, 0xff, 0xff, 0xff, // File Version = 0xffffffff (Unversioned) 6166 0x00, 0x28, 0x00, 0x00, // File Maximum Size = 10KB 6167 0x02, // File Maximum File Descriptor count = 2 6168 0x05, // File Name Length = 5 6169 0x46, 0x69, 0x6C, 0x65, 0x31, 6170 0x00, // File Name = "File1\NULL" 6171 }; 6172 6173 struct pldm_file_descriptor_pdr decodedPdr = {}; 6174 6175 /* 6176 * Expect error: The original length of the data buffer is larger than 6177 * the target extract length. 6178 */ 6179 rc = decode_pldm_file_descriptor_pdr(pdr1.data(), pdr1.size(), &decodedPdr); 6180 EXPECT_EQ(-EBADMSG, rc); 6181 } 6182 6183 TEST(decodePldmFileDescriptorPdr, BadTestDataBufferUnderLength) 6184 { 6185 int rc; 6186 6187 /*Un-matched OEM File Classification Name Length*/ 6188 std::vector<uint8_t> pdr1{ 6189 // Common PDR Header 6190 0x01, 0x0, 0x0, 0x0, // Record Handle 6191 0x01, // PDR Header Version 6192 PLDM_FILE_DESCRIPTOR_PDR, // PDRType 6193 0x01, 0x00, // Record Change Number 6194 0x2A, 0x00, // Data Length = 42 bytes 6195 /* PLDM File Descriptor PDR Data*/ 6196 0x01, 0x00, // Terminus Handle = 0x01 6197 0x01, 0x00, // File Identifier = 0x01 6198 0x09, 0x00, // Entity Type = Physical | Device File 6199 0x01, 0x00, // Entity instance number = 1 6200 PLDM_PLATFORM_ENTITY_SYSTEM_CONTAINER_ID, 6201 0, // Container ID = Overall system 6202 0x02, 0, // Supper Dir File Identifier = 0x0002 6203 0x01, // File Classification = 0x01 (BootLog) 6204 0x01, // OEM File Classification = 0x01 6205 0x15, 0x00, // File Capabilities = 0x0015 6206 0xff, 0xff, 0xff, 0xff, // File Version = 0xffffffff (Unversioned) 6207 0x00, 0x28, 0x00, 0x00, // File Maximum Size = 10KB 6208 0x02, // File Maximum File Descriptor count = 2 6209 0x06, // File Name Length = 6 6210 0x46, 0x69, 0x6C, 0x65, 0x31, 6211 0x00, // File Name = "File1\NULL" 6212 0x0B, // OEM File Classification Name Length = 11 6213 0x4F, 0x45, 0x4D, 0x20, 0x46, 0x69, 0x6C, 0x65, 6214 0x00 // OEM File Classification Name = "OEM File\NULL" 6215 }; 6216 6217 struct pldm_file_descriptor_pdr decodedPdr = {}; 6218 6219 /* 6220 * Expect error: The original length of the data buffer is smaller than 6221 * the target extract length. 6222 */ 6223 rc = decode_pldm_file_descriptor_pdr(pdr1.data(), pdr1.size(), &decodedPdr); 6224 EXPECT_EQ(-EOVERFLOW, rc); 6225 } 6226 #endif 6227