1 #include <libpldm/file.h> 2 #include <libpldm/pldm_types.h> 3 4 #include <array> 5 #include <cstdint> 6 #include <cstring> 7 #include <vector> 8 9 #include "msgbuf.h" 10 11 #include <gmock/gmock.h> 12 #include <gtest/gtest.h> 13 14 #ifdef LIBPLDM_API_TESTING 15 TEST(EncodeDfOpenReq, GoodTest) 16 { 17 uint8_t instance_id = 0; 18 uint16_t file_identifier = 0x0100; 19 bitfield16_t file_attribute; 20 file_attribute.value = 0x0400; 21 std::array<uint8_t, PLDM_DF_OPEN_REQ_BYTES> requestMsg = {0x00, 0x01, 0x00, 22 0x04}; 23 24 const struct pldm_file_df_open_req req_data = {file_identifier, 25 file_attribute}; 26 27 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_OPEN_REQ_BYTES); 28 auto rc = encode_pldm_file_df_open_req(instance_id, &req_data, requestPtr, 29 PLDM_DF_OPEN_REQ_BYTES); 30 31 ASSERT_EQ(rc, 0); 32 EXPECT_EQ( 33 0, memcmp(requestPtr->payload, requestMsg.data(), sizeof(requestMsg))); 34 } 35 #endif 36 37 #ifdef LIBPLDM_API_TESTING 38 TEST(EncodeDfOpenReq, BadTestUnAllocatedPtrParams) 39 { 40 uint8_t instance_id = 0; 41 uint16_t file_identifier = 0x0100; 42 bitfield16_t file_attribute; 43 file_attribute.value = 0x0400; 44 int rc; 45 46 const struct pldm_file_df_open_req req_data = {file_identifier, 47 file_attribute}; 48 49 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_OPEN_REQ_BYTES); 50 rc = encode_pldm_file_df_open_req(instance_id, &req_data, nullptr, 51 PLDM_DF_OPEN_REQ_BYTES); 52 EXPECT_EQ(rc, -EINVAL); 53 54 rc = encode_pldm_file_df_open_req(instance_id, nullptr, requestPtr, 55 PLDM_DF_OPEN_REQ_BYTES); 56 EXPECT_EQ(rc, -EINVAL); 57 } 58 #endif 59 60 #ifdef LIBPLDM_API_TESTING 61 TEST(EncodeDfOpenReq, BadTestInvalidExpectedOutputMsgLength) 62 { 63 uint8_t instance_id = 0; 64 uint16_t file_identifier = 0x0100; 65 bitfield16_t file_attribute; 66 file_attribute.value = 0x0400; 67 int rc; 68 69 const struct pldm_file_df_open_req req_data = {file_identifier, 70 file_attribute}; 71 72 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_OPEN_REQ_BYTES); 73 rc = encode_pldm_file_df_open_req(instance_id, &req_data, requestPtr, 1); 74 EXPECT_EQ(rc, -EOVERFLOW); 75 } 76 #endif 77 78 #ifdef LIBPLDM_API_TESTING 79 TEST(DecodeDfOpenResp, GoodTest) 80 { 81 uint8_t completion_code = PLDM_SUCCESS; 82 uint16_t file_descriptor = 20; 83 84 struct pldm_file_df_open_resp resp_data = {}; 85 86 PLDM_MSGBUF_DEFINE_P(buf); 87 int rc; 88 89 static constexpr const size_t payload_length = PLDM_DF_OPEN_RESP_BYTES; 90 91 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 92 93 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 94 ASSERT_EQ(rc, 0); 95 96 pldm_msgbuf_insert_uint8(buf, completion_code); 97 pldm_msgbuf_insert_uint16(buf, file_descriptor); 98 99 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 100 101 rc = decode_pldm_file_df_open_resp(responseMsg, payload_length, &resp_data); 102 103 ASSERT_EQ(rc, 0); 104 EXPECT_EQ(resp_data.completion_code, completion_code); 105 EXPECT_EQ(resp_data.file_descriptor, file_descriptor); 106 } 107 #endif 108 109 #ifdef LIBPLDM_API_TESTING 110 TEST(DecodeDfOpenResp, BadTestUnAllocatedPtrParams) 111 { 112 uint8_t completion_code = PLDM_SUCCESS; 113 uint16_t file_descriptor = 20; 114 115 struct pldm_file_df_open_resp resp_data = {}; 116 117 PLDM_MSGBUF_DEFINE_P(buf); 118 int rc; 119 120 static constexpr const size_t payload_length = PLDM_DF_OPEN_RESP_BYTES; 121 122 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 123 124 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 125 ASSERT_EQ(rc, 0); 126 127 pldm_msgbuf_insert_uint8(buf, completion_code); 128 pldm_msgbuf_insert_uint16(buf, file_descriptor); 129 130 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 131 132 rc = decode_pldm_file_df_open_resp(nullptr, payload_length, &resp_data); 133 EXPECT_EQ(rc, -EINVAL); 134 135 rc = decode_pldm_file_df_open_resp(responseMsg, payload_length, nullptr); 136 EXPECT_EQ(rc, -EINVAL); 137 } 138 #endif 139 140 #ifdef LIBPLDM_API_TESTING 141 TEST(DecodeDfOpenResp, BadTestInvalidExpectedInputMsgLength) 142 { 143 uint8_t completion_code = PLDM_SUCCESS; 144 uint16_t file_descriptor = 20; 145 146 struct pldm_file_df_open_resp resp_data = {}; 147 148 PLDM_MSGBUF_DEFINE_P(buf); 149 int rc; 150 151 static constexpr const size_t payload_length = PLDM_DF_OPEN_RESP_BYTES; 152 153 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 154 155 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 156 ASSERT_EQ(rc, 0); 157 158 pldm_msgbuf_insert_uint8(buf, completion_code); 159 pldm_msgbuf_insert_uint16(buf, file_descriptor); 160 161 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 162 163 rc = decode_pldm_file_df_open_resp(responseMsg, 0, &resp_data); 164 EXPECT_EQ(rc, -EOVERFLOW); 165 } 166 #endif 167 168 #ifdef LIBPLDM_API_TESTING 169 TEST(EncodeDfCloseReq, GoodTest) 170 { 171 uint8_t instance_id = 0; 172 uint16_t file_descriptor = 0x0200; 173 bitfield16_t df_close_options; 174 df_close_options.value = 0x0100; 175 std::array<uint8_t, PLDM_DF_CLOSE_REQ_BYTES> requestMsg = {0x00, 0x02, 0x00, 176 0x01}; 177 178 const struct pldm_file_df_close_req req_data = {file_descriptor, 179 df_close_options}; 180 181 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_OPEN_REQ_BYTES); 182 auto rc = encode_pldm_file_df_close_req(instance_id, &req_data, requestPtr, 183 PLDM_DF_CLOSE_REQ_BYTES); 184 185 ASSERT_EQ(rc, 0); 186 EXPECT_EQ( 187 0, memcmp(requestPtr->payload, requestMsg.data(), sizeof(requestMsg))); 188 } 189 #endif 190 191 #ifdef LIBPLDM_API_TESTING 192 TEST(EncodeDfCloseReq, BadTestUnAllocatedPtrParams) 193 { 194 uint8_t instance_id = 0; 195 uint16_t file_descriptor = 0x0200; 196 bitfield16_t df_close_options; 197 df_close_options.value = 0x0100; 198 int rc; 199 200 const struct pldm_file_df_close_req req_data = {file_descriptor, 201 df_close_options}; 202 203 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_CLOSE_REQ_BYTES); 204 rc = encode_pldm_file_df_close_req(instance_id, &req_data, nullptr, 205 PLDM_DF_CLOSE_REQ_BYTES); 206 EXPECT_EQ(rc, -EINVAL); 207 208 rc = encode_pldm_file_df_close_req(instance_id, nullptr, requestPtr, 209 PLDM_DF_CLOSE_REQ_BYTES); 210 EXPECT_EQ(rc, -EINVAL); 211 } 212 #endif 213 214 #ifdef LIBPLDM_API_TESTING 215 TEST(EncodeDfCloseReq, BadTestInvalidExpectedOutputMsgLength) 216 { 217 uint8_t instance_id = 0; 218 uint16_t file_descriptor = 0x0200; 219 bitfield16_t df_close_options; 220 df_close_options.value = 0x0100; 221 int rc; 222 223 const struct pldm_file_df_close_req req_data = {file_descriptor, 224 df_close_options}; 225 226 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_CLOSE_REQ_BYTES); 227 rc = encode_pldm_file_df_close_req(instance_id, &req_data, requestPtr, 1); 228 EXPECT_EQ(rc, -EOVERFLOW); 229 } 230 #endif 231 232 #ifdef LIBPLDM_API_TESTING 233 TEST(DecodeDfCloseResp, GoodTest) 234 { 235 uint8_t completion_code = PLDM_SUCCESS; 236 237 struct pldm_file_df_close_resp resp_data = {}; 238 239 PLDM_MSGBUF_DEFINE_P(buf); 240 int rc; 241 242 static constexpr const size_t payload_length = PLDM_DF_CLOSE_RESP_BYTES; 243 244 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 245 246 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 247 ASSERT_EQ(rc, 0); 248 249 pldm_msgbuf_insert_uint8(buf, completion_code); 250 251 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 252 253 rc = 254 decode_pldm_file_df_close_resp(responseMsg, payload_length, &resp_data); 255 256 ASSERT_EQ(rc, 0); 257 EXPECT_EQ(resp_data.completion_code, completion_code); 258 } 259 #endif 260 261 #ifdef LIBPLDM_API_TESTING 262 TEST(DecodeDfCloseResp, BadTestUnAllocatedPtrParams) 263 { 264 uint8_t completion_code = PLDM_SUCCESS; 265 266 struct pldm_file_df_close_resp resp_data = {}; 267 268 PLDM_MSGBUF_DEFINE_P(buf); 269 int rc; 270 271 static constexpr const size_t payload_length = PLDM_DF_CLOSE_RESP_BYTES; 272 273 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 274 275 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 276 ASSERT_EQ(rc, 0); 277 278 pldm_msgbuf_insert_uint8(buf, completion_code); 279 280 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 281 282 rc = decode_pldm_file_df_close_resp(nullptr, payload_length, &resp_data); 283 EXPECT_EQ(rc, -EINVAL); 284 285 rc = decode_pldm_file_df_close_resp(responseMsg, payload_length, nullptr); 286 EXPECT_EQ(rc, -EINVAL); 287 } 288 #endif 289 290 #ifdef LIBPLDM_API_TESTING 291 TEST(EncodeDfHeartbeatReq, GoodTest) 292 { 293 uint8_t instance_id = 0; 294 uint16_t file_descriptor = 0x0200; 295 uint32_t requester_max_interval = 0x88130000; // 5000 ms 296 std::array<uint8_t, PLDM_DF_HEARTBEAT_REQ_BYTES> requestMsg = { 297 0x00, 0x02, 0x00, 0x00, 0x13, 0x88}; 298 299 const struct pldm_file_df_heartbeat_req req_data = {file_descriptor, 300 requester_max_interval}; 301 302 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES); 303 auto rc = encode_pldm_file_df_heartbeat_req( 304 instance_id, &req_data, requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES); 305 306 ASSERT_EQ(rc, 0); 307 EXPECT_EQ( 308 0, memcmp(requestPtr->payload, requestMsg.data(), sizeof(requestMsg))); 309 } 310 #endif 311 312 #ifdef LIBPLDM_API_TESTING 313 TEST(EncodeDfHeartbeatReq, BadTestUnAllocatedPtrParams) 314 { 315 uint8_t instance_id = 0; 316 uint16_t file_descriptor = 0x0200; 317 uint32_t requester_max_interval = 0x88130000; // 5000 ms 318 int rc; 319 320 const struct pldm_file_df_heartbeat_req req_data = {file_descriptor, 321 requester_max_interval}; 322 323 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES); 324 rc = encode_pldm_file_df_heartbeat_req(instance_id, &req_data, nullptr, 325 PLDM_DF_HEARTBEAT_REQ_BYTES); 326 EXPECT_EQ(rc, -EINVAL); 327 328 rc = encode_pldm_file_df_heartbeat_req(instance_id, nullptr, requestPtr, 329 PLDM_DF_HEARTBEAT_REQ_BYTES); 330 EXPECT_EQ(rc, -EINVAL); 331 } 332 #endif 333 334 #ifdef LIBPLDM_API_TESTING 335 TEST(EncodeDfHeartbeatReq, BadTestInvalidExpectedOutputMsgLength) 336 { 337 uint8_t instance_id = 0; 338 uint16_t file_descriptor = 0x0200; 339 uint32_t requester_max_interval = 0x88130000; // 5000 ms 340 int rc; 341 342 const struct pldm_file_df_heartbeat_req req_data = {file_descriptor, 343 requester_max_interval}; 344 345 PLDM_MSG_DEFINE_P(requestPtr, PLDM_DF_HEARTBEAT_REQ_BYTES); 346 rc = encode_pldm_file_df_heartbeat_req(instance_id, &req_data, requestPtr, 347 1); 348 EXPECT_EQ(rc, -EOVERFLOW); 349 } 350 #endif 351 352 #ifdef LIBPLDM_API_TESTING 353 TEST(DecodeDfHeartbeatResp, GoodTest) 354 { 355 uint8_t completion_code = PLDM_SUCCESS; 356 uint32_t responder_max_interval = 0xa00f0000; // 4000 ms 357 358 struct pldm_file_df_heartbeat_resp resp_data = {}; 359 360 PLDM_MSGBUF_DEFINE_P(buf); 361 int rc; 362 363 static constexpr const size_t payload_length = PLDM_DF_HEARTBEAT_RESP_BYTES; 364 365 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 366 367 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 368 ASSERT_EQ(rc, 0); 369 370 pldm_msgbuf_insert_uint8(buf, completion_code); 371 pldm_msgbuf_insert_uint32(buf, responder_max_interval); 372 373 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 374 375 rc = decode_pldm_file_df_heartbeat_resp(responseMsg, payload_length, 376 &resp_data); 377 378 ASSERT_EQ(rc, 0); 379 EXPECT_EQ(resp_data.completion_code, completion_code); 380 EXPECT_EQ(resp_data.responder_max_interval, responder_max_interval); 381 } 382 #endif 383 384 #ifdef LIBPLDM_API_TESTING 385 TEST(DecodeDfHeartbeatResp, BadTestUnAllocatedPtrParams) 386 { 387 uint8_t completion_code = PLDM_SUCCESS; 388 uint32_t responder_max_interval = 0xa00f0000; // 4000 ms 389 390 struct pldm_file_df_heartbeat_resp resp_data = {}; 391 392 PLDM_MSGBUF_DEFINE_P(buf); 393 int rc; 394 395 static constexpr const size_t payload_length = PLDM_DF_HEARTBEAT_RESP_BYTES; 396 397 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 398 399 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 400 ASSERT_EQ(rc, 0); 401 402 pldm_msgbuf_insert_uint8(buf, completion_code); 403 pldm_msgbuf_insert_uint32(buf, responder_max_interval); 404 405 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 406 407 rc = 408 decode_pldm_file_df_heartbeat_resp(nullptr, payload_length, &resp_data); 409 EXPECT_EQ(rc, -EINVAL); 410 411 rc = decode_pldm_file_df_heartbeat_resp(responseMsg, payload_length, 412 nullptr); 413 EXPECT_EQ(rc, -EINVAL); 414 } 415 #endif 416 417 #ifdef LIBPLDM_API_TESTING 418 TEST(DecodeDfHeartbeatResp, BadTestInvalidExpectedInputMsgLength) 419 { 420 uint8_t completion_code = PLDM_SUCCESS; 421 uint32_t responder_max_interval = 0xa00f0000; // 4000 ms 422 423 struct pldm_file_df_heartbeat_resp resp_data = {}; 424 425 PLDM_MSGBUF_DEFINE_P(buf); 426 int rc; 427 428 static constexpr const size_t payload_length = PLDM_DF_HEARTBEAT_RESP_BYTES; 429 430 PLDM_MSG_DEFINE_P(responseMsg, payload_length); 431 432 rc = pldm_msgbuf_init_errno(buf, 0, responseMsg->payload, payload_length); 433 ASSERT_EQ(rc, 0); 434 435 pldm_msgbuf_insert_uint8(buf, completion_code); 436 pldm_msgbuf_insert_uint32(buf, responder_max_interval); 437 438 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 439 440 rc = decode_pldm_file_df_heartbeat_resp(responseMsg, 0, &resp_data); 441 EXPECT_EQ(rc, -EOVERFLOW); 442 } 443 #endif 444 445 #ifdef LIBPLDM_API_TESTING 446 TEST(EncodeDfOpenResp, GoodTest) 447 { 448 uint8_t instance_id = 0; 449 uint8_t completion_code = PLDM_SUCCESS; 450 uint16_t file_descriptor = 0x0100; 451 size_t payload_length = PLDM_DF_OPEN_RESP_BYTES; 452 std::array<uint8_t, PLDM_DF_OPEN_RESP_BYTES> responseMsg = {0x00, 0x00, 453 0x01}; 454 455 const struct pldm_file_df_open_resp resp_data = {completion_code, 456 file_descriptor}; 457 458 PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_OPEN_RESP_BYTES); 459 auto rc = encode_pldm_file_df_open_resp(instance_id, &resp_data, 460 responsePtr, &payload_length); 461 462 ASSERT_EQ(rc, 0); 463 EXPECT_EQ(0, memcmp(responsePtr->payload, responseMsg.data(), 464 sizeof(responseMsg))); 465 EXPECT_EQ(payload_length, PLDM_DF_OPEN_RESP_BYTES); 466 } 467 #endif 468 469 #ifdef LIBPLDM_API_TESTING 470 TEST(EncodeDfOpenResp, BadTestUnAllocatedPtrParams) 471 { 472 uint8_t instance_id = 0; 473 uint8_t completion_code = PLDM_SUCCESS; 474 uint16_t file_descriptor = 0x0100; 475 int rc; 476 size_t payload_length = PLDM_DF_OPEN_RESP_BYTES; 477 const struct pldm_file_df_open_resp resp_data = {completion_code, 478 file_descriptor}; 479 480 PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_OPEN_RESP_BYTES); 481 rc = encode_pldm_file_df_open_resp(instance_id, &resp_data, nullptr, 482 &payload_length); 483 EXPECT_EQ(rc, -EINVAL); 484 485 rc = encode_pldm_file_df_open_req(instance_id, nullptr, responsePtr, 486 PLDM_DF_OPEN_RESP_BYTES); 487 EXPECT_EQ(rc, -EINVAL); 488 } 489 #endif 490 491 #ifdef LIBPLDM_API_TESTING 492 TEST(EncodeDfOpenResp, BadTestInvalidExpectedOutputMsgLength) 493 { 494 uint8_t instance_id = 0; 495 uint8_t completion_code = PLDM_SUCCESS; 496 uint16_t file_descriptor = 0x0100; 497 size_t payload_length; 498 499 const struct pldm_file_df_open_resp resp_data = {completion_code, 500 file_descriptor}; 501 502 PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_OPEN_RESP_BYTES); 503 payload_length = 1; 504 auto rc = encode_pldm_file_df_open_resp(instance_id, &resp_data, 505 responsePtr, &payload_length); 506 EXPECT_EQ(rc, -EOVERFLOW); 507 } 508 #endif 509 510 #ifdef LIBPLDM_API_TESTING 511 TEST(EncodeDfOpenResp, GoodTestCompletionCode) 512 { 513 uint8_t instance_id = 0; 514 uint8_t completion_code = PLDM_FILE_CC_INVALID_FILE_DESCRIPTOR; 515 uint16_t file_descriptor = 0x0100; 516 size_t payload_length = PLDM_DF_OPEN_RESP_BYTES; 517 518 const struct pldm_file_df_open_resp resp_data = {completion_code, 519 file_descriptor}; 520 521 PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_OPEN_RESP_BYTES); 522 auto rc = encode_pldm_file_df_open_resp(instance_id, &resp_data, 523 responsePtr, &payload_length); 524 EXPECT_EQ(rc, 0); 525 EXPECT_EQ(payload_length, 1); // Completion code only 526 } 527 #endif 528 529 #ifdef LIBPLDM_API_TESTING 530 TEST(DecodeDfOpenReq, GoodTest) 531 { 532 uint16_t file_identifier = 0x0100; 533 bitfield16_t file_attribute; 534 file_attribute.value = 0x0400; 535 536 struct pldm_file_df_open_req req_data = {}; 537 538 PLDM_MSGBUF_DEFINE_P(buf); 539 int rc; 540 541 static constexpr const size_t payload_length = PLDM_DF_OPEN_REQ_BYTES; 542 543 PLDM_MSG_DEFINE_P(requestMsg, payload_length); 544 545 rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length); 546 ASSERT_EQ(rc, 0); 547 548 pldm_msgbuf_insert_uint16(buf, file_identifier); 549 pldm_msgbuf_insert_uint16(buf, file_attribute.value); 550 551 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 552 553 rc = decode_pldm_file_df_open_req(requestMsg, payload_length, &req_data); 554 555 ASSERT_EQ(rc, 0); 556 EXPECT_EQ(req_data.file_identifier, file_identifier); 557 EXPECT_EQ(req_data.file_attribute.value, file_attribute.value); 558 } 559 #endif 560 561 #ifdef LIBPLDM_API_TESTING 562 TEST(DecodeDfOpenReq, BadTestUnAllocatedPtrParams) 563 { 564 uint16_t file_identifier = 0x0100; 565 bitfield16_t file_attribute; 566 file_attribute.value = 0x0400; 567 568 struct pldm_file_df_open_req req_data = {}; 569 570 PLDM_MSGBUF_DEFINE_P(buf); 571 int rc; 572 573 static constexpr const size_t payload_length = PLDM_DF_OPEN_REQ_BYTES; 574 575 PLDM_MSG_DEFINE_P(requestMsg, payload_length); 576 577 rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length); 578 ASSERT_EQ(rc, 0); 579 580 pldm_msgbuf_insert_uint16(buf, file_identifier); 581 pldm_msgbuf_insert_uint16(buf, file_attribute.value); 582 583 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 584 585 rc = decode_pldm_file_df_open_req(nullptr, payload_length, &req_data); 586 EXPECT_EQ(rc, -EINVAL); 587 588 rc = decode_pldm_file_df_open_req(requestMsg, payload_length, nullptr); 589 EXPECT_EQ(rc, -EINVAL); 590 } 591 #endif 592 593 #ifdef LIBPLDM_API_TESTING 594 TEST(DecodeDfOpenReq, BadTestInvalidExpectedInputMsgLength) 595 { 596 uint16_t file_identifier = 0x0100; 597 bitfield16_t file_attribute; 598 file_attribute.value = 0x0400; 599 600 struct pldm_file_df_open_req req_data = {}; 601 602 PLDM_MSGBUF_DEFINE_P(buf); 603 int rc; 604 605 static constexpr const size_t payload_length = PLDM_DF_OPEN_REQ_BYTES; 606 607 PLDM_MSG_DEFINE_P(requestMsg, payload_length); 608 609 rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length); 610 ASSERT_EQ(rc, 0); 611 612 pldm_msgbuf_insert_uint16(buf, file_identifier); 613 pldm_msgbuf_insert_uint16(buf, file_attribute.value); 614 615 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 616 617 rc = decode_pldm_file_df_open_req(requestMsg, 0, &req_data); 618 EXPECT_EQ(rc, -EOVERFLOW); 619 } 620 #endif 621 622 #ifdef LIBPLDM_API_TESTING 623 TEST(EncodeDfCloseResp, GoodTest) 624 { 625 uint8_t instance_id = 0; 626 size_t payload_length = PLDM_DF_CLOSE_RESP_BYTES; 627 std::array<uint8_t, PLDM_DF_CLOSE_RESP_BYTES> responseMsg = {PLDM_SUCCESS}; 628 629 const struct pldm_file_df_close_resp resp_data = {PLDM_SUCCESS}; 630 631 PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_CLOSE_RESP_BYTES); 632 633 auto rc = encode_pldm_file_df_close_resp(instance_id, &resp_data, 634 responsePtr, &payload_length); 635 636 ASSERT_EQ(rc, 0); 637 EXPECT_EQ(0, memcmp(responsePtr->payload, responseMsg.data(), 638 sizeof(responseMsg))); 639 } 640 #endif 641 642 #ifdef LIBPLDM_API_TESTING 643 TEST(EncodeDfCloseResp, BadTestUnAllocatedPtrParams) 644 { 645 uint8_t instance_id = 0; 646 size_t payload_length = PLDM_DF_CLOSE_RESP_BYTES; 647 const struct pldm_file_df_close_resp resp_data = {PLDM_SUCCESS}; 648 int rc; 649 650 PLDM_MSG_DEFINE_P(responsePtr, PLDM_DF_CLOSE_RESP_BYTES); 651 652 rc = encode_pldm_file_df_close_resp(instance_id, &resp_data, nullptr, 653 &payload_length); 654 EXPECT_EQ(rc, -EINVAL); 655 656 rc = encode_pldm_file_df_close_resp(instance_id, nullptr, responsePtr, 657 &payload_length); 658 EXPECT_EQ(rc, -EINVAL); 659 } 660 #endif 661 662 #ifdef LIBPLDM_API_TESTING 663 TEST(DecodeDfCloseReq, GoodTest) 664 { 665 uint16_t file_descriptor = 0x1000; 666 bitfield16_t df_close_options; 667 df_close_options.value = 0x4000; 668 669 struct pldm_file_df_close_req req_data = {}; 670 671 PLDM_MSGBUF_DEFINE_P(buf); 672 int rc; 673 674 static constexpr const size_t payload_length = PLDM_DF_CLOSE_REQ_BYTES; 675 676 PLDM_MSG_DEFINE_P(requestMsg, payload_length); 677 678 rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length); 679 ASSERT_EQ(rc, 0); 680 681 pldm_msgbuf_insert_uint16(buf, file_descriptor); 682 pldm_msgbuf_insert_uint16(buf, df_close_options.value); 683 684 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 685 686 rc = decode_pldm_file_df_close_req(requestMsg, payload_length, &req_data); 687 688 ASSERT_EQ(rc, 0); 689 EXPECT_EQ(req_data.file_descriptor, file_descriptor); 690 EXPECT_EQ(req_data.df_close_options.value, df_close_options.value); 691 } 692 #endif 693 694 #ifdef LIBPLDM_API_TESTING 695 TEST(DecodeDfCloseReq, BadTestUnAllocatedPtrParams) 696 { 697 uint16_t file_descriptor = 0x1000; 698 bitfield16_t df_close_options; 699 df_close_options.value = 0x4000; 700 701 struct pldm_file_df_close_req req_data = {}; 702 703 PLDM_MSGBUF_DEFINE_P(buf); 704 int rc; 705 706 static constexpr const size_t payload_length = PLDM_DF_CLOSE_REQ_BYTES; 707 708 PLDM_MSG_DEFINE_P(requestMsg, payload_length); 709 710 rc = pldm_msgbuf_init_errno(buf, 0, requestMsg->payload, payload_length); 711 ASSERT_EQ(rc, 0); 712 713 pldm_msgbuf_insert_uint16(buf, file_descriptor); 714 pldm_msgbuf_insert_uint16(buf, df_close_options.value); 715 716 ASSERT_EQ(pldm_msgbuf_complete_consumed(buf), 0); 717 718 rc = decode_pldm_file_df_close_req(nullptr, payload_length, &req_data); 719 EXPECT_EQ(rc, -EINVAL); 720 721 rc = decode_pldm_file_df_close_req(requestMsg, payload_length, nullptr); 722 EXPECT_EQ(rc, -EINVAL); 723 } 724 #endif 725