1 #include <endian.h> 2 3 #include <cfloat> 4 5 #include <gtest/gtest.h> 6 7 /* We're exercising the implementation so disable the asserts for now */ 8 #ifndef NDEBUG 9 #define NDEBUG 1 10 #endif 11 12 #include "msgbuf.h" 13 14 TEST(msgbuf, init_bad_ctx) 15 { 16 EXPECT_NE(pldm_msgbuf_init(NULL, 0, NULL, 0), PLDM_SUCCESS); 17 } 18 19 TEST(msgbuf, init_bad_minsize) 20 { 21 struct pldm_msgbuf _ctx; 22 struct pldm_msgbuf* ctx = &_ctx; 23 uint8_t buf[1] = {}; 24 25 EXPECT_NE(pldm_msgbuf_init(ctx, sizeof(buf) + 1U, buf, sizeof(buf)), 26 PLDM_SUCCESS); 27 } 28 29 TEST(msgbuf, init_bad_buf) 30 { 31 struct pldm_msgbuf _ctx; 32 struct pldm_msgbuf* ctx = &_ctx; 33 34 EXPECT_NE(pldm_msgbuf_init(ctx, 0, NULL, 0), PLDM_SUCCESS); 35 } 36 37 TEST(msgbuf, init_bad_len) 38 { 39 struct pldm_msgbuf _ctx; 40 struct pldm_msgbuf* ctx = &_ctx; 41 uint8_t buf[1] = {}; 42 43 EXPECT_NE(pldm_msgbuf_init(ctx, sizeof(buf), buf, SIZE_MAX), PLDM_SUCCESS); 44 } 45 46 TEST(msgbuf, init_overflow) 47 { 48 struct pldm_msgbuf _ctx; 49 struct pldm_msgbuf* ctx = &_ctx; 50 // NOLINTNEXTLINE(performance-no-int-to-ptr) 51 void* buf = (void*)UINTPTR_MAX; 52 53 EXPECT_NE(pldm_msgbuf_init(ctx, 0, buf, 2), PLDM_SUCCESS); 54 } 55 56 TEST(msgbuf, init_success) 57 { 58 struct pldm_msgbuf _ctx; 59 struct pldm_msgbuf* ctx = &_ctx; 60 uint8_t buf[1] = {}; 61 62 EXPECT_EQ(pldm_msgbuf_init(ctx, sizeof(buf), buf, sizeof(buf)), 63 PLDM_SUCCESS); 64 } 65 66 TEST(msgbuf, destroy_none) 67 { 68 struct pldm_msgbuf _ctx; 69 struct pldm_msgbuf* ctx = &_ctx; 70 uint8_t buf[1] = {}; 71 72 ASSERT_EQ(pldm_msgbuf_init(ctx, sizeof(buf), buf, sizeof(buf)), 73 PLDM_SUCCESS); 74 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 75 } 76 77 TEST(msgbuf, destroy_exact) 78 { 79 struct pldm_msgbuf _ctx; 80 struct pldm_msgbuf* ctx = &_ctx; 81 uint8_t buf[1] = {0xa5}; 82 uint8_t val; 83 84 ASSERT_EQ(pldm_msgbuf_init(ctx, sizeof(buf), buf, sizeof(buf)), 85 PLDM_SUCCESS); 86 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS); 87 EXPECT_EQ(val, 0xa5); 88 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 89 } 90 91 TEST(msgbuf, destroy_over) 92 { 93 struct pldm_msgbuf _ctx; 94 struct pldm_msgbuf* ctx = &_ctx; 95 uint8_t buf[1] = {0xa5}; 96 uint8_t val; 97 98 ASSERT_EQ(pldm_msgbuf_init(ctx, sizeof(buf), buf, sizeof(buf)), 99 PLDM_SUCCESS); 100 ASSERT_EQ(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS); 101 ASSERT_EQ(val, 0xa5); 102 EXPECT_NE(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS); 103 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 104 } 105 106 TEST(msgbuf, destroy_under) 107 { 108 struct pldm_msgbuf _ctx; 109 struct pldm_msgbuf* ctx = &_ctx; 110 uint8_t buf[2] = {0x5a, 0xa5}; 111 uint8_t val; 112 113 ASSERT_EQ(pldm_msgbuf_init(ctx, sizeof(buf), buf, sizeof(buf)), 114 PLDM_SUCCESS); 115 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS); 116 EXPECT_EQ(val, 0x5a); 117 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 118 } 119 120 TEST(msgbuf, extract_one_uint8) 121 { 122 struct pldm_msgbuf _ctx; 123 struct pldm_msgbuf* ctx = &_ctx; 124 uint8_t buf[1] = {0xa5}; 125 uint8_t val; 126 127 ASSERT_EQ(pldm_msgbuf_init(ctx, sizeof(buf), buf, sizeof(buf)), 128 PLDM_SUCCESS); 129 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS); 130 EXPECT_EQ(val, 0xa5); 131 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 132 } 133 134 TEST(msgbuf, extract_over_uint8) 135 { 136 struct pldm_msgbuf _ctx; 137 struct pldm_msgbuf* ctx = &_ctx; 138 uint8_t buf[1] = {}; 139 uint8_t val; 140 141 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 142 EXPECT_NE(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS); 143 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 144 } 145 146 TEST(msgbuf, extract_under_uint8) 147 { 148 struct pldm_msgbuf _ctx; 149 struct pldm_msgbuf* ctx = &_ctx; 150 151 uint8_t buf[1] = {}; 152 uint8_t val; 153 154 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 155 ctx->remaining = INTMAX_MIN; 156 EXPECT_NE(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS); 157 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 158 } 159 160 TEST(msgbuf, extract_one_int8) 161 { 162 struct pldm_msgbuf _ctx; 163 struct pldm_msgbuf* ctx = &_ctx; 164 int8_t buf[1] = {-1}; 165 int8_t val; 166 167 ASSERT_EQ(pldm_msgbuf_init(ctx, sizeof(buf), buf, sizeof(buf)), 168 PLDM_SUCCESS); 169 EXPECT_EQ(pldm_msgbuf_extract_int8(ctx, &val), PLDM_SUCCESS); 170 EXPECT_EQ(val, -1); 171 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 172 } 173 174 TEST(msgbuf, extract_over_int8) 175 { 176 struct pldm_msgbuf _ctx; 177 struct pldm_msgbuf* ctx = &_ctx; 178 int8_t buf[1] = {}; 179 int8_t val; 180 181 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 182 EXPECT_NE(pldm_msgbuf_extract_int8(ctx, &val), PLDM_SUCCESS); 183 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 184 } 185 186 TEST(msgbuf, extract_under_int8) 187 { 188 struct pldm_msgbuf _ctx; 189 struct pldm_msgbuf* ctx = &_ctx; 190 191 uint8_t buf[1] = {}; 192 int8_t val; 193 194 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 195 ctx->remaining = INTMAX_MIN; 196 EXPECT_NE(pldm_msgbuf_extract_int8(ctx, &val), PLDM_SUCCESS); 197 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 198 } 199 200 TEST(msgbuf, extract_one_uint16) 201 { 202 struct pldm_msgbuf _ctx; 203 struct pldm_msgbuf* ctx = &_ctx; 204 uint16_t buf[1] = {htole16(0x5aa5)}; 205 uint16_t val = {}; 206 207 ASSERT_EQ(pldm_msgbuf_init(ctx, sizeof(buf), buf, sizeof(buf)), 208 PLDM_SUCCESS); 209 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctx, &val), PLDM_SUCCESS); 210 EXPECT_EQ(val, 0x5aa5); 211 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 212 } 213 214 TEST(msgbuf, extract_under_uint16) 215 { 216 struct pldm_msgbuf _ctx; 217 struct pldm_msgbuf* ctx = &_ctx; 218 219 uint16_t buf[1] = {}; 220 uint16_t val; 221 222 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 223 ctx->remaining = INTMAX_MIN + sizeof(val) - 1; 224 EXPECT_NE(pldm_msgbuf_extract_uint16(ctx, &val), PLDM_SUCCESS); 225 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 226 } 227 228 TEST(msgbuf, extract_over_uint16) 229 { 230 struct pldm_msgbuf _ctx; 231 struct pldm_msgbuf* ctx = &_ctx; 232 uint16_t buf[1] = {}; 233 uint16_t val; 234 235 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 236 EXPECT_NE(pldm_msgbuf_extract_uint16(ctx, &val), PLDM_SUCCESS); 237 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 238 } 239 240 TEST(msgbuf, extract_one_int16) 241 { 242 struct pldm_msgbuf _ctx; 243 struct pldm_msgbuf* ctx = &_ctx; 244 int16_t buf[1] = {(int16_t)(htole16((uint16_t)INT16_MIN))}; 245 int16_t val; 246 247 ASSERT_EQ(pldm_msgbuf_init(ctx, sizeof(buf), buf, sizeof(buf)), 248 PLDM_SUCCESS); 249 EXPECT_EQ(pldm_msgbuf_extract_int16(ctx, &val), PLDM_SUCCESS); 250 EXPECT_EQ(val, INT16_MIN); 251 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 252 } 253 254 TEST(msgbuf, extract_over_int16) 255 { 256 struct pldm_msgbuf _ctx; 257 struct pldm_msgbuf* ctx = &_ctx; 258 int16_t buf[1] = {}; 259 int16_t val; 260 261 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 262 EXPECT_NE(pldm_msgbuf_extract_int16(ctx, &val), PLDM_SUCCESS); 263 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 264 } 265 266 TEST(msgbuf, extract_under_int16) 267 { 268 struct pldm_msgbuf _ctx; 269 struct pldm_msgbuf* ctx = &_ctx; 270 271 int16_t buf[1] = {}; 272 int16_t val; 273 274 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 275 ctx->remaining = INTMAX_MIN + sizeof(val) - 1; 276 EXPECT_NE(pldm_msgbuf_extract_int16(ctx, &val), PLDM_SUCCESS); 277 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 278 } 279 280 TEST(msgbuf, extract_one_uint32) 281 { 282 struct pldm_msgbuf _ctx; 283 struct pldm_msgbuf* ctx = &_ctx; 284 uint32_t buf[1] = {htole32(0x5a00ffa5)}; 285 uint32_t val; 286 287 ASSERT_EQ(pldm_msgbuf_init(ctx, sizeof(buf), buf, sizeof(buf)), 288 PLDM_SUCCESS); 289 EXPECT_EQ(pldm_msgbuf_extract_uint32(ctx, &val), PLDM_SUCCESS); 290 EXPECT_EQ(val, 0x5a00ffa5); 291 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 292 } 293 294 TEST(msgbuf, extract_over_uint32) 295 { 296 struct pldm_msgbuf _ctx; 297 struct pldm_msgbuf* ctx = &_ctx; 298 uint32_t buf[1] = {}; 299 uint32_t val; 300 301 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 302 EXPECT_NE(pldm_msgbuf_extract_uint32(ctx, &val), PLDM_SUCCESS); 303 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 304 } 305 306 TEST(msgbuf, extract_under_uint32) 307 { 308 struct pldm_msgbuf _ctx; 309 struct pldm_msgbuf* ctx = &_ctx; 310 311 uint32_t buf[1] = {}; 312 uint32_t val; 313 314 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 315 ctx->remaining = INTMAX_MIN + sizeof(val) - 1; 316 EXPECT_NE(pldm_msgbuf_extract_uint32(ctx, &val), PLDM_SUCCESS); 317 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 318 } 319 320 TEST(msgbuf, extract_one_int32) 321 { 322 struct pldm_msgbuf _ctx; 323 struct pldm_msgbuf* ctx = &_ctx; 324 int32_t buf[1] = {(int32_t)(htole32((uint32_t)(INT32_MIN)))}; 325 int32_t val; 326 327 ASSERT_EQ(pldm_msgbuf_init(ctx, sizeof(buf), buf, sizeof(buf)), 328 PLDM_SUCCESS); 329 EXPECT_EQ(pldm_msgbuf_extract_int32(ctx, &val), PLDM_SUCCESS); 330 EXPECT_EQ(val, INT32_MIN); 331 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 332 } 333 334 TEST(msgbuf, extract_over_int32) 335 { 336 struct pldm_msgbuf _ctx; 337 struct pldm_msgbuf* ctx = &_ctx; 338 int32_t buf[1] = {}; 339 int32_t val; 340 341 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 342 EXPECT_NE(pldm_msgbuf_extract_int32(ctx, &val), PLDM_SUCCESS); 343 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 344 } 345 346 TEST(msgbuf, extract_under_int32) 347 { 348 struct pldm_msgbuf _ctx; 349 struct pldm_msgbuf* ctx = &_ctx; 350 351 int32_t buf[1] = {}; 352 int32_t val; 353 354 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 355 ctx->remaining = INTMAX_MIN + sizeof(val) - 1; 356 EXPECT_NE(pldm_msgbuf_extract_int32(ctx, &val), PLDM_SUCCESS); 357 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 358 } 359 360 TEST(msgbuf, extract_one_real32) 361 { 362 struct pldm_msgbuf _ctx; 363 struct pldm_msgbuf* ctx = &_ctx; 364 uint32_t buf[1] = {}; 365 uint32_t xform; 366 real32_t val; 367 368 val = FLT_MAX; 369 memcpy(&xform, &val, sizeof(val)); 370 buf[0] = htole32(xform); 371 val = 0; 372 373 ASSERT_EQ(pldm_msgbuf_init(ctx, sizeof(buf), buf, sizeof(buf)), 374 PLDM_SUCCESS); 375 EXPECT_EQ(pldm_msgbuf_extract_real32(ctx, &val), PLDM_SUCCESS); 376 EXPECT_EQ(val, FLT_MAX); 377 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 378 } 379 380 TEST(msgbuf, extract_over_real32) 381 { 382 struct pldm_msgbuf _ctx; 383 struct pldm_msgbuf* ctx = &_ctx; 384 real32_t buf[1] = {}; 385 real32_t val; 386 387 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 388 EXPECT_NE(pldm_msgbuf_extract_real32(ctx, &val), PLDM_SUCCESS); 389 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 390 } 391 392 TEST(msgbuf, extract_under_real32) 393 { 394 struct pldm_msgbuf _ctx; 395 struct pldm_msgbuf* ctx = &_ctx; 396 397 real32_t buf[1] = {}; 398 real32_t val; 399 400 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 401 ctx->remaining = INTMAX_MIN + sizeof(val) - 1; 402 EXPECT_NE(pldm_msgbuf_extract_real32(ctx, &val), PLDM_SUCCESS); 403 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 404 } 405 406 TEST(msgbuf, extract_array_uint8_buf0_req0) 407 { 408 struct pldm_msgbuf _ctx; 409 struct pldm_msgbuf* ctx = &_ctx; 410 uint8_t buf[1] = {}; 411 uint8_t arr[1]; 412 413 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 414 EXPECT_EQ(pldm_msgbuf_extract_array_uint8(ctx, arr, 0), PLDM_SUCCESS); 415 ASSERT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 416 } 417 418 TEST(msgbuf, extract_array_uint8_buf1_req1) 419 { 420 struct pldm_msgbuf _ctx; 421 struct pldm_msgbuf* ctx = &_ctx; 422 uint8_t buf[1] = {}; 423 uint8_t arr[1]; 424 425 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 426 EXPECT_EQ(pldm_msgbuf_extract_array_uint8(ctx, arr, sizeof(arr)), 427 PLDM_SUCCESS); 428 EXPECT_EQ(arr[0], 0); 429 ASSERT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 430 } 431 432 TEST(msgbuf, extract_array_uint8_buf1_req2) 433 { 434 struct pldm_msgbuf _ctx; 435 struct pldm_msgbuf* ctx = &_ctx; 436 uint8_t buf[1] = {}; 437 uint8_t arr[2]; 438 439 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 440 EXPECT_NE(pldm_msgbuf_extract_array_uint8(ctx, arr, sizeof(arr)), 441 PLDM_SUCCESS); 442 ASSERT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 443 } 444 445 TEST(msgbuf, extract_under_array_uint8) 446 { 447 struct pldm_msgbuf _ctx; 448 struct pldm_msgbuf* ctx = &_ctx; 449 uint8_t buf[1] = {}; 450 uint8_t arr[1]; 451 452 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 453 ctx->remaining = INTMAX_MIN; 454 EXPECT_NE(pldm_msgbuf_extract_array_uint8(ctx, arr, 1), PLDM_SUCCESS); 455 ASSERT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 456 } 457 458 TEST(msgbuf, consumed_under) 459 { 460 struct pldm_msgbuf _ctx; 461 struct pldm_msgbuf* ctx = &_ctx; 462 uint8_t buf[1] = {}; 463 464 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 465 EXPECT_EQ(pldm_msgbuf_destroy_consumed(ctx), PLDM_ERROR_INVALID_LENGTH); 466 } 467 468 TEST(msgbuf, consumed_exact) 469 { 470 struct pldm_msgbuf _ctx; 471 struct pldm_msgbuf* ctx = &_ctx; 472 uint8_t buf[1] = {}; 473 uint8_t val; 474 475 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 476 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS); 477 EXPECT_EQ(pldm_msgbuf_destroy_consumed(ctx), PLDM_SUCCESS); 478 } 479 480 TEST(msgbuf, consumed_over) 481 { 482 struct pldm_msgbuf _ctx; 483 struct pldm_msgbuf* ctx = &_ctx; 484 uint8_t buf[1] = {}; 485 uint8_t val[2]; 486 487 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 488 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctx, &val[0]), PLDM_SUCCESS); 489 EXPECT_NE(pldm_msgbuf_extract_uint8(ctx, &val[1]), PLDM_SUCCESS); 490 EXPECT_EQ(pldm_msgbuf_destroy_consumed(ctx), PLDM_ERROR_INVALID_LENGTH); 491 } 492 493 TEST(msgbuf, pldm_msgbuf_insert_int32_good) 494 { 495 struct pldm_msgbuf _ctx; 496 struct pldm_msgbuf* ctx = &_ctx; 497 int32_t src = -12345; 498 int32_t checkVal = 0; 499 uint8_t buf[sizeof(int32_t)] = {}; 500 501 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 502 EXPECT_EQ(pldm_msgbuf_insert_int32(ctx, src), PLDM_SUCCESS); 503 504 struct pldm_msgbuf _ctxExtract; 505 struct pldm_msgbuf* ctxExtract = &_ctxExtract; 506 507 ASSERT_EQ(pldm_msgbuf_init(ctxExtract, 0, buf, sizeof(buf)), PLDM_SUCCESS); 508 EXPECT_EQ(pldm_msgbuf_extract_int32(ctxExtract, &checkVal), PLDM_SUCCESS); 509 510 EXPECT_EQ(src, checkVal); 511 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS); 512 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 513 } 514 515 TEST(msgbuf, pldm_msgbuf_insert_int32_bad) 516 { 517 int32_t src = -12345; 518 519 auto rc = pldm_msgbuf_insert_int32(NULL, src); 520 521 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 522 } 523 524 TEST(msgbuf, insert_under_int32) 525 { 526 struct pldm_msgbuf _ctx; 527 struct pldm_msgbuf* ctx = &_ctx; 528 529 int32_t buf[1] = {}; 530 int32_t val = 0; 531 532 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 533 ctx->remaining = INTMAX_MIN + sizeof(val) - 1; 534 EXPECT_NE(pldm_msgbuf_insert_int32(ctx, val), PLDM_SUCCESS); 535 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 536 } 537 538 TEST(msgbuf, pldm_msgbuf_insert_uint32_good) 539 { 540 struct pldm_msgbuf _ctx; 541 struct pldm_msgbuf* ctx = &_ctx; 542 uint32_t src = 0xf1223344; 543 uint32_t checkVal = 0; 544 uint8_t buf[sizeof(uint32_t)] = {}; 545 546 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 547 EXPECT_EQ(pldm_msgbuf_insert_uint32(ctx, src), PLDM_SUCCESS); 548 549 struct pldm_msgbuf _ctxExtract; 550 struct pldm_msgbuf* ctxExtract = &_ctxExtract; 551 552 ASSERT_EQ(pldm_msgbuf_init(ctxExtract, 0, buf, sizeof(buf)), PLDM_SUCCESS); 553 EXPECT_EQ(pldm_msgbuf_extract_uint32(ctxExtract, &checkVal), PLDM_SUCCESS); 554 555 EXPECT_EQ(src, checkVal); 556 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS); 557 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 558 } 559 560 TEST(msgbuf, pldm_msgbuf_insert_uint32_bad) 561 { 562 uint32_t src = 0xf1223344; 563 564 auto rc = pldm_msgbuf_insert_uint32(NULL, src); 565 566 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 567 } 568 569 TEST(msgbuf, insert_under_uint32) 570 { 571 struct pldm_msgbuf _ctx; 572 struct pldm_msgbuf* ctx = &_ctx; 573 574 uint32_t buf[1] = {}; 575 uint32_t val = 0; 576 577 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 578 ctx->remaining = INTMAX_MIN + sizeof(val) - 1; 579 EXPECT_NE(pldm_msgbuf_insert_uint32(ctx, val), PLDM_SUCCESS); 580 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 581 } 582 583 TEST(msgbuf, pldm_msgbuf_insert_uint16_good) 584 { 585 struct pldm_msgbuf _ctx; 586 struct pldm_msgbuf* ctx = &_ctx; 587 uint16_t src = 0xf344; 588 uint16_t checkVal = 0; 589 uint8_t buf[sizeof(uint16_t)] = {}; 590 591 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(uint16_t)), PLDM_SUCCESS); 592 EXPECT_EQ(pldm_msgbuf_insert_uint16(ctx, src), PLDM_SUCCESS); 593 594 struct pldm_msgbuf _ctxExtract; 595 struct pldm_msgbuf* ctxExtract = &_ctxExtract; 596 597 ASSERT_EQ(pldm_msgbuf_init(ctxExtract, 0, buf, sizeof(buf)), PLDM_SUCCESS); 598 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &checkVal), PLDM_SUCCESS); 599 600 EXPECT_EQ(src, checkVal); 601 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS); 602 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 603 } 604 605 TEST(msgbuf, pldm_msgbuf_insert_uint16_bad) 606 { 607 uint16_t src = 0xf344; 608 609 auto rc = pldm_msgbuf_insert_uint16(NULL, src); 610 611 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 612 } 613 614 TEST(msgbuf, insert_under_uint16) 615 { 616 struct pldm_msgbuf _ctx; 617 struct pldm_msgbuf* ctx = &_ctx; 618 619 uint16_t buf[1] = {}; 620 uint16_t val = 0; 621 622 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 623 ctx->remaining = INTMAX_MIN + sizeof(val) - 1; 624 EXPECT_NE(pldm_msgbuf_insert_uint16(ctx, val), PLDM_SUCCESS); 625 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 626 } 627 628 TEST(msgbuf, pldm_msgbuf_insert_int16_good) 629 { 630 struct pldm_msgbuf _ctx; 631 struct pldm_msgbuf* ctx = &_ctx; 632 int16_t src = -12; 633 int16_t checkVal = 0; 634 uint8_t buf[sizeof(int16_t)] = {}; 635 636 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(uint16_t)), PLDM_SUCCESS); 637 EXPECT_EQ(pldm_msgbuf_insert_int16(ctx, src), PLDM_SUCCESS); 638 639 struct pldm_msgbuf _ctxExtract; 640 struct pldm_msgbuf* ctxExtract = &_ctxExtract; 641 642 ASSERT_EQ(pldm_msgbuf_init(ctxExtract, 0, buf, sizeof(buf)), PLDM_SUCCESS); 643 EXPECT_EQ(pldm_msgbuf_extract_int16(ctxExtract, &checkVal), PLDM_SUCCESS); 644 645 EXPECT_EQ(src, checkVal); 646 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS); 647 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 648 } 649 650 TEST(msgbuf, pldm_msgbuf_insert_int16_bad) 651 { 652 int16_t src = -12; 653 654 auto rc = pldm_msgbuf_insert_int16(NULL, src); 655 656 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 657 } 658 659 TEST(msgbuf, insert_under_int16) 660 { 661 struct pldm_msgbuf _ctx; 662 struct pldm_msgbuf* ctx = &_ctx; 663 664 int16_t buf[1] = {}; 665 int16_t val = 0; 666 667 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 668 ctx->remaining = INTMAX_MIN + sizeof(val) - 1; 669 EXPECT_NE(pldm_msgbuf_insert_int16(ctx, val), PLDM_SUCCESS); 670 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 671 } 672 673 TEST(msgbuf, pldm_msgbuf_insert_uint8_good) 674 { 675 struct pldm_msgbuf _ctx; 676 struct pldm_msgbuf* ctx = &_ctx; 677 uint8_t src = 0xf4; 678 uint8_t checkVal = 0; 679 uint8_t buf[sizeof(uint8_t)] = {}; 680 681 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 682 EXPECT_EQ(pldm_msgbuf_insert_uint8(ctx, src), PLDM_SUCCESS); 683 684 struct pldm_msgbuf _ctxExtract; 685 struct pldm_msgbuf* ctxExtract = &_ctxExtract; 686 687 ASSERT_EQ(pldm_msgbuf_init(ctxExtract, 0, buf, sizeof(buf)), PLDM_SUCCESS); 688 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctxExtract, &checkVal), PLDM_SUCCESS); 689 690 EXPECT_EQ(src, checkVal); 691 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS); 692 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 693 } 694 695 TEST(msgbuf, pldm_msgbuf_insert_uint8_bad) 696 { 697 uint8_t src = 0xf4; 698 699 auto rc = pldm_msgbuf_insert_uint8(NULL, src); 700 701 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 702 } 703 704 TEST(msgbuf, insert_under_uint8) 705 { 706 struct pldm_msgbuf _ctx; 707 struct pldm_msgbuf* ctx = &_ctx; 708 709 uint8_t buf[1] = {}; 710 uint8_t val = 0; 711 712 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 713 ctx->remaining = INTMAX_MIN + sizeof(val) - 1; 714 EXPECT_NE(pldm_msgbuf_insert_uint8(ctx, val), PLDM_SUCCESS); 715 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 716 } 717 718 TEST(msgbuf, pldm_msgbuf_insert_int8_good) 719 { 720 struct pldm_msgbuf _ctx; 721 struct pldm_msgbuf* ctx = &_ctx; 722 int8_t src = -4; 723 int8_t checkVal = 0; 724 uint8_t buf[sizeof(int8_t)] = {}; 725 726 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 727 EXPECT_EQ(pldm_msgbuf_insert_int8(ctx, src), PLDM_SUCCESS); 728 729 struct pldm_msgbuf _ctxExtract; 730 struct pldm_msgbuf* ctxExtract = &_ctxExtract; 731 732 ASSERT_EQ(pldm_msgbuf_init(ctxExtract, 0, buf, sizeof(buf)), PLDM_SUCCESS); 733 EXPECT_EQ(pldm_msgbuf_extract_int8(ctxExtract, &checkVal), PLDM_SUCCESS); 734 735 EXPECT_EQ(src, checkVal); 736 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS); 737 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 738 } 739 740 TEST(msgbuf, pldm_msgbuf_insert_int8_bad) 741 { 742 int8_t src = -4; 743 744 auto rc = pldm_msgbuf_insert_int8(NULL, src); 745 746 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA); 747 } 748 749 TEST(msgbuf, insert_under_int8) 750 { 751 struct pldm_msgbuf _ctx; 752 struct pldm_msgbuf* ctx = &_ctx; 753 754 int8_t buf[1] = {}; 755 int8_t val = 0; 756 757 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 758 ctx->remaining = INTMAX_MIN + sizeof(val) - 1; 759 EXPECT_NE(pldm_msgbuf_insert_int8(ctx, val), PLDM_SUCCESS); 760 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 761 } 762 763 TEST(msgbuf, pldm_msgbuf_insert_array_uint8_good) 764 { 765 struct pldm_msgbuf _ctx; 766 struct pldm_msgbuf* ctx = &_ctx; 767 uint8_t src[6] = {0x11, 0x22, 0x44, 0x55, 0x66, 0x77}; 768 uint8_t buf[6] = {}; 769 uint8_t retBuff[6] = {}; 770 771 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 772 EXPECT_EQ(pldm_msgbuf_insert_array_uint8(ctx, src, sizeof(src)), 773 PLDM_SUCCESS); 774 775 struct pldm_msgbuf _ctxExtract; 776 struct pldm_msgbuf* ctxExtract = &_ctxExtract; 777 778 ASSERT_EQ(pldm_msgbuf_init(ctxExtract, 0, buf, sizeof(buf)), PLDM_SUCCESS); 779 EXPECT_EQ( 780 pldm_msgbuf_extract_array_uint8(ctxExtract, retBuff, sizeof(retBuff)), 781 PLDM_SUCCESS); 782 783 EXPECT_EQ(memcmp(src, retBuff, sizeof(retBuff)), 0); 784 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS); 785 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 786 } 787 788 TEST(msgbuf, pldm_msgbuf_insert_array_uint8_bad) 789 { 790 struct pldm_msgbuf _ctx; 791 struct pldm_msgbuf* ctx = &_ctx; 792 uint8_t src[6] = {0x11, 0x22, 0x44, 0x55, 0x66, 0x77}; 793 uint8_t buf[6] = {}; 794 795 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 796 EXPECT_EQ(pldm_msgbuf_insert_array_uint8(NULL, src, sizeof(src)), 797 PLDM_ERROR_INVALID_DATA); 798 EXPECT_EQ(pldm_msgbuf_insert_array_uint8(ctx, NULL, sizeof(src)), 799 PLDM_ERROR_INVALID_DATA); 800 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 801 } 802 803 TEST(msgbuf, insert_under_array_uint8) 804 { 805 struct pldm_msgbuf _ctx; 806 struct pldm_msgbuf* ctx = &_ctx; 807 808 uint8_t buf[1] = {}; 809 uint8_t val[1] = {0}; 810 811 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 812 ctx->remaining = INTMAX_MIN + sizeof(val) - 1; 813 EXPECT_NE(pldm_msgbuf_insert_array_uint8(ctx, val, sizeof(val)), 814 PLDM_SUCCESS); 815 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 816 } 817 818 TEST(msgbuf, pldm_msgbuf_span_required_good) 819 { 820 struct pldm_msgbuf _ctx; 821 struct pldm_msgbuf* ctx = &_ctx; 822 uint8_t src[6] = {0x11, 0x22, 0x44, 0x55, 0x66, 0x77}; 823 uint8_t buf[6] = {0}; 824 const size_t required = 4; 825 uint8_t expectData[required] = {0x44, 0x55, 0x66, 0x77}; 826 uint16_t testVal; 827 uint8_t* retBuff = NULL; 828 829 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 830 EXPECT_EQ(pldm_msgbuf_insert_array_uint8(ctx, src, sizeof(src)), 831 PLDM_SUCCESS); 832 833 struct pldm_msgbuf _ctxExtract; 834 struct pldm_msgbuf* ctxExtract = &_ctxExtract; 835 836 ASSERT_EQ(pldm_msgbuf_init(ctxExtract, 0, buf, sizeof(buf)), PLDM_SUCCESS); 837 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), PLDM_SUCCESS); 838 EXPECT_EQ(pldm_msgbuf_span_required(ctxExtract, required, (void**)&retBuff), 839 PLDM_SUCCESS); 840 841 EXPECT_EQ(memcmp(expectData, retBuff, required), 0); 842 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS); 843 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 844 } 845 846 TEST(msgbuf, pldm_msgbuf_span_required_bad) 847 { 848 struct pldm_msgbuf _ctx; 849 struct pldm_msgbuf* ctx = &_ctx; 850 uint8_t src[6] = {0x11, 0x22, 0x44, 0x55, 0x66, 0x77}; 851 uint8_t buf[6] = {0}; 852 const size_t required = 4; 853 uint16_t testVal; 854 [[maybe_unused]] uint8_t* retBuff = NULL; 855 856 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 857 EXPECT_EQ(pldm_msgbuf_insert_array_uint8(ctx, src, sizeof(src)), 858 PLDM_SUCCESS); 859 860 struct pldm_msgbuf _ctxExtract; 861 struct pldm_msgbuf* ctxExtract = &_ctxExtract; 862 863 ASSERT_EQ(pldm_msgbuf_init(ctxExtract, 0, buf, sizeof(buf)), PLDM_SUCCESS); 864 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), PLDM_SUCCESS); 865 EXPECT_EQ(pldm_msgbuf_span_required(ctxExtract, required, NULL), 866 PLDM_ERROR_INVALID_DATA); 867 EXPECT_EQ(pldm_msgbuf_span_required(NULL, required, (void**)&retBuff), 868 PLDM_ERROR_INVALID_DATA); 869 870 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS); 871 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 872 } 873 874 TEST(msgbuf, span_required_under) 875 { 876 struct pldm_msgbuf _ctx; 877 struct pldm_msgbuf* ctx = &_ctx; 878 879 uint8_t buf[1] = {}; 880 void* cursor = nullptr; 881 882 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, 0), PLDM_SUCCESS); 883 ctx->remaining = INTMAX_MIN; 884 EXPECT_NE(pldm_msgbuf_span_required(ctx, 1, &cursor), PLDM_SUCCESS); 885 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH); 886 } 887 888 TEST(msgbuf, pldm_msgbuf_span_remaining_good) 889 { 890 struct pldm_msgbuf _ctx; 891 struct pldm_msgbuf* ctx = &_ctx; 892 uint8_t src[8] = {0x11, 0x22, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99}; 893 uint8_t buf[8] = {0}; 894 uint16_t testVal; 895 uint8_t expectData[6] = {0x44, 0x55, 0x66, 0x77, 0x88, 0x99}; 896 size_t remaining; 897 uint8_t* retBuff = NULL; 898 899 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 900 EXPECT_EQ(pldm_msgbuf_insert_array_uint8(ctx, src, sizeof(src)), 901 PLDM_SUCCESS); 902 903 struct pldm_msgbuf _ctxExtract; 904 struct pldm_msgbuf* ctxExtract = &_ctxExtract; 905 906 ASSERT_EQ(pldm_msgbuf_init(ctxExtract, 0, buf, sizeof(buf)), PLDM_SUCCESS); 907 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), PLDM_SUCCESS); 908 EXPECT_EQ( 909 pldm_msgbuf_span_remaining(ctxExtract, (void**)&retBuff, &remaining), 910 PLDM_SUCCESS); 911 912 EXPECT_EQ(remaining, sizeof(expectData)); 913 EXPECT_EQ(memcmp(expectData, retBuff, remaining), 0); 914 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS); 915 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 916 } 917 918 TEST(msgbuf, pldm_msgbuf_span_remaining_bad) 919 { 920 struct pldm_msgbuf _ctx; 921 struct pldm_msgbuf* ctx = &_ctx; 922 uint8_t src[8] = {0x11, 0x22, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99}; 923 uint8_t buf[8] = {0}; 924 uint16_t testVal; 925 size_t remaining; 926 uint8_t* retBuff = NULL; 927 928 ASSERT_EQ(pldm_msgbuf_init(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS); 929 EXPECT_EQ(pldm_msgbuf_insert_array_uint8(ctx, src, sizeof(src)), 930 PLDM_SUCCESS); 931 932 struct pldm_msgbuf _ctxExtract; 933 struct pldm_msgbuf* ctxExtract = &_ctxExtract; 934 935 ASSERT_EQ(pldm_msgbuf_init(ctxExtract, 0, buf, sizeof(buf)), PLDM_SUCCESS); 936 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), PLDM_SUCCESS); 937 EXPECT_EQ(pldm_msgbuf_span_remaining(NULL, (void**)&retBuff, &remaining), 938 PLDM_ERROR_INVALID_DATA); 939 EXPECT_EQ(pldm_msgbuf_span_remaining(ctxExtract, NULL, &remaining), 940 PLDM_ERROR_INVALID_DATA); 941 EXPECT_EQ(pldm_msgbuf_span_remaining(ctxExtract, (void**)&retBuff, NULL), 942 PLDM_ERROR_INVALID_DATA); 943 944 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS); 945 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS); 946 } 947 948 TEST(msgbuf, pldm_msgbuf_copy_good) 949 { 950 struct pldm_msgbuf _src; 951 struct pldm_msgbuf* src = &_src; 952 uint16_t buf[1] = {htole16(0x5aa5)}; 953 954 ASSERT_EQ(pldm_msgbuf_init(src, sizeof(buf), buf, sizeof(buf)), 955 PLDM_SUCCESS); 956 957 struct pldm_msgbuf _dst; 958 struct pldm_msgbuf* dst = &_dst; 959 uint16_t checkVal = 0; 960 uint8_t buf1[sizeof(buf)] = {}; 961 962 ASSERT_EQ(pldm_msgbuf_init(dst, sizeof(buf1), buf1, sizeof(buf1)), 963 PLDM_SUCCESS); 964 EXPECT_EQ(pldm_msgbuf_copy(dst, src, buf[0], name), PLDM_SUCCESS); 965 966 ASSERT_EQ(pldm_msgbuf_init(dst, sizeof(buf1), buf1, sizeof(buf1)), 967 PLDM_SUCCESS); 968 EXPECT_EQ(pldm_msgbuf_extract_uint16(dst, &checkVal), PLDM_SUCCESS); 969 970 EXPECT_EQ(buf[0], checkVal); 971 EXPECT_EQ(pldm_msgbuf_destroy(src), PLDM_SUCCESS); 972 EXPECT_EQ(pldm_msgbuf_destroy(dst), PLDM_SUCCESS); 973 } 974 975 TEST(msgbuf, pldm_msgbuf_copy_bad) 976 { 977 struct pldm_msgbuf _src; 978 struct pldm_msgbuf* src = &_src; 979 struct pldm_msgbuf _dst; 980 struct pldm_msgbuf* dst = &_dst; 981 uint8_t buf[1] = {sizeof(uint8_t)}; 982 uint8_t buf1[1] = {sizeof(uint16_t)}; 983 uint16_t value = 8; 984 985 EXPECT_EQ(pldm_msgbuf_copy(dst, NULL, buf[0], name), 986 PLDM_ERROR_INVALID_DATA); 987 EXPECT_EQ(pldm_msgbuf_copy(NULL, src, buf[0], name), 988 PLDM_ERROR_INVALID_DATA); 989 990 ASSERT_EQ(pldm_msgbuf_init(src, 0, buf, sizeof(buf)), PLDM_SUCCESS); 991 ASSERT_EQ(pldm_msgbuf_init(dst, 0, buf1, sizeof(buf1)), PLDM_SUCCESS); 992 EXPECT_EQ(pldm_msgbuf_copy(dst, src, value, name), 993 PLDM_ERROR_INVALID_LENGTH); 994 995 ASSERT_EQ(pldm_msgbuf_init(src, 0, buf1, sizeof(buf1)), PLDM_SUCCESS); 996 ASSERT_EQ(pldm_msgbuf_init(dst, 0, buf, sizeof(buf)), PLDM_SUCCESS); 997 EXPECT_EQ(pldm_msgbuf_copy(dst, src, value, name), 998 PLDM_ERROR_INVALID_LENGTH); 999 } 1000