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