1 #include <endian.h>
2 #include <libpldm/utils.h>
3
4 #include <cfloat>
5
6 #include <gtest/gtest.h>
7
8 /* We're exercising the implementation so disable the asserts for now */
9 #ifndef NDEBUG
10 #define NDEBUG 1
11 #endif
12
13 #include "msgbuf.h"
14
TEST(msgbuf,init_bad_minsize)15 TEST(msgbuf, init_bad_minsize)
16 {
17 struct pldm_msgbuf _ctx;
18 struct pldm_msgbuf* ctx = &_ctx;
19 uint8_t buf[1] = {};
20
21 EXPECT_NE(pldm_msgbuf_init_cc(ctx, sizeof(buf) + 1U, buf, sizeof(buf)),
22 PLDM_SUCCESS);
23 }
24
TEST(msgbuf,init_bad_len)25 TEST(msgbuf, init_bad_len)
26 {
27 struct pldm_msgbuf _ctx;
28 struct pldm_msgbuf* ctx = &_ctx;
29 uint8_t buf[1] = {};
30
31 EXPECT_NE(pldm_msgbuf_init_cc(ctx, sizeof(buf), buf, SIZE_MAX),
32 PLDM_SUCCESS);
33 }
34
TEST(msgbuf,init_overflow)35 TEST(msgbuf, init_overflow)
36 {
37 struct pldm_msgbuf _ctx;
38 struct pldm_msgbuf* ctx = &_ctx;
39 // NOLINTNEXTLINE(performance-no-int-to-ptr)
40 void* buf = (void*)UINTPTR_MAX;
41
42 EXPECT_NE(pldm_msgbuf_init_cc(ctx, 0, buf, 2), PLDM_SUCCESS);
43 }
44
TEST(msgbuf,init_success)45 TEST(msgbuf, init_success)
46 {
47 struct pldm_msgbuf _ctx;
48 struct pldm_msgbuf* ctx = &_ctx;
49 uint8_t buf[1] = {};
50
51 EXPECT_EQ(pldm_msgbuf_init_cc(ctx, sizeof(buf), buf, sizeof(buf)),
52 PLDM_SUCCESS);
53 }
54
TEST(msgbuf,destroy_none)55 TEST(msgbuf, destroy_none)
56 {
57 struct pldm_msgbuf _ctx;
58 struct pldm_msgbuf* ctx = &_ctx;
59 uint8_t buf[1] = {};
60
61 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, sizeof(buf), buf, sizeof(buf)),
62 PLDM_SUCCESS);
63 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
64 }
65
TEST(msgbuf,destroy_exact)66 TEST(msgbuf, destroy_exact)
67 {
68 struct pldm_msgbuf _ctx;
69 struct pldm_msgbuf* ctx = &_ctx;
70 uint8_t buf[1] = {0xa5};
71 uint8_t val;
72
73 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, sizeof(buf), buf, sizeof(buf)),
74 PLDM_SUCCESS);
75 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS);
76 EXPECT_EQ(val, 0xa5);
77 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
78 }
79
TEST(msgbuf,destroy_over)80 TEST(msgbuf, destroy_over)
81 {
82 struct pldm_msgbuf _ctx;
83 struct pldm_msgbuf* ctx = &_ctx;
84 uint8_t buf[1] = {0xa5};
85 uint8_t val;
86
87 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, sizeof(buf), buf, sizeof(buf)),
88 PLDM_SUCCESS);
89 ASSERT_EQ(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS);
90 ASSERT_EQ(val, 0xa5);
91 EXPECT_NE(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS);
92 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
93 }
94
TEST(msgbuf,destroy_under)95 TEST(msgbuf, destroy_under)
96 {
97 struct pldm_msgbuf _ctx;
98 struct pldm_msgbuf* ctx = &_ctx;
99 uint8_t buf[2] = {0x5a, 0xa5};
100 uint8_t val;
101
102 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, sizeof(buf), buf, sizeof(buf)),
103 PLDM_SUCCESS);
104 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS);
105 EXPECT_EQ(val, 0x5a);
106 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
107 }
108
TEST(msgbuf,extract_one_uint8)109 TEST(msgbuf, extract_one_uint8)
110 {
111 struct pldm_msgbuf _ctx;
112 struct pldm_msgbuf* ctx = &_ctx;
113 uint8_t buf[1] = {0xa5};
114 uint8_t val;
115
116 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, sizeof(buf), buf, sizeof(buf)),
117 PLDM_SUCCESS);
118 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS);
119 EXPECT_EQ(val, 0xa5);
120 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
121 }
122
TEST(msgbuf,extract_over_uint8)123 TEST(msgbuf, extract_over_uint8)
124 {
125 struct pldm_msgbuf _ctx;
126 struct pldm_msgbuf* ctx = &_ctx;
127 uint8_t buf[1] = {};
128 uint8_t val;
129
130 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
131 EXPECT_NE(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS);
132 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
133 }
134
TEST(msgbuf,extract_under_uint8)135 TEST(msgbuf, extract_under_uint8)
136 {
137 struct pldm_msgbuf _ctx;
138 struct pldm_msgbuf* ctx = &_ctx;
139
140 uint8_t buf[1] = {};
141 uint8_t val;
142
143 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
144 ctx->remaining = INTMAX_MIN;
145 EXPECT_NE(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS);
146 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
147 }
148
TEST(msgbuf,extract_one_int8)149 TEST(msgbuf, extract_one_int8)
150 {
151 struct pldm_msgbuf _ctx;
152 struct pldm_msgbuf* ctx = &_ctx;
153 int8_t buf[1] = {-1};
154 int8_t val;
155
156 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, sizeof(buf), buf, sizeof(buf)),
157 PLDM_SUCCESS);
158 EXPECT_EQ(pldm_msgbuf_extract_int8(ctx, &val), PLDM_SUCCESS);
159 EXPECT_EQ(val, -1);
160 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
161 }
162
TEST(msgbuf,extract_over_int8)163 TEST(msgbuf, extract_over_int8)
164 {
165 struct pldm_msgbuf _ctx;
166 struct pldm_msgbuf* ctx = &_ctx;
167 int8_t buf[1] = {};
168 int8_t val;
169
170 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
171 EXPECT_NE(pldm_msgbuf_extract_int8(ctx, &val), PLDM_SUCCESS);
172 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
173 }
174
TEST(msgbuf,extract_under_int8)175 TEST(msgbuf, extract_under_int8)
176 {
177 struct pldm_msgbuf _ctx;
178 struct pldm_msgbuf* ctx = &_ctx;
179
180 uint8_t buf[1] = {};
181 int8_t val;
182
183 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
184 ctx->remaining = INTMAX_MIN;
185 EXPECT_NE(pldm_msgbuf_extract_int8(ctx, &val), PLDM_SUCCESS);
186 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
187 }
188
TEST(msgbuf,extract_one_uint16)189 TEST(msgbuf, extract_one_uint16)
190 {
191 struct pldm_msgbuf _ctx;
192 struct pldm_msgbuf* ctx = &_ctx;
193 uint16_t buf[1] = {htole16(0x5aa5)};
194 uint16_t val = {};
195
196 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, sizeof(buf), buf, sizeof(buf)),
197 PLDM_SUCCESS);
198 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctx, &val), PLDM_SUCCESS);
199 EXPECT_EQ(val, 0x5aa5);
200 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
201 }
202
TEST(msgbuf,extract_under_uint16)203 TEST(msgbuf, extract_under_uint16)
204 {
205 struct pldm_msgbuf _ctx;
206 struct pldm_msgbuf* ctx = &_ctx;
207
208 uint16_t buf[1] = {};
209 uint16_t val;
210
211 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
212 ctx->remaining = INTMAX_MIN + sizeof(val) - 1;
213 EXPECT_NE(pldm_msgbuf_extract_uint16(ctx, &val), PLDM_SUCCESS);
214 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
215 }
216
TEST(msgbuf,extract_over_uint16)217 TEST(msgbuf, extract_over_uint16)
218 {
219 struct pldm_msgbuf _ctx;
220 struct pldm_msgbuf* ctx = &_ctx;
221 uint16_t buf[1] = {};
222 uint16_t val;
223
224 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
225 EXPECT_NE(pldm_msgbuf_extract_uint16(ctx, &val), PLDM_SUCCESS);
226 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
227 }
228
TEST(msgbuf,extract_one_int16)229 TEST(msgbuf, extract_one_int16)
230 {
231 struct pldm_msgbuf _ctx;
232 struct pldm_msgbuf* ctx = &_ctx;
233 int16_t buf[1] = {(int16_t)(htole16((uint16_t)INT16_MIN))};
234 int16_t val;
235
236 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, sizeof(buf), buf, sizeof(buf)),
237 PLDM_SUCCESS);
238 EXPECT_EQ(pldm_msgbuf_extract_int16(ctx, &val), PLDM_SUCCESS);
239 EXPECT_EQ(val, INT16_MIN);
240 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
241 }
242
TEST(msgbuf,extract_over_int16)243 TEST(msgbuf, extract_over_int16)
244 {
245 struct pldm_msgbuf _ctx;
246 struct pldm_msgbuf* ctx = &_ctx;
247 int16_t buf[1] = {};
248 int16_t val;
249
250 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
251 EXPECT_NE(pldm_msgbuf_extract_int16(ctx, &val), PLDM_SUCCESS);
252 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
253 }
254
TEST(msgbuf,extract_under_int16)255 TEST(msgbuf, extract_under_int16)
256 {
257 struct pldm_msgbuf _ctx;
258 struct pldm_msgbuf* ctx = &_ctx;
259
260 int16_t buf[1] = {};
261 int16_t val;
262
263 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
264 ctx->remaining = INTMAX_MIN + sizeof(val) - 1;
265 EXPECT_NE(pldm_msgbuf_extract_int16(ctx, &val), PLDM_SUCCESS);
266 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
267 }
268
TEST(msgbuf,extract_one_uint32)269 TEST(msgbuf, extract_one_uint32)
270 {
271 struct pldm_msgbuf _ctx;
272 struct pldm_msgbuf* ctx = &_ctx;
273 uint32_t buf[1] = {htole32(0x5a00ffa5)};
274 uint32_t val;
275
276 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, sizeof(buf), buf, sizeof(buf)),
277 PLDM_SUCCESS);
278 EXPECT_EQ(pldm_msgbuf_extract_uint32(ctx, &val), PLDM_SUCCESS);
279 EXPECT_EQ(val, 0x5a00ffa5);
280 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
281 }
282
TEST(msgbuf,extract_over_uint32)283 TEST(msgbuf, extract_over_uint32)
284 {
285 struct pldm_msgbuf _ctx;
286 struct pldm_msgbuf* ctx = &_ctx;
287 uint32_t buf[1] = {};
288 uint32_t val;
289
290 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
291 EXPECT_NE(pldm_msgbuf_extract_uint32(ctx, &val), PLDM_SUCCESS);
292 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
293 }
294
TEST(msgbuf,extract_under_uint32)295 TEST(msgbuf, extract_under_uint32)
296 {
297 struct pldm_msgbuf _ctx;
298 struct pldm_msgbuf* ctx = &_ctx;
299
300 uint32_t buf[1] = {};
301 uint32_t val;
302
303 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
304 ctx->remaining = INTMAX_MIN + sizeof(val) - 1;
305 EXPECT_NE(pldm_msgbuf_extract_uint32(ctx, &val), PLDM_SUCCESS);
306 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
307 }
308
TEST(msgbuf,extract_one_int32)309 TEST(msgbuf, extract_one_int32)
310 {
311 struct pldm_msgbuf _ctx;
312 struct pldm_msgbuf* ctx = &_ctx;
313 int32_t buf[1] = {(int32_t)(htole32((uint32_t)(INT32_MIN)))};
314 int32_t val;
315
316 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, sizeof(buf), buf, sizeof(buf)),
317 PLDM_SUCCESS);
318 EXPECT_EQ(pldm_msgbuf_extract_int32(ctx, &val), PLDM_SUCCESS);
319 EXPECT_EQ(val, INT32_MIN);
320 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
321 }
322
TEST(msgbuf,extract_over_int32)323 TEST(msgbuf, extract_over_int32)
324 {
325 struct pldm_msgbuf _ctx;
326 struct pldm_msgbuf* ctx = &_ctx;
327 int32_t buf[1] = {};
328 int32_t val;
329
330 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
331 EXPECT_NE(pldm_msgbuf_extract_int32(ctx, &val), PLDM_SUCCESS);
332 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
333 }
334
TEST(msgbuf,extract_under_int32)335 TEST(msgbuf, extract_under_int32)
336 {
337 struct pldm_msgbuf _ctx;
338 struct pldm_msgbuf* ctx = &_ctx;
339
340 int32_t buf[1] = {};
341 int32_t val;
342
343 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
344 ctx->remaining = INTMAX_MIN + sizeof(val) - 1;
345 EXPECT_NE(pldm_msgbuf_extract_int32(ctx, &val), PLDM_SUCCESS);
346 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
347 }
348
TEST(msgbuf,extract_one_real32)349 TEST(msgbuf, extract_one_real32)
350 {
351 struct pldm_msgbuf _ctx;
352 struct pldm_msgbuf* ctx = &_ctx;
353 uint32_t buf[1] = {};
354 uint32_t xform;
355 real32_t val;
356
357 val = FLT_MAX;
358 memcpy(&xform, &val, sizeof(val));
359 buf[0] = htole32(xform);
360 val = 0;
361
362 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, sizeof(buf), buf, sizeof(buf)),
363 PLDM_SUCCESS);
364 EXPECT_EQ(pldm_msgbuf_extract_real32(ctx, &val), PLDM_SUCCESS);
365 EXPECT_EQ(val, FLT_MAX);
366 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
367 }
368
TEST(msgbuf,extract_over_real32)369 TEST(msgbuf, extract_over_real32)
370 {
371 struct pldm_msgbuf _ctx;
372 struct pldm_msgbuf* ctx = &_ctx;
373 real32_t buf[1] = {};
374 real32_t val;
375
376 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
377 EXPECT_NE(pldm_msgbuf_extract_real32(ctx, &val), PLDM_SUCCESS);
378 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
379 }
380
TEST(msgbuf,extract_under_real32)381 TEST(msgbuf, extract_under_real32)
382 {
383 struct pldm_msgbuf _ctx;
384 struct pldm_msgbuf* ctx = &_ctx;
385
386 real32_t buf[1] = {};
387 real32_t val;
388
389 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
390 ctx->remaining = INTMAX_MIN + sizeof(val) - 1;
391 EXPECT_NE(pldm_msgbuf_extract_real32(ctx, &val), PLDM_SUCCESS);
392 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
393 }
394
TEST(msgbuf,extract_array_uint8_buf0_req0)395 TEST(msgbuf, extract_array_uint8_buf0_req0)
396 {
397 struct pldm_msgbuf _ctx;
398 struct pldm_msgbuf* ctx = &_ctx;
399 uint8_t buf[1] = {};
400 uint8_t arr[1];
401
402 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
403 EXPECT_EQ(pldm_msgbuf_extract_array_uint8(ctx, 0, arr, 0), PLDM_SUCCESS);
404 ASSERT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
405 }
406
TEST(msgbuf,extract_array_uint8_buf1_req1)407 TEST(msgbuf, extract_array_uint8_buf1_req1)
408 {
409 struct pldm_msgbuf _ctx;
410 struct pldm_msgbuf* ctx = &_ctx;
411 uint8_t buf[1] = {};
412 uint8_t arr[1];
413
414 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS);
415 EXPECT_EQ(
416 pldm_msgbuf_extract_array_uint8(ctx, sizeof(arr), arr, sizeof(arr)),
417 PLDM_SUCCESS);
418 EXPECT_EQ(arr[0], 0);
419 ASSERT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
420 }
421
TEST(msgbuf,extract_array_uint8_buf1_req2)422 TEST(msgbuf, extract_array_uint8_buf1_req2)
423 {
424 struct pldm_msgbuf _ctx;
425 struct pldm_msgbuf* ctx = &_ctx;
426 uint8_t buf[1] = {};
427 uint8_t arr[2];
428
429 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS);
430 EXPECT_NE(
431 pldm_msgbuf_extract_array_uint8(ctx, sizeof(arr), arr, sizeof(arr)),
432 PLDM_SUCCESS);
433 ASSERT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
434 }
435
TEST(msgbuf,extract_under_array_uint8)436 TEST(msgbuf, extract_under_array_uint8)
437 {
438 struct pldm_msgbuf _ctx;
439 struct pldm_msgbuf* ctx = &_ctx;
440 uint8_t buf[1] = {};
441 uint8_t arr[1];
442
443 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
444 ctx->remaining = INTMAX_MIN;
445 EXPECT_NE(pldm_msgbuf_extract_array_uint8(ctx, 1, arr, 1), PLDM_SUCCESS);
446 ASSERT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
447 }
448
TEST(msgbuf,extract_array_char_buf0_req0)449 TEST(msgbuf, extract_array_char_buf0_req0)
450 {
451 struct pldm_msgbuf _ctx;
452 struct pldm_msgbuf* ctx = &_ctx;
453 char buf[1] = {'\0'};
454 char arr[1] = {'1'};
455
456 ASSERT_EQ(pldm_msgbuf_init_errno(ctx, 0, buf, 0), 0);
457 EXPECT_EQ(pldm_msgbuf_extract_array_char(ctx, 0, arr, 0), 0);
458 ASSERT_EQ(pldm_msgbuf_destroy(ctx), 0);
459 }
460
TEST(msgbuf,extract_array_char_buf1_req1)461 TEST(msgbuf, extract_array_char_buf1_req1)
462 {
463 struct pldm_msgbuf _ctx;
464 struct pldm_msgbuf* ctx = &_ctx;
465 char buf[1] = {'\0'};
466 char arr[1] = {'1'};
467
468 ASSERT_EQ(pldm_msgbuf_init_errno(ctx, 0, buf, sizeof(buf)), 0);
469 EXPECT_EQ(
470 pldm_msgbuf_extract_array_char(ctx, sizeof(arr), arr, sizeof(arr)), 0);
471 EXPECT_EQ(arr[0], '\0');
472 ASSERT_EQ(pldm_msgbuf_destroy(ctx), 0);
473 }
474
TEST(msgbuf,extract_array_char_buf1_req2)475 TEST(msgbuf, extract_array_char_buf1_req2)
476 {
477 struct pldm_msgbuf _ctx;
478 struct pldm_msgbuf* ctx = &_ctx;
479 char buf[1] = {'\0'};
480 char arr[2] = {'1', '2'};
481
482 ASSERT_EQ(pldm_msgbuf_init_errno(ctx, 0, buf, sizeof(buf)), 0);
483 EXPECT_NE(
484 pldm_msgbuf_extract_array_char(ctx, sizeof(arr), arr, sizeof(arr)), 0);
485 ASSERT_EQ(pldm_msgbuf_destroy(ctx), -EOVERFLOW);
486 }
487
TEST(msgbuf,extract_under_array_char)488 TEST(msgbuf, extract_under_array_char)
489 {
490 struct pldm_msgbuf _ctx;
491 struct pldm_msgbuf* ctx = &_ctx;
492 char buf[1] = {'\0'};
493 char arr[1] = {'1'};
494
495 ASSERT_EQ(pldm_msgbuf_init_errno(ctx, 0, buf, 0), 0);
496 ctx->remaining = INTMAX_MIN;
497 EXPECT_NE(pldm_msgbuf_extract_array_char(ctx, 1, arr, 1), 0);
498 ASSERT_EQ(pldm_msgbuf_destroy(ctx), -EOVERFLOW);
499 }
500
TEST(msgbuf,consumed_under)501 TEST(msgbuf, consumed_under)
502 {
503 struct pldm_msgbuf _ctx;
504 struct pldm_msgbuf* ctx = &_ctx;
505 uint8_t buf[1] = {};
506
507 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS);
508 EXPECT_EQ(pldm_msgbuf_destroy_consumed(ctx), PLDM_ERROR_INVALID_LENGTH);
509 }
510
TEST(msgbuf,consumed_exact)511 TEST(msgbuf, consumed_exact)
512 {
513 struct pldm_msgbuf _ctx;
514 struct pldm_msgbuf* ctx = &_ctx;
515 uint8_t buf[1] = {};
516 uint8_t val;
517
518 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS);
519 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctx, &val), PLDM_SUCCESS);
520 EXPECT_EQ(pldm_msgbuf_destroy_consumed(ctx), PLDM_SUCCESS);
521 }
522
TEST(msgbuf,consumed_over)523 TEST(msgbuf, consumed_over)
524 {
525 struct pldm_msgbuf _ctx;
526 struct pldm_msgbuf* ctx = &_ctx;
527 uint8_t buf[1] = {};
528 uint8_t val[2];
529
530 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS);
531 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctx, &val[0]), PLDM_SUCCESS);
532 EXPECT_NE(pldm_msgbuf_extract_uint8(ctx, &val[1]), PLDM_SUCCESS);
533 EXPECT_EQ(pldm_msgbuf_destroy_consumed(ctx), PLDM_ERROR_INVALID_LENGTH);
534 }
535
TEST(msgbuf,pldm_msgbuf_insert_int32_good)536 TEST(msgbuf, pldm_msgbuf_insert_int32_good)
537 {
538 struct pldm_msgbuf _ctx;
539 struct pldm_msgbuf* ctx = &_ctx;
540 int32_t src = -12345;
541 int32_t checkVal = 0;
542 uint8_t buf[sizeof(int32_t)] = {};
543
544 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS);
545 EXPECT_EQ(pldm_msgbuf_insert_int32(ctx, src), PLDM_SUCCESS);
546
547 struct pldm_msgbuf _ctxExtract;
548 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
549
550 ASSERT_EQ(pldm_msgbuf_init_cc(ctxExtract, 0, buf, sizeof(buf)),
551 PLDM_SUCCESS);
552 EXPECT_EQ(pldm_msgbuf_extract_int32(ctxExtract, &checkVal), PLDM_SUCCESS);
553
554 EXPECT_EQ(src, checkVal);
555 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS);
556 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
557 }
558
TEST(msgbuf,insert_under_int32)559 TEST(msgbuf, insert_under_int32)
560 {
561 struct pldm_msgbuf _ctx;
562 struct pldm_msgbuf* ctx = &_ctx;
563
564 int32_t buf[1] = {};
565 int32_t val = 0;
566
567 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
568 ctx->remaining = INTMAX_MIN + sizeof(val) - 1;
569 EXPECT_NE(pldm_msgbuf_insert_int32(ctx, val), PLDM_SUCCESS);
570 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
571 }
572
TEST(msgbuf,pldm_msgbuf_insert_uint32_good)573 TEST(msgbuf, pldm_msgbuf_insert_uint32_good)
574 {
575 struct pldm_msgbuf _ctx;
576 struct pldm_msgbuf* ctx = &_ctx;
577 uint32_t src = 0xf1223344;
578 uint32_t checkVal = 0;
579 uint8_t buf[sizeof(uint32_t)] = {};
580
581 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS);
582 EXPECT_EQ(pldm_msgbuf_insert_uint32(ctx, src), PLDM_SUCCESS);
583
584 struct pldm_msgbuf _ctxExtract;
585 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
586
587 ASSERT_EQ(pldm_msgbuf_init_cc(ctxExtract, 0, buf, sizeof(buf)),
588 PLDM_SUCCESS);
589 EXPECT_EQ(pldm_msgbuf_extract_uint32(ctxExtract, &checkVal), PLDM_SUCCESS);
590
591 EXPECT_EQ(src, checkVal);
592 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS);
593 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
594 }
595
TEST(msgbuf,insert_under_uint32)596 TEST(msgbuf, insert_under_uint32)
597 {
598 struct pldm_msgbuf _ctx;
599 struct pldm_msgbuf* ctx = &_ctx;
600
601 uint32_t buf[1] = {};
602 uint32_t val = 0;
603
604 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
605 ctx->remaining = INTMAX_MIN + sizeof(val) - 1;
606 EXPECT_NE(pldm_msgbuf_insert_uint32(ctx, val), PLDM_SUCCESS);
607 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
608 }
609
TEST(msgbuf,pldm_msgbuf_insert_uint16_good)610 TEST(msgbuf, pldm_msgbuf_insert_uint16_good)
611 {
612 struct pldm_msgbuf _ctx;
613 struct pldm_msgbuf* ctx = &_ctx;
614 uint16_t src = 0xf344;
615 uint16_t checkVal = 0;
616 uint8_t buf[sizeof(uint16_t)] = {};
617
618 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(uint16_t)), PLDM_SUCCESS);
619 EXPECT_EQ(pldm_msgbuf_insert_uint16(ctx, src), PLDM_SUCCESS);
620
621 struct pldm_msgbuf _ctxExtract;
622 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
623
624 ASSERT_EQ(pldm_msgbuf_init_cc(ctxExtract, 0, buf, sizeof(buf)),
625 PLDM_SUCCESS);
626 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &checkVal), PLDM_SUCCESS);
627
628 EXPECT_EQ(src, checkVal);
629 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS);
630 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
631 }
632
TEST(msgbuf,insert_under_uint16)633 TEST(msgbuf, insert_under_uint16)
634 {
635 struct pldm_msgbuf _ctx;
636 struct pldm_msgbuf* ctx = &_ctx;
637
638 uint16_t buf[1] = {};
639 uint16_t val = 0;
640
641 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
642 ctx->remaining = INTMAX_MIN + sizeof(val) - 1;
643 EXPECT_NE(pldm_msgbuf_insert_uint16(ctx, val), PLDM_SUCCESS);
644 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
645 }
646
TEST(msgbuf,pldm_msgbuf_insert_int16_good)647 TEST(msgbuf, pldm_msgbuf_insert_int16_good)
648 {
649 struct pldm_msgbuf _ctx;
650 struct pldm_msgbuf* ctx = &_ctx;
651 int16_t src = -12;
652 int16_t checkVal = 0;
653 uint8_t buf[sizeof(int16_t)] = {};
654
655 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(uint16_t)), PLDM_SUCCESS);
656 EXPECT_EQ(pldm_msgbuf_insert_int16(ctx, src), PLDM_SUCCESS);
657
658 struct pldm_msgbuf _ctxExtract;
659 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
660
661 ASSERT_EQ(pldm_msgbuf_init_cc(ctxExtract, 0, buf, sizeof(buf)),
662 PLDM_SUCCESS);
663 EXPECT_EQ(pldm_msgbuf_extract_int16(ctxExtract, &checkVal), PLDM_SUCCESS);
664
665 EXPECT_EQ(src, checkVal);
666 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS);
667 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
668 }
669
TEST(msgbuf,insert_under_int16)670 TEST(msgbuf, insert_under_int16)
671 {
672 struct pldm_msgbuf _ctx;
673 struct pldm_msgbuf* ctx = &_ctx;
674
675 int16_t buf[1] = {};
676 int16_t val = 0;
677
678 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
679 ctx->remaining = INTMAX_MIN + sizeof(val) - 1;
680 EXPECT_NE(pldm_msgbuf_insert_int16(ctx, val), PLDM_SUCCESS);
681 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
682 }
683
TEST(msgbuf,pldm_msgbuf_insert_uint8_good)684 TEST(msgbuf, pldm_msgbuf_insert_uint8_good)
685 {
686 struct pldm_msgbuf _ctx;
687 struct pldm_msgbuf* ctx = &_ctx;
688 uint8_t src = 0xf4;
689 uint8_t checkVal = 0;
690 uint8_t buf[sizeof(uint8_t)] = {};
691
692 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS);
693 EXPECT_EQ(pldm_msgbuf_insert_uint8(ctx, src), PLDM_SUCCESS);
694
695 struct pldm_msgbuf _ctxExtract;
696 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
697
698 ASSERT_EQ(pldm_msgbuf_init_cc(ctxExtract, 0, buf, sizeof(buf)),
699 PLDM_SUCCESS);
700 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctxExtract, &checkVal), PLDM_SUCCESS);
701
702 EXPECT_EQ(src, checkVal);
703 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS);
704 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
705 }
706
TEST(msgbuf,insert_under_uint8)707 TEST(msgbuf, insert_under_uint8)
708 {
709 struct pldm_msgbuf _ctx;
710 struct pldm_msgbuf* ctx = &_ctx;
711
712 uint8_t buf[1] = {};
713 uint8_t val = 0;
714
715 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
716 ctx->remaining = INTMAX_MIN + sizeof(val) - 1;
717 EXPECT_NE(pldm_msgbuf_insert_uint8(ctx, val), PLDM_SUCCESS);
718 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
719 }
720
TEST(msgbuf,pldm_msgbuf_insert_int8_good)721 TEST(msgbuf, pldm_msgbuf_insert_int8_good)
722 {
723 struct pldm_msgbuf _ctx;
724 struct pldm_msgbuf* ctx = &_ctx;
725 int8_t src = -4;
726 int8_t checkVal = 0;
727 uint8_t buf[sizeof(int8_t)] = {};
728
729 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS);
730 EXPECT_EQ(pldm_msgbuf_insert_int8(ctx, src), PLDM_SUCCESS);
731
732 struct pldm_msgbuf _ctxExtract;
733 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
734
735 ASSERT_EQ(pldm_msgbuf_init_cc(ctxExtract, 0, buf, sizeof(buf)),
736 PLDM_SUCCESS);
737 EXPECT_EQ(pldm_msgbuf_extract_int8(ctxExtract, &checkVal), PLDM_SUCCESS);
738
739 EXPECT_EQ(src, checkVal);
740 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS);
741 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
742 }
743
TEST(msgbuf,insert_under_int8)744 TEST(msgbuf, insert_under_int8)
745 {
746 struct pldm_msgbuf _ctx;
747 struct pldm_msgbuf* ctx = &_ctx;
748
749 int8_t buf[1] = {};
750 int8_t val = 0;
751
752 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
753 ctx->remaining = INTMAX_MIN + sizeof(val) - 1;
754 EXPECT_NE(pldm_msgbuf_insert_int8(ctx, val), PLDM_SUCCESS);
755 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
756 }
757
TEST(msgbuf,pldm_msgbuf_insert_array_uint8_good)758 TEST(msgbuf, pldm_msgbuf_insert_array_uint8_good)
759 {
760 struct pldm_msgbuf _ctx;
761 struct pldm_msgbuf* ctx = &_ctx;
762 uint8_t src[6] = {0x11, 0x22, 0x44, 0x55, 0x66, 0x77};
763 uint8_t buf[6] = {};
764 uint8_t retBuff[6] = {};
765
766 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS);
767 EXPECT_EQ(
768 pldm_msgbuf_insert_array_uint8(ctx, sizeof(src), src, sizeof(src)),
769 PLDM_SUCCESS);
770
771 struct pldm_msgbuf _ctxExtract;
772 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
773
774 ASSERT_EQ(pldm_msgbuf_init_cc(ctxExtract, 0, buf, sizeof(buf)),
775 PLDM_SUCCESS);
776 EXPECT_EQ(pldm_msgbuf_extract_array_uint8(ctxExtract, sizeof(retBuff),
777 retBuff, sizeof(retBuff)),
778 PLDM_SUCCESS);
779
780 EXPECT_EQ(memcmp(src, retBuff, sizeof(retBuff)), 0);
781 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS);
782 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
783 }
784
TEST(msgbuf,insert_under_array_uint8)785 TEST(msgbuf, insert_under_array_uint8)
786 {
787 struct pldm_msgbuf _ctx;
788 struct pldm_msgbuf* ctx = &_ctx;
789
790 uint8_t buf[1] = {};
791 uint8_t val[1] = {0};
792
793 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
794 ctx->remaining = INTMAX_MIN + sizeof(val) - 1;
795 EXPECT_NE(
796 pldm_msgbuf_insert_array_uint8(ctx, sizeof(val), val, sizeof(val)),
797 PLDM_SUCCESS);
798 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
799 }
800
TEST(msgbuf,pldm_msgbuf_insert_array_char_good)801 TEST(msgbuf, pldm_msgbuf_insert_array_char_good)
802 {
803 struct pldm_msgbuf _ctx;
804 struct pldm_msgbuf* ctx = &_ctx;
805 char src[6] = {0x11, 0x22, 0x44, 0x55, 0x66, 0x77};
806 char buf[6] = {};
807 char retBuff[6] = {};
808
809 ASSERT_EQ(pldm_msgbuf_init_errno(ctx, 0, buf, sizeof(buf)), 0);
810 EXPECT_EQ(pldm_msgbuf_insert_array_char(ctx, sizeof(src), src, sizeof(src)),
811 0);
812
813 struct pldm_msgbuf _ctxExtract;
814 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
815
816 ASSERT_EQ(pldm_msgbuf_init_errno(ctxExtract, 0, buf, sizeof(buf)), 0);
817 EXPECT_EQ(pldm_msgbuf_extract_array_char(ctxExtract, sizeof(retBuff),
818 retBuff, sizeof(retBuff)),
819 0);
820
821 EXPECT_EQ(memcmp(src, retBuff, sizeof(retBuff)), 0);
822 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), 0);
823 EXPECT_EQ(pldm_msgbuf_destroy(ctx), 0);
824 }
825
TEST(msgbuf,insert_under_array_char)826 TEST(msgbuf, insert_under_array_char)
827 {
828 struct pldm_msgbuf _ctx;
829 struct pldm_msgbuf* ctx = &_ctx;
830 char buf[1] = {};
831 char val[1] = {0};
832
833 ASSERT_EQ(pldm_msgbuf_init_errno(ctx, 0, buf, 0), 0);
834 ctx->remaining = INTMAX_MIN + sizeof(val) - 1;
835 EXPECT_NE(pldm_msgbuf_insert_array_char(ctx, sizeof(val), val, sizeof(val)),
836 0);
837 EXPECT_EQ(pldm_msgbuf_destroy(ctx), -EOVERFLOW);
838 }
839
TEST(msgbuf,pldm_msgbuf_span_required_good)840 TEST(msgbuf, pldm_msgbuf_span_required_good)
841 {
842 struct pldm_msgbuf _ctx;
843 struct pldm_msgbuf* ctx = &_ctx;
844 uint8_t src[6] = {0x11, 0x22, 0x44, 0x55, 0x66, 0x77};
845 uint8_t buf[6] = {0};
846 const size_t required = 4;
847 uint8_t expectData[required] = {0x44, 0x55, 0x66, 0x77};
848 uint16_t testVal;
849 uint8_t* retBuff = NULL;
850
851 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS);
852 EXPECT_EQ(
853 pldm_msgbuf_insert_array_uint8(ctx, sizeof(src), src, sizeof(src)),
854 PLDM_SUCCESS);
855
856 struct pldm_msgbuf _ctxExtract;
857 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
858
859 ASSERT_EQ(pldm_msgbuf_init_cc(ctxExtract, 0, buf, sizeof(buf)),
860 PLDM_SUCCESS);
861 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), PLDM_SUCCESS);
862 EXPECT_EQ(pldm_msgbuf_span_required(ctxExtract, required, (void**)&retBuff),
863 PLDM_SUCCESS);
864
865 EXPECT_EQ(memcmp(expectData, retBuff, required), 0);
866 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS);
867 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
868 }
869
TEST(msgbuf,pldm_msgbuf_span_required_bad)870 TEST(msgbuf, pldm_msgbuf_span_required_bad)
871 {
872 struct pldm_msgbuf _ctx;
873 struct pldm_msgbuf* ctx = &_ctx;
874 uint8_t src[6] = {0x11, 0x22, 0x44, 0x55, 0x66, 0x77};
875 uint8_t buf[6] = {0};
876 const size_t required = 4;
877 uint16_t testVal;
878 [[maybe_unused]] uint8_t* retBuff = NULL;
879
880 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS);
881 EXPECT_EQ(
882 pldm_msgbuf_insert_array_uint8(ctx, sizeof(src), src, sizeof(src)),
883 PLDM_SUCCESS);
884
885 struct pldm_msgbuf _ctxExtract;
886 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
887
888 ASSERT_EQ(pldm_msgbuf_init_cc(ctxExtract, 0, buf, sizeof(buf)),
889 PLDM_SUCCESS);
890 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), PLDM_SUCCESS);
891 EXPECT_EQ(pldm_msgbuf_span_required(ctxExtract, required, NULL),
892 PLDM_SUCCESS);
893
894 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS);
895 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
896 }
897
TEST(msgbuf,span_required_under)898 TEST(msgbuf, span_required_under)
899 {
900 struct pldm_msgbuf _ctx;
901 struct pldm_msgbuf* ctx = &_ctx;
902
903 uint8_t buf[1] = {};
904 void* cursor = nullptr;
905
906 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, 0), PLDM_SUCCESS);
907 ctx->remaining = INTMAX_MIN;
908 EXPECT_NE(pldm_msgbuf_span_required(ctx, 1, &cursor), PLDM_SUCCESS);
909 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_ERROR_INVALID_LENGTH);
910 }
911
TEST(msgbuf,pldm_msgbuf_span_string_ascii_good)912 TEST(msgbuf, pldm_msgbuf_span_string_ascii_good)
913 {
914 struct pldm_msgbuf _ctxExtract;
915 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
916 uint8_t src[9] = {0x11, 0x22, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x77};
917 constexpr size_t required = 6;
918 const char expectData[required] = {0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00};
919 uint16_t testVal;
920 uint8_t testVal1;
921 char* retBuff = NULL;
922
923 ASSERT_EQ(pldm_msgbuf_init_errno(ctxExtract, 0, src, sizeof(src)), 0);
924 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), 0);
925 EXPECT_EQ(0x2211, testVal);
926 EXPECT_EQ(pldm_msgbuf_span_string_ascii(ctxExtract, (void**)&retBuff, NULL),
927 0);
928 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctxExtract, &testVal1), 0);
929 EXPECT_EQ(0x77, testVal1);
930
931 EXPECT_EQ(required, strlen(retBuff) + 1);
932 EXPECT_EQ(strncmp(expectData, retBuff, strlen(retBuff) + 1), 0);
933 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), 0);
934 }
935
TEST(msgbuf,pldm_msgbuf_span_string_ascii_good_with_length)936 TEST(msgbuf, pldm_msgbuf_span_string_ascii_good_with_length)
937 {
938 struct pldm_msgbuf _ctxExtract;
939 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
940 uint8_t src[9] = {0x11, 0x22, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00, 0x77};
941 constexpr size_t required = 6;
942 const char expectData[required] = {0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00};
943 uint16_t testVal;
944 uint8_t testVal1;
945 char* retBuff = NULL;
946 size_t length;
947
948 ASSERT_EQ(pldm_msgbuf_init_errno(ctxExtract, 0, src, sizeof(src)), 0);
949 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), 0);
950 EXPECT_EQ(0x2211, testVal);
951 EXPECT_EQ(
952 pldm_msgbuf_span_string_ascii(ctxExtract, (void**)&retBuff, &length),
953 0);
954 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctxExtract, &testVal1), 0);
955 EXPECT_EQ(0x77, testVal1);
956
957 EXPECT_EQ(required, strlen(retBuff) + 1);
958 EXPECT_EQ(length, strlen(retBuff) + 1);
959 EXPECT_EQ(required, length);
960 EXPECT_EQ(strncmp(expectData, retBuff, strlen(retBuff) + 1), 0);
961 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), 0);
962 }
963
TEST(msgbuf,pldm_msgbuf_span_string_ascii_allow_null_args)964 TEST(msgbuf, pldm_msgbuf_span_string_ascii_allow_null_args)
965 {
966 struct pldm_msgbuf _ctxExtract;
967 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
968 uint8_t src[8] = {0x11, 0x22, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x00};
969 uint16_t testVal;
970
971 ASSERT_EQ(pldm_msgbuf_init_errno(ctxExtract, 0, src, sizeof(src)), 0);
972 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), 0);
973 EXPECT_EQ(0x2211, testVal);
974 EXPECT_EQ(pldm_msgbuf_span_string_ascii(ctxExtract, NULL, NULL), 0);
975 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), 0);
976 }
977
TEST(msgbuf,pldm_msgbuf_span_string_ascii_bad_no_terminator)978 TEST(msgbuf, pldm_msgbuf_span_string_ascii_bad_no_terminator)
979 {
980 struct pldm_msgbuf _ctxExtract;
981 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
982 uint8_t src[8] = {0x11, 0x22, 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x77};
983 uint16_t testVal;
984 char* retBuff = NULL;
985
986 ASSERT_EQ(pldm_msgbuf_init_errno(ctxExtract, 0, src, sizeof(src)), 0);
987 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), 0);
988 EXPECT_EQ(0x2211, testVal);
989 EXPECT_EQ(pldm_msgbuf_span_string_ascii(ctxExtract, (void**)&retBuff, NULL),
990 -EOVERFLOW);
991 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), -EOVERFLOW);
992 }
993
TEST(msgbuf,pldm_msgbuf_span_string_ascii_under)994 TEST(msgbuf, pldm_msgbuf_span_string_ascii_under)
995 {
996 struct pldm_msgbuf _ctxExtract;
997 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
998
999 uint8_t src[1] = {};
1000 char* retBuff = NULL;
1001
1002 ASSERT_EQ(pldm_msgbuf_init_errno(ctxExtract, 0, src, 0), 0);
1003 ctxExtract->remaining = INTMAX_MIN;
1004 EXPECT_NE(pldm_msgbuf_span_string_ascii(ctxExtract, (void**)&retBuff, NULL),
1005 0);
1006 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), -EOVERFLOW);
1007 }
1008
str16len(char16_t * startptr)1009 static size_t str16len(char16_t* startptr)
1010 {
1011 char16_t* endptr = startptr;
1012 while (*endptr)
1013 {
1014 endptr++;
1015 }
1016 return endptr - startptr;
1017 }
1018
TEST(msgbuf,pldm_msgbuf_span_string_utf16_good)1019 TEST(msgbuf, pldm_msgbuf_span_string_utf16_good)
1020 {
1021 struct pldm_msgbuf _ctxExtract;
1022 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
1023 uint8_t src[] __attribute__((aligned(alignof(char16_t)))) = {
1024 0x11, 0x22, 0x11, 0x68, 0x22, 0x65, 0x33, 0x6c,
1025 0x44, 0x6c, 0x55, 0x6f, 0x00, 0x00, 0x34, 0x12};
1026 const char expectData[] = {0x11, 0x68, 0x22, 0x65, 0x33, 0x6c,
1027 0x44, 0x6c, 0x55, 0x6f, 0x00, 0x00};
1028 uint16_t testVal;
1029 uint16_t testVal1;
1030 void* retBuff = NULL;
1031
1032 ASSERT_EQ(pldm_msgbuf_init_errno(ctxExtract, 0, src, sizeof(src)), 0);
1033 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), 0);
1034 EXPECT_EQ(0x2211, testVal);
1035
1036 ASSERT_EQ(pldm_msgbuf_span_string_utf16(ctxExtract, (void**)&retBuff, NULL),
1037 0);
1038 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal1), 0);
1039 EXPECT_EQ(0x1234, testVal1);
1040
1041 ASSERT_EQ(0, (uintptr_t)retBuff & (alignof(char16_t) - 1));
1042 EXPECT_EQ(6, str16len((char16_t*)retBuff) + 1);
1043 EXPECT_EQ(0, memcmp(expectData, retBuff, sizeof(expectData)));
1044 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), 0);
1045 }
1046
TEST(msgbuf,pldm_msgbuf_span_string_utf16_good2)1047 TEST(msgbuf, pldm_msgbuf_span_string_utf16_good2)
1048 {
1049 struct pldm_msgbuf _ctxExtract;
1050 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
1051 uint8_t src[24] = {0x11, 0x22, 0x11, 0x68, 0x22, 0x65, 0x33, 0x6c,
1052 0x44, 0x6c, 0x55, 0x6f, 0x00, 0x00, 0x34, 0x12,
1053 0x44, 0x6c, 0x55, 0x6f, 0x00, 0x00, 0x34, 0x12};
1054 constexpr size_t required = 6;
1055 const char16_t expectData[required] = {0x6811, 0x6522, 0x6c33,
1056 0x6c44, 0x6f55, 0x0000};
1057 const char16_t expectData1[3] = {0x6c44, 0x6f55, 0x0000};
1058 uint16_t testVal;
1059 uint16_t testVal1;
1060 char* retBuff = NULL;
1061 char* retBuff1 = NULL;
1062 size_t length = 0;
1063
1064 ASSERT_EQ(pldm_msgbuf_init_errno(ctxExtract, 0, src, sizeof(src)), 0);
1065 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), 0);
1066 EXPECT_EQ(0x2211, testVal);
1067
1068 EXPECT_EQ(pldm_msgbuf_span_string_utf16(ctxExtract, (void**)&retBuff, NULL),
1069 0);
1070
1071 ASSERT_EQ(0, (uintptr_t)retBuff & (alignof(char16_t) - 1));
1072 EXPECT_EQ(6, str16len((char16_t*)retBuff) + 1);
1073 EXPECT_EQ(memcmp(expectData, retBuff,
1074 sizeof(char16_t) * (str16len((char16_t*)retBuff) + 1)),
1075 0);
1076
1077 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal1), 0);
1078 EXPECT_EQ(0x1234, testVal1);
1079
1080 EXPECT_EQ(
1081 pldm_msgbuf_span_string_utf16(ctxExtract, (void**)&retBuff1, &length),
1082 0);
1083
1084 EXPECT_EQ(0, length % 2);
1085 EXPECT_EQ(memcmp(expectData1, retBuff1, length), 0);
1086
1087 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal1), 0);
1088 EXPECT_EQ(0x1234, testVal1);
1089
1090 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), 0);
1091 }
1092
TEST(msgbuf,pldm_msgbuf_span_string_utf16_allow_null_args)1093 TEST(msgbuf, pldm_msgbuf_span_string_utf16_allow_null_args)
1094 {
1095 struct pldm_msgbuf _ctxExtract;
1096 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
1097 uint8_t src[14] = {0x11, 0x22, 0x11, 0x68, 0x22, 0x65, 0x33,
1098 0x6c, 0x44, 0x6c, 0x55, 0x6f, 0x00, 0x00};
1099 uint16_t testVal;
1100
1101 ASSERT_EQ(pldm_msgbuf_init_errno(ctxExtract, 0, src, sizeof(src)), 0);
1102 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), 0);
1103 EXPECT_EQ(0x2211, testVal);
1104 EXPECT_EQ(pldm_msgbuf_span_string_utf16(ctxExtract, NULL, NULL), 0);
1105 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), 0);
1106 }
1107
TEST(msgbuf,pldm_msgbuf_span_string_utf16_bad_no_terminator)1108 TEST(msgbuf, pldm_msgbuf_span_string_utf16_bad_no_terminator)
1109 {
1110 struct pldm_msgbuf _ctxExtract;
1111 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
1112 uint8_t src[14] = {0x11, 0x22, 0x11, 0x68, 0x22, 0x65, 0x33,
1113 0x6c, 0x44, 0x6c, 0x55, 0x6f, 0x66, 0x77};
1114 uint16_t testVal;
1115 char16_t* retBuff = NULL;
1116
1117 ASSERT_EQ(pldm_msgbuf_init_errno(ctxExtract, 0, src, sizeof(src)), 0);
1118 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), 0);
1119 EXPECT_EQ(0x2211, testVal);
1120 EXPECT_EQ(pldm_msgbuf_span_string_utf16(ctxExtract, (void**)&retBuff, NULL),
1121 -EOVERFLOW);
1122 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), -EOVERFLOW);
1123 }
1124
TEST(msgbuf,pldm_msgbuf_span_string_utf16_bad_odd_size)1125 TEST(msgbuf, pldm_msgbuf_span_string_utf16_bad_odd_size)
1126 {
1127 struct pldm_msgbuf _ctxExtract;
1128 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
1129 uint8_t src[] = {0x11, 0x22, 0x11, 0x68, 0x22, 0x65, 0x33,
1130 0x6c, 0x44, 0x6c, 0x55, 0x00, 0x00};
1131 uint16_t testVal;
1132 char16_t* retBuff = NULL;
1133
1134 ASSERT_EQ(pldm_msgbuf_init_errno(ctxExtract, 0, src, sizeof(src)), 0);
1135 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), 0);
1136 EXPECT_EQ(0x2211, testVal);
1137 EXPECT_EQ(pldm_msgbuf_span_string_utf16(ctxExtract, (void**)&retBuff, NULL),
1138 -EOVERFLOW);
1139 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), -EOVERFLOW);
1140 }
1141
TEST(msgbuf,pldm_msgbuf_span_string_utf16_mix)1142 TEST(msgbuf, pldm_msgbuf_span_string_utf16_mix)
1143 {
1144 struct pldm_msgbuf _ctxExtract;
1145 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
1146 uint8_t src[36] = {0x2, 0x65, 0x6e, 0x00, // Language Tag "en"
1147 0x00, 0x53, 0x00, 0x30, 0x00, 0x53, 0x00,
1148 0x58, 0x00, 0x00, // Entity Name "S0S"
1149 0x66, 0x6e, 0x00, // Language Tag "en"
1150 0x00, 0x53, 0x00, 0x31, 0x00, 0x00, // Entity Name "S1"
1151 0x67, 0x6e, 0x00, // Language Tag "en"
1152 0x00, 0x52, 0x00, 0x52, 0x00, 0x33, 0x00,
1153 0x00, // Entity Name "RR3"
1154 0x77, 0x88};
1155 uint8_t name_count;
1156 uint16_t test_val;
1157 char* tag = NULL;
1158 char* name = NULL;
1159 char* tag1 = NULL;
1160 char* name1 = NULL;
1161 char* tag2 = NULL;
1162 char* name2 = NULL;
1163 const char expectTag0[3] = {0x65, 0x6e, 0x00};
1164 const char expectTag1[3] = {0x66, 0x6e, 0x00};
1165 const char expectTag2[3] = {0x67, 0x6e, 0x00};
1166
1167 const char16_t expectName0[5] = {0x5300, 0x3000, 0x5300, 0x5800, 0x0000};
1168 const char16_t expectName1[3] = {0x5300, 0x3100, 0x0000};
1169 const char16_t expectName2[4] = {0x5200, 0x5200, 0x3300, 0x0000};
1170 size_t length = 0;
1171
1172 ASSERT_EQ(pldm_msgbuf_init_errno(ctxExtract, 0, src, sizeof(src)), 0);
1173 EXPECT_EQ(pldm_msgbuf_extract_uint8(ctxExtract, &name_count), 0);
1174 EXPECT_EQ(0x2, name_count);
1175
1176 EXPECT_EQ(pldm_msgbuf_span_string_ascii(ctxExtract, (void**)&tag, NULL), 0);
1177 EXPECT_EQ(strncmp(expectTag0, tag, strlen(tag) + 1), 0);
1178
1179 EXPECT_EQ(pldm_msgbuf_span_string_utf16(ctxExtract, (void**)&name, NULL),
1180 0);
1181 ASSERT_EQ(0, (uintptr_t)name & (alignof(char16_t) - 1));
1182 EXPECT_EQ(5, str16len((char16_t*)name) + 1);
1183 EXPECT_EQ(memcmp(expectName0, name,
1184 sizeof(char16_t) * (str16len((char16_t*)name) + 1)),
1185 0);
1186
1187 EXPECT_EQ(pldm_msgbuf_span_string_ascii(ctxExtract, (void**)&tag1, &length),
1188 0);
1189 EXPECT_EQ(strncmp(expectTag1, tag1, length), 0);
1190 EXPECT_EQ(
1191 pldm_msgbuf_span_string_utf16(ctxExtract, (void**)&name1, &length), 0);
1192 EXPECT_EQ(0, length % 2);
1193 EXPECT_EQ(memcmp(expectName1, name1, length), 0);
1194
1195 EXPECT_EQ(pldm_msgbuf_span_string_ascii(ctxExtract, (void**)&tag2, NULL),
1196 0);
1197 EXPECT_EQ(strncmp(expectTag2, tag2, strlen(tag2) + 1), 0);
1198 EXPECT_EQ(pldm_msgbuf_span_string_utf16(ctxExtract, (void**)&name2, NULL),
1199 0);
1200 ASSERT_EQ(0, (uintptr_t)name2 & (alignof(char16_t) - 1));
1201 EXPECT_EQ(4, str16len((char16_t*)name2) + 1);
1202 EXPECT_EQ(memcmp(expectName2, name2,
1203 sizeof(char16_t) * (str16len((char16_t*)name2) + 1)),
1204 0);
1205
1206 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &test_val), 0);
1207 EXPECT_EQ(0x8877, test_val);
1208
1209 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), 0);
1210 }
1211
TEST(msgbuf,pldm_msgbuf_span_string_utf16_under)1212 TEST(msgbuf, pldm_msgbuf_span_string_utf16_under)
1213 {
1214 struct pldm_msgbuf _ctxExtract;
1215 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
1216
1217 uint8_t src[1] = {};
1218 char* retBuff = NULL;
1219
1220 ASSERT_EQ(pldm_msgbuf_init_errno(ctxExtract, 0, src, 0), 0);
1221 ctxExtract->remaining = INTMAX_MIN;
1222 EXPECT_NE(pldm_msgbuf_span_string_utf16(ctxExtract, (void**)&retBuff, NULL),
1223 0);
1224 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), -EOVERFLOW);
1225 }
1226
TEST(msgbuf,pldm_msgbuf_span_remaining_good)1227 TEST(msgbuf, pldm_msgbuf_span_remaining_good)
1228 {
1229 struct pldm_msgbuf _ctx;
1230 struct pldm_msgbuf* ctx = &_ctx;
1231 uint8_t src[8] = {0x11, 0x22, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99};
1232 uint8_t buf[8] = {0};
1233 uint16_t testVal;
1234 uint8_t expectData[6] = {0x44, 0x55, 0x66, 0x77, 0x88, 0x99};
1235 size_t remaining;
1236 uint8_t* retBuff = NULL;
1237
1238 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS);
1239 EXPECT_EQ(
1240 pldm_msgbuf_insert_array_uint8(ctx, sizeof(src), src, sizeof(src)),
1241 PLDM_SUCCESS);
1242
1243 struct pldm_msgbuf _ctxExtract;
1244 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
1245
1246 ASSERT_EQ(pldm_msgbuf_init_cc(ctxExtract, 0, buf, sizeof(buf)),
1247 PLDM_SUCCESS);
1248 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), PLDM_SUCCESS);
1249 EXPECT_EQ(
1250 pldm_msgbuf_span_remaining(ctxExtract, (void**)&retBuff, &remaining),
1251 PLDM_SUCCESS);
1252
1253 EXPECT_EQ(remaining, sizeof(expectData));
1254 EXPECT_EQ(memcmp(expectData, retBuff, remaining), 0);
1255 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS);
1256 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
1257 }
1258
TEST(msgbuf,pldm_msgbuf_span_remaining_bad)1259 TEST(msgbuf, pldm_msgbuf_span_remaining_bad)
1260 {
1261 struct pldm_msgbuf _ctx;
1262 struct pldm_msgbuf* ctx = &_ctx;
1263 uint8_t src[8] = {0x11, 0x22, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99};
1264 uint8_t buf[8] = {0};
1265 uint16_t testVal;
1266
1267 ASSERT_EQ(pldm_msgbuf_init_cc(ctx, 0, buf, sizeof(buf)), PLDM_SUCCESS);
1268 EXPECT_EQ(
1269 pldm_msgbuf_insert_array_uint8(ctx, sizeof(src), src, sizeof(src)),
1270 PLDM_SUCCESS);
1271
1272 struct pldm_msgbuf _ctxExtract;
1273 struct pldm_msgbuf* ctxExtract = &_ctxExtract;
1274
1275 ASSERT_EQ(pldm_msgbuf_init_cc(ctxExtract, 0, buf, sizeof(buf)),
1276 PLDM_SUCCESS);
1277 EXPECT_EQ(pldm_msgbuf_extract_uint16(ctxExtract, &testVal), PLDM_SUCCESS);
1278
1279 EXPECT_EQ(pldm_msgbuf_destroy(ctxExtract), PLDM_SUCCESS);
1280 EXPECT_EQ(pldm_msgbuf_destroy(ctx), PLDM_SUCCESS);
1281 }
1282
TEST(msgbuf,pldm_msgbuf_copy_good)1283 TEST(msgbuf, pldm_msgbuf_copy_good)
1284 {
1285 struct pldm_msgbuf _src;
1286 struct pldm_msgbuf* src = &_src;
1287 uint16_t buf[1] = {htole16(0x5aa5)};
1288
1289 ASSERT_EQ(pldm_msgbuf_init_cc(src, sizeof(buf), buf, sizeof(buf)),
1290 PLDM_SUCCESS);
1291
1292 struct pldm_msgbuf _dst;
1293 struct pldm_msgbuf* dst = &_dst;
1294 uint16_t checkVal = 0;
1295 uint8_t buf1[sizeof(buf)] = {};
1296
1297 ASSERT_EQ(pldm_msgbuf_init_cc(dst, sizeof(buf1), buf1, sizeof(buf1)),
1298 PLDM_SUCCESS);
1299 EXPECT_EQ(pldm_msgbuf_copy(dst, src, buf[0], name), PLDM_SUCCESS);
1300
1301 ASSERT_EQ(pldm_msgbuf_init_cc(dst, sizeof(buf1), buf1, sizeof(buf1)),
1302 PLDM_SUCCESS);
1303 EXPECT_EQ(pldm_msgbuf_extract_uint16(dst, &checkVal), PLDM_SUCCESS);
1304
1305 EXPECT_EQ(pldm_msgbuf_destroy(src), PLDM_SUCCESS);
1306 EXPECT_EQ(pldm_msgbuf_destroy(dst), PLDM_SUCCESS);
1307
1308 EXPECT_EQ(buf[0], checkVal);
1309 }
1310
TEST(msgbuf,pldm_msgbuf_copy_bad)1311 TEST(msgbuf, pldm_msgbuf_copy_bad)
1312 {
1313 struct pldm_msgbuf _src;
1314 struct pldm_msgbuf* src = &_src;
1315 struct pldm_msgbuf _dst;
1316 struct pldm_msgbuf* dst = &_dst;
1317 uint8_t buf[1] = {sizeof(uint8_t)};
1318 uint8_t buf1[1] = {sizeof(uint16_t)};
1319 uint16_t value = 8;
1320
1321 ASSERT_EQ(pldm_msgbuf_init_cc(src, 0, buf, sizeof(buf)), PLDM_SUCCESS);
1322 ASSERT_EQ(pldm_msgbuf_init_cc(dst, 0, buf1, sizeof(buf1)), PLDM_SUCCESS);
1323 EXPECT_EQ(pldm_msgbuf_copy(dst, src, value, name),
1324 PLDM_ERROR_INVALID_LENGTH);
1325
1326 ASSERT_EQ(pldm_msgbuf_init_cc(src, 0, buf1, sizeof(buf1)), PLDM_SUCCESS);
1327 ASSERT_EQ(pldm_msgbuf_init_cc(dst, 0, buf, sizeof(buf)), PLDM_SUCCESS);
1328 EXPECT_EQ(pldm_msgbuf_copy(dst, src, value, name),
1329 PLDM_ERROR_INVALID_LENGTH);
1330 }
1331
TEST(msgbuf,pldm_msgbuf_copy_string_ascii_exact)1332 TEST(msgbuf, pldm_msgbuf_copy_string_ascii_exact)
1333 {
1334 const char msg[] = "this is a message";
1335
1336 struct pldm_msgbuf _src;
1337 struct pldm_msgbuf* src = &_src;
1338 struct pldm_msgbuf _dst;
1339 struct pldm_msgbuf* dst = &_dst;
1340
1341 char buf[sizeof(msg)] = {};
1342
1343 ASSERT_EQ(pldm_msgbuf_init_errno(src, 0, msg, sizeof(msg)), 0);
1344 ASSERT_EQ(pldm_msgbuf_init_errno(dst, 0, buf, sizeof(buf)), 0);
1345 EXPECT_EQ(pldm_msgbuf_copy_string_ascii(dst, src), 0);
1346 ASSERT_EQ(pldm_msgbuf_destroy(dst), 0);
1347 ASSERT_EQ(pldm_msgbuf_destroy(src), 0);
1348 EXPECT_EQ(0, memcmp(msg, buf, sizeof(buf)));
1349 }
1350
TEST(msgbuf,pldm_msgbuf_copy_string_ascii_dst_exceeds_src)1351 TEST(msgbuf, pldm_msgbuf_copy_string_ascii_dst_exceeds_src)
1352 {
1353 const char msg[] = "this is a message";
1354
1355 struct pldm_msgbuf _src;
1356 struct pldm_msgbuf* src = &_src;
1357 struct pldm_msgbuf _dst;
1358 struct pldm_msgbuf* dst = &_dst;
1359
1360 char buf[sizeof(msg) + 1] = {};
1361
1362 ASSERT_EQ(pldm_msgbuf_init_errno(src, 0, msg, sizeof(msg)), 0);
1363 ASSERT_EQ(pldm_msgbuf_init_errno(dst, 0, buf, sizeof(buf)), 0);
1364 EXPECT_EQ(pldm_msgbuf_copy_string_ascii(dst, src), 0);
1365 ASSERT_EQ(pldm_msgbuf_destroy(dst), 0);
1366 ASSERT_EQ(pldm_msgbuf_destroy(src), 0);
1367 EXPECT_EQ(0, memcmp(buf, msg, sizeof(msg)));
1368 }
1369
TEST(msgbuf,pldm_msgbuf_copy_string_ascii_src_exceeds_dst)1370 TEST(msgbuf, pldm_msgbuf_copy_string_ascii_src_exceeds_dst)
1371 {
1372 const char msg[] = "this is a message";
1373
1374 struct pldm_msgbuf _src;
1375 struct pldm_msgbuf* src = &_src;
1376 struct pldm_msgbuf _dst;
1377 struct pldm_msgbuf* dst = &_dst;
1378
1379 char buf[sizeof(msg) - 1] = {};
1380
1381 ASSERT_EQ(pldm_msgbuf_init_errno(src, 0, msg, sizeof(msg)), 0);
1382 ASSERT_EQ(pldm_msgbuf_init_errno(dst, 0, buf, sizeof(buf)), 0);
1383 EXPECT_EQ(pldm_msgbuf_copy_string_ascii(dst, src), -EOVERFLOW);
1384 ASSERT_EQ(pldm_msgbuf_destroy(dst), -EOVERFLOW);
1385 ASSERT_EQ(pldm_msgbuf_destroy(src), 0);
1386 }
1387
TEST(msgbuf,pldm_msgbuf_copy_string_ascii_unterminated_src)1388 TEST(msgbuf, pldm_msgbuf_copy_string_ascii_unterminated_src)
1389 {
1390 const char msg[] = {'a'};
1391
1392 struct pldm_msgbuf _src;
1393 struct pldm_msgbuf* src = &_src;
1394 struct pldm_msgbuf _dst;
1395 struct pldm_msgbuf* dst = &_dst;
1396
1397 char buf[sizeof(msg)] = {};
1398
1399 ASSERT_EQ(pldm_msgbuf_init_errno(src, 0, msg, sizeof(msg)), 0);
1400 ASSERT_EQ(pldm_msgbuf_init_errno(dst, 0, buf, sizeof(buf)), 0);
1401 EXPECT_EQ(pldm_msgbuf_copy_string_ascii(dst, src), -EOVERFLOW);
1402 ASSERT_EQ(pldm_msgbuf_destroy(dst), 0);
1403 ASSERT_EQ(pldm_msgbuf_destroy(src), -EOVERFLOW);
1404 }
1405
TEST(msgbuf,pldm_msgbuf_copy_utf16_exact)1406 TEST(msgbuf, pldm_msgbuf_copy_utf16_exact)
1407 {
1408 const char16_t msg[] = u"this is a message";
1409
1410 struct pldm_msgbuf _src;
1411 struct pldm_msgbuf* src = &_src;
1412 struct pldm_msgbuf _dst;
1413 struct pldm_msgbuf* dst = &_dst;
1414
1415 char buf[sizeof(msg)] = {};
1416
1417 ASSERT_EQ(pldm_msgbuf_init_errno(src, 0, msg, sizeof(msg)), 0);
1418 ASSERT_EQ(pldm_msgbuf_init_errno(dst, 0, buf, sizeof(buf)), 0);
1419 EXPECT_EQ(pldm_msgbuf_copy_string_utf16(dst, src), 0);
1420 ASSERT_EQ(pldm_msgbuf_destroy(dst), 0);
1421 ASSERT_EQ(pldm_msgbuf_destroy(src), 0);
1422 EXPECT_EQ(0, memcmp(buf, msg, sizeof(msg)));
1423 }
1424
TEST(msgbuf,pldm_msgbuf_copy_utf16_dst_exceeds_src)1425 TEST(msgbuf, pldm_msgbuf_copy_utf16_dst_exceeds_src)
1426 {
1427 const char16_t msg[] = u"this is a message";
1428
1429 struct pldm_msgbuf _src;
1430 struct pldm_msgbuf* src = &_src;
1431 struct pldm_msgbuf _dst;
1432 struct pldm_msgbuf* dst = &_dst;
1433
1434 char buf[sizeof(msg) + 1] = {};
1435
1436 ASSERT_EQ(pldm_msgbuf_init_errno(src, 0, msg, sizeof(msg)), 0);
1437 ASSERT_EQ(pldm_msgbuf_init_errno(dst, 0, buf, sizeof(buf)), 0);
1438 EXPECT_EQ(pldm_msgbuf_copy_string_utf16(dst, src), 0);
1439 ASSERT_EQ(pldm_msgbuf_destroy(dst), 0);
1440 ASSERT_EQ(pldm_msgbuf_destroy(src), 0);
1441 EXPECT_EQ(0, memcmp(buf, msg, sizeof(msg)));
1442 }
1443
TEST(msgbuf,pldm_msgbuf_copy_utf16_src_exceeds_dst)1444 TEST(msgbuf, pldm_msgbuf_copy_utf16_src_exceeds_dst)
1445 {
1446 const char16_t msg[] = u"this is a message";
1447
1448 struct pldm_msgbuf _src;
1449 struct pldm_msgbuf* src = &_src;
1450 struct pldm_msgbuf _dst;
1451 struct pldm_msgbuf* dst = &_dst;
1452
1453 char buf[sizeof(msg) - 1] = {};
1454
1455 ASSERT_EQ(pldm_msgbuf_init_errno(src, 0, msg, sizeof(msg)), 0);
1456 ASSERT_EQ(pldm_msgbuf_init_errno(dst, 0, buf, sizeof(buf)), 0);
1457 EXPECT_EQ(pldm_msgbuf_copy_string_utf16(dst, src), -EOVERFLOW);
1458 ASSERT_EQ(pldm_msgbuf_destroy(dst), -EOVERFLOW);
1459 ASSERT_EQ(pldm_msgbuf_destroy(src), 0);
1460 }
1461
TEST(msgbuf,pldm_msgbuf_copy_utf16_unterminated_src)1462 TEST(msgbuf, pldm_msgbuf_copy_utf16_unterminated_src)
1463 {
1464 const char16_t msg[] = {u'a'};
1465
1466 struct pldm_msgbuf _src;
1467 struct pldm_msgbuf* src = &_src;
1468 struct pldm_msgbuf _dst;
1469 struct pldm_msgbuf* dst = &_dst;
1470
1471 char buf[sizeof(msg)] = {};
1472
1473 ASSERT_EQ(pldm_msgbuf_init_errno(src, 0, msg, sizeof(msg)), 0);
1474 ASSERT_EQ(pldm_msgbuf_init_errno(dst, 0, buf, sizeof(buf)), 0);
1475 EXPECT_EQ(pldm_msgbuf_copy_string_utf16(dst, src), -EOVERFLOW);
1476 ASSERT_EQ(pldm_msgbuf_destroy(dst), 0);
1477 ASSERT_EQ(pldm_msgbuf_destroy(src), -EOVERFLOW);
1478 }
1479