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