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