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