ceph/src/spdk/dpdk/test/test/test_cmdline_cirbuf.c

   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
  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
 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
 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
 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
 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
 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
 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
 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
 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
 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
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
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
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
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 }