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