1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2014 Intel Corporation
3 */
4
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <string.h>
8
9 #include <rte_string_fns.h>
10
11 #include <cmdline_cirbuf.h>
12
13 #include "test_cmdline.h"
14
15 /* different length strings */
16 #define CIRBUF_STR_HEAD " HEAD"
17 #define CIRBUF_STR_TAIL "TAIL"
18
19 /* miscellaneous tests - they make bullseye happy */
20 static int
test_cirbuf_string_misc(void)21 test_cirbuf_string_misc(void)
22 {
23 struct cirbuf cb;
24 char buf[CMDLINE_TEST_BUFSIZE];
25 char tmp[CMDLINE_TEST_BUFSIZE];
26
27 /* initialize buffers */
28 memset(buf, 0, sizeof(buf));
29 memset(tmp, 0, sizeof(tmp));
30
31 /*
32 * initialize circular buffer
33 */
34 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
35 printf("Error: failed to initialize circular buffer!\n");
36 return -1;
37 }
38
39 /*
40 * add strings to head and tail, but read only tail
41 * this results in read operation that does not transcend
42 * from buffer end to buffer beginning (in other words,
43 * strlen <= cb->maxlen - cb->end)
44 */
45
46 /* add string to head */
47 if (cirbuf_add_buf_head(&cb, CIRBUF_STR_HEAD, sizeof(CIRBUF_STR_HEAD))
48 != (sizeof(CIRBUF_STR_HEAD))) {
49 printf("Error: failed to add string to head!\n");
50 return -1;
51 }
52 /* add string to tail */
53 if (cirbuf_add_buf_tail(&cb, CIRBUF_STR_TAIL, sizeof(CIRBUF_STR_TAIL))
54 != (sizeof(CIRBUF_STR_TAIL))) {
55 printf("Error: failed to add string to head!\n");
56 return -1;
57 }
58 /* read string from tail */
59 if (cirbuf_get_buf_tail(&cb, tmp, sizeof(CIRBUF_STR_TAIL))
60 != (sizeof(CIRBUF_STR_TAIL))) {
61 printf("Error: failed to get string from tail!\n");
62 return -1;
63 }
64 /* verify string */
65 if (strncmp(tmp, CIRBUF_STR_TAIL, sizeof(CIRBUF_STR_TAIL)) != 0) {
66 printf("Error: tail strings do not match!\n");
67 return -1;
68 }
69 /* clear buffers */
70 memset(tmp, 0, sizeof(tmp));
71 memset(buf, 0, sizeof(buf));
72
73
74
75 /*
76 * add a string to buffer when start/end is at end of buffer
77 */
78
79 /*
80 * reinitialize circular buffer with start at the end of cirbuf
81 */
82 if (cirbuf_init(&cb, buf, CMDLINE_TEST_BUFSIZE - 2, sizeof(buf)) < 0) {
83 printf("Error: failed to reinitialize circular buffer!\n");
84 return -1;
85 }
86
87
88 /* add string to tail */
89 if (cirbuf_add_buf_tail(&cb, CIRBUF_STR_TAIL, sizeof(CIRBUF_STR_TAIL))
90 != (sizeof(CIRBUF_STR_TAIL))) {
91 printf("Error: failed to add string to tail!\n");
92 return -1;
93 }
94 /* read string from tail */
95 if (cirbuf_get_buf_tail(&cb, tmp, sizeof(CIRBUF_STR_TAIL))
96 != (sizeof(CIRBUF_STR_TAIL))) {
97 printf("Error: failed to get string from tail!\n");
98 return -1;
99 }
100 /* verify string */
101 if (strncmp(tmp, CIRBUF_STR_TAIL, sizeof(CIRBUF_STR_TAIL)) != 0) {
102 printf("Error: tail strings do not match!\n");
103 return -1;
104 }
105 /* clear tmp buffer */
106 memset(tmp, 0, sizeof(tmp));
107
108
109 /* add string to head */
110 if (cirbuf_add_buf_head(&cb, CIRBUF_STR_HEAD, sizeof(CIRBUF_STR_HEAD))
111 != (sizeof(CIRBUF_STR_HEAD))) {
112 printf("Error: failed to add string to head!\n");
113 return -1;
114 }
115 /* read string from tail */
116 if (cirbuf_get_buf_head(&cb, tmp, sizeof(CIRBUF_STR_HEAD))
117 != (sizeof(CIRBUF_STR_HEAD))) {
118 printf("Error: failed to get string from head!\n");
119 return -1;
120 }
121 /* verify string */
122 if (strncmp(tmp, CIRBUF_STR_HEAD, sizeof(CIRBUF_STR_HEAD)) != 0) {
123 printf("Error: headstrings do not match!\n");
124 return -1;
125 }
126
127 return 0;
128 }
129
130 /* test adding and deleting strings */
131 static int
test_cirbuf_string_add_del(void)132 test_cirbuf_string_add_del(void)
133 {
134 struct cirbuf cb;
135 char buf[CMDLINE_TEST_BUFSIZE];
136 char tmp[CMDLINE_TEST_BUFSIZE];
137
138 /* initialize buffers */
139 memset(buf, 0, sizeof(buf));
140 memset(tmp, 0, sizeof(tmp));
141
142 /*
143 * initialize circular buffer
144 */
145 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
146 printf("Error: failed to initialize circular buffer!\n");
147 return -1;
148 }
149
150 /* add string to head */
151 if (cirbuf_add_buf_head(&cb, CIRBUF_STR_HEAD, sizeof(CIRBUF_STR_HEAD))
152 != (sizeof(CIRBUF_STR_HEAD))) {
153 printf("Error: failed to add string to head!\n");
154 return -1;
155 }
156 /* read string from head */
157 if (cirbuf_get_buf_head(&cb, tmp, sizeof(CIRBUF_STR_HEAD))
158 != (sizeof(CIRBUF_STR_HEAD))) {
159 printf("Error: failed to get string from head!\n");
160 return -1;
161 }
162 /* verify string */
163 if (strncmp(tmp, CIRBUF_STR_HEAD, sizeof(CIRBUF_STR_HEAD)) != 0) {
164 printf("Error: head strings do not match!\n");
165 return -1;
166 }
167 /* clear tmp buffer */
168 memset(tmp, 0, sizeof(tmp));
169 /* read string from tail */
170 if (cirbuf_get_buf_tail(&cb, tmp, sizeof(CIRBUF_STR_HEAD))
171 != (sizeof(CIRBUF_STR_HEAD))) {
172 printf("Error: failed to get string from head!\n");
173 return -1;
174 }
175 /* verify string */
176 if (strncmp(tmp, CIRBUF_STR_HEAD, sizeof(CIRBUF_STR_HEAD)) != 0) {
177 printf("Error: head strings do not match!\n");
178 return -1;
179 }
180 /* delete string from head*/
181 if (cirbuf_del_buf_head(&cb, sizeof(CIRBUF_STR_HEAD)) < 0) {
182 printf("Error: failed to delete string from head!\n");
183 return -1;
184 }
185 /* verify string was deleted */
186 if (cirbuf_del_head_safe(&cb) == 0) {
187 printf("Error: buffer should have been empty!\n");
188 return -1;
189 }
190 /* clear tmp buffer */
191 memset(tmp, 0, sizeof(tmp));
192
193
194
195 /*
196 * reinitialize circular buffer
197 */
198 memset(buf, 0, sizeof(buf));
199 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
200 printf("Error: failed to reinitialize circular buffer!\n");
201 return -1;
202 }
203
204 /* add string to tail */
205 if (cirbuf_add_buf_tail(&cb, CIRBUF_STR_TAIL, sizeof(CIRBUF_STR_TAIL))
206 != (sizeof(CIRBUF_STR_TAIL))) {
207 printf("Error: failed to add string to tail!\n");
208 return -1;
209 }
210 /* get string from tail */
211 if (cirbuf_get_buf_tail(&cb, tmp, sizeof(CIRBUF_STR_TAIL))
212 != (sizeof(CIRBUF_STR_TAIL))) {
213 printf("Error: failed to get string from tail!\n");
214 return -1;
215 }
216 /* verify string */
217 if (strncmp(tmp, CIRBUF_STR_TAIL, sizeof(CIRBUF_STR_TAIL)) != 0) {
218 printf("Error: tail strings do not match!\n");
219 return -1;
220 }
221 /* clear tmp buffer */
222 memset(tmp, 0, sizeof(tmp));
223 /* get string from head */
224 if (cirbuf_get_buf_head(&cb, tmp, sizeof(CIRBUF_STR_TAIL))
225 != (sizeof(CIRBUF_STR_TAIL))) {
226 printf("Error: failed to get string from tail!\n");
227 return -1;
228 }
229 /* verify string */
230 if (strncmp(tmp, CIRBUF_STR_TAIL, sizeof(CIRBUF_STR_TAIL)) != 0) {
231 printf("Error: tail strings do not match!\n");
232 return -1;
233 }
234 /* delete string from tail */
235 if (cirbuf_del_buf_tail(&cb, sizeof(CIRBUF_STR_TAIL)) < 0) {
236 printf("Error: failed to delete string from tail!\n");
237 return -1;
238 }
239 /* verify string was deleted */
240 if (cirbuf_del_tail_safe(&cb) == 0) {
241 printf("Error: buffer should have been empty!\n");
242 return -1;
243 }
244
245 return 0;
246 }
247
248 /* test adding from head and deleting from tail, and vice versa */
249 static int
test_cirbuf_string_add_del_reverse(void)250 test_cirbuf_string_add_del_reverse(void)
251 {
252 struct cirbuf cb;
253 char buf[CMDLINE_TEST_BUFSIZE];
254 char tmp[CMDLINE_TEST_BUFSIZE];
255
256 /* initialize buffers */
257 memset(buf, 0, sizeof(buf));
258 memset(tmp, 0, sizeof(tmp));
259
260 /*
261 * initialize circular buffer
262 */
263 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
264 printf("Error: failed to initialize circular buffer!\n");
265 return -1;
266 }
267
268 /* add string to head */
269 if (cirbuf_add_buf_head(&cb, CIRBUF_STR_HEAD, sizeof(CIRBUF_STR_HEAD))
270 != (sizeof(CIRBUF_STR_HEAD))) {
271 printf("Error: failed to add string to head!\n");
272 return -1;
273 }
274 /* delete string from tail */
275 if (cirbuf_del_buf_tail(&cb, sizeof(CIRBUF_STR_HEAD)) < 0) {
276 printf("Error: failed to delete string from tail!\n");
277 return -1;
278 }
279 /* verify string was deleted */
280 if (cirbuf_del_tail_safe(&cb) == 0) {
281 printf("Error: buffer should have been empty!\n");
282 return -1;
283 }
284 /* clear tmp buffer */
285 memset(tmp, 0, sizeof(tmp));
286
287 /*
288 * reinitialize circular buffer
289 */
290 memset(buf, 0, sizeof(buf));
291 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
292 printf("Error: failed to reinitialize circular buffer!\n");
293 return -1;
294 }
295
296 /* add string to tail */
297 if (cirbuf_add_buf_tail(&cb, CIRBUF_STR_TAIL, sizeof(CIRBUF_STR_TAIL))
298 != (sizeof(CIRBUF_STR_TAIL))) {
299 printf("Error: failed to add string to tail!\n");
300 return -1;
301 }
302 /* delete string from head */
303 if (cirbuf_del_buf_head(&cb, sizeof(CIRBUF_STR_TAIL)) < 0) {
304 printf("Error: failed to delete string from head!\n");
305 return -1;
306 }
307 /* verify string was deleted */
308 if (cirbuf_del_head_safe(&cb) == 0) {
309 printf("Error: buffer should have been empty!\n");
310 return -1;
311 }
312
313 return 0;
314 }
315
316 /* try to write more than available */
317 static int
test_cirbuf_string_add_boundaries(void)318 test_cirbuf_string_add_boundaries(void)
319 {
320 struct cirbuf cb;
321 char buf[CMDLINE_TEST_BUFSIZE];
322 unsigned i;
323
324 /* initialize buffers */
325 memset(buf, 0, sizeof(buf));
326
327 /*
328 * initialize circular buffer
329 */
330 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
331 printf("Error: failed to initialize circular buffer!\n");
332 return -1;
333 }
334
335 /* fill the buffer from tail */
336 for (i = 0; i < CMDLINE_TEST_BUFSIZE - sizeof(CIRBUF_STR_TAIL) + 1; i++)
337 cirbuf_add_tail_safe(&cb, 't');
338
339 /* try adding a string to tail */
340 if (cirbuf_add_buf_tail(&cb, CIRBUF_STR_TAIL, sizeof(CIRBUF_STR_TAIL))
341 > 0) {
342 printf("Error: buffer should have been full!\n");
343 return -1;
344 }
345 /* try adding a string to head */
346 if (cirbuf_add_buf_head(&cb, CIRBUF_STR_TAIL, sizeof(CIRBUF_STR_TAIL))
347 > 0) {
348 printf("Error: buffer should have been full!\n");
349 return -1;
350 }
351
352 /*
353 * reinitialize circular buffer
354 */
355 memset(buf, 0, sizeof(buf));
356 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
357 printf("Error: failed to reinitialize circular buffer!\n");
358 return -1;
359 }
360
361 /* fill the buffer from head */
362 for (i = 0; i < CMDLINE_TEST_BUFSIZE - sizeof(CIRBUF_STR_HEAD) + 1; i++)
363 cirbuf_add_head_safe(&cb, 'h');
364
365 /* try adding a string to head */
366 if (cirbuf_add_buf_head(&cb, CIRBUF_STR_HEAD, sizeof(CIRBUF_STR_HEAD))
367 > 0) {
368 printf("Error: buffer should have been full!\n");
369 return -1;
370 }
371 /* try adding a string to tail */
372 if (cirbuf_add_buf_tail(&cb, CIRBUF_STR_HEAD, sizeof(CIRBUF_STR_HEAD))
373 > 0) {
374 printf("Error: buffer should have been full!\n");
375 return -1;
376 }
377
378 return 0;
379 }
380
381 /* try to read/delete more than written */
382 static int
test_cirbuf_string_get_del_boundaries(void)383 test_cirbuf_string_get_del_boundaries(void)
384 {
385 struct cirbuf cb;
386 char buf[CMDLINE_TEST_BUFSIZE];
387 char tmp[CMDLINE_TEST_BUFSIZE];
388
389 /* initialize buffers */
390 memset(buf, 0, sizeof(buf));
391 memset(tmp, 0, sizeof(tmp));
392
393 /*
394 * initialize circular buffer
395 */
396 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
397 printf("Error: failed to initialize circular buffer!\n");
398 return -1;
399 }
400
401
402 /* add string to head */
403 if (cirbuf_add_buf_head(&cb, CIRBUF_STR_HEAD, sizeof(CIRBUF_STR_HEAD))
404 != (sizeof(CIRBUF_STR_HEAD))) {
405 printf("Error: failed to add string to head!\n");
406 return -1;
407 }
408 /* read more than written (head) */
409 if (cirbuf_get_buf_head(&cb, tmp, sizeof(CIRBUF_STR_HEAD) + 1)
410 != sizeof(CIRBUF_STR_HEAD)) {
411 printf("Error: unexpected result when reading too much data!\n");
412 return -1;
413 }
414 /* read more than written (tail) */
415 if (cirbuf_get_buf_tail(&cb, tmp, sizeof(CIRBUF_STR_HEAD) + 1)
416 != sizeof(CIRBUF_STR_HEAD)) {
417 printf("Error: unexpected result when reading too much data!\n");
418 return -1;
419 }
420 /* delete more than written (head) */
421 if (cirbuf_del_buf_head(&cb, sizeof(CIRBUF_STR_HEAD) + 1) == 0) {
422 printf("Error: unexpected result when deleting too much data!\n");
423 return -1;
424 }
425 /* delete more than written (tail) */
426 if (cirbuf_del_buf_tail(&cb, sizeof(CIRBUF_STR_HEAD) + 1) == 0) {
427 printf("Error: unexpected result when deleting too much data!\n");
428 return -1;
429 }
430
431 /*
432 * reinitialize circular buffer
433 */
434 memset(buf, 0, sizeof(buf));
435 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
436 printf("Error: failed to reinitialize circular buffer!\n");
437 return -1;
438 }
439
440 /* add string to tail */
441 if (cirbuf_add_buf_tail(&cb, CIRBUF_STR_TAIL, sizeof(CIRBUF_STR_TAIL))
442 != (sizeof(CIRBUF_STR_TAIL))) {
443 printf("Error: failed to add string to tail!\n");
444 return -1;
445 }
446 /* read more than written (tail) */
447 if (cirbuf_get_buf_tail(&cb, tmp, sizeof(CIRBUF_STR_TAIL) + 1)
448 != sizeof(CIRBUF_STR_TAIL)) {
449 printf("Error: unexpected result when reading too much data!\n");
450 return -1;
451 }
452 /* read more than written (head) */
453 if (cirbuf_get_buf_head(&cb, tmp, sizeof(CIRBUF_STR_TAIL) + 1)
454 != sizeof(CIRBUF_STR_TAIL)) {
455 printf("Error: unexpected result when reading too much data!\n");
456 return -1;
457 }
458 /* delete more than written (tail) */
459 if (cirbuf_del_buf_tail(&cb, sizeof(CIRBUF_STR_TAIL) + 1) == 0) {
460 printf("Error: unexpected result when deleting too much data!\n");
461 return -1;
462 }
463 /* delete more than written (head) */
464 if (cirbuf_del_buf_tail(&cb, sizeof(CIRBUF_STR_TAIL) + 1) == 0) {
465 printf("Error: unexpected result when deleting too much data!\n");
466 return -1;
467 }
468
469 return 0;
470 }
471
472 /* try to read/delete less than written */
473 static int
test_cirbuf_string_get_del_partial(void)474 test_cirbuf_string_get_del_partial(void)
475 {
476 struct cirbuf cb;
477 char buf[CMDLINE_TEST_BUFSIZE];
478 char tmp[CMDLINE_TEST_BUFSIZE];
479 char tmp2[CMDLINE_TEST_BUFSIZE];
480
481 /* initialize buffers */
482 memset(buf, 0, sizeof(buf));
483 memset(tmp, 0, sizeof(tmp));
484 memset(tmp2, 0, sizeof(tmp));
485
486 strlcpy(tmp2, CIRBUF_STR_HEAD, sizeof(tmp2));
487
488 /*
489 * initialize circular buffer
490 */
491 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
492 printf("Error: failed to initialize circular buffer!\n");
493 return -1;
494 }
495
496 /* add string to head */
497 if (cirbuf_add_buf_head(&cb, CIRBUF_STR_HEAD, sizeof(CIRBUF_STR_HEAD))
498 != (sizeof(CIRBUF_STR_HEAD))) {
499 printf("Error: failed to add string to head!\n");
500 return -1;
501 }
502 /* read less than written (head) */
503 if (cirbuf_get_buf_head(&cb, tmp, sizeof(CIRBUF_STR_HEAD) - 1)
504 != sizeof(CIRBUF_STR_HEAD) - 1) {
505 printf("Error: unexpected result when reading from head!\n");
506 return -1;
507 }
508 /* verify string */
509 if (strncmp(tmp, tmp2, sizeof(CIRBUF_STR_HEAD) - 1) != 0) {
510 printf("Error: strings mismatch!\n");
511 return -1;
512 }
513 memset(tmp, 0, sizeof(tmp));
514 /* read less than written (tail) */
515 if (cirbuf_get_buf_tail(&cb, tmp, sizeof(CIRBUF_STR_HEAD) - 1)
516 != sizeof(CIRBUF_STR_HEAD) - 1) {
517 printf("Error: unexpected result when reading from tail!\n");
518 return -1;
519 }
520 /* verify string */
521 if (strncmp(tmp, &tmp2[1], sizeof(CIRBUF_STR_HEAD) - 1) != 0) {
522 printf("Error: strings mismatch!\n");
523 return -1;
524 }
525
526 /*
527 * verify correct deletion
528 */
529
530 /* clear buffer */
531 memset(tmp, 0, sizeof(tmp));
532
533 /* delete less than written (head) */
534 if (cirbuf_del_buf_head(&cb, 1) != 0) {
535 printf("Error: delete from head failed!\n");
536 return -1;
537 }
538 /* read from head */
539 if (cirbuf_get_buf_head(&cb, tmp, sizeof(CIRBUF_STR_HEAD) - 1)
540 != sizeof(CIRBUF_STR_HEAD) - 1) {
541 printf("Error: unexpected result when reading from head!\n");
542 return -1;
543 }
544 /* since we deleted from head, first char should be deleted */
545 if (strncmp(tmp, &tmp2[1], sizeof(CIRBUF_STR_HEAD) - 1) != 0) {
546 printf("Error: strings mismatch!\n");
547 return -1;
548 }
549 /* clear buffer */
550 memset(tmp, 0, sizeof(tmp));
551
552 /* delete less than written (tail) */
553 if (cirbuf_del_buf_tail(&cb, 1) != 0) {
554 printf("Error: delete from tail failed!\n");
555 return -1;
556 }
557 /* read from tail */
558 if (cirbuf_get_buf_tail(&cb, tmp, sizeof(CIRBUF_STR_HEAD) - 2)
559 != sizeof(CIRBUF_STR_HEAD) - 2) {
560 printf("Error: unexpected result when reading from head!\n");
561 return -1;
562 }
563 /* since we deleted from tail, last char should be deleted */
564 if (strncmp(tmp, &tmp2[1], sizeof(CIRBUF_STR_HEAD) - 2) != 0) {
565 printf("Error: strings mismatch!\n");
566 return -1;
567 }
568
569 return 0;
570 }
571
572 /* test cmdline_cirbuf char add/del functions */
573 static int
test_cirbuf_char_add_del(void)574 test_cirbuf_char_add_del(void)
575 {
576 struct cirbuf cb;
577 char buf[CMDLINE_TEST_BUFSIZE];
578 char tmp[CMDLINE_TEST_BUFSIZE];
579
580 /* clear buffer */
581 memset(buf, 0, sizeof(buf));
582 memset(tmp, 0, sizeof(tmp));
583
584 /*
585 * initialize circular buffer
586 */
587 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
588 printf("Error: failed to initialize circular buffer!\n");
589 return -1;
590 }
591
592 /*
593 * try to delete something from cirbuf. since it's empty,
594 * these should fail.
595 */
596 if (cirbuf_del_head_safe(&cb) == 0) {
597 printf("Error: deleting from empty cirbuf head succeeded!\n");
598 return -1;
599 }
600 if (cirbuf_del_tail_safe(&cb) == 0) {
601 printf("Error: deleting from empty cirbuf tail succeeded!\n");
602 return -1;
603 }
604
605 /*
606 * add, verify and delete. these should pass.
607 */
608 if (cirbuf_add_head_safe(&cb,'h') < 0) {
609 printf("Error: adding to cirbuf head failed!\n");
610 return -1;
611 }
612 if (cirbuf_get_head(&cb) != 'h') {
613 printf("Error: wrong head content!\n");
614 return -1;
615 }
616 if (cirbuf_del_head_safe(&cb) < 0) {
617 printf("Error: deleting from cirbuf head failed!\n");
618 return -1;
619 }
620 if (cirbuf_add_tail_safe(&cb,'t') < 0) {
621 printf("Error: adding to cirbuf tail failed!\n");
622 return -1;
623 }
624 if (cirbuf_get_tail(&cb) != 't') {
625 printf("Error: wrong tail content!\n");
626 return -1;
627 }
628 if (cirbuf_del_tail_safe(&cb) < 0) {
629 printf("Error: deleting from cirbuf tail failed!\n");
630 return -1;
631 }
632 /* do the same for unsafe versions. those are void. */
633 cirbuf_add_head(&cb,'h');
634 if (cirbuf_get_head(&cb) != 'h') {
635 printf("Error: wrong head content!\n");
636 return -1;
637 }
638 cirbuf_del_head(&cb);
639
640 /* test if char has been deleted. we can't call cirbuf_get_head
641 * because it's unsafe, but we can call cirbuf_get_buf_head.
642 */
643 if (cirbuf_get_buf_head(&cb, tmp, 1) > 0) {
644 printf("Error: buffer should have been empty!\n");
645 return -1;
646 }
647
648 cirbuf_add_tail(&cb,'t');
649 if (cirbuf_get_tail(&cb) != 't') {
650 printf("Error: wrong tail content!\n");
651 return -1;
652 }
653 cirbuf_del_tail(&cb);
654
655 /* test if char has been deleted. we can't call cirbuf_get_tail
656 * because it's unsafe, but we can call cirbuf_get_buf_tail.
657 */
658 if (cirbuf_get_buf_tail(&cb, tmp, 1) > 0) {
659 printf("Error: buffer should have been empty!\n");
660 return -1;
661 }
662
663 return 0;
664 }
665
666 /* test filling up buffer with chars */
667 static int
test_cirbuf_char_fill(void)668 test_cirbuf_char_fill(void)
669 {
670 struct cirbuf cb;
671 char buf[CMDLINE_TEST_BUFSIZE];
672 unsigned i;
673
674 /* clear buffer */
675 memset(buf, 0, sizeof(buf));
676
677 /*
678 * initialize circular buffer
679 */
680 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
681 printf("Error: failed to initialize circular buffer!\n");
682 return -1;
683 }
684
685 /*
686 * fill the buffer from head or tail, verify contents, test boundaries
687 * and clear the buffer
688 */
689
690 /* fill the buffer from tail */
691 for (i = 0; i < CMDLINE_TEST_BUFSIZE; i++)
692 cirbuf_add_tail_safe(&cb, 't');
693 /* verify that contents of the buffer are what they are supposed to be */
694 for (i = 0; i < sizeof(buf); i++) {
695 if (buf[i] != 't') {
696 printf("Error: wrong content in buffer!\n");
697 return -1;
698 }
699 }
700 /* try to add to a full buffer from tail */
701 if (cirbuf_add_tail_safe(&cb, 't') == 0) {
702 printf("Error: buffer should have been full!\n");
703 return -1;
704 }
705 /* try to add to a full buffer from head */
706 if (cirbuf_add_head_safe(&cb, 'h') == 0) {
707 printf("Error: buffer should have been full!\n");
708 return -1;
709 }
710 /* delete buffer from tail */
711 for(i = 0; i < CMDLINE_TEST_BUFSIZE; i++)
712 cirbuf_del_tail_safe(&cb);
713 /* try to delete from an empty buffer */
714 if (cirbuf_del_tail_safe(&cb) >= 0) {
715 printf("Error: buffer should have been empty!\n");
716 return -1;
717 }
718
719 /* fill the buffer from head */
720 for (i = 0; i < CMDLINE_TEST_BUFSIZE; i++)
721 cirbuf_add_head_safe(&cb, 'h');
722 /* verify that contents of the buffer are what they are supposed to be */
723 for (i = 0; i < sizeof(buf); i++) {
724 if (buf[i] != 'h') {
725 printf("Error: wrong content in buffer!\n");
726 return -1;
727 }
728 }
729 /* try to add to a full buffer from head */
730 if (cirbuf_add_head_safe(&cb,'h') >= 0) {
731 printf("Error: buffer should have been full!\n");
732 return -1;
733 }
734 /* try to add to a full buffer from tail */
735 if (cirbuf_add_tail_safe(&cb, 't') == 0) {
736 printf("Error: buffer should have been full!\n");
737 return -1;
738 }
739 /* delete buffer from head */
740 for(i = 0; i < CMDLINE_TEST_BUFSIZE; i++)
741 cirbuf_del_head_safe(&cb);
742 /* try to delete from an empty buffer */
743 if (cirbuf_del_head_safe(&cb) >= 0) {
744 printf("Error: buffer should have been empty!\n");
745 return -1;
746 }
747
748 /*
749 * fill the buffer from both head and tail, with alternating characters,
750 * verify contents and clear the buffer
751 */
752
753 /* fill half of buffer from tail */
754 for (i = 0; i < CMDLINE_TEST_BUFSIZE / 2; i++)
755 cirbuf_add_tail_safe(&cb, (char) (i % 2 ? 't' : 'T'));
756 /* fill other half of the buffer from head */
757 for (i = 0; i < CMDLINE_TEST_BUFSIZE / 2; i++)
758 cirbuf_add_head_safe(&cb, (char) (i % 2 ? 'H' : 'h')); /* added in reverse */
759
760 /* verify that contents of the buffer are what they are supposed to be */
761 for (i = 0; i < sizeof(buf) / 2; i++) {
762 if (buf[i] != (char) (i % 2 ? 't' : 'T')) {
763 printf("Error: wrong content in buffer at %u!\n", i);
764 return -1;
765 }
766 }
767 for (i = sizeof(buf) / 2; i < sizeof(buf); i++) {
768 if (buf[i] != (char) (i % 2 ? 'h' : 'H')) {
769 printf("Error: wrong content in buffer %u!\n", i);
770 return -1;
771 }
772 }
773
774 return 0;
775 }
776
777 /* test left alignment */
778 static int
test_cirbuf_align_left(void)779 test_cirbuf_align_left(void)
780 {
781 #define HALF_OFFSET CMDLINE_TEST_BUFSIZE / 2
782 #define SMALL_OFFSET HALF_OFFSET / 2
783 /* resulting buffer lengths for each of the test cases */
784 #define LEN1 HALF_OFFSET - SMALL_OFFSET - 1
785 #define LEN2 HALF_OFFSET + SMALL_OFFSET + 2
786 #define LEN3 HALF_OFFSET - SMALL_OFFSET
787 #define LEN4 HALF_OFFSET + SMALL_OFFSET - 1
788
789 struct cirbuf cb;
790 char buf[CMDLINE_TEST_BUFSIZE];
791 char tmp[CMDLINE_TEST_BUFSIZE];
792 unsigned i;
793
794 /*
795 * align left when start < end and start in left half
796 */
797
798 /*
799 * initialize circular buffer
800 */
801 memset(buf, 0, sizeof(buf));
802 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
803 printf("Error: failed to initialize circular buffer!\n");
804 return -1;
805 }
806
807 /* push end into left half */
808 for (i = 0; i < HALF_OFFSET - 1; i++)
809 cirbuf_add_tail_safe(&cb, 't');
810
811 /* push start into left half < end */
812 for (i = 0; i < SMALL_OFFSET; i++)
813 cirbuf_del_head_safe(&cb);
814
815 /* align */
816 if (cirbuf_align_left(&cb) < 0) {
817 printf("Error: alignment failed!\n");
818 return -1;
819 }
820
821 /* verify result */
822 if (cb.start != 0 || cb.len != LEN1 || cb.end != cb.len - 1) {
823 printf("Error: buffer alignment is wrong!\n");
824 return -1;
825 }
826
827 /*
828 * align left when start > end and start in left half
829 */
830
831 /*
832 * reinitialize circular buffer
833 */
834 memset(buf, 0, sizeof(buf));
835 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
836 printf("Error: failed to reinitialize circular buffer!\n");
837 return -1;
838 }
839
840 /* push start into left half */
841 for (i = 0; i < HALF_OFFSET + 2; i++)
842 cirbuf_add_head_safe(&cb, 'h');
843
844 /* push end into left half > start */
845 for (i = 0; i < SMALL_OFFSET; i++)
846 cirbuf_add_tail_safe(&cb, 't');
847
848 /* align */
849 if (cirbuf_align_left(&cb) < 0) {
850 printf("Error: alignment failed!\n");
851 return -1;
852 }
853
854 /* verify result */
855 if (cb.start != 0 || cb.len != LEN2 || cb.end != cb.len - 1) {
856 printf("Error: buffer alignment is wrong!");
857 return -1;
858 }
859
860 /*
861 * align left when start < end and start in right half
862 */
863
864 /*
865 * reinitialize circular buffer
866 */
867 memset(buf, 0, sizeof(buf));
868 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
869 printf("Error: failed to reinitialize circular buffer!\n");
870 return -1;
871 }
872
873 /* push start into the right half */
874 for (i = 0; i < HALF_OFFSET; i++)
875 cirbuf_add_head_safe(&cb, 'h');
876
877 /* push end into left half > start */
878 for (i = 0; i < SMALL_OFFSET; i++)
879 cirbuf_del_tail_safe(&cb);
880
881 /* align */
882 if (cirbuf_align_left(&cb) < 0) {
883 printf("Error: alignment failed!\n");
884 return -1;
885 }
886
887 /* verify result */
888 if (cb.start != 0 || cb.len != LEN3 || cb.end != cb.len - 1) {
889 printf("Error: buffer alignment is wrong!");
890 return -1;
891 }
892
893 /*
894 * align left when start > end and start in right half
895 */
896
897 /*
898 * reinitialize circular buffer
899 */
900 memset(buf, 0, sizeof(buf));
901 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
902 printf("Error: failed to reinitialize circular buffer!\n");
903 return -1;
904 }
905
906 /* push start into the right half */
907 for (i = 0; i < HALF_OFFSET - 1; i++)
908 cirbuf_add_head_safe(&cb, 'h');
909
910 /* push end into left half < start */
911 for (i = 0; i < SMALL_OFFSET; i++)
912 cirbuf_add_tail_safe(&cb, 't');
913
914 /* align */
915 if (cirbuf_align_left(&cb) < 0) {
916 printf("Error: alignment failed!\n");
917 return -1;
918 }
919
920 /* verify result */
921 if (cb.start != 0 || cb.len != LEN4 ||
922 cb.end != cb.len - 1) {
923 printf("Error: buffer alignment is wrong!");
924 return -1;
925 }
926
927 /*
928 * Verify that alignment doesn't corrupt data
929 */
930
931 /*
932 * reinitialize circular buffer
933 */
934 memset(buf, 0, sizeof(buf));
935 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
936 printf("Error: failed to reinitialize circular buffer!\n");
937 return -1;
938 }
939
940 /* add string to tail and head */
941 if (cirbuf_add_buf_head(&cb, CIRBUF_STR_HEAD,
942 sizeof(CIRBUF_STR_HEAD)) < 0 || cirbuf_add_buf_tail(&cb,
943 CIRBUF_STR_TAIL, sizeof(CIRBUF_STR_TAIL)) < 0) {
944 printf("Error: failed to add strings!\n");
945 return -1;
946 }
947
948 /* align */
949 if (cirbuf_align_left(&cb) < 0) {
950 printf("Error: alignment failed!\n");
951 return -1;
952 }
953
954 /* get string from head */
955 if (cirbuf_get_buf_head(&cb, tmp,
956 sizeof(CIRBUF_STR_HEAD) + sizeof(CIRBUF_STR_TAIL)) < 0) {
957 printf("Error: failed to read string from head!\n");
958 return -1;
959 }
960
961 /* verify string */
962 if (strncmp(tmp, CIRBUF_STR_HEAD "\0" CIRBUF_STR_TAIL,
963 sizeof(CIRBUF_STR_HEAD) + sizeof(CIRBUF_STR_TAIL)) != 0) {
964 printf("Error: strings mismatch!\n");
965 return -1;
966 }
967
968 /* reset tmp buffer */
969 memset(tmp, 0, sizeof(tmp));
970
971 /* get string from tail */
972 if (cirbuf_get_buf_tail(&cb, tmp,
973 sizeof(CIRBUF_STR_HEAD) + sizeof(CIRBUF_STR_TAIL)) < 0) {
974 printf("Error: failed to read string from head!\n");
975 return -1;
976 }
977
978 /* verify string */
979 if (strncmp(tmp, CIRBUF_STR_HEAD "\0" CIRBUF_STR_TAIL,
980 sizeof(CIRBUF_STR_HEAD) + sizeof(CIRBUF_STR_TAIL)) != 0) {
981 printf("Error: strings mismatch!\n");
982 return -1;
983 }
984
985 return 0;
986 }
987
988 /* test right alignment */
989 static int
test_cirbuf_align_right(void)990 test_cirbuf_align_right(void)
991 {
992 #define END_OFFSET CMDLINE_TEST_BUFSIZE - 1
993 struct cirbuf cb;
994 char buf[CMDLINE_TEST_BUFSIZE];
995 char tmp[CMDLINE_TEST_BUFSIZE];
996 unsigned i;
997
998
999 /*
1000 * align right when start < end and start in left half
1001 */
1002
1003 /*
1004 * initialize circular buffer
1005 */
1006 memset(buf, 0, sizeof(buf));
1007 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
1008 printf("Error: failed to initialize circular buffer!\n");
1009 return -1;
1010 }
1011
1012 /* push end into left half */
1013 for (i = 0; i < HALF_OFFSET - 1; i++)
1014 cirbuf_add_tail_safe(&cb, 't');
1015
1016 /* push start into left half < end */
1017 for (i = 0; i < SMALL_OFFSET; i++)
1018 cirbuf_del_head_safe(&cb);
1019
1020 /* align */
1021 cirbuf_align_right(&cb);
1022
1023 /* verify result */
1024 if (cb.start != END_OFFSET || cb.len != LEN1 || cb.end != cb.len - 2) {
1025 printf("Error: buffer alignment is wrong!\n");
1026 return -1;
1027 }
1028
1029 /*
1030 * align right when start > end and start in left half
1031 */
1032
1033 /*
1034 * reinitialize circular buffer
1035 */
1036 memset(buf, 0, sizeof(buf));
1037 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
1038 printf("Error: failed to reinitialize circular buffer!\n");
1039 return -1;
1040 }
1041
1042 /* push start into left half */
1043 for (i = 0; i < HALF_OFFSET + 2; i++)
1044 cirbuf_add_head_safe(&cb, 'h');
1045
1046 /* push end into left half > start */
1047 for (i = 0; i < SMALL_OFFSET; i++)
1048 cirbuf_add_tail_safe(&cb, 't');
1049
1050 /* align */
1051 cirbuf_align_right(&cb);
1052
1053 /* verify result */
1054 if (cb.start != END_OFFSET || cb.len != LEN2 || cb.end != cb.len - 2) {
1055 printf("Error: buffer alignment is wrong!");
1056 return -1;
1057 }
1058
1059 /*
1060 * align right when start < end and start in right half
1061 */
1062
1063 /*
1064 * reinitialize circular buffer
1065 */
1066 memset(buf, 0, sizeof(buf));
1067 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
1068 printf("Error: failed to reinitialize circular buffer!\n");
1069 return -1;
1070 }
1071
1072 /* push start into the right half */
1073 for (i = 0; i < HALF_OFFSET; i++)
1074 cirbuf_add_head_safe(&cb, 'h');
1075
1076 /* push end into left half > start */
1077 for (i = 0; i < SMALL_OFFSET; i++)
1078 cirbuf_del_tail_safe(&cb);
1079
1080 /* align */
1081 cirbuf_align_right(&cb);
1082
1083 /* verify result */
1084 if (cb.end != END_OFFSET || cb.len != LEN3 || cb.start != cb.end - cb.len + 1) {
1085 printf("Error: buffer alignment is wrong!");
1086 return -1;
1087 }
1088
1089 /*
1090 * align right when start > end and start in right half
1091 */
1092
1093 /*
1094 * reinitialize circular buffer
1095 */
1096 memset(buf, 0, sizeof(buf));
1097 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
1098 printf("Error: failed to reinitialize circular buffer!\n");
1099 return -1;
1100 }
1101
1102 /* push start into the right half */
1103 for (i = 0; i < HALF_OFFSET - 1; i++)
1104 cirbuf_add_head_safe(&cb, 'h');
1105
1106 /* push end into left half < start */
1107 for (i = 0; i < SMALL_OFFSET; i++)
1108 cirbuf_add_tail_safe(&cb, 't');
1109
1110 /* align */
1111 cirbuf_align_right(&cb);
1112
1113 /* verify result */
1114 if (cb.end != END_OFFSET || cb.len != LEN4 || cb.start != cb.end - cb.len + 1) {
1115 printf("Error: buffer alignment is wrong!");
1116 return -1;
1117 }
1118
1119 /*
1120 * Verify that alignment doesn't corrupt data
1121 */
1122
1123 /*
1124 * reinitialize circular buffer
1125 */
1126 memset(buf, 0, sizeof(buf));
1127 if (cirbuf_init(&cb, buf, 0, sizeof(buf)) < 0) {
1128 printf("Error: failed to reinitialize circular buffer!\n");
1129 return -1;
1130 }
1131
1132 /* add string to tail and head */
1133 if (cirbuf_add_buf_tail(&cb, CIRBUF_STR_TAIL,
1134 sizeof(CIRBUF_STR_TAIL)) < 0 || cirbuf_add_buf_head(&cb,
1135 CIRBUF_STR_HEAD, sizeof(CIRBUF_STR_HEAD)) < 0) {
1136 printf("Error: failed to add strings!\n");
1137 return -1;
1138 }
1139
1140 /* align */
1141 if (cirbuf_align_right(&cb) < 0) {
1142 printf("Error: alignment failed!\n");
1143 return -1;
1144 }
1145
1146 /* get string from head */
1147 if (cirbuf_get_buf_head(&cb, tmp,
1148 sizeof(CIRBUF_STR_HEAD) + sizeof(CIRBUF_STR_TAIL)) < 0) {
1149 printf("Error: failed to read string from head!\n");
1150 return -1;
1151 }
1152
1153 /* verify string */
1154 if (strncmp(tmp, CIRBUF_STR_HEAD "\0" CIRBUF_STR_TAIL,
1155 sizeof(CIRBUF_STR_HEAD) + sizeof(CIRBUF_STR_TAIL)) != 0) {
1156 printf("Error: strings mismatch!\n");
1157 return -1;
1158 }
1159
1160 /* reset tmp buffer */
1161 memset(tmp, 0, sizeof(tmp));
1162
1163 /* get string from tail */
1164 if (cirbuf_get_buf_tail(&cb, tmp,
1165 sizeof(CIRBUF_STR_HEAD) + sizeof(CIRBUF_STR_TAIL)) < 0) {
1166 printf("Error: failed to read string from head!\n");
1167 return -1;
1168 }
1169 /* verify string */
1170 if (strncmp(tmp, CIRBUF_STR_HEAD "\0" CIRBUF_STR_TAIL,
1171 sizeof(CIRBUF_STR_HEAD) + sizeof(CIRBUF_STR_TAIL)) != 0) {
1172 printf("Error: strings mismatch!\n");
1173 return -1;
1174 }
1175
1176 return 0;
1177 }
1178
1179 /* call functions with invalid parameters */
1180 int
test_cirbuf_invalid_param(void)1181 test_cirbuf_invalid_param(void)
1182 {
1183 struct cirbuf cb;
1184 char buf[CMDLINE_TEST_BUFSIZE];
1185
1186 /* null cirbuf */
1187 if (cirbuf_init(0, buf, 0, sizeof(buf)) == 0)
1188 return -1;
1189 /* null buffer */
1190 if (cirbuf_init(&cb, 0, 0, sizeof(buf)) == 0)
1191 return -1;
1192 /* null cirbuf */
1193 if (cirbuf_add_head_safe(0, 'h') == 0)
1194 return -1;
1195 if (cirbuf_add_tail_safe(0, 't') == 0)
1196 return -1;
1197 if (cirbuf_del_head_safe(0) == 0)
1198 return -1;
1199 if (cirbuf_del_tail_safe(0) == 0)
1200 return -1;
1201 /* null buffer */
1202 if (cirbuf_add_buf_head(&cb, 0, 0) == 0)
1203 return -1;
1204 if (cirbuf_add_buf_tail(&cb, 0, 0) == 0)
1205 return -1;
1206 /* null cirbuf */
1207 if (cirbuf_add_buf_head(0, buf, 0) == 0)
1208 return -1;
1209 if (cirbuf_add_buf_tail(0, buf, 0) == 0)
1210 return -1;
1211 /* null size */
1212 if (cirbuf_add_buf_head(&cb, buf, 0) == 0)
1213 return -1;
1214 if (cirbuf_add_buf_tail(&cb, buf, 0) == 0)
1215 return -1;
1216 /* null cirbuf */
1217 if (cirbuf_del_buf_head(0, 0) == 0)
1218 return -1;
1219 if (cirbuf_del_buf_tail(0, 0) == 0)
1220 return -1;
1221 /* null size */
1222 if (cirbuf_del_buf_head(&cb, 0) == 0)
1223 return -1;
1224 if (cirbuf_del_buf_tail(&cb, 0) == 0)
1225 return -1;
1226 /* null cirbuf */
1227 if (cirbuf_get_buf_head(0, 0, 0) == 0)
1228 return -1;
1229 if (cirbuf_get_buf_tail(0, 0, 0) == 0)
1230 return -1;
1231 /* null buffer */
1232 if (cirbuf_get_buf_head(&cb, 0, 0) == 0)
1233 return -1;
1234 if (cirbuf_get_buf_tail(&cb, 0, 0) == 0)
1235 return -1;
1236 /* null size, this is valid but should return 0 */
1237 if (cirbuf_get_buf_head(&cb, buf, 0) != 0)
1238 return -1;
1239 if (cirbuf_get_buf_tail(&cb, buf, 0) != 0)
1240 return -1;
1241 /* null cirbuf */
1242 if (cirbuf_align_left(0) == 0)
1243 return -1;
1244 if (cirbuf_align_right(0) == 0)
1245 return -1;
1246
1247 return 0;
1248 }
1249
1250 /* test cmdline_cirbuf char functions */
1251 int
test_cirbuf_char(void)1252 test_cirbuf_char(void)
1253 {
1254 int ret;
1255
1256 ret = test_cirbuf_char_add_del();
1257 if (ret < 0)
1258 return -1;
1259
1260 ret = test_cirbuf_char_fill();
1261 if (ret < 0)
1262 return -1;
1263
1264 return 0;
1265 }
1266
1267 /* test cmdline_cirbuf string functions */
1268 int
test_cirbuf_string(void)1269 test_cirbuf_string(void)
1270 {
1271 if (test_cirbuf_string_add_del() < 0)
1272 return -1;
1273
1274 if (test_cirbuf_string_add_del_reverse() < 0)
1275 return -1;
1276
1277 if (test_cirbuf_string_add_boundaries() < 0)
1278 return -1;
1279
1280 if (test_cirbuf_string_get_del_boundaries() < 0)
1281 return -1;
1282
1283 if (test_cirbuf_string_get_del_partial() < 0)
1284 return -1;
1285
1286 if (test_cirbuf_string_misc() < 0)
1287 return -1;
1288
1289 return 0;
1290 }
1291
1292 /* test cmdline_cirbuf align functions */
1293 int
test_cirbuf_align(void)1294 test_cirbuf_align(void)
1295 {
1296 if (test_cirbuf_align_left() < 0)
1297 return -1;
1298 if (test_cirbuf_align_right() < 0)
1299 return -1;
1300 return 0;
1301 }
1302