libsheepyTest.c (467258B)
1 #include <stdlib.h> 2 #include <stdio.h> 3 #include <check.h> 4 5 //START MEM TEST ANCHOR 6 7 #include "libsheepy.h" 8 9 // TODO redirect stderr 10 11 START_TEST(cleanUpCharFreeT) 12 13 cleanCharP(s) = strdup("test"); 14 15 END_TEST 16 17 18 START_TEST(cleanUpListFreeT) 19 20 cleanListP(l) = listCreateS("a","b"); 21 22 END_TEST 23 24 25 START_TEST(cleanUpFileFreeT) 26 27 cleanFileP(f) = fopen("renameTest.null", "r"); 28 29 END_TEST 30 31 32 START_TEST(cleanUpCharFreeNullT) 33 34 cleanCharP(s) = null; 35 36 END_TEST 37 38 39 START_TEST(cleanUpListFreeNullT) 40 41 cleanListP(l) = null; 42 43 END_TEST 44 45 46 START_TEST(cleanUpFileFreeNullT) 47 48 cleanFileP(f) = null; 49 50 END_TEST 51 52 53 START_TEST(shStopwatchT) 54 55 stopwatchStart; 56 stopwatchLog; 57 58 END_TEST 59 60 61 START_TEST(setLogSymbolsT) 62 63 int m; 64 65 // set mode utf8 66 setLogSymbols(LOG_UTF8); 67 m = getLogSymbols(); 68 ck_assert_int_eq(m, LOG_UTF8); 69 70 // set invalid mode 71 setLogSymbols(LOG_INVALID_MODE); 72 m = getLogSymbols(); 73 ck_assert_int_eq(m, LOG_INVALID_MODE); 74 75 setLogSymbols(LOG_UTF8); 76 setLogSymbols(LOG_INVALID_MODE+10); 77 m = getLogSymbols(); 78 ck_assert_int_eq(m, LOG_INVALID_MODE); 79 80 END_TEST 81 82 83 START_TEST(setMaxLogLevelT) 84 85 int lv; 86 87 // set max level 88 setMaxLogLevel(LOG_DISABLE); 89 lv = getMaxLogLevel(); 90 ck_assert_int_eq(lv, LOG_DISABLE); 91 92 // set invalid max level (all levels) 93 setMaxLogLevel(LOG_INVALID); 94 lv = getMaxLogLevel(); 95 ck_assert_int_eq(lv, LOG_MAX_LEVEL); 96 97 98 END_TEST 99 100 101 START_TEST(setLogShortPathT) 102 103 bool sp; 104 105 // set long path 106 setLogShortPath(no); 107 sp = getLogShortPath(); 108 ck_assert(!sp); 109 110 // set short path 111 setLogShortPath(yes); 112 sp = getLogShortPath(); 113 ck_assert(sp); 114 115 END_TEST 116 117 118 START_TEST(setLogStdoutT) 119 120 bool std; 121 122 // set long path 123 setLogStdout(no); 124 std = getLogStdout(); 125 ck_assert(!std); 126 127 // set short path 128 setLogStdout(yes); 129 std = getLogStdout(); 130 ck_assert(std); 131 132 END_TEST 133 134 135 START_TEST(openProgLogFileT) 136 137 const char *pn; 138 bool r; 139 140 // check that prog name is not set 141 pn = getProgName(); 142 ck_assert_ptr_eq(pn, null); 143 r = openProgLogFile(); 144 ck_assert(!r); 145 146 // set progname and open file 147 r = setProgName("openProgLogFileT"); 148 ck_assert(r); 149 r = openProgLogFile(); 150 ck_assert(r); 151 152 freeProgName(); 153 closeLogFiles(); 154 int R = rmAll("openProgLogFileT.log"); 155 ck_assert_int_ne(R, 0); 156 157 END_TEST 158 159 160 START_TEST(setLogFileT) 161 162 FILE *f; 163 164 // open log file 165 f = setLogFile("test.log"); 166 ck_assert_ptr_ne(f, NULL); 167 168 // read only location 169 f = setLogFile("/test.log"); 170 ck_assert_ptr_eq(f, NULL); 171 172 // open all log slots 173 f = setLogFile("test1.log"); 174 ck_assert_ptr_ne(f, NULL); 175 176 f = setLogFile("test2.log"); 177 ck_assert_ptr_ne(f, NULL); 178 179 f = setLogFile("test3.log"); 180 ck_assert_ptr_ne(f, NULL); 181 182 f = setLogFile("test4.log"); 183 ck_assert_ptr_ne(f, NULL); 184 185 f = setLogFile("test5.log"); 186 ck_assert_ptr_ne(f, NULL); 187 188 f = setLogFile("test6.log"); 189 ck_assert_ptr_ne(f, NULL); 190 191 f = setLogFile("test7.log"); 192 ck_assert_ptr_ne(f, NULL); 193 194 f = setLogFile("test8.log"); 195 ck_assert_ptr_ne(f, NULL); 196 197 f = setLogFile("test9.log"); 198 ck_assert_ptr_ne(f, NULL); 199 200 f = setLogFile("test10.log"); 201 ck_assert_ptr_ne(f, NULL); 202 203 f = setLogFile("test11.log"); 204 ck_assert_ptr_ne(f, NULL); 205 206 f = setLogFile("test12.log"); 207 ck_assert_ptr_ne(f, NULL); 208 209 f = setLogFile("test13.log"); 210 ck_assert_ptr_ne(f, NULL); 211 212 f = setLogFile("test14.log"); 213 ck_assert_ptr_ne(f, NULL); 214 215 f = setLogFile("test15.log"); 216 ck_assert_ptr_eq(f, NULL); 217 218 closeLogFiles(); 219 int R; 220 R = rmAll("test1.log"); 221 ck_assert_int_ne(R, 0); 222 R = rmAll("test2.log"); 223 ck_assert_int_ne(R, 0); 224 R = rmAll("test3.log"); 225 ck_assert_int_ne(R, 0); 226 R = rmAll("test4.log"); 227 ck_assert_int_ne(R, 0); 228 R = rmAll("test5.log"); 229 ck_assert_int_ne(R, 0); 230 R = rmAll("test6.log"); 231 ck_assert_int_ne(R, 0); 232 R = rmAll("test7.log"); 233 ck_assert_int_ne(R, 0); 234 R = rmAll("test8.log"); 235 ck_assert_int_ne(R, 0); 236 R = rmAll("test9.log"); 237 ck_assert_int_ne(R, 0); 238 R = rmAll("test10.log"); 239 ck_assert_int_ne(R, 0); 240 R = rmAll("test11.log"); 241 ck_assert_int_ne(R, 0); 242 R = rmAll("test12.log"); 243 ck_assert_int_ne(R, 0); 244 R = rmAll("test13.log"); 245 ck_assert_int_ne(R, 0); 246 R = rmAll("test14.log"); 247 ck_assert_int_ne(R, 0); 248 249 // NULL 250 ck_assert_ptr_eq(setLogFile(NULL), NULL); 251 252 END_TEST 253 254 255 START_TEST(closeLogFilesT) 256 257 closeLogFiles(); 258 closeLogFiles(); 259 260 END_TEST 261 262 263 START_TEST(getLogModeT) 264 265 ck_assert_int_eq(getLogMode(), LOG_DATE); 266 267 END_TEST 268 269 270 START_TEST(setLogModeT) 271 272 // set mode 273 setLogMode(LOG_CONCISE); 274 ck_assert_int_eq(getLogMode(), LOG_CONCISE); 275 276 setLogMode(LOG_DATE); 277 ck_assert_int_eq(getLogMode(), LOG_DATE); 278 279 setLogMode(LOG_FUNC); 280 ck_assert_int_eq(getLogMode(), LOG_FUNC); 281 282 setLogMode(LOG_PROG); 283 ck_assert_int_eq(getLogMode(), LOG_PROG); 284 285 setLogMode(LOG_PROGNDATE); 286 ck_assert_int_eq(getLogMode(), LOG_PROGNDATE); 287 288 setLogMode(LOG_VOID); 289 ck_assert_int_eq(getLogMode(), LOG_VOID); 290 291 setLogMode(LOG_UTF8); 292 ck_assert_int_eq(getLogMode(), LOG_UTF8); 293 294 setLogMode(LOG_VERBOSE); 295 ck_assert_int_eq(getLogMode(), LOG_VERBOSE); 296 297 // set invalid value 298 setLogMode(LOG_CONCISE+10); 299 ck_assert_int_eq(getLogMode(), LOG_VERBOSE); 300 301 // invalid log mode 302 setLogMode(-1); 303 setLogMode(LOG_INVALID_MODE); 304 305 END_TEST 306 307 308 START_TEST(_pLogT) 309 310 setLogFile("test.log"); 311 312 // default log mode 313 puts("Default mode"); 314 pLog(LOG_EMERGENCY, "pLog test"); 315 pLog(LOG_ALERT, "pLog test"); 316 pLog(LOG_CRITICAL, "pLog test"); 317 pLog(LOG_ERROR, "pLog test"); 318 pLog(LOG_WARNING, "pLog test"); 319 pLog(LOG_NOTICE, "pLog test"); 320 pLog(LOG_PASS, "pLog test"); 321 pLog(LOG_INFO, "pLog test\nmultiline"); 322 pLog(LOG_DEBUG, "pLog test"); 323 // invalid log level 324 pLog(LOG_INFO+20, "pLog test"); 325 pLog(-1, "pLog test"); 326 327 // concise mode 328 puts("LOG_CONCISE mode"); 329 setLogMode(LOG_CONCISE); 330 pLog(LOG_EMERGENCY, "pLog test"); 331 pLog(LOG_ALERT, "pLog test"); 332 pLog(LOG_CRITICAL, "pLog test"); 333 pLog(LOG_ERROR, "pLog test"); 334 pLog(LOG_WARNING, "pLog test"); 335 pLog(LOG_NOTICE, "pLog test"); 336 pLog(LOG_PASS, "pLog test"); 337 pLog(LOG_INFO, "pLog test"); 338 pLog(LOG_DEBUG, "pLog test"); 339 // invalid log level 340 pLog(LOG_INFO+20, "pLog test"); 341 342 // verbose mode 343 puts("LOG_VERBOSE mode"); 344 setLogMode(LOG_VERBOSE); 345 pLog(LOG_EMERGENCY, "pLog test"); 346 pLog(LOG_ALERT, "pLog test"); 347 pLog(LOG_CRITICAL, "pLog test"); 348 pLog(LOG_ERROR, "pLog test"); 349 pLog(LOG_WARNING, "pLog test"); 350 pLog(LOG_NOTICE, "pLog test"); 351 pLog(LOG_PASS, "pLog test"); 352 pLog(LOG_INFO, "pLog test"); 353 pLog(LOG_DEBUG, "pLog test"); 354 // invalid log level 355 pLog(LOG_INFO+20, "pLog test"); 356 357 // date mode 358 puts("LOG_DATE mode"); 359 setLogMode(LOG_DATE); 360 pLog(LOG_EMERGENCY, "pLog test"); 361 pLog(LOG_ALERT, "pLog test"); 362 pLog(LOG_CRITICAL, "pLog test"); 363 pLog(LOG_ERROR, "pLog test"); 364 pLog(LOG_WARNING, "pLog test"); 365 pLog(LOG_NOTICE, "pLog test"); 366 pLog(LOG_PASS, "pLog test"); 367 pLog(LOG_INFO, "pLog test"); 368 pLog(LOG_DEBUG, "pLog test"); 369 // invalid log level 370 pLog(LOG_INFO+20, "pLog test"); 371 372 // function mode 373 puts("LOG_FUNC mode"); 374 setLogMode(LOG_FUNC); 375 pLog(LOG_EMERGENCY, "pLog test"); 376 pLog(LOG_ALERT, "pLog test"); 377 pLog(LOG_CRITICAL, "pLog test"); 378 pLog(LOG_ERROR, "pLog test"); 379 pLog(LOG_WARNING, "pLog test"); 380 pLog(LOG_NOTICE, "pLog test"); 381 pLog(LOG_PASS, "pLog test"); 382 pLog(LOG_INFO, "pLog test"); 383 pLog(LOG_DEBUG, "pLog test"); 384 // invalid log level 385 pLog(LOG_INFO+20, "pLog test"); 386 387 // program name mode 388 puts("LOG_PROG mode"); 389 setLogMode(LOG_PROG); 390 pLog(LOG_EMERGENCY, "pLog test"); 391 pLog(LOG_ALERT, "pLog test"); 392 pLog(LOG_CRITICAL, "pLog test"); 393 pLog(LOG_ERROR, "pLog test"); 394 pLog(LOG_WARNING, "pLog test"); 395 pLog(LOG_NOTICE, "pLog test"); 396 pLog(LOG_PASS, "pLog test"); 397 pLog(LOG_INFO, "pLog test"); 398 pLog(LOG_DEBUG, "pLog test"); 399 // invalid log level 400 pLog(LOG_INFO+20, "pLog test"); 401 402 // program name and date mode 403 puts("LOG_PROGNDATE mode"); 404 setLogMode(LOG_PROGNDATE); 405 pLog(LOG_EMERGENCY, "pLog test"); 406 pLog(LOG_ALERT, "pLog test"); 407 pLog(LOG_CRITICAL, "pLog test"); 408 pLog(LOG_ERROR, "pLog test"); 409 pLog(LOG_WARNING, "pLog test"); 410 pLog(LOG_NOTICE, "pLog test"); 411 pLog(LOG_PASS, "pLog test"); 412 pLog(LOG_INFO, "pLog test"); 413 pLog(LOG_DEBUG, "pLog test"); 414 // invalid log level 415 pLog(LOG_INFO+20, "pLog test"); 416 417 // void mode 418 puts("LOG_VOID mode"); 419 setLogMode(LOG_VOID); 420 pLog(LOG_EMERGENCY, "pLog test"); 421 pLog(LOG_ALERT, "pLog test"); 422 pLog(LOG_CRITICAL, "pLog test"); 423 pLog(LOG_ERROR, "pLog test"); 424 pLog(LOG_WARNING, "pLog test"); 425 pLog(LOG_NOTICE, "pLog test"); 426 pLog(LOG_PASS, "pLog test"); 427 pLog(LOG_INFO, "pLog test"); 428 pLog(LOG_DEBUG, "pLog test"); 429 // invalid log level 430 pLog(LOG_INFO+20, "pLog test"); 431 432 // void mode 433 puts("LOG_UTF8 mode"); 434 setLogMode(LOG_UTF8); 435 pLog(LOG_EMERGENCY, "pLog test"); 436 pLog(LOG_ALERT, "pLog test"); 437 pLog(LOG_CRITICAL, "pLog test"); 438 pLog(LOG_ERROR, "pLog test"); 439 pLog(LOG_WARNING, "pLog test"); 440 pLog(LOG_NOTICE, "pLog test"); 441 pLog(LOG_PASS, "pLog test"); 442 pLog(LOG_INFO, "pLog test"); 443 pLog(LOG_DEBUG, "pLog test"); 444 // invalid log level 445 pLog(LOG_INFO+20, "pLog test"); 446 447 closeLogFiles(); 448 int R = rmAll("test.log"); 449 ck_assert_int_ne(R, 0); 450 451 END_TEST 452 453 454 START_TEST(setProgNameT) 455 456 bool r; 457 458 // set default prog name (null since init is not called yet) 459 setDefaultProgName(); 460 ck_assert_ptr_eq(getProgName(), null); 461 462 // set prog name 463 r = setProgName("name"); 464 ck_assert(r); 465 466 // set null prog name 467 r = setProgName(NULL); 468 ck_assert(!r); 469 ck_assert_ptr_ne(getProgName(), null); 470 ck_assert_str_eq(getProgName(), "name"); 471 472 freeProgName(); 473 474 // set prog name and then set default prog name 475 // no memory leak should happen 476 r = setProgName("name"); 477 ck_assert(r); 478 setDefaultProgName(); 479 480 END_TEST 481 482 483 void initTest(void) { } 484 485 486 START_TEST(initLibsheepyFT) 487 488 // regular program 489 initLibsheepy("test"); 490 491 // program compiled with sheepy with init function 492 initLibsheepyF("/.sheepy/build/test", initTest); 493 494 END_TEST 495 496 497 START_TEST(setStackLimitT) 498 499 int r; 500 i64 stackSize; 501 502 // set bigger stack 503 r = setStackLimit(16 * 1024 * 1024); 504 ck_assert(r!=0); 505 stackSize = getStackLimit(); 506 ck_assert_int_eq(stackSize, 16 * 1024 * 1024); 507 508 // set unlimited stack 509 r = setStackLimit(-1); 510 ck_assert(r!=0); 511 512 END_TEST 513 514 515 START_TEST(getProgPathT) 516 517 const char *s; 518 519 // getProgPath stored prog path 520 s = getProgPath(); 521 ck_assert_ptr_ne(s, NULL); 522 523 initLibsheepy("test"); 524 525 // getProgPath stored prog path 526 s = getProgPath(); 527 ck_assert_str_eq(s, "test"); 528 529 // program compiled with sheepy with init function 530 initLibsheepyF("/.sheepy/build/test", initTest); 531 532 // getProgPath stored prog path 533 s = getProgPath(); 534 ck_assert_str_eq(s, "/test"); 535 536 END_TEST 537 538 539 START_TEST(getRealProgPathT) 540 541 const char *s; 542 543 // getProgPath real prog path 544 s = getProgPath(); 545 ck_assert_ptr_ne(s, NULL); 546 547 initLibsheepy("test"); 548 549 s = getRealProgPath(); 550 ck_assert_ptr_ne(s, NULL); 551 freeRealProgPath(); 552 553 END_TEST 554 555 556 START_TEST(systemNFreeFT) 557 558 int r; 559 560 // normal command 561 r = systemNFree(strdup("echo TEST")); 562 ck_assert_int_eq(r, 0); 563 564 // NULL 565 r = systemNFree(NULL); 566 ck_assert_int_ne(r, 0); 567 568 END_TEST 569 570 571 START_TEST(getModificationTimeT) 572 573 // get time 574 ck_assert_int_ne(getModificationTime("libsheepy.c"), 0); 575 576 // missing file 577 ck_assert_int_eq(getModificationTime("nonexistingfile"), 0); 578 579 // NULL 580 ck_assert_int_eq(getModificationTime(NULL), 0); 581 582 END_TEST 583 584 585 START_TEST(setModificationTimeT) 586 587 time_t t; 588 589 // set time 590 t = getModificationTime("chmodTest.null"); 591 ck_assert_int_eq(setModificationTime("chmodTest.null", t), 1); 592 593 // non existing file 594 ck_assert_int_eq(setModificationTime("/chmodTest.null", t), 0); 595 596 // NULL 597 ck_assert_int_eq(setModificationTime(NULL, t), 0); 598 599 END_TEST 600 601 602 START_TEST(isReadableT) 603 604 bool r; 605 606 // check readable file 607 r = isReadable("sizeTest.null"); 608 ck_assert(r); 609 610 // non readable file 611 r = isReadable("writeOnlyText.null"); 612 ck_assert(!r); 613 614 // non existing file 615 r = isReadable("random.null"); 616 ck_assert(!r); 617 618 // null 619 r = isReadable(null); 620 ck_assert(!r); 621 622 END_TEST 623 624 625 START_TEST(isWritableT) 626 627 bool r; 628 629 // check writable file 630 r = isWritable("writeOnlyText.null"); 631 ck_assert(r); 632 633 // non writable file 634 r = isWritable("sizeTest.null"); 635 ck_assert(!r); 636 637 // non existing file 638 r = isWritable("random.null"); 639 ck_assert(!r); 640 641 // null 642 r = isWritable(null); 643 ck_assert(!r); 644 645 END_TEST 646 647 648 START_TEST(isExecutableT) 649 650 bool r; 651 652 // check executable file 653 r = isExecutable("runCuTest.sh"); 654 ck_assert(r); 655 656 // non executable file 657 r = isExecutable("sizeTest.null"); 658 ck_assert(!r); 659 660 // non existing file 661 r = isExecutable("random.null"); 662 ck_assert(!r); 663 664 // null 665 r = isExecutable(null); 666 ck_assert(!r); 667 668 END_TEST 669 670 671 START_TEST(equalModificationTimesT) 672 673 // equal time 674 ck_assert(equalModificationTimes("chmodTest.null", "chmodTest.null")); 675 676 // not equal 677 ck_assert(!equalModificationTimes("chmodTest.null", "libsheepy.c")); 678 679 // non existing 680 ck_assert(!equalModificationTimes("/chmodTest.null", "libsheepy.c")); 681 ck_assert(!equalModificationTimes("chmodTest.null", "/libsheepy.c")); 682 683 // NULL 684 ck_assert(!equalModificationTimes(NULL, "libsheepy.c")); 685 ck_assert(!equalModificationTimes("chmodTest.null", NULL)); 686 687 END_TEST 688 689 690 START_TEST(getCurrentUnixTimeT) 691 692 time_t t = getCurrentUnixTime(); 693 ck_assert_int_ne(t, 0); 694 695 END_TEST 696 697 698 START_TEST(strToUnixTimeT) 699 700 time_t t; 701 702 // convert 703 t = strToUnixTime("2020-05-15 13:59:58", "%Y-%m-%d %H:%M"); 704 ck_assert_int_ne(t, -1); 705 // depends on local settings - ck_assert_int_eq(t, 1589547540); 706 707 708 // bad date or format 709 t = strToUnixTime("", "%Y-%m-%d %H:%M"); 710 ck_assert_int_eq(t, -1); 711 712 // null date 713 t = strToUnixTime(null, "%Y-%m-%d %H:%M"); 714 ck_assert_int_eq(t, -1); 715 716 // null format 717 t = strToUnixTime("", null); 718 ck_assert_int_eq(t, -1); 719 720 END_TEST 721 722 723 START_TEST(timeToST) 724 725 char *s; 726 727 s = timeToS(0); 728 ck_assert_str_eq(s, "Thu Jan 1 01:00:00 1970"); 729 free(s); 730 731 // bTimeToS 732 char b[80] = init0Var; 733 s = bTimeToS(b, 0); 734 ck_assert_ptr_ne(s, null); 735 ck_assert_str_eq(b, "Thu Jan 1 01:00:00 1970"); 736 737 // bLTimeToS 738 char bL[50] = init0Var; 739 s = bLTimeToS(bL, sizeof(bL), 0); 740 ck_assert_ptr_ne(s, null); 741 ck_assert_str_eq(bL, "Thu Jan 1 01:00:00 1970"); 742 743 // null parameter 744 s = bTimeToS(null, 0); 745 ck_assert_ptr_eq(s, null); 746 s = bLTimeToS(null, sizeof(bL), 0); 747 ck_assert_ptr_eq(s, null); 748 749 END_TEST 750 751 752 START_TEST(timeToYMDST) 753 754 char *s; 755 756 s = timeToYMDS(0); 757 ck_assert_str_eq(s, "1970-01-01 01:00:00"); 758 free(s); 759 760 // bTimeToYMDS 761 char b[80] = init0Var; 762 s = bTimeToYMDS(b, 0); 763 ck_assert_ptr_ne(s, null); 764 ck_assert_str_eq(b, "1970-01-01 01:00:00"); 765 766 // bLTimeToYMDS 767 char bL[50] = init0Var; 768 s = bLTimeToYMDS(bL, sizeof(bL), 0); 769 ck_assert_ptr_ne(s, null); 770 ck_assert_str_eq(bL, "1970-01-01 01:00:00"); 771 772 // null parameter 773 s = bTimeToYMDS(null, 0); 774 ck_assert_ptr_eq(s, null); 775 s = bLTimeToYMDS(null, sizeof(bL), 0); 776 ck_assert_ptr_eq(s, null); 777 778 END_TEST 779 780 781 START_TEST(getCurrentDateT) 782 783 char *s; 784 785 s = getCurrentDate(); 786 ck_assert_ptr_ne(s, null); 787 free(s); 788 789 char b[80] = init0Var; 790 s = bGetCurrentDate(b); 791 ck_assert_ptr_ne(s, null); 792 793 char bL[50] = init0Var; 794 s = bLGetCurrentDate(bL, sizeof(bL)); 795 ck_assert_ptr_ne(s, null); 796 797 // null parameter 798 s = bGetCurrentDate(null); 799 ck_assert_ptr_eq(s, null); 800 s = bLGetCurrentDate(null, sizeof(bL)); 801 ck_assert_ptr_eq(s, null); 802 803 END_TEST 804 805 806 START_TEST(getCurrentDateYMDT) 807 808 char *s; 809 810 s = getCurrentDateYMD(); 811 ck_assert_ptr_ne(s, null); 812 free(s); 813 814 char b[80] = init0Var; 815 s = bGetCurrentDateYMD(b); 816 ck_assert_ptr_ne(s, null); 817 818 char bL[50] = init0Var; 819 s = bLGetCurrentDateYMD(bL, sizeof(bL)); 820 ck_assert_ptr_ne(s, null); 821 822 // null parameter 823 s = bGetCurrentDateYMD(null); 824 ck_assert_ptr_eq(s, null); 825 s = bLGetCurrentDateYMD(null, sizeof(bL)); 826 ck_assert_ptr_eq(s, null); 827 828 END_TEST 829 830 831 START_TEST(shDirnameT) 832 833 char *s; 834 835 // path 836 s = shDirname("release/libsheepy.a"); 837 ck_assert_str_eq(s, "release"); 838 free(s); 839 840 // one item path 841 s = shDirname("sheepy.lib"); 842 ck_assert_str_eq(s, "./"); 843 free(s); 844 845 // empty 846 s = shDirname(" "); 847 ck_assert_str_eq(s, "./"); 848 free(s); 849 850 // NULL 851 ck_assert_ptr_eq(shDirname(NULL), NULL); 852 853 END_TEST 854 855 856 START_TEST(bDirnameT) 857 858 char s[100] = "release/libsheepy.a"; 859 char *r = null; 860 861 // path 862 r = bDirname(s); 863 ck_assert_ptr_eq(r, s); 864 ck_assert_str_eq(s, "release"); 865 866 // one item path 867 r = strCpy(s, "sheepy.lib"); 868 ck_assert_ptr_eq(r, s); 869 r = bDirname(s); 870 ck_assert_ptr_eq(r, s); 871 ck_assert_str_eq(s, "./"); 872 873 // empty 874 r = strCpy(s, " "); 875 ck_assert_ptr_eq(r, s); 876 r = bDirname(s); 877 ck_assert_ptr_eq(r, s); 878 ck_assert_str_eq(s, "./"); 879 880 // NULL 881 r = bDirname(NULL); 882 ck_assert_ptr_eq(r, null); 883 884 END_TEST 885 886 887 START_TEST(bLDirnameT) 888 889 char s[100] = "release/libsheepy.a"; 890 char *r = null; 891 892 // path 893 r = bLDirname(s, sizeof s); 894 ck_assert_ptr_eq(r, s); 895 ck_assert_str_eq(s, "release"); 896 897 // buffer shorter than path 898 strcpy(s, "release/anotherdir/libsheepy.a"); 899 r = bLDirname(s, 10); 900 ck_assert_ptr_eq(r, s); 901 ck_assert_str_eq(s, "release"); 902 strcpy(s, "release/anotherdir/libsheepy.a"); 903 r = bLDirname(s, 9); 904 ck_assert_ptr_eq(r, s); 905 ck_assert_str_eq(s, "release/"); 906 907 // one item path 908 r = strCpy(s, "sheepy.lib"); 909 ck_assert_ptr_eq(r, s); 910 r = bLDirname(s, sizeof s); 911 ck_assert_ptr_eq(r, s); 912 ck_assert_str_eq(s, "./"); 913 914 // empty 915 r = strCpy(s, " "); 916 ck_assert_ptr_eq(r, s); 917 r = bLDirname(s, sizeof s); 918 ck_assert_ptr_eq(r, s); 919 ck_assert_str_eq(s, "./"); 920 921 // size 0 - no change in s 922 r = bLDirname(s, 0); 923 ck_assert_ptr_eq(r, null); 924 ck_assert_str_eq(s, "./"); 925 926 // NULL 927 r = bLDirname(NULL, 0); 928 ck_assert_ptr_eq(r, null); 929 930 END_TEST 931 932 933 START_TEST(expandHomeT) 934 935 // no ~/ 936 char *s; 937 s = expandHome("sheepy"); 938 ck_assert_str_eq(s, "sheepy"); 939 free(s); 940 // NULL path 941 ck_assert_ptr_eq(expandHome(NULL), NULL); 942 943 END_TEST 944 945 946 START_TEST(iExpandHomeT) 947 948 // no ~/ 949 char *s = strdup("sheepy"); 950 char *r = null; 951 952 r = iExpandHome(&s); 953 ck_assert_ptr_eq(r, s); 954 ck_assert_str_eq(s, "sheepy"); 955 free(s); 956 // NULL path 957 s = NULL; 958 r = iExpandHome(&s); 959 ck_assert_ptr_eq(r, s); 960 ck_assert_ptr_eq(s, NULL); 961 // NULL var 962 r = iExpandHome(NULL); 963 ck_assert_ptr_eq(r, null); 964 965 END_TEST 966 967 968 START_TEST(bExpandHomeT) 969 970 // no ~/ 971 char s[100] = "sheepy"; 972 char *r = null; 973 974 r = bExpandHome(s); 975 ck_assert_ptr_eq(r, s); 976 ck_assert_str_eq(s, "sheepy"); 977 // NULL 978 r = bExpandHome(NULL); 979 ck_assert_ptr_eq(r, null); 980 981 END_TEST 982 983 984 START_TEST(bLExpandHomeT) 985 986 // no ~/ 987 char s[100] = "sheepy"; 988 char *r = null; 989 990 r = bLExpandHome(s, sizeof s); 991 ck_assert_ptr_eq(r, s); 992 ck_assert_str_eq(s, "sheepy"); 993 // shorter buffer size 994 r = bLExpandHome(s, 3); 995 ck_assert_ptr_eq(r, s); 996 ck_assert_str_eq(s, "sh"); 997 // size 0 998 r = bLExpandHome(s, 0); 999 ck_assert_ptr_eq(r, s); 1000 ck_assert_str_eq(s, "sh"); 1001 // NULL 1002 r = bLExpandHome(NULL, sizeof s); 1003 ck_assert_ptr_eq(r, null); 1004 1005 END_TEST 1006 1007 1008 START_TEST(normalizePathT) 1009 1010 // test 1011 char *s; 1012 s = normalizePath("test/.././file.txt"); 1013 ck_assert_str_eq(s, "file.txt"); 1014 free(s); 1015 // remove end / 1016 s = normalizePath("/home/"); 1017 ck_assert_str_eq(s, "/home"); 1018 free(s); 1019 // cancel path and keep leading / 1020 s = normalizePath("/home/.."); 1021 ck_assert_str_eq(s, "/"); 1022 free(s); 1023 // cancel path 1024 s = normalizePath("home/.."); 1025 ck_assert_str_eq(s, ""); 1026 free(s); 1027 // multiple / 1028 s = normalizePath("/home///stuff"); 1029 ck_assert_str_eq(s, "/home/stuff"); 1030 free(s); 1031 // remove . and .. and keep leading / 1032 s = normalizePath("/a/./b/../../c/"); 1033 ck_assert_str_eq(s, "/c"); 1034 free(s); 1035 // keep leading / 1036 s = normalizePath("/../"); 1037 ck_assert_str_eq(s, "/"); 1038 free(s); 1039 // keep leading .. 1040 s = normalizePath(".././/"); 1041 ck_assert_str_eq(s, ".."); 1042 free(s); 1043 // remove . 1044 s = normalizePath("./"); 1045 ck_assert_str_eq(s, ""); 1046 free(s); 1047 // keep / before . 1048 s = normalizePath("/."); 1049 ck_assert_str_eq(s, "/"); 1050 free(s); 1051 // remove . 1052 s = normalizePath("."); 1053 ck_assert_str_eq(s, ""); 1054 free(s); 1055 // / not changed 1056 s = normalizePath("/"); 1057 ck_assert_str_eq(s, "/"); 1058 free(s); 1059 // // becomes / 1060 s = normalizePath("//"); 1061 ck_assert_str_eq(s, "/"); 1062 free(s); 1063 // remove leading . 1064 s = normalizePath("/./werwer"); 1065 ck_assert_str_eq(s, "/werwer"); 1066 free(s); 1067 // keep leading .. and remove .. in path 1068 s = normalizePath(".././test/../test/file"); 1069 ck_assert_str_eq(s, "../test/file"); 1070 free(s); 1071 s = normalizePath("../d1/./d2/../f1"); 1072 ck_assert_str_eq(s, "../d1/f1"); 1073 free(s); 1074 s = normalizePath("a/b/c/../d/../e"); 1075 ck_assert_str_eq(s, "a/b/e"); 1076 free(s); 1077 // dont remove .. when there are only .. in front 1078 s = normalizePath("../../test/test/file"); 1079 ck_assert_str_eq(s, "../../test/test/file"); 1080 free(s); 1081 // empty path 1082 s = normalizePath(""); 1083 ck_assert_str_eq(s, ""); 1084 free(s); 1085 // NULL path 1086 ck_assert_ptr_eq(normalizePath(NULL), NULL); 1087 1088 END_TEST 1089 1090 1091 START_TEST(iNormalizePathT) 1092 1093 // test 1094 char *s = strdup("test/.././file.txt"); 1095 char *r = null; 1096 1097 r = iNormalizePath(&s); 1098 ck_assert_ptr_eq(r, s); 1099 ck_assert_str_eq(s, "file.txt"); 1100 free(s); 1101 // remove end / 1102 s = strdup("/home/"); 1103 r = iNormalizePath(&s); 1104 ck_assert_ptr_eq(r, s); 1105 ck_assert_str_eq(s, "/home"); 1106 free(s); 1107 // cancel path and keep leading / 1108 s = strdup("/home/.."); 1109 r = iNormalizePath(&s); 1110 ck_assert_ptr_eq(r, s); 1111 ck_assert_str_eq(s, "/"); 1112 free(s); 1113 // cancel path 1114 s = strdup("home/.."); 1115 r = iNormalizePath(&s); 1116 ck_assert_ptr_eq(r, s); 1117 ck_assert_str_eq(s, ""); 1118 free(s); 1119 // multiple / 1120 s = strdup("/home///stuff"); 1121 r = iNormalizePath(&s); 1122 ck_assert_ptr_eq(r, s); 1123 ck_assert_str_eq(s, "/home/stuff"); 1124 free(s); 1125 // remove . and .. and keep leading / 1126 s = strdup("/a/./b/../../c/"); 1127 r = iNormalizePath(&s); 1128 ck_assert_ptr_eq(r, s); 1129 ck_assert_str_eq(s, "/c"); 1130 free(s); 1131 // keep leading / 1132 s = strdup("/../"); 1133 r = iNormalizePath(&s); 1134 ck_assert_ptr_eq(r, s); 1135 ck_assert_str_eq(s, "/"); 1136 free(s); 1137 // keep leading .. 1138 s = strdup(".././/"); 1139 r = iNormalizePath(&s); 1140 ck_assert_ptr_eq(r, s); 1141 ck_assert_str_eq(s, ".."); 1142 free(s); 1143 // remove . 1144 s = strdup("./"); 1145 r = iNormalizePath(&s); 1146 ck_assert_ptr_eq(r, s); 1147 ck_assert_str_eq(s, ""); 1148 free(s); 1149 // keep / before . 1150 s = strdup("/."); 1151 r = iNormalizePath(&s); 1152 ck_assert_ptr_eq(r, s); 1153 ck_assert_str_eq(s, "/"); 1154 free(s); 1155 // remove . 1156 s = strdup("."); 1157 r = iNormalizePath(&s); 1158 ck_assert_ptr_eq(r, s); 1159 ck_assert_str_eq(s, ""); 1160 free(s); 1161 // / not changed 1162 s = strdup("/"); 1163 r = iNormalizePath(&s); 1164 ck_assert_ptr_eq(r, s); 1165 ck_assert_str_eq(s, "/"); 1166 free(s); 1167 // // becomes / 1168 s = strdup("//"); 1169 r = iNormalizePath(&s); 1170 ck_assert_ptr_eq(r, s); 1171 ck_assert_str_eq(s, "/"); 1172 free(s); 1173 // remove leading . 1174 s = strdup("/./werwer"); 1175 r = iNormalizePath(&s); 1176 ck_assert_ptr_eq(r, s); 1177 ck_assert_str_eq(s, "/werwer"); 1178 free(s); 1179 // keep leading .. and remove .. in path 1180 s = strdup(".././test/../test/file"); 1181 r = iNormalizePath(&s); 1182 ck_assert_ptr_eq(r, s); 1183 ck_assert_str_eq(s, "../test/file"); 1184 free(s); 1185 s = strdup("../d1/./d2/../f1"); 1186 r = iNormalizePath(&s); 1187 ck_assert_ptr_eq(r, s); 1188 ck_assert_str_eq(s, "../d1/f1"); 1189 free(s); 1190 s = strdup("a/b/c/../d/../e"); 1191 r = iNormalizePath(&s); 1192 ck_assert_ptr_eq(r, s); 1193 ck_assert_str_eq(s, "a/b/e"); 1194 free(s); 1195 // dont remove .. when there are only .. in front 1196 s = strdup("../../test/test/file"); 1197 r = iNormalizePath(&s); 1198 ck_assert_ptr_eq(r, s); 1199 ck_assert_str_eq(s, "../../test/test/file"); 1200 free(s); 1201 // empty path 1202 s = strdup(""); 1203 r = iNormalizePath(&s); 1204 ck_assert_ptr_eq(r, s); 1205 ck_assert_str_eq(s, ""); 1206 free(s); 1207 // empty NULL path 1208 s = NULL; 1209 r = iNormalizePath(&s); 1210 ck_assert_ptr_eq(r, null); 1211 // NULL path 1212 r = iNormalizePath(NULL); 1213 ck_assert_ptr_eq(r, null); 1214 1215 END_TEST 1216 1217 1218 START_TEST(bNormalizePathT) 1219 1220 // test 1221 char s[100] = "test/.././file.txt"; 1222 char *r = null; 1223 1224 r = bNormalizePath(s); 1225 ck_assert_ptr_eq(r, s); 1226 ck_assert_str_eq(s, "file.txt"); 1227 // remove end / 1228 strcpy(s, "/home/"); 1229 r = bNormalizePath(s); 1230 ck_assert_ptr_eq(r, s); 1231 ck_assert_str_eq(s, "/home"); 1232 // cancel path and keep leading / 1233 strcpy(s, "/home/.."); 1234 r = bNormalizePath(s); 1235 ck_assert_ptr_eq(r, s); 1236 ck_assert_str_eq(s, "/"); 1237 // cancel path 1238 strcpy(s, "home/.."); 1239 r = bNormalizePath(s); 1240 ck_assert_ptr_eq(r, s); 1241 ck_assert_str_eq(s, ""); 1242 // multiple / 1243 strcpy(s, "/home///stuff"); 1244 r = bNormalizePath(s); 1245 ck_assert_ptr_eq(r, s); 1246 ck_assert_str_eq(s, "/home/stuff"); 1247 // remove . and .. and keep leading / 1248 strcpy(s, "/a/./b/../../c/"); 1249 r = bNormalizePath(s); 1250 ck_assert_ptr_eq(r, s); 1251 ck_assert_str_eq(s, "/c"); 1252 // keep leading / 1253 strcpy(s, "/../"); 1254 r = bNormalizePath(s); 1255 ck_assert_ptr_eq(r, s); 1256 ck_assert_str_eq(s, "/"); 1257 // keep leading .. 1258 strcpy(s, ".././/"); 1259 r = bNormalizePath(s); 1260 ck_assert_ptr_eq(r, s); 1261 ck_assert_str_eq(s, ".."); 1262 // remove . 1263 strcpy(s, "./"); 1264 r = bNormalizePath(s); 1265 ck_assert_ptr_eq(r, s); 1266 ck_assert_str_eq(s, ""); 1267 // keep / before . 1268 strcpy(s, "/."); 1269 r = bNormalizePath(s); 1270 ck_assert_ptr_eq(r, s); 1271 ck_assert_str_eq(s, "/"); 1272 // remove . 1273 strcpy(s, "."); 1274 r = bNormalizePath(s); 1275 ck_assert_ptr_eq(r, s); 1276 ck_assert_str_eq(s, ""); 1277 // / not changed 1278 strcpy(s, "/"); 1279 r = bNormalizePath(s); 1280 ck_assert_ptr_eq(r, s); 1281 ck_assert_str_eq(s, "/"); 1282 // // becomes / 1283 strcpy(s, "//"); 1284 r = bNormalizePath(s); 1285 ck_assert_ptr_eq(r, s); 1286 ck_assert_str_eq(s, "/"); 1287 // remove leading . 1288 strcpy(s, "/./werwer"); 1289 r = bNormalizePath(s); 1290 ck_assert_ptr_eq(r, s); 1291 ck_assert_str_eq(s, "/werwer"); 1292 // keep leading .. and remove .. in path 1293 strcpy(s, ".././test/../test/file"); 1294 r = bNormalizePath(s); 1295 ck_assert_ptr_eq(r, s); 1296 ck_assert_str_eq(s, "../test/file"); 1297 strcpy(s, "../d1/./d2/../f1"); 1298 r = bNormalizePath(s); 1299 ck_assert_ptr_eq(r, s); 1300 ck_assert_str_eq(s, "../d1/f1"); 1301 strcpy(s, "a/b/c/../d/../e"); 1302 r = bNormalizePath(s); 1303 ck_assert_ptr_eq(r, s); 1304 ck_assert_str_eq(s, "a/b/e"); 1305 // dont remove .. when there are only .. in front 1306 strcpy(s, "../../test/test/file"); 1307 r = bNormalizePath(s); 1308 ck_assert_ptr_eq(r, s); 1309 ck_assert_str_eq(s, "../../test/test/file"); 1310 // empty path 1311 strcpy(s, ""); 1312 r = bNormalizePath(s); 1313 ck_assert_ptr_eq(r, s); 1314 ck_assert_str_eq(s, ""); 1315 // NULL path 1316 r = bNormalizePath(NULL); 1317 ck_assert_ptr_eq(r, null); 1318 1319 END_TEST 1320 1321 1322 START_TEST(bLNormalizePathT) 1323 1324 // test 1325 char s[100] = "test/.././file.txt"; 1326 char *r = null; 1327 1328 r = bLNormalizePath(s, sizeof s); 1329 ck_assert_ptr_eq(r, s); 1330 ck_assert_str_eq(s, "file.txt"); 1331 // remove end / 1332 strcpy(s, "/home/"); 1333 r = bLNormalizePath(s, sizeof s); 1334 ck_assert_ptr_eq(r, s); 1335 ck_assert_str_eq(s, "/home"); 1336 // cancel path and keep leading / 1337 strcpy(s, "/home/.."); 1338 r = bLNormalizePath(s, sizeof s); 1339 ck_assert_ptr_eq(r, s); 1340 ck_assert_str_eq(s, "/"); 1341 // cancel path 1342 strcpy(s, "home/.."); 1343 r = bLNormalizePath(s, sizeof s); 1344 ck_assert_ptr_eq(r, s); 1345 ck_assert_str_eq(s, ""); 1346 // multiple / 1347 strcpy(s, "/home///stuff"); 1348 r = bLNormalizePath(s, sizeof s); 1349 ck_assert_ptr_eq(r, s); 1350 ck_assert_str_eq(s, "/home/stuff"); 1351 // remove . and .. and keep leading / 1352 strcpy(s, "/a/./b/../../c/"); 1353 r = bLNormalizePath(s, sizeof s); 1354 ck_assert_ptr_eq(r, s); 1355 ck_assert_str_eq(s, "/c"); 1356 // keep leading / 1357 strcpy(s, "/../"); 1358 r = bLNormalizePath(s, sizeof s); 1359 ck_assert_ptr_eq(r, s); 1360 ck_assert_str_eq(s, "/"); 1361 // keep leading .. 1362 strcpy(s, ".././/"); 1363 r = bLNormalizePath(s, sizeof s); 1364 ck_assert_ptr_eq(r, s); 1365 ck_assert_str_eq(s, ".."); 1366 // remove . 1367 strcpy(s, "./"); 1368 r = bLNormalizePath(s, sizeof s); 1369 ck_assert_ptr_eq(r, s); 1370 ck_assert_str_eq(s, ""); 1371 // keep / before . 1372 strcpy(s, "/."); 1373 r = bLNormalizePath(s, sizeof s); 1374 ck_assert_ptr_eq(r, s); 1375 ck_assert_str_eq(s, "/"); 1376 // remove . 1377 strcpy(s, "."); 1378 r = bLNormalizePath(s, sizeof s); 1379 ck_assert_ptr_eq(r, s); 1380 ck_assert_str_eq(s, ""); 1381 // / not changed 1382 strcpy(s, "/"); 1383 r = bLNormalizePath(s, sizeof s); 1384 ck_assert_ptr_eq(r, s); 1385 ck_assert_str_eq(s, "/"); 1386 // // becomes / 1387 strcpy(s, "//"); 1388 r = bLNormalizePath(s, sizeof s); 1389 ck_assert_ptr_eq(r, s); 1390 ck_assert_str_eq(s, "/"); 1391 // remove leading . 1392 strcpy(s, "/./werwer"); 1393 r = bLNormalizePath(s, sizeof s); 1394 ck_assert_ptr_eq(r, s); 1395 ck_assert_str_eq(s, "/werwer"); 1396 // keep leading .. and remove .. in path 1397 strcpy(s, ".././test/../test/file"); 1398 r = bLNormalizePath(s, sizeof s); 1399 ck_assert_ptr_eq(r, s); 1400 ck_assert_str_eq(s, "../test/file"); 1401 strcpy(s, "../d1/./d2/../f1"); 1402 r = bLNormalizePath(s, sizeof s); 1403 ck_assert_ptr_eq(r, s); 1404 ck_assert_str_eq(s, "../d1/f1"); 1405 strcpy(s, "a/b/c/../d/../e"); 1406 r = bLNormalizePath(s, sizeof s); 1407 ck_assert_ptr_eq(r, s); 1408 ck_assert_str_eq(s, "a/b/e"); 1409 // dont remove .. when there are only .. in front 1410 strcpy(s, "../../test/test/file"); 1411 r = bLNormalizePath(s, sizeof s); 1412 ck_assert_ptr_eq(r, s); 1413 ck_assert_str_eq(s, "../../test/test/file"); 1414 // empty path 1415 strcpy(s, ""); 1416 r = bLNormalizePath(s, sizeof s); 1417 ck_assert_ptr_eq(r, s); 1418 ck_assert_str_eq(s, ""); 1419 // shorter buffer than path 1420 strcpy(s, "a/b/c/../d/../e"); 1421 r = bLNormalizePath(s, 4); 1422 ck_assert_ptr_eq(r, s); 1423 ck_assert_str_eq(s, "a/b"); 1424 strcpy(s, "a/b/c/../d/../e"); 1425 // size 0 - no change in path 1426 r = bLNormalizePath(s, 0); 1427 ck_assert_ptr_eq(r, s); 1428 ck_assert_str_eq(s, "a/b/c/../d/../e"); 1429 // NULL path 1430 r = bLNormalizePath(NULL, sizeof s); 1431 ck_assert_ptr_eq(r, null); 1432 1433 END_TEST 1434 1435 1436 START_TEST(relPathT) 1437 1438 char *r; 1439 char *cwd; 1440 1441 // relative to cwd 1442 cwd = getCwd(); 1443 r = iAppendS(&cwd, "/../sheepy"); 1444 ck_assert_ptr_eq(r, cwd); 1445 r = relPath(cwd, null); 1446 ck_assert_str_eq(r, "../sheepy"); 1447 free(r); 1448 free(cwd); 1449 1450 // relative to cwd and path starts with cwd but is a different path 1451 // (no slash between cwd and "../sheepy") 1452 cwd = getCwd(); 1453 r = iAppendS(&cwd, "../sheepy"); 1454 ck_assert_ptr_eq(r, cwd); 1455 r = relPath(cwd, null); 1456 ck_assert_str_eq(r, "../src../sheepy"); 1457 free(r); 1458 free(cwd); 1459 1460 // subdirectory to cwd 1461 cwd = getCwd(); 1462 r = iAppendS(&cwd, "/sheepy"); 1463 ck_assert_ptr_eq(r, cwd); 1464 r = relPath(cwd, null); 1465 ck_assert_str_eq(r, "sheepy"); 1466 free(r); 1467 free(cwd); 1468 1469 // path = start 1470 cwd = getCwd(); 1471 r = relPath(cwd, null); 1472 ck_assert_str_eq(r, "."); 1473 free(r); 1474 free(cwd); 1475 1476 // start = root 1477 cwd = getCwd(); 1478 r = iAppendS(&cwd, "/sheepy"); 1479 ck_assert_ptr_eq(r, cwd); 1480 r = relPath(cwd, "/../"); 1481 ck_assert_str_eq(r, cwd+1); 1482 free(r); 1483 free(cwd); 1484 1485 // relative to start 1486 r = relPath("/home/sheepy", "/home/test"); 1487 ck_assert_str_eq(r, "../sheepy"); 1488 free(r); 1489 1490 // path is relative (no leading slash), start is cwd 1491 r = relPath("../src/sheepy", null); 1492 ck_assert_str_eq(r, "sheepy"); 1493 free(r); 1494 1495 // path is relative (no leading slash) 1496 r = relPath("../test/sheepy", "/home/test"); 1497 ck_assert_str_eq(r, "sheepy"); 1498 free(r); 1499 1500 // start is relative to cwd 1501 cwd = getCwd(); 1502 r = iAppendS(&cwd, "/../sheepy"); 1503 ck_assert_ptr_eq(r, cwd); 1504 r = relPath(cwd, "test/"); 1505 ck_assert_str_eq(r, "../../sheepy"); 1506 free(r); 1507 free(cwd); 1508 1509 // all relative paths 1510 // the reference for path and start parameters is an arbitrary directory 1511 r = relPath("sheepy", "shefjf/test/src/"); 1512 ck_assert_str_eq(r, "../../../sheepy"); 1513 free(r); 1514 1515 r = relPath("sheepy", "shee"); 1516 ck_assert_str_eq(r, "../sheepy"); 1517 free(r); 1518 1519 // null path 1520 r = relPath(null, null); 1521 ck_assert_ptr_eq(r, null); 1522 1523 END_TEST 1524 1525 1526 START_TEST(iRelPathT) 1527 1528 char *r; 1529 char *cwd; 1530 1531 // relative to cwd 1532 cwd = getCwd(); 1533 r = iAppendS(&cwd, "/../sheepy"); 1534 ck_assert_ptr_eq(r, cwd); 1535 r = iRelPath(&cwd, null); 1536 ck_assert_str_eq(r, "../sheepy"); 1537 free(r); 1538 1539 // relative to cwd and path starts with cwd but is a different path 1540 // (no slash between cwd and "../sheepy") 1541 cwd = getCwd(); 1542 r = iAppendS(&cwd, "../sheepy"); 1543 ck_assert_ptr_eq(r, cwd); 1544 r = iRelPath(&cwd, null); 1545 ck_assert_str_eq(r, "../src../sheepy"); 1546 free(r); 1547 1548 // subdirectory to cwd 1549 cwd = getCwd(); 1550 r = iAppendS(&cwd, "/sheepy"); 1551 ck_assert_ptr_eq(r, cwd); 1552 r = iRelPath(&cwd, null); 1553 ck_assert_str_eq(r, "sheepy"); 1554 free(r); 1555 1556 // path = start 1557 cwd = getCwd(); 1558 r = iRelPath(&cwd, null); 1559 ck_assert_str_eq(r, "."); 1560 free(r); 1561 1562 // start = root 1563 cwd = getCwd(); 1564 r = iAppendS(&cwd, "/sheepy"); 1565 ck_assert_ptr_eq(r, cwd); 1566 char *expected = strdup(cwd+1); 1567 r = iRelPath(&cwd, "/../"); 1568 ck_assert_str_eq(r, expected); 1569 free(r); 1570 free(expected); 1571 1572 // relative to start 1573 cwd = strdup("/home/sheepy"); 1574 r = iRelPath(&cwd, "/home/test"); 1575 ck_assert_str_eq(r, "../sheepy"); 1576 free(r); 1577 1578 // path is relative (no leading slash), start is cwd 1579 cwd = strdup("../src/sheepy"); 1580 r = iRelPath(&cwd, null); 1581 ck_assert_str_eq(r, "sheepy"); 1582 free(r); 1583 1584 // path is relative (no leading slash) 1585 cwd = strdup("../test/sheepy"); 1586 r = iRelPath(&cwd, "/home/test"); 1587 ck_assert_str_eq(r, "sheepy"); 1588 free(r); 1589 1590 // start is relative to cwd 1591 cwd = getCwd(); 1592 r = iAppendS(&cwd, "/../sheepy"); 1593 ck_assert_ptr_eq(r, cwd); 1594 r = iRelPath(&cwd, "test/"); 1595 ck_assert_str_eq(r, "../../sheepy"); 1596 free(r); 1597 1598 // all relative paths 1599 // the reference for path and start parameters is an arbitrary directory 1600 cwd = strdup("sheepy"); 1601 r = iRelPath(&cwd, "shefjf/test/src/"); 1602 ck_assert_str_eq(r, "../../../sheepy"); 1603 free(r); 1604 1605 cwd = strdup("sheepy"); 1606 r = iRelPath(&cwd, "shee"); 1607 ck_assert_str_eq(r, "../sheepy"); 1608 free(r); 1609 1610 // null path 1611 cwd = null; 1612 r = iRelPath(&cwd, null); 1613 ck_assert_ptr_eq(r, null); 1614 1615 // null var 1616 r = iRelPath(null, null); 1617 ck_assert_ptr_eq(r, null); 1618 1619 END_TEST 1620 1621 1622 START_TEST(bRelPathT) 1623 1624 char b[8192] = init0Var; 1625 char *r; 1626 char *cwd; 1627 1628 // relative to cwd 1629 cwd = getCwd(); 1630 r = iAppendS(&cwd, "/../sheepy"); 1631 ck_assert_ptr_eq(r, cwd); 1632 r = bRelPath(b, cwd, null); 1633 ck_assert_str_eq(r, "../sheepy"); 1634 free(cwd); 1635 1636 // relative to cwd and path starts with cwd but is a different path 1637 // (no slash between cwd and "../sheepy") 1638 cwd = getCwd(); 1639 r = iAppendS(&cwd, "../sheepy"); 1640 ck_assert_ptr_eq(r, cwd); 1641 r = bRelPath(b, cwd, null); 1642 ck_assert_str_eq(r, "../src../sheepy"); 1643 free(cwd); 1644 1645 // subdirectory to cwd 1646 cwd = getCwd(); 1647 r = iAppendS(&cwd, "/sheepy"); 1648 ck_assert_ptr_eq(r, cwd); 1649 r = bRelPath(b, cwd, null); 1650 ck_assert_str_eq(r, "sheepy"); 1651 free(cwd); 1652 1653 // path = start 1654 cwd = getCwd(); 1655 r = bRelPath(b, cwd, null); 1656 ck_assert_str_eq(r, "."); 1657 free(cwd); 1658 1659 // start = root 1660 cwd = getCwd(); 1661 r = iAppendS(&cwd, "/sheepy"); 1662 ck_assert_ptr_eq(r, cwd); 1663 r = bRelPath(b, cwd, "/../"); 1664 ck_assert_str_eq(r, cwd+1); 1665 free(cwd); 1666 1667 // relative to start 1668 r = bRelPath(b, "/home/sheepy", "/home/test"); 1669 ck_assert_str_eq(r, "../sheepy"); 1670 1671 // path is relative (no leading slash), start is cwd 1672 r = bRelPath(b, "../src/sheepy", null); 1673 ck_assert_str_eq(r, "sheepy"); 1674 1675 // path is relative (no leading slash) 1676 r = bRelPath(b, "../test/sheepy", "/home/test"); 1677 ck_assert_str_eq(r, "sheepy"); 1678 1679 // start is relative to cwd 1680 cwd = getCwd(); 1681 r = iAppendS(&cwd, "/../sheepy"); 1682 ck_assert_ptr_eq(r, cwd); 1683 r = bRelPath(b, cwd, "test/"); 1684 ck_assert_str_eq(r, "../../sheepy"); 1685 free(cwd); 1686 1687 // all relative paths 1688 // the reference for path and start parameters is an arbitrary directory 1689 r = bRelPath(b, "sheepy", "shefjf/test/src/"); 1690 ck_assert_str_eq(r, "../../../sheepy"); 1691 1692 r = bRelPath(b, "sheepy", "shee"); 1693 ck_assert_str_eq(r, "../sheepy"); 1694 1695 // null path 1696 r = bRelPath(b, null, null); 1697 ck_assert_ptr_eq(r, null); 1698 1699 // null dest 1700 r = bRelPath(null, "", null); 1701 ck_assert_ptr_eq(r, null); 1702 1703 1704 END_TEST 1705 1706 1707 START_TEST(bLRelPathT) 1708 1709 char b[8192] = init0Var; 1710 char *r; 1711 char *cwd; 1712 1713 // relative to cwd 1714 cwd = getCwd(); 1715 r = iAppendS(&cwd, "/../sheepy"); 1716 ck_assert_ptr_eq(r, cwd); 1717 r = bLRelPath(b, sizeof(b), cwd, null); 1718 ck_assert_str_eq(r, "../sheepy"); 1719 free(cwd); 1720 1721 // relative to cwd and path starts with cwd but is a different path 1722 // (no slash between cwd and "../sheepy") 1723 cwd = getCwd(); 1724 r = iAppendS(&cwd, "../sheepy"); 1725 ck_assert_ptr_eq(r, cwd); 1726 r = bLRelPath(b, sizeof(b), cwd, null); 1727 ck_assert_str_eq(r, "../src../sheepy"); 1728 free(cwd); 1729 1730 // subdirectory to cwd 1731 cwd = getCwd(); 1732 r = iAppendS(&cwd, "/sheepy"); 1733 ck_assert_ptr_eq(r, cwd); 1734 r = bLRelPath(b, sizeof(b), cwd, null); 1735 ck_assert_str_eq(r, "sheepy"); 1736 free(cwd); 1737 1738 // path = start 1739 cwd = getCwd(); 1740 r = bLRelPath(b, sizeof(b), cwd, null); 1741 ck_assert_str_eq(r, "."); 1742 free(cwd); 1743 1744 // start = root 1745 cwd = getCwd(); 1746 r = iAppendS(&cwd, "/sheepy"); 1747 ck_assert_ptr_eq(r, cwd); 1748 r = bLRelPath(b, sizeof(b), cwd, "/../"); 1749 ck_assert_str_eq(r, cwd+1); 1750 free(cwd); 1751 1752 // relative to start 1753 r = bLRelPath(b, sizeof(b), "/home/sheepy", "/home/test"); 1754 ck_assert_str_eq(r, "../sheepy"); 1755 1756 // path is relative (no leading slash), start is cwd 1757 r = bLRelPath(b, sizeof(b), "../src/sheepy", null); 1758 ck_assert_str_eq(r, "sheepy"); 1759 1760 // path is relative (no leading slash) 1761 r = bLRelPath(b, sizeof(b), "../test/sheepy", "/home/test"); 1762 ck_assert_str_eq(r, "sheepy"); 1763 1764 // start is relative to cwd 1765 cwd = getCwd(); 1766 r = iAppendS(&cwd, "/../sheepy"); 1767 ck_assert_ptr_eq(r, cwd); 1768 r = bLRelPath(b, sizeof(b), cwd, "test/"); 1769 ck_assert_str_eq(r, "../../sheepy"); 1770 free(cwd); 1771 1772 // all relative paths 1773 // the reference for path and start parameters is an arbitrary directory 1774 r = bLRelPath(b, sizeof(b), "sheepy", "shefjf/test/src/"); 1775 ck_assert_str_eq(r, "../../../sheepy"); 1776 1777 r = bLRelPath(b, sizeof(b), "sheepy", "shee"); 1778 ck_assert_str_eq(r, "../sheepy"); 1779 1780 // null path 1781 r = bLRelPath(b, sizeof(b), null, null); 1782 ck_assert_ptr_eq(r, null); 1783 1784 // null dest 1785 r = bLRelPath(null, sizeof(b), "", null); 1786 ck_assert_ptr_eq(r, null); 1787 1788 END_TEST 1789 1790 1791 START_TEST(getHomePathT) 1792 1793 char *r = getHomePath(); 1794 ck_assert_ptr_ne(r, null); 1795 ck_assert_int_eq(r[0], '/'); 1796 free(r); 1797 1798 char b[8192] = init0Var; 1799 r = bGetHomePath(b); 1800 ck_assert_ptr_ne(r, null); 1801 ck_assert_int_eq(r[0], '/'); 1802 1803 r = bLGetHomePath(b, sizeof(b)); 1804 ck_assert_ptr_ne(r, null); 1805 ck_assert_int_eq(r[0], '/'); 1806 1807 // buffer too short 1808 char bL[2] = init0Var; 1809 r = bLGetHomePath(bL, sizeof(bL)); 1810 ck_assert_ptr_eq(r, null); 1811 1812 const char *cR = getCHomePath(); 1813 ck_assert_ptr_ne(cR, null); 1814 ck_assert_int_eq(cR[0], '/'); 1815 1816 END_TEST 1817 1818 1819 START_TEST(getCwdT) 1820 1821 char *r = getCwd(); 1822 ck_assert_ptr_ne(r, null); 1823 ck_assert_int_eq(r[0], '/'); 1824 free(r); 1825 1826 // buffer 1827 char b[8192] = init0Var; 1828 r = bLGetCwd(b, sizeof(b)); 1829 ck_assert_ptr_ne(r, null); 1830 ck_assert_int_eq(r[0], '/'); 1831 1832 // buffer too short 1833 char bL[2] = init0Var; 1834 r = bLGetCwd(bL, sizeof(bL)); 1835 ck_assert_ptr_eq(r, null); 1836 1837 END_TEST 1838 1839 1840 START_TEST(chDirT) 1841 1842 // change directory 1843 char *c = getCwd(); 1844 ck_assert(chDir("dirTest.null")); 1845 char *s = getCwd(); 1846 ck_assert((size_t)findS(s, "dirTest.null")); 1847 bool r = chDir(c); 1848 ck_assert(r); 1849 freeManyS(c,s); 1850 // non existing dir 1851 ck_assert(!chDir("RandomNonExistingDir")); 1852 // NULL path 1853 ck_assert(!chDir(NULL)); 1854 1855 END_TEST 1856 1857 1858 START_TEST(isDirT) 1859 1860 // dir 1861 ck_assert(isDir("dirTest.null")); 1862 1863 // non existing dir 1864 ck_assert(!isDir("RandomNonExistingDir")); 1865 1866 // blank 1867 ck_assert(!isDir(" ")); 1868 1869 // NULL path 1870 ck_assert(!isDir(NULL)); 1871 1872 END_TEST 1873 1874 1875 START_TEST(shReadlinkT) 1876 1877 char *r; 1878 1879 // read a link 1880 r = shReadlink("linkTest.null"); 1881 ck_assert_ptr_ne(r, null); 1882 ck_assert_str_eq(r, "textTest.null"); 1883 free(r); 1884 1885 // not a link, regular file 1886 r = shReadlink("textTest.null"); 1887 ck_assert_ptr_eq(r, null); 1888 1889 // non existing path 1890 r = shReadlink("random"); 1891 ck_assert_ptr_eq(r, null); 1892 1893 // blank path 1894 r = shReadlink(" "); 1895 ck_assert_ptr_eq(r, null); 1896 1897 // null path 1898 r = shReadlink(null); 1899 ck_assert_ptr_eq(r, null); 1900 1901 END_TEST 1902 1903 1904 START_TEST(endlinkT) 1905 1906 char *r; 1907 1908 // read a link 1909 r = endlink("linkTest.null"); 1910 ck_assert_ptr_ne(r, null); 1911 ck_assert_str_eq(r, "textTest.null"); 1912 free(r); 1913 1914 // read a link to absolute path 1915 r = endlink("absLinkTest.null"); 1916 ck_assert_ptr_ne(r, null); 1917 ck_assert_str_eq(r, "/usr/local/bin/sheepy"); 1918 free(r); 1919 1920 // not a link, regular file 1921 r = endlink("textTest.null"); 1922 ck_assert_ptr_eq(r, null); 1923 1924 // non existing path 1925 r = endlink("random"); 1926 ck_assert_ptr_eq(r, null); 1927 1928 // blank path 1929 r = endlink(" "); 1930 ck_assert_ptr_eq(r, null); 1931 1932 // null path 1933 r = endlink(null); 1934 ck_assert_ptr_eq(r, null); 1935 1936 END_TEST 1937 1938 1939 START_TEST(isLinkT) 1940 1941 // link 1942 ck_assert(isLink("linkTest.null")); 1943 1944 // not link 1945 ck_assert(!isLink("textTest.null")); 1946 1947 // non existing link 1948 ck_assert(!isLink("RandomNonExistingDir")); 1949 1950 // blank 1951 ck_assert(!isLink(" ")); 1952 1953 // NULL path 1954 ck_assert(!isLink(NULL)); 1955 1956 END_TEST 1957 1958 1959 START_TEST(fileExistsT) 1960 1961 // detect existing file 1962 ck_assert(fileExists("libsheepyTest.c")); 1963 // non existing file 1964 ck_assert(!fileExists("wefwepfk34.c")); 1965 // folder 1966 ck_assert(fileExists("../src")); 1967 // empty path 1968 ck_assert(!fileExists("")); 1969 // NULL path 1970 ck_assert(!fileExists(NULL)); 1971 1972 END_TEST 1973 1974 1975 START_TEST(fileChmodT) 1976 1977 // existing file 1978 ck_assert(fileChmod("chmodTest.null", S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)); 1979 ck_assert(fileChmod("chmodTest.null", S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)); 1980 // non existing file 1981 ck_assert(!fileChmod("qweqwe_null", S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)); 1982 // empty path 1983 ck_assert(!fileChmod("",0)); 1984 // NULL path 1985 ck_assert(!fileChmod(NULL,0)); 1986 1987 END_TEST 1988 1989 1990 START_TEST(fileSizeT) 1991 1992 // existing file 1993 ck_assert_uint_eq(fileSize("sizeTest.null"), 743); 1994 // empty file 1995 ck_assert_uint_eq(fileSize("chmodTest.null"), 0); 1996 // non existing file 1997 ck_assert_int_eq(fileSize("qweqwe_null"), -1); 1998 // empty path 1999 ck_assert_int_eq(fileSize(""), -1); 2000 // NULL path 2001 ck_assert_int_eq(fileSize(NULL), -1); 2002 2003 END_TEST 2004 2005 2006 START_TEST(fileSizeFPT) 2007 2008 FILE *f; 2009 2010 // existing file 2011 f = fopen("sizeTest.null", "r"); 2012 ck_assert_int_eq(fileSizeFP(f), 743); 2013 fclose(f); 2014 2015 // empty file 2016 f = fopen("chmodTest.null", "r"); 2017 ck_assert_int_eq(fileSizeFP(f), 0); 2018 fclose(f); 2019 2020 // null file 2021 ck_assert_int_eq(fileSizeFP(null), -1); 2022 2023 END_TEST 2024 2025 2026 START_TEST(readFileToST) 2027 2028 char *l; 2029 2030 // text 2031 l = readFileToS("textTest.null"); 2032 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2033 free(l); 2034 2035 // empty text 2036 l = readFileToS("chmodTest.null"); 2037 ck_assert_str_eq(l, ""); 2038 free(l); 2039 2040 // write only file 2041 bool r = fileChmod("writeOnlyText.null", S_IWUSR | S_IWGRP | S_IWOTH); 2042 ck_assert(r); 2043 ck_assert_ptr_eq(readFileToS("writeOnlyText.null"), NULL); 2044 2045 // blank path 2046 ck_assert_ptr_eq(readFileToS(""), NULL); 2047 2048 // NULL path 2049 ck_assert_ptr_eq(readFileToS(NULL), NULL); 2050 2051 // non existing path 2052 if (fileExists("nonExistingFile")) { 2053 int R = rmAll("nonExistingFile"); 2054 ck_assert_int_ne(R, 0); 2055 } 2056 ck_assert_ptr_eq(readFileToS("nonExistingFile"), NULL); 2057 2058 END_TEST 2059 2060 2061 START_TEST(readStreamToST) 2062 2063 FILE *f; 2064 char *l; 2065 2066 // text 2067 f = fopen("textTest.null", "r"); 2068 l = readStreamToS(f); 2069 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2070 free(l); 2071 fclose(f); 2072 2073 // empty text 2074 f = fopen("chmodTest.null", "r"); 2075 l = readStreamToS(f); 2076 ck_assert_str_eq(l, ""); 2077 free(l); 2078 fclose(f); 2079 2080 // null file 2081 ck_assert_ptr_eq(readStreamToS(null), null); 2082 2083 END_TEST 2084 2085 2086 START_TEST(bReadFileToST) 2087 2088 char l[100]; 2089 void *r = null; 2090 2091 // text 2092 r = bReadFileToS("textTest.null", l); 2093 ck_assert_ptr_eq(r, l); 2094 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2095 2096 // empty text 2097 r = bReadFileToS("chmodTest.null", l); 2098 ck_assert_ptr_eq(r, l); 2099 ck_assert_str_eq(l, ""); 2100 2101 // write only file 2102 r = bReadFileToS("writeOnlyText.null", l); 2103 ck_assert_ptr_eq(r, null); 2104 2105 // blank path 2106 r = bReadFileToS("", l); 2107 ck_assert_ptr_eq(r, null); 2108 2109 // NULL path 2110 r = bReadFileToS(NULL, l); 2111 ck_assert_ptr_eq(r, null); 2112 2113 // NULL buffer 2114 r = bReadFileToS("wqe", NULL); 2115 ck_assert_ptr_eq(r, null); 2116 2117 // non existing path 2118 if (fileExists("nonExistingFile")) { 2119 int R = rmAll("nonExistingFile"); 2120 ck_assert_int_ne(R, 0); 2121 } 2122 r = bReadFileToS("nonExistingFile", l); 2123 ck_assert_ptr_eq(r, null); 2124 2125 END_TEST 2126 2127 2128 START_TEST(bReadStreamToST) 2129 2130 FILE *f; 2131 char l[1024] = init0Var; 2132 char *r; 2133 2134 // text 2135 f = fopen("textTest.null", "r"); 2136 r = bReadStreamToS(f, l); 2137 ck_assert_str_eq(r, "LINE 1\nANOTHER line\n"); 2138 fclose(f); 2139 2140 // empty text 2141 f = fopen("chmodTest.null", "r"); 2142 r = bReadStreamToS(f, l); 2143 ck_assert_str_eq(r, ""); 2144 fclose(f); 2145 2146 // null dst 2147 ck_assert_ptr_eq(bReadStreamToS(f, null), null); 2148 2149 // null file 2150 ck_assert_ptr_eq(bReadStreamToS(null, l), null); 2151 2152 2153 END_TEST 2154 2155 2156 START_TEST(bLReadFileToST) 2157 2158 char l[100]; 2159 void *r = null; 2160 2161 // text 2162 r = bLReadFileToS("textTest.null", l, sizeof l); 2163 ck_assert_ptr_eq(r, l); 2164 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2165 2166 // shorter buffer 2167 r = bLReadFileToS("textTest.null", l, 3); 2168 ck_assert_ptr_eq(r, l); 2169 ck_assert_str_eq(l, "LI"); 2170 2171 // empty text 2172 r = bLReadFileToS("chmodTest.null", l, sizeof l); 2173 ck_assert_ptr_eq(r, l); 2174 ck_assert_str_eq(l, ""); 2175 2176 // size 0 buffer - no change 2177 strcpy(l, "libsheepy"); 2178 r = bLReadFileToS("textTest.null", l, 0); 2179 ck_assert_ptr_eq(r, l); 2180 ck_assert_str_eq(l, "libsheepy"); 2181 2182 // write only file 2183 r = bLReadFileToS("writeOnlyText.null", l, sizeof l); 2184 ck_assert_ptr_eq(r, null); 2185 2186 // blank path 2187 r = bLReadFileToS("", l, sizeof l); 2188 ck_assert_ptr_eq(r, null); 2189 2190 // NULL path 2191 r = bLReadFileToS(NULL, l, sizeof l); 2192 ck_assert_ptr_eq(r, null); 2193 2194 // NULL buffer 2195 r = bLReadFileToS("wqe", NULL, sizeof l); 2196 ck_assert_ptr_eq(r, null); 2197 2198 // non existing path 2199 if (fileExists("nonExistingFile")) { 2200 int R = rmAll("nonExistingFile"); 2201 ck_assert_int_ne(R, 0); 2202 } 2203 r = bLReadFileToS("nonExistingFile", l, sizeof l); 2204 ck_assert_ptr_eq(r, null); 2205 2206 END_TEST 2207 2208 2209 START_TEST(bLReadStreamToST) 2210 2211 FILE *f; 2212 char l[1024] = init0Var; 2213 char *r; 2214 2215 // text 2216 f = fopen("textTest.null", "r"); 2217 r = bLReadStreamToS(f, l, sizeof(l)); 2218 ck_assert_str_eq(r, "LINE 1\nANOTHER line\n"); 2219 fclose(f); 2220 2221 // shorter buffer 2222 l[0] = 'a'; 2223 l[1] = 'a'; 2224 f = fopen("textTest.null", "r"); 2225 r = bLReadStreamToS(f, l, 2); 2226 ck_assert_str_eq(r, "L"); 2227 fclose(f); 2228 2229 // empty text 2230 f = fopen("chmodTest.null", "r"); 2231 r = bLReadStreamToS(f, l, sizeof(l)); 2232 ck_assert_str_eq(r, ""); 2233 fclose(f); 2234 2235 // dst size 0, no changes 2236 r = bLReadStreamToS(f, l, 0); 2237 ck_assert_str_eq(r, ""); 2238 2239 // null dst 2240 ck_assert_ptr_eq(bLReadStreamToS(f, null, sizeof(l)), null); 2241 2242 // null file 2243 ck_assert_ptr_eq(bLReadStreamToS(null, l, sizeof(l)), null); 2244 2245 END_TEST 2246 2247 2248 START_TEST(readFileT) 2249 2250 char *l; 2251 ssize_t sz; 2252 2253 // text 2254 sz = readFile("textTest.null", (void **) &l); 2255 l[19] = 0; 2256 ck_assert_str_eq(l, "LINE 1\nANOTHER line"); 2257 ck_assert_int_eq(sz, 20); 2258 free(l); 2259 2260 // empty text 2261 // allocated 0 bytes 2262 sz = readFile("chmodTest.null", (void **) &l); 2263 ck_assert_ptr_ne(l, NULL); 2264 ck_assert_int_eq(sz, 0); 2265 free(l); 2266 2267 // write only file 2268 bool r = fileChmod("writeOnlyText.null", S_IWUSR | S_IWGRP | S_IWOTH); 2269 ck_assert(r); 2270 ck_assert_int_eq(readFile("writeOnlyText.null", (void **) &l), -1); 2271 2272 // blank path 2273 ck_assert_int_eq(readFile("", (void **) &l), -1); 2274 2275 // NULL buffer 2276 ck_assert_int_eq(readFile("lib", NULL), -1); 2277 2278 // NULL path 2279 ck_assert_int_eq(readFile(NULL, (void **) &l), -1); 2280 2281 // non existing path 2282 if (fileExists("nonExistingFile")) { 2283 int R = rmAll("nonExistingFile"); 2284 ck_assert_int_ne(R, 0); 2285 } 2286 ck_assert_int_eq(readFile("nonExistingFile", (void **) &l), -1); 2287 2288 END_TEST 2289 2290 2291 START_TEST(bReadFileT) 2292 2293 char l[100]; 2294 ssize_t sz; 2295 2296 // text 2297 sz = bReadFile("textTest.null", l); 2298 l[19] = 0; 2299 ck_assert_str_eq(l, "LINE 1\nANOTHER line"); 2300 ck_assert_int_eq(sz, 20); 2301 2302 // empty text 2303 sz = bReadFile("chmodTest.null", l); 2304 ck_assert_str_eq(l, "LINE 1\nANOTHER line"); 2305 ck_assert_int_eq(sz, 0); 2306 2307 // write only file 2308 ck_assert_int_eq(bReadFile("writeOnlyText.null", l), -1); 2309 2310 // blank path 2311 ck_assert_int_eq(bReadFile("", l), -1); 2312 2313 // NULL buffer 2314 ck_assert_int_eq(bReadFile("lib", NULL), -1); 2315 2316 // NULL path 2317 ck_assert_int_eq(bReadFile(NULL, l), -1); 2318 2319 // non existing path 2320 if (fileExists("nonExistingFile")) { 2321 int R = rmAll("nonExistingFile"); 2322 ck_assert_int_ne(R, 0); 2323 } 2324 ck_assert_int_eq(bReadFile("nonExistingFile", l), -1); 2325 2326 END_TEST 2327 2328 2329 START_TEST(bLReadFileT) 2330 2331 char l[100]; 2332 ssize_t sz; 2333 2334 // text 2335 sz = bLReadFile("textTest.null", l, sizeof l); 2336 l[19] = 0; 2337 ck_assert_str_eq(l, "LINE 1\nANOTHER line"); 2338 ck_assert_int_eq(sz, 20); 2339 2340 // shorter buffer 2341 l[0] = 'a'; 2342 l[1] = 'a'; 2343 sz = bLReadFile("textTest.null", l, 1); 2344 ck_assert_str_eq(l, "LaNE 1\nANOTHER line"); 2345 ck_assert_int_eq(sz, 1); 2346 2347 // empty text - l not changed 2348 sz = bLReadFile("chmodTest.null", l, sizeof l); 2349 ck_assert_str_eq(l, "LaNE 1\nANOTHER line"); 2350 ck_assert_int_eq(sz, 0); 2351 2352 // size 0 - l not changed 2353 sz = bLReadFile("chmodTest.null", l, 0); 2354 ck_assert_str_eq(l, "LaNE 1\nANOTHER line"); 2355 ck_assert_int_eq(sz, 0); 2356 2357 // write only file 2358 ck_assert_int_eq(bLReadFile("writeOnlyText.null", l, sizeof l), -1); 2359 2360 // blank path 2361 ck_assert_int_eq(bLReadFile("", l, sizeof l), -1); 2362 2363 // NULL buffer 2364 ck_assert_int_eq(bLReadFile("lib", NULL, sizeof l), -1); 2365 2366 // NULL path 2367 ck_assert_int_eq(bLReadFile(NULL, l, sizeof l), -1); 2368 2369 // non existing path 2370 if (fileExists("nonExistingFile")) { 2371 int R = rmAll("nonExistingFile"); 2372 ck_assert_int_ne(R, 0); 2373 } 2374 ck_assert_int_eq(bLReadFile("nonExistingFile", l, sizeof l), -1); 2375 2376 END_TEST 2377 2378 2379 START_TEST(writeFileST) 2380 2381 char *l; 2382 int r; 2383 2384 // write textOutTest.null 2385 l = readFileToS("textTest.null"); 2386 r = writeFileS("textOutTest.null", l); 2387 ck_assert(r); 2388 free(l); 2389 2390 // check textOutTest.null 2391 l = readFileToS("textOutTest.null"); 2392 ck_assert_uint_eq(strlen(l),20); 2393 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2394 // non existing file 2395 // make sure the file doesnt exist 2396 if (fileExists("nonExistingFile")) { 2397 int R = rmAll("nonExistingFile"); 2398 ck_assert_int_ne(R, 0); 2399 } 2400 ck_assert(writeFileS("nonExistingFile",l)); 2401 if (fileExists("nonExistingFile")) { 2402 int R = rmAll("nonExistingFile"); 2403 ck_assert_int_ne(R, 0); 2404 } 2405 // blank file name 2406 ck_assert(!writeFileS(" ",l)); 2407 // read only path 2408 ck_assert(!writeFileS("/nonExistingFile",l)); 2409 // NULL path 2410 ck_assert(!writeFileS(NULL,l)); 2411 free(l); 2412 // NULL string 2413 ck_assert(!writeFileS("a",NULL)); 2414 2415 END_TEST 2416 2417 2418 START_TEST(writeFileT) 2419 2420 char *l; 2421 int r; 2422 2423 // write textOutTest.null 2424 l = readFileToS("textTest.null"); 2425 r = writeFile("textOutTest.null", l, strlen(l)+1); 2426 ck_assert(r); 2427 free(l); 2428 2429 // check textOutTest.null 2430 l = readFileToS("textOutTest.null"); 2431 ck_assert_uint_eq(strlen(l),20); 2432 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2433 // non existing file 2434 // make sure the file doesnt exist 2435 if (fileExists("nonExistingFile")) { 2436 int R = rmAll("nonExistingFile"); 2437 ck_assert_int_ne(R, 0); 2438 } 2439 ck_assert(writeFile("nonExistingFile",l, strlen(l)+1)); 2440 // 0 length 2441 ck_assert(writeFile("nonExistingFile", l, 0)); 2442 if (fileExists("nonExistingFile")) { 2443 int R = rmAll("nonExistingFile"); 2444 ck_assert_int_ne(R, 0); 2445 } 2446 // blank file name 2447 ck_assert(!writeFile(" ",l, 1)); 2448 // read only path 2449 ck_assert(!writeFile("/nonExistingFile",l, 1)); 2450 // NULL path 2451 ck_assert(!writeFile(NULL,l, 1)); 2452 free(l); 2453 // NULL buffer 2454 ck_assert(!writeFile("a",NULL, 1)); 2455 2456 END_TEST 2457 2458 2459 START_TEST(writeStreamST) 2460 2461 char *l; 2462 int r; 2463 FILE *f; 2464 2465 // write textOutTest.null 2466 l = readFileToS("textTest.null"); 2467 f = fopen("textOutTest.null", "w"); 2468 r = writeStreamS(f, l); 2469 ck_assert(r); 2470 free(l); 2471 fclose(f); 2472 2473 // check textOutTest.null 2474 l = readFileToS("textOutTest.null"); 2475 ck_assert_uint_eq(strlen(l),20); 2476 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2477 2478 // NULL file 2479 ck_assert(!writeStreamS(NULL,l)); 2480 free(l); 2481 // NULL string 2482 ck_assert(!writeStreamS(f,NULL)); 2483 2484 2485 END_TEST 2486 2487 2488 START_TEST(writeLStreamT) 2489 2490 char *l; 2491 int r; 2492 FILE *f; 2493 2494 // write textOutTest.null 2495 l = readFileToS("textTest.null"); 2496 f = fopen("textOutTest.null", "w"); 2497 r = writeLStream(f, l, strlen(l)); 2498 ck_assert(r); 2499 free(l); 2500 fclose(f); 2501 2502 // check textOutTest.null 2503 l = readFileToS("textOutTest.null"); 2504 ck_assert_uint_eq(strlen(l),20); 2505 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2506 2507 // NULL file 2508 ck_assert(!writeLStream(NULL,l, strlen(l))); 2509 free(l); 2510 // NULL string 2511 ck_assert(!writeLStream(f,NULL, 10)); 2512 2513 2514 END_TEST 2515 2516 2517 START_TEST(appendFileST) 2518 2519 char *l; 2520 int r; 2521 2522 // write textOutTest.null 2523 l = "appended line\n"; 2524 r = appendFileS("appendTextOutTest.null", l); 2525 ck_assert(r); 2526 l = "appended line 2\n"; 2527 r = appendFileS("appendTextOutTest.null", l); 2528 ck_assert(r); 2529 2530 // check textOutTest.null 2531 l = readFileToS("appendTextOutTest.null"); 2532 ck_assert_uint_eq(strlen(l),30); 2533 ck_assert_str_eq(l, "appended line\nappended line 2\n"); 2534 if (fileExists("appendTextOutTest.null")) { 2535 int R = rmAll("appendTextOutTest.null"); 2536 ck_assert_int_ne(R, 0); 2537 } 2538 // blank file name 2539 ck_assert(!appendFileS(" ",l)); 2540 // read only path 2541 ck_assert(!appendFileS("/nonExistingFile",l)); 2542 // NULL path 2543 ck_assert(!appendFileS(NULL,l)); 2544 free(l); 2545 // NULL string 2546 ck_assert(!appendFileS("a",NULL)); 2547 2548 2549 END_TEST 2550 2551 2552 START_TEST(appendFileT) 2553 2554 char *l; 2555 int r; 2556 2557 // write textOutTest.null 2558 l = "appended line\n"; 2559 r = appendFile("appendTextOutTest.null", l, strlen(l)); 2560 ck_assert(r); 2561 l = "appended line 2\n"; 2562 r = appendFile("appendTextOutTest.null", l, strlen(l)); 2563 ck_assert(r); 2564 2565 // check textOutTest.null 2566 l = readFileToS("appendTextOutTest.null"); 2567 ck_assert_uint_eq(strlen(l),30); 2568 ck_assert_str_eq(l, "appended line\nappended line 2\n"); 2569 if (fileExists("appendTextOutTest.null")) { 2570 int R = rmAll("appendTextOutTest.null"); 2571 ck_assert_int_ne(R, 0); 2572 } 2573 // blank file name 2574 ck_assert(!appendFile(" ",l, strlen(l))); 2575 // read only path 2576 ck_assert(!appendFile("/nonExistingFile",l, strlen(l))); 2577 // NULL path 2578 ck_assert(!appendFile(NULL,l, strlen(l))); 2579 free(l); 2580 // NULL string 2581 ck_assert(!appendFile("a",NULL, 0)); 2582 2583 2584 END_TEST 2585 2586 2587 START_TEST(walkDirT) 2588 2589 char **l; 2590 2591 // existing directory 2592 l = walkDir("dirTest.null"); 2593 ck_assert_uint_eq(listLengthS(l),3); 2594 ck_assert_str_eq(l[0], "dirTest.null/one"); 2595 ck_assert_str_eq(l[1], "dirTest.null/two/four"); 2596 ck_assert_str_eq(l[2], "dirTest.null/two/three"); 2597 listFreeS(l); 2598 // empty path 2599 ck_assert_ptr_eq(walkDir(""), NULL); 2600 // non existing directory 2601 l = walkDir("nonExisting.null"); 2602 ck_assert(listIsEmptyS(l)); 2603 listFreeS(l); 2604 // NULL path 2605 ck_assert_ptr_eq(walkDir(NULL), NULL); 2606 2607 END_TEST 2608 2609 2610 START_TEST(walkDirDirT) 2611 2612 char **l; 2613 2614 // existing directory 2615 l = walkDirDir("dirTest.null"); 2616 ck_assert_uint_eq(listLengthS(l),2); 2617 ck_assert_str_eq(l[0], "dirTest.null/symlinkLoop"); 2618 ck_assert_str_eq(l[1], "dirTest.null/two"); 2619 listFreeS(l); 2620 // empty path 2621 ck_assert_ptr_eq(walkDirDir(""), NULL); 2622 // non existing directory 2623 l = walkDirDir("nonExisting.null"); 2624 ck_assert(listIsEmptyS(l)); 2625 listFreeS(l); 2626 // NULL path 2627 ck_assert_ptr_eq(walkDirDir(NULL), NULL); 2628 2629 END_TEST 2630 2631 2632 START_TEST(readDirT) 2633 2634 char **l; 2635 2636 // existing directory 2637 l = readDir("dirTest.null"); 2638 ck_assert_uint_eq(listLengthS(l),1); 2639 ck_assert_str_eq(l[0], "one"); 2640 listFreeS(l); 2641 // empty path 2642 ck_assert_ptr_eq(readDir(""), NULL); 2643 // non existing directory 2644 l = readDir("nonExisting.null"); 2645 ck_assert(listIsEmptyS(l)); 2646 listFreeS(l); 2647 // NULL path 2648 ck_assert_ptr_eq(readDir(NULL), NULL); 2649 2650 END_TEST 2651 2652 2653 START_TEST(readDirDirT) 2654 2655 char **l; 2656 2657 // existing directory 2658 l = readDirDir("dirTest.null"); 2659 ck_assert_uint_eq(listLengthS(l),2); 2660 ck_assert_str_eq(l[0], "symlinkLoop"); 2661 ck_assert_str_eq(l[1], "two"); 2662 listFreeS(l); 2663 // empty path 2664 ck_assert_ptr_eq(readDirDir(""), NULL); 2665 // non existing directory 2666 l = readDirDir("nonExisting.null"); 2667 ck_assert(listIsEmptyS(l)); 2668 listFreeS(l); 2669 // NULL path 2670 ck_assert_ptr_eq(readDirDir(NULL), NULL); 2671 2672 END_TEST 2673 2674 2675 START_TEST(walkDirAllT) 2676 2677 char **l; 2678 2679 // existing directory 2680 l = walkDirAll("dirTest.null"); 2681 ck_assert_uint_eq(listLengthS(l),5); 2682 ck_assert_str_eq(l[0], "dirTest.null/one"); 2683 ck_assert_str_eq(l[1], "dirTest.null/symlinkLoop"); 2684 ck_assert_str_eq(l[2], "dirTest.null/two"); 2685 ck_assert_str_eq(l[3], "dirTest.null/two/four"); 2686 ck_assert_str_eq(l[4], "dirTest.null/two/three"); 2687 listFreeS(l); 2688 // empty path 2689 ck_assert_ptr_eq(walkDirAll(""), NULL); 2690 // non existing directory 2691 l = walkDirAll("nonExisting.null"); 2692 ck_assert(listIsEmptyS(l)); 2693 listFreeS(l); 2694 // NULL path 2695 ck_assert_ptr_eq(walkDirAll(NULL), NULL); 2696 2697 END_TEST 2698 2699 2700 START_TEST(readDirAllT) 2701 2702 char **l; 2703 2704 // existing directory 2705 l = readDirAll("dirTest.null"); 2706 ck_assert_uint_eq(listLengthS(l),3); 2707 ck_assert_str_eq(l[0], "one"); 2708 ck_assert_str_eq(l[1], "symlinkLoop"); 2709 ck_assert_str_eq(l[2], "two"); 2710 listFreeS(l); 2711 // empty path 2712 ck_assert_ptr_eq(readDirAll(""), NULL); 2713 // non existing directory 2714 l = readDirAll("nonExisting.null"); 2715 ck_assert(listIsEmptyS(l)); 2716 listFreeS(l); 2717 // NULL path 2718 ck_assert_ptr_eq(readDirAll(NULL), NULL); 2719 2720 END_TEST 2721 2722 2723 START_TEST(mkdirParentsT) 2724 2725 // directory 2726 int R = rmAll("mkdirTest.null/null"); 2727 ck_assert_int_ne(R, 0); 2728 ck_assert_int_eq(mkdirParents("mkdirTest.null/null"),1); 2729 ck_assert_int_eq(mkdirParents("mkdirTest.null/null/"),1); 2730 // not allowed 2731 ck_assert_int_eq(mkdirParents("/usr/null"),0); 2732 ck_assert_int_eq(mkdirParents("/usr/null/null"),0); 2733 // empty path 2734 ck_assert_int_eq(mkdirParents(""),0); 2735 // NULL path 2736 ck_assert_int_eq(mkdirParents(NULL),0); 2737 2738 END_TEST 2739 2740 2741 START_TEST(rmAllT) 2742 2743 // directory 2744 int r = mkdirParents("rmAllTest.null/null"); 2745 ck_assert_int_ne(r, 0); 2746 ck_assert_int_eq(rmAll("rmAllTest.null"),1); 2747 // empty path 2748 ck_assert_int_eq(rmAll(""),0); 2749 // too little permissions 2750 ck_assert_int_eq(rmAll("/var/lock"),0); 2751 // NULL path 2752 ck_assert_int_eq(rmAll(NULL),0); 2753 2754 END_TEST 2755 2756 2757 START_TEST(copyT) 2758 2759 // file 2760 int R = rmAll("copyTest.null"); 2761 printf("%d\n",R); 2762 R = rmAll("copy2Test.null"); 2763 printf("%d\n",R); 2764 ck_assert_int_eq(copy("chmodTest.null", "copyTest.null"),1); 2765 ck_assert(fileExists("copyTest.null")); 2766 // too little permissions 2767 bool r = fileChmod("copyTest.null", 0); 2768 ck_assert(r); 2769 ck_assert_int_eq(copy("copyTest.null", "copy2Test.null"),0); 2770 r = fileChmod("copyTest.null", S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH); 2771 ck_assert(r); 2772 R = rmAll("copyTest.null"); 2773 ck_assert_int_ne(R, 0); 2774 // give dir another name 2775 ck_assert_int_eq(copy("dirTest.null", "copyTest.null"),1); 2776 // copy dir to non existing dir 2777 ck_assert_int_eq(copy("dirTest.null", "copyTest.null/we/"),1); 2778 // copy file to dir (wrong final slash in dst missing) 2779 ck_assert_int_eq(copy("chmodTest.null", "copyTest.null"),0); 2780 // copy file to dir (with final slash in dst) 2781 ck_assert_int_eq(copy("chmodTest.null", "copyTest.null/"),1); 2782 // copy content of source dir to new dst 2783 ck_assert_int_eq(copy("dirTest.null/", "copyTest.null/content"),1); 2784 char **l = walkDirAll("copyTest.null"); 2785 // copy results 2786 ck_assert_int_eq(listLengthS(l), 17); 2787 ck_assert_str_eq(l[0], "copyTest.null/chmodTest.null"); 2788 ck_assert_str_eq(l[1], "copyTest.null/content"); 2789 ck_assert_str_eq(l[2], "copyTest.null/content/one"); 2790 ck_assert_str_eq(l[3], "copyTest.null/content/two"); 2791 ck_assert_str_eq(l[4], "copyTest.null/content/two/four"); 2792 ck_assert_str_eq(l[5], "copyTest.null/content/two/three"); 2793 ck_assert_str_eq(l[6], "copyTest.null/dirTest.null"); 2794 ck_assert_str_eq(l[7], "copyTest.null/dirTest.null/one"); 2795 ck_assert_str_eq(l[8], "copyTest.null/dirTest.null/two"); 2796 ck_assert_str_eq(l[9], "copyTest.null/dirTest.null/two/four"); 2797 ck_assert_str_eq(l[10], "copyTest.null/dirTest.null/two/three"); 2798 ck_assert_str_eq(l[11], "copyTest.null/we"); 2799 ck_assert_str_eq(l[12], "copyTest.null/we/dirTest.null"); 2800 ck_assert_str_eq(l[13], "copyTest.null/we/dirTest.null/one"); 2801 ck_assert_str_eq(l[14], "copyTest.null/we/dirTest.null/two"); 2802 ck_assert_str_eq(l[15], "copyTest.null/we/dirTest.null/two/four"); 2803 ck_assert_str_eq(l[16], "copyTest.null/we/dirTest.null/two/three"); 2804 listFreeS(l); 2805 R = rmAll("copyTest.null"); 2806 ck_assert_int_ne(R, 0); 2807 // copy dir to read only destination, no mkdir 2808 ck_assert_int_eq(copy("mkdirTest.null/", "/newdir"),0); 2809 // copy dir to read only destination, new dir 2810 ck_assert_int_eq(copy("mkdirTest.null", "/newdir"),0); 2811 // non existing source 2812 ck_assert_int_eq(copy("nonExistingFile", "copyTest.null"),0); 2813 // empty path 2814 ck_assert_int_eq(copy("", "copyTest.null"),0); 2815 ck_assert(!fileExists("copyTest.null")); 2816 ck_assert_int_eq(copy("chmodTest.null", ""),0); 2817 ck_assert(!fileExists("copyTest.null")); 2818 // NULL path 2819 ck_assert_int_eq(copy(NULL, "copyTest.null"),0); 2820 ck_assert_int_eq(copy("chmodTest.null", NULL),0); 2821 ck_assert_int_eq(copy(NULL, NULL),0); 2822 2823 END_TEST 2824 2825 2826 START_TEST(shRenameT) 2827 2828 // regualar file 2829 ck_assert_int_eq(shRename("renameTest.null", "rename2Test.null"), 1); 2830 ck_assert_int_eq(shRename("rename2Test.null", "renameTest.null"), 1); 2831 // dir 2832 ck_assert_int_eq(shRename("mkdirTest.null", "rename2Test.null"), 1); 2833 ck_assert_int_eq(shRename("rename2Test.null", "mkdirTest.null"), 1); 2834 // non existing source 2835 ck_assert_int_eq(shRename("rename2Test.null", "renameTest.null"), 0); 2836 // already existing destination 2837 ck_assert_int_eq(shRename("mkdirTest.null", "renameTest.null"), 0); 2838 // blank paths 2839 ck_assert_int_eq(shRename(" ", "renameTest.null"), 0); 2840 ck_assert_int_eq(shRename("qwe", ""), 0); 2841 // NULL 2842 ck_assert_int_eq(shRename(NULL, "renameTest.null"), 0); 2843 ck_assert_int_eq(shRename("mkdirTest.null", NULL), 0); 2844 2845 END_TEST 2846 2847 2848 START_TEST(shMoveT) 2849 2850 // regualar file 2851 ck_assert_int_eq(shMove("renameTest.null", "rename2Test.null"), 1); 2852 ck_assert_int_eq(shMove("rename2Test.null", "renameTest.null"), 1); 2853 // dir 2854 ck_assert_int_eq(shMove("mkdirTest.null", "rename2Test.null"), 1); 2855 ck_assert_int_eq(shMove("rename2Test.null/mkdirTest.null", "."), 1); 2856 int R = rmAll("rename2Test.null"); 2857 ck_assert_int_ne(R, 0); 2858 // non existing source 2859 ck_assert_int_eq(shMove("rename2Test.null", "renameTest.null"), 0); 2860 // already existing destination 2861 ck_assert_int_eq(shMove("mkdirTest.null", "renameTest.null"), 0); 2862 // blank paths 2863 ck_assert_int_eq(shMove(" ", "renameTest.null"), 0); 2864 ck_assert_int_eq(shMove("qwe", ""), 0); 2865 // NULL 2866 ck_assert_int_eq(shMove(NULL, "renameTest.null"), 0); 2867 ck_assert_int_eq(shMove("mkdirTest.null", NULL), 0); 2868 2869 END_TEST 2870 2871 2872 START_TEST(setSoftwareRandomT) 2873 2874 // open /dev/urandom 2875 setSoftwareRandom(); 2876 randomUrandomClose(); 2877 2878 END_TEST 2879 2880 2881 START_TEST(setHardwareRandomT) 2882 2883 // open /dev/urandom 2884 setHardwareRandom(); 2885 setSoftwareRandom(); 2886 randomUrandomClose(); 2887 2888 END_TEST 2889 2890 2891 START_TEST(randomOpenCloseT) 2892 2893 int r; 2894 2895 // open /dev/urandom 2896 r = randomUrandomOpen(); 2897 ck_assert_int_eq(r,1); 2898 randomUrandomClose(); 2899 2900 END_TEST 2901 2902 2903 START_TEST(randomWordT) 2904 2905 // get random value 2906 int r = randomUrandomOpen(); 2907 ck_assert_int_eq(r,1); 2908 ck_assert_int_ne(randomWord(),0); 2909 randomUrandomClose(); 2910 // error when /dev/urandom is closed 2911 ck_assert_int_eq(randomWord(),0); 2912 2913 END_TEST 2914 2915 2916 START_TEST(randomWordFromHWT) 2917 2918 // get random value 2919 setHardwareRandom(); 2920 uint64_t r = randomWordFromHW(); 2921 printf("%"PRIu64"\n", r); 2922 2923 // string 2924 char *s = randomS(10); 2925 ck_assert_ptr_ne(s, NULL); 2926 free(s); 2927 setSoftwareRandom(); 2928 randomUrandomClose(); 2929 2930 END_TEST 2931 2932 2933 START_TEST(randomChoiceT) 2934 2935 // get random value 2936 int r = randomUrandomOpen(); 2937 ck_assert_int_eq(r,1); 2938 ck_assert_int_ne(randomChoice(10),10); 2939 // invalid range (0) 2940 ck_assert_int_eq(randomChoice(0),0); 2941 randomUrandomClose(); 2942 // error when /dev/urandom is closed 2943 ck_assert_int_eq(randomChoice(10),10); 2944 2945 END_TEST 2946 2947 2948 START_TEST(randomST) 2949 2950 // get random string 2951 char *s = randomS(10); 2952 ck_assert_ptr_ne(s, NULL); 2953 free(s); 2954 // invalid length (0) 2955 ck_assert_ptr_eq(randomS(0), NULL); 2956 2957 END_TEST 2958 2959 2960 START_TEST(bRandomST) 2961 2962 char s[11]; 2963 char *r; 2964 // get random string 2965 r = bRandomS(s, 10); 2966 ck_assert_ptr_ne(r, NULL); 2967 // invalid length (0) 2968 ck_assert_ptr_eq(bRandomS(s, 0), NULL); 2969 // NULL 2970 ck_assert_ptr_eq(bRandomS(NULL, 10), NULL); 2971 2972 END_TEST 2973 2974 2975 START_TEST(randomAlphaNumST) 2976 2977 // get random string 2978 char *s = randomAlphaNumS(10); 2979 ck_assert_ptr_ne(s, NULL); 2980 free(s); 2981 // invalid length (0) 2982 ck_assert_ptr_eq(randomAlphaNumS(0), NULL); 2983 2984 END_TEST 2985 2986 2987 START_TEST(bRandomAlphaNumST) 2988 2989 char s[11]; 2990 char *r; 2991 // get random string 2992 r = bRandomAlphaNumS(s, 10); 2993 ck_assert_ptr_ne(r, NULL); 2994 // invalid length (0) 2995 ck_assert_ptr_eq(bRandomAlphaNumS(s, 0), NULL); 2996 // NULL 2997 ck_assert_ptr_eq(bRandomAlphaNumS(NULL, 10), NULL); 2998 2999 END_TEST 3000 3001 3002 START_TEST(readST) 3003 3004 char *s = readS(); 3005 ck_assert_str_eq(s, "aaaaaaaaaaaaaaaaaaaa"); 3006 free(s); 3007 3008 END_TEST 3009 3010 3011 START_TEST(bLReadST) 3012 3013 char s[21]; 3014 char *r = null; 3015 3016 r = bLReadS(s, 21); 3017 ck_assert_ptr_eq(r, s); 3018 ck_assert_str_eq(s, "aaaaaaaaaaaaaaaaaaaa"); 3019 // size 1 3020 r = bLReadS(s, 1); 3021 ck_assert_ptr_eq(r, null); 3022 // NULL 3023 r = bLReadS(NULL, 2); 3024 ck_assert_ptr_eq(r, null); 3025 3026 END_TEST 3027 3028 3029 START_TEST(readPasswordST) 3030 3031 char *r = readPasswordS(); 3032 ck_assert_str_eq(r, "*****"); 3033 free(r); 3034 3035 END_TEST 3036 3037 3038 START_TEST(zeroST) 3039 3040 bool r; 3041 3042 // clear string 3043 char *s = strdup("zero"); 3044 r = zeroS(s); 3045 ck_assert_str_eq(s, ""); 3046 ck_assert(r); 3047 free(s); 3048 3049 // null string 3050 r = zeroS(null); 3051 ck_assert(!r); 3052 3053 END_TEST 3054 3055 3056 START_TEST(zeroBufT) 3057 3058 bool r; 3059 3060 // clear string 3061 char *s = strdup("zero"); 3062 r = zeroBuf(s, strlen(s)); 3063 ck_assert_str_eq(s, ""); 3064 ck_assert(r); 3065 free(s); 3066 3067 // 0 length 3068 r = zeroBuf(s, 0); 3069 ck_assert(!r); 3070 3071 // null string 3072 r = zeroBuf(null, 1); 3073 ck_assert(!r); 3074 3075 END_TEST 3076 3077 3078 START_TEST(memdupT) 3079 3080 char *r; 3081 3082 // clear string 3083 r = memdup("memdup", sizeof("memdup")); 3084 ck_assert_str_eq(r, "memdup"); 3085 free(r); 3086 3087 // 0 length 3088 r = memdup("wef", 0); 3089 ck_assert_ptr_eq(r, null); 3090 3091 // null string 3092 r = memdup(null, 1); 3093 ck_assert_ptr_eq(r, null); 3094 3095 END_TEST 3096 3097 3098 START_TEST(readEnterT) 3099 3100 readEnter(); 3101 3102 END_TEST 3103 3104 3105 START_TEST(readLineT) 3106 3107 FILE *fp; 3108 char *s; 3109 3110 // file with data 3111 fp = fopen("textTest.null", "r"); 3112 s = readLine(fp); 3113 fclose(fp); 3114 ck_assert_str_eq(s, "LINE 1"); 3115 free(s); 3116 // empty file or end of stream 3117 fp = fopen("chmodTest.null", "r"); 3118 s = readLine(fp); 3119 ck_assert_ptr_ne(s, NULL); 3120 ck_assert(isEmptyS(s)); 3121 free(s); 3122 fclose(fp); 3123 // NULL stream 3124 ck_assert_ptr_eq(readLine(NULL), NULL); 3125 3126 3127 END_TEST 3128 3129 3130 START_TEST(dupST) 3131 3132 // string 3133 char *s = dupS("sheepy"); 3134 ck_assert_str_eq(s, "sheepy"); 3135 free(s); 3136 // NULL string 3137 ck_assert_ptr_eq(dupS(NULL), NULL); 3138 3139 END_TEST 3140 3141 3142 START_TEST(shPrintfST) 3143 3144 shPrintfS("\nWEE %d\n", 234); 3145 shPrintfS(NULL); 3146 3147 END_TEST 3148 3149 3150 START_TEST(shEprintfT) 3151 3152 shEPrintfS("\nWEE %d\n", 234); 3153 shEPrintfS(NULL); 3154 3155 END_TEST 3156 3157 START_TEST(freeManyST) 3158 3159 // not possible to know if a pointer is already freed 3160 char *s1 = emptySF(); 3161 char *s2 = emptySF(); 3162 freeManyS(s1, s2); 3163 3164 END_TEST 3165 3166 3167 START_TEST(logNFreeT) 3168 3169 char *s = strdup("libsheepy"); 3170 logNFree(s); 3171 logNFree(NULL); 3172 3173 END_TEST 3174 3175 3176 START_TEST(loghexT) 3177 3178 char *b = "abc"; 3179 3180 // print hex 3181 loghex(b, strlen(b)+1); 3182 3183 // size zero 3184 loghex(b, 0); 3185 3186 // null buf 3187 loghex(null, 1); 3188 3189 END_TEST 3190 3191 3192 START_TEST(toHexST) 3193 3194 char *b = "abc"; 3195 char *r; 3196 3197 // print hex 3198 r = toHexS(b, strlen(b)+1); 3199 ck_assert_str_eq(r, "0x61, 0x62, 0x63, 0x00"); 3200 free(r); 3201 3202 // size zero 3203 r = toHexS(b, 0); 3204 ck_assert_ptr_eq(r, null); 3205 3206 // null buf 3207 r = toHexS(null, 1); 3208 ck_assert_ptr_eq(r, null); 3209 3210 3211 END_TEST 3212 3213 3214 START_TEST(toHexSepST) 3215 3216 char *b = "abc"; 3217 char *r; 3218 3219 // print hex 3220 r = toHexSepS(b, strlen(b)+1, ","); 3221 ck_assert_str_eq(r, "0x61,0x62,0x63,0x00"); 3222 free(r); 3223 3224 // size zero 3225 r = toHexSepS(b, 0, ""); 3226 ck_assert_ptr_eq(r, null); 3227 3228 // null sep 3229 r = toHexSepS(b, 1, null); 3230 ck_assert_ptr_eq(r, null); 3231 3232 // null buf 3233 r = toHexSepS(null, 1, ""); 3234 ck_assert_ptr_eq(r, null); 3235 3236 END_TEST 3237 3238 3239 START_TEST(toHexHeadSepST) 3240 3241 char *b = "abc"; 3242 char *r; 3243 3244 // print hex 3245 r = toHexHeadSepS(b, strlen(b)+1, "x", ","); 3246 ck_assert_str_eq(r, "x61,x62,x63,x00"); 3247 free(r); 3248 3249 // size zero 3250 r = toHexHeadSepS(b, 0, "", ""); 3251 ck_assert_ptr_eq(r, null); 3252 3253 // null head 3254 r = toHexHeadSepS(b, 1, null, ""); 3255 ck_assert_ptr_eq(r, null); 3256 3257 // null sep 3258 r = toHexHeadSepS(b, 1, "", null); 3259 ck_assert_ptr_eq(r, null); 3260 3261 // null buf 3262 r = toHexHeadSepS(null, 1, "", ""); 3263 ck_assert_ptr_eq(r, null); 3264 3265 END_TEST 3266 3267 3268 START_TEST(strCpyT) 3269 3270 char s[1024] = init0Var; 3271 char *r; 3272 3273 // copy string 3274 r = strCpy(s, "lib"); 3275 ck_assert_ptr_eq(r, s); 3276 ck_assert_str_eq(s, "lib"); 3277 // NULL 3278 s[0] = 0; 3279 r = strCpy(s, NULL); 3280 ck_assert_ptr_eq(r, null); 3281 ck_assert_str_eq(s, ""); 3282 r = strCpy(NULL, "lib"); 3283 ck_assert_ptr_eq(r, null); 3284 3285 END_TEST 3286 3287 3288 START_TEST(strNCpyT) 3289 3290 char s[1024] = init0Var; 3291 char *r; 3292 3293 // copy string 3294 r = strNCpy(s, "lib", 4); 3295 ck_assert_ptr_ne(r, null); 3296 ck_assert_str_eq(s, "lib"); 3297 3298 // size 0 3299 r = strNCpy(s, "AAA", 0); 3300 ck_assert_ptr_ne(r, null); 3301 ck_assert_str_eq(s, "lib"); 3302 3303 // NULL 3304 s[0] = 0; 3305 r = strNCpy(s, NULL, 10); 3306 ck_assert_ptr_eq(r, null); 3307 ck_assert_str_eq(s, ""); 3308 ck_assert_ptr_eq(strNCpy(NULL, "lib", 1), NULL); 3309 3310 END_TEST 3311 3312 3313 START_TEST(strLCpyT) 3314 3315 char s[1024]; 3316 char *r = null; 3317 3318 // copy string 3319 r = strLCpy(s, 100, "lib"); 3320 ck_assert_ptr_eq(r, s); 3321 ck_assert_str_eq(s, "lib"); 3322 // truncate src 3323 s[0] = 0; 3324 s[1] = 0; 3325 s[2] = 0; 3326 r = strLCpy(s, 3, "lib"); 3327 ck_assert_ptr_eq(r, s); 3328 ck_assert_str_eq(s, "li"); 3329 s[0] = 'a'; 3330 s[1] = 'a'; 3331 s[2] = 'a'; 3332 s[3] = 0; 3333 r = strLCpy(s, 3, "lib"); 3334 ck_assert_ptr_eq(r, s); 3335 ck_assert_str_eq(s, "li"); 3336 // size 0 - no change in s 3337 r = strLCpy(s, 0, "libsheepy"); 3338 ck_assert_ptr_eq(r, s); 3339 ck_assert_str_eq(s, "li"); 3340 // NULL 3341 s[0] = 0; 3342 r = strLCpy(s, 1, NULL); 3343 ck_assert_ptr_eq(r, null); 3344 ck_assert_str_eq(s, ""); 3345 r = strLCpy(NULL,1, "lib"); 3346 ck_assert_ptr_eq(r, null); 3347 3348 END_TEST 3349 3350 3351 START_TEST(strCatT) 3352 3353 char s[1024]; 3354 char *r = null; 3355 3356 // append string 3357 r = strCpy(s, "lib"); 3358 ck_assert_ptr_eq(r, s); 3359 r = strCat(s, "sheepy"); 3360 ck_assert_ptr_eq(r, s); 3361 ck_assert_str_eq(s, "libsheepy"); 3362 // empty string2 3363 r = strCat(s, ""); 3364 ck_assert_ptr_eq(r, s); 3365 ck_assert_str_eq(s, "libsheepy"); 3366 // NULL string2 3367 r = strCat(s, NULL); 3368 ck_assert_ptr_eq(r, null); 3369 ck_assert_str_eq(s, "libsheepy"); 3370 // NULL parameter 3371 r = strCat(NULL, "ad"); 3372 ck_assert_ptr_eq(r, null); 3373 3374 END_TEST 3375 3376 3377 START_TEST(strNCatT) 3378 3379 char s[1024]; 3380 char *r = null; 3381 3382 // append string 3383 r = strCpy(s, "lib"); 3384 ck_assert_ptr_eq(r, s); 3385 r = strNCat(s, "sheepy", 100); 3386 ck_assert_ptr_eq(r, s); 3387 ck_assert_str_eq(s, "libsheepy"); 3388 // empty string2 3389 r = strNCat(s, "", 10); 3390 ck_assert_ptr_eq(r, s); 3391 ck_assert_str_eq(s, "libsheepy"); 3392 // truncate src 3393 s[0] = 'a'; 3394 s[1] = 'a'; 3395 s[2] = 'a'; 3396 s[3] = 'a'; 3397 s[4] = 'a'; 3398 s[5] = 'a'; 3399 r = strCpy(s, "lib"); 3400 ck_assert_ptr_eq(r, s); 3401 ck_assert_str_eq(s, "lib"); 3402 r = strNCat(s, "sheepy", 2); 3403 ck_assert_ptr_eq(r, s); 3404 ck_assert_str_eq(s, "libsh"); 3405 // NULL string2 3406 r = strNCat(s, NULL, 1); 3407 ck_assert_ptr_eq(r, null); 3408 ck_assert_str_eq(s, "libsh"); 3409 // NULL parameter 3410 r = strNCat(NULL, "ad", 1); 3411 ck_assert_ptr_eq(r, null); 3412 3413 END_TEST 3414 3415 3416 START_TEST(strLCatT) 3417 3418 char s[1024]; 3419 char *r = null; 3420 3421 // append string 3422 r = strCpy(s, "lib"); 3423 ck_assert_ptr_eq(r, s); 3424 r = strLCat(s, 100, "sheepy"); 3425 ck_assert_ptr_eq(r, s); 3426 ck_assert_str_eq(s, "libsheepy"); 3427 // empty string2 3428 r = strLCat(s, 20, ""); 3429 ck_assert_ptr_eq(r, s); 3430 ck_assert_str_eq(s, "libsheepy"); 3431 // s strlen bigger than s size - keep s as it is 3432 r = strLCat(s, 6, "qwqwe"); 3433 ck_assert_ptr_eq(r, s); 3434 ck_assert_str_eq(s, "libsheepy"); 3435 // truncate src 3436 s[0] = 'a'; 3437 s[1] = 'a'; 3438 s[2] = 'a'; 3439 s[3] = 'a'; 3440 s[4] = 'a'; 3441 s[5] = 'a'; 3442 r = strCpy(s, "lib"); 3443 ck_assert_ptr_eq(r, s); 3444 ck_assert_str_eq(s, "lib"); 3445 r = strLNCat(s,100, "sheepy", 2); 3446 ck_assert_ptr_eq(r, s); 3447 ck_assert_str_eq(s, "libsh"); 3448 // truncate dst 3449 s[0] = 'a'; 3450 s[1] = 'a'; 3451 s[2] = 'a'; 3452 s[3] = 'a'; 3453 s[4] = 'a'; 3454 s[5] = 'a'; 3455 r = strCpy(s, "lib"); 3456 ck_assert_ptr_eq(r, s); 3457 ck_assert_str_eq(s, "lib"); 3458 r = strLCat(s, 6, "sheepy"); 3459 ck_assert_ptr_eq(r, s); 3460 ck_assert_str_eq(s, "libsh"); 3461 // NULL string2 3462 r = strLCat(s, 1, NULL); 3463 ck_assert_ptr_eq(r, null); 3464 ck_assert_str_eq(s, "libsh"); 3465 // NULL parameter 3466 r = strLCat(NULL, 1, "ad"); 3467 ck_assert_ptr_eq(r, null); 3468 3469 END_TEST 3470 3471 3472 START_TEST(strLNCatT) 3473 3474 char s[1024]; 3475 char *r = null; 3476 3477 // append string 3478 r = strCpy(s, "lib"); 3479 ck_assert_ptr_eq(r, s); 3480 r = strLNCat(s, 100, "sheepy", 100); 3481 ck_assert_ptr_eq(r, s); 3482 ck_assert_str_eq(s, "libsheepy"); 3483 // empty string2 3484 r = strLNCat(s, 20, "", 10); 3485 ck_assert_ptr_eq(r, s); 3486 ck_assert_str_eq(s, "libsheepy"); 3487 // s strlen bigger than s size - keep s as it is 3488 r = strLNCat(s, 6, "qwqwe", 1); 3489 ck_assert_ptr_eq(r, s); 3490 ck_assert_str_eq(s, "libsheepy"); 3491 // truncate dst 3492 s[0] = 'a'; 3493 s[1] = 'a'; 3494 s[2] = 'a'; 3495 s[3] = 'a'; 3496 s[4] = 'a'; 3497 s[5] = 'a'; 3498 r = strCpy(s, "lib"); 3499 ck_assert_ptr_eq(r, s); 3500 ck_assert_str_eq(s, "lib"); 3501 r = strLNCat(s, 6, "sheepy", 4); 3502 ck_assert_ptr_eq(r, s); 3503 ck_assert_str_eq(s, "libsh"); 3504 // NULL string2 3505 r = strLNCat(s, 1, NULL, 1); 3506 ck_assert_ptr_eq(r, null); 3507 ck_assert_str_eq(s, "libsh"); 3508 // NULL parameter 3509 r = strLNCat(NULL, 1, "ad", 1); 3510 ck_assert_ptr_eq(r, null); 3511 3512 END_TEST 3513 3514 3515 START_TEST(catST) 3516 3517 char *s; 3518 char *r; 3519 3520 // cat strings 3521 s = strdup("#@#"); 3522 r = catS(s,"asd"); 3523 ck_assert_str_eq(r, "#@#asd"); 3524 free(s); 3525 free(r); 3526 // empty string 3527 r = catS(""); 3528 ck_assert(isEmptyS(r)); 3529 free(r); 3530 // cat empty string with string 3531 r = catS("", "asd"); 3532 ck_assert_str_eq(r, "asd"); 3533 free(r); 3534 3535 END_TEST 3536 3537 3538 START_TEST(iCatST) 3539 3540 char *s; 3541 char r[100]; 3542 char *r2 = null; 3543 3544 // cat strings 3545 s = strdup("#@#"); 3546 r2 = iCatS(r, s,"asd"); 3547 ck_assert_ptr_eq(r2, r); 3548 ck_assert_str_eq(r, "#@#asd"); 3549 free(s); 3550 // empty string 3551 r2 = iCatS(r, ""); 3552 ck_assert_ptr_eq(r2, r); 3553 ck_assert(isEmptyS(r)); 3554 // cat empty string with string 3555 r2 = iCatS(r, "", "asd"); 3556 ck_assert_ptr_eq(r2, r); 3557 ck_assert_str_eq(r, "asd"); 3558 // NULL 3559 r2 = iCatS(NULL, "wef","wef"); 3560 ck_assert_ptr_eq(r2, null); 3561 3562 END_TEST 3563 3564 3565 START_TEST(bLCatST) 3566 3567 char *s; 3568 char r[100]; 3569 char *r2 = null; 3570 3571 // cat strings 3572 s = strdup("#@#"); 3573 r2 = bLCatS(r, sizeof r, s,"asd"); 3574 ck_assert_ptr_eq(r2, r); 3575 ck_assert_str_eq(r, "#@#asd"); 3576 // shorter buffer 3577 r2 = bLCatS(r, 3, s,"asd"); 3578 ck_assert_ptr_eq(r2, r); 3579 ck_assert_str_eq(r, "#@"); 3580 free(s); 3581 // empty string 3582 r2 = bLCatS(r, sizeof r, ""); 3583 ck_assert_ptr_eq(r2, r); 3584 ck_assert(isEmptyS(r)); 3585 // cat empty string with string 3586 r2 = bLCatS(r, sizeof r, "", "asd"); 3587 ck_assert_ptr_eq(r2, r); 3588 ck_assert_str_eq(r, "asd"); 3589 // size 0 - no change in r 3590 r2 = bLCatS(r, 0, "", "asd"); 3591 ck_assert_ptr_eq(r2, r); 3592 ck_assert_str_eq(r, "asd"); 3593 // NULL 3594 r2 = bLCatS(NULL, sizeof r, "wef","wef"); 3595 ck_assert_ptr_eq(r2, null); 3596 3597 END_TEST 3598 3599 3600 START_TEST(formatST) 3601 3602 char *s; 3603 char r[128] = init0Var; 3604 3605 // format 3606 s = formatS("sheepy is num %d", 1); 3607 ck_assert_str_eq(s, "sheepy is num 1"); 3608 free(s); 3609 // NULL 3610 ck_assert_ptr_eq(formatS(NULL), NULL); 3611 3612 // bFormatS 3613 s = bFormatS(r, "sheepy is num %d", 1); 3614 ck_assert_str_eq(s, "sheepy is num 1"); 3615 // NULL 3616 ck_assert_ptr_eq(bFormatS(r,NULL), NULL); 3617 ck_assert_ptr_eq(bFormatS(NULL,"ojoi"), NULL); 3618 3619 // bLFormatS 3620 s = bLFormatS(r, sizeof(r), "sheepy is num %d", 1); 3621 ck_assert_str_eq(s, "sheepy is num 1"); 3622 // shorter buffer 3623 s = bLFormatS(r, 7, "sheepy is num %d", 1); 3624 ck_assert_str_eq(s, "sheepy"); 3625 // buffer size 0 3626 s = bLFormatS(r, 0, "sheepy is num %d", 1); 3627 ck_assert_str_eq(s, "sheepy"); 3628 // NULL 3629 ck_assert_ptr_eq(bLFormatS(r,1,NULL), NULL); 3630 ck_assert_ptr_eq(bLFormatS(NULL,1,"ojoi"), NULL); 3631 3632 END_TEST 3633 3634 3635 START_TEST(appendST) 3636 3637 char *s; 3638 3639 // append string 3640 s = appendS("lib", "sheepy"); 3641 ck_assert_str_eq(s, "libsheepy"); 3642 free(s); 3643 // empty string2 3644 s = appendS("libsheepy", ""); 3645 ck_assert_str_eq(s, "libsheepy"); 3646 free(s); 3647 // NULL string2 3648 s = appendS("libsheepy", NULL); 3649 ck_assert_str_eq(s, "libsheepy"); 3650 free(s); 3651 // NULL string 3652 s = appendS(NULL, "ad"); 3653 ck_assert_ptr_eq(s, NULL); 3654 3655 END_TEST 3656 3657 3658 START_TEST(appendCharST) 3659 3660 char *s; 3661 3662 // append string 3663 s = appendCharS("lib", 'C'); 3664 ck_assert_str_eq(s, "libC"); 3665 free(s); 3666 // empty string2 3667 s = appendCharS("libsheepy", 0); 3668 ck_assert_str_eq(s, "libsheepy"); 3669 free(s); 3670 // NULL string 3671 s = appendCharS(NULL, 'C'); 3672 ck_assert_ptr_eq(s, NULL); 3673 3674 END_TEST 3675 3676 3677 START_TEST(appendSCharT) 3678 3679 char *s; 3680 3681 // append string 3682 s = appendSChar('l', "sheepy"); 3683 ck_assert_str_eq(s, "lsheepy"); 3684 free(s); 3685 // empty string2 3686 s = appendSChar('l', ""); 3687 ck_assert_str_eq(s, "l"); 3688 free(s); 3689 // NULL string2 3690 s = appendSChar('l', NULL); 3691 ck_assert_str_eq(s, "l"); 3692 free(s); 3693 3694 END_TEST 3695 3696 3697 START_TEST(iAppendST) 3698 3699 char *s; 3700 char *r = null; 3701 3702 // append string 3703 s = strdup("lib"); 3704 r = iAppendS(&s, "sheepy"); 3705 ck_assert_ptr_eq(r, s); 3706 ck_assert_str_eq(s, "libsheepy"); 3707 // empty string2 3708 r = iAppendS(&s, ""); 3709 ck_assert_ptr_eq(r, s); 3710 ck_assert_str_eq(s, "libsheepy"); 3711 // NULL string2 3712 r = iAppendS(&s, NULL); 3713 ck_assert_ptr_eq(r, s); 3714 ck_assert_str_eq(s, "libsheepy"); 3715 free(s); 3716 // NULL string 3717 s = NULL; 3718 r = iAppendS(&s, "ad"); 3719 ck_assert_ptr_eq(r, s); 3720 ck_assert_str_eq(s, "ad"); 3721 free(s); 3722 // NULL parameter 3723 r = iAppendS(NULL, "ad"); 3724 ck_assert_ptr_eq(r, null); 3725 3726 END_TEST 3727 3728 3729 START_TEST(iAppendCharST) 3730 3731 char *s; 3732 char *r = null; 3733 3734 // append string 3735 s = strdup("lib"); 3736 r = iAppendCharS(&s, 'C'); 3737 ck_assert_ptr_eq(r, s); 3738 ck_assert_str_eq(s, "libC"); 3739 // empty string2 3740 r = iAppendCharS(&s, 0); 3741 ck_assert_ptr_eq(r, s); 3742 ck_assert_str_eq(s, "libC"); 3743 free(s); 3744 // NULL string 3745 s = NULL; 3746 r = iAppendCharS(&s, 'C'); 3747 ck_assert_ptr_eq(r, s); 3748 ck_assert_str_eq(s, "C"); 3749 free(s); 3750 // NULL parameter 3751 r = iAppendCharS(NULL, 'C'); 3752 ck_assert_ptr_eq(r, null); 3753 3754 END_TEST 3755 3756 3757 START_TEST(iAppendNFreeST) 3758 3759 char *s; 3760 char *r = null; 3761 3762 // append string 3763 s = strdup("lib"); 3764 r = iAppendNFreeS(&s, strdup("sheepy")); 3765 ck_assert_ptr_eq(r, s); 3766 ck_assert_str_eq(s, "libsheepy"); 3767 // empty string2 3768 r = iAppendNFreeS(&s, strdup("")); 3769 ck_assert_ptr_eq(r, s); 3770 ck_assert_str_eq(s, "libsheepy"); 3771 // NULL string2 3772 r = iAppendNFreeS(&s, NULL); 3773 ck_assert_ptr_eq(r, s); 3774 ck_assert_str_eq(s, "libsheepy"); 3775 free(s); 3776 // NULL string 3777 s = NULL; 3778 r = iAppendNFreeS(&s, strdup("ad")); 3779 ck_assert_ptr_eq(r, s); 3780 ck_assert_str_eq(s, "ad"); 3781 free(s); 3782 // NULL parameter 3783 s = strdup("ad"); 3784 r = iAppendNFreeS(NULL, s); 3785 ck_assert_ptr_eq(r, null); 3786 free(s); 3787 3788 END_TEST 3789 3790 3791 START_TEST(iAppendManyST) 3792 3793 char *s; 3794 char *r = null; 3795 3796 // append string 3797 s = strdup("lib"); 3798 r = iAppendManyS(&s, "sheepy","2"); 3799 ck_assert_ptr_eq(r, s); 3800 ck_assert_str_eq(s, "libsheepy2"); 3801 // empty string2 3802 r = iAppendManyS(&s, "", ""); 3803 ck_assert_ptr_eq(r, s); 3804 ck_assert_str_eq(s, "libsheepy2"); 3805 // NULL string2 3806 r = iAppendManyS(&s, "a", NULL); 3807 ck_assert_ptr_eq(r, s); 3808 ck_assert_str_eq(s, "libsheepy2a"); 3809 //not allowed - iAppendManyS(&s, NULL); 3810 free(s); 3811 // NULL string (allocate) 3812 s = NULL; 3813 r = iAppendManyS(&s, "ad", ""); 3814 ck_assert_ptr_eq(r, s); 3815 ck_assert_str_eq(s, "ad"); 3816 free(s); 3817 // NULL parameter 3818 r = iAppendManyS(NULL, "ad", ""); 3819 ck_assert_ptr_eq(r, null); 3820 3821 END_TEST 3822 3823 3824 START_TEST(bAppendManyST) 3825 3826 char s[100]; 3827 char *r = null; 3828 3829 // append string 3830 strcpy(s, "lib"); 3831 r = bAppendManyS(s, "sheepy","2"); 3832 ck_assert_ptr_eq(r, s); 3833 ck_assert_str_eq(s, "libsheepy2"); 3834 // empty string2 3835 r = bAppendManyS(s, "", ""); 3836 ck_assert_ptr_eq(r, s); 3837 ck_assert_str_eq(s, "libsheepy2"); 3838 // NULL string2 3839 r = bAppendManyS(s, "a", NULL); 3840 ck_assert_ptr_eq(r, s); 3841 ck_assert_str_eq(s, "libsheepy2a"); 3842 //not allowed - bAppendManyS(s, NULL); 3843 // NULL parameter 3844 r = bAppendManyS(NULL, "ad", ""); 3845 ck_assert_ptr_eq(r, null); 3846 3847 END_TEST 3848 3849 3850 START_TEST(bLAppendManyST) 3851 3852 char s[100]; 3853 char *r = null; 3854 3855 // append string 3856 strcpy(s, "lib"); 3857 r = bLAppendManyS(s, sizeof s, "sheepy","2"); 3858 ck_assert_ptr_eq(r, s); 3859 ck_assert_str_eq(s, "libsheepy2"); 3860 // shorter buffer 3861 strcpy(s, "lib"); 3862 r = bLAppendManyS(s, 5, "sheepy","2"); 3863 ck_assert_ptr_eq(r, s); 3864 ck_assert_str_eq(s, "libs"); 3865 // empty string2 3866 r = bLAppendManyS(s, sizeof s, "", ""); 3867 ck_assert_ptr_eq(r, s); 3868 ck_assert_str_eq(s, "libs"); 3869 // NULL string2 3870 r = bLAppendManyS(s, sizeof s, "a", NULL); 3871 ck_assert_ptr_eq(r, s); 3872 ck_assert_str_eq(s, "libsa"); 3873 // size 0 - no change 3874 r = bLAppendManyS(s, 0, "a", NULL); 3875 ck_assert_ptr_eq(r, s); 3876 ck_assert_str_eq(s, "libsa"); 3877 //not allowed - bLAppendManyS(s, sizeof s, NULL); 3878 // NULL parameter 3879 r = bLAppendManyS(NULL, sizeof s, "ad", ""); 3880 ck_assert_ptr_eq(r, null); 3881 3882 END_TEST 3883 3884 3885 START_TEST(prependST) 3886 3887 char *s; 3888 3889 s = prependS("sheepy", "lib"); 3890 ck_assert_str_eq(s, "libsheepy"); 3891 free(s); 3892 3893 END_TEST 3894 3895 3896 START_TEST(prependCharST) 3897 3898 char *s; 3899 3900 s = prependCharS("sheepy", 'l'); 3901 ck_assert_str_eq(s, "lsheepy"); 3902 free(s); 3903 3904 END_TEST 3905 3906 3907 START_TEST(prependSCharT) 3908 3909 char *s; 3910 3911 s = prependSChar('C', "lib"); 3912 ck_assert_str_eq(s, "libC"); 3913 free(s); 3914 3915 END_TEST 3916 3917 3918 START_TEST(iPrependST) 3919 3920 char *s; 3921 char *r = null; 3922 3923 // append string 3924 s = strdup("lib"); 3925 r = iPrependS(&s, "sheepy"); 3926 ck_assert_ptr_eq(r, s); 3927 ck_assert_str_eq(s, "sheepylib"); 3928 // empty string2 3929 r = iPrependS(&s, ""); 3930 ck_assert_ptr_eq(r, s); 3931 ck_assert_str_eq(s, "sheepylib"); 3932 // NULL string2 3933 r = iPrependS(&s, NULL); 3934 ck_assert_ptr_eq(r, s); 3935 ck_assert_str_eq(s, "sheepylib"); 3936 free(s); 3937 // NULL string 3938 s = NULL; 3939 r = iPrependS(&s, "ad"); 3940 ck_assert_ptr_eq(r, s); 3941 ck_assert_str_eq(s, "ad"); 3942 free(s); 3943 // NULL parameter 3944 r = iPrependS(NULL, "ad"); 3945 ck_assert_ptr_eq(r, null); 3946 3947 END_TEST 3948 3949 3950 START_TEST(iPrependCharST) 3951 3952 char *s; 3953 char *r = null; 3954 3955 // append string 3956 s = strdup("lib"); 3957 r = iPrependCharS(&s, 'C'); 3958 ck_assert_ptr_eq(r, s); 3959 ck_assert_str_eq(s, "Clib"); 3960 // empty string2 3961 r = iPrependCharS(&s, 0); 3962 ck_assert_ptr_eq(r, s); 3963 ck_assert_str_eq(s, "Clib"); 3964 free(s); 3965 // NULL string 3966 s = NULL; 3967 r = iPrependCharS(&s, 'C'); 3968 ck_assert_ptr_eq(r, s); 3969 ck_assert_str_eq(s, "C"); 3970 free(s); 3971 // NULL parameter 3972 r = iPrependCharS(NULL, 'a'); 3973 ck_assert_ptr_eq(r, null); 3974 3975 END_TEST 3976 3977 3978 START_TEST(iPrependNFreeST) 3979 3980 char *s; 3981 char *r = null; 3982 3983 // append string 3984 s = strdup("lib"); 3985 r = iPrependNFreeS(&s, strdup("sheepy")); 3986 ck_assert_ptr_eq(r, s); 3987 ck_assert_str_eq(s, "sheepylib"); 3988 // empty string2 3989 r = iPrependNFreeS(&s, strdup("")); 3990 ck_assert_ptr_eq(r, s); 3991 ck_assert_str_eq(s, "sheepylib"); 3992 // NULL string2 3993 r = iPrependNFreeS(&s, NULL); 3994 ck_assert_ptr_eq(r, s); 3995 ck_assert_str_eq(s, "sheepylib"); 3996 free(s); 3997 // NULL string 3998 s = NULL; 3999 r = iPrependNFreeS(&s, strdup("ad")); 4000 ck_assert_ptr_eq(r, s); 4001 ck_assert_str_eq(s, "ad"); 4002 free(s); 4003 // NULL parameter 4004 s = strdup("ad"); 4005 r = iPrependNFreeS(NULL, s); 4006 ck_assert_ptr_eq(r, null); 4007 free(s); 4008 4009 END_TEST 4010 4011 4012 START_TEST(bPrependST) 4013 4014 char s[100]; 4015 char *r = null; 4016 4017 // append string 4018 strcpy(s, "lib"); 4019 r = bPrependS(s, "sheepy"); 4020 ck_assert_ptr_eq(r, s); 4021 ck_assert_str_eq(s, "sheepylib"); 4022 // empty string2 4023 r = bPrependS(s, ""); 4024 ck_assert_ptr_eq(r, s); 4025 ck_assert_str_eq(s, "sheepylib"); 4026 // NULL string2 4027 r = bPrependS(s, NULL); 4028 ck_assert_ptr_eq(r, null); 4029 ck_assert_str_eq(s, "sheepylib"); 4030 // empty string 4031 bEmptyS(s); 4032 r = bPrependS(s, "ad"); 4033 ck_assert_ptr_eq(r, s); 4034 ck_assert_str_eq(s, "ad"); 4035 // NULL parameter 4036 r = bPrependS(NULL, "ad"); 4037 ck_assert_ptr_eq(r, null); 4038 4039 END_TEST 4040 4041 4042 START_TEST(bLPrependST) 4043 4044 char s[100]; 4045 char *r = null; 4046 4047 // append string 4048 strcpy(s, "lib"); 4049 r = bLPrependS(s, sizeof s, "sheepy"); 4050 ck_assert_ptr_eq(r, s); 4051 ck_assert_str_eq(s, "sheepylib"); 4052 // shorter buffer 4053 strcpy(s, "lib"); 4054 r = bLPrependS(s, 5, "sheepy"); 4055 ck_assert_ptr_eq(r, s); 4056 ck_assert_str_eq(s, "shee"); 4057 // empty string2 4058 r = bLPrependS(s, sizeof s, ""); 4059 ck_assert_ptr_eq(r, s); 4060 ck_assert_str_eq(s, "shee"); 4061 // NULL string2 4062 r = bLPrependS(s, sizeof s, NULL); 4063 ck_assert_ptr_eq(r, null); 4064 ck_assert_str_eq(s, "shee"); 4065 // empty string 4066 bEmptyS(s); 4067 r = bLPrependS(s, sizeof s, "ad"); 4068 ck_assert_ptr_eq(r, s); 4069 ck_assert_str_eq(s, "ad"); 4070 // size 0 - no change 4071 r = bLPrependS(s, 0, "ad"); 4072 ck_assert_ptr_eq(r, s); 4073 ck_assert_str_eq(s, "ad"); 4074 // NULL parameter 4075 r = bLPrependS(NULL, sizeof s, "ad"); 4076 ck_assert_ptr_eq(r, null); 4077 4078 END_TEST 4079 4080 4081 START_TEST(replaceST) 4082 4083 // replace string, multiple character new delimeter 4084 char *s = replaceS_max("#ee#ee#ad", "#","^^"); 4085 ck_assert_str_eq(s, "^^ee^^ee^^ad"); 4086 free(s); 4087 // replace string, multiple character old delimeter 4088 s = replaceS_max("AA##ee##ee#", "##","|"); 4089 ck_assert_str_eq(s, "AA|ee|ee#"); 4090 free(s); 4091 // replace one time at the start of string 4092 s = replaceS("#ee#ee#ad", "#","^^",1); 4093 ck_assert_str_eq(s, "^^ee#ee#ad"); 4094 free(s); 4095 // replace one time 4096 s = replaceS("AA##ee##ee#", "##","|",1); 4097 ck_assert_str_eq(s, "AA|ee##ee#"); 4098 free(s); 4099 // NULL new delimiter, one time: same as empty delimiter 4100 s = replaceS("AA##ee##ee#", "##",NULL,1); 4101 ck_assert_str_eq(s, "AAee##ee#"); 4102 free(s); 4103 // empty string 4104 s = replaceS("", "##",NULL,1); 4105 ck_assert_str_eq(s, ""); 4106 free(s); 4107 // empty old delimiter 4108 ck_assert_ptr_eq(replaceS("qwe", "","|",1), NULL); 4109 // NULL old delimiter 4110 ck_assert_ptr_eq(replaceS("qwe", NULL,"|",1), NULL); 4111 // NULL string 4112 ck_assert_ptr_eq(replaceS(NULL, "##","|",1), NULL); 4113 // empty old delimiter 4114 ck_assert_ptr_eq(replaceS("AA##ee##ee#", "","|",1), NULL); 4115 4116 END_TEST 4117 4118 4119 START_TEST(replaceCharSST) 4120 4121 // replace string, multiple character new delimeter 4122 char *s = replaceCharSS("#ee#ee#ad", '#',"^^", 0); 4123 ck_assert_str_eq(s, "^^ee^^ee^^ad"); 4124 free(s); 4125 // replace one time at the start of string 4126 s = replaceCharSS("#ee#ee#ad", '#',"^^",1); 4127 ck_assert_str_eq(s, "^^ee#ee#ad"); 4128 free(s); 4129 // replace one time 4130 s = replaceCharSS("AA##ee##ee#", '#',"|",1); 4131 ck_assert_str_eq(s, "AA|#ee##ee#"); 4132 free(s); 4133 // NULL new delimiter, one time: same as empty delimiter 4134 s = replaceCharSS("AA#ee##ee#", '#',NULL,1); 4135 ck_assert_str_eq(s, "AAee##ee#"); 4136 free(s); 4137 // empty string 4138 s = replaceCharSS("", '#',NULL,1); 4139 ck_assert_str_eq(s, ""); 4140 free(s); 4141 // empty old delimiter 4142 ck_assert_ptr_eq(replaceCharSS("qwe", 0,"|",1), NULL); 4143 // NULL string 4144 ck_assert_ptr_eq(replaceCharSS(NULL, '#',"|",1), NULL); 4145 // empty old delimiter 4146 ck_assert_ptr_eq(replaceCharSS("AA##ee##ee#", 0,"|",1), NULL); 4147 4148 END_TEST 4149 4150 4151 START_TEST(replaceSCharST) 4152 4153 // replace string, multiple character new delimeter 4154 char *s = replaceSCharS("#ee#ee#ad", "#",'^',0); 4155 ck_assert_str_eq(s, "^ee^ee^ad"); 4156 free(s); 4157 // replace string, multiple character old delimeter 4158 s = replaceSCharS("AA##ee##ee#", "##",'|',0); 4159 ck_assert_str_eq(s, "AA|ee|ee#"); 4160 free(s); 4161 // replace string empty char, multiple character old delimeter 4162 s = replaceSCharS("AA##ee##ee#", "##", 0,0); 4163 ck_assert_str_eq(s, "AAeeee#"); 4164 free(s); 4165 // replace one time at the start of string 4166 s = replaceSCharS("#ee#ee#ad", "#",'^',1); 4167 ck_assert_str_eq(s, "^ee#ee#ad"); 4168 free(s); 4169 // replace one time 4170 s = replaceSCharS("AA##ee##ee#", "##",'|',1); 4171 ck_assert_str_eq(s, "AA|ee##ee#"); 4172 free(s); 4173 // empty string 4174 s = replaceSCharS("", "##",0,1); 4175 ck_assert_str_eq(s, ""); 4176 free(s); 4177 // empty old delimiter 4178 ck_assert_ptr_eq(replaceSCharS("qwe", "",'|',1), NULL); 4179 // NULL old delimiter 4180 ck_assert_ptr_eq(replaceSCharS("qwe", NULL,'|',1), NULL); 4181 // NULL string 4182 ck_assert_ptr_eq(replaceSCharS(NULL, "##",'|',1), NULL); 4183 // empty old delimiter 4184 ck_assert_ptr_eq(replaceSCharS("AA##ee##ee#", "",'|',1), NULL); 4185 4186 END_TEST 4187 4188 4189 START_TEST(replaceCharCharST) 4190 4191 // replace string, multiple character new delimeter 4192 char *s = replaceCharCharS("#ee#ee#ad", '#','^', 0); 4193 ck_assert_str_eq(s, "^ee^ee^ad"); 4194 free(s); 4195 // replace one time at the start of string 4196 s = replaceCharCharS("#ee#ee#ad", '#','^',1); 4197 ck_assert_str_eq(s, "^ee#ee#ad"); 4198 free(s); 4199 // replace one time 4200 s = replaceCharCharS("AA#ee##ee#", '#','|',1); 4201 ck_assert_str_eq(s, "AA|ee##ee#"); 4202 free(s); 4203 // empty string 4204 s = replaceCharCharS("", '#','^',1); 4205 ck_assert_str_eq(s, ""); 4206 free(s); 4207 // empty old delimiter 4208 ck_assert_ptr_eq(replaceCharCharS("qwe", 0,'|',1), NULL); 4209 // NULL string 4210 ck_assert_ptr_eq(replaceCharCharS(NULL, '#','|',1), NULL); 4211 // empty old delimiter 4212 ck_assert_ptr_eq(replaceCharCharS("AA##ee##ee#", 0,'|',1), NULL); 4213 4214 END_TEST 4215 4216 4217 START_TEST(iReplaceST) 4218 4219 char *s; 4220 char *r = null; 4221 4222 // replace string, multiple character new delimeter 4223 s = strdup("#ee#ee#ad"); 4224 r = iReplaceS_max(&s, "#","^^"); 4225 ck_assert_ptr_eq(r, s); 4226 ck_assert_str_eq(s, "^^ee^^ee^^ad"); 4227 free(s); 4228 // replace string, multiple character old delimeter 4229 s = strdup("AA##ee##ee#"); 4230 r = iReplaceS_max(&s, "##","|"); 4231 ck_assert_ptr_eq(r, s); 4232 ck_assert_str_eq(s, "AA|ee|ee#"); 4233 free(s); 4234 // replace one time at the start of string 4235 s = strdup("#ee#ee#ad"); 4236 r = iReplaceS(&s, "#","^^",1); 4237 ck_assert_ptr_eq(r, s); 4238 ck_assert_str_eq(s, "^^ee#ee#ad"); 4239 free(s); 4240 // replace one time 4241 s = strdup("AA##ee##ee#"); 4242 r = iReplaceS(&s, "##","|",1); 4243 ck_assert_ptr_eq(r, s); 4244 ck_assert_str_eq(s, "AA|ee##ee#"); 4245 free(s); 4246 // NULL new delimiter, one time: same as empty delimiter 4247 s = strdup("AA##ee##ee#"); 4248 r = iReplaceS(&s, "##",NULL,1); 4249 ck_assert_ptr_eq(r, s); 4250 ck_assert_str_eq(s, "AAee##ee#"); 4251 free(s); 4252 // empty string 4253 emptyS(s); 4254 r = iReplaceS(&s, "##",NULL,1); 4255 ck_assert_ptr_eq(r, null); 4256 ck_assert_str_eq(s, ""); 4257 free(s); 4258 // empty old delimiter 4259 s = strdup("qwe"); 4260 r = iReplaceS(&s, "","|",1); 4261 ck_assert_ptr_eq(r, null); 4262 ck_assert_str_eq(s, "qwe"); 4263 free(s); 4264 // NULL old delimiter 4265 s = strdup("qwe"); 4266 r = iReplaceS(&s, NULL,"|",1); 4267 ck_assert_ptr_eq(r, null); 4268 ck_assert_str_eq(s, "qwe"); 4269 free(s); 4270 // NULL string 4271 s = NULL; 4272 r = iReplaceS(&s, "##","|",1); 4273 ck_assert_ptr_eq(r, null); 4274 // NULL var 4275 r = iReplaceS(NULL, "##","|",1); 4276 ck_assert_ptr_eq(r, null); 4277 4278 END_TEST 4279 4280 4281 START_TEST(iReplaceCharSST) 4282 4283 char *s; 4284 char *r = null; 4285 4286 // replace string, multiple character new delimeter 4287 s = strdup("#ee#ee#ad"); 4288 r = iReplaceCharSS(&s, '#',"^^", 0); 4289 ck_assert_ptr_eq(r, s); 4290 ck_assert_str_eq(s, "^^ee^^ee^^ad"); 4291 free(s); 4292 // replace one time at the start of string 4293 s = strdup("#ee#ee#ad"); 4294 r = iReplaceCharSS(&s, '#',"^^",1); 4295 ck_assert_ptr_eq(r, s); 4296 ck_assert_str_eq(s, "^^ee#ee#ad"); 4297 free(s); 4298 // replace one time 4299 s = strdup("AA#ee##ee#"); 4300 r = iReplaceCharSS(&s, '#',"|",1); 4301 ck_assert_ptr_eq(r, s); 4302 ck_assert_str_eq(s, "AA|ee##ee#"); 4303 free(s); 4304 // NULL new delimiter, one time: same as empty delimiter 4305 s = strdup("AA#ee##ee#"); 4306 r = iReplaceCharSS(&s, '#',NULL,1); 4307 ck_assert_ptr_eq(r, s); 4308 ck_assert_str_eq(s, "AAee##ee#"); 4309 free(s); 4310 // empty string 4311 emptyS(s); 4312 r = iReplaceCharSS(&s, '#',NULL,1); 4313 ck_assert_ptr_eq(r, null); 4314 ck_assert_str_eq(s, ""); 4315 free(s); 4316 // empty old delimiter 4317 s = strdup("qwe"); 4318 r = iReplaceCharSS(&s, 0,"|",1); 4319 ck_assert_ptr_eq(r, null); 4320 ck_assert_str_eq(s, "qwe"); 4321 free(s); 4322 // NULL string 4323 s = NULL; 4324 r = iReplaceCharSS(&s, '#',"|",1); 4325 ck_assert_ptr_eq(r, s); 4326 // NULL var 4327 r = iReplaceCharSS(NULL, '#',"|",1); 4328 ck_assert_ptr_eq(r, null); 4329 4330 END_TEST 4331 4332 4333 START_TEST(iReplaceSCharST) 4334 4335 char *s; 4336 char *r = null; 4337 4338 // replace string, multiple character new delimeter 4339 s = strdup("#ee#ee#ad"); 4340 r = iReplaceSCharS(&s, "#",'^', 0); 4341 ck_assert_ptr_eq(r, s); 4342 ck_assert_str_eq(s, "^ee^ee^ad"); 4343 free(s); 4344 // replace string, multiple character old delimeter 4345 s = strdup("AA##ee##ee#"); 4346 r = iReplaceSCharS(&s, "##",'|', 0); 4347 ck_assert_ptr_eq(r, s); 4348 ck_assert_str_eq(s, "AA|ee|ee#"); 4349 free(s); 4350 // replace one time at the start of string 4351 s = strdup("#ee#ee#ad"); 4352 r = iReplaceSCharS(&s, "#",'^',1); 4353 ck_assert_ptr_eq(r, s); 4354 ck_assert_str_eq(s, "^ee#ee#ad"); 4355 free(s); 4356 // replace one time 4357 s = strdup("AA##ee##ee#"); 4358 r = iReplaceSCharS(&s, "##",'|',1); 4359 ck_assert_ptr_eq(r, s); 4360 ck_assert_str_eq(s, "AA|ee##ee#"); 4361 free(s); 4362 // empty string 4363 emptyS(s); 4364 r = iReplaceSCharS(&s, "##", 0,1); 4365 ck_assert_ptr_eq(r, null); 4366 ck_assert_str_eq(s, ""); 4367 free(s); 4368 // empty old delimiter 4369 s = strdup("qwe"); 4370 r = iReplaceSCharS(&s, "",'|',1); 4371 ck_assert_ptr_eq(r, null); 4372 ck_assert_str_eq(s, "qwe"); 4373 free(s); 4374 // NULL old delimiter 4375 s = strdup("qwe"); 4376 r = iReplaceSCharS(&s, NULL,'|',1); 4377 ck_assert_ptr_eq(r, null); 4378 ck_assert_str_eq(s, "qwe"); 4379 free(s); 4380 // NULL string 4381 s = NULL; 4382 r = iReplaceSCharS(&s, "##",'|',1); 4383 ck_assert_ptr_eq(r, null); 4384 // NULL var 4385 r = iReplaceSCharS(NULL, "##",'|',1); 4386 ck_assert_ptr_eq(r, null); 4387 4388 END_TEST 4389 4390 4391 START_TEST(iReplaceCharCharST) 4392 4393 char *s; 4394 char *r = null; 4395 4396 // replace string, multiple character new delimeter 4397 s = strdup("#ee#ee#ad"); 4398 r = iReplaceCharCharS(&s, '#','^', 0); 4399 ck_assert_ptr_eq(r, s); 4400 ck_assert_str_eq(s, "^ee^ee^ad"); 4401 free(s); 4402 // replace one time at the start of string 4403 s = strdup("#ee#ee#ad"); 4404 r = iReplaceCharCharS(&s, '#','^',1); 4405 ck_assert_ptr_eq(r, s); 4406 ck_assert_str_eq(s, "^ee#ee#ad"); 4407 free(s); 4408 // replace one time 4409 s = strdup("AA#ee##ee#"); 4410 r = iReplaceCharCharS(&s, '#','|',1); 4411 ck_assert_ptr_eq(r, s); 4412 ck_assert_str_eq(s, "AA|ee##ee#"); 4413 free(s); 4414 // empty string 4415 emptyS(s); 4416 r = iReplaceCharCharS(&s, '#', 0,1); 4417 ck_assert_ptr_eq(r, null); 4418 ck_assert_str_eq(s, ""); 4419 free(s); 4420 // empty old delimiter 4421 s = strdup("qwe"); 4422 r = iReplaceCharCharS(&s, 0,'|',1); 4423 ck_assert_ptr_eq(r, null); 4424 ck_assert_str_eq(s, "qwe"); 4425 free(s); 4426 // NULL string 4427 s = NULL; 4428 r = iReplaceCharCharS(&s, '#','|',1); 4429 ck_assert_ptr_eq(r, s); 4430 // NULL var 4431 r = iReplaceCharCharS(NULL, '#','|',1); 4432 ck_assert_ptr_eq(r, null); 4433 4434 END_TEST 4435 4436 4437 START_TEST(bReplaceST) 4438 4439 char s[100]; 4440 char *r = null; 4441 4442 // replace string, multiple character new delimeter 4443 strcpy(s, "#ee#ee#ad"); 4444 r = bReplaceS_max(s, "#","^^"); 4445 ck_assert_ptr_eq(r, s); 4446 ck_assert_str_eq(s, "^^ee^^ee^^ad"); 4447 // replace string, multiple character old delimeter 4448 strcpy(s, "AA##ee##ee#"); 4449 r = bReplaceS_max(s, "##","|"); 4450 ck_assert_ptr_eq(r, s); 4451 ck_assert_str_eq(s, "AA|ee|ee#"); 4452 // replace one time at the start of string 4453 strcpy(s, "#ee#ee#ad"); 4454 r = bReplaceS(s, "#","^^",1); 4455 ck_assert_ptr_eq(r, s); 4456 ck_assert_str_eq(s, "^^ee#ee#ad"); 4457 // replace one time 4458 strcpy(s, "AA##ee##ee#"); 4459 r = bReplaceS(s, "##","|",1); 4460 ck_assert_ptr_eq(r, s); 4461 ck_assert_str_eq(s, "AA|ee##ee#"); 4462 // NULL new delimiter, one time: same as empty delimiter 4463 strcpy(s, "AA##ee##ee#"); 4464 r = bReplaceS(s, "##",NULL,1); 4465 ck_assert_ptr_eq(r, s); 4466 ck_assert_str_eq(s, "AAee##ee#"); 4467 // empty string 4468 bEmptyS(s); 4469 r = bReplaceS(s, "##",NULL,1); 4470 ck_assert_ptr_eq(r, null); 4471 ck_assert_str_eq(s, ""); 4472 // empty old delimiter 4473 strcpy(s, "qwe"); 4474 r = bReplaceS(s, "","|",1); 4475 ck_assert_ptr_eq(r, null); 4476 ck_assert_str_eq(s, "qwe"); 4477 // NULL old delimiter 4478 strcpy(s, "qwe"); 4479 r = bReplaceS(s, NULL,"|",1); 4480 ck_assert_ptr_eq(r, null); 4481 ck_assert_str_eq(s, "qwe"); 4482 // NULL var 4483 r = bReplaceS(NULL, "##","|",1); 4484 ck_assert_ptr_eq(r, null); 4485 4486 END_TEST 4487 4488 4489 START_TEST(bLReplaceST) 4490 4491 char s[100]; 4492 char *r = null; 4493 4494 // replace string, multiple character new delimeter 4495 strcpy(s, "#ee#ee#ad"); 4496 r = bLReplaceS_max(s, sizeof s, "#","^^"); 4497 ck_assert_ptr_eq(r, s); 4498 ck_assert_str_eq(s, "^^ee^^ee^^ad"); 4499 // shorter buffer 4500 strcpy(s, "#ee#ee#ad"); 4501 r = bLReplaceS_max(s, 5, "#","^^"); 4502 ck_assert_ptr_eq(r, s); 4503 ck_assert_str_eq(s, "^^ee"); 4504 // replace string, multiple character old delimeter 4505 strcpy(s, "AA##ee##ee#"); 4506 r = bLReplaceS_max(s, sizeof s, "##","|"); 4507 ck_assert_ptr_eq(r, s); 4508 ck_assert_str_eq(s, "AA|ee|ee#"); 4509 // replace one time at the start of string 4510 strcpy(s, "#ee#ee#ad"); 4511 r = bLReplaceS(s, sizeof s, "#","^^",1); 4512 ck_assert_ptr_eq(r, s); 4513 ck_assert_str_eq(s, "^^ee#ee#ad"); 4514 // replace one time 4515 strcpy(s, "AA##ee##ee#"); 4516 r = bLReplaceS(s, sizeof s, "##","|",1); 4517 ck_assert_ptr_eq(r, s); 4518 ck_assert_str_eq(s, "AA|ee##ee#"); 4519 // NULL new delimiter, one time: same as empty delimiter 4520 strcpy(s, "AA##ee##ee#"); 4521 r = bLReplaceS(s, sizeof s, "##",NULL,1); 4522 ck_assert_ptr_eq(r, s); 4523 ck_assert_str_eq(s, "AAee##ee#"); 4524 // empty string 4525 bEmptyS(s); 4526 r = bLReplaceS(s, sizeof s, "##",NULL,1); 4527 ck_assert_ptr_eq(r, null); 4528 ck_assert_str_eq(s, ""); 4529 // empty old delimiter 4530 strcpy(s, "qwe"); 4531 r = bLReplaceS(s, sizeof s, "","|",1); 4532 ck_assert_ptr_eq(r, null); 4533 ck_assert_str_eq(s, "qwe"); 4534 // NULL old delimiter 4535 strcpy(s, "qwe"); 4536 r = bLReplaceS(s, sizeof s, NULL,"|",1); 4537 ck_assert_ptr_eq(r, null); 4538 ck_assert_str_eq(s, "qwe"); 4539 // size 0 - no change 4540 strcpy(s, "qwe"); 4541 r = bLReplaceS(s, 0, "q","|",1); 4542 ck_assert_ptr_eq(r, s); 4543 ck_assert_str_eq(s, "qwe"); 4544 // NULL var 4545 r = bLReplaceS(NULL, sizeof s, "##","|",1); 4546 ck_assert_ptr_eq(r, null); 4547 4548 END_TEST 4549 4550 4551 START_TEST(icReplaceST) 4552 4553 char *s; 4554 4555 // replace string, multiple character new delimeter 4556 s = icReplaceS("#EE#ee#ad", "ee","VV", 0); 4557 ck_assert_str_eq(s, "#VV#VV#ad"); 4558 free(s); 4559 // icReplaceCharSS 4560 s = icReplaceCharSS("#EE#ee#ad", 'e',"V", 0); 4561 ck_assert_str_eq(s, "#VV#VV#ad"); 4562 free(s); 4563 // icReplaceSCharS 4564 s = icReplaceSCharS("#EE#ee#ad", "e",'V', 0); 4565 ck_assert_str_eq(s, "#VV#VV#ad"); 4566 free(s); 4567 // icReplaceCharCharS 4568 s = icReplaceCharCharS("#EE#ee#ad", 'e','V', 0); 4569 ck_assert_str_eq(s, "#VV#VV#ad"); 4570 free(s); 4571 4572 // replace string, multiple character old delimeter 4573 s = icReplaceS("AA##ee##ee#", "##","|", 0); 4574 ck_assert_str_eq(s, "AA|ee|ee#"); 4575 free(s); 4576 // replace one time at the start of string 4577 s = icReplaceS("#ee#ee#ad", "#","^^",1); 4578 ck_assert_str_eq(s, "^^ee#ee#ad"); 4579 free(s); 4580 // replace one time 4581 s = icReplaceS("AA##ee##ee#", "##","|",1); 4582 ck_assert_str_eq(s, "AA|ee##ee#"); 4583 free(s); 4584 // NULL new delimiter, one time: same as empty delimiter 4585 s = icReplaceS("AA##ee##ee#", "##",NULL,1); 4586 ck_assert_str_eq(s, "AAee##ee#"); 4587 free(s); 4588 // empty string 4589 s = icReplaceS("", "##",NULL,1); 4590 ck_assert_str_eq(s, ""); 4591 free(s); 4592 // empty old delimiter 4593 ck_assert_ptr_eq(icReplaceS("qwe", "","|",1), NULL); 4594 // NULL old delimiter 4595 ck_assert_ptr_eq(icReplaceS("qwe", NULL,"|",1), NULL); 4596 // NULL string 4597 ck_assert_ptr_eq(icReplaceS(NULL, "##","|",1), NULL); 4598 // empty old delimiter 4599 ck_assert_ptr_eq(icReplaceS("AA##ee##ee#", "","|",1), NULL); 4600 4601 4602 END_TEST 4603 4604 4605 START_TEST(iicReplaceST) 4606 4607 char *s; 4608 char *r = null; 4609 4610 // replace string, multiple character new delimeter 4611 s = strdup("#EE#ee#ad"); 4612 r = iicReplaceS(&s, "EE","VV", 0); 4613 ck_assert_ptr_eq(r, s); 4614 ck_assert_str_eq(s, "#VV#VV#ad"); 4615 free(s); 4616 // iicReplaceCharSS 4617 s = strdup("#EE#ee#ad"); 4618 s = iicReplaceCharSS(&s, 'e',"V", 0); 4619 ck_assert_str_eq(s, "#VV#VV#ad"); 4620 free(s); 4621 // iicReplaceSCharS 4622 s = strdup("#EE#ee#ad"); 4623 s = iicReplaceSCharS(&s, "e",'V', 0); 4624 ck_assert_str_eq(s, "#VV#VV#ad"); 4625 free(s); 4626 // iicReplaceCharCharS 4627 s = strdup("#EE#ee#ad"); 4628 s = iicReplaceCharCharS(&s, 'e','V', 0); 4629 ck_assert_str_eq(s, "#VV#VV#ad"); 4630 free(s); 4631 // replace string, multiple character old delimeter 4632 s = strdup("AA##ee##ee#"); 4633 r = iicReplaceS(&s, "##","|", 0); 4634 ck_assert_ptr_eq(r, s); 4635 ck_assert_str_eq(s, "AA|ee|ee#"); 4636 free(s); 4637 // replace one time at the start of string 4638 s = strdup("#ee#ee#ad"); 4639 r = iicReplaceS(&s, "#","^^",1); 4640 ck_assert_ptr_eq(r, s); 4641 ck_assert_str_eq(s, "^^ee#ee#ad"); 4642 free(s); 4643 // replace one time 4644 s = strdup("AA##ee##ee#"); 4645 r = iicReplaceS(&s, "##","|",1); 4646 ck_assert_ptr_eq(r, s); 4647 ck_assert_str_eq(s, "AA|ee##ee#"); 4648 free(s); 4649 // NULL new delimiter, one time: same as empty delimiter 4650 s = strdup("AA##ee##ee#"); 4651 r = iicReplaceS(&s, "##",NULL,1); 4652 ck_assert_ptr_eq(r, s); 4653 ck_assert_str_eq(s, "AAee##ee#"); 4654 free(s); 4655 // empty string 4656 emptyS(s); 4657 r = iicReplaceS(&s, "##",NULL,1); 4658 ck_assert_ptr_eq(r, null); 4659 ck_assert_str_eq(s, ""); 4660 free(s); 4661 // empty old delimiter 4662 s = strdup("qwe"); 4663 r = iicReplaceS(&s, "","|",1); 4664 ck_assert_ptr_eq(r, null); 4665 ck_assert_str_eq(s, "qwe"); 4666 free(s); 4667 // NULL old delimiter 4668 s = strdup("qwe"); 4669 r = iicReplaceS(&s, NULL,"|",1); 4670 ck_assert_ptr_eq(r, null); 4671 ck_assert_str_eq(s, "qwe"); 4672 free(s); 4673 // NULL string 4674 s = NULL; 4675 r = iicReplaceS(&s, "##","|",1); 4676 ck_assert_ptr_eq(r, null); 4677 // NULL var 4678 r = iicReplaceS(NULL, "##","|",1); 4679 ck_assert_ptr_eq(r, null); 4680 4681 4682 END_TEST 4683 4684 4685 START_TEST(bicReplaceST) 4686 4687 char s[100]; 4688 char *r = null; 4689 4690 // replace string, multiple character new delimeter 4691 strcpy(s, "#EE#ee#ad"); 4692 r = bicReplaceS(s, "ee","VV", 0); 4693 ck_assert_ptr_eq(r, s); 4694 ck_assert_str_eq(s, "#VV#VV#ad"); 4695 // replace string, multiple character old delimeter 4696 strcpy(s, "AA##ee##ee#"); 4697 r = bicReplaceS(s, "##","|", 0); 4698 ck_assert_ptr_eq(r, s); 4699 ck_assert_str_eq(s, "AA|ee|ee#"); 4700 // replace one time at the start of string 4701 strcpy(s, "#ee#ee#ad"); 4702 r = bicReplaceS(s, "#","^^",1); 4703 ck_assert_ptr_eq(r, s); 4704 ck_assert_str_eq(s, "^^ee#ee#ad"); 4705 // replace one time 4706 strcpy(s, "AA##ee##ee#"); 4707 r = bicReplaceS(s, "##","|",1); 4708 ck_assert_ptr_eq(r, s); 4709 ck_assert_str_eq(s, "AA|ee##ee#"); 4710 // NULL new delimiter, one time: same as empty delimiter 4711 strcpy(s, "AA##ee##ee#"); 4712 r = bicReplaceS(s, "##",NULL,1); 4713 ck_assert_ptr_eq(r, s); 4714 ck_assert_str_eq(s, "AAee##ee#"); 4715 // empty string 4716 bEmptyS(s); 4717 r = bicReplaceS(s, "##",NULL,1); 4718 ck_assert_ptr_eq(r, null); 4719 ck_assert_str_eq(s, ""); 4720 // empty old delimiter 4721 strcpy(s, "qwe"); 4722 r = bicReplaceS(s, "","|",1); 4723 ck_assert_ptr_eq(r, null); 4724 ck_assert_str_eq(s, "qwe"); 4725 // NULL old delimiter 4726 strcpy(s, "qwe"); 4727 r = bicReplaceS(s, NULL,"|",1); 4728 ck_assert_ptr_eq(r, null); 4729 ck_assert_str_eq(s, "qwe"); 4730 // NULL var 4731 r = bicReplaceS(NULL, "##","|",1); 4732 ck_assert_ptr_eq(r, null); 4733 4734 4735 END_TEST 4736 4737 4738 START_TEST(bLicReplaceST) 4739 4740 char s[100]; 4741 char *r = null; 4742 4743 // replace string, multiple character new delimeter 4744 strcpy(s, "#ee#EE#ad"); 4745 r = bLicReplaceS(s, sizeof s, "ee","vv", 0); 4746 ck_assert_ptr_eq(r, s); 4747 ck_assert_str_eq(s, "#vv#vv#ad"); 4748 // shorter buffer 4749 strcpy(s, "#ee#ee#ad"); 4750 r = bLicReplaceS(s, 5, "#","^^", 0); 4751 ck_assert_ptr_eq(r, s); 4752 ck_assert_str_eq(s, "^^ee"); 4753 // replace string, multiple character old delimeter 4754 strcpy(s, "AA##ee##ee#"); 4755 r = bLicReplaceS(s, sizeof s, "##","|", 0); 4756 ck_assert_ptr_eq(r, s); 4757 ck_assert_str_eq(s, "AA|ee|ee#"); 4758 // replace one time at the start of string 4759 strcpy(s, "#ee#ee#ad"); 4760 r = bLicReplaceS(s, sizeof s, "#","^^",1); 4761 ck_assert_ptr_eq(r, s); 4762 ck_assert_str_eq(s, "^^ee#ee#ad"); 4763 // replace one time 4764 strcpy(s, "AA##ee##ee#"); 4765 r = bLicReplaceS(s, sizeof s, "##","|",1); 4766 ck_assert_ptr_eq(r, s); 4767 ck_assert_str_eq(s, "AA|ee##ee#"); 4768 // NULL new delimiter, one time: same as empty delimiter 4769 strcpy(s, "AA##ee##ee#"); 4770 r = bLicReplaceS(s, sizeof s, "##",NULL,1); 4771 ck_assert_ptr_eq(r, s); 4772 ck_assert_str_eq(s, "AAee##ee#"); 4773 // empty string 4774 bEmptyS(s); 4775 r = bLicReplaceS(s, sizeof s, "##",NULL,1); 4776 ck_assert_ptr_eq(r, null); 4777 ck_assert_str_eq(s, ""); 4778 // empty old delimiter 4779 strcpy(s, "qwe"); 4780 r = bLicReplaceS(s, sizeof s, "","|",1); 4781 ck_assert_ptr_eq(r, null); 4782 ck_assert_str_eq(s, "qwe"); 4783 // NULL old delimiter 4784 strcpy(s, "qwe"); 4785 r = bLicReplaceS(s, sizeof s, NULL,"|",1); 4786 ck_assert_ptr_eq(r, null); 4787 ck_assert_str_eq(s, "qwe"); 4788 // size 0 - no change 4789 strcpy(s, "qwe"); 4790 r = bLicReplaceS(s, 0, "q","|",1); 4791 ck_assert_ptr_eq(r, s); 4792 ck_assert_str_eq(s, "qwe"); 4793 // NULL var 4794 r = bLicReplaceS(NULL, sizeof s, "##","|",1); 4795 ck_assert_ptr_eq(r, null); 4796 4797 4798 END_TEST 4799 4800 4801 START_TEST(replaceManyST) 4802 4803 // replace string, multiple character new delimeter 4804 char *s = replaceManyS("#ee#ee#ad", "#","^^","ad","AD"); 4805 ck_assert_str_eq(s, "^^ee^^ee^^AD"); 4806 free(s); 4807 // replace string, empty new delimeter 4808 s = replaceManyS("#ee#ee#ad", "#","","ad","AD"); 4809 ck_assert_str_eq(s, "eeeeAD"); 4810 free(s); 4811 // not enough olds:news pairs 4812 s = replaceManyS("#ee#ee#ad", "#","","ad"); 4813 ck_assert_str_eq(s, "eeeead"); 4814 free(s); 4815 // only 2 parameters 4816 s = replaceManyS("#ee#ee#ad", "#"); 4817 ck_assert_ptr_eq(s, NULL); 4818 free(s); 4819 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 4820 s = replaceManyS("AA##ee##ee#", "##",NULL); 4821 ck_assert_ptr_eq(s, NULL); 4822 free(s); 4823 // empty string 4824 s = replaceManyS("", "##", ""); 4825 ck_assert_str_eq(s, ""); 4826 free(s); 4827 // empty string many pairs 4828 s = replaceManyS("", "##", "", "$$", ""); 4829 ck_assert_str_eq(s, ""); 4830 free(s); 4831 // empty string many pairs empty olds 4832 s = replaceManyS("", "##", "", "", ""); 4833 ck_assert_str_eq(s, ""); 4834 free(s); 4835 // empty string and NULL old delimiter 4836 s = replaceManyS("", NULL,"|"); 4837 ck_assert_str_eq(s, ""); 4838 free(s); 4839 // empty string and NULL old delimiter not first - same as replace empty string 4840 s = replaceManyS("","##","|", NULL,"|"); 4841 ck_assert_str_eq(s, ""); 4842 free(s); 4843 // empty old delimiter 4844 ck_assert_ptr_eq(replaceManyS("AA##ee##ee#", "","|", "AA", "BB"), NULL); 4845 // empty old delimiter not first 4846 ck_assert_ptr_eq(replaceManyS("AA##ee##ee#", "##","|", "", "BB"), NULL); 4847 // NULL string 4848 ck_assert_ptr_eq(replaceManyS(NULL, "##","|"), NULL); 4849 // NULL string many pairs 4850 ck_assert_ptr_eq(replaceManyS(NULL, "##","|", "$$", ""), NULL); 4851 4852 END_TEST 4853 4854 4855 START_TEST(iReplaceManyST) 4856 4857 char *s; 4858 char *r = null; 4859 4860 // replace string, multiple character new delimeter 4861 s = strdup("#ee#ee#ad"); 4862 r = iReplaceManyS(&s, "#","^^","ad","AD"); 4863 ck_assert_ptr_eq(r, s); 4864 ck_assert_str_eq(s, "^^ee^^ee^^AD"); 4865 free(s); 4866 // replace string, empty new delimeter 4867 s = strdup("#ee#ee#ad"); 4868 r = iReplaceManyS(&s, "#","","ad","AD"); 4869 ck_assert_ptr_eq(r, s); 4870 ck_assert_str_eq(s, "eeeeAD"); 4871 free(s); 4872 // not enough olds:news pairs 4873 s = strdup("#ee#ee#ad"); 4874 r = iReplaceManyS(&s, "#","","ad"); 4875 ck_assert_ptr_eq(r, s); 4876 ck_assert_str_eq(s, "eeeead"); 4877 free(s); 4878 // only 2 parameters 4879 // doesn't compile 4880 /* s = strdup("#ee#ee#ad"); */ 4881 /* iReplaceManyS(&s, "#"); */ 4882 /* ck_assert_str_eq(s, "#ee#ee#ad"); */ 4883 /* free(s); */ 4884 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 4885 s = strdup("#ee#ee#ad"); 4886 r = iReplaceManyS(&s, "#", NULL); 4887 ck_assert_ptr_eq(r, s); 4888 ck_assert_str_eq(s, "#ee#ee#ad"); 4889 free(s); 4890 // empty string 4891 emptyS(s); 4892 r = iReplaceManyS(&s, "#", ""); 4893 ck_assert_ptr_eq(r, null); 4894 ck_assert_str_eq(s, ""); 4895 free(s); 4896 // empty string many pairs 4897 emptyS(s); 4898 r = iReplaceManyS(&s, "#", "", "%", ""); 4899 ck_assert_ptr_eq(r, null); 4900 ck_assert_str_eq(s, ""); 4901 free(s); 4902 // many pairs empty olds 4903 s = strdup("qw#e"); 4904 r = iReplaceManyS(&s, "#", "", "", ""); 4905 ck_assert_ptr_eq(r, s); 4906 ck_assert_str_eq(s, "qwe"); 4907 free(s); 4908 // NULL old delimiter 4909 s = strdup("qw#e"); 4910 r = iReplaceManyS(&s, NULL, ""); 4911 ck_assert_ptr_eq(r, s); 4912 ck_assert_str_eq(s, "qw#e"); 4913 free(s); 4914 // NULL old delimiter not first - same as replace empty string 4915 s = strdup("qw#e"); 4916 r = iReplaceManyS(&s, "#","|", NULL, ""); 4917 ck_assert_ptr_eq(r, s); 4918 ck_assert_str_eq(s, "qw|e"); 4919 free(s); 4920 // empty old delimiter 4921 s = strdup("qw#e"); 4922 r = iReplaceManyS(&s, "","|", NULL, ""); 4923 ck_assert_ptr_eq(r, s); 4924 ck_assert_str_eq(s, "qw#e"); 4925 free(s); 4926 // empty old delimiter not first 4927 s = strdup("qw#e"); 4928 r = iReplaceManyS(&s, "#","|", "", "*"); 4929 ck_assert_ptr_eq(r, s); 4930 ck_assert_str_eq(s, "qw|e"); 4931 free(s); 4932 // NULL string 4933 s = NULL; 4934 r = iReplaceManyS(&s, "#","|", "$", "*"); 4935 ck_assert_ptr_eq(r, null); 4936 ck_assert_ptr_eq(s, NULL); 4937 free(s); 4938 // NULL var 4939 r = iReplaceManyS(NULL, "#","|", "$", "*"); 4940 ck_assert_ptr_eq(r, null); 4941 4942 END_TEST 4943 4944 4945 START_TEST(bReplaceManyST) 4946 4947 char s[100]; 4948 char *r = null; 4949 4950 // replace string, multiple character new delimeter 4951 strcpy(s, "#ee#ee#ad"); 4952 r = bReplaceManyS(s, "#","^^","ad","AD"); 4953 ck_assert_ptr_eq(r, s); 4954 ck_assert_str_eq(s, "^^ee^^ee^^AD"); 4955 // replace string, empty new delimeter 4956 strcpy(s, "#ee#ee#ad"); 4957 r = bReplaceManyS(s, "#","","ad","AD"); 4958 ck_assert_ptr_eq(r, s); 4959 ck_assert_str_eq(s, "eeeeAD"); 4960 // not enough olds:news pairs 4961 strcpy(s, "#ee#ee#ad"); 4962 r = bReplaceManyS(s, "#","","ad"); 4963 ck_assert_ptr_eq(r, s); 4964 ck_assert_str_eq(s, "eeeead"); 4965 // only 2 parameters 4966 // doesn't compile 4967 /* strcpy(s, "#ee#ee#ad"); */ 4968 /* bReplaceManyS(s, "#"); */ 4969 /* ck_assert_str_eq(s, "#ee#ee#ad"); */ 4970 /* free(s); */ 4971 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 4972 strcpy(s, "#ee#ee#ad"); 4973 r = bReplaceManyS(s, "#", NULL); 4974 ck_assert_ptr_eq(r, s); 4975 ck_assert_str_eq(s, "#ee#ee#ad"); 4976 // empty string 4977 bEmptyS(s); 4978 r = bReplaceManyS(s, "#", ""); 4979 ck_assert_ptr_eq(r, null); 4980 ck_assert_str_eq(s, ""); 4981 // empty string many pairs 4982 bEmptyS(s); 4983 r = bReplaceManyS(s, "#", "", "%", ""); 4984 ck_assert_ptr_eq(r, null); 4985 ck_assert_str_eq(s, ""); 4986 // many pairs empty olds 4987 strcpy(s, "qw#e"); 4988 r = bReplaceManyS(s, "#", "", "", ""); 4989 ck_assert_ptr_eq(r, s); 4990 ck_assert_str_eq(s, "qwe"); 4991 // NULL old delimiter 4992 strcpy(s, "qw#e"); 4993 r = bReplaceManyS(s, NULL, ""); 4994 ck_assert_ptr_eq(r, s); 4995 ck_assert_str_eq(s, "qw#e"); 4996 // NULL old delimiter not first - same as replace empty string 4997 strcpy(s, "qw#e"); 4998 r = bReplaceManyS(s, "#","|", NULL, ""); 4999 ck_assert_ptr_eq(r, s); 5000 ck_assert_str_eq(s, "qw|e"); 5001 // empty old delimiter 5002 strcpy(s, "qw#e"); 5003 r = bReplaceManyS(s, "","|", NULL, ""); 5004 ck_assert_ptr_eq(r, s); 5005 ck_assert_str_eq(s, "qw#e"); 5006 // empty old delimiter not first 5007 strcpy(s, "qw#e"); 5008 r = bReplaceManyS(s, "#","|", "", "*"); 5009 ck_assert_ptr_eq(r, s); 5010 ck_assert_str_eq(s, "qw|e"); 5011 // NULL var 5012 r = bReplaceManyS(NULL, "#","|", "$", "*"); 5013 ck_assert_ptr_eq(r, null); 5014 5015 END_TEST 5016 5017 5018 START_TEST(bLReplaceManyST) 5019 5020 char s[100]; 5021 char *r = null; 5022 5023 // replace string, multiple character new delimeter 5024 strcpy(s, "#ee#ee#ad"); 5025 r = bLReplaceManyS(s, sizeof s, "#","^^","ad","AD"); 5026 ck_assert_ptr_eq(r, s); 5027 ck_assert_str_eq(s, "^^ee^^ee^^AD"); 5028 // shorter buffer 5029 strcpy(s, "#ee#ee#ad"); 5030 r = bLReplaceManyS(s, 5, "#","^^","ad","AD"); 5031 ck_assert_ptr_eq(r, s); 5032 ck_assert_str_eq(s, "^^ee"); 5033 // replace string, empty new delimeter 5034 strcpy(s, "#ee#ee#ad"); 5035 r = bLReplaceManyS(s, sizeof s, "#","","ad","AD"); 5036 ck_assert_ptr_eq(r, s); 5037 ck_assert_str_eq(s, "eeeeAD"); 5038 // not enough olds:news pairs 5039 strcpy(s, "#ee#ee#ad"); 5040 r = bLReplaceManyS(s, sizeof s, "#","","ad"); 5041 ck_assert_ptr_eq(r, s); 5042 ck_assert_str_eq(s, "eeeead"); 5043 // only 2 parameters 5044 // doesn't compile 5045 /* strcpy(s, "#ee#ee#ad"); */ 5046 /* bLReplaceManyS(s, sizeof s, "#"); */ 5047 /* ck_assert_str_eq(s, "#ee#ee#ad"); */ 5048 /* free(s); */ 5049 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 5050 strcpy(s, "#ee#ee#ad"); 5051 r = bLReplaceManyS(s, sizeof s, "#", NULL); 5052 ck_assert_ptr_eq(r, s); 5053 ck_assert_str_eq(s, "#ee#ee#ad"); 5054 // empty string 5055 bEmptyS(s); 5056 r = bLReplaceManyS(s, sizeof s, "#", ""); 5057 ck_assert_ptr_eq(r, null); 5058 ck_assert_str_eq(s, ""); 5059 // empty string many pairs 5060 bEmptyS(s); 5061 r = bLReplaceManyS(s, sizeof s, "#", "", "%", ""); 5062 ck_assert_ptr_eq(r, null); 5063 ck_assert_str_eq(s, ""); 5064 // many pairs empty olds 5065 strcpy(s, "qw#e"); 5066 r = bLReplaceManyS(s, sizeof s, "#", "", "", ""); 5067 ck_assert_ptr_eq(r, s); 5068 ck_assert_str_eq(s, "qwe"); 5069 // NULL old delimiter 5070 strcpy(s, "qw#e"); 5071 r = bLReplaceManyS(s, sizeof s, NULL, ""); 5072 ck_assert_ptr_eq(r, s); 5073 ck_assert_str_eq(s, "qw#e"); 5074 // NULL old delimiter not first - same as replace empty string 5075 strcpy(s, "qw#e"); 5076 r = bLReplaceManyS(s, sizeof s, "#","|", NULL, ""); 5077 ck_assert_ptr_eq(r, s); 5078 ck_assert_str_eq(s, "qw|e"); 5079 // empty old delimiter 5080 strcpy(s, "qw#e"); 5081 r = bLReplaceManyS(s, sizeof s, "","|", NULL, ""); 5082 ck_assert_ptr_eq(r, s); 5083 ck_assert_str_eq(s, "qw#e"); 5084 // empty old delimiter not first 5085 strcpy(s, "qw#e"); 5086 r = bLReplaceManyS(s, sizeof s, "#","|", "", "*"); 5087 ck_assert_ptr_eq(r, s); 5088 ck_assert_str_eq(s, "qw|e"); 5089 // size 0 - no change 5090 r = bLReplaceManyS(s, 0, "#","|", "", "*"); 5091 ck_assert_ptr_eq(r, s); 5092 ck_assert_str_eq(s, "qw|e"); 5093 // NULL var 5094 r = bLReplaceManyS(NULL, sizeof s, "#","|", "$", "*"); 5095 ck_assert_ptr_eq(r, null); 5096 5097 END_TEST 5098 5099 5100 START_TEST(icReplaceManyST) 5101 5102 // replace string, multiple character new delimeter 5103 char *s = icReplaceManyS("#ee#ee#ad", "#","^^","AD","vv"); 5104 ck_assert_str_eq(s, "^^ee^^ee^^vv"); 5105 free(s); 5106 // replace string, empty new delimeter 5107 s = icReplaceManyS("#ee#ee#ad", "#","","ad","AD"); 5108 ck_assert_str_eq(s, "eeeeAD"); 5109 free(s); 5110 // not enough olds:news pairs 5111 s = icReplaceManyS("#ee#ee#ad", "#","","ad"); 5112 ck_assert_str_eq(s, "eeeead"); 5113 free(s); 5114 // only 2 parameters 5115 s = icReplaceManyS("#ee#ee#ad", "#"); 5116 ck_assert_ptr_eq(s, NULL); 5117 free(s); 5118 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 5119 s = icReplaceManyS("AA##ee##ee#", "##",NULL); 5120 ck_assert_ptr_eq(s, NULL); 5121 free(s); 5122 // empty string 5123 s = icReplaceManyS("", "##", ""); 5124 ck_assert_str_eq(s, ""); 5125 free(s); 5126 // empty string many pairs 5127 s = icReplaceManyS("", "##", "", "$$", ""); 5128 ck_assert_str_eq(s, ""); 5129 free(s); 5130 // empty string many pairs empty olds 5131 s = icReplaceManyS("", "##", "", "", ""); 5132 ck_assert_str_eq(s, ""); 5133 free(s); 5134 // empty string and NULL old delimiter 5135 s = icReplaceManyS("", NULL,"|"); 5136 ck_assert_str_eq(s, ""); 5137 free(s); 5138 // empty string and NULL old delimiter not first - same as replace empty string 5139 s = icReplaceManyS("","##","|", NULL,"|"); 5140 ck_assert_str_eq(s, ""); 5141 free(s); 5142 // empty old delimiter 5143 ck_assert_ptr_eq(icReplaceManyS("AA##ee##ee#", "","|", "AA", "BB"), NULL); 5144 // empty old delimiter not first 5145 ck_assert_ptr_eq(icReplaceManyS("AA##ee##ee#", "##","|", "", "BB"), NULL); 5146 // NULL string 5147 ck_assert_ptr_eq(icReplaceManyS(NULL, "##","|"), NULL); 5148 // NULL string many pairs 5149 ck_assert_ptr_eq(icReplaceManyS(NULL, "##","|", "$$", ""), NULL); 5150 5151 5152 END_TEST 5153 5154 5155 START_TEST(iicReplaceManyST) 5156 5157 char *s; 5158 char *r = null; 5159 5160 // replace string, multiple character new delimeter 5161 s = strdup("#ee#ee#ad"); 5162 r = iicReplaceManyS(&s, "#","^^","ad","vv"); 5163 ck_assert_ptr_eq(r, s); 5164 ck_assert_str_eq(s, "^^ee^^ee^^vv"); 5165 free(s); 5166 // replace string, empty new delimeter 5167 s = strdup("#ee#ee#ad"); 5168 r = iicReplaceManyS(&s, "#","","ad","AD"); 5169 ck_assert_ptr_eq(r, s); 5170 ck_assert_str_eq(s, "eeeeAD"); 5171 free(s); 5172 // not enough olds:news pairs 5173 s = strdup("#ee#ee#ad"); 5174 r = iicReplaceManyS(&s, "#","","ad"); 5175 ck_assert_ptr_eq(r, s); 5176 ck_assert_str_eq(s, "eeeead"); 5177 free(s); 5178 // only 2 parameters 5179 // doesn't compile 5180 /* s = strdup("#ee#ee#ad"); */ 5181 /* iicReplaceManyS(&s, "#"); */ 5182 /* ck_assert_str_eq(s, "#ee#ee#ad"); */ 5183 /* free(s); */ 5184 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 5185 s = strdup("#ee#ee#ad"); 5186 r = iicReplaceManyS(&s, "#", NULL); 5187 ck_assert_ptr_eq(r, s); 5188 ck_assert_str_eq(s, "#ee#ee#ad"); 5189 free(s); 5190 // empty string 5191 emptyS(s); 5192 r = iicReplaceManyS(&s, "#", ""); 5193 ck_assert_ptr_eq(r, null); 5194 ck_assert_str_eq(s, ""); 5195 free(s); 5196 // empty string many pairs 5197 emptyS(s); 5198 r = iicReplaceManyS(&s, "#", "", "%", ""); 5199 ck_assert_ptr_eq(r, null); 5200 ck_assert_str_eq(s, ""); 5201 free(s); 5202 // many pairs empty olds 5203 s = strdup("qw#e"); 5204 r = iicReplaceManyS(&s, "#", "", "", ""); 5205 ck_assert_ptr_eq(r, s); 5206 ck_assert_str_eq(s, "qwe"); 5207 free(s); 5208 // NULL old delimiter 5209 s = strdup("qw#e"); 5210 r = iicReplaceManyS(&s, NULL, ""); 5211 ck_assert_ptr_eq(r, s); 5212 ck_assert_str_eq(s, "qw#e"); 5213 free(s); 5214 // NULL old delimiter not first - same as replace empty string 5215 s = strdup("qw#e"); 5216 r = iicReplaceManyS(&s, "#","|", NULL, ""); 5217 ck_assert_ptr_eq(r, s); 5218 ck_assert_str_eq(s, "qw|e"); 5219 free(s); 5220 // empty old delimiter 5221 s = strdup("qw#e"); 5222 r = iicReplaceManyS(&s, "","|", NULL, ""); 5223 ck_assert_ptr_eq(r, s); 5224 ck_assert_str_eq(s, "qw#e"); 5225 free(s); 5226 // empty old delimiter not first 5227 s = strdup("qw#e"); 5228 r = iicReplaceManyS(&s, "#","|", "", "*"); 5229 ck_assert_ptr_eq(r, s); 5230 ck_assert_str_eq(s, "qw|e"); 5231 free(s); 5232 // NULL string 5233 s = NULL; 5234 r = iicReplaceManyS(&s, "#","|", "$", "*"); 5235 ck_assert_ptr_eq(r, null); 5236 ck_assert_ptr_eq(s, NULL); 5237 free(s); 5238 // NULL var 5239 r = iicReplaceManyS(NULL, "#","|", "$", "*"); 5240 ck_assert_ptr_eq(r, null); 5241 5242 5243 END_TEST 5244 5245 5246 START_TEST(bicReplaceManyST) 5247 5248 char s[100]; 5249 char *r = null; 5250 5251 // replace string, multiple character new delimeter 5252 strcpy(s, "#ee#ee#ad"); 5253 r = bicReplaceManyS(s, "#","^^","AD","vv"); 5254 ck_assert_ptr_eq(r, s); 5255 ck_assert_str_eq(s, "^^ee^^ee^^vv"); 5256 // replace string, empty new delimeter 5257 strcpy(s, "#ee#ee#ad"); 5258 r = bicReplaceManyS(s, "#","","ad","AD"); 5259 ck_assert_ptr_eq(r, s); 5260 ck_assert_str_eq(s, "eeeeAD"); 5261 // not enough olds:news pairs 5262 strcpy(s, "#ee#ee#ad"); 5263 r = bicReplaceManyS(s, "#","","ad"); 5264 ck_assert_ptr_eq(r, s); 5265 ck_assert_str_eq(s, "eeeead"); 5266 // only 2 parameters 5267 // doesn't compile 5268 /* strcpy(s, "#ee#ee#ad"); */ 5269 /* bicReplaceManyS(s, "#"); */ 5270 /* ck_assert_str_eq(s, "#ee#ee#ad"); */ 5271 /* free(s); */ 5272 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 5273 strcpy(s, "#ee#ee#ad"); 5274 r = bicReplaceManyS(s, "#", NULL); 5275 ck_assert_ptr_eq(r, s); 5276 ck_assert_str_eq(s, "#ee#ee#ad"); 5277 // empty string 5278 bEmptyS(s); 5279 r = bicReplaceManyS(s, "#", ""); 5280 ck_assert_ptr_eq(r, null); 5281 ck_assert_str_eq(s, ""); 5282 // empty string many pairs 5283 bEmptyS(s); 5284 r = bicReplaceManyS(s, "#", "", "%", ""); 5285 ck_assert_ptr_eq(r, null); 5286 ck_assert_str_eq(s, ""); 5287 // many pairs empty olds 5288 strcpy(s, "qw#e"); 5289 r = bicReplaceManyS(s, "#", "", "", ""); 5290 ck_assert_ptr_eq(r, s); 5291 ck_assert_str_eq(s, "qwe"); 5292 // NULL old delimiter 5293 strcpy(s, "qw#e"); 5294 r = bicReplaceManyS(s, NULL, ""); 5295 ck_assert_ptr_eq(r, s); 5296 ck_assert_str_eq(s, "qw#e"); 5297 // NULL old delimiter not first - same as replace empty string 5298 strcpy(s, "qw#e"); 5299 r = bicReplaceManyS(s, "#","|", NULL, ""); 5300 ck_assert_ptr_eq(r, s); 5301 ck_assert_str_eq(s, "qw|e"); 5302 // empty old delimiter 5303 strcpy(s, "qw#e"); 5304 r = bicReplaceManyS(s, "","|", NULL, ""); 5305 ck_assert_ptr_eq(r, s); 5306 ck_assert_str_eq(s, "qw#e"); 5307 // empty old delimiter not first 5308 strcpy(s, "qw#e"); 5309 r = bicReplaceManyS(s, "#","|", "", "*"); 5310 ck_assert_ptr_eq(r, s); 5311 ck_assert_str_eq(s, "qw|e"); 5312 // NULL var 5313 r = bicReplaceManyS(NULL, "#","|", "$", "*"); 5314 ck_assert_ptr_eq(r, null); 5315 5316 5317 END_TEST 5318 5319 5320 START_TEST(bLicReplaceManyST) 5321 5322 char s[100]; 5323 char *r = null; 5324 5325 // replace string, multiple character new delimeter 5326 strcpy(s, "#ee#ee#ad"); 5327 r = bLicReplaceManyS(s, sizeof s, "#","^^","AD","vv"); 5328 ck_assert_ptr_eq(r, s); 5329 ck_assert_str_eq(s, "^^ee^^ee^^vv"); 5330 // shorter buffer 5331 strcpy(s, "#ee#ee#ad"); 5332 r = bLicReplaceManyS(s, 5, "#","^^","ad","AD"); 5333 ck_assert_ptr_eq(r, s); 5334 ck_assert_str_eq(s, "^^ee"); 5335 // replace string, empty new delimeter 5336 strcpy(s, "#ee#ee#ad"); 5337 r = bLicReplaceManyS(s, sizeof s, "#","","ad","AD"); 5338 ck_assert_ptr_eq(r, s); 5339 ck_assert_str_eq(s, "eeeeAD"); 5340 // not enough olds:news pairs 5341 strcpy(s, "#ee#ee#ad"); 5342 r = bLicReplaceManyS(s, sizeof s, "#","","ad"); 5343 ck_assert_ptr_eq(r, s); 5344 ck_assert_str_eq(s, "eeeead"); 5345 // only 2 parameters 5346 // doesn't compile 5347 /* strcpy(s, "#ee#ee#ad"); */ 5348 /* bLicReplaceManyS(s, sizeof s, "#"); */ 5349 /* ck_assert_str_eq(s, "#ee#ee#ad"); */ 5350 /* free(s); */ 5351 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 5352 strcpy(s, "#ee#ee#ad"); 5353 r = bLicReplaceManyS(s, sizeof s, "#", NULL); 5354 ck_assert_ptr_eq(r, s); 5355 ck_assert_str_eq(s, "#ee#ee#ad"); 5356 // empty string 5357 bEmptyS(s); 5358 r = bLicReplaceManyS(s, sizeof s, "#", ""); 5359 ck_assert_ptr_eq(r, null); 5360 ck_assert_str_eq(s, ""); 5361 // empty string many pairs 5362 bEmptyS(s); 5363 r = bLicReplaceManyS(s, sizeof s, "#", "", "%", ""); 5364 ck_assert_ptr_eq(r, null); 5365 ck_assert_str_eq(s, ""); 5366 // many pairs empty olds 5367 strcpy(s, "qw#e"); 5368 r = bLicReplaceManyS(s, sizeof s, "#", "", "", ""); 5369 ck_assert_ptr_eq(r, s); 5370 ck_assert_str_eq(s, "qwe"); 5371 // NULL old delimiter 5372 strcpy(s, "qw#e"); 5373 r = bLicReplaceManyS(s, sizeof s, NULL, ""); 5374 ck_assert_ptr_eq(r, s); 5375 ck_assert_str_eq(s, "qw#e"); 5376 // NULL old delimiter not first - same as replace empty string 5377 strcpy(s, "qw#e"); 5378 r = bLicReplaceManyS(s, sizeof s, "#","|", NULL, ""); 5379 ck_assert_ptr_eq(r, s); 5380 ck_assert_str_eq(s, "qw|e"); 5381 // empty old delimiter 5382 strcpy(s, "qw#e"); 5383 r = bLicReplaceManyS(s, sizeof s, "","|", NULL, ""); 5384 ck_assert_ptr_eq(r, s); 5385 ck_assert_str_eq(s, "qw#e"); 5386 // empty old delimiter not first 5387 strcpy(s, "qw#e"); 5388 r = bLicReplaceManyS(s, sizeof s, "#","|", "", "*"); 5389 ck_assert_ptr_eq(r, s); 5390 ck_assert_str_eq(s, "qw|e"); 5391 // size 0 - no change 5392 r = bLicReplaceManyS(s, 0, "#","|", "", "*"); 5393 ck_assert_ptr_eq(r, s); 5394 ck_assert_str_eq(s, "qw|e"); 5395 // NULL var 5396 r = bLicReplaceManyS(NULL, sizeof s, "#","|", "$", "*"); 5397 ck_assert_ptr_eq(r, null); 5398 5399 5400 END_TEST 5401 5402 5403 START_TEST(eqST) 5404 5405 // identical strings 5406 ck_assert(eqS("shee", "shee")); 5407 // different strings 5408 ck_assert(!eqS("shee", "SH")); 5409 // empty strings 5410 ck_assert(!eqS("shee", "")); 5411 ck_assert(!eqS("", "SH")); 5412 ck_assert(eqS("", "")); 5413 // NULL string 5414 ck_assert(!eqS(NULL,"a")); 5415 ck_assert(!eqS("a", NULL)); 5416 5417 END_TEST 5418 5419 5420 START_TEST(eqCharST) 5421 5422 // identical strings 5423 ck_assert(eqCharS('s', "s")); 5424 // different strings 5425 ck_assert(!eqCharS('s', "SH")); 5426 // empty strings 5427 ck_assert(!eqCharS('s', "")); 5428 ck_assert(!eqCharS(0, "SH")); 5429 ck_assert(eqCharS(0, "")); 5430 // NULL string 5431 ck_assert(!eqCharS(0,"a")); 5432 ck_assert(!eqCharS('a', NULL)); 5433 5434 END_TEST 5435 5436 5437 START_TEST(eqSCharT) 5438 5439 // identical strings 5440 ck_assert(eqSChar("s", 's')); 5441 // different strings 5442 ck_assert(!eqSChar("shee", 'S')); 5443 // empty strings 5444 ck_assert(!eqSChar("shee", 0)); 5445 ck_assert(!eqSChar("", 'S')); 5446 ck_assert(eqSChar("", 0)); 5447 // NULL string 5448 ck_assert(!eqSChar(NULL,'a')); 5449 ck_assert(!eqS("a", 0)); 5450 5451 END_TEST 5452 5453 5454 START_TEST(eqIST) 5455 5456 // identical strings 5457 ck_assert(eqIS("Ashee|", "shee", 1)); 5458 ck_assert(eqIS("Ashee", "shee", -4)); 5459 // string at index shorter than string2 5460 ck_assert(!eqIS("Ashee", "shee", 2)); 5461 // empty string 5462 ck_assert(!eqIS("", "shee", 0)); 5463 ck_assert(!eqIS("Ashee", "", 0)); 5464 ck_assert(eqIS("", "", 0)); 5465 // index mismatch 5466 ck_assert(!eqIS("Ashee", "shee", 0)); 5467 // index outside 5468 ck_assert(!eqIS("Ashee", "shee", 10)); 5469 ck_assert(!eqIS("Ashee", "shee", -10)); 5470 // different strings 5471 ck_assert(!eqIS("shee", "SH",0)); 5472 // NULL string 5473 ck_assert(!eqIS(NULL,"a", 0)); 5474 ck_assert(!eqIS("a", NULL, 0)); 5475 5476 END_TEST 5477 5478 5479 START_TEST(eqICharST) 5480 5481 // identical strings 5482 ck_assert(eqICharS("Ashee", 's', 1)); 5483 ck_assert(eqICharS("Ashee", 's', -4)); 5484 // string at index shorter than string2 5485 ck_assert(!eqICharS("Ashee", 's', 2)); 5486 // empty string 5487 ck_assert(!eqICharS("", 's', 0)); 5488 ck_assert(!eqICharS("Ashee", 0, 0)); 5489 ck_assert(eqICharS("", 0, 0)); 5490 // index mismatch 5491 ck_assert(!eqICharS("Ashee", 's', 0)); 5492 // index outside 5493 ck_assert(!eqICharS("Ashee", 's', 10)); 5494 ck_assert(!eqICharS("Ashee", 's', -10)); 5495 // different strings 5496 ck_assert(!eqICharS("shee", 'S',0)); 5497 // NULL string 5498 ck_assert(!eqICharS(NULL,'a', 0)); 5499 ck_assert(!eqICharS("a", 0, 0)); 5500 5501 END_TEST 5502 5503 5504 START_TEST(startsWithST) 5505 5506 // identical strings 5507 ck_assert(startsWithS("shee", "shee")); 5508 ck_assert(startsWithS("sheepy", "shee")); 5509 // different strings 5510 ck_assert(!startsWithS("shee", "SH")); 5511 ck_assert(!startsWithS("shee", "sheep")); 5512 ck_assert(!startsWithS("-shee", "shee")); 5513 // NULL string 5514 ck_assert(!startsWithS(NULL,"a")); 5515 ck_assert(!startsWithS("a", NULL)); 5516 5517 END_TEST 5518 5519 5520 START_TEST(startsWithCharST) 5521 5522 // identical strings 5523 ck_assert(startsWithCharS("shee", 's')); 5524 ck_assert(startsWithCharS("sheepy", 's')); 5525 ck_assert(startsWithCharS("", 0)); 5526 // different strings 5527 ck_assert(!startsWithCharS("shee", 'S')); 5528 ck_assert(!startsWithCharS("-shee", 's')); 5529 ck_assert(!startsWithCharS("", '0')); 5530 // NULL string 5531 ck_assert(!startsWithCharS(NULL,'a')); 5532 ck_assert(!startsWithCharS("a", 0)); 5533 5534 END_TEST 5535 5536 5537 START_TEST(endsWithST) 5538 5539 // identical strings 5540 ck_assert(endsWithS("shee", "shee")); 5541 ck_assert(endsWithS("sheepy", "eepy")); 5542 // different strings 5543 ck_assert(!endsWithS("shee", "SH")); 5544 ck_assert(!endsWithS("shee", "sheep")); 5545 ck_assert(!endsWithS("shee-", "shee")); 5546 // NULL string 5547 ck_assert(!endsWithS(NULL,"a")); 5548 ck_assert(!endsWithS("a", NULL)); 5549 5550 END_TEST 5551 5552 5553 START_TEST(endsWithCharST) 5554 5555 // identical strings 5556 ck_assert(endsWithCharS("shee", 'e')); 5557 ck_assert(endsWithCharS("sheepy", 'y')); 5558 ck_assert(endsWithCharS("", 0)); 5559 // different strings 5560 ck_assert(!endsWithCharS("shee", 'E')); 5561 ck_assert(!endsWithCharS("shee", 'p')); 5562 ck_assert(!endsWithCharS("shee-", 'e')); 5563 ck_assert(!endsWithCharS("", '0')); 5564 // NULL string 5565 ck_assert(!endsWithCharS(NULL,'a')); 5566 ck_assert(!endsWithCharS("a", 0)); 5567 5568 END_TEST 5569 5570 5571 START_TEST(countST) 5572 5573 // positive count 5574 ck_assert_int_eq(countS("shee", "shee"), 1); 5575 ck_assert_int_eq(countS("aaa aaa", "a"), 6); 5576 ck_assert_int_eq(countS("aaa aaa", "aa"), 2); 5577 // 0 count 5578 ck_assert_int_eq(countS("shee", "SH"), 0); 5579 ck_assert_int_eq(countS("shee", "sheepy"), 0); 5580 ck_assert_int_eq(countS("aaa aaa", "ab"), 0); 5581 // empty string 5582 ck_assert_int_eq(countS("shee", ""), -1); 5583 // NULL string 5584 ck_assert_int_eq(countS(NULL,"a"), -1); 5585 ck_assert_int_eq(countS("a", NULL), -1); 5586 5587 END_TEST 5588 5589 5590 START_TEST(countCharST) 5591 5592 // positive count 5593 ck_assert_int_eq(countCharS("shee", 's'), 1); 5594 ck_assert_int_eq(countCharS("aaa aaa", 'a'), 6); 5595 // 0 count 5596 ck_assert_int_eq(countCharS("shee", 'S'), 0); 5597 ck_assert_int_eq(countCharS("shee", 'y'), 0); 5598 ck_assert_int_eq(countCharS("aaa aaa", 'b'), 0); 5599 // empty string 5600 ck_assert_int_eq(countCharS("", 'a'), 0); 5601 ck_assert_int_eq(countCharS("", 0), -1); 5602 // NULL string 5603 ck_assert_int_eq(countCharS(NULL,'a'), -1); 5604 ck_assert_int_eq(countCharS("a", 0), -1); 5605 5606 END_TEST 5607 5608 5609 START_TEST(icEqST) 5610 5611 // identical strings 5612 ck_assert(icEqS("SHEE", "shee")); 5613 // different strings 5614 ck_assert(!icEqS("shee", "SH")); 5615 // empty strings 5616 ck_assert(!icEqS("shee", "")); 5617 ck_assert(!icEqS("", "SH")); 5618 ck_assert(icEqS("", "")); 5619 // NULL string 5620 ck_assert(!icEqS(NULL,"a")); 5621 ck_assert(!icEqS("a", NULL)); 5622 5623 5624 END_TEST 5625 5626 5627 START_TEST(icEqCharST) 5628 5629 // identical strings 5630 ck_assert(icEqCharS('S', "s")); 5631 // different strings 5632 ck_assert(!icEqCharS('s', "SH")); 5633 // empty strings 5634 ck_assert(!icEqCharS('s', "")); 5635 ck_assert(!icEqCharS(0, "SH")); 5636 ck_assert(icEqCharS(0, "")); 5637 // NULL string 5638 ck_assert(!icEqCharS(0,"a")); 5639 ck_assert(!icEqCharS('a', NULL)); 5640 5641 5642 END_TEST 5643 5644 5645 START_TEST(icEqSCharT) 5646 5647 // identical strings 5648 ck_assert(icEqSChar("S", 's')); 5649 // different strings 5650 ck_assert(!icEqSChar("shee", 'S')); 5651 // empty strings 5652 ck_assert(!icEqSChar("shee", 0)); 5653 ck_assert(!icEqSChar("", 'S')); 5654 ck_assert(icEqSChar("", 0)); 5655 // NULL string 5656 ck_assert(!icEqSChar(NULL,'a')); 5657 ck_assert(!eqS("a", 0)); 5658 5659 5660 END_TEST 5661 5662 5663 START_TEST(icEqIST) 5664 5665 // identical strings 5666 ck_assert(icEqIS("AshEe|", "shee", 1)); 5667 ck_assert(icEqIS("AshEE", "shee", -4)); 5668 // string at index shorter than string2 5669 ck_assert(!icEqIS("Ashee", "shee", 2)); 5670 // empty string 5671 ck_assert(!icEqIS("", "shee", 0)); 5672 ck_assert(!icEqIS("Ashee", "", 0)); 5673 ck_assert(icEqIS("", "", 0)); 5674 // index mismatch 5675 ck_assert(!icEqIS("Ashee", "shee", 0)); 5676 // index outside 5677 ck_assert(!icEqIS("Ashee", "shee", 10)); 5678 ck_assert(!icEqIS("Ashee", "shee", -10)); 5679 // different strings 5680 ck_assert(!icEqIS("shee", "Sg",0)); 5681 // NULL string 5682 ck_assert(!icEqIS(NULL,"a", 0)); 5683 ck_assert(!icEqIS("a", NULL, 0)); 5684 5685 5686 END_TEST 5687 5688 5689 START_TEST(icEqICharST) 5690 5691 // identical strings 5692 ck_assert(icEqICharS("ASHEE", 's', 1)); 5693 ck_assert(icEqICharS("Ashee", 's', -4)); 5694 // string at index shorter than string2 5695 ck_assert(!icEqICharS("Ashee", 's', 2)); 5696 // empty string 5697 ck_assert(!icEqICharS("", 's', 0)); 5698 ck_assert(!icEqICharS("Ashee", 0, 0)); 5699 ck_assert(icEqICharS("", 0, 0)); 5700 // index mismatch 5701 ck_assert(!icEqICharS("Ashee", 's', 0)); 5702 // index outside 5703 ck_assert(!icEqICharS("Ashee", 's', 10)); 5704 ck_assert(!icEqICharS("Ashee", 's', -10)); 5705 // different strings 5706 ck_assert(!icEqICharS("shee", 'd',0)); 5707 // NULL string 5708 ck_assert(!icEqICharS(NULL,'a', 0)); 5709 ck_assert(!icEqICharS("a", 0, 0)); 5710 5711 5712 END_TEST 5713 5714 5715 START_TEST(icStartsWithST) 5716 5717 // identical strings 5718 ck_assert(icStartsWithS("SHEE", "shee")); 5719 ck_assert(icStartsWithS("SHEEPY", "shee")); 5720 // different strings 5721 ck_assert(!icStartsWithS("shee", "aH")); 5722 ck_assert(!icStartsWithS("shee", "sheep")); 5723 ck_assert(!icStartsWithS("-shee", "shee")); 5724 // NULL string 5725 ck_assert(!icStartsWithS(NULL,"a")); 5726 ck_assert(!icStartsWithS("a", NULL)); 5727 5728 5729 END_TEST 5730 5731 5732 START_TEST(icStartsWithCharST) 5733 5734 // identical strings 5735 ck_assert(icStartsWithCharS("Shee", 's')); 5736 ck_assert(icStartsWithCharS("Sheepy", 's')); 5737 ck_assert(icStartsWithCharS("", 0)); 5738 // different strings 5739 ck_assert(!icStartsWithCharS("shee", 'a')); 5740 ck_assert(!icStartsWithCharS("-shee", 's')); 5741 ck_assert(!icStartsWithCharS("", '0')); 5742 // NULL string 5743 ck_assert(!icStartsWithCharS(NULL,'a')); 5744 ck_assert(!icStartsWithCharS("a", 0)); 5745 5746 5747 END_TEST 5748 5749 5750 START_TEST(icEndsWithST) 5751 5752 // identical strings 5753 ck_assert(icEndsWithS("SHEE", "shee")); 5754 ck_assert(icEndsWithS("SHEEPY", "eepy")); 5755 // different strings 5756 ck_assert(!icEndsWithS("shee", "SH")); 5757 ck_assert(!icEndsWithS("shee", "sheep")); 5758 ck_assert(!icEndsWithS("shee-", "shee")); 5759 // NULL string 5760 ck_assert(!icEndsWithS(NULL,"a")); 5761 ck_assert(!icEndsWithS("a", NULL)); 5762 5763 5764 END_TEST 5765 5766 5767 START_TEST(icEndsWithCharST) 5768 5769 // identical strings 5770 ck_assert(icEndsWithCharS("sheE", 'e')); 5771 ck_assert(icEndsWithCharS("sheepY", 'y')); 5772 ck_assert(icEndsWithCharS("", 0)); 5773 // different strings 5774 ck_assert(!icEndsWithCharS("shee", 'R')); 5775 ck_assert(!icEndsWithCharS("shee", 'p')); 5776 ck_assert(!icEndsWithCharS("shee-", 'e')); 5777 ck_assert(!icEndsWithCharS("", '0')); 5778 // NULL string 5779 ck_assert(!icEndsWithCharS(NULL,'a')); 5780 ck_assert(!icEndsWithCharS("a", 0)); 5781 5782 5783 END_TEST 5784 5785 5786 START_TEST(icCountST) 5787 5788 // positive count 5789 ck_assert_int_eq(icCountS("SHEE", "shee"), 1); 5790 ck_assert_int_eq(icCountS("AAA AAA", "a"), 6); 5791 ck_assert_int_eq(icCountS("AAA AAA", "aa"), 2); 5792 // 0 count 5793 ck_assert_int_eq(icCountS("shee", "eSH"), 0); 5794 ck_assert_int_eq(icCountS("shee", "sheepy"), 0); 5795 ck_assert_int_eq(icCountS("aaa aaa", "ab"), 0); 5796 // empty needle 5797 ck_assert_int_eq(icCountS("aaa aaa", ""), -1); 5798 // NULL string 5799 ck_assert_int_eq(icCountS(NULL,"a"), -1); 5800 ck_assert_int_eq(icCountS("a", NULL), -1); 5801 5802 5803 END_TEST 5804 5805 5806 START_TEST(icCountCharST) 5807 5808 // positive count 5809 ck_assert_int_eq(icCountCharS("Shee", 's'), 1); 5810 ck_assert_int_eq(icCountCharS("AAA aaa", 'a'), 6); 5811 // 0 count 5812 ck_assert_int_eq(icCountCharS("shee", '0'), 0); 5813 ck_assert_int_eq(icCountCharS("shee", 'y'), 0); 5814 ck_assert_int_eq(icCountCharS("aaa aaa", 'b'), 0); 5815 // empty string 5816 ck_assert_int_eq(icCountCharS("", 'a'), 0); 5817 ck_assert_int_eq(icCountCharS("", 0), -1); 5818 // NULL string 5819 ck_assert_int_eq(icCountCharS(NULL,'a'), -1); 5820 ck_assert_int_eq(icCountCharS("a", 0), -1); 5821 5822 5823 END_TEST 5824 5825 5826 START_TEST(hasCtrlCharT) 5827 5828 // string with control char 5829 ck_assert(hasCtrlChar("\tsheepy\n")); 5830 // no control char 5831 ck_assert(!hasCtrlChar("sheepy")); 5832 // null string 5833 ck_assert(!hasCtrlChar(null)); 5834 5835 5836 END_TEST 5837 5838 5839 START_TEST(stripCtrlST) 5840 5841 char *r; 5842 5843 // string with control char 5844 r = stripCtrlS("\tsheepy\n"); 5845 ck_assert_str_eq(r, "sheepy"); 5846 free(r); 5847 // no control char 5848 r = stripCtrlS("sheepy"); 5849 ck_assert_str_eq(r, "sheepy"); 5850 free(r); 5851 // null string 5852 r = stripCtrlS(null); 5853 ck_assert_ptr_eq(r, null); 5854 5855 5856 END_TEST 5857 5858 5859 START_TEST(iStripCtrlST) 5860 5861 char *r, *s; 5862 5863 // string with control char 5864 s = strdup("\tsheepy\n"); 5865 r = iStripCtrlS(&s); 5866 ck_assert_str_eq(r, "sheepy"); 5867 free(r); 5868 // no control char 5869 s = strdup("sheepy"); 5870 r = iStripCtrlS(&s); 5871 ck_assert_str_eq(r, "sheepy"); 5872 free(r); 5873 // null string 5874 s = null; 5875 r = iStripCtrlS(&s); 5876 ck_assert_ptr_eq(r, null); 5877 r = iStripCtrlS(null); 5878 ck_assert_ptr_eq(r, null); 5879 5880 5881 END_TEST 5882 5883 5884 START_TEST(bStripCtrlST) 5885 5886 char *r; 5887 char s[40]; 5888 5889 // string with control char 5890 r = strLCpy(s, sizeof(s), "\tsheepy\n"); 5891 ck_assert_ptr_eq(r, s); 5892 r = bStripCtrlS(s); 5893 ck_assert_str_eq(r, "sheepy"); 5894 // no control char 5895 r = strLCpy(s, sizeof(s), "sheepy"); 5896 ck_assert_ptr_eq(r, s); 5897 r = bStripCtrlS(s); 5898 ck_assert_str_eq(r, "sheepy"); 5899 // null string 5900 r = bStripCtrlS(null); 5901 ck_assert_ptr_eq(r, null); 5902 5903 5904 END_TEST 5905 5906 5907 START_TEST(quoteST) 5908 5909 char *r; 5910 5911 // no change 5912 r = quoteS("abc", '"'); 5913 ck_assert_str_eq(r, "abc"); 5914 free(r); 5915 // add backslashes 5916 r = quoteS("\"abc\\", '"'); 5917 ck_assert_str_eq(r, "\\\"abc\\\\"); 5918 free(r); 5919 // null string 5920 ck_assert_ptr_eq(quoteS(null, 0), null); 5921 5922 END_TEST 5923 5924 5925 START_TEST(bQuoteST) 5926 5927 char *r; 5928 char s[40]; 5929 5930 // no change 5931 r = bQuoteS(s, "abc", '"'); 5932 ck_assert_str_eq(r, "abc"); 5933 // add backslashes 5934 r = bQuoteS(s, "\"abc\\", '"'); 5935 ck_assert_str_eq(r, "\\\"abc\\\\"); 5936 // null string 5937 ck_assert_ptr_eq(bQuoteS(s, null, 0), null); 5938 // null dest 5939 ck_assert_ptr_eq(bQuoteS(null, "asd", 0), null); 5940 5941 END_TEST 5942 5943 5944 START_TEST(bLQuoteST) 5945 5946 char *r; 5947 char s[40]; 5948 5949 // no change 5950 r = bLQuoteS(s, sizeof(s), "abc", '"'); 5951 ck_assert_str_eq(r, "abc"); 5952 // add backslashes 5953 r = bLQuoteS(s, sizeof(s), "\"abc\\", '"'); 5954 ck_assert_str_eq(r, "\\\"abc\\\\"); 5955 // too small dest buffer 5956 r = bLQuoteS(s, 3, "abc", '"'); 5957 ck_assert_str_eq(r, "ab"); 5958 r = bLQuoteS(s, 3, "a\\\"", '"'); 5959 ck_assert_str_eq(r, "a"); 5960 r = bLQuoteS(s, 3, "ab\"", '"'); 5961 ck_assert_str_eq(r, "ab"); 5962 // null string 5963 ck_assert_ptr_eq(bLQuoteS(s, 10, null, 0), null); 5964 // null dest 5965 ck_assert_ptr_eq(bLQuoteS(null, 10, "asd", 0), null); 5966 // 0 dest size 5967 ck_assert_ptr_eq(bLQuoteS(s, 0, "asd", 0), null); 5968 5969 END_TEST 5970 5971 5972 START_TEST(quoteLenST) 5973 5974 size_t r; 5975 5976 // no change 5977 r = quoteLenS("abc", '"'); 5978 ck_assert_int_eq(r, 3); 5979 // add backslashes 5980 r = quoteLenS("\"abc\\", '"'); 5981 ck_assert_int_eq(r, 7); 5982 // null string 5983 ck_assert_int_eq(quoteLenS(null, 0), 0); 5984 5985 END_TEST 5986 5987 5988 START_TEST(escapeST) 5989 5990 char *r; 5991 5992 // no change 5993 r = escapeS("abc", '"'); 5994 ck_assert_str_eq(r, "abc"); 5995 free(r); 5996 // add backslashes 5997 r = escapeS("\b\f\r\t\"abc\n\\", '"'); 5998 ck_assert_str_eq(r, "\\b\\f\\r\\t\\\"abc\\n\\\\"); 5999 free(r); 6000 // null string 6001 ck_assert_ptr_eq(escapeS(null, 0), null); 6002 6003 END_TEST 6004 6005 6006 START_TEST(bEscapeST) 6007 6008 char *r; 6009 char s[40]; 6010 6011 // no change 6012 r = bEscapeS(s, "abc", '"'); 6013 ck_assert_str_eq(r, "abc"); 6014 // add backslashes 6015 r = bEscapeS(s, "\b\f\r\t\"abc\n\\", '"'); 6016 ck_assert_str_eq(r, "\\b\\f\\r\\t\\\"abc\\n\\\\"); 6017 // null string 6018 ck_assert_ptr_eq(bEscapeS(s, null, 0), null); 6019 // null dest 6020 ck_assert_ptr_eq(bEscapeS(null, "asd", 0), null); 6021 6022 END_TEST 6023 6024 6025 START_TEST(bLEscapeST) 6026 6027 char *r; 6028 char s[40]; 6029 6030 // no change 6031 r = bLEscapeS(s, sizeof(s), "abc", '"'); 6032 ck_assert_str_eq(r, "abc"); 6033 // add backslashes 6034 r = bLEscapeS(s, sizeof(s), "\b\f\r\t\"abc\n\\", '"'); 6035 ck_assert_str_eq(r, "\\b\\f\\r\\t\\\"abc\\n\\\\"); 6036 // too small dest buffer 6037 r = bLEscapeS(s, 3, "abc", '"'); 6038 ck_assert_str_eq(r, "ab"); 6039 r = bLEscapeS(s, 3, "a\\\"", '"'); 6040 ck_assert_str_eq(r, "a"); 6041 r = bLEscapeS(s, 3, "ab\"", '"'); 6042 ck_assert_str_eq(r, "ab"); 6043 r = bLEscapeS(s, 3, "a\t", '"'); 6044 ck_assert_str_eq(r, "a"); 6045 // null string 6046 ck_assert_ptr_eq(bLEscapeS(s, 10, null, 0), null); 6047 // null dest 6048 ck_assert_ptr_eq(bLEscapeS(null, 10, "asd", 0), null); 6049 // 0 dest size 6050 ck_assert_ptr_eq(bLEscapeS(s, 0, "asd", 0), null); 6051 6052 END_TEST 6053 6054 6055 START_TEST(escapeLenST) 6056 6057 size_t r; 6058 6059 // no change 6060 r = escapeLenS("abc", '"'); 6061 ck_assert_int_eq(r, 3); 6062 // add backslashes 6063 r = escapeLenS("\"abc\b", '"'); 6064 ck_assert_int_eq(r, 7); 6065 // null string 6066 ck_assert_int_eq(escapeLenS(null, 0), 0); 6067 6068 END_TEST 6069 6070 6071 START_TEST(nibbleToHexT) 6072 6073 char r; 6074 6075 r = nibbleToHex(9); 6076 ck_assert_int_eq(r, '9'); 6077 r = nibbleToHex(15); 6078 ck_assert_int_eq(r, 'F'); 6079 // out of range 6080 r = nibbleToHex(30); 6081 ck_assert_int_eq(r, 'X'); 6082 6083 END_TEST 6084 6085 6086 START_TEST(cEscapeST) 6087 6088 char *r; 6089 6090 // no change 6091 r = cEscapeS("abc"); 6092 ck_assert_str_eq(r, "abc"); 6093 free(r); 6094 // add backslashes 6095 r = cEscapeS("\n\a\b\f\r\t\"ab\x03\v\\"); 6096 ck_assert_str_eq(r, "\\n\\a\\b\\f\\r\\t\\\"ab\"\"\\x03\"\"\\v\\\\"); 6097 free(r); 6098 // null string 6099 ck_assert_ptr_eq(cEscapeS(null), null); 6100 6101 END_TEST 6102 6103 6104 START_TEST(bCEscapeST) 6105 6106 char *r; 6107 char s[40]; 6108 6109 // no change 6110 r = bCEscapeS(s, "abc"); 6111 ck_assert_str_eq(r, "abc"); 6112 // add backslashes 6113 r = bCEscapeS(s, "\n\a\b\f\r\t\"ab\x03\v\\"); 6114 ck_assert_str_eq(r, "\\n\\a\\b\\f\\r\\t\\\"ab\"\"\\x03\"\"\\v\\\\"); 6115 // null string 6116 ck_assert_ptr_eq(bCEscapeS(s, null), null); 6117 // null dest 6118 ck_assert_ptr_eq(bCEscapeS(null, "asd"), null); 6119 6120 END_TEST 6121 6122 6123 START_TEST(bLCEscapeST) 6124 6125 char *r; 6126 char s[40]; 6127 6128 // no change 6129 r = bLCEscapeS(s, sizeof(s), "abc"); 6130 ck_assert_str_eq(r, "abc"); 6131 // add backslashes 6132 r = bLCEscapeS(s, sizeof(s), "\n\a\b\f\r\t\"ab\x03\v\\"); 6133 ck_assert_str_eq(r, "\\n\\a\\b\\f\\r\\t\\\"ab\"\"\\x03\"\"\\v\\\\"); 6134 // too small dest buffer 6135 r = bLCEscapeS(s, 3, "abc"); 6136 ck_assert_str_eq(r, "ab"); 6137 r = bLCEscapeS(s, 3, "a\\\""); 6138 ck_assert_str_eq(r, "a"); 6139 r = bLCEscapeS(s, 3, "ab\""); 6140 ck_assert_str_eq(r, "ab"); 6141 r = bLCEscapeS(s, 3, "a\a"); 6142 ck_assert_str_eq(r, "a"); 6143 r = bLCEscapeS(s, 3, "a\b"); 6144 ck_assert_str_eq(r, "a"); 6145 r = bLCEscapeS(s, 3, "a\t"); 6146 ck_assert_str_eq(r, "a"); 6147 r = bLCEscapeS(s, 3, "a\n"); 6148 ck_assert_str_eq(r, "a"); 6149 r = bLCEscapeS(s, 3, "a\v"); 6150 ck_assert_str_eq(r, "a"); 6151 r = bLCEscapeS(s, 3, "a\f"); 6152 ck_assert_str_eq(r, "a"); 6153 r = bLCEscapeS(s, 3, "a\r"); 6154 ck_assert_str_eq(r, "a"); 6155 r = bLCEscapeS(s, 3, "a\x01"); 6156 ck_assert_str_eq(r, "a"); 6157 // null string 6158 ck_assert_ptr_eq(bLCEscapeS(s, 10, null), null); 6159 // null dest 6160 ck_assert_ptr_eq(bLCEscapeS(null, 10, "asd"), null); 6161 // 0 dest size 6162 ck_assert_ptr_eq(bLCEscapeS(s, 0, "asd"), null); 6163 6164 END_TEST 6165 6166 6167 START_TEST(cEscapeLenST) 6168 6169 size_t r; 6170 6171 // no change 6172 r = cEscapeLenS("abc"); 6173 ck_assert_int_eq(r, 3); 6174 // add backslashes 6175 r = cEscapeLenS("\"abc\b\x01"); 6176 ck_assert_int_eq(r, 15); 6177 // null string 6178 ck_assert_int_eq(cEscapeLenS(null), 0); 6179 6180 END_TEST 6181 6182 6183 START_TEST(isNumberT) 6184 6185 // number 6186 ck_assert(isNumber("-12.3")); 6187 ck_assert(isNumber("-123")); 6188 ck_assert(isNumber("123")); 6189 ck_assert(isNumber("1e23")); 6190 ck_assert(isNumber("12E-3")); 6191 ck_assert(isNumber(".123")); 6192 ck_assert(isNumber("-.123")); 6193 ck_assert(isNumber("1E+32")); 6194 // not a number 6195 ck_assert(!isNumber(".12e3")); 6196 ck_assert(!isNumber("-.12e3")); 6197 ck_assert(!isNumber("-1-23")); 6198 ck_assert(!isNumber("123-")); 6199 ck_assert(!isNumber("-")); 6200 ck_assert(!isNumber("-123.")); 6201 ck_assert(!isNumber("-1.2.3")); 6202 ck_assert(!isNumber("1-2.3")); 6203 ck_assert(!isNumber("12..3")); 6204 ck_assert(!isNumber(".12.3")); 6205 ck_assert(!isNumber(".")); 6206 ck_assert(!isNumber("E12")); 6207 ck_assert(!isNumber("E1E2")); 6208 ck_assert(!isNumber("E1.2")); 6209 ck_assert(!isNumber("1E")); 6210 ck_assert(!isNumber("1E2.3")); 6211 ck_assert(!isNumber("1-")); 6212 ck_assert(!isNumber("1E-")); 6213 ck_assert(!isNumber("lib123sheepy")); 6214 // string without number 6215 ck_assert(!isNumber("s")); 6216 // empty string 6217 ck_assert(!isNumber("")); 6218 // NULL string 6219 ck_assert(!isNumber(NULL)); 6220 6221 END_TEST 6222 6223 6224 START_TEST(isIntT) 6225 6226 // integer 6227 ck_assert(isInt("-123")); 6228 ck_assert(isInt("123")); 6229 // not a integer 6230 ck_assert(!isInt("1e23")); 6231 ck_assert(!isInt("12E-3")); 6232 ck_assert(!isInt("-12.3")); 6233 ck_assert(!isInt("-1-23")); 6234 ck_assert(!isInt("123-")); 6235 ck_assert(!isInt("-")); 6236 ck_assert(!isInt("-123.")); 6237 ck_assert(!isInt(".123")); 6238 ck_assert(!isInt("-1.2.3")); 6239 ck_assert(!isInt("1-2.3")); 6240 ck_assert(!isInt("12..3")); 6241 ck_assert(!isInt(".")); 6242 ck_assert(!isInt("1E")); 6243 ck_assert(!isInt("1-")); 6244 ck_assert(!isInt("1E-")); 6245 ck_assert(!isInt("lib123sheepy")); 6246 // string without number 6247 ck_assert(!isInt("s")); 6248 // empty string 6249 ck_assert(!isInt("")); 6250 // NULL string 6251 ck_assert(!isInt(NULL)); 6252 6253 END_TEST 6254 6255 6256 START_TEST(parseIntT) 6257 6258 // number 6259 ck_assert_int_eq(parseInt("123sheepy"), 123); 6260 ck_assert_int_eq(parseInt("lib123sheepy"), 123); 6261 ck_assert_int_eq(parseInt("-123"), -123); 6262 // out of range - TODO check stderr 6263 int r = parseInt("999999999999999999999999999999999999999"); 6264 ck_assert_int_eq(r, -1); 6265 // string without number 6266 ck_assert_int_eq(parseInt("sheepy"), 0); 6267 // NULL string 6268 ck_assert_int_eq(parseInt(NULL), 0); 6269 6270 END_TEST 6271 6272 6273 START_TEST(parseIntCharT) 6274 6275 // number 6276 ck_assert_int_eq(parseIntChar('1'),1); 6277 ck_assert_int_eq(parseIntChar('0'),0); 6278 ck_assert_int_eq(parseIntChar('9'),9); 6279 // not a number 6280 ck_assert_int_eq(parseIntChar('a'),-1); 6281 ck_assert_int_eq(parseIntChar(0),-1); 6282 6283 END_TEST 6284 6285 6286 START_TEST(parseI64T) 6287 6288 // number 6289 ck_assert_int_eq(parseI64("123sheepy"), 123); 6290 ck_assert_int_eq(parseI64("lib123sheepy"), 123); 6291 ck_assert_int_eq(parseI64("-123"), -123); 6292 // out of range - TODO check stderr 6293 int r = parseI64("999999999999999999999999999999999999999"); 6294 ck_assert_int_eq(r, -1); 6295 // string without number 6296 ck_assert_int_eq(parseI64("sheepy"), 0); 6297 // NULL string 6298 ck_assert_int_eq(parseI64(NULL), 0); 6299 6300 6301 END_TEST 6302 6303 6304 START_TEST(parseI64CharT) 6305 6306 // number 6307 ck_assert_int_eq(parseI64Char('1'),1); 6308 ck_assert_int_eq(parseI64Char('0'),0); 6309 ck_assert_int_eq(parseI64Char('9'),9); 6310 // not a number 6311 ck_assert_int_eq(parseI64Char('a'),-1); 6312 ck_assert_int_eq(parseI64Char(0),-1); 6313 6314 6315 END_TEST 6316 6317 6318 START_TEST(parseDoubleT) 6319 6320 // number 6321 ck_assert_int_eq(parseDouble("123.2sheepy"), 123); 6322 ck_assert_int_eq(parseDouble("lib123sheepy"), 123); 6323 ck_assert_int_eq(parseDouble("-123"), -123); 6324 // out of range - TODO check stderr 6325 int r = parseDouble("999999999999999999999999999999999999999"); 6326 ck_assert_int_eq(r, -2147483648); 6327 // string without number 6328 ck_assert_int_eq(parseDouble("sheepy"), 0); 6329 // NULL string 6330 ck_assert_int_eq(parseDouble(NULL), 0); 6331 6332 END_TEST 6333 6334 6335 START_TEST(parseDoubleCharT) 6336 6337 // number 6338 ck_assert_int_eq(parseDoubleChar('1'),1); 6339 ck_assert_int_eq(parseDoubleChar('0'),0); 6340 ck_assert_int_eq(parseDoubleChar('9'),9); 6341 // not a number 6342 ck_assert_int_eq(parseDoubleChar('a'),-1); 6343 ck_assert_int_eq(parseDoubleChar(0),-1); 6344 6345 END_TEST 6346 6347 6348 START_TEST(parseHexT) 6349 6350 u64 r; 6351 6352 // hex to int 6353 r = parseHex("0x04"); 6354 ck_assert_int_eq(r, 4); 6355 r = parseHex("aoij0xaa"); 6356 ck_assert_int_eq(r, 170); 6357 // null string 6358 r = parseHex(null); 6359 ck_assert_int_eq(r, 0); 6360 6361 6362 END_TEST 6363 6364 6365 START_TEST(intToST) 6366 6367 // number 6368 char *s = intToS(123); 6369 ck_assert_str_eq(s, "123"); 6370 free(s); 6371 s = intToS(-465464123); 6372 ck_assert_str_eq(s, "-465464123"); 6373 free(s); 6374 6375 END_TEST 6376 6377 6378 START_TEST(bIntToST) 6379 6380 // number 6381 char s[50]; 6382 char *r = null; 6383 6384 r = bIntToS(s, 123); 6385 ck_assert_ptr_eq(r, s); 6386 ck_assert_str_eq(s, "123"); 6387 r = bIntToS(s, -465464123); 6388 ck_assert_ptr_eq(r, s); 6389 ck_assert_str_eq(s, "-465464123"); 6390 // NULL 6391 r = bIntToS(NULL, 123); 6392 ck_assert_ptr_eq(r, null); 6393 6394 END_TEST 6395 6396 6397 START_TEST(doubleToST) 6398 6399 // number 6400 char *s = doubleToS(123.4); 6401 ck_assert_str_eq(s, "1.234000e+02"); 6402 free(s); 6403 s = doubleToS(-4652445e5); 6404 ck_assert_str_eq(s, "-4.652445e+11"); 6405 free(s); 6406 6407 END_TEST 6408 6409 6410 START_TEST(bDoubleToST) 6411 6412 // number 6413 char s[256]; 6414 char *r = null; 6415 6416 r = bDoubleToS(s, 123.4); 6417 ck_assert_ptr_eq(r, s); 6418 ck_assert_str_eq(s, "1.234000e+02"); 6419 r = bDoubleToS(s, -4652445e5); 6420 ck_assert_ptr_eq(r, s); 6421 ck_assert_str_eq(s, "-4.652445e+11"); 6422 // NULL 6423 r = bDoubleToS(NULL, 123.4); 6424 ck_assert_ptr_eq(r, null); 6425 6426 END_TEST 6427 6428 6429 START_TEST(lenST) 6430 6431 // string 6432 ck_assert_uint_eq(lenS("sheepy"), 6); 6433 // NULL string 6434 ck_assert_uint_eq(lenS(NULL), 0); 6435 6436 END_TEST 6437 6438 6439 START_TEST(sizeST) 6440 6441 // string 6442 ck_assert_uint_eq(sizeS("sheepy"), 7); 6443 // NULL string 6444 ck_assert_uint_eq(sizeS(NULL), 0); 6445 6446 END_TEST 6447 6448 6449 START_TEST(upperST) 6450 6451 // string 6452 char *s = upperS("sheepy"); 6453 ck_assert_str_eq(s, "SHEEPY"); 6454 free(s); 6455 // NULL string 6456 ck_assert_ptr_eq(upperS(NULL), NULL); 6457 6458 END_TEST 6459 6460 6461 START_TEST(iUpperST) 6462 6463 char *s; 6464 char *r; 6465 6466 // string 6467 s = strdup("sheepy"); 6468 r = iUpperS(&s); 6469 ck_assert_ptr_eq(r, s); 6470 ck_assert_str_eq(s, "SHEEPY"); 6471 free(s); 6472 // NULL string 6473 s = NULL; 6474 r = iUpperS(&s); 6475 ck_assert_ptr_eq(r, s); 6476 ck_assert_ptr_eq(s, NULL); 6477 // NULL var 6478 r = iUpperS(NULL); 6479 ck_assert_ptr_eq(r, null); 6480 6481 END_TEST 6482 6483 6484 START_TEST(bUpperST) 6485 6486 char s[50]; 6487 char *r = null; 6488 6489 // string 6490 strcpy(s, "sheepy"); 6491 r = bUpperS(s); 6492 ck_assert_ptr_eq(r, s); 6493 ck_assert_str_eq(s, "SHEEPY"); 6494 // NULL var 6495 r = bUpperS(NULL); 6496 ck_assert_ptr_eq(r, null); 6497 6498 END_TEST 6499 6500 6501 START_TEST(lowerST) 6502 6503 // string 6504 char *s = lowerS("SHeePY"); 6505 ck_assert_str_eq(s, "sheepy"); 6506 free(s); 6507 // NULL string 6508 ck_assert_ptr_eq(lowerS(NULL), NULL); 6509 6510 END_TEST 6511 6512 6513 START_TEST(iLowerST) 6514 6515 char *s; 6516 char *r = null; 6517 6518 // string 6519 s = strdup("SHEEPY"); 6520 r = iLowerS(&s); 6521 ck_assert_ptr_eq(r, s); 6522 ck_assert_str_eq(s, "sheepy"); 6523 free(s); 6524 // NULL string 6525 s = NULL; 6526 r = iLowerS(&s); 6527 ck_assert_ptr_eq(r, s); 6528 ck_assert_ptr_eq(s, NULL); 6529 // NULL var 6530 r = iLowerS(NULL); 6531 ck_assert_ptr_eq(r, null); 6532 6533 END_TEST 6534 6535 6536 START_TEST(bLowerST) 6537 6538 char s[50]; 6539 char *r = null; 6540 6541 // string 6542 strcpy(s, "SHEEPY"); 6543 r = bLowerS(s); 6544 ck_assert_ptr_eq(r, s); 6545 ck_assert_str_eq(s, "sheepy"); 6546 // NULL var 6547 r = bLowerS(NULL); 6548 ck_assert_ptr_eq(r, null); 6549 6550 END_TEST 6551 6552 6553 START_TEST(trimST) 6554 6555 // no spaces 6556 char *s = trimS("SHeePY"); 6557 ck_assert_str_eq(s, "SHeePY"); 6558 free(s); 6559 // heading spaces 6560 s = trimS(" SHeePY"); 6561 ck_assert_str_eq(s, "SHeePY"); 6562 free(s); 6563 // trailing spaces 6564 s = trimS("SHeePY "); 6565 ck_assert_str_eq(s, "SHeePY"); 6566 free(s); 6567 // string with spaces in the middle 6568 s = trimS(" SHe ePY "); 6569 ck_assert_str_eq(s, "SHe ePY"); 6570 free(s); 6571 // all spaces 6572 s = trimS(" "); 6573 ck_assert_str_eq(s, ""); 6574 free(s); 6575 // NULL string 6576 ck_assert_ptr_eq(trimS(NULL), NULL); 6577 6578 END_TEST 6579 6580 6581 START_TEST(iTrimST) 6582 6583 char *s; 6584 char *r = null; 6585 6586 // no spaces 6587 s = strdup("SHeePY"); 6588 r = iTrimS(&s); 6589 ck_assert_ptr_eq(r, s); 6590 ck_assert_str_eq(s, "SHeePY"); 6591 free(s); 6592 // heading spaces 6593 s = strdup(" SHeePY"); 6594 r = iTrimS(&s); 6595 ck_assert_ptr_eq(r, s); 6596 ck_assert_str_eq(s, "SHeePY"); 6597 free(s); 6598 // trailing spaces 6599 s = strdup("SHeePY "); 6600 r = iTrimS(&s); 6601 ck_assert_ptr_eq(r, s); 6602 ck_assert_str_eq(s, "SHeePY"); 6603 free(s); 6604 // string with spaces in the middle 6605 s = strdup(" SHe ePY "); 6606 r = iTrimS(&s); 6607 ck_assert_ptr_eq(r, s); 6608 ck_assert_str_eq(s, "SHe ePY"); 6609 free(s); 6610 // all spaces 6611 s = strdup(" "); 6612 r = iTrimS(&s); 6613 ck_assert_ptr_eq(r, s); 6614 ck_assert_str_eq(s, ""); 6615 free(s); 6616 // NULL string 6617 s = NULL; 6618 r = iTrimS(&s); 6619 ck_assert_ptr_eq(r, s); 6620 ck_assert_ptr_eq(s, NULL); 6621 // NULL var 6622 r = iTrimS(NULL); 6623 ck_assert_ptr_eq(r, null); 6624 6625 END_TEST 6626 6627 6628 START_TEST(bTrimST) 6629 6630 char s[50]; 6631 char *r = null; 6632 6633 // no spaces 6634 strcpy(s, "SHeePY"); 6635 r = bTrimS(s); 6636 ck_assert_ptr_eq(r, s); 6637 ck_assert_str_eq(s, "SHeePY"); 6638 // heading spaces 6639 strcpy(s, " SHeePY"); 6640 r = bTrimS(s); 6641 ck_assert_ptr_eq(r, s); 6642 ck_assert_str_eq(s, "SHeePY"); 6643 // trailing spaces 6644 strcpy(s, "SHeePY "); 6645 r = bTrimS(s); 6646 ck_assert_ptr_eq(r, s); 6647 ck_assert_str_eq(s, "SHeePY"); 6648 // string with spaces in the middle 6649 strcpy(s, " SHe ePY "); 6650 r = bTrimS(s); 6651 ck_assert_ptr_eq(r, s); 6652 ck_assert_str_eq(s, "SHe ePY"); 6653 // all spaces 6654 strcpy(s, " "); 6655 r = bTrimS(s); 6656 ck_assert_ptr_eq(r, s); 6657 ck_assert_str_eq(s, ""); 6658 // NULL var 6659 r = bTrimS(NULL); 6660 ck_assert_ptr_eq(r, null); 6661 6662 END_TEST 6663 6664 6665 START_TEST(lTrimST) 6666 6667 // no spaces 6668 char *s = lTrimS("SHeePY"); 6669 ck_assert_str_eq(s, "SHeePY"); 6670 free(s); 6671 // heading spaces 6672 s = lTrimS(" SHeePY"); 6673 ck_assert_str_eq(s, "SHeePY"); 6674 free(s); 6675 // trailing spaces 6676 s = lTrimS("SHeePY "); 6677 ck_assert_str_eq(s, "SHeePY "); 6678 free(s); 6679 // string with spaces in the middle 6680 s = lTrimS(" SHe ePY "); 6681 ck_assert_str_eq(s, "SHe ePY "); 6682 free(s); 6683 // all spaces 6684 s = lTrimS(" "); 6685 ck_assert_str_eq(s, ""); 6686 free(s); 6687 // NULL string 6688 ck_assert_ptr_eq(lTrimS(NULL), NULL); 6689 6690 END_TEST 6691 6692 6693 START_TEST(iLTrimST) 6694 6695 char *s; 6696 char *r = null; 6697 6698 // no spaces 6699 s = strdup("SHeePY"); 6700 r = iLTrimS(&s); 6701 ck_assert_ptr_eq(r, s); 6702 ck_assert_str_eq(s, "SHeePY"); 6703 free(s); 6704 // heading spaces 6705 s = strdup(" SHeePY"); 6706 r = iLTrimS(&s); 6707 ck_assert_ptr_eq(r, s); 6708 ck_assert_str_eq(s, "SHeePY"); 6709 free(s); 6710 // trailing spaces 6711 s = strdup("SHeePY "); 6712 r = iLTrimS(&s); 6713 ck_assert_ptr_eq(r, s); 6714 ck_assert_str_eq(s, "SHeePY "); 6715 free(s); 6716 // string with spaces in the middle 6717 s = strdup(" SHe ePY "); 6718 r = iLTrimS(&s); 6719 ck_assert_ptr_eq(r, s); 6720 ck_assert_str_eq(s, "SHe ePY "); 6721 free(s); 6722 // all spaces 6723 s = strdup(" "); 6724 r = iLTrimS(&s); 6725 ck_assert_ptr_eq(r, s); 6726 ck_assert_str_eq(s, ""); 6727 free(s); 6728 // NULL string 6729 s = NULL; 6730 r = iLTrimS(&s); 6731 ck_assert_ptr_eq(r, s); 6732 ck_assert_ptr_eq(s, NULL); 6733 // NULL var 6734 r = iLTrimS(NULL); 6735 ck_assert_ptr_eq(r, null); 6736 6737 END_TEST 6738 6739 6740 START_TEST(bLTrimST) 6741 6742 char s[50]; 6743 char *r = null; 6744 6745 // no spaces 6746 strcpy(s, "SHeePY"); 6747 r = bLTrimS(s); 6748 ck_assert_ptr_eq(r, s); 6749 ck_assert_str_eq(s, "SHeePY"); 6750 // heading spaces 6751 strcpy(s, " SHeePY"); 6752 r = bLTrimS(s); 6753 ck_assert_ptr_eq(r, s); 6754 ck_assert_str_eq(s, "SHeePY"); 6755 // trailing spaces 6756 strcpy(s, "SHeePY "); 6757 r = bLTrimS(s); 6758 ck_assert_ptr_eq(r, s); 6759 ck_assert_str_eq(s, "SHeePY "); 6760 // string with spaces in the middle 6761 strcpy(s, " SHe ePY "); 6762 r = bLTrimS(s); 6763 ck_assert_ptr_eq(r, s); 6764 ck_assert_str_eq(s, "SHe ePY "); 6765 // all spaces 6766 strcpy(s, " "); 6767 r = bLTrimS(s); 6768 ck_assert_ptr_eq(r, s); 6769 ck_assert_str_eq(s, ""); 6770 // NULL var 6771 r = bLTrimS(NULL); 6772 ck_assert_ptr_eq(r, null); 6773 6774 END_TEST 6775 6776 6777 START_TEST(rTrimST) 6778 6779 // no spaces 6780 char *s = rTrimS("SHeePY"); 6781 ck_assert_str_eq(s, "SHeePY"); 6782 free(s); 6783 // heading spaces 6784 s = rTrimS(" SHeePY"); 6785 ck_assert_str_eq(s, " SHeePY"); 6786 free(s); 6787 // trailing spaces 6788 s = rTrimS("SHeePY "); 6789 ck_assert_str_eq(s, "SHeePY"); 6790 free(s); 6791 // string with spaces in the middle 6792 s = rTrimS(" SHe ePY "); 6793 ck_assert_str_eq(s, " SHe ePY"); 6794 free(s); 6795 // all spaces 6796 s = rTrimS(" "); 6797 ck_assert_str_eq(s, ""); 6798 free(s); 6799 // NULL string 6800 ck_assert_ptr_eq(rTrimS(NULL), NULL); 6801 6802 END_TEST 6803 6804 6805 START_TEST(iRTrimST) 6806 6807 char *s; 6808 char *r = null; 6809 6810 // no spaces 6811 s = strdup("SHeePY"); 6812 r = iRTrimS(&s); 6813 ck_assert_ptr_eq(r, s); 6814 ck_assert_str_eq(s, "SHeePY"); 6815 free(s); 6816 // heading spaces 6817 s = strdup(" SHeePY"); 6818 r = iRTrimS(&s); 6819 ck_assert_ptr_eq(r, s); 6820 ck_assert_str_eq(s, " SHeePY"); 6821 free(s); 6822 // trailing spaces 6823 s = strdup("SHeePY "); 6824 r = iRTrimS(&s); 6825 ck_assert_ptr_eq(r, s); 6826 ck_assert_str_eq(s, "SHeePY"); 6827 free(s); 6828 // string with spaces in the middle 6829 s = strdup(" SHe ePY "); 6830 r = iRTrimS(&s); 6831 ck_assert_ptr_eq(r, s); 6832 ck_assert_str_eq(s, " SHe ePY"); 6833 free(s); 6834 // all spaces 6835 s = strdup(" "); 6836 r = iRTrimS(&s); 6837 ck_assert_ptr_eq(r, s); 6838 ck_assert_str_eq(s, ""); 6839 free(s); 6840 // NULL string 6841 s = NULL; 6842 r = iRTrimS(&s); 6843 ck_assert_ptr_eq(r, s); 6844 ck_assert_ptr_eq(s, NULL); 6845 // NULL var 6846 r = iRTrimS(NULL); 6847 ck_assert_ptr_eq(r, null); 6848 6849 END_TEST 6850 6851 6852 START_TEST(bRTrimST) 6853 6854 char s[100]; 6855 char *r = null; 6856 6857 // no spaces 6858 strcpy(s, "SHeePY"); 6859 r = bRTrimS(s); 6860 ck_assert_ptr_eq(r, s); 6861 ck_assert_str_eq(s, "SHeePY"); 6862 // heading spaces 6863 strcpy(s, " SHeePY"); 6864 r = bRTrimS(s); 6865 ck_assert_ptr_eq(r, s); 6866 ck_assert_str_eq(s, " SHeePY"); 6867 // trailing spaces 6868 strcpy(s, "SHeePY "); 6869 r = bRTrimS(s); 6870 ck_assert_ptr_eq(r, s); 6871 ck_assert_str_eq(s, "SHeePY"); 6872 // string with spaces in the middle 6873 strcpy(s, " SHe ePY "); 6874 r = bRTrimS(s); 6875 ck_assert_ptr_eq(r, s); 6876 ck_assert_str_eq(s, " SHe ePY"); 6877 // all spaces 6878 strcpy(s, " "); 6879 r = bRTrimS(s); 6880 ck_assert_ptr_eq(r, s); 6881 ck_assert_str_eq(s, ""); 6882 // NULL var 6883 r = bRTrimS(NULL); 6884 ck_assert_ptr_eq(r, null); 6885 6886 END_TEST 6887 6888 6889 START_TEST(uniqST) 6890 6891 char *s; 6892 6893 // uniquify 6894 s = uniqS("/qwd///", '/'); 6895 ck_assert_str_eq(s, "/qwd/"); 6896 free(s); 6897 // short string 6898 s = uniqS("?", '/'); 6899 ck_assert_str_eq(s, "?"); 6900 free(s); 6901 // NULL 6902 ck_assert_ptr_eq(uniqS(NULL, '/'), NULL); 6903 6904 END_TEST 6905 6906 6907 START_TEST(iUniqST) 6908 6909 char *s; 6910 6911 // uniquify 6912 s = strdup("/qwd///"); 6913 ck_assert_str_eq(iUniqS(&s, '/'), "/qwd/"); 6914 free(s); 6915 // short string 6916 s = strdup("?"); 6917 ck_assert_str_eq(iUniqS(&s, '/'), "?"); 6918 free(s); 6919 // NULL string 6920 s = NULL; 6921 ck_assert_ptr_eq(iUniqS(&s, '/'), NULL); 6922 // NULL 6923 ck_assert_ptr_eq(iUniqS(NULL, '/'), NULL); 6924 6925 END_TEST 6926 6927 6928 START_TEST(bUniqST) 6929 6930 char s[100]; 6931 6932 // uniquify 6933 strcpy(s, "/qwd///"); 6934 ck_assert_str_eq(bUniqS(s, '/'), "/qwd/"); 6935 // short string 6936 strcpy(s, "?"); 6937 ck_assert_str_eq(bUniqS(s, '/'), "?"); 6938 // NULL 6939 ck_assert_ptr_eq(bUniqS(NULL, '/'), NULL); 6940 6941 END_TEST 6942 6943 6944 START_TEST(icUniqST) 6945 6946 char *s; 6947 6948 // uniquify 6949 s = icUniqS("/qQqwd///", 'q'); 6950 ck_assert_str_eq(s, "/qwd///"); 6951 free(s); 6952 // short string 6953 s = icUniqS("?", '/'); 6954 ck_assert_str_eq(s, "?"); 6955 free(s); 6956 // NULL 6957 ck_assert_ptr_eq(icUniqS(NULL, '/'), NULL); 6958 6959 6960 END_TEST 6961 6962 6963 START_TEST(iicUniqST) 6964 6965 char *s; 6966 6967 // uniquify 6968 s = strdup("/qQqwd///"); 6969 ck_assert_str_eq(iicUniqS(&s, 'Q'), "/qwd///"); 6970 free(s); 6971 // short string 6972 s = strdup("?"); 6973 ck_assert_str_eq(iicUniqS(&s, '/'), "?"); 6974 free(s); 6975 // NULL string 6976 s = NULL; 6977 ck_assert_ptr_eq(iicUniqS(&s, '/'), NULL); 6978 // NULL 6979 ck_assert_ptr_eq(iicUniqS(NULL, '/'), NULL); 6980 6981 6982 END_TEST 6983 6984 6985 START_TEST(bicUniqST) 6986 6987 char s[100]; 6988 6989 // uniquify 6990 strcpy(s, "/qQqwd///"); 6991 ck_assert_str_eq(bicUniqS(s, 'q'), "/qwd///"); 6992 // short string 6993 strcpy(s, "?"); 6994 ck_assert_str_eq(bicUniqS(s, '/'), "?"); 6995 // NULL 6996 ck_assert_ptr_eq(bicUniqS(NULL, '/'), NULL); 6997 6998 6999 END_TEST 7000 7001 7002 START_TEST(repeatST) 7003 7004 char *r; 7005 7006 // repeat 7007 r = repeatS("abc", 2); 7008 ck_assert_str_eq(r, "abcabc"); 7009 free(r); 7010 7011 // empty string 7012 r = repeatS("", 2); 7013 ck_assert_str_eq(r, ""); 7014 free(r); 7015 7016 // once 7017 r = repeatS("ab", 1); 7018 ck_assert_str_eq(r, "ab"); 7019 free(r); 7020 7021 // 0 times 7022 r = repeatS("jhgjgh", 0); 7023 ck_assert_str_eq(r, ""); 7024 free(r); 7025 7026 // null string 7027 r = repeatS(null, 2); 7028 ck_assert_ptr_eq(r, null); 7029 7030 END_TEST 7031 7032 7033 START_TEST(iRepeatST) 7034 7035 char *s, *r; 7036 7037 // repeat 7038 s = strdup("abc"); 7039 r = iRepeatS(&s, 2); 7040 ck_assert_ptr_eq(r, s); 7041 ck_assert_str_eq(r, "abcabc"); 7042 free(r); 7043 7044 // empty string 7045 s = strdup(""); 7046 r = iRepeatS(&s, 2); 7047 ck_assert_str_eq(r, ""); 7048 free(r); 7049 7050 // once 7051 s = strdup("ab"); 7052 r = iRepeatS(&s, 1); 7053 ck_assert_str_eq(r, "ab"); 7054 free(r); 7055 7056 // 0 times 7057 s = strdup("jhgjgh"); 7058 r = iRepeatS(&s, 0); 7059 ck_assert_str_eq(r, ""); 7060 free(r); 7061 7062 // null string 7063 s = null; 7064 r = iRepeatS(&s, 2); 7065 ck_assert_ptr_eq(r, null); 7066 7067 r = iRepeatS(null, 2); 7068 ck_assert_ptr_eq(r, null); 7069 7070 END_TEST 7071 7072 7073 START_TEST(bRepeatST) 7074 7075 char s[128] = init0Var; 7076 char *r; 7077 7078 // repeat 7079 r = bRepeatS(s, "abc", 2); 7080 ck_assert_str_eq(r, "abcabc"); 7081 7082 // empty string 7083 r = bRepeatS(s, "", 2); 7084 ck_assert_str_eq(r, ""); 7085 7086 // once 7087 r = bRepeatS(s, "ab", 1); 7088 ck_assert_str_eq(r, "ab"); 7089 7090 // 0 times 7091 r = bRepeatS(s, "adsad", 0); 7092 ck_assert_str_eq(r, ""); 7093 7094 // null string 7095 r = bRepeatS(s, null, 2); 7096 ck_assert_ptr_eq(r, null); 7097 7098 // null dest 7099 r = bRepeatS(null, "asd", 2); 7100 ck_assert_ptr_eq(r, null); 7101 7102 END_TEST 7103 7104 7105 START_TEST(bLRepeatST) 7106 7107 char s[6] = init0Var; 7108 char *r; 7109 7110 // repeat 7111 r = bLRepeatS(s, sizeof(s), "ab", 2); 7112 ck_assert_str_eq(r, "abab"); 7113 7114 // empty string 7115 r = bLRepeatS(s, sizeof(s), "", 2); 7116 ck_assert_str_eq(r, ""); 7117 7118 // once 7119 r = bLRepeatS(s, sizeof(s), "ab", 1); 7120 ck_assert_str_eq(r, "ab"); 7121 7122 // 0 times 7123 r = bLRepeatS(s, sizeof(s), "asdasd", 0); 7124 ck_assert_str_eq(r, ""); 7125 7126 // once bigger than buffer 7127 r = bLRepeatS(s, sizeof(s), "123456", 1); 7128 ck_assert_ptr_eq(r, null); 7129 7130 // dest size 0 7131 r = bLRepeatS(s, 0, "123", 2); 7132 ck_assert_ptr_eq(r, null); 7133 7134 // null string 7135 r = bLRepeatS(s, sizeof(s), null, 2); 7136 ck_assert_ptr_eq(r, null); 7137 7138 // null dest 7139 r = bLRepeatS(null, sizeof(s), "asd", 2); 7140 ck_assert_ptr_eq(r, null); 7141 7142 7143 END_TEST 7144 7145 7146 START_TEST(repeatCharST) 7147 7148 char *r; 7149 7150 // repeat 7151 r = repeatCharS('$', 2); 7152 ck_assert_str_eq(r, "$$"); 7153 free(r); 7154 7155 // once 7156 r = repeatCharS('!', 1); 7157 ck_assert_str_eq(r, "!"); 7158 free(r); 7159 7160 // 0 times 7161 r = repeatCharS('0', 0); 7162 ck_assert_str_eq(r, ""); 7163 free(r); 7164 7165 END_TEST 7166 7167 7168 START_TEST(bRepeatCharST) 7169 7170 char s[128] = init0Var; 7171 char *r; 7172 7173 // repeat 7174 r = bRepeatCharS(s, 'a', 2); 7175 ck_assert_str_eq(r, "aa"); 7176 7177 // once 7178 r = bRepeatCharS(s, 'a', 1); 7179 ck_assert_str_eq(r, "a"); 7180 7181 // 0 times 7182 r = bRepeatCharS(s, '0', 0); 7183 ck_assert_str_eq(r, ""); 7184 7185 // null dest 7186 r = bRepeatCharS(null, 'd', 2); 7187 ck_assert_ptr_eq(r, null); 7188 7189 7190 END_TEST 7191 7192 7193 START_TEST(bLRepeatCharST) 7194 7195 char s[6] = init0Var; 7196 char *r; 7197 7198 // repeat 7199 r = bLRepeatCharS(s, sizeof(s), '$', 4); 7200 ck_assert_str_eq(r, "$$$$"); 7201 7202 // once 7203 r = bLRepeatCharS(s, sizeof(s), '+', 1); 7204 ck_assert_str_eq(r, "+"); 7205 7206 // 0 times 7207 r = bLRepeatCharS(s, sizeof(s), '1', 0); 7208 ck_assert_str_eq(r, ""); 7209 7210 // once bigger than buffer 7211 r = bLRepeatCharS(s, sizeof(s), '=', 6); 7212 ck_assert_ptr_eq(r, null); 7213 7214 // dest size 0 7215 r = bLRepeatCharS(s, 0, '/', 2); 7216 ck_assert_ptr_eq(r, null); 7217 7218 // null dest 7219 r = bLRepeatCharS(null, sizeof(s), '\'', 2); 7220 ck_assert_ptr_eq(r, null); 7221 7222 7223 END_TEST 7224 7225 7226 START_TEST(repeatLenST) 7227 7228 ssize_t r; 7229 7230 r = repeatLenS("asd", 3); 7231 ck_assert_int_eq(r, 9); 7232 7233 // 0 times 7234 r = repeatLenS("asd", 0); 7235 ck_assert_int_eq(r, 0); 7236 7237 // empty string 7238 r = repeatLenS("", 3); 7239 ck_assert_int_eq(r, 0); 7240 7241 // null string 7242 r = repeatLenS(null, 3); 7243 ck_assert_int_eq(r, -1); 7244 7245 END_TEST 7246 7247 7248 START_TEST(ellipsisStartST) 7249 7250 char *r; 7251 7252 // no ellipsis 7253 r = ellipsisStartS("sheepy", 10, "..."); 7254 ck_assert_str_eq(r, "sheepy"); 7255 free(r); 7256 r = ellipsisStartS("sheepy", 6, "..."); 7257 ck_assert_str_eq(r, "sheepy"); 7258 free(r); 7259 7260 // ellipsis 7261 r = ellipsisStartS("sheepy", 5, "..."); 7262 ck_assert_str_eq(r, "...py"); 7263 free(r); 7264 7265 // ellipsis longer than target length 7266 r = ellipsisStartS("sheepy", 5, "......"); 7267 ck_assert_str_eq(r, "....."); 7268 free(r); 7269 7270 // empty ellipsis 7271 r = ellipsisStartS("sheepy", 5, ""); 7272 ck_assert_str_eq(r, "heepy"); 7273 free(r); 7274 7275 // target length 0 7276 r = ellipsisStartS("sheepy", 0, "..."); 7277 ck_assert_str_eq(r, ""); 7278 free(r); 7279 7280 // null string 7281 ck_assert_ptr_eq(ellipsisStartS(null,4,""), null); 7282 // null ellipsis 7283 ck_assert_ptr_eq(ellipsisStartS("",4,null), null); 7284 7285 END_TEST 7286 7287 7288 START_TEST(iEllipsisStartST) 7289 7290 char *s, *r; 7291 7292 // no ellipsis 7293 s = strdup("sheepy"); 7294 r = iEllipsisStartS(&s, 10, "..."); 7295 ck_assert_str_eq(r, "sheepy"); 7296 free(r); 7297 s = strdup("sheepy"); 7298 r = iEllipsisStartS(&s, 6, "..."); 7299 ck_assert_str_eq(r, "sheepy"); 7300 free(r); 7301 7302 // ellipsis 7303 s = strdup("sheepy"); 7304 r = iEllipsisStartS(&s, 5, "..."); 7305 ck_assert_str_eq(r, "...py"); 7306 free(r); 7307 7308 // ellipsis longer than target length 7309 s = strdup("sheepy"); 7310 r = iEllipsisStartS(&s, 5, "......"); 7311 ck_assert_str_eq(r, "....."); 7312 free(r); 7313 7314 // empty ellipsis 7315 s = strdup("sheepy"); 7316 r = iEllipsisStartS(&s, 5, ""); 7317 ck_assert_str_eq(r, "heepy"); 7318 free(r); 7319 7320 // target length 0 7321 s = strdup("sheepy"); 7322 r = iEllipsisStartS(&s, 0, "..."); 7323 ck_assert_str_eq(r, ""); 7324 free(r); 7325 7326 // null string 7327 s = null; 7328 ck_assert_ptr_eq(iEllipsisStartS(&s,4,""), null); 7329 ck_assert_ptr_eq(iEllipsisStartS(null,4,""), null); 7330 // null ellipsis 7331 s = strdup("sd"); 7332 ck_assert_ptr_eq(iEllipsisStartS(&s,4,null), null); 7333 free(s); 7334 7335 7336 END_TEST 7337 7338 7339 START_TEST(bEllipsisStartST) 7340 7341 char *r; 7342 char dest[48]; 7343 7344 // no ellipsis 7345 r = bEllipsisStartS(dest, "sheepy", 10, "..."); 7346 ck_assert_str_eq(r, "sheepy"); 7347 r = bEllipsisStartS(dest, "sheepy", 6, "..."); 7348 ck_assert_str_eq(r, "sheepy"); 7349 7350 // ellipsis 7351 r = bEllipsisStartS(dest, "sheepy", 5, "..."); 7352 ck_assert_str_eq(r, "...py"); 7353 7354 // ellipsis longer than target length 7355 r = bEllipsisStartS(dest, "sheepy", 5, "......"); 7356 ck_assert_str_eq(r, "....."); 7357 7358 // empty ellipsis 7359 r = bEllipsisStartS(dest, "sheepy", 5, ""); 7360 ck_assert_str_eq(r, "heepy"); 7361 7362 // target length 0 7363 r = bEllipsisStartS(dest, "sheepy", 0, "..."); 7364 ck_assert_str_eq(r, ""); 7365 7366 // null string 7367 ck_assert_ptr_eq(bEllipsisStartS(dest, null,4,""), null); 7368 // null ellipsis 7369 ck_assert_ptr_eq(bEllipsisStartS(dest, "",4,null), null); 7370 // null dest 7371 ck_assert_ptr_eq(bEllipsisStartS(null, "",4,""), null); 7372 7373 7374 END_TEST 7375 7376 7377 START_TEST(bLEllipsisStartST) 7378 7379 char *r; 7380 char dest[6]; 7381 7382 // no ellipsis 7383 r = bLEllipsisStartS(dest, sizeof(dest), "sheepy", 10, "..."); 7384 ck_assert_str_eq(r, "sheep"); 7385 r = bLEllipsisStartS(dest, sizeof(dest), "sheepy", 6, "..."); 7386 ck_assert_str_eq(r, "sheep"); 7387 7388 // ellipsis 7389 r = bLEllipsisStartS(dest, sizeof(dest), "sheepy", 5, "..."); 7390 ck_assert_str_eq(r, "...py"); 7391 7392 // ellipsis longer than target length 7393 r = bLEllipsisStartS(dest, sizeof(dest), "sheepy", 5, "......"); 7394 ck_assert_str_eq(r, "....."); 7395 7396 // empty ellipsis 7397 r = bLEllipsisStartS(dest, sizeof(dest), "sheepy", 5, ""); 7398 ck_assert_str_eq(r, "heepy"); 7399 7400 // target length 0 7401 r = bLEllipsisStartS(dest, sizeof(dest), "sheepy", 0, "..."); 7402 ck_assert_str_eq(r, ""); 7403 7404 // dest size 0, dest unchanged 7405 dest[0] = 'a'; 7406 dest[1] = 0; 7407 r = bLEllipsisStartS(dest, 0, "sheepy", 5, ""); 7408 ck_assert_str_eq(r, "a"); 7409 7410 // null string 7411 ck_assert_ptr_eq(bLEllipsisStartS(dest, sizeof(dest), null,4,""), null); 7412 // null ellipsis 7413 ck_assert_ptr_eq(bLEllipsisStartS(dest, sizeof(dest), "",4,null), null); 7414 // null dest 7415 ck_assert_ptr_eq(bLEllipsisStartS(null, sizeof(dest), "",4,""), null); 7416 7417 7418 END_TEST 7419 7420 7421 START_TEST(ellipsisStartCharST) 7422 7423 char *r; 7424 7425 // no ellipsis 7426 r = ellipsisStartCharS("sheepy", 10, '-'); 7427 ck_assert_str_eq(r, "sheepy"); 7428 free(r); 7429 r = ellipsisStartCharS("sheepy", 6, '-'); 7430 ck_assert_str_eq(r, "sheepy"); 7431 free(r); 7432 7433 // ellipsis 7434 r = ellipsisStartCharS("sheepy", 5, '-'); 7435 ck_assert_str_eq(r, "-eepy"); 7436 free(r); 7437 7438 // target length 0 7439 r = ellipsisStartCharS("sheepy", 0, '-'); 7440 ck_assert_str_eq(r, ""); 7441 free(r); 7442 7443 // null string 7444 ck_assert_ptr_eq(ellipsisStartCharS(null,4,'-'), null); 7445 7446 7447 END_TEST 7448 7449 7450 START_TEST(iEllipsisStartCharST) 7451 7452 char *s, *r; 7453 7454 // no ellipsis 7455 s = strdup("sheepy"); 7456 r = iEllipsisStartCharS(&s, 10, '-'); 7457 ck_assert_str_eq(r, "sheepy"); 7458 free(r); 7459 s = strdup("sheepy"); 7460 r = iEllipsisStartCharS(&s, 6, '-'); 7461 ck_assert_str_eq(r, "sheepy"); 7462 free(r); 7463 7464 // ellipsis 7465 s = strdup("sheepy"); 7466 r = iEllipsisStartCharS(&s, 5, '-'); 7467 ck_assert_str_eq(r, "-eepy"); 7468 free(r); 7469 7470 // target length 0 7471 s = strdup("sheepy"); 7472 r = iEllipsisStartCharS(&s, 0, '-'); 7473 ck_assert_str_eq(r, ""); 7474 free(r); 7475 7476 // null string 7477 s = null; 7478 ck_assert_ptr_eq(iEllipsisStartCharS(&s,4,'-'), null); 7479 ck_assert_ptr_eq(iEllipsisStartCharS(null,4,'-'), null); 7480 7481 7482 END_TEST 7483 7484 7485 START_TEST(bEllipsisStartCharST) 7486 7487 char *r; 7488 char dest[48]; 7489 7490 // no ellipsis 7491 r = bEllipsisStartCharS(dest, "sheepy", 10, '-'); 7492 ck_assert_str_eq(r, "sheepy"); 7493 r = bEllipsisStartCharS(dest, "sheepy", 6, '-'); 7494 ck_assert_str_eq(r, "sheepy"); 7495 7496 // ellipsis 7497 r = bEllipsisStartCharS(dest, "sheepy", 5, '-'); 7498 ck_assert_str_eq(r, "-eepy"); 7499 7500 // target length 0 7501 r = bEllipsisStartCharS(dest, "sheepy", 0, '-'); 7502 ck_assert_str_eq(r, ""); 7503 7504 // null string 7505 ck_assert_ptr_eq(bEllipsisStartCharS(dest, null,4,'-'), null); 7506 // null dest 7507 ck_assert_ptr_eq(bEllipsisStartCharS(null, "",4,'-'), null); 7508 7509 7510 END_TEST 7511 7512 7513 START_TEST(bLEllipsisStartCharST) 7514 7515 char *r; 7516 char dest[6]; 7517 7518 // no ellipsis 7519 r = bLEllipsisStartCharS(dest, sizeof(dest), "sheepy", 10, '-'); 7520 ck_assert_str_eq(r, "sheep"); 7521 r = bLEllipsisStartCharS(dest, sizeof(dest), "sheepy", 6, '-'); 7522 ck_assert_str_eq(r, "sheep"); 7523 7524 // ellipsis 7525 r = bLEllipsisStartCharS(dest, sizeof(dest), "sheepy", 5, '-'); 7526 ck_assert_str_eq(r, "-eepy"); 7527 7528 // target length 0 7529 r = bLEllipsisStartCharS(dest, sizeof(dest), "sheepy", 0, '-'); 7530 ck_assert_str_eq(r, ""); 7531 7532 // dest size 0, dest unchanged 7533 dest[0] = 'a'; 7534 dest[1] = 0; 7535 r = bLEllipsisStartCharS(dest, 0, "sheepy", 5, '-'); 7536 ck_assert_str_eq(r, "a"); 7537 7538 // null string 7539 ck_assert_ptr_eq(bLEllipsisStartCharS(dest, sizeof(dest), null,4,'-'), null); 7540 // null dest 7541 ck_assert_ptr_eq(bLEllipsisStartCharS(null, sizeof(dest), "",4,'-'), null); 7542 7543 7544 END_TEST 7545 7546 7547 START_TEST(ellipsisLenST) 7548 7549 ssize_t r; 7550 7551 // no ellipsis 7552 r = ellipsisLenS("sheepy", 10, "..."); 7553 ck_assert_int_eq(r, 6); 7554 r = ellipsisLenS("sheepy", 6, "..."); 7555 ck_assert_int_eq(r, 6); 7556 7557 // ellipsis 7558 r = ellipsisLenS("sheepy", 5, "..."); 7559 ck_assert_int_eq(r, 5); 7560 7561 // ellipsis longer than target length 7562 r = ellipsisLenS("sheepy", 5, "......"); 7563 ck_assert_int_eq(r, 5); 7564 7565 // empty ellipsis 7566 r = ellipsisLenS("sheepy", 5, ""); 7567 ck_assert_int_eq(r, 5); 7568 7569 // target length 0 7570 r = ellipsisLenS("sheepy", 0, "..."); 7571 ck_assert_int_eq(r, 0); 7572 7573 // null string 7574 ck_assert_int_eq(ellipsisLenS(null,4,""), -1); 7575 // null ellipsis 7576 ck_assert_int_eq(ellipsisLenS("",4,null), -1); 7577 7578 7579 END_TEST 7580 7581 7582 START_TEST(ellipsisEndST) 7583 7584 char *r; 7585 7586 // no ellipsis 7587 r = ellipsisEndS("sheepy", 10, "..."); 7588 ck_assert_str_eq(r, "sheepy"); 7589 free(r); 7590 r = ellipsisEndS("sheepy", 6, "..."); 7591 ck_assert_str_eq(r, "sheepy"); 7592 free(r); 7593 7594 // ellipsis 7595 r = ellipsisEndS("sheepy", 5, "..."); 7596 ck_assert_str_eq(r, "sh..."); 7597 free(r); 7598 7599 // ellipsis longer than target length 7600 r = ellipsisEndS("sheepy", 5, "......"); 7601 ck_assert_str_eq(r, "....."); 7602 free(r); 7603 7604 // empty ellipsis 7605 r = ellipsisEndS("sheepy", 5, ""); 7606 ck_assert_str_eq(r, "sheep"); 7607 free(r); 7608 7609 // target length 0 7610 r = ellipsisEndS("sheepy", 0, "..."); 7611 ck_assert_str_eq(r, ""); 7612 free(r); 7613 7614 // null string 7615 ck_assert_ptr_eq(ellipsisEndS(null,4,""), null); 7616 // null ellipsis 7617 ck_assert_ptr_eq(ellipsisEndS("",4,null), null); 7618 7619 7620 END_TEST 7621 7622 7623 START_TEST(iEllipsisEndST) 7624 7625 char *s, *r; 7626 7627 // no ellipsis 7628 s = strdup("sheepy"); 7629 r = iEllipsisEndS(&s, 10, "..."); 7630 ck_assert_str_eq(r, "sheepy"); 7631 free(r); 7632 s = strdup("sheepy"); 7633 r = iEllipsisEndS(&s, 6, "..."); 7634 ck_assert_str_eq(r, "sheepy"); 7635 free(r); 7636 7637 // ellipsis 7638 s = strdup("sheepy"); 7639 r = iEllipsisEndS(&s, 5, "..."); 7640 ck_assert_str_eq(r, "sh..."); 7641 free(r); 7642 7643 // ellipsis longer than target length 7644 s = strdup("sheepy"); 7645 r = iEllipsisEndS(&s, 5, "......"); 7646 ck_assert_str_eq(r, "....."); 7647 free(r); 7648 7649 // empty ellipsis 7650 s = strdup("sheepy"); 7651 r = iEllipsisEndS(&s, 5, ""); 7652 ck_assert_str_eq(r, "sheep"); 7653 free(r); 7654 7655 // target length 0 7656 s = strdup("sheepy"); 7657 r = iEllipsisEndS(&s, 0, "..."); 7658 ck_assert_str_eq(r, ""); 7659 free(r); 7660 7661 // null string 7662 s = null; 7663 ck_assert_ptr_eq(iEllipsisEndS(&s,4,""), null); 7664 ck_assert_ptr_eq(iEllipsisEndS(null,4,""), null); 7665 // null ellipsis 7666 s = strdup("sd"); 7667 ck_assert_ptr_eq(iEllipsisEndS(&s,4,null), null); 7668 free(s); 7669 7670 7671 END_TEST 7672 7673 7674 START_TEST(bEllipsisEndST) 7675 7676 char *r; 7677 char dest[48]; 7678 7679 // no ellipsis 7680 r = bEllipsisEndS(dest, "sheepy", 10, "..."); 7681 ck_assert_str_eq(r, "sheepy"); 7682 r = bEllipsisEndS(dest, "sheepy", 6, "..."); 7683 ck_assert_str_eq(r, "sheepy"); 7684 7685 // ellipsis 7686 r = bEllipsisEndS(dest, "sheepy", 5, "..."); 7687 ck_assert_str_eq(r, "sh..."); 7688 7689 // ellipsis longer than target length 7690 r = bEllipsisEndS(dest, "sheepy", 5, "......"); 7691 ck_assert_str_eq(r, "....."); 7692 7693 // empty ellipsis 7694 r = bEllipsisEndS(dest, "sheepy", 5, ""); 7695 ck_assert_str_eq(r, "sheep"); 7696 7697 // target length 0 7698 r = bEllipsisEndS(dest, "sheepy", 0, "..."); 7699 ck_assert_str_eq(r, ""); 7700 7701 // null string 7702 ck_assert_ptr_eq(bEllipsisEndS(dest, null,4,""), null); 7703 // null ellipsis 7704 ck_assert_ptr_eq(bEllipsisEndS(dest, "",4,null), null); 7705 // null dest 7706 ck_assert_ptr_eq(bEllipsisEndS(null, "",4,""), null); 7707 7708 7709 END_TEST 7710 7711 7712 START_TEST(bLEllipsisEndST) 7713 7714 char *r; 7715 char dest[6]; 7716 7717 // no ellipsis 7718 r = bLEllipsisEndS(dest, sizeof(dest), "sheepy", 10, "..."); 7719 ck_assert_str_eq(r, "sheep"); 7720 r = bLEllipsisEndS(dest, sizeof(dest), "sheepy", 6, "..."); 7721 ck_assert_str_eq(r, "sheep"); 7722 7723 // ellipsis 7724 r = bLEllipsisEndS(dest, sizeof(dest), "sheepy", 5, "..."); 7725 ck_assert_str_eq(r, "sh..."); 7726 7727 // ellipsis longer than target length 7728 r = bLEllipsisEndS(dest, sizeof(dest), "sheepy", 5, "......"); 7729 ck_assert_str_eq(r, "....."); 7730 7731 // empty ellipsis 7732 r = bLEllipsisEndS(dest, sizeof(dest), "sheepy", 4, ""); 7733 ck_assert_str_eq(r, "shee"); 7734 7735 // target length 0 7736 r = bLEllipsisEndS(dest, sizeof(dest), "sheepy", 0, "..."); 7737 ck_assert_str_eq(r, ""); 7738 7739 // dest size 0, dest unchanged 7740 dest[0] = 'a'; 7741 dest[1] = 0; 7742 r = bLEllipsisEndS(dest, 0, "sheepy", 5, ""); 7743 ck_assert_str_eq(r, "a"); 7744 7745 // null string 7746 ck_assert_ptr_eq(bLEllipsisEndS(dest, sizeof(dest), null,4,""), null); 7747 // null ellipsis 7748 ck_assert_ptr_eq(bLEllipsisEndS(dest, sizeof(dest), "",4,null), null); 7749 // null dest 7750 ck_assert_ptr_eq(bLEllipsisEndS(null, sizeof(dest), "",4,""), null); 7751 7752 7753 END_TEST 7754 7755 7756 START_TEST(ellipsisEndCharST) 7757 7758 char *r; 7759 7760 // no ellipsis 7761 r = ellipsisEndCharS("sheepy", 10, '-'); 7762 ck_assert_str_eq(r, "sheepy"); 7763 free(r); 7764 r = ellipsisEndCharS("sheepy", 6, '-'); 7765 ck_assert_str_eq(r, "sheepy"); 7766 free(r); 7767 7768 // ellipsis 7769 r = ellipsisEndCharS("sheepy", 5, '-'); 7770 ck_assert_str_eq(r, "shee-"); 7771 free(r); 7772 7773 // target length 0 7774 r = ellipsisEndCharS("sheepy", 0, '-'); 7775 ck_assert_str_eq(r, ""); 7776 free(r); 7777 7778 // null string 7779 ck_assert_ptr_eq(ellipsisEndCharS(null,4,'-'), null); 7780 7781 7782 END_TEST 7783 7784 7785 START_TEST(iEllipsisEndCharST) 7786 7787 char *s, *r; 7788 7789 // no ellipsis 7790 s = strdup("sheepy"); 7791 r = iEllipsisEndCharS(&s, 10, '-'); 7792 ck_assert_str_eq(r, "sheepy"); 7793 free(r); 7794 s = strdup("sheepy"); 7795 r = iEllipsisEndCharS(&s, 6, '-'); 7796 ck_assert_str_eq(r, "sheepy"); 7797 free(r); 7798 7799 // ellipsis 7800 s = strdup("sheepy"); 7801 r = iEllipsisEndCharS(&s, 5, '-'); 7802 ck_assert_str_eq(r, "shee-"); 7803 free(r); 7804 7805 // target length 0 7806 s = strdup("sheepy"); 7807 r = iEllipsisEndCharS(&s, 0, '-'); 7808 ck_assert_str_eq(r, ""); 7809 free(r); 7810 7811 // null string 7812 s = null; 7813 ck_assert_ptr_eq(iEllipsisEndCharS(&s,4,'-'), null); 7814 ck_assert_ptr_eq(iEllipsisEndCharS(null,4,'-'), null); 7815 7816 7817 END_TEST 7818 7819 7820 START_TEST(bEllipsisEndCharST) 7821 7822 char *r; 7823 char dest[48]; 7824 7825 // no ellipsis 7826 r = bEllipsisEndCharS(dest, "sheepy", 10, '-'); 7827 ck_assert_str_eq(r, "sheepy"); 7828 r = bEllipsisEndCharS(dest, "sheepy", 6, '-'); 7829 ck_assert_str_eq(r, "sheepy"); 7830 7831 // ellipsis 7832 r = bEllipsisEndCharS(dest, "sheepy", 5, '-'); 7833 ck_assert_str_eq(r, "shee-"); 7834 7835 // target length 0 7836 r = bEllipsisEndCharS(dest, "sheepy", 0, '-'); 7837 ck_assert_str_eq(r, ""); 7838 7839 // null string 7840 ck_assert_ptr_eq(bEllipsisEndCharS(dest, null,4,'-'), null); 7841 // null dest 7842 ck_assert_ptr_eq(bEllipsisEndCharS(null, "",4,'-'), null); 7843 7844 7845 END_TEST 7846 7847 7848 START_TEST(bLEllipsisEndCharST) 7849 7850 char *r; 7851 char dest[6]; 7852 7853 // no ellipsis 7854 r = bLEllipsisEndCharS(dest, sizeof(dest), "sheepy", 10, '-'); 7855 ck_assert_str_eq(r, "sheep"); 7856 r = bLEllipsisEndCharS(dest, sizeof(dest), "sheepy", 6, '-'); 7857 ck_assert_str_eq(r, "sheep"); 7858 7859 // ellipsis 7860 r = bLEllipsisEndCharS(dest, sizeof(dest), "sheepy", 5, '-'); 7861 ck_assert_str_eq(r, "shee-"); 7862 7863 // target length 0 7864 r = bLEllipsisEndCharS(dest, sizeof(dest), "sheepy", 0, '-'); 7865 ck_assert_str_eq(r, ""); 7866 7867 // dest size 0, dest unchanged 7868 dest[0] = 'a'; 7869 dest[1] = 0; 7870 r = bLEllipsisEndCharS(dest, 0, "sheepy", 5, '-'); 7871 ck_assert_str_eq(r, "a"); 7872 7873 // null string 7874 ck_assert_ptr_eq(bLEllipsisEndCharS(dest, sizeof(dest), null,4,'-'), null); 7875 // null dest 7876 ck_assert_ptr_eq(bLEllipsisEndCharS(null, sizeof(dest), "",4,'-'), null); 7877 7878 7879 END_TEST 7880 7881 7882 START_TEST(padStartST) 7883 7884 char *r; 7885 7886 // pad string 7887 r = padStartS("sheepy", 10, ">>>"); 7888 ck_assert_str_eq(r, ">>>>sheepy"); 7889 free(r); 7890 7891 r = padStartS("sheepy", 7, ">>>"); 7892 ck_assert_str_eq(r, ">sheepy"); 7893 free(r); 7894 7895 // string bigger than target length 7896 r = padStartS("sheepy", 4, ">>>"); 7897 ck_assert_str_eq(r, "sheepy"); 7898 free(r); 7899 7900 // empty pad string 7901 r = padStartS("sheepy", 10, ""); 7902 ck_assert_str_eq(r, "sheepy"); 7903 free(r); 7904 7905 // null pad string 7906 r = padStartS("sheepy", 4, null); 7907 ck_assert_str_eq(r, "sheepy"); 7908 free(r); 7909 r = padStartS("sheepy", 10, null); 7910 ck_assert_ptr_eq(r, null); 7911 7912 // null string 7913 r = padStartS(null, 4, "q"); 7914 ck_assert_ptr_eq(r, null); 7915 7916 END_TEST 7917 7918 7919 START_TEST(iPadStartST) 7920 7921 char *s, *r; 7922 7923 // pad string 7924 s = strdup("sheepy"); 7925 r = iPadStartS(&s, 10, ">>>"); 7926 ck_assert_str_eq(r, ">>>>sheepy"); 7927 free(r); 7928 7929 s = strdup("sheepy"); 7930 r = iPadStartS(&s, 7, ">>>"); 7931 ck_assert_str_eq(r, ">sheepy"); 7932 free(r); 7933 7934 // string bigger than target length 7935 s = strdup("sheepy"); 7936 r = iPadStartS(&s, 4, ">>>"); 7937 ck_assert_str_eq(r, "sheepy"); 7938 free(r); 7939 7940 // empty pad string 7941 s = strdup("sheepy"); 7942 r = iPadStartS(&s, 10, ""); 7943 ck_assert_str_eq(r, "sheepy"); 7944 free(r); 7945 7946 // null pad string 7947 s = strdup("sheepy"); 7948 r = iPadStartS(&s, 4, null); 7949 ck_assert_str_eq(r, "sheepy"); 7950 free(r); 7951 s = strdup("sheepy"); 7952 r = iPadStartS(&s, 10, null); 7953 ck_assert_ptr_eq(r, null); 7954 free(s); 7955 7956 // null string 7957 s = null; 7958 r = iPadStartS(&s, 4, "q"); 7959 ck_assert_ptr_eq(r, null); 7960 r = iPadStartS(null, 4, "q"); 7961 ck_assert_ptr_eq(r, null); 7962 7963 7964 END_TEST 7965 7966 7967 START_TEST(bPadStartST) 7968 7969 char *r; 7970 char b[48]; 7971 7972 // pad string 7973 r = bPadStartS(b, "sheepy", 10, ">>>"); 7974 ck_assert_str_eq(r, ">>>>sheepy"); 7975 7976 r = bPadStartS(b, "sheepy", 7, ">>>"); 7977 ck_assert_str_eq(r, ">sheepy"); 7978 7979 // string bigger than target length 7980 r = bPadStartS(b, "sheepy", 4, ">>>"); 7981 ck_assert_str_eq(r, "sheepy"); 7982 7983 // empty pad string 7984 r = bPadStartS(b, "sheepy", 10, ""); 7985 ck_assert_str_eq(r, "sheepy"); 7986 7987 // null pad string 7988 r = bPadStartS(b, "sheepy", 4, null); 7989 ck_assert_str_eq(r, "sheepy"); 7990 r = bPadStartS(b, "sheepy", 10, null); 7991 ck_assert_ptr_eq(r, null); 7992 7993 // null string 7994 r = bPadStartS(b, null, 4, "q"); 7995 ck_assert_ptr_eq(r, null); 7996 7997 // null dest 7998 r = bPadStartS(null, "d", 4, "q"); 7999 ck_assert_ptr_eq(r, null); 8000 8001 8002 END_TEST 8003 8004 8005 START_TEST(bLPadStartST) 8006 8007 char *r; 8008 char b[48]; 8009 8010 // pad string 8011 r = bLPadStartS(b, sizeof(b), "sheepy", 10, ">>>"); 8012 ck_assert_str_eq(r, ">>>>sheepy"); 8013 r = bLPadStartS(b, sizeof(b), "sheepy", 7, ">>>"); 8014 ck_assert_str_eq(r, ">sheepy"); 8015 // smaller dest size 8016 r = bLPadStartS(b, 4, "sheepy", 7, ">>>"); 8017 ck_assert_str_eq(r, ">sh"); 8018 8019 // string bigger than target length 8020 r = bLPadStartS(b, sizeof(b), "sheepy", 4, ">>>"); 8021 ck_assert_str_eq(r, "sheepy"); 8022 // smaller dest size 8023 r = bLPadStartS(b, 4, "sheepy", 4, ">>>"); 8024 ck_assert_str_eq(r, "she"); 8025 8026 // empty pad string 8027 r = bLPadStartS(b, sizeof(b), "sheepy", 10, ""); 8028 ck_assert_str_eq(r, "sheepy"); 8029 // smaller dest size 8030 r = bLPadStartS(b, 4, "sheepy", 10, ""); 8031 ck_assert_str_eq(r, "she"); 8032 8033 8034 // null pad string 8035 r = bLPadStartS(b, sizeof(b), "sheepy", 4, null); 8036 ck_assert_str_eq(r, "sheepy"); 8037 r = bLPadStartS(b, sizeof(b), "sheepy", 10, null); 8038 ck_assert_ptr_eq(r, null); 8039 8040 // null string 8041 r = bLPadStartS(b, sizeof(b), null, 4, "q"); 8042 ck_assert_ptr_eq(r, null); 8043 8044 // null dest 8045 r = bLPadStartS(null, sizeof(b), "d", 4, "q"); 8046 ck_assert_ptr_eq(r, null); 8047 8048 8049 END_TEST 8050 8051 8052 START_TEST(padStartCharST) 8053 8054 char *r; 8055 8056 // pad string 8057 r = padStartCharS("sheepy", 10, '>'); 8058 ck_assert_str_eq(r, ">>>>sheepy"); 8059 free(r); 8060 8061 r = padStartCharS("sheepy", 7, '>'); 8062 ck_assert_str_eq(r, ">sheepy"); 8063 free(r); 8064 8065 // string bigger than target length 8066 r = padStartCharS("sheepy", 4, '>'); 8067 ck_assert_str_eq(r, "sheepy"); 8068 free(r); 8069 8070 // null string 8071 r = padStartCharS(null, 4, 'q'); 8072 ck_assert_ptr_eq(r, null); 8073 8074 8075 END_TEST 8076 8077 8078 START_TEST(iPadStartCharST) 8079 8080 char *s, *r; 8081 8082 // pad string 8083 s = strdup("sheepy"); 8084 r = iPadStartCharS(&s, 10, '>'); 8085 ck_assert_str_eq(r, ">>>>sheepy"); 8086 free(r); 8087 8088 s = strdup("sheepy"); 8089 r = iPadStartCharS(&s, 7, '>'); 8090 ck_assert_str_eq(r, ">sheepy"); 8091 free(r); 8092 8093 // string bigger than target length 8094 s = strdup("sheepy"); 8095 r = iPadStartCharS(&s, 4, '>'); 8096 ck_assert_str_eq(r, "sheepy"); 8097 free(r); 8098 8099 // null string 8100 s = null; 8101 r = iPadStartCharS(&s, 4, 'q'); 8102 ck_assert_ptr_eq(r, null); 8103 r = iPadStartCharS(null, 4, 'q'); 8104 ck_assert_ptr_eq(r, null); 8105 8106 8107 END_TEST 8108 8109 8110 START_TEST(bPadStartCharST) 8111 8112 char *r; 8113 char b[48]; 8114 8115 // pad string 8116 r = bPadStartCharS(b, "sheepy", 10, '>'); 8117 ck_assert_str_eq(r, ">>>>sheepy"); 8118 8119 r = bPadStartCharS(b, "sheepy", 7, '>'); 8120 ck_assert_str_eq(r, ">sheepy"); 8121 8122 // string bigger than target length 8123 r = bPadStartCharS(b, "sheepy", 4, '>'); 8124 ck_assert_str_eq(r, "sheepy"); 8125 8126 // null string 8127 r = bPadStartCharS(b, null, 4, 'q'); 8128 ck_assert_ptr_eq(r, null); 8129 8130 // null dest 8131 r = bPadStartCharS(null, "d", 4, 'q'); 8132 ck_assert_ptr_eq(r, null); 8133 8134 8135 END_TEST 8136 8137 8138 START_TEST(bLPadStartCharST) 8139 8140 char *r; 8141 char b[48]; 8142 8143 // pad string 8144 r = bLPadStartCharS(b, sizeof(b), "sheepy", 10, '>'); 8145 ck_assert_str_eq(r, ">>>>sheepy"); 8146 r = bLPadStartCharS(b, sizeof(b), "sheepy", 7, '>'); 8147 ck_assert_str_eq(r, ">sheepy"); 8148 // smaller dest size 8149 r = bLPadStartCharS(b, 4, "sheepy", 7, '>'); 8150 ck_assert_str_eq(r, ">sh"); 8151 8152 // string bigger than target length 8153 r = bLPadStartCharS(b, sizeof(b), "sheepy", 4, '>'); 8154 ck_assert_str_eq(r, "sheepy"); 8155 // smaller dest size 8156 r = bLPadStartCharS(b, 4, "sheepy", 4, '>'); 8157 ck_assert_str_eq(r, "she"); 8158 8159 // null string 8160 r = bLPadStartCharS(b, sizeof(b), null, 4, 'q'); 8161 ck_assert_ptr_eq(r, null); 8162 8163 // null dest 8164 r = bLPadStartCharS(null, sizeof(b), "d", 4, 'q'); 8165 ck_assert_ptr_eq(r, null); 8166 8167 8168 END_TEST 8169 8170 8171 START_TEST(padStartLenST) 8172 8173 ssize_t r; 8174 8175 // pad string 8176 r = padStartLenS("sheepy", 10, ">>>"); 8177 ck_assert_int_eq(r, 10); 8178 8179 r = padStartLenS("sheepy", 7, ">>>"); 8180 ck_assert_int_eq(r, 7); 8181 8182 // string bigger than target length 8183 r = padStartLenS("sheepy", 4, ">>>"); 8184 ck_assert_int_eq(r, 6); 8185 8186 // empty pad string 8187 r = padStartLenS("sheepy", 10, ""); 8188 ck_assert_int_eq(r, 6); 8189 8190 // null pad string 8191 r = padStartLenS("sheepy", 4, null); 8192 ck_assert_int_eq(r, 6); 8193 r = padStartLenS("sheepy", 10, null); 8194 ck_assert_int_eq(r, -1); 8195 8196 // null string 8197 r = padStartLenS(null, 4, "q"); 8198 ck_assert_int_eq(r, -1); 8199 8200 8201 END_TEST 8202 8203 8204 START_TEST(padEndST) 8205 8206 char *r; 8207 8208 // pad string 8209 r = padEndS("sheepy", 10, ">>>"); 8210 ck_assert_str_eq(r, "sheepy>>>>"); 8211 free(r); 8212 8213 r = padEndS("sheepy", 7, ">>>"); 8214 ck_assert_str_eq(r, "sheepy>"); 8215 free(r); 8216 8217 // string bigger than target length 8218 r = padEndS("sheepy", 4, ">>>"); 8219 ck_assert_str_eq(r, "sheepy"); 8220 free(r); 8221 8222 // empty pad string 8223 r = padEndS("sheepy", 10, ""); 8224 ck_assert_str_eq(r, "sheepy"); 8225 free(r); 8226 8227 // null pad string 8228 r = padEndS("sheepy", 4, null); 8229 ck_assert_str_eq(r, "sheepy"); 8230 free(r); 8231 r = padEndS("sheepy", 10, null); 8232 ck_assert_ptr_eq(r, null); 8233 8234 // null string 8235 r = padEndS(null, 4, "q"); 8236 ck_assert_ptr_eq(r, null); 8237 8238 8239 END_TEST 8240 8241 8242 START_TEST(iPadEndST) 8243 8244 char *s, *r; 8245 8246 // pad string 8247 s = strdup("sheepy"); 8248 r = iPadEndS(&s, 10, ">>>"); 8249 ck_assert_str_eq(r, "sheepy>>>>"); 8250 free(r); 8251 8252 s = strdup("sheepy"); 8253 r = iPadEndS(&s, 7, ">>>"); 8254 ck_assert_str_eq(r, "sheepy>"); 8255 free(r); 8256 8257 // string bigger than target length 8258 s = strdup("sheepy"); 8259 r = iPadEndS(&s, 4, ">>>"); 8260 ck_assert_str_eq(r, "sheepy"); 8261 free(r); 8262 8263 // empty pad string 8264 s = strdup("sheepy"); 8265 r = iPadEndS(&s, 10, ""); 8266 ck_assert_str_eq(r, "sheepy"); 8267 free(r); 8268 8269 // null pad string 8270 s = strdup("sheepy"); 8271 r = iPadEndS(&s, 4, null); 8272 ck_assert_str_eq(r, "sheepy"); 8273 free(r); 8274 s = strdup("sheepy"); 8275 r = iPadEndS(&s, 10, null); 8276 ck_assert_ptr_eq(r, null); 8277 free(s); 8278 8279 // null string 8280 s = null; 8281 r = iPadEndS(&s, 4, "q"); 8282 ck_assert_ptr_eq(r, null); 8283 r = iPadEndS(null, 4, "q"); 8284 ck_assert_ptr_eq(r, null); 8285 8286 8287 END_TEST 8288 8289 8290 START_TEST(bPadEndST) 8291 8292 char *r; 8293 char b[48]; 8294 8295 // pad string 8296 r = bPadEndS(b, "sheepy", 10, ">>>"); 8297 ck_assert_str_eq(r, "sheepy>>>>"); 8298 8299 r = bPadEndS(b, "sheepy", 7, ">>>"); 8300 ck_assert_str_eq(r, "sheepy>"); 8301 8302 // string bigger than target length 8303 r = bPadEndS(b, "sheepy", 4, ">>>"); 8304 ck_assert_str_eq(r, "sheepy"); 8305 8306 // empty pad string 8307 r = bPadEndS(b, "sheepy", 10, ""); 8308 ck_assert_str_eq(r, "sheepy"); 8309 8310 // null pad string 8311 r = bPadEndS(b, "sheepy", 4, null); 8312 ck_assert_str_eq(r, "sheepy"); 8313 r = bPadEndS(b, "sheepy", 10, null); 8314 ck_assert_ptr_eq(r, null); 8315 8316 // null string 8317 r = bPadEndS(b, null, 4, "q"); 8318 ck_assert_ptr_eq(r, null); 8319 8320 // null dest 8321 r = bPadEndS(null, "d", 4, "q"); 8322 ck_assert_ptr_eq(r, null); 8323 8324 8325 END_TEST 8326 8327 8328 START_TEST(bLPadEndST) 8329 8330 char *r; 8331 char b[48]; 8332 8333 // pad string 8334 r = bLPadEndS(b, sizeof(b), "sheepy", 10, ">>>"); 8335 ck_assert_str_eq(r, "sheepy>>>>"); 8336 r = bLPadEndS(b, sizeof(b), "sheepy", 7, ">>>"); 8337 ck_assert_str_eq(r, "sheepy>"); 8338 // smaller dest size 8339 r = bLPadEndS(b, 4, "sheepy", 7, ">>>"); 8340 ck_assert_str_eq(r, "she"); 8341 8342 // string bigger than target length 8343 r = bLPadEndS(b, sizeof(b), "sheepy", 4, ">>>"); 8344 ck_assert_str_eq(r, "sheepy"); 8345 // smaller dest size 8346 r = bLPadEndS(b, 4, "sheepy", 4, ">>>"); 8347 ck_assert_str_eq(r, "she"); 8348 8349 // empty pad string 8350 r = bLPadEndS(b, sizeof(b), "sheepy", 10, ""); 8351 ck_assert_str_eq(r, "sheepy"); 8352 // smaller dest size 8353 r = bLPadEndS(b, 4, "sheepy", 10, ""); 8354 ck_assert_str_eq(r, "she"); 8355 8356 8357 // null pad string 8358 r = bLPadEndS(b, sizeof(b), "sheepy", 4, null); 8359 ck_assert_str_eq(r, "sheepy"); 8360 r = bLPadEndS(b, sizeof(b), "sheepy", 10, null); 8361 ck_assert_ptr_eq(r, null); 8362 8363 // null string 8364 r = bLPadEndS(b, sizeof(b), null, 4, "q"); 8365 ck_assert_ptr_eq(r, null); 8366 8367 // null dest 8368 r = bLPadEndS(null, sizeof(b), "d", 4, "q"); 8369 ck_assert_ptr_eq(r, null); 8370 8371 8372 END_TEST 8373 8374 8375 START_TEST(padEndCharST) 8376 8377 char *r; 8378 8379 // pad string 8380 r = padEndCharS("sheepy", 10, '>'); 8381 ck_assert_str_eq(r, "sheepy>>>>"); 8382 free(r); 8383 8384 r = padEndCharS("sheepy", 7, '>'); 8385 ck_assert_str_eq(r, "sheepy>"); 8386 free(r); 8387 8388 // string bigger than target length 8389 r = padEndCharS("sheepy", 4, '>'); 8390 ck_assert_str_eq(r, "sheepy"); 8391 free(r); 8392 8393 // null string 8394 r = padEndCharS(null, 4, 'q'); 8395 ck_assert_ptr_eq(r, null); 8396 8397 8398 END_TEST 8399 8400 8401 START_TEST(iPadEndCharST) 8402 8403 char *s, *r; 8404 8405 // pad string 8406 s = strdup("sheepy"); 8407 r = iPadEndCharS(&s, 10, '>'); 8408 ck_assert_str_eq(r, "sheepy>>>>"); 8409 free(r); 8410 8411 s = strdup("sheepy"); 8412 r = iPadEndCharS(&s, 7, '>'); 8413 ck_assert_str_eq(r, "sheepy>"); 8414 free(r); 8415 8416 // string bigger than target length 8417 s = strdup("sheepy"); 8418 r = iPadEndCharS(&s, 4, '>'); 8419 ck_assert_str_eq(r, "sheepy"); 8420 free(r); 8421 8422 // null string 8423 s = null; 8424 r = iPadEndCharS(&s, 4, 'q'); 8425 ck_assert_ptr_eq(r, null); 8426 r = iPadEndCharS(null, 4, 'q'); 8427 ck_assert_ptr_eq(r, null); 8428 8429 8430 END_TEST 8431 8432 8433 START_TEST(bPadEndCharST) 8434 8435 char *r; 8436 char b[48]; 8437 8438 // pad string 8439 r = bPadEndCharS(b, "sheepy", 10, '>'); 8440 ck_assert_str_eq(r, "sheepy>>>>"); 8441 8442 r = bPadEndCharS(b, "sheepy", 7, '>'); 8443 ck_assert_str_eq(r, "sheepy>"); 8444 8445 // string bigger than target length 8446 r = bPadEndCharS(b, "sheepy", 4, '>'); 8447 ck_assert_str_eq(r, "sheepy"); 8448 8449 // null string 8450 r = bPadEndCharS(b, null, 4, 'q'); 8451 ck_assert_ptr_eq(r, null); 8452 8453 // null dest 8454 r = bPadEndCharS(null, "d", 4, 'q'); 8455 ck_assert_ptr_eq(r, null); 8456 8457 8458 END_TEST 8459 8460 8461 START_TEST(bLPadEndCharST) 8462 8463 char *r; 8464 char b[48]; 8465 8466 // pad string 8467 r = bLPadEndCharS(b, sizeof(b), "sheepy", 10, '>'); 8468 ck_assert_str_eq(r, "sheepy>>>>"); 8469 r = bLPadEndCharS(b, sizeof(b), "sheepy", 7, '>'); 8470 ck_assert_str_eq(r, "sheepy>"); 8471 // smaller dest size 8472 r = bLPadEndCharS(b, 4, "sheepy", 7, '>'); 8473 ck_assert_str_eq(r, "she"); 8474 8475 // string bigger than target length 8476 r = bLPadEndCharS(b, sizeof(b), "sheepy", 4, '>'); 8477 ck_assert_str_eq(r, "sheepy"); 8478 // smaller dest size 8479 r = bLPadEndCharS(b, 4, "sheepy", 4, '>'); 8480 ck_assert_str_eq(r, "she"); 8481 8482 // null string 8483 r = bLPadEndCharS(b, sizeof(b), null, 4, 'q'); 8484 ck_assert_ptr_eq(r, null); 8485 8486 // null dest 8487 r = bLPadEndCharS(null, sizeof(b), "d", 4, 'q'); 8488 ck_assert_ptr_eq(r, null); 8489 8490 8491 END_TEST 8492 8493 8494 START_TEST(padEndLenST) 8495 8496 ssize_t r; 8497 8498 // pad string 8499 r = padEndLenS("sheepy", 10, ">>>"); 8500 ck_assert_int_eq(r, 10); 8501 8502 r = padEndLenS("sheepy", 7, ">>>"); 8503 ck_assert_int_eq(r, 7); 8504 8505 // string bigger than target length 8506 r = padEndLenS("sheepy", 4, ">>>"); 8507 ck_assert_int_eq(r, 6); 8508 8509 // empty pad string 8510 r = padEndLenS("sheepy", 10, ""); 8511 ck_assert_int_eq(r, 6); 8512 8513 // null pad string 8514 r = padEndLenS("sheepy", 4, null); 8515 ck_assert_int_eq(r, 6); 8516 r = padEndLenS("sheepy", 10, null); 8517 ck_assert_int_eq(r, -1); 8518 8519 // null string 8520 r = padEndLenS(null, 4, "q"); 8521 ck_assert_int_eq(r, -1); 8522 8523 8524 END_TEST 8525 8526 8527 START_TEST(getST) 8528 8529 // get char 8530 ck_assert_uint_eq(getS("sheepy", 0), 's'); 8531 // negative index 8532 ck_assert_uint_eq(getS("sheepy", -1), 'y'); 8533 // outside string 8534 ck_assert_uint_eq(getS("sheepy", 10), 0); 8535 ck_assert_uint_eq(getS("sheepy", -10), 0); 8536 // negative index in a one char string 8537 ck_assert_uint_eq(getS("z", -1), 'z'); 8538 // empty string 8539 ck_assert_uint_eq(getS("", 0), 0); 8540 // NULL string 8541 ck_assert_uint_eq(getS(NULL, 0), 0); 8542 8543 END_TEST 8544 8545 8546 START_TEST(setST) 8547 8548 char *s; 8549 char *r = null; 8550 8551 s = strdup("sheepy"); 8552 8553 // set char 8554 r = setS(s, 0, 'S'); 8555 ck_assert_ptr_eq(r, s); 8556 ck_assert_uint_eq(s[0], 'S'); 8557 // negative index 8558 r = setS(s, -2, 'P'); 8559 ck_assert_ptr_eq(r, s); 8560 ck_assert_uint_eq(s[4], 'P'); 8561 // outside string 8562 r = setS(s, 20, 'Y'); 8563 ck_assert_ptr_eq(r, null); 8564 r = setS(s, -20, 'Y'); 8565 ck_assert_ptr_eq(r, null); 8566 ck_assert_str_eq(s, "SheePy"); 8567 free(s); 8568 // negative index in a one char string 8569 s = strdup("s"); 8570 r = setS(s, -1, 'S'); 8571 ck_assert_ptr_eq(r, s); 8572 ck_assert_uint_eq(s[0], 'S'); 8573 free(s); 8574 // empty string 8575 emptyS(s); 8576 r = setS(s, -1, 'S'); 8577 ck_assert_ptr_eq(r, null); 8578 ck_assert_str_eq(s, ""); 8579 free(s); 8580 // NULL string 8581 r = setS(NULL, 0, 's'); 8582 ck_assert_ptr_eq(r, null); 8583 8584 8585 END_TEST 8586 8587 8588 START_TEST(swapST) 8589 8590 char *r; 8591 8592 // swap 8593 r = swapS("sheepy", 0, 2); 8594 ck_assert_str_eq(r, "ehsepy"); 8595 free(r); 8596 r = swapS("sheepy", -6, 2); 8597 ck_assert_str_eq(r, "ehsepy"); 8598 free(r); 8599 r = swapS("sheepy", 2, 0); 8600 ck_assert_str_eq(r, "ehsepy"); 8601 free(r); 8602 r = swapS("sheepy", 2, -6); 8603 ck_assert_str_eq(r, "ehsepy"); 8604 free(r); 8605 8606 // index1 >= len 8607 r = swapS("sheepy", 6, 2); 8608 ck_assert_ptr_eq(r, null); 8609 8610 // index2 >= len 8611 r = swapS("sheepy", 2, 6); 8612 ck_assert_ptr_eq(r, null); 8613 8614 // index1 < -len 8615 r = swapS("sheepy", -10, 2); 8616 ck_assert_ptr_eq(r, null); 8617 8618 // index2 < -len 8619 r = swapS("sheepy", 2, -7); 8620 ck_assert_ptr_eq(r, null); 8621 8622 // null string 8623 r = swapS(null, 0, 2); 8624 ck_assert_ptr_eq(r, null); 8625 8626 END_TEST 8627 8628 8629 START_TEST(iSwapST) 8630 8631 char *b; 8632 char *r; 8633 8634 // swap 8635 b = strdup("sheepy"); 8636 r = iSwapS(&b, 0, 2); 8637 ck_assert_str_eq(r, "ehsepy"); 8638 free(r); 8639 b = strdup("sheepy"); 8640 r = iSwapS(&b, -6, 2); 8641 ck_assert_str_eq(r, "ehsepy"); 8642 free(r); 8643 b = strdup("sheepy"); 8644 r = iSwapS(&b, 2, 0); 8645 ck_assert_str_eq(r, "ehsepy"); 8646 free(r); 8647 b = strdup("sheepy"); 8648 r = iSwapS(&b, 2, -6); 8649 ck_assert_str_eq(r, "ehsepy"); 8650 free(r); 8651 8652 b = strdup("sheepy"); 8653 8654 // index1 >= len 8655 r = iSwapS(&b, 6, 2); 8656 ck_assert_ptr_eq(r, null); 8657 8658 // index2 >= len 8659 r = iSwapS(&b, 2, 6); 8660 ck_assert_ptr_eq(r, null); 8661 8662 // index1 < -len 8663 r = iSwapS(&b, -10, 2); 8664 ck_assert_ptr_eq(r, null); 8665 8666 // index2 < -len 8667 r = iSwapS(&b, 2, -7); 8668 ck_assert_ptr_eq(r, null); 8669 8670 free(b); 8671 8672 // null string 8673 b = null; 8674 r = iSwapS(&b, 0, 2); 8675 ck_assert_ptr_eq(r, null); 8676 r = iSwapS(null, 0, 2); 8677 ck_assert_ptr_eq(r, null); 8678 8679 8680 END_TEST 8681 8682 8683 START_TEST(bSwapST) 8684 8685 char b[20]; 8686 char *r; 8687 8688 // swap 8689 strcpy(b, "sheepy"); 8690 r = bSwapS(b, 0, 2); 8691 ck_assert_str_eq(r, "ehsepy"); 8692 strcpy(b, "sheepy"); 8693 r = bSwapS(b, -6, 2); 8694 ck_assert_str_eq(r, "ehsepy"); 8695 strcpy(b, "sheepy"); 8696 r = bSwapS(b, 2, 0); 8697 ck_assert_str_eq(r, "ehsepy"); 8698 strcpy(b, "sheepy"); 8699 r = bSwapS(b, 2, -6); 8700 ck_assert_str_eq(r, "ehsepy"); 8701 8702 // index1 >= len 8703 r = bSwapS("sheepy", 6, 2); 8704 ck_assert_ptr_eq(r, null); 8705 8706 // index2 >= len 8707 r = bSwapS("sheepy", 2, 6); 8708 ck_assert_ptr_eq(r, null); 8709 8710 // index1 < -len 8711 r = bSwapS("sheepy", -10, 2); 8712 ck_assert_ptr_eq(r, null); 8713 8714 // index2 < -len 8715 r = bSwapS("sheepy", 2, -7); 8716 ck_assert_ptr_eq(r, null); 8717 8718 // null string 8719 r = bSwapS(null, 0, 2); 8720 ck_assert_ptr_eq(r, null); 8721 8722 8723 END_TEST 8724 8725 8726 START_TEST(bLSwapST) 8727 8728 char b[20]; 8729 char *r; 8730 8731 // swap 8732 strcpy(b, "sheepy"); 8733 r = bLSwapS(b, sizeof(b), 0, 2); 8734 ck_assert_str_eq(r, "ehsepy"); 8735 strcpy(b, "sheepy"); 8736 r = bLSwapS(b, sizeof(b), -6, 2); 8737 ck_assert_str_eq(r, "ehsepy"); 8738 strcpy(b, "sheepy"); 8739 r = bLSwapS(b, sizeof(b), 2, 0); 8740 ck_assert_str_eq(r, "ehsepy"); 8741 strcpy(b, "sheepy"); 8742 r = bLSwapS(b, sizeof(b), 2, -6); 8743 ck_assert_str_eq(r, "ehsepy"); 8744 8745 // buffer = strlen+1 8746 strcpy(b, "sheepy"); 8747 r = bLSwapS(b, 7, -1, 0); 8748 ck_assert_str_eq(r, "yheeps"); 8749 // buffer shorter than strlen 8750 strcpy(b, "sheepy"); 8751 r = bLSwapS(b, 6, -1, 0); 8752 ck_assert_str_eq(r, "pheesy"); 8753 8754 // size 0 8755 strcpy(b, "sheepy"); 8756 r = bLSwapS(b, 0, -1, 0); 8757 ck_assert_str_eq(r, "sheepy"); 8758 8759 // index1 >= len 8760 r = bLSwapS("sheepy", sizeof(b), 6, 2); 8761 ck_assert_ptr_eq(r, null); 8762 8763 // index2 >= len 8764 r = bLSwapS("sheepy", sizeof(b), 2, 6); 8765 ck_assert_ptr_eq(r, null); 8766 8767 // index1 < -len 8768 r = bLSwapS("sheepy", sizeof(b), -10, 2); 8769 ck_assert_ptr_eq(r, null); 8770 8771 // index2 < -len 8772 r = bLSwapS("sheepy", sizeof(b), 2, -7); 8773 ck_assert_ptr_eq(r, null); 8774 8775 // null string 8776 r = bLSwapS(null, sizeof(b), 0, 2); 8777 ck_assert_ptr_eq(r, null); 8778 8779 8780 END_TEST 8781 8782 8783 START_TEST(sliceST) 8784 8785 // slice 8786 char *s = sliceS("sheepy", 0,2); 8787 ck_assert_str_eq(s, "sh"); 8788 free(s); 8789 // negative index 8790 s = sliceS("sheepy", -2,0); 8791 ck_assert_str_eq(s, "py"); 8792 free(s); 8793 // positive and negative indexes 8794 s = sliceS("sheepy", 2,-2); 8795 ck_assert_str_eq(s, "ee"); 8796 free(s); 8797 // start = end 8798 s = sliceS("sheepy", 2,-4); 8799 ck_assert_str_eq(s, ""); 8800 free(s); 8801 // end of string 8802 s = sliceS("sheepy", 2,6); 8803 ck_assert_str_eq(s, "eepy"); 8804 free(s); 8805 // NULL string 8806 ck_assert_ptr_eq(sliceS(NULL, 2,-4), NULL); 8807 // start outside string 8808 ck_assert_ptr_eq(sliceS("sheepy", 20,-4), NULL); 8809 // end outside string 8810 s = sliceS("sheepy", 2,40); 8811 ck_assert_str_eq(s, "eepy"); 8812 free(s); 8813 s = sliceS("sheepy", -22,3); 8814 ck_assert_str_eq(s, "she"); 8815 free(s); 8816 ck_assert_ptr_eq(sliceS("sheepy", 2,-40), NULL); 8817 // end before start 8818 ck_assert_ptr_eq(sliceS("sheepy", 4,2), NULL); 8819 8820 END_TEST 8821 8822 8823 START_TEST(iSliceST) 8824 8825 char *s; 8826 char *r = null; 8827 8828 // slice 8829 s = strdup("sheepy"); 8830 r = iSliceS(&s, 0,2); 8831 ck_assert_ptr_eq(r, s); 8832 ck_assert_str_eq(s, "sh"); 8833 free(s); 8834 // negative index 8835 s = strdup("sheepy"); 8836 r = iSliceS(&s, -2,0); 8837 ck_assert_ptr_eq(r, s); 8838 ck_assert_str_eq(s, "py"); 8839 free(s); 8840 // positive and negative indexes 8841 s = strdup("sheepy"); 8842 r = iSliceS(&s, 2,-2); 8843 ck_assert_ptr_eq(r, s); 8844 ck_assert_str_eq(s, "ee"); 8845 free(s); 8846 // start = end 8847 s = strdup("sheepy"); 8848 r = iSliceS(&s, 2,-4); 8849 ck_assert_ptr_eq(r, s); 8850 ck_assert_str_eq(s, ""); 8851 free(s); 8852 // end of string 8853 s = strdup("sheepy"); 8854 r = iSliceS(&s, 2,6); 8855 ck_assert_ptr_eq(r, s); 8856 ck_assert_str_eq(s, "eepy"); 8857 free(s); 8858 // NULL string 8859 s = NULL; 8860 r = iSliceS(&s, 2,-4); 8861 ck_assert_ptr_eq(r, s); 8862 ck_assert_ptr_eq(s, NULL); 8863 // start outside string 8864 s = strdup("sheepy"); 8865 r = iSliceS(&s, 20,-4); 8866 ck_assert_ptr_eq(r, null); 8867 ck_assert_str_eq(s, ""); 8868 free(s); 8869 // end outside string 8870 s = strdup("sheepy"); 8871 r = iSliceS(&s, 2,40); 8872 ck_assert_ptr_eq(r, s); 8873 ck_assert_str_eq(s, "eepy"); 8874 free(s); 8875 s = strdup("sheepy"); 8876 r = iSliceS(&s, -22,3); 8877 ck_assert_ptr_eq(r, s); 8878 ck_assert_str_eq(s, "she"); 8879 free(s); 8880 s = strdup("sheepy"); 8881 r = iSliceS(&s, 2,-40); 8882 ck_assert_ptr_eq(r, null); 8883 ck_assert_str_eq(s, ""); 8884 free(s); 8885 // end before start 8886 s = strdup("sheepy"); 8887 r = iSliceS(&s, 4,2); 8888 ck_assert_ptr_eq(r, null); 8889 ck_assert_str_eq(s, ""); 8890 free(s); 8891 // NULL var 8892 r = iSliceS(NULL, 0, 0); 8893 ck_assert_ptr_eq(r, null); 8894 8895 END_TEST 8896 8897 8898 START_TEST(bSliceST) 8899 8900 char s[100]; 8901 char *r = null; 8902 8903 // slice 8904 strcpy(s, "sheepy"); 8905 r = bSliceS(s, 0,2); 8906 ck_assert_ptr_eq(r, s); 8907 ck_assert_str_eq(s, "sh"); 8908 // negative index 8909 strcpy(s, "sheepy"); 8910 r = bSliceS(s, -2,0); 8911 ck_assert_ptr_eq(r, s); 8912 ck_assert_str_eq(s, "py"); 8913 // positive and negative indexes 8914 strcpy(s, "sheepy"); 8915 r = bSliceS(s, 2,-2); 8916 ck_assert_ptr_eq(r, s); 8917 ck_assert_str_eq(s, "ee"); 8918 // start = end 8919 strcpy(s, "sheepy"); 8920 r = bSliceS(s, 2,-4); 8921 ck_assert_ptr_eq(r, s); 8922 ck_assert_str_eq(s, ""); 8923 // end of string 8924 strcpy(s, "sheepy"); 8925 r = bSliceS(s, 2,6); 8926 ck_assert_ptr_eq(r, s); 8927 ck_assert_str_eq(s, "eepy"); 8928 // start outside string 8929 strcpy(s, "sheepy"); 8930 r = bSliceS(s, 20,-4); 8931 ck_assert_ptr_eq(r, null); 8932 ck_assert_str_eq(s, ""); 8933 // end outside string 8934 strcpy(s, "sheepy"); 8935 r = bSliceS(s, 2,40); 8936 ck_assert_ptr_eq(r, s); 8937 ck_assert_str_eq(s, "eepy"); 8938 strcpy(s, "sheepy"); 8939 r = bSliceS(s, -22,3); 8940 ck_assert_ptr_eq(r, s); 8941 ck_assert_str_eq(s, "she"); 8942 strcpy(s, "sheepy"); 8943 r = bSliceS(s, 2,-40); 8944 ck_assert_ptr_eq(r, null); 8945 ck_assert_str_eq(s, ""); 8946 // end before start 8947 strcpy(s, "sheepy"); 8948 r = bSliceS(s, 4,2); 8949 ck_assert_ptr_eq(r, null); 8950 ck_assert_str_eq(s, ""); 8951 // NULL var 8952 r = bSliceS(NULL, 0, 0); 8953 ck_assert_ptr_eq(r, null); 8954 8955 END_TEST 8956 8957 8958 START_TEST(bLSliceST) 8959 8960 char s[100]; 8961 char *r = null; 8962 8963 // slice 8964 strcpy(s, "sheepy"); 8965 r = bLSliceS(s, sizeof(s), 0,2); 8966 ck_assert_ptr_eq(r, s); 8967 ck_assert_str_eq(s, "sh"); 8968 // buffer shorter than string 8969 strcpy(s, "sheepy"); 8970 r = bLSliceS(s, 5, 0,2); 8971 ck_assert_ptr_eq(r, s); 8972 ck_assert_str_eq(s, "sh"); 8973 // negative index 8974 strcpy(s, "sheepy"); 8975 r = bLSliceS(s, sizeof(s), -2,0); 8976 ck_assert_ptr_eq(r, s); 8977 ck_assert_str_eq(s, "py"); 8978 // positive and negative indexes 8979 strcpy(s, "sheepy"); 8980 r = bLSliceS(s, sizeof(s), 2,-2); 8981 ck_assert_ptr_eq(r, s); 8982 ck_assert_str_eq(s, "ee"); 8983 // start = end 8984 strcpy(s, "sheepy"); 8985 r = bLSliceS(s, sizeof(s), 2,-4); 8986 ck_assert_ptr_eq(r, s); 8987 ck_assert_str_eq(s, ""); 8988 // end of string 8989 strcpy(s, "sheepy"); 8990 r = bLSliceS(s, sizeof(s), 2,6); 8991 ck_assert_ptr_eq(r, s); 8992 ck_assert_str_eq(s, "eepy"); 8993 // start outside string 8994 strcpy(s, "sheepy"); 8995 r = bLSliceS(s, sizeof(s), 20,-4); 8996 ck_assert_ptr_eq(r, null); 8997 ck_assert_str_eq(s, ""); 8998 // end outside string 8999 strcpy(s, "sheepy"); 9000 r = bLSliceS(s, sizeof(s), 2,40); 9001 ck_assert_ptr_eq(r, s); 9002 ck_assert_str_eq(s, "eepy"); 9003 strcpy(s, "sheepy"); 9004 r = bLSliceS(s, sizeof(s), -22,3); 9005 ck_assert_ptr_eq(r, s); 9006 ck_assert_str_eq(s, "she"); 9007 strcpy(s, "sheepy"); 9008 r = bLSliceS(s, sizeof(s), 2,-40); 9009 ck_assert_ptr_eq(r, null); 9010 ck_assert_str_eq(s, ""); 9011 // end before start 9012 strcpy(s, "sheepy"); 9013 r = bLSliceS(s, sizeof(s), 4,2); 9014 ck_assert_ptr_eq(r, null); 9015 ck_assert_str_eq(s, ""); 9016 // size 0 9017 r = bLSliceS(s, 0, 0, 0); 9018 ck_assert_ptr_eq(r, null); 9019 // NULL var 9020 r = bLSliceS(NULL, sizeof(s), 0, 0); 9021 ck_assert_ptr_eq(r, null); 9022 9023 9024 END_TEST 9025 9026 9027 START_TEST(cropST) 9028 9029 char b[20]; 9030 char *s; 9031 9032 // crop 9033 strcpy(b, "sheepy"); 9034 s = cropS(b, 0,2); 9035 ck_assert_str_eq(s, "sh"); 9036 ck_assert_str_eq(b, "eepy"); 9037 free(s); 9038 // negative index 9039 strcpy(b, "sheepy"); 9040 s = cropS(b, -2,0); 9041 ck_assert_str_eq(s, "py"); 9042 ck_assert_str_eq(b, "shee"); 9043 free(s); 9044 // positive and negative indexes 9045 strcpy(b, "sheepy"); 9046 s = cropS(b, 2,-2); 9047 ck_assert_str_eq(s, "ee"); 9048 ck_assert_str_eq(b, "shpy"); 9049 free(s); 9050 // start = end 9051 strcpy(b, "sheepy"); 9052 s = cropS(b, 2,-4); 9053 ck_assert_str_eq(s, ""); 9054 ck_assert_str_eq(b, "sheepy"); 9055 free(s); 9056 // end of string 9057 strcpy(b, "sheepy"); 9058 s = cropS(b, 2,6); 9059 ck_assert_str_eq(s, "eepy"); 9060 ck_assert_str_eq(b, "sh"); 9061 free(s); 9062 // NULL string 9063 ck_assert_ptr_eq(cropS(NULL, 2,-4), NULL); 9064 // start outside string 9065 ck_assert_ptr_eq(cropS("sheepy", 20,-4), NULL); 9066 // end outside string 9067 strcpy(b, "sheepy"); 9068 s = cropS(b, 2,40); 9069 ck_assert_str_eq(s, "eepy"); 9070 ck_assert_str_eq(b, "sh"); 9071 free(s); 9072 strcpy(b, "sheepy"); 9073 s = cropS(b, -22,3); 9074 ck_assert_str_eq(s, "she"); 9075 ck_assert_str_eq(b, "epy"); 9076 free(s); 9077 ck_assert_ptr_eq(cropS("sheepy", 2,-40), NULL); 9078 // end before start 9079 ck_assert_ptr_eq(cropS("sheepy", 4,2), NULL); 9080 9081 9082 END_TEST 9083 9084 9085 START_TEST(iCropST) 9086 9087 char *b; 9088 char *s; 9089 9090 // crop 9091 b = strdup("sheepy"); 9092 s = iCropS(&b, 0,2); 9093 ck_assert_str_eq(s, "sh"); 9094 ck_assert_str_eq(b, "eepy"); 9095 free(s); 9096 free(b); 9097 // negative index 9098 b = strdup("sheepy"); 9099 s = iCropS(&b, -2,0); 9100 ck_assert_str_eq(s, "py"); 9101 ck_assert_str_eq(b, "shee"); 9102 free(s); 9103 free(b); 9104 // positive and negative indexes 9105 b = strdup("sheepy"); 9106 s = iCropS(&b, 2,-2); 9107 ck_assert_str_eq(s, "ee"); 9108 ck_assert_str_eq(b, "shpy"); 9109 free(s); 9110 free(b); 9111 // start = end 9112 b = strdup("sheepy"); 9113 s = iCropS(&b, 2,-4); 9114 ck_assert_str_eq(s, ""); 9115 ck_assert_str_eq(b, "sheepy"); 9116 free(s); 9117 free(b); 9118 // end of string 9119 b = strdup("sheepy"); 9120 s = iCropS(&b, 2,6); 9121 ck_assert_str_eq(s, "eepy"); 9122 ck_assert_str_eq(b, "sh"); 9123 free(s); 9124 free(b); 9125 // NULL string 9126 b = null; 9127 ck_assert_ptr_eq(iCropS(&b, 2,-4), NULL); 9128 ck_assert_ptr_eq(iCropS(NULL, 2,-4), NULL); 9129 // start outside string 9130 b = strdup("sheepy"); 9131 ck_assert_ptr_eq(iCropS(&b, 20,-4), NULL); 9132 free(b); 9133 // end outside string 9134 b = strdup("sheepy"); 9135 s = iCropS(&b, 2,40); 9136 ck_assert_str_eq(s, "eepy"); 9137 ck_assert_str_eq(b, "sh"); 9138 free(s); 9139 free(b); 9140 b = strdup("sheepy"); 9141 s = iCropS(&b, -22,3); 9142 ck_assert_str_eq(s, "she"); 9143 ck_assert_str_eq(b, "epy"); 9144 free(s); 9145 free(b); 9146 b = strdup("sheepy"); 9147 ck_assert_ptr_eq(iCropS(&b, 2,-40), NULL); 9148 free(b); 9149 // end before start 9150 b = strdup("sheepy"); 9151 ck_assert_ptr_eq(iCropS(&b, 4,2), NULL); 9152 free(b); 9153 9154 9155 END_TEST 9156 9157 9158 START_TEST(cropElemST) 9159 9160 char b[20]; 9161 char r; 9162 9163 // crop 9164 strcpy(b, "sheepy"); 9165 r = cropElemS(b, 0); 9166 ck_assert_int_eq(r, 's'); 9167 ck_assert_str_eq(b, "heepy"); 9168 strcpy(b, "sheepy"); 9169 r = cropElemS(b, 5); 9170 ck_assert_int_eq(r, 'y'); 9171 ck_assert_str_eq(b, "sheep"); 9172 // negative index 9173 strcpy(b, "sheepy"); 9174 r = cropElemS(b, -1); 9175 ck_assert_int_eq(r, 'y'); 9176 ck_assert_str_eq(b, "sheep"); 9177 strcpy(b, "sheepy"); 9178 r = cropElemS(b, -6); 9179 ck_assert_int_eq(r, 's'); 9180 ck_assert_str_eq(b, "heepy"); 9181 // index outside string 9182 strcpy(b, "sheepy"); 9183 r = cropElemS(b, 6); 9184 ck_assert_int_eq(r, 0); 9185 ck_assert_str_eq(b, "sheepy"); 9186 strcpy(b, "sheepy"); 9187 r = cropElemS(b, -7); 9188 ck_assert_int_eq(r, 0); 9189 ck_assert_str_eq(b, "sheepy"); 9190 // null string 9191 ck_assert_int_eq(cropElemS(null, 0), 0); 9192 9193 END_TEST 9194 9195 9196 START_TEST(iCropElemST) 9197 9198 char *b; 9199 char r; 9200 9201 // crop 9202 b = strdup("sheepy"); 9203 r = iCropElemS(&b, 0); 9204 ck_assert_int_eq(r, 's'); 9205 ck_assert_str_eq(b, "heepy"); 9206 free(b); 9207 b = strdup("sheepy"); 9208 r = iCropElemS(&b, 5); 9209 ck_assert_int_eq(r, 'y'); 9210 ck_assert_str_eq(b, "sheep"); 9211 free(b); 9212 // negative index 9213 b = strdup("sheepy"); 9214 r = iCropElemS(&b, -1); 9215 ck_assert_int_eq(r, 'y'); 9216 ck_assert_str_eq(b, "sheep"); 9217 free(b); 9218 b = strdup("sheepy"); 9219 r = iCropElemS(&b, -6); 9220 ck_assert_int_eq(r, 's'); 9221 ck_assert_str_eq(b, "heepy"); 9222 free(b); 9223 // index outside string 9224 b = strdup("sheepy"); 9225 r = iCropElemS(&b, 6); 9226 ck_assert_int_eq(r, 0); 9227 ck_assert_str_eq(b, "sheepy"); 9228 free(b); 9229 b = strdup("sheepy"); 9230 r = iCropElemS(&b, -7); 9231 ck_assert_int_eq(r, 0); 9232 ck_assert_str_eq(b, "sheepy"); 9233 free(b); 9234 // null string 9235 b = null; 9236 ck_assert_int_eq(iCropElemS(&b, 0), 0); 9237 ck_assert_int_eq(iCropElemS(null, 0), 0); 9238 9239 9240 END_TEST 9241 9242 9243 START_TEST(insertST) 9244 9245 char *s; 9246 9247 // insert 9248 s = insertS("sheepy", 0, "lib"); 9249 ck_assert_str_eq(s, "libsheepy"); 9250 free(s); 9251 // negative index 9252 s = insertS("libsheepy", -2, "P"); 9253 ck_assert_str_eq(s, "libsheepPy"); 9254 free(s); 9255 // edge 9256 s = insertS("qwe", 3, "C"); 9257 ck_assert_str_eq(s, "qweC"); 9258 free(s); 9259 // outside string 9260 s = insertS("qwe", 4, "C"); 9261 ck_assert_ptr_eq(s, NULL); 9262 s = insertS("qwe", -5, "C"); 9263 ck_assert_ptr_eq(s, NULL); 9264 // negative index in a one char string 9265 s = insertS("s", -1, "S"); 9266 ck_assert_str_eq(s, "sS"); 9267 free(s); 9268 // empty string 9269 s = insertS("", 0, "s"); 9270 ck_assert_str_eq(s, "s"); 9271 free(s); 9272 s = insertS("", -1, "s"); 9273 ck_assert_str_eq(s, "s"); 9274 free(s); 9275 // empty insert string 9276 s = insertS("a", 0, ""); 9277 ck_assert_str_eq(s, "a"); 9278 free(s); 9279 // NULL insert string 9280 s = insertS("a", 0, NULL); 9281 ck_assert_str_eq(s, "a"); 9282 free(s); 9283 // NULL string 9284 s = insertS(NULL, 0, "s"); 9285 ck_assert_str_eq(s, "s"); 9286 free(s); 9287 9288 9289 END_TEST 9290 9291 9292 START_TEST(insertNFreeST) 9293 9294 char *s, *a; 9295 9296 // insert 9297 s = insertNFreeS("sheepy", 0, strdup("lib")); 9298 ck_assert_str_eq(s, "libsheepy"); 9299 free(s); 9300 // negative index 9301 s = insertNFreeS("libsheepy", -2, strdup("P")); 9302 ck_assert_str_eq(s, "libsheepPy"); 9303 free(s); 9304 // edge 9305 s = insertNFreeS("qwe", 3, strdup("C")); 9306 ck_assert_str_eq(s, "qweC"); 9307 free(s); 9308 // outside string 9309 a = strdup("C"); 9310 s = insertNFreeS("qwe", 4, a); 9311 ck_assert_ptr_eq(s, NULL); 9312 s = insertNFreeS("qwe", -5, a); 9313 ck_assert_ptr_eq(s, NULL); 9314 free(a); 9315 // negative index in a one char string 9316 s = insertNFreeS("s", -1, strdup("S")); 9317 ck_assert_str_eq(s, "sS"); 9318 free(s); 9319 // empty string 9320 s = insertNFreeS("", 0, strdup("s")); 9321 ck_assert_str_eq(s, "s"); 9322 free(s); 9323 s = insertNFreeS("", -1, strdup("s")); 9324 ck_assert_str_eq(s, "s"); 9325 free(s); 9326 // empty insert string 9327 s = insertNFreeS("a", 0, strdup("")); 9328 ck_assert_str_eq(s, "a"); 9329 free(s); 9330 // NULL insert string 9331 s = insertNFreeS("a", 0, NULL); 9332 ck_assert_str_eq(s, "a"); 9333 free(s); 9334 // NULL string 9335 s = insertNFreeS(NULL, 0, strdup("s")); 9336 ck_assert_str_eq(s, "s"); 9337 free(s); 9338 9339 9340 END_TEST 9341 9342 9343 START_TEST(iInsertST) 9344 9345 char *s; 9346 char *r = null; 9347 9348 // insert 9349 s = strdup("sheepy"); 9350 r = iInsertS(&s, 0, "lib"); 9351 ck_assert_ptr_eq(r, s); 9352 ck_assert_str_eq(s, "libsheepy"); 9353 free(s); 9354 // negative index 9355 s = strdup("libsheepy"); 9356 r = iInsertS(&s, -2, "P"); 9357 ck_assert_ptr_eq(r, s); 9358 ck_assert_str_eq(s, "libsheepPy"); 9359 free(s); 9360 // edge 9361 s = strdup("qwe"); 9362 r = iInsertS(&s, 3, "C"); 9363 ck_assert_ptr_eq(r, s); 9364 ck_assert_str_eq(s, "qweC"); 9365 free(s); 9366 // outside string 9367 s = strdup("qwe"); 9368 r = iInsertS(&s, 4, "C"); 9369 ck_assert_ptr_eq(r, null); 9370 ck_assert_str_eq(s, "qwe"); 9371 r = iInsertS(&s, -5, "C"); 9372 ck_assert_ptr_eq(r, null); 9373 ck_assert_str_eq(s, "qwe"); 9374 free(s); 9375 // negative index in a one char string 9376 s = strdup("s"); 9377 r = iInsertS(&s, -1, "S"); 9378 ck_assert_ptr_eq(r, s); 9379 ck_assert_str_eq(s, "sS"); 9380 free(s); 9381 // empty string 9382 emptyS(s); 9383 r = iInsertS(&s, 0, "s"); 9384 ck_assert_ptr_eq(r, s); 9385 ck_assert_str_eq(s, "s"); 9386 free(s); 9387 emptyS(s); 9388 r = iInsertS(&s, -1, "s"); 9389 ck_assert_ptr_eq(r, s); 9390 ck_assert_str_eq(s, "s"); 9391 free(s); 9392 // empty insert string 9393 s = strdup("a"); 9394 r = iInsertS(&s, 0, ""); 9395 ck_assert_ptr_eq(r, s); 9396 ck_assert_str_eq(s, "a"); 9397 free(s); 9398 // NULL insert string 9399 s = strdup("a"); 9400 r = iInsertS(&s, 0, NULL); 9401 ck_assert_ptr_eq(r, s); 9402 ck_assert_str_eq(s, "a"); 9403 free(s); 9404 // NULL string 9405 s = NULL; 9406 r = iInsertS(&s, 0, "s"); 9407 ck_assert_ptr_eq(r, s); 9408 ck_assert_str_eq(s, "s"); 9409 free(s); 9410 // NULL var 9411 r = iInsertS(NULL, 0, "s"); 9412 ck_assert_ptr_eq(r, null); 9413 9414 END_TEST 9415 9416 9417 START_TEST(iInsertNFreeST) 9418 9419 char *s, *a, *r; 9420 9421 // insert 9422 s = strdup("sheepy"); 9423 r = iInsertNFreeS(&s, 0, strdup("lib")); 9424 ck_assert_ptr_eq(r, s); 9425 ck_assert_str_eq(s, "libsheepy"); 9426 free(s); 9427 // negative index 9428 s = strdup("libsheepy"); 9429 r = iInsertNFreeS(&s, -2, strdup("P")); 9430 ck_assert_ptr_eq(r, s); 9431 ck_assert_str_eq(s, "libsheepPy"); 9432 free(s); 9433 // edge 9434 s = strdup("qwe"); 9435 r = iInsertNFreeS(&s, 3, strdup("C")); 9436 ck_assert_ptr_eq(r, s); 9437 ck_assert_str_eq(s, "qweC"); 9438 free(s); 9439 // outside string 9440 s = strdup("qwe"); 9441 a = strdup("C"); 9442 r = iInsertNFreeS(&s, 4, a); 9443 ck_assert_ptr_eq(r, NULL); 9444 ck_assert_str_eq(s, "qwe"); 9445 r = iInsertNFreeS(&s, -5, a); 9446 ck_assert_ptr_eq(r, NULL); 9447 free(a); 9448 ck_assert_str_eq(s, "qwe"); 9449 free(s); 9450 // negative index in a one char string 9451 s = strdup("s"); 9452 r = iInsertNFreeS(&s, -1, strdup("S")); 9453 ck_assert_ptr_eq(r, s); 9454 ck_assert_str_eq(s, "sS"); 9455 free(s); 9456 // empty string 9457 emptyS(s); 9458 r = iInsertNFreeS(&s, 0, strdup("s")); 9459 ck_assert_ptr_eq(r, s); 9460 ck_assert_str_eq(s, "s"); 9461 free(s); 9462 emptyS(s); 9463 r = iInsertNFreeS(&s, -1, strdup("s")); 9464 ck_assert_ptr_eq(r, s); 9465 ck_assert_str_eq(s, "s"); 9466 free(s); 9467 // empty insert string 9468 s = strdup("a"); 9469 r = iInsertNFreeS(&s, 0, strdup("")); 9470 ck_assert_ptr_eq(r, s); 9471 ck_assert_str_eq(s, "a"); 9472 free(s); 9473 // NULL insert string 9474 s = strdup("a"); 9475 r = iInsertNFreeS(&s, 0, NULL); 9476 ck_assert_ptr_eq(r, s); 9477 ck_assert_str_eq(s, "a"); 9478 free(s); 9479 // NULL string 9480 s = NULL; 9481 r = iInsertNFreeS(&s, 0, strdup("s")); 9482 ck_assert_ptr_eq(r, s); 9483 ck_assert_str_eq(s, "s"); 9484 free(s); 9485 // NULL var 9486 s = strdup("s"); 9487 r = iInsertNFreeS(NULL, 0, s); 9488 ck_assert_ptr_eq(r, NULL); 9489 free(s); 9490 9491 END_TEST 9492 9493 9494 START_TEST(bInsertST) 9495 9496 char s[100]; 9497 char *r = null; 9498 9499 // insert 9500 strcpy(s, "sheepy"); 9501 r = bInsertS(s, 0, "lib"); 9502 ck_assert_ptr_eq(r, s); 9503 ck_assert_str_eq(s, "libsheepy"); 9504 // negative index 9505 strcpy(s, "libsheepy"); 9506 r = bInsertS(s, -2, "P"); 9507 ck_assert_ptr_eq(r, s); 9508 ck_assert_str_eq(s, "libsheepPy"); 9509 // edge 9510 strcpy(s, "qwe"); 9511 r = bInsertS(s, 3, "C"); 9512 ck_assert_ptr_eq(r, s); 9513 ck_assert_str_eq(s, "qweC"); 9514 // outside string 9515 strcpy(s, "qwe"); 9516 r = bInsertS(s, 4, "C"); 9517 ck_assert_ptr_eq(r, null); 9518 ck_assert_str_eq(s, "qwe"); 9519 r = bInsertS(s, -5, "C"); 9520 ck_assert_ptr_eq(r, null); 9521 ck_assert_str_eq(s, "qwe"); 9522 // negative index in a one char string 9523 strcpy(s, "s"); 9524 r = bInsertS(s, -1, "S"); 9525 ck_assert_ptr_eq(r, s); 9526 ck_assert_str_eq(s, "sS"); 9527 // empty string 9528 bEmptyS(s); 9529 r = bInsertS(s, 0, "s"); 9530 ck_assert_ptr_eq(r, s); 9531 ck_assert_str_eq(s, "s"); 9532 bEmptyS(s); 9533 r = bInsertS(s, -1, "s"); 9534 ck_assert_ptr_eq(r, s); 9535 ck_assert_str_eq(s, "s"); 9536 // empty insert string 9537 strcpy(s, "a"); 9538 r = bInsertS(s, 0, ""); 9539 ck_assert_ptr_eq(r, s); 9540 ck_assert_str_eq(s, "a"); 9541 // NULL insert string 9542 strcpy(s, "a"); 9543 r = bInsertS(s, 0, NULL); 9544 ck_assert_ptr_eq(r, s); 9545 ck_assert_str_eq(s, "a"); 9546 // NULL var 9547 r = bInsertS(NULL, 0, "s"); 9548 ck_assert_ptr_eq(r, null); 9549 9550 END_TEST 9551 9552 9553 START_TEST(bLInsertST) 9554 9555 char s[100]; 9556 char *r = null; 9557 9558 // insert 9559 strcpy(s, "sheepy"); 9560 r = bLInsertS(s, sizeof s, 0, "lib"); 9561 ck_assert_ptr_eq(r, s); 9562 ck_assert_str_eq(s, "libsheepy"); 9563 // shorter buffer 9564 strcpy(s, "sheepy"); 9565 r = bLInsertS(s, 5, 0, "lib"); 9566 ck_assert_ptr_eq(r, s); 9567 ck_assert_str_eq(s, "libs"); 9568 // negative index 9569 strcpy(s, "libsheepy"); 9570 r = bLInsertS(s, sizeof s, -2, "P"); 9571 ck_assert_ptr_eq(r, s); 9572 ck_assert_str_eq(s, "libsheepPy"); 9573 // edge 9574 strcpy(s, "qwe"); 9575 r = bLInsertS(s, sizeof s, 3, "C"); 9576 ck_assert_ptr_eq(r, s); 9577 ck_assert_str_eq(s, "qweC"); 9578 // outside string 9579 strcpy(s, "qwe"); 9580 r = bLInsertS(s, sizeof s, 4, "C"); 9581 ck_assert_ptr_eq(r, null); 9582 ck_assert_str_eq(s, "qwe"); 9583 r = bLInsertS(s, sizeof s, -5, "C"); 9584 ck_assert_ptr_eq(r, null); 9585 ck_assert_str_eq(s, "qwe"); 9586 // negative index in a one char string 9587 strcpy(s, "s"); 9588 r = bLInsertS(s, sizeof s, -1, "S"); 9589 ck_assert_ptr_eq(r, s); 9590 ck_assert_str_eq(s, "sS"); 9591 // empty string 9592 bEmptyS(s); 9593 r = bLInsertS(s, sizeof s, 0, "s"); 9594 ck_assert_ptr_eq(r, s); 9595 ck_assert_str_eq(s, "s"); 9596 bEmptyS(s); 9597 r = bLInsertS(s, sizeof s, -1, "s"); 9598 ck_assert_ptr_eq(r, s); 9599 ck_assert_str_eq(s, "s"); 9600 // empty insert string 9601 strcpy(s, "a"); 9602 r = bLInsertS(s, sizeof s, 0, ""); 9603 ck_assert_ptr_eq(r, s); 9604 ck_assert_str_eq(s, "a"); 9605 // size 0 - no change 9606 r = bLInsertS(s, 0, 0, "qwe"); 9607 ck_assert_ptr_eq(r, s); 9608 ck_assert_str_eq(s, "a"); 9609 // NULL insert string 9610 strcpy(s, "a"); 9611 r = bLInsertS(s, sizeof s, 0, NULL); 9612 ck_assert_ptr_eq(r, s); 9613 ck_assert_str_eq(s, "a"); 9614 // NULL var 9615 r = bLInsertS(NULL, sizeof s, 0, "s"); 9616 ck_assert_ptr_eq(r, null); 9617 9618 END_TEST 9619 9620 9621 START_TEST(injectST) 9622 9623 char *s; 9624 9625 // insert 9626 s = injectS("sheepy", 0, 'L'); 9627 ck_assert_str_eq(s, "Lsheepy"); 9628 free(s); 9629 // negative index 9630 s = injectS("libsheepy", -2, 'P'); 9631 ck_assert_str_eq(s, "libsheepPy"); 9632 free(s); 9633 // edge 9634 s = injectS("qwe", 3, 'C'); 9635 ck_assert_str_eq(s, "qweC"); 9636 free(s); 9637 // outside string 9638 s = injectS("qwe", 4, 'C'); 9639 ck_assert_ptr_eq(s, NULL); 9640 s = injectS("qwe", -5, 'C'); 9641 ck_assert_ptr_eq(s, NULL); 9642 // negative index in a one char string 9643 s = injectS("s", -2, 'S'); 9644 ck_assert_str_eq(s, "Ss"); 9645 free(s); 9646 // empty string 9647 s = injectS("", 0, 's'); 9648 ck_assert_str_eq(s, "s"); 9649 free(s); 9650 s = injectS("", -1, 's'); 9651 ck_assert_str_eq(s, "s"); 9652 free(s); 9653 // NULL string 9654 s = injectS(NULL, 0, 's'); 9655 ck_assert_str_eq(s, "s"); 9656 free(s); 9657 9658 9659 END_TEST 9660 9661 9662 START_TEST(iInjectST) 9663 9664 char *s; 9665 char *r = null; 9666 9667 // insert 9668 s = strdup("sheepy"); 9669 r = iInjectS(&s, 0, 'L'); 9670 ck_assert_ptr_eq(r, s); 9671 ck_assert_str_eq(s, "Lsheepy"); 9672 free(s); 9673 // negative index 9674 s = strdup("libsheepy"); 9675 r = iInjectS(&s, -2, 'P'); 9676 ck_assert_ptr_eq(r, s); 9677 ck_assert_str_eq(s, "libsheepPy"); 9678 free(s); 9679 // edge 9680 s = strdup("qwe"); 9681 r = iInjectS(&s, 3, 'C'); 9682 ck_assert_ptr_eq(r, s); 9683 ck_assert_str_eq(s, "qweC"); 9684 free(s); 9685 // outside string 9686 s = strdup("qwe"); 9687 r = iInjectS(&s, 4, 'C'); 9688 ck_assert_ptr_eq(r, null); 9689 ck_assert_str_eq(s, "qwe"); 9690 r = iInjectS(&s, -5, 'C'); 9691 ck_assert_ptr_eq(r, null); 9692 ck_assert_str_eq(s, "qwe"); 9693 free(s); 9694 // negative index in a one char string 9695 s = strdup("s"); 9696 r = iInjectS(&s, -1, 'S'); 9697 ck_assert_ptr_eq(r, s); 9698 ck_assert_str_eq(s, "sS"); 9699 free(s); 9700 // empty string 9701 emptyS(s); 9702 r = iInjectS(&s, 0, 's'); 9703 ck_assert_ptr_eq(r, s); 9704 ck_assert_str_eq(s, "s"); 9705 free(s); 9706 emptyS(s); 9707 r = iInjectS(&s, -1, 's'); 9708 ck_assert_ptr_eq(r, s); 9709 ck_assert_str_eq(s, "s"); 9710 free(s); 9711 // NULL string 9712 s = NULL; 9713 r = iInjectS(&s, 0, 's'); 9714 ck_assert_ptr_eq(r, s); 9715 ck_assert_str_eq(s, "s"); 9716 free(s); 9717 // NULL var 9718 r = iInjectS(NULL, 0, 's'); 9719 ck_assert_ptr_eq(r, null); 9720 9721 END_TEST 9722 9723 9724 START_TEST(bInjectST) 9725 9726 char s[100]; 9727 char *r = null; 9728 9729 // insert 9730 strcpy(s, "sheepy"); 9731 r = bInjectS(s, 0, 'L'); 9732 ck_assert_ptr_eq(r, s); 9733 ck_assert_str_eq(s, "Lsheepy"); 9734 // negative index 9735 strcpy(s, "libsheepy"); 9736 r = bInjectS(s, -2, 'P'); 9737 ck_assert_ptr_eq(r, s); 9738 ck_assert_str_eq(s, "libsheepPy"); 9739 // edge 9740 strcpy(s, "qwe"); 9741 r = bInjectS(s, 3, 'C'); 9742 ck_assert_ptr_eq(r, s); 9743 ck_assert_str_eq(s, "qweC"); 9744 // outside string 9745 strcpy(s, "qwe"); 9746 r = bInjectS(s, 4, 'C'); 9747 ck_assert_ptr_eq(r, null); 9748 ck_assert_str_eq(s, "qwe"); 9749 r = bInjectS(s, -5, 'C'); 9750 ck_assert_ptr_eq(r, null); 9751 ck_assert_str_eq(s, "qwe"); 9752 // negative index in a one char string 9753 strcpy(s, "s"); 9754 r = bInjectS(s, -1, 'S'); 9755 ck_assert_ptr_eq(r, s); 9756 ck_assert_str_eq(s, "sS"); 9757 // empty string 9758 bEmptyS(s); 9759 r = bInjectS(s, 0, 's'); 9760 ck_assert_ptr_eq(r, s); 9761 ck_assert_str_eq(s, "s"); 9762 bEmptyS(s); 9763 r = bInjectS(s, -1, 's'); 9764 ck_assert_ptr_eq(r, s); 9765 ck_assert_str_eq(s, "s"); 9766 // NULL var 9767 r = bInjectS(NULL, 0, 's'); 9768 ck_assert_ptr_eq(r, null); 9769 9770 END_TEST 9771 9772 9773 START_TEST(bLInjectST) 9774 9775 char s[100]; 9776 char *r = null; 9777 9778 // insert 9779 strcpy(s, "sheepy"); 9780 r = bLInjectS(s, sizeof s, 0, 'L'); 9781 ck_assert_ptr_eq(r, s); 9782 ck_assert_str_eq(s, "Lsheepy"); 9783 // shorter buffer 9784 strcpy(s, "sheepy"); 9785 r = bLInjectS(s, 5, 0, 'L'); 9786 ck_assert_ptr_eq(r, s); 9787 ck_assert_str_eq(s, "Lshe"); 9788 // negative index 9789 strcpy(s, "libsheepy"); 9790 r = bLInjectS(s, sizeof s, -2, 'P'); 9791 ck_assert_ptr_eq(r, s); 9792 ck_assert_str_eq(s, "libsheepPy"); 9793 // edge 9794 strcpy(s, "qwe"); 9795 r = bLInjectS(s, sizeof s, 3, 'C'); 9796 ck_assert_ptr_eq(r, s); 9797 ck_assert_str_eq(s, "qweC"); 9798 // outside string 9799 strcpy(s, "qwe"); 9800 r = bLInjectS(s, sizeof s, 4, 'C'); 9801 ck_assert_ptr_eq(r, null); 9802 ck_assert_str_eq(s, "qwe"); 9803 r = bLInjectS(s, sizeof s, -5, 'C'); 9804 ck_assert_ptr_eq(r, null); 9805 ck_assert_str_eq(s, "qwe"); 9806 // negative index in a one char string 9807 strcpy(s, "s"); 9808 r = bLInjectS(s, sizeof s, -1, 'S'); 9809 ck_assert_ptr_eq(r, s); 9810 ck_assert_str_eq(s, "sS"); 9811 // empty string 9812 bEmptyS(s); 9813 r = bLInjectS(s, sizeof s, 0, 's'); 9814 ck_assert_ptr_eq(r, s); 9815 ck_assert_str_eq(s, "s"); 9816 bEmptyS(s); 9817 r = bLInjectS(s, sizeof s, -1, 's'); 9818 ck_assert_ptr_eq(r, s); 9819 ck_assert_str_eq(s, "s"); 9820 // size 0 - no change 9821 r = bLInjectS(s, 0, -1, 's'); 9822 ck_assert_ptr_eq(r, s); 9823 ck_assert_str_eq(s, "s"); 9824 // NULL var 9825 r = bLInjectS(NULL, sizeof s, 0, 's'); 9826 ck_assert_ptr_eq(r, null); 9827 9828 END_TEST 9829 9830 9831 START_TEST(delST) 9832 9833 // del 9834 char *s = delS("sheepy", 0,2); 9835 ck_assert_str_eq(s, "eepy"); 9836 free(s); 9837 // negative index 9838 s = delS("sheepy", -2,0); 9839 ck_assert_str_eq(s, "shee"); 9840 free(s); 9841 // positive and negative indexes 9842 s = delS("sheepy", 2,-2); 9843 ck_assert_str_eq(s, "shpy"); 9844 free(s); 9845 // start = end 9846 s = delS("sheepy", 2,-4); 9847 ck_assert_str_eq(s, "sheepy"); 9848 free(s); 9849 // delete entire string 9850 s = delS("sheepy", 0,0); 9851 ck_assert_str_eq(s, ""); 9852 free(s); 9853 // end of string 9854 s = delS("sheepy", 2,6); 9855 ck_assert_str_eq(s, "sh"); 9856 free(s); 9857 // NULL string 9858 ck_assert_ptr_eq(delS(NULL, 2,-4), NULL); 9859 // start outside string 9860 ck_assert_ptr_eq(delS("sheepy", 20,-4), NULL); 9861 s = delS("sheepy", -20,-4); 9862 ck_assert_str_eq(s, "eepy"); 9863 free(s); 9864 // end outside string 9865 s = delS("sheepy", 2,40); 9866 ck_assert_str_eq(s, "sh"); 9867 free(s); 9868 ck_assert_ptr_eq(delS("sheepy", 2,-40), NULL); 9869 // end before start 9870 ck_assert_ptr_eq(delS("sheepy", 4,2), NULL); 9871 9872 END_TEST 9873 9874 9875 START_TEST(iDelST) 9876 9877 char *s, *r; 9878 // del 9879 s = strdup("sheepy"); 9880 r = iDelS(&s, 0,2); 9881 ck_assert_str_eq(s, "eepy"); 9882 free(s); 9883 // negative index 9884 s = strdup("sheepy"); 9885 r = iDelS(&s, -2,0); 9886 ck_assert_str_eq(s, "shee"); 9887 free(s); 9888 // positive and negative indexes 9889 s = strdup("sheepy"); 9890 r = iDelS(&s, 2,-2); 9891 ck_assert_str_eq(s, "shpy"); 9892 free(s); 9893 // start = end 9894 s = strdup("sheepy"); 9895 r = iDelS(&s, 2,-4); 9896 ck_assert_str_eq(s, "sheepy"); 9897 free(s); 9898 // delete entire string 9899 s = strdup("sheepy"); 9900 r = iDelS(&s, 0,0); 9901 ck_assert_str_eq(s, ""); 9902 free(s); 9903 // end of string 9904 s = strdup("sheepy"); 9905 r = iDelS(&s, 2,6); 9906 ck_assert_str_eq(s, "sh"); 9907 free(s); 9908 // NULL string 9909 s = NULL; 9910 r = iDelS(&s, 2,-4); 9911 ck_assert_ptr_eq(s, NULL); 9912 // start outside string 9913 s = strdup("sheepy"); 9914 r = iDelS(&s, 20,-4); 9915 ck_assert_str_eq(s, "sheepy"); 9916 r = iDelS(&s, -20,-4); 9917 ck_assert_str_eq(s, "eepy"); 9918 free(s); 9919 // end outside string 9920 s = strdup("sheepy"); 9921 r = iDelS(&s, 2,40); 9922 ck_assert_str_eq(s, "sh"); 9923 free(s); 9924 s = strdup("sheepy"); 9925 r = iDelS(&s, 2,-40); 9926 ck_assert_str_eq(s, "sheepy"); 9927 free(s); 9928 // end before start 9929 s = strdup("sheepy"); 9930 r = iDelS(&s, 4,2); 9931 ck_assert_str_eq(s, "sheepy"); 9932 free(s); 9933 // NULL var 9934 r = iDelS(NULL, 4,2); 9935 ck_assert_ptr_eq(r, null); 9936 9937 END_TEST 9938 9939 9940 START_TEST(bDelST) 9941 9942 char s[100]; 9943 char *r = null; 9944 9945 // del 9946 strcpy(s, "sheepy"); 9947 r = bDelS(s, 0,2); 9948 ck_assert_ptr_eq(r, s); 9949 ck_assert_str_eq(s, "eepy"); 9950 // negative index 9951 strcpy(s, "sheepy"); 9952 r = bDelS(s, -2,0); 9953 ck_assert_ptr_eq(r, s); 9954 ck_assert_str_eq(s, "shee"); 9955 // positive and negative indexes 9956 strcpy(s, "sheepy"); 9957 r = bDelS(s, 2,-2); 9958 ck_assert_ptr_eq(r, s); 9959 ck_assert_str_eq(s, "shpy"); 9960 // start = end 9961 strcpy(s, "sheepy"); 9962 r = bDelS(s, 2,-4); 9963 ck_assert_ptr_eq(r, s); 9964 ck_assert_str_eq(s, "sheepy"); 9965 // delete entire string 9966 strcpy(s, "sheepy"); 9967 r = bDelS(s, 0,0); 9968 ck_assert_ptr_eq(r, s); 9969 ck_assert_str_eq(s, ""); 9970 // end of string 9971 strcpy(s, "sheepy"); 9972 r = bDelS(s, 2,6); 9973 ck_assert_ptr_eq(r, s); 9974 ck_assert_str_eq(s, "sh"); 9975 // start outside string 9976 strcpy(s, "sheepy"); 9977 r = bDelS(s, 20,-4); 9978 ck_assert_ptr_eq(r, null); 9979 ck_assert_str_eq(s, "sheepy"); 9980 r = bDelS(s, -20,-4); 9981 ck_assert_ptr_eq(r, s); 9982 ck_assert_str_eq(s, "eepy"); 9983 // end outside string 9984 strcpy(s, "sheepy"); 9985 r = bDelS(s, 2,40); 9986 ck_assert_ptr_eq(r, s); 9987 ck_assert_str_eq(s, "sh"); 9988 strcpy(s, "sheepy"); 9989 r = bDelS(s, 2,-40); 9990 ck_assert_ptr_eq(r, null); 9991 ck_assert_str_eq(s, "sheepy"); 9992 // end before start 9993 strcpy(s, "sheepy"); 9994 r = bDelS(s, 4,2); 9995 ck_assert_ptr_eq(r, null); 9996 ck_assert_str_eq(s, "sheepy"); 9997 // NULL var 9998 r = bDelS(NULL, 4,2); 9999 ck_assert_ptr_eq(r, null); 10000 10001 END_TEST 10002 10003 10004 START_TEST(bLDelST) 10005 10006 char s[100]; 10007 char *r = null; 10008 10009 // del 10010 strcpy(s, "sheepy"); 10011 r = bLDelS(s, sizeof(s), 0,2); 10012 ck_assert_ptr_eq(r, s); 10013 ck_assert_str_eq(s, "eepy"); 10014 // buffer shorter than string 10015 strcpy(s, "sheepy"); 10016 r = bLDelS(s, 5, 0,2); 10017 ck_assert_ptr_eq(r, s); 10018 ck_assert_str_eq(s, "ee"); 10019 // negative index 10020 strcpy(s, "sheepy"); 10021 r = bLDelS(s, sizeof(s), -2,0); 10022 ck_assert_ptr_eq(r, s); 10023 ck_assert_str_eq(s, "shee"); 10024 // positive and negative indexes 10025 strcpy(s, "sheepy"); 10026 r = bLDelS(s, sizeof(s), 2,-2); 10027 ck_assert_ptr_eq(r, s); 10028 ck_assert_str_eq(s, "shpy"); 10029 // start = end 10030 strcpy(s, "sheepy"); 10031 r = bLDelS(s, sizeof(s), 2,-4); 10032 ck_assert_ptr_eq(r, s); 10033 ck_assert_str_eq(s, "sheepy"); 10034 // end of string 10035 strcpy(s, "sheepy"); 10036 r = bLDelS(s, sizeof(s), 2,6); 10037 ck_assert_ptr_eq(r, s); 10038 ck_assert_str_eq(s, "sh"); 10039 // start outside string 10040 strcpy(s, "sheepy"); 10041 r = bLDelS(s, sizeof(s), 20,-4); 10042 ck_assert_ptr_eq(r, null); 10043 ck_assert_str_eq(s, "sheepy"); 10044 // end outside string 10045 strcpy(s, "sheepy"); 10046 r = bLDelS(s, sizeof(s), 2,40); 10047 ck_assert_ptr_eq(r, s); 10048 ck_assert_str_eq(s, "sh"); 10049 strcpy(s, "sheepy"); 10050 r = bLDelS(s, sizeof(s), -22,3); 10051 ck_assert_ptr_eq(r, s); 10052 ck_assert_str_eq(s, "epy"); 10053 strcpy(s, "sheepy"); 10054 r = bLDelS(s, sizeof(s), 2,-40); 10055 ck_assert_ptr_eq(r, null); 10056 ck_assert_str_eq(s, "sheepy"); 10057 // end before start 10058 strcpy(s, "sheepy"); 10059 r = bLDelS(s, sizeof(s), 4,2); 10060 ck_assert_ptr_eq(r, null); 10061 ck_assert_str_eq(s, "sheepy"); 10062 // size 0 10063 r = bLDelS(s, 0, 0, 0); 10064 ck_assert_ptr_eq(r, null); 10065 // NULL var 10066 r = bLDelS(NULL, sizeof(s), 0, 0); 10067 ck_assert_ptr_eq(r, null); 10068 10069 10070 END_TEST 10071 10072 10073 START_TEST(delElemST) 10074 10075 char b[20]; 10076 char *r; 10077 10078 // del 10079 strcpy(b, "sheepy"); 10080 r = delElemS(b, 0); 10081 ck_assert_str_eq(r, "heepy"); 10082 free(r); 10083 strcpy(b, "sheepy"); 10084 r = delElemS(b, 5); 10085 ck_assert_str_eq(r, "sheep"); 10086 free(r); 10087 // negative index 10088 strcpy(b, "sheepy"); 10089 r = delElemS(b, -1); 10090 ck_assert_str_eq(r, "sheep"); 10091 free(r); 10092 strcpy(b, "sheepy"); 10093 r = delElemS(b, -6); 10094 ck_assert_str_eq(r, "heepy"); 10095 free(r); 10096 // index outside string 10097 strcpy(b, "sheepy"); 10098 r = delElemS(b, 6); 10099 ck_assert_ptr_eq(r, null); 10100 free(r); 10101 strcpy(b, "sheepy"); 10102 r = delElemS(b, -7); 10103 ck_assert_ptr_eq(r, null); 10104 free(r); 10105 // null string 10106 ck_assert_ptr_eq(delElemS(null, 0), null); 10107 10108 10109 END_TEST 10110 10111 10112 START_TEST(iDelElemST) 10113 10114 char *b; 10115 char *r; 10116 10117 // del 10118 b = strdup("sheepy"); 10119 r = iDelElemS(&b, 0); 10120 ck_assert_str_eq(r, "heepy"); 10121 free(r); 10122 b = strdup("sheepy"); 10123 r = iDelElemS(&b, 5); 10124 ck_assert_str_eq(r, "sheep"); 10125 free(r); 10126 // negative index 10127 b = strdup("sheepy"); 10128 r = iDelElemS(&b, -1); 10129 ck_assert_str_eq(r, "sheep"); 10130 free(r); 10131 b = strdup("sheepy"); 10132 r = iDelElemS(&b, -6); 10133 ck_assert_str_eq(r, "heepy"); 10134 free(r); 10135 // index outside string 10136 b = strdup("sheepy"); 10137 r = iDelElemS(&b, 6); 10138 ck_assert_ptr_eq(r, null); 10139 free(b); 10140 b = strdup("sheepy"); 10141 r = iDelElemS(&b, -7); 10142 ck_assert_ptr_eq(r, null); 10143 free(b); 10144 // null string 10145 ck_assert_ptr_eq(iDelElemS(null, 0), null); 10146 10147 10148 END_TEST 10149 10150 10151 START_TEST(bDelElemST) 10152 10153 char b[20]; 10154 char *r; 10155 10156 // del 10157 strcpy(b, "sheepy"); 10158 r = bDelElemS(b, 0); 10159 ck_assert_str_eq(r, "heepy"); 10160 strcpy(b, "sheepy"); 10161 r = bDelElemS(b, 5); 10162 ck_assert_str_eq(r, "sheep"); 10163 // negative index 10164 strcpy(b, "sheepy"); 10165 r = bDelElemS(b, -1); 10166 ck_assert_str_eq(r, "sheep"); 10167 strcpy(b, "sheepy"); 10168 r = bDelElemS(b, -6); 10169 ck_assert_str_eq(r, "heepy"); 10170 // index outside string 10171 strcpy(b, "sheepy"); 10172 r = bDelElemS(b, 6); 10173 ck_assert_ptr_eq(r, null); 10174 strcpy(b, "sheepy"); 10175 r = bDelElemS(b, -7); 10176 ck_assert_ptr_eq(r, null); 10177 // null string 10178 ck_assert_ptr_eq(bDelElemS(null, 0), null); 10179 10180 10181 END_TEST 10182 10183 10184 START_TEST(bLDelElemST) 10185 10186 char b[20]; 10187 char *r; 10188 10189 // del 10190 strcpy(b, "sheepy"); 10191 r = bLDelElemS(b, sizeof(b), 0); 10192 ck_assert_str_eq(r, "heepy"); 10193 strcpy(b, "sheepy"); 10194 r = bLDelElemS(b, sizeof(b), 5); 10195 ck_assert_str_eq(r, "sheep"); 10196 // negative index 10197 strcpy(b, "sheepy"); 10198 r = bLDelElemS(b, sizeof(b), -1); 10199 ck_assert_str_eq(r, "sheep"); 10200 strcpy(b, "sheepy"); 10201 r = bLDelElemS(b, sizeof(b), -6); 10202 ck_assert_str_eq(r, "heepy"); 10203 // dest size shorter than strlen 10204 strcpy(b, "sheepy"); 10205 r = bLDelElemS(b, 4, -1); 10206 ck_assert_str_eq(r, "sh"); 10207 // index outside string 10208 strcpy(b, "sheepy"); 10209 r = bLDelElemS(b, sizeof(b), 6); 10210 ck_assert_ptr_eq(r, null); 10211 strcpy(b, "sheepy"); 10212 r = bLDelElemS(b, sizeof(b), -7); 10213 ck_assert_ptr_eq(r, null); 10214 r = bLDelElemS(b, sizeof(b), -8); 10215 ck_assert_ptr_eq(r, null); 10216 // size 0 10217 ck_assert_ptr_eq(bLDelElemS(b, 0, 0), null); 10218 // null string 10219 ck_assert_ptr_eq(bLDelElemS(null, sizeof(b), 0), null); 10220 10221 10222 END_TEST 10223 10224 10225 START_TEST(findST) 10226 10227 // find string in the middle 10228 ck_assert_str_eq(findS("sheepy", "ee"), "eepy"); 10229 // find non existing string 10230 ck_assert_ptr_eq(findS("sheepy", "$"), NULL); 10231 // find NULL 10232 ck_assert_ptr_eq(findS("sheepy", NULL), NULL); 10233 // NULL string 10234 ck_assert_ptr_eq(findS(NULL, "$"), NULL); 10235 10236 END_TEST 10237 10238 10239 START_TEST(findCharST) 10240 10241 // find string in the middle 10242 ck_assert_str_eq(findCharS("sheepy", 'e'), "eepy"); 10243 // find non existing string 10244 ck_assert_ptr_eq(findCharS("sheepy", '$'), NULL); 10245 // find 0 10246 ck_assert_str_eq(findCharS("sheepy", 0), ""); 10247 // NULL string 10248 ck_assert_ptr_eq(findCharS(NULL, '$'), NULL); 10249 10250 END_TEST 10251 10252 10253 START_TEST(indexOfST) 10254 10255 // indexOf string in the middle 10256 ck_assert_int_eq(indexOfS("sheepy", "ee"), 2); 10257 // indexOf non existing string 10258 ck_assert_int_eq(indexOfS("sheepy", "$"), -1); 10259 // indexOf NULL 10260 ck_assert_int_eq(indexOfS("sheepy", NULL), -1); 10261 // NULL string 10262 ck_assert_int_eq(indexOfS(NULL, "$"), -1); 10263 10264 10265 END_TEST 10266 10267 10268 START_TEST(indexOfCharST) 10269 10270 // indexOf string in the middle 10271 ck_assert_int_eq(indexOfCharS("sheepy", 'e'), 2); 10272 // indexOf non existing string 10273 ck_assert_int_eq(indexOfCharS("sheepy", '$'), -1); 10274 // indexOf 0 10275 ck_assert_int_eq(indexOfCharS("sheepy", 0), 6); 10276 // NULL string 10277 ck_assert_int_eq(indexOfCharS(NULL, '$'), -1); 10278 10279 10280 END_TEST 10281 10282 10283 START_TEST(hasST) 10284 10285 // find string in the middle 10286 ck_assert(hasS("sheepy", "ee")); 10287 // find non existing string 10288 ck_assert(!hasS("sheepy", "$")); 10289 // find NULL 10290 ck_assert(!hasS("sheepy", NULL)); 10291 // NULL string 10292 ck_assert(!hasS(NULL, "$")); 10293 10294 END_TEST 10295 10296 10297 START_TEST(hasCharST) 10298 10299 // find string in the middle 10300 ck_assert(hasCharS("sheepy", 'e')); 10301 // find non existing string 10302 ck_assert(!hasCharS("sheepy", '$')); 10303 // find 0 10304 ck_assert(hasCharS("sheepy", 0)); 10305 // NULL string 10306 ck_assert(!hasCharS(NULL, '$')); 10307 10308 END_TEST 10309 10310 10311 START_TEST(icFindST) 10312 10313 // find string in the middle 10314 ck_assert_str_eq(icFindS("shEepy", "eE"), "Eepy"); 10315 // find non existing string 10316 ck_assert_ptr_eq(icFindS("sheepy", "$"), NULL); 10317 // find NULL 10318 ck_assert_ptr_eq(icFindS("sheepy", NULL), NULL); 10319 // NULL string 10320 ck_assert_ptr_eq(icFindS(NULL, "$"), NULL); 10321 10322 10323 END_TEST 10324 10325 10326 START_TEST(icFindCharST) 10327 10328 // find string in the middle 10329 ck_assert_str_eq(icFindCharS("shEEpy", 'e'), "EEpy"); 10330 // find non existing string 10331 ck_assert_ptr_eq(icFindCharS("sheepy", '$'), NULL); 10332 // find 0 10333 ck_assert_str_eq(icFindCharS("sheepy", 0), ""); 10334 // NULL string 10335 ck_assert_ptr_eq(icFindCharS(NULL, '$'), NULL); 10336 10337 10338 END_TEST 10339 10340 10341 START_TEST(icIndexOfST) 10342 10343 // indexOf string in the middle 10344 ck_assert_int_eq(icIndexOfS("sheepy", "EE"), 2); 10345 // indexOf non existing string 10346 ck_assert_int_eq(icIndexOfS("sheepy", "$"), -1); 10347 // indexOf NULL 10348 ck_assert_int_eq(icIndexOfS("sheepy", NULL), -1); 10349 // NULL string 10350 ck_assert_int_eq(icIndexOfS(NULL, "$"), -1); 10351 10352 10353 END_TEST 10354 10355 10356 START_TEST(icIndexOfCharST) 10357 10358 // indexOf string in the middle 10359 ck_assert_int_eq(icIndexOfCharS("sheepy", 'E'), 2); 10360 // indexOf non existing string 10361 ck_assert_int_eq(icIndexOfCharS("sheepy", '$'), -1); 10362 // indexOf 0 10363 ck_assert_int_eq(icIndexOfCharS("sheepy", 0), 6); 10364 // NULL string 10365 ck_assert_int_eq(icIndexOfCharS(NULL, '$'), -1); 10366 10367 10368 END_TEST 10369 10370 10371 START_TEST(icHasST) 10372 10373 // find string in the middle 10374 ck_assert(icHasS("sheepy", "EE")); 10375 // find non existing string 10376 ck_assert(!icHasS("sheepy", "$")); 10377 // find NULL 10378 ck_assert(!icHasS("sheepy", NULL)); 10379 // NULL string 10380 ck_assert(!icHasS(NULL, "$")); 10381 10382 10383 END_TEST 10384 10385 10386 START_TEST(icHasCharST) 10387 10388 // find string in the middle 10389 ck_assert(icHasCharS("shEepy", 'e')); 10390 // find non existing string 10391 ck_assert(!icHasCharS("sheepy", '$')); 10392 // find 0 10393 ck_assert(icHasCharS("sheepy", 0)); 10394 // NULL string 10395 ck_assert(!icHasCharS(NULL, '$')); 10396 10397 10398 END_TEST 10399 10400 10401 START_TEST(tokST) 10402 10403 // string 10404 char *s; 10405 char *w; 10406 s = strdup("172.16.43.0/24 dev ens32 dev proto"); 10407 w = s; 10408 ck_assert_str_eq(tokS(s, "dev ", &w), "172.16.43.0/24 "); 10409 free(s); 10410 // delimiter not found 10411 s = strdup("172.16.43.0/24 dev ens32 dev proto"); 10412 ck_assert_str_eq(tokS(s, "ANYTHING", &w), "172.16.43.0/24 dev ens32 dev proto"); 10413 ck_assert_ptr_eq(w, NULL); 10414 free(s); 10415 // same with w initialized to NULL 10416 s = strdup("172.16.43.0/24 dev ens32 dev proto"); 10417 w = NULL; 10418 ck_assert_str_eq(tokS(s, "dev ", &w), "172.16.43.0/24 "); 10419 ck_assert_str_eq(w, "ens32 dev proto"); 10420 ck_assert_str_eq(tokS(NULL, "dev ", &w), "ens32 "); 10421 ck_assert_str_eq(w, "proto"); 10422 ck_assert_str_eq(tokS(NULL, "dev ", &w), "proto"); 10423 ck_assert_ptr_eq(w, NULL); 10424 free(s); 10425 // NULL string 10426 w = NULL; 10427 ck_assert_ptr_eq(tokS(NULL, ";", &w), NULL); 10428 // NULL delimiter 10429 ck_assert_ptr_eq(tokS("test", NULL, &w), NULL); 10430 10431 END_TEST 10432 10433 10434 START_TEST(icTokST) 10435 10436 // string 10437 char *s; 10438 char *w; 10439 s = strdup("172.16.43.0/24 dev ens32 dev proto"); 10440 w = s; 10441 ck_assert_str_eq(icTokS(s, "DEV ", &w), "172.16.43.0/24 "); 10442 free(s); 10443 // delimiter not found 10444 s = strdup("172.16.43.0/24 dev ens32 dev proto"); 10445 ck_assert_str_eq(icTokS(s, "ANYTHING", &w), "172.16.43.0/24 dev ens32 dev proto"); 10446 ck_assert_ptr_eq(w, NULL); 10447 free(s); 10448 // same with w initialized to NULL 10449 s = strdup("172.16.43.0/24 DEV ens32 dev proto"); 10450 w = NULL; 10451 ck_assert_str_eq(icTokS(s, "dev ", &w), "172.16.43.0/24 "); 10452 ck_assert_str_eq(w, "ens32 dev proto"); 10453 ck_assert_str_eq(icTokS(NULL, "dev ", &w), "ens32 "); 10454 ck_assert_str_eq(w, "proto"); 10455 ck_assert_str_eq(icTokS(NULL, "dev ", &w), "proto"); 10456 ck_assert_ptr_eq(w, NULL); 10457 free(s); 10458 // NULL string 10459 w = NULL; 10460 ck_assert_ptr_eq(icTokS(NULL, ";", &w), NULL); 10461 // NULL delimiter 10462 ck_assert_ptr_eq(icTokS("test", NULL, &w), NULL); 10463 10464 10465 END_TEST 10466 10467 10468 START_TEST(lenUTF8T) 10469 10470 // string 10471 ck_assert_uint_eq(lenUTF8("sheepy"), 6); 10472 // UTF8 10473 ck_assert_uint_eq(lenUTF8("sheepy£"), 7); 10474 ck_assert_uint_eq(lenS("sheepy£"), 8); 10475 // NULL string 10476 ck_assert_uint_eq(lenUTF8(NULL), 0); 10477 10478 10479 END_TEST 10480 10481 10482 START_TEST(bLLenUTF8T) 10483 10484 // string 10485 ck_assert_uint_eq(bLLenUTF8("sheepy", 7), 6); 10486 // UTF8 10487 ck_assert_uint_eq(bLLenUTF8("sheepy£",9), 7); 10488 ck_assert_uint_eq(bLLenUTF8("sheepy£", 6), 5); 10489 ck_assert_uint_eq(lenS("sheepy£"), 8); 10490 // size 0 10491 ck_assert_uint_eq(bLLenUTF8("sheepy£", 0), 0); 10492 // NULL string 10493 ck_assert_uint_eq(bLLenUTF8(NULL, 1), 0); 10494 10495 10496 END_TEST 10497 10498 10499 START_TEST(isUTF8T) 10500 10501 char b[8]; 10502 char *r = null; 10503 10504 // string 10505 ck_assert(isUTF8("sheepy")); 10506 // UTF8 10507 ck_assert(isUTF8("sheepy£")); 10508 // invalid UTF8 10509 r = strLCpy(b, sizeof(b), "sheepy£"); 10510 ck_assert_ptr_eq(r, b); 10511 ck_assert(!isUTF8(b)); 10512 // null string 10513 ck_assert(!isUTF8(null)); 10514 10515 10516 END_TEST 10517 10518 10519 START_TEST(bLIsUTF8T) 10520 10521 // string 10522 ck_assert(bLIsUTF8("sheepy", 7)); 10523 // UTF8 10524 ck_assert(bLIsUTF8("sheepy£", 9)); 10525 // buffer shorter than string (string is not nul terminated) 10526 ck_assert(!bLIsUTF8("sheepy", 6)); 10527 // invalid UTF8 10528 ck_assert(!bLIsUTF8("sheepy£", 8)); 10529 // size 0 10530 ck_assert(!bLIsUTF8("sheepy£", 0)); 10531 // null string 10532 ck_assert(!bLIsUTF8(null, 1)); 10533 10534 10535 END_TEST 10536 10537 10538 START_TEST(isCodeUTF8T) 10539 10540 // valid 10541 ck_assert(isCodeUTF8("as")); 10542 ck_assert(isCodeUTF8("£s")); 10543 // invalid 10544 u8 b[3] = init0Var; 10545 b[0] = 128; 10546 ck_assert(!isCodeUTF8((char*)b)); 10547 // null string 10548 ck_assert(!isCodeUTF8(null)); 10549 10550 10551 END_TEST 10552 10553 10554 START_TEST(nextUTF8T) 10555 10556 const char *r; 10557 10558 // next 10559 r = nextUTF8("£sheepy"); 10560 ck_assert_str_eq(r, "sheepy"); 10561 // empty string 10562 r = nextUTF8(""); 10563 ck_assert_ptr_eq(r, null); 10564 // null string 10565 r = nextUTF8(null); 10566 ck_assert_ptr_eq(r, null); 10567 10568 10569 END_TEST 10570 10571 10572 START_TEST(bLNextUTF8T) 10573 10574 char b[20] = init0Var; 10575 const char *r; 10576 strcpy(b, "£sheepy"); 10577 10578 // next 10579 r = bLNextUTF8(b, sizeof(b), &b[3]); 10580 ck_assert_str_eq(r, "eepy"); 10581 // last char 10582 r = bLNextUTF8(b, sizeof(b), &b[7]); 10583 ck_assert_ptr_eq(r, null); 10584 // empty string 10585 r = bLNextUTF8(b, sizeof(b), &b[10]); 10586 ck_assert_ptr_eq(r, null); 10587 // string longer than buffer 10588 r = bLNextUTF8(b, 6, &b[7]); 10589 ck_assert_ptr_eq(r, null); 10590 r = bLNextUTF8(b, 6, &b[5]); 10591 ck_assert_ptr_eq(r, null); 10592 // size 0 10593 r = bLNextUTF8(b, 0, b); 10594 ck_assert_ptr_eq(r, null); 10595 // null string 10596 r = bLNextUTF8(null, 1, b); 10597 ck_assert_ptr_eq(r, null); 10598 r = bLNextUTF8(b, 1, null); 10599 ck_assert_ptr_eq(r, null); 10600 10601 10602 END_TEST 10603 10604 10605 START_TEST(findNextUTF8T) 10606 10607 char b[20] = init0Var; 10608 const char *r; 10609 strcpy(b, "£sheepy"); 10610 10611 // next 10612 r = findNextUTF8(b, sizeof(b), &b[3]); 10613 ck_assert_str_eq(r, "eepy"); 10614 // in a code point, find first valid code point in utf8 parameter 10615 // same as findNextUTF8(b, sizeof(b), &b[2]) 10616 r = findNextUTF8(b, sizeof(b), &b[1]); 10617 ck_assert_str_eq(r, "heepy"); 10618 // last char 10619 r = findNextUTF8(b, sizeof(b), &b[7]); 10620 ck_assert_ptr_eq(r, null); 10621 // empty string 10622 r = findNextUTF8(b, sizeof(b), &b[10]); 10623 ck_assert_ptr_eq(r, null); 10624 // string longer than buffer 10625 r = findNextUTF8(b, 6, &b[7]); 10626 ck_assert_ptr_eq(r, null); 10627 r = findNextUTF8(b, 6, &b[5]); 10628 ck_assert_ptr_eq(r, null); 10629 // size 0 10630 r = findNextUTF8(b, 0, b); 10631 ck_assert_ptr_eq(r, null); 10632 // null string 10633 r = findNextUTF8(null, 1, b); 10634 ck_assert_ptr_eq(r, null); 10635 r = findNextUTF8(b, 1, null); 10636 ck_assert_ptr_eq(r, null); 10637 10638 10639 END_TEST 10640 10641 10642 START_TEST(prevUTF8T) 10643 10644 char b[20] = init0Var; 10645 const char *r; 10646 strcpy(b, "£sheepy"); 10647 10648 // prev 10649 r = prevUTF8(&b[2]); 10650 ck_assert_str_eq(r, "£sheepy"); 10651 // null string 10652 r = prevUTF8(null); 10653 ck_assert_ptr_eq(r, null); 10654 10655 10656 END_TEST 10657 10658 10659 START_TEST(bPrevUTF8T) 10660 10661 char b[20] = init0Var; 10662 const char *r; 10663 strcpy(b, "£sheepy"); 10664 10665 // prev 10666 r = bPrevUTF8(b, &b[2]); 10667 ck_assert_str_eq(r, "£sheepy"); 10668 // string start 10669 r = bPrevUTF8(b, b); 10670 ck_assert_ptr_eq(r, null); 10671 // null string 10672 r = bPrevUTF8(null, b); 10673 ck_assert_ptr_eq(r, null); 10674 r = bPrevUTF8(b, null); 10675 ck_assert_ptr_eq(r, null); 10676 10677 END_TEST 10678 10679 10680 START_TEST(idx2PtrUTF8T) 10681 10682 char *emptys = ""; 10683 const char *r; 10684 10685 // index 10686 r = idx2PtrUTF8("£sheepy", 1); 10687 ck_assert_str_eq(r, "sheepy"); 10688 r = idx2PtrUTF8("£sheepy", 2); 10689 ck_assert_str_eq(r, "heepy"); 10690 r = idx2PtrUTF8("£sheepy", 0); 10691 ck_assert_str_eq(r, "£sheepy"); 10692 // NUL byte index 10693 r = idx2PtrUTF8("£sheepy", strlen("£sheepy")-1); 10694 ck_assert_str_eq(r, ""); 10695 // negative index 10696 r = idx2PtrUTF8("£sheepy", -1); 10697 ck_assert_str_eq(r, "y"); 10698 // empty string 10699 r = idx2PtrUTF8(emptys, -1); 10700 ck_assert_ptr_eq(r, emptys); 10701 // index outside buffer 10702 r = idx2PtrUTF8("£sheepy", 8); 10703 ck_assert_ptr_eq(r, null); 10704 r = idx2PtrUTF8("£sheepy", 9); 10705 ck_assert_ptr_eq(r, null); 10706 r = idx2PtrUTF8("£sheepy", -9); 10707 ck_assert_ptr_eq(r, null); 10708 // null string 10709 r = idx2PtrUTF8(null, 1); 10710 ck_assert_ptr_eq(r, null); 10711 10712 END_TEST 10713 10714 10715 START_TEST(bLIdx2PtrUTF8T) 10716 10717 char b[20] = init0Var; 10718 const char *r; 10719 strcpy(b, "£sheepy"); 10720 10721 // index 10722 r = bLIdx2PtrUTF8(b, sizeof(b), 3); 10723 ck_assert_str_eq(r, "eepy"); 10724 r = bLIdx2PtrUTF8(b, sizeof(b), 0); 10725 ck_assert_str_eq(r, b); 10726 // NUL byte index 10727 r = bLIdx2PtrUTF8(b, sizeS(b), strlen(b)-1); 10728 ck_assert_str_eq(r, ""); 10729 // negative index 10730 r = bLIdx2PtrUTF8(b, sizeof(b), -2); 10731 ck_assert_str_eq(r, "py"); 10732 r = bLIdx2PtrUTF8(b, sizeof(b), -1); 10733 ck_assert_str_eq(r, "y"); 10734 // string longer than buffer and negative index 10735 r = bLIdx2PtrUTF8(b, 8, -1); 10736 ck_assert_str_eq(r, "py"); 10737 // last char 10738 r = bLIdx2PtrUTF8(b, sizeof(b), 7); 10739 ck_assert_str_eq(r, ""); 10740 // empty string 10741 r = bLIdx2PtrUTF8(&b[10], 2, 1); 10742 ck_assert_str_eq(r, &b[10]); 10743 // index outside string 10744 r = bLIdx2PtrUTF8(b, 6, 7); 10745 ck_assert_ptr_eq(r, null); 10746 r = bLIdx2PtrUTF8(b, 6, 5); 10747 ck_assert_ptr_eq(r, null); 10748 r = bLIdx2PtrUTF8(b, 6, -7); 10749 ck_assert_ptr_eq(r, null); 10750 // size 0 10751 r = bLIdx2PtrUTF8(b, 0, 0); 10752 ck_assert_ptr_eq(r, b); 10753 // null string 10754 r = bLIdx2PtrUTF8(null, 1, 0); 10755 ck_assert_ptr_eq(r, null); 10756 10757 10758 END_TEST 10759 10760 10761 START_TEST(ptr2IdxUTF8T) 10762 10763 char b[20] = init0Var; 10764 int64_t r; 10765 strcpy(b, "£sheepy"); 10766 10767 // pointer to index 10768 r = ptr2IdxUTF8(b, &b[1]); 10769 ck_assert_int_eq(r, 0); 10770 r = ptr2IdxUTF8(b, &b[2]); 10771 ck_assert_int_eq(r, 1); 10772 r = ptr2IdxUTF8(&b[2], &b[4]); 10773 ck_assert_int_eq(r, 2); 10774 r = ptr2IdxUTF8(b, &b[7]); 10775 ck_assert_int_eq(r, 6); 10776 // negative index 10777 r = ptr2IdxUTF8(&b[8], &b[7]); 10778 ck_assert_int_eq(r, -1); 10779 r = ptr2IdxUTF8(&b[8], &b[6]); 10780 ck_assert_int_eq(r, -2); 10781 r = ptr2IdxUTF8(&b[8], b); 10782 ck_assert_int_eq(r, -7); 10783 // string start 10784 r = ptr2IdxUTF8(b, b); 10785 ck_assert_int_eq(r, 0); 10786 // null pos 10787 r = ptr2IdxUTF8(b, null); 10788 ck_assert_int_eq(r, 0); 10789 // null string 10790 r = ptr2IdxUTF8(null, b); 10791 ck_assert_int_eq(r, 0); 10792 10793 END_TEST 10794 10795 10796 START_TEST(bPtr2IdxUTF8T) 10797 10798 char b[20] = init0Var; 10799 int64_t r; 10800 strcpy(b, "£sheepy"); 10801 10802 // pointer to index 10803 r = bPtr2IdxUTF8(b, b, &b[1]); 10804 ck_assert_int_eq(r, 0); 10805 r = bPtr2IdxUTF8(b, b, &b[2]); 10806 ck_assert_int_eq(r, 1); 10807 r = bPtr2IdxUTF8(b, b, &b[7]); 10808 ck_assert_int_eq(r, 6); 10809 // negative index 10810 r = bPtr2IdxUTF8(b, &b[8], &b[7]); 10811 ck_assert_int_eq(r, -1); 10812 r = bPtr2IdxUTF8(b, &b[8], &b[6]); 10813 ck_assert_int_eq(r, -2); 10814 r = bPtr2IdxUTF8(b, &b[8], b); 10815 ck_assert_int_eq(r, -7); 10816 // string start 10817 r = bPtr2IdxUTF8(b, b, b); 10818 ck_assert_int_eq(r, 0); 10819 // null pos 10820 r = bPtr2IdxUTF8(b, b, null); 10821 ck_assert_int_eq(r, 0); 10822 // null string 10823 r = bPtr2IdxUTF8(b, null, b); 10824 ck_assert_int_eq(r, 0); 10825 r = bPtr2IdxUTF8(null, b, b); 10826 ck_assert_int_eq(r, 0); 10827 10828 10829 END_TEST 10830 10831 10832 START_TEST(bLPtr2IdxUTF8T) 10833 10834 char b[20] = init0Var; 10835 int64_t r; 10836 strcpy(b, "£sheepy"); 10837 10838 // pointer to index 10839 r = bLPtr2IdxUTF8(b, sizeof(b), &b[1]); 10840 ck_assert_int_eq(r, 0); 10841 r = bLPtr2IdxUTF8(b, sizeof(b), &b[2]); 10842 ck_assert_int_eq(r, 1); 10843 r = bLPtr2IdxUTF8(b, sizeof(b), &b[7]); 10844 ck_assert_int_eq(r, 6); 10845 // string start 10846 r = bLPtr2IdxUTF8(b, sizeof(b), b); 10847 ck_assert_int_eq(r, 0); 10848 // null pos 10849 r = bLPtr2IdxUTF8(b, sizeof(b), null); 10850 ck_assert_int_eq(r, -1); 10851 // pos outside buffer 10852 r = bLPtr2IdxUTF8(b, 8, &b[10]); 10853 ck_assert_int_eq(r, -1); 10854 // pos before buffer start 10855 r = bLPtr2IdxUTF8(&b[1], 8, b); 10856 ck_assert_int_eq(r, -1); 10857 // size 0 buffer 10858 r = bLPtr2IdxUTF8(b, 0, b); 10859 ck_assert_int_eq(r, -1); 10860 r = bLPtr2IdxUTF8(null, sizeof(b), b); 10861 ck_assert_int_eq(r, -1); 10862 10863 10864 END_TEST 10865 10866 10867 START_TEST(bLPtr2NegIdxUTF8T) 10868 10869 char b[20] = init0Var; 10870 int64_t r; 10871 strcpy(b, "£sheepy"); 10872 10873 // negative index 10874 r = bLPtr2NegIdxUTF8(b, 9, &b[7]); 10875 ck_assert_int_eq(r, -1); 10876 r = bLPtr2NegIdxUTF8(b, 9, &b[6]); 10877 ck_assert_int_eq(r, -2); 10878 r = bLPtr2NegIdxUTF8(b, 9, b); 10879 ck_assert_int_eq(r, -7); 10880 // null pos 10881 r = bLPtr2NegIdxUTF8(b, sizeof(b), null); 10882 ck_assert_int_eq(r, 0); 10883 // pos outside buffer 10884 r = bLPtr2NegIdxUTF8(b, 9, &b[10]); 10885 ck_assert_int_eq(r, 0); 10886 // pos before buffer start 10887 r = bLPtr2NegIdxUTF8(&b[1], 9, b); 10888 ck_assert_int_eq(r, 0); 10889 // size 0 buffer 10890 r = bLPtr2NegIdxUTF8(b, 0, b); 10891 ck_assert_int_eq(r, 0); 10892 r = bLPtr2NegIdxUTF8(null, sizeof(b), b); 10893 ck_assert_int_eq(r, 0); 10894 10895 END_TEST 10896 10897 10898 START_TEST(makeValidUTF8T) 10899 10900 char b[20] = init0Var; 10901 char *r; 10902 strcpy(b, "£sheepy"); 10903 10904 // valid utf8, no change 10905 r = makeValidUTF8(b); 10906 ck_assert_str_eq(r, b); 10907 free(r); 10908 // invalid utf8 string 10909 r = makeValidUTF8(&b[1]); 10910 ck_assert_str_eq(r, "?sheepy"); 10911 free(r); 10912 // null string 10913 ck_assert_ptr_eq(makeValidUTF8(null), null); 10914 10915 10916 END_TEST 10917 10918 10919 START_TEST(bMakeValidUTF8T) 10920 10921 char b[20] = init0Var; 10922 char *r; 10923 strcpy(b, "£sheepy"); 10924 10925 // valid utf8, no change 10926 r = bMakeValidUTF8(b); 10927 ck_assert_str_eq(r, "£sheepy"); 10928 // invalid utf8 string 10929 r = bMakeValidUTF8(&b[1]); 10930 ck_assert_str_eq(r, "?sheepy"); 10931 // null string 10932 ck_assert_ptr_eq(bMakeValidUTF8(null), null); 10933 10934 10935 END_TEST 10936 10937 10938 START_TEST(nMakeValidUTF8T) 10939 10940 char b[20] = init0Var; 10941 char *r; 10942 strcpy(b, "£sheepy"); 10943 10944 // valid utf8, no change 10945 r = nMakeValidUTF8(b, 4); 10946 ck_assert_str_eq(r, "£sh"); 10947 free(r); 10948 // invalid utf8 string 10949 r = nMakeValidUTF8(&b[1], 4); 10950 ck_assert_str_eq(r, "?she"); 10951 free(r); 10952 // len 0 10953 ck_assert_ptr_eq(nMakeValidUTF8(b, 0), null); 10954 // null string 10955 ck_assert_ptr_eq(nMakeValidUTF8(null, 1), null); 10956 10957 10958 END_TEST 10959 10960 10961 START_TEST(bNMakeValidUTF8T) 10962 10963 char b[20] = init0Var; 10964 char s[20] = init0Var; 10965 char *r; 10966 10967 // valid utf8, no change 10968 strcpy(b, "£sheepy"); 10969 r = bNMakeValidUTF8(s, b, 4); 10970 ck_assert_str_eq(r, "£sh"); 10971 // invalid utf8 string 10972 strcpy(b, "£sheepy"); 10973 r = bNMakeValidUTF8(s, &b[1], 4); 10974 ck_assert_str_eq(r, "?she"); 10975 // len 0 10976 ck_assert_ptr_eq(bNMakeValidUTF8(s, b, 0), null); 10977 // null string 10978 ck_assert_ptr_eq(bNMakeValidUTF8(s, null, 1), null); 10979 // null dest 10980 ck_assert_ptr_eq(bNMakeValidUTF8(null, b, 1), null); 10981 10982 10983 END_TEST 10984 10985 10986 START_TEST(bLMakeValidUTF8T) 10987 10988 char b[20] = init0Var; 10989 char s[20] = init0Var; 10990 char *r; 10991 10992 // valid utf8, no change 10993 strcpy(b, "£sheepy"); 10994 r = bLMakeValidUTF8(s, 5, b); 10995 ck_assert_str_eq(r, "£sh"); 10996 // invalid utf8 string 10997 strcpy(b, "£sheepy"); 10998 r = bLMakeValidUTF8(s, 5, &b[1]); 10999 ck_assert_str_eq(r, "?she"); 11000 // len 0 11001 ck_assert_ptr_eq(bLMakeValidUTF8(s, 0, b), null); 11002 // null string 11003 ck_assert_ptr_eq(bLMakeValidUTF8(s, 1, null), null); 11004 // null dest 11005 ck_assert_ptr_eq(bLMakeValidUTF8(null, 1, b), null); 11006 11007 11008 END_TEST 11009 11010 11011 START_TEST(bLNMakeValidUTF8T) 11012 11013 char b[20] = init0Var; 11014 char s[20] = init0Var; 11015 char *r; 11016 11017 // valid utf8, no change 11018 strcpy(b, "£sheepy"); 11019 r = bLNMakeValidUTF8(s, 5, b, 4); 11020 ck_assert_str_eq(r, "£sh"); 11021 r = bLNMakeValidUTF8(s, 5, b, 3); 11022 ck_assert_str_eq(r, "£s"); 11023 r = bLNMakeValidUTF8(s, 5, b, 6); 11024 ck_assert_str_eq(r, "£sh"); 11025 // invalid utf8 string 11026 strcpy(b, "£sheepy"); 11027 r = bLNMakeValidUTF8(s, 5, &b[1],4); 11028 ck_assert_str_eq(r, "?she"); 11029 // len 0 11030 ck_assert_ptr_eq(bLNMakeValidUTF8(s, 0, b, 1), null); 11031 ck_assert_ptr_eq(bLNMakeValidUTF8(s, 2, b, 0), null); 11032 // null string 11033 ck_assert_ptr_eq(bLNMakeValidUTF8(s, 1, null, 1), null); 11034 // null dest 11035 ck_assert_ptr_eq(bLNMakeValidUTF8(null, 1, b, 1), null); 11036 11037 11038 END_TEST 11039 11040 11041 START_TEST(strNCpyUTF8T) 11042 11043 char s[1024] = init0Var; 11044 char *r; 11045 11046 // copy string 11047 r = strNCpyUTF8(s, "lib", 4); 11048 ck_assert_ptr_ne(r, null); 11049 ck_assert_str_eq(s, "lib"); 11050 11051 // size 0 11052 r = strNCpyUTF8(s, "AAA", 0); 11053 ck_assert_ptr_ne(r, null); 11054 ck_assert_str_eq(s, "lib"); 11055 11056 // NULL 11057 s[0] = 0; 11058 r = strNCpyUTF8(s, NULL, 10); 11059 ck_assert_ptr_eq(r, null); 11060 ck_assert_str_eq(s, ""); 11061 ck_assert_ptr_eq(strNCpyUTF8(NULL, "lib", 1), NULL); 11062 11063 11064 END_TEST 11065 11066 11067 START_TEST(strLCpyUTF8T) 11068 11069 char s[1024]; 11070 char *r = null; 11071 11072 // copy string 11073 r = strLCpyUTF8(s, 100, "lib"); 11074 ck_assert_ptr_eq(r, s); 11075 ck_assert_str_eq(s, "lib"); 11076 // truncate src 11077 s[0] = 0; 11078 s[1] = 0; 11079 s[2] = 0; 11080 r = strLCpyUTF8(s, 3, "lib"); 11081 ck_assert_ptr_eq(r, s); 11082 ck_assert_str_eq(s, "li"); 11083 s[0] = 'a'; 11084 s[1] = 'a'; 11085 s[2] = 'a'; 11086 s[3] = 0; 11087 r = strLCpyUTF8(s, 3, "lib"); 11088 ck_assert_ptr_eq(r, s); 11089 ck_assert_str_eq(s, "li"); 11090 // size 0 - no change in s 11091 r = strLCpyUTF8(s, 0, "libsheepy"); 11092 ck_assert_ptr_eq(r, s); 11093 ck_assert_str_eq(s, "li"); 11094 // NULL 11095 s[0] = 0; 11096 r = strLCpyUTF8(s, 1, NULL); 11097 ck_assert_ptr_eq(r, null); 11098 ck_assert_str_eq(s, ""); 11099 r = strLCpyUTF8(NULL,1, "lib"); 11100 ck_assert_ptr_eq(r, null); 11101 11102 11103 END_TEST 11104 11105 11106 START_TEST(strNCatUTF8T) 11107 11108 char s[1024]; 11109 char *r = null; 11110 11111 // append string 11112 r = strCpy(s, "lib"); 11113 ck_assert_ptr_eq(r, s); 11114 r = strNCatUTF8(s, "sheepy", 100); 11115 ck_assert_ptr_eq(r, s); 11116 ck_assert_str_eq(s, "libsheepy"); 11117 // empty string2 11118 r = strNCatUTF8(s, "", 10); 11119 ck_assert_ptr_eq(r, s); 11120 ck_assert_str_eq(s, "libsheepy"); 11121 // truncate src 11122 s[0] = 'a'; 11123 s[1] = 'a'; 11124 s[2] = 'a'; 11125 s[3] = 'a'; 11126 s[4] = 'a'; 11127 s[5] = 'a'; 11128 r = strCpy(s, "lib"); 11129 ck_assert_ptr_eq(r, s); 11130 ck_assert_str_eq(s, "lib"); 11131 r = strNCatUTF8(s, "sheepy", 2); 11132 ck_assert_ptr_eq(r, s); 11133 ck_assert_str_eq(s, "libsh"); 11134 // length 0 11135 r = strNCatUTF8(s, "sheepy", 0); 11136 ck_assert_ptr_eq(r, s); 11137 ck_assert_str_eq(s, "libsh"); 11138 // NULL string2 11139 r = strNCatUTF8(s, NULL, 1); 11140 ck_assert_ptr_eq(r, null); 11141 ck_assert_str_eq(s, "libsh"); 11142 // NULL parameter 11143 r = strNCatUTF8(NULL, "ad", 1); 11144 ck_assert_ptr_eq(r, null); 11145 11146 11147 END_TEST 11148 11149 11150 START_TEST(strLCatUTF8T) 11151 11152 char s[1024]; 11153 char *r = null; 11154 11155 // append string 11156 r = strCpy(s, "lib"); 11157 ck_assert_ptr_eq(r, s); 11158 r = strLCatUTF8(s, 100, "sheepy"); 11159 ck_assert_ptr_eq(r, s); 11160 ck_assert_str_eq(s, "libsheepy"); 11161 // empty string2 11162 r = strLCatUTF8(s, 20, ""); 11163 ck_assert_ptr_eq(r, s); 11164 ck_assert_str_eq(s, "libsheepy"); 11165 // s strlen bigger than s size - keep s as it is 11166 r = strLCatUTF8(s, 6, "qwqwe"); 11167 ck_assert_ptr_eq(r, s); 11168 ck_assert_str_eq(s, "libsheepy"); 11169 // truncate src 11170 s[0] = 'a'; 11171 s[1] = 'a'; 11172 s[2] = 'a'; 11173 s[3] = 'a'; 11174 s[4] = 'a'; 11175 s[5] = 'a'; 11176 r = strCpy(s, "lib"); 11177 ck_assert_ptr_eq(r, s); 11178 ck_assert_str_eq(s, "lib"); 11179 r = strLNCat(s,100, "sheepy", 2); 11180 ck_assert_ptr_eq(r, s); 11181 ck_assert_str_eq(s, "libsh"); 11182 // truncate dst 11183 s[0] = 'a'; 11184 s[1] = 'a'; 11185 s[2] = 'a'; 11186 s[3] = 'a'; 11187 s[4] = 'a'; 11188 s[5] = 'a'; 11189 r = strCpy(s, "lib"); 11190 ck_assert_ptr_eq(r, s); 11191 ck_assert_str_eq(s, "lib"); 11192 r = strLCatUTF8(s, 6, "sheepy"); 11193 ck_assert_ptr_eq(r, s); 11194 ck_assert_str_eq(s, "libsh"); 11195 // NULL string2 11196 r = strLCatUTF8(s, 1, NULL); 11197 ck_assert_ptr_eq(r, null); 11198 ck_assert_str_eq(s, "libsh"); 11199 // NULL parameter 11200 r = strLCatUTF8(NULL, 1, "ad"); 11201 ck_assert_ptr_eq(r, null); 11202 11203 11204 END_TEST 11205 11206 11207 START_TEST(strLNCatUTF8T) 11208 11209 char s[1024]; 11210 char *r = null; 11211 11212 // append string 11213 r = strCpy(s, "lib"); 11214 ck_assert_ptr_eq(r, s); 11215 r = strLNCatUTF8(s, 100, "sheepy", 100); 11216 ck_assert_ptr_eq(r, s); 11217 ck_assert_str_eq(s, "libsheepy"); 11218 // empty string2 11219 r = strLNCatUTF8(s, 20, "", 10); 11220 ck_assert_ptr_eq(r, s); 11221 ck_assert_str_eq(s, "libsheepy"); 11222 // s strlen bigger than s size - keep s as it is 11223 r = strLNCatUTF8(s, 6, "qwqwe", 1); 11224 ck_assert_ptr_eq(r, s); 11225 ck_assert_str_eq(s, "libsheepy"); 11226 // truncate dst 11227 s[0] = 'a'; 11228 s[1] = 'a'; 11229 s[2] = 'a'; 11230 s[3] = 'a'; 11231 s[4] = 'a'; 11232 s[5] = 'a'; 11233 r = strCpy(s, "lib"); 11234 ck_assert_ptr_eq(r, s); 11235 ck_assert_str_eq(s, "lib"); 11236 r = strLNCatUTF8(s, 6, "sheepy", 4); 11237 ck_assert_ptr_eq(r, s); 11238 ck_assert_str_eq(s, "libsh"); 11239 // 0 source length 11240 r = strLNCatUTF8(s, 6, "sheepy", 0); 11241 ck_assert_ptr_eq(r, s); 11242 ck_assert_str_eq(s, "libsh"); 11243 // NULL string2 11244 r = strLNCatUTF8(s, 1, NULL, 1); 11245 ck_assert_ptr_eq(r, null); 11246 ck_assert_str_eq(s, "libsh"); 11247 // NULL parameter 11248 r = strLNCatUTF8(NULL, 1, "ad", 1); 11249 ck_assert_ptr_eq(r, null); 11250 11251 11252 END_TEST 11253 11254 11255 START_TEST(eqIUTF8T) 11256 11257 // identical strings 11258 ck_assert(eqIUTF8("Ashee|", "shee", 1)); 11259 ck_assert(eqIUTF8("Ashee", "shee", -4)); 11260 // string at index shorter than string2 11261 ck_assert(!eqIUTF8("Ashee", "shee", 2)); 11262 // empty string 11263 ck_assert(!eqIUTF8("", "shee", 0)); 11264 ck_assert(!eqIUTF8("Ashee", "", 0)); 11265 ck_assert(eqIUTF8("", "", 0)); 11266 // index mismatch 11267 ck_assert(!eqIUTF8("Ashee", "shee", 0)); 11268 // index outside 11269 ck_assert(!eqIUTF8("Ashee", "shee", 10)); 11270 ck_assert(!eqIUTF8("Ashee", "shee", -10)); 11271 // different strings 11272 ck_assert(!eqIUTF8("shee", "SH",0)); 11273 // NULL string 11274 ck_assert(!eqIUTF8(NULL,"a", 0)); 11275 ck_assert(!eqIUTF8("a", NULL, 0)); 11276 11277 11278 END_TEST 11279 11280 11281 START_TEST(eqICharUTF8T) 11282 11283 // identical strings 11284 ck_assert(eqICharUTF8("Ashee", 's', 1)); 11285 ck_assert(eqICharUTF8("Ashee", 's', -4)); 11286 // string at index shorter than string2 11287 ck_assert(!eqICharUTF8("Ashee", 's', 2)); 11288 // empty string 11289 ck_assert(!eqICharUTF8("", 's', 0)); 11290 ck_assert(!eqICharUTF8("Ashee", 0, 0)); 11291 ck_assert(eqICharUTF8("", 0, 0)); 11292 // index mismatch 11293 ck_assert(!eqICharUTF8("Ashee", 's', 0)); 11294 // index outside 11295 ck_assert(!eqICharUTF8("Ashee", 's', 10)); 11296 ck_assert(!eqICharUTF8("Ashee", 's', -10)); 11297 // different strings 11298 ck_assert(!eqICharUTF8("shee", 'S',0)); 11299 // NULL string 11300 ck_assert(!eqICharUTF8(NULL,'a', 0)); 11301 ck_assert(!eqICharUTF8("a", 0, 0)); 11302 11303 11304 END_TEST 11305 11306 11307 START_TEST(icEqUTF8T) 11308 11309 // identical strings 11310 ck_assert(icEqUTF8("SHEE", "shee")); 11311 // different strings 11312 ck_assert(!icEqUTF8("shee", "SH")); 11313 // empty strings 11314 ck_assert(!icEqUTF8("shee", "")); 11315 ck_assert(!icEqUTF8("", "SH")); 11316 ck_assert(icEqUTF8("", "")); 11317 // NULL string 11318 ck_assert(!icEqUTF8(NULL,"a")); 11319 ck_assert(!icEqUTF8("a", NULL)); 11320 11321 11322 END_TEST 11323 11324 11325 START_TEST(icEqCharUTF8T) 11326 11327 // identical strings 11328 ck_assert(icEqCharUTF8('S', "s")); 11329 // different strings 11330 ck_assert(!icEqCharUTF8('s', "SH")); 11331 // empty strings 11332 ck_assert(!icEqCharUTF8('s', "")); 11333 ck_assert(!icEqCharUTF8(0, "SH")); 11334 ck_assert(icEqCharUTF8(0, "")); 11335 // NULL string 11336 ck_assert(!icEqCharUTF8(0,"a")); 11337 ck_assert(!icEqCharUTF8('a', NULL)); 11338 11339 11340 END_TEST 11341 11342 11343 START_TEST(icEqUTF8CharT) 11344 11345 // identical strings 11346 ck_assert(icEqUTF8Char("S", 's')); 11347 // different strings 11348 ck_assert(!icEqUTF8Char("shee", 'S')); 11349 // empty strings 11350 ck_assert(!icEqUTF8Char("shee", 0)); 11351 ck_assert(!icEqUTF8Char("", 'S')); 11352 ck_assert(icEqUTF8Char("", 0)); 11353 // NULL string 11354 ck_assert(!icEqUTF8Char(NULL,'a')); 11355 ck_assert(!icEqUTF8Char("a", 0)); 11356 11357 11358 END_TEST 11359 11360 11361 START_TEST(icStartsWithUTF8T) 11362 11363 // identical strings 11364 ck_assert(icStartsWithUTF8("SHEE", "shee")); 11365 ck_assert(icStartsWithUTF8("SHEEPY", "shee")); 11366 // different strings 11367 ck_assert(!icStartsWithUTF8("shee", "aH")); 11368 ck_assert(!icStartsWithUTF8("shee", "sheep")); 11369 ck_assert(!icStartsWithUTF8("-shee", "shee")); 11370 // NULL string 11371 ck_assert(!icStartsWithUTF8(NULL,"a")); 11372 ck_assert(!icStartsWithUTF8("a", NULL)); 11373 11374 11375 END_TEST 11376 11377 11378 START_TEST(icEndsWithUTF8T) 11379 11380 // identical strings 11381 ck_assert(icEndsWithUTF8("SHEE", "shee")); 11382 ck_assert(icEndsWithUTF8("SHEEPY", "eepy")); 11383 // different strings 11384 ck_assert(!icEndsWithUTF8("shee", "SH")); 11385 ck_assert(!icEndsWithUTF8("shee", "sheep")); 11386 ck_assert(!icEndsWithUTF8("shee-", "shee")); 11387 // NULL string 11388 ck_assert(!icEndsWithUTF8(NULL,"a")); 11389 ck_assert(!icEndsWithUTF8("a", NULL)); 11390 11391 11392 END_TEST 11393 11394 11395 START_TEST(icCountUTF8T) 11396 11397 // positive count 11398 ck_assert_int_eq(icCountUTF8("SHEE", "shee"), 1); 11399 ck_assert_int_eq(icCountUTF8("AAA AAA", "a"), 6); 11400 ck_assert_int_eq(icCountUTF8("AAA AAA", "aa"), 2); 11401 // 0 count 11402 ck_assert_int_eq(icCountUTF8("shee", "eSH"), 0); 11403 ck_assert_int_eq(icCountUTF8("shee", "sheepy"), 0); 11404 ck_assert_int_eq(icCountUTF8("aaa aaa", "ab"), 0); 11405 // NULL string 11406 ck_assert_int_eq(icCountUTF8(NULL,"a"), -1); 11407 ck_assert_int_eq(icCountUTF8("a", NULL), -1); 11408 11409 11410 END_TEST 11411 11412 11413 START_TEST(code2RuneUTF8T) 11414 11415 u32 r; 11416 11417 r = code2RuneUTF8("£"); 11418 ck_assert_int_eq(r, 163); 11419 11420 END_TEST 11421 11422 11423 START_TEST(code2RuneLUTF8T) 11424 11425 u8 n; 11426 u32 r; 11427 11428 r = code2RuneLUTF8("£", &n); 11429 ck_assert_int_eq(r, 163); 11430 ck_assert_int_eq(n, 2); 11431 // empty string 11432 r = code2RuneLUTF8("", &n); 11433 ck_assert_int_eq(r, 0); 11434 // null length 11435 r = code2RuneLUTF8("£", null); 11436 ck_assert_int_eq(r, 0); 11437 // null string 11438 r = code2RuneLUTF8(null, &n); 11439 ck_assert_int_eq(r, 0); 11440 11441 11442 END_TEST 11443 11444 11445 START_TEST(bRune2CodeUTF8T) 11446 11447 u8 n; 11448 char r[20] = init0Var; 11449 11450 // pound 11451 n = bRune2CodeUTF8(r, 163); 11452 ck_assert_str_eq(r, "£"); 11453 ck_assert_int_eq(n, 2); 11454 11455 // null dst 11456 n = 0; 11457 n = bRune2CodeUTF8(null, 163); 11458 ck_assert_int_eq(n, 2); 11459 11460 END_TEST 11461 11462 11463 START_TEST(runeLenUTF8T) 11464 11465 u8 r; 11466 11467 r = runeLenUTF8(163); 11468 ck_assert_int_eq(r, 2); 11469 11470 11471 END_TEST 11472 11473 11474 START_TEST(toupperUTF8T) 11475 11476 rune r; 11477 char dst[20] = init0Var; 11478 11479 r = toupperUTF8(163); 11480 ck_assert_int_eq(r, 163); 11481 11482 r = code2RuneUTF8("å"); 11483 r = toupperUTF8(r); 11484 u8 r2 = bRune2CodeUTF8(dst,r); 11485 ck_assert_str_eq(dst, "Å"); 11486 ck_assert_int_eq(r2, 2); 11487 11488 END_TEST 11489 11490 11491 START_TEST(upperUTF8T) 11492 11493 // string 11494 char *s = upperUTF8("sheepyå"); 11495 ck_assert_str_eq(s, "SHEEPYÅ"); 11496 free(s); 11497 // NULL string 11498 ck_assert_ptr_eq(upperUTF8(NULL), NULL); 11499 11500 11501 END_TEST 11502 11503 11504 START_TEST(iUpperUTF8T) 11505 11506 char *s; 11507 char *r = null; 11508 11509 // string 11510 s = strdup("sheepy"); 11511 r = iUpperUTF8(&s); 11512 ck_assert_ptr_eq(r, s); 11513 ck_assert_str_eq(s, "SHEEPY"); 11514 free(s); 11515 // NULL string 11516 s = NULL; 11517 r = iUpperUTF8(&s); 11518 ck_assert_ptr_eq(r, s); 11519 ck_assert_ptr_eq(s, NULL); 11520 // NULL var 11521 r = iUpperUTF8(NULL); 11522 ck_assert_ptr_eq(r, null); 11523 11524 11525 END_TEST 11526 11527 11528 START_TEST(tolowerUTF8T) 11529 11530 rune r; 11531 char dst[20] = init0Var; 11532 11533 r = tolowerUTF8(163); 11534 ck_assert_int_eq(r, 163); 11535 11536 r = code2RuneUTF8("Å"); 11537 r = tolowerUTF8(r); 11538 u8 r2 = bRune2CodeUTF8(dst,r); 11539 ck_assert_str_eq(dst, "å"); 11540 ck_assert_int_eq(r2, 2); 11541 11542 11543 END_TEST 11544 11545 11546 START_TEST(lowerUTF8T) 11547 11548 // string 11549 char *s = lowerUTF8("SHeePY"); 11550 ck_assert_str_eq(s, "sheepy"); 11551 free(s); 11552 // NULL string 11553 ck_assert_ptr_eq(lowerUTF8(NULL), NULL); 11554 11555 11556 END_TEST 11557 11558 11559 START_TEST(iLowerUTF8T) 11560 11561 char *s; 11562 char *r = null; 11563 11564 // string 11565 s = strdup("SHEEPY"); 11566 r = iLowerUTF8(&s); 11567 ck_assert_ptr_eq(r, s); 11568 ck_assert_str_eq(s, "sheepy"); 11569 free(s); 11570 // NULL string 11571 s = NULL; 11572 r = iLowerUTF8(&s); 11573 ck_assert_ptr_eq(r, s); 11574 ck_assert_ptr_eq(s, NULL); 11575 // NULL var 11576 r = iLowerUTF8(NULL); 11577 ck_assert_ptr_eq(r, null); 11578 11579 11580 END_TEST 11581 11582 11583 START_TEST(uniqUTF8T) 11584 11585 char *s; 11586 11587 // uniquify 11588 s = uniqUTF8("∑qwd∑∑∑", "∑"); 11589 ck_assert_str_eq(s, "∑qwd∑"); 11590 free(s); 11591 // short string 11592 s = uniqUTF8("?", "/"); 11593 ck_assert_str_eq(s, "?"); 11594 free(s); 11595 // NULL 11596 ck_assert_ptr_eq(uniqUTF8(NULL, "/"), NULL); 11597 ck_assert_ptr_eq(uniqUTF8("sd", null), NULL); 11598 11599 11600 END_TEST 11601 11602 11603 START_TEST(iUniqUTF8T) 11604 11605 char *s; 11606 11607 // uniquify 11608 s = strdup("/qwd///"); 11609 ck_assert_str_eq(iUniqUTF8(&s, "/"), "/qwd/"); 11610 free(s); 11611 // short string 11612 s = strdup("?"); 11613 ck_assert_str_eq(iUniqUTF8(&s, "/"), "?"); 11614 free(s); 11615 // NULL string 11616 ck_assert_ptr_eq(iUniqUTF8(&s, null), NULL); 11617 s = NULL; 11618 ck_assert_ptr_eq(iUniqUTF8(&s, "/"), NULL); 11619 // NULL 11620 ck_assert_ptr_eq(iUniqUTF8(NULL, "/"), NULL); 11621 11622 11623 END_TEST 11624 11625 11626 START_TEST(bUniqUTF8T) 11627 11628 char s[100]; 11629 11630 // uniquify 11631 strcpy(s, "/qwd///"); 11632 ck_assert_str_eq(bUniqUTF8(s, "/"), "/qwd/"); 11633 // short string 11634 strcpy(s, "?"); 11635 ck_assert_str_eq(bUniqUTF8(s, "/"), "?"); 11636 // NULL 11637 ck_assert_ptr_eq(bUniqUTF8(s, null), NULL); 11638 ck_assert_ptr_eq(bUniqUTF8(NULL, "/"), NULL); 11639 11640 11641 END_TEST 11642 11643 11644 START_TEST(getUTF8T) 11645 11646 // get char 11647 ck_assert_uint_eq(getUTF8("sheepy", 0), 's'); 11648 // negative index 11649 ck_assert_uint_eq(getUTF8("sheepy", -1), 'y'); 11650 // outside string 11651 ck_assert_uint_eq(getUTF8("sheepy", 10), 0); 11652 ck_assert_uint_eq(getUTF8("sheepy", -10), 0); 11653 // negative index in a one char string 11654 ck_assert_uint_eq(getUTF8("z", -1), 'z'); 11655 // empty string 11656 ck_assert_uint_eq(getUTF8("", 0), 0); 11657 // NULL string 11658 ck_assert_uint_eq(getUTF8(NULL, 0), 0); 11659 11660 11661 END_TEST 11662 11663 11664 START_TEST(setUTF8T) 11665 11666 char *s; 11667 s = strdup("sheepy"); 11668 char *r = null; 11669 11670 // set char 11671 r = setUTF8(s, 0, 'S'); 11672 ck_assert_ptr_eq(r, s); 11673 ck_assert_uint_eq(s[0], 'S'); 11674 // negative index 11675 r = setUTF8(s, -2, 'P'); 11676 ck_assert_ptr_eq(r, s); 11677 ck_assert_uint_eq(s[4], 'P'); 11678 // outside string 11679 r = setUTF8(s, 20, 'Y'); 11680 ck_assert_ptr_eq(r, null); 11681 r = setUTF8(s, -20, 'Y'); 11682 ck_assert_ptr_eq(r, null); 11683 ck_assert_str_eq(s, "SheePy"); 11684 free(s); 11685 // negative index in a one char string 11686 s = strdup("s"); 11687 r = setUTF8(s, -1, 'S'); 11688 ck_assert_ptr_eq(r, s); 11689 ck_assert_uint_eq(s[0], 'S'); 11690 free(s); 11691 // empty string 11692 emptyS(s); 11693 r = setUTF8(s, -1, 'S'); 11694 ck_assert_ptr_eq(r, null); 11695 ck_assert_str_eq(s, ""); 11696 free(s); 11697 // NULL string 11698 r = setUTF8(NULL, 0, 's'); 11699 ck_assert_ptr_eq(r, null); 11700 11701 11702 END_TEST 11703 11704 11705 START_TEST(sliceUTF8T) 11706 11707 // slice 11708 char *s = sliceUTF8("sheepy", 0,2); 11709 ck_assert_str_eq(s, "sh"); 11710 free(s); 11711 // negative index 11712 s = sliceUTF8("sheepy", -2,0); 11713 ck_assert_str_eq(s, "py"); 11714 free(s); 11715 // positive and negative indexes 11716 s = sliceUTF8("sheepy", 2,-2); 11717 ck_assert_str_eq(s, "ee"); 11718 free(s); 11719 // start = end 11720 s = sliceUTF8("sheepy", 2,-4); 11721 ck_assert_str_eq(s, ""); 11722 free(s); 11723 // end of string 11724 s = sliceUTF8("sheepy", 2,6); 11725 ck_assert_str_eq(s, "eepy"); 11726 free(s); 11727 // NULL string 11728 ck_assert_ptr_eq(sliceUTF8(NULL, 2,-4), NULL); 11729 // start outside string 11730 ck_assert_ptr_eq(sliceUTF8("sheepy", 20,-4), NULL); 11731 // end outside string 11732 s = sliceUTF8("sheepy", 2,40); 11733 ck_assert_str_eq(s, "eepy"); 11734 free(s); 11735 s = sliceUTF8("sheepy", -22,3); 11736 ck_assert_str_eq(s, "she"); 11737 free(s); 11738 ck_assert_ptr_eq(sliceUTF8("sheepy", 2,-40), NULL); 11739 // end before start 11740 ck_assert_ptr_eq(sliceUTF8("sheepy", 4,2), NULL); 11741 11742 11743 END_TEST 11744 11745 11746 START_TEST(iSliceUTF8T) 11747 11748 char *s; 11749 char *r = null; 11750 11751 // slice 11752 s = strdup("sheepy"); 11753 r = iSliceUTF8(&s, 0,2); 11754 ck_assert_ptr_eq(r, s); 11755 ck_assert_str_eq(s, "sh"); 11756 free(s); 11757 // negative index 11758 s = strdup("sheepy"); 11759 r = iSliceUTF8(&s, -2,0); 11760 ck_assert_ptr_eq(r, s); 11761 ck_assert_str_eq(s, "py"); 11762 free(s); 11763 // positive and negative indexes 11764 s = strdup("sheepy"); 11765 r = iSliceUTF8(&s, 2,-2); 11766 ck_assert_ptr_eq(r, s); 11767 ck_assert_str_eq(s, "ee"); 11768 free(s); 11769 // start = end 11770 s = strdup("sheepy"); 11771 r = iSliceUTF8(&s, 2,-4); 11772 ck_assert_ptr_eq(r, s); 11773 ck_assert_str_eq(s, ""); 11774 free(s); 11775 // end of string 11776 s = strdup("sheepy"); 11777 r = iSliceUTF8(&s, 2,6); 11778 ck_assert_ptr_eq(r, s); 11779 ck_assert_str_eq(s, "eepy"); 11780 free(s); 11781 // NULL string 11782 s = NULL; 11783 r = iSliceUTF8(&s, 2,-4); 11784 ck_assert_ptr_eq(r, s); 11785 ck_assert_ptr_eq(s, NULL); 11786 // start outside string 11787 s = strdup("sheepy"); 11788 r = iSliceUTF8(&s, 20,-4); 11789 ck_assert_ptr_eq(r, null); 11790 ck_assert_str_eq(s, ""); 11791 free(s); 11792 // end outside string 11793 s = strdup("sheepy"); 11794 r = iSliceUTF8(&s, 2,40); 11795 ck_assert_ptr_eq(r, s); 11796 ck_assert_str_eq(s, "eepy"); 11797 free(s); 11798 s = strdup("sheepy"); 11799 r = iSliceUTF8(&s, -22,3); 11800 ck_assert_ptr_eq(r, s); 11801 ck_assert_str_eq(s, "she"); 11802 free(s); 11803 s = strdup("sheepy"); 11804 r = iSliceUTF8(&s, 2,-40); 11805 ck_assert_ptr_eq(r, null); 11806 ck_assert_str_eq(s, ""); 11807 free(s); 11808 // end before start 11809 s = strdup("sheepy"); 11810 r = iSliceUTF8(&s, 4,2); 11811 ck_assert_ptr_eq(r, null); 11812 ck_assert_str_eq(s, ""); 11813 free(s); 11814 // NULL var 11815 r = iSliceUTF8(NULL, 0, 0); 11816 ck_assert_ptr_eq(r, null); 11817 11818 11819 END_TEST 11820 11821 11822 START_TEST(bSliceUTF8T) 11823 11824 char s[100]; 11825 char *r = null; 11826 11827 // slice 11828 strcpy(s, "sheepy"); 11829 r = bSliceUTF8(s, 0,2); 11830 ck_assert_ptr_eq(r, s); 11831 ck_assert_str_eq(s, "sh"); 11832 // negative index 11833 strcpy(s, "sheepy"); 11834 r = bSliceUTF8(s, -2,0); 11835 ck_assert_ptr_eq(r, s); 11836 ck_assert_str_eq(s, "py"); 11837 // positive and negative indexes 11838 strcpy(s, "sheepy"); 11839 r = bSliceUTF8(s, 2,-2); 11840 ck_assert_ptr_eq(r, s); 11841 ck_assert_str_eq(s, "ee"); 11842 // start = end 11843 strcpy(s, "sheepy"); 11844 r = bSliceUTF8(s, 2,-4); 11845 ck_assert_ptr_eq(r, s); 11846 ck_assert_str_eq(s, ""); 11847 // end of string 11848 strcpy(s, "sheepy"); 11849 r = bSliceUTF8(s, 2,6); 11850 ck_assert_ptr_eq(r, s); 11851 ck_assert_str_eq(s, "eepy"); 11852 // start outside string 11853 strcpy(s, "sheepy"); 11854 r = bSliceUTF8(s, 20,-4); 11855 ck_assert_ptr_eq(r, null); 11856 ck_assert_str_eq(s, ""); 11857 // end outside string 11858 strcpy(s, "sheepy"); 11859 r = bSliceUTF8(s, 2,40); 11860 ck_assert_ptr_eq(r, s); 11861 ck_assert_str_eq(s, "eepy"); 11862 strcpy(s, "sheepy"); 11863 r = bSliceUTF8(s, -22,3); 11864 ck_assert_ptr_eq(r, s); 11865 ck_assert_str_eq(s, "she"); 11866 strcpy(s, "sheepy"); 11867 r = bSliceUTF8(s, 2,-40); 11868 ck_assert_ptr_eq(r, null); 11869 ck_assert_str_eq(s, ""); 11870 // end before start 11871 strcpy(s, "sheepy"); 11872 r = bSliceUTF8(s, 4,2); 11873 ck_assert_ptr_eq(r, null); 11874 ck_assert_str_eq(s, ""); 11875 // NULL var 11876 r = bSliceUTF8(NULL, 0, 0); 11877 ck_assert_ptr_eq(r, null); 11878 11879 11880 END_TEST 11881 11882 11883 START_TEST(bLSliceUTF8T) 11884 11885 char s[100]; 11886 char *r = null; 11887 11888 // slice 11889 strcpy(s, "sheepy"); 11890 r = bLSliceUTF8(s, sizeof(s), 0,2); 11891 ck_assert_ptr_eq(r, s); 11892 ck_assert_str_eq(s, "sh"); 11893 // buffer shorter than string 11894 strcpy(s, "sheepy"); 11895 r = bLSliceUTF8(s, 5, 0,2); 11896 ck_assert_ptr_eq(r, s); 11897 ck_assert_str_eq(s, "sh"); 11898 // negative index 11899 strcpy(s, "sheepy"); 11900 r = bLSliceUTF8(s, sizeof(s), -2,0); 11901 ck_assert_ptr_eq(r, s); 11902 ck_assert_str_eq(s, "py"); 11903 // positive and negative indexes 11904 strcpy(s, "sheepy"); 11905 r = bLSliceUTF8(s, sizeof(s), 2,-2); 11906 ck_assert_ptr_eq(r, s); 11907 ck_assert_str_eq(s, "ee"); 11908 // start = end 11909 strcpy(s, "sheepy"); 11910 r = bLSliceUTF8(s, sizeof(s), 2,-4); 11911 ck_assert_ptr_eq(r, s); 11912 ck_assert_str_eq(s, ""); 11913 // end of string 11914 strcpy(s, "sheepy"); 11915 r = bLSliceUTF8(s, sizeof(s), 2,6); 11916 ck_assert_ptr_eq(r, s); 11917 ck_assert_str_eq(s, "eepy"); 11918 // start outside string 11919 strcpy(s, "sheepy"); 11920 r = bLSliceUTF8(s, sizeof(s), 20,-4); 11921 ck_assert_ptr_eq(r, null); 11922 ck_assert_str_eq(s, ""); 11923 // end outside string 11924 strcpy(s, "sheepy"); 11925 r = bLSliceUTF8(s, sizeof(s), 2,40); 11926 ck_assert_ptr_eq(r, s); 11927 ck_assert_str_eq(s, "eepy"); 11928 strcpy(s, "sheepy"); 11929 r = bLSliceUTF8(s, sizeof(s), -22,3); 11930 ck_assert_ptr_eq(r, s); 11931 ck_assert_str_eq(s, "she"); 11932 strcpy(s, "sheepy"); 11933 r = bLSliceUTF8(s, sizeof(s), 2,-40); 11934 ck_assert_ptr_eq(r, null); 11935 ck_assert_str_eq(s, ""); 11936 // end before start 11937 strcpy(s, "sheepy"); 11938 r = bLSliceUTF8(s, sizeof(s), 4,2); 11939 ck_assert_ptr_eq(r, null); 11940 ck_assert_str_eq(s, ""); 11941 // size 0 11942 r = bLSliceUTF8(s, 0, 0, 0); 11943 ck_assert_ptr_eq(r, null); 11944 // NULL var 11945 r = bLSliceUTF8(NULL, sizeof(s), 0, 0); 11946 ck_assert_ptr_eq(r, null); 11947 11948 11949 END_TEST 11950 11951 11952 START_TEST(insertUTF8T) 11953 11954 char *s; 11955 11956 // insert 11957 s = insertUTF8("sheepy", 0, "lib"); 11958 ck_assert_str_eq(s, "libsheepy"); 11959 free(s); 11960 // negative index 11961 s = insertUTF8("libsheepy", -2, "P"); 11962 ck_assert_str_eq(s, "libsheepPy"); 11963 free(s); 11964 // edge 11965 s = insertUTF8("qwe", 3, "C"); 11966 ck_assert_str_eq(s, "qweC"); 11967 free(s); 11968 // outside string 11969 s = insertUTF8("qwe", 4, "C"); 11970 ck_assert_ptr_eq(s, NULL); 11971 s = insertUTF8("qwe", -5, "C"); 11972 ck_assert_ptr_eq(s, NULL); 11973 // negative index in a one char string 11974 s = insertUTF8("s", -1, "S"); 11975 ck_assert_str_eq(s, "sS"); 11976 free(s); 11977 // empty string 11978 s = insertUTF8("", 0, "s"); 11979 ck_assert_str_eq(s, "s"); 11980 free(s); 11981 s = insertUTF8("", -1, "s"); 11982 ck_assert_str_eq(s, "s"); 11983 free(s); 11984 // empty insert string 11985 s = insertUTF8("a", 0, ""); 11986 ck_assert_str_eq(s, "a"); 11987 free(s); 11988 // NULL insert string 11989 s = insertUTF8("a", 0, NULL); 11990 ck_assert_str_eq(s, "a"); 11991 free(s); 11992 // NULL string 11993 s = insertUTF8(NULL, 0, "s"); 11994 ck_assert_str_eq(s, "s"); 11995 free(s); 11996 11997 11998 END_TEST 11999 12000 12001 START_TEST(insertNFreeUTF8T) 12002 12003 char *s, *a; 12004 12005 // insert 12006 s = insertNFreeUTF8("sheepy", 0, strdup("lib")); 12007 ck_assert_str_eq(s, "libsheepy"); 12008 free(s); 12009 // negative index 12010 s = insertNFreeUTF8("libsheepy", -2, strdup("P")); 12011 ck_assert_str_eq(s, "libsheepPy"); 12012 free(s); 12013 // edge 12014 s = insertNFreeUTF8("qwe", 3, strdup("C")); 12015 ck_assert_str_eq(s, "qweC"); 12016 free(s); 12017 // outside string 12018 a = strdup("C"); 12019 s = insertNFreeUTF8("qwe", 4, a); 12020 ck_assert_ptr_eq(s, NULL); 12021 s = insertNFreeUTF8("qwe", -5, a); 12022 ck_assert_ptr_eq(s, NULL); 12023 free(a); 12024 // negative index in a one char string 12025 s = insertNFreeUTF8("s", -1, strdup("S")); 12026 ck_assert_str_eq(s, "sS"); 12027 free(s); 12028 // empty string 12029 s = insertNFreeUTF8("", 0, strdup("s")); 12030 ck_assert_str_eq(s, "s"); 12031 free(s); 12032 s = insertNFreeUTF8("", -1, strdup("s")); 12033 ck_assert_str_eq(s, "s"); 12034 free(s); 12035 // empty insert string 12036 s = insertNFreeUTF8("a", 0, strdup("")); 12037 ck_assert_str_eq(s, "a"); 12038 free(s); 12039 // NULL insert string 12040 s = insertNFreeUTF8("a", 0, NULL); 12041 ck_assert_str_eq(s, "a"); 12042 free(s); 12043 // NULL string 12044 s = insertNFreeUTF8(NULL, 0, strdup("s")); 12045 ck_assert_str_eq(s, "s"); 12046 free(s); 12047 12048 12049 END_TEST 12050 12051 12052 START_TEST(iInsertUTF8T) 12053 12054 char *s; 12055 char *r = null; 12056 12057 // insert 12058 s = strdup("sheepy"); 12059 r = iInsertUTF8(&s, 0, "lib"); 12060 ck_assert_ptr_eq(r, s); 12061 ck_assert_str_eq(s, "libsheepy"); 12062 free(s); 12063 // negative index 12064 s = strdup("libsheepy"); 12065 r = iInsertUTF8(&s, -2, "P"); 12066 ck_assert_ptr_eq(r, s); 12067 ck_assert_str_eq(s, "libsheepPy"); 12068 free(s); 12069 // edge 12070 s = strdup("qwe"); 12071 r = iInsertUTF8(&s, 3, "C"); 12072 ck_assert_ptr_eq(r, s); 12073 ck_assert_str_eq(s, "qweC"); 12074 free(s); 12075 // outside string 12076 s = strdup("qwe"); 12077 r = iInsertUTF8(&s, 4, "C"); 12078 ck_assert_ptr_eq(r, null); 12079 ck_assert_str_eq(s, "qwe"); 12080 r = iInsertUTF8(&s, -5, "C"); 12081 ck_assert_ptr_eq(r, null); 12082 ck_assert_str_eq(s, "qwe"); 12083 free(s); 12084 // negative index in a one char string 12085 s = strdup("s"); 12086 r = iInsertUTF8(&s, -1, "S"); 12087 ck_assert_ptr_eq(r, s); 12088 ck_assert_str_eq(s, "sS"); 12089 free(s); 12090 // empty string 12091 emptyS(s); 12092 r = iInsertUTF8(&s, 0, "s"); 12093 ck_assert_ptr_eq(r, s); 12094 ck_assert_str_eq(s, "s"); 12095 free(s); 12096 emptyS(s); 12097 r = iInsertUTF8(&s, -1, "s"); 12098 ck_assert_ptr_eq(r, s); 12099 ck_assert_str_eq(s, "s"); 12100 free(s); 12101 // empty insert string 12102 s = strdup("a"); 12103 r = iInsertUTF8(&s, 0, ""); 12104 ck_assert_ptr_eq(r, s); 12105 ck_assert_str_eq(s, "a"); 12106 free(s); 12107 // NULL insert string 12108 s = strdup("a"); 12109 r = iInsertUTF8(&s, 0, NULL); 12110 ck_assert_ptr_eq(r, s); 12111 ck_assert_str_eq(s, "a"); 12112 free(s); 12113 // NULL string 12114 s = NULL; 12115 r = iInsertUTF8(&s, 0, "s"); 12116 ck_assert_ptr_eq(r, s); 12117 ck_assert_str_eq(s, "s"); 12118 free(s); 12119 // NULL var 12120 r = iInsertUTF8(NULL, 0, "s"); 12121 ck_assert_ptr_eq(r, null); 12122 12123 12124 END_TEST 12125 12126 12127 START_TEST(iInsertNFreeUTF8T) 12128 12129 char *s, *a, *r; 12130 12131 // insert 12132 s = strdup("sheepy"); 12133 r = iInsertNFreeUTF8(&s, 0, strdup("lib")); 12134 ck_assert_ptr_eq(r, s); 12135 ck_assert_str_eq(s, "libsheepy"); 12136 free(s); 12137 // negative index 12138 s = strdup("libsheepy"); 12139 r = iInsertNFreeUTF8(&s, -2, strdup("P")); 12140 ck_assert_ptr_eq(r, s); 12141 ck_assert_str_eq(s, "libsheepPy"); 12142 free(s); 12143 // edge 12144 s = strdup("qwe"); 12145 r = iInsertNFreeUTF8(&s, 3, strdup("C")); 12146 ck_assert_ptr_eq(r, s); 12147 ck_assert_str_eq(s, "qweC"); 12148 free(s); 12149 // outside string 12150 s = strdup("qwe"); 12151 a = strdup("C"); 12152 r = iInsertNFreeUTF8(&s, 4, a); 12153 ck_assert_ptr_eq(r, NULL); 12154 ck_assert_str_eq(s, "qwe"); 12155 r = iInsertNFreeUTF8(&s, -5, a); 12156 ck_assert_ptr_eq(r, NULL); 12157 free(a); 12158 ck_assert_str_eq(s, "qwe"); 12159 free(s); 12160 // negative index in a one char string 12161 s = strdup("s"); 12162 r = iInsertNFreeUTF8(&s, -1, strdup("S")); 12163 ck_assert_ptr_eq(r, s); 12164 ck_assert_str_eq(s, "sS"); 12165 free(s); 12166 // empty string 12167 emptyS(s); 12168 r = iInsertNFreeUTF8(&s, 0, strdup("s")); 12169 ck_assert_ptr_eq(r, s); 12170 ck_assert_str_eq(s, "s"); 12171 free(s); 12172 emptyS(s); 12173 r = iInsertNFreeUTF8(&s, -1, strdup("s")); 12174 ck_assert_ptr_eq(r, s); 12175 ck_assert_str_eq(s, "s"); 12176 free(s); 12177 // empty insert string 12178 s = strdup("a"); 12179 r = iInsertNFreeUTF8(&s, 0, strdup("")); 12180 ck_assert_ptr_eq(r, s); 12181 ck_assert_str_eq(s, "a"); 12182 free(s); 12183 // NULL insert string 12184 s = strdup("a"); 12185 r = iInsertNFreeUTF8(&s, 0, NULL); 12186 ck_assert_ptr_eq(r, s); 12187 ck_assert_str_eq(s, "a"); 12188 free(s); 12189 // NULL string 12190 s = NULL; 12191 r = iInsertNFreeUTF8(&s, 0, strdup("s")); 12192 ck_assert_ptr_eq(r, s); 12193 ck_assert_str_eq(s, "s"); 12194 free(s); 12195 // NULL var 12196 s = strdup("s"); 12197 r = iInsertNFreeUTF8(NULL, 0, s); 12198 ck_assert_ptr_eq(r, NULL); 12199 free(s); 12200 12201 12202 END_TEST 12203 12204 12205 START_TEST(bInsertUTF8T) 12206 12207 char s[100]; 12208 char *r = null; 12209 12210 // insert 12211 strcpy(s, "sheepy"); 12212 r = bInsertUTF8(s, 0, "lib"); 12213 ck_assert_ptr_eq(r, s); 12214 ck_assert_str_eq(s, "libsheepy"); 12215 // negative index 12216 strcpy(s, "libsheepy"); 12217 r = bInsertUTF8(s, -2, "P"); 12218 ck_assert_ptr_eq(r, s); 12219 ck_assert_str_eq(s, "libsheepPy"); 12220 // edge 12221 strcpy(s, "qwe"); 12222 r = bInsertUTF8(s, 3, "C"); 12223 ck_assert_ptr_eq(r, s); 12224 ck_assert_str_eq(s, "qweC"); 12225 // outside string 12226 strcpy(s, "qwe"); 12227 r = bInsertUTF8(s, 4, "C"); 12228 ck_assert_ptr_eq(r, null); 12229 ck_assert_str_eq(s, "qwe"); 12230 r = bInsertUTF8(s, -5, "C"); 12231 ck_assert_ptr_eq(r, null); 12232 ck_assert_str_eq(s, "qwe"); 12233 // negative index in a one char string 12234 strcpy(s, "s"); 12235 r = bInsertUTF8(s, -1, "S"); 12236 ck_assert_ptr_eq(r, s); 12237 ck_assert_str_eq(s, "sS"); 12238 // empty string 12239 bEmptyS(s); 12240 r = bInsertUTF8(s, 0, "s"); 12241 ck_assert_ptr_eq(r, s); 12242 ck_assert_str_eq(s, "s"); 12243 bEmptyS(s); 12244 r = bInsertUTF8(s, -1, "s"); 12245 ck_assert_ptr_eq(r, s); 12246 ck_assert_str_eq(s, "s"); 12247 // empty insert string 12248 strcpy(s, "a"); 12249 r = bInsertUTF8(s, 0, ""); 12250 ck_assert_ptr_eq(r, s); 12251 ck_assert_str_eq(s, "a"); 12252 // NULL insert string 12253 strcpy(s, "a"); 12254 r = bInsertUTF8(s, 0, NULL); 12255 ck_assert_ptr_eq(r, s); 12256 ck_assert_str_eq(s, "a"); 12257 // NULL var 12258 r = bInsertUTF8(NULL, 0, "s"); 12259 ck_assert_ptr_eq(r, null); 12260 12261 12262 END_TEST 12263 12264 12265 START_TEST(bLInsertUTF8T) 12266 12267 char s[100]; 12268 char *r = null; 12269 12270 // insert 12271 strcpy(s, "sheepy"); 12272 r = bLInsertUTF8(s, sizeof s, 0, "lib"); 12273 ck_assert_ptr_eq(r, s); 12274 ck_assert_str_eq(s, "libsheepy"); 12275 // shorter buffer 12276 strcpy(s, "sheepy"); 12277 r = bLInsertUTF8(s, 5, 0, "lib"); 12278 ck_assert_ptr_eq(r, s); 12279 ck_assert_str_eq(s, "libs"); 12280 // negative index 12281 strcpy(s, "libsheepy"); 12282 r = bLInsertUTF8(s, sizeof s, -2, "P"); 12283 ck_assert_ptr_eq(r, s); 12284 ck_assert_str_eq(s, "libsheepPy"); 12285 // edge 12286 strcpy(s, "qwe"); 12287 r = bLInsertUTF8(s, sizeof s, 3, "C"); 12288 ck_assert_ptr_eq(r, s); 12289 ck_assert_str_eq(s, "qweC"); 12290 // outside string 12291 strcpy(s, "qwe"); 12292 r = bLInsertUTF8(s, sizeof s, 4, "C"); 12293 ck_assert_ptr_eq(r, null); 12294 ck_assert_str_eq(s, "qwe"); 12295 r = bLInsertUTF8(s, sizeof s, -5, "C"); 12296 ck_assert_ptr_eq(r, null); 12297 ck_assert_str_eq(s, "qwe"); 12298 // negative index in a one char string 12299 strcpy(s, "s"); 12300 r = bLInsertUTF8(s, sizeof s, -1, "S"); 12301 ck_assert_ptr_eq(r, s); 12302 ck_assert_str_eq(s, "sS"); 12303 // empty string 12304 bEmptyS(s); 12305 r = bLInsertUTF8(s, sizeof s, 0, "s"); 12306 ck_assert_ptr_eq(r, s); 12307 ck_assert_str_eq(s, "s"); 12308 bEmptyS(s); 12309 r = bLInsertUTF8(s, sizeof s, -1, "s"); 12310 ck_assert_ptr_eq(r, s); 12311 ck_assert_str_eq(s, "s"); 12312 // empty insert string 12313 strcpy(s, "a"); 12314 r = bLInsertUTF8(s, sizeof s, 0, ""); 12315 ck_assert_ptr_eq(r, s); 12316 ck_assert_str_eq(s, "a"); 12317 // size 0 - no change 12318 r = bLInsertUTF8(s, 0, 0, "qwe"); 12319 ck_assert_ptr_eq(r, s); 12320 ck_assert_str_eq(s, "a"); 12321 // NULL insert string 12322 strcpy(s, "a"); 12323 r = bLInsertUTF8(s, sizeof s, 0, NULL); 12324 ck_assert_ptr_eq(r, s); 12325 ck_assert_str_eq(s, "a"); 12326 // NULL var 12327 r = bLInsertUTF8(NULL, sizeof s, 0, "s"); 12328 ck_assert_ptr_eq(r, null); 12329 12330 12331 END_TEST 12332 12333 12334 START_TEST(delUTF8T) 12335 12336 // del 12337 char *s = delUTF8("sheepy", 0,2); 12338 ck_assert_str_eq(s, "eepy"); 12339 free(s); 12340 // negative index 12341 s = delUTF8("sheepy", -2,0); 12342 ck_assert_str_eq(s, "shee"); 12343 free(s); 12344 // positive and negative indexes 12345 s = delUTF8("sheepy", 2,-2); 12346 ck_assert_str_eq(s, "shpy"); 12347 free(s); 12348 // start = end 12349 s = delUTF8("sheepy", 2,-4); 12350 ck_assert_str_eq(s, "sheepy"); 12351 free(s); 12352 // delete entire string 12353 s = delUTF8("sheepy", 0,0); 12354 ck_assert_str_eq(s, ""); 12355 free(s); 12356 // end of string 12357 s = delUTF8("sheepy", 2,6); 12358 ck_assert_str_eq(s, "sh"); 12359 free(s); 12360 // NULL string 12361 ck_assert_ptr_eq(delUTF8(NULL, 2,-4), NULL); 12362 // start outside string 12363 ck_assert_ptr_eq(delUTF8("sheepy", 20,-4), NULL); 12364 s = delUTF8("sheepy", -20,-4); 12365 ck_assert_str_eq(s, "eepy"); 12366 free(s); 12367 // end outside string 12368 s = delUTF8("sheepy", 2,40); 12369 ck_assert_str_eq(s, "sh"); 12370 free(s); 12371 ck_assert_ptr_eq(delUTF8("sheepy", 2,-40), NULL); 12372 // end before start 12373 ck_assert_ptr_eq(delUTF8("sheepy", 4,2), NULL); 12374 12375 12376 END_TEST 12377 12378 12379 START_TEST(iDelUTF8T) 12380 12381 char *s; 12382 char *r = null; 12383 12384 // del 12385 s = strdup("sheepy"); 12386 r = iDelUTF8(&s, 0,2); 12387 ck_assert_ptr_eq(r, s); 12388 ck_assert_str_eq(s, "eepy"); 12389 free(s); 12390 // negative index 12391 s = strdup("sheepy"); 12392 r = iDelUTF8(&s, -2,0); 12393 ck_assert_ptr_eq(r, s); 12394 ck_assert_str_eq(s, "shee"); 12395 free(s); 12396 // positive and negative indexes 12397 s = strdup("sheepy"); 12398 r = iDelUTF8(&s, 2,-2); 12399 ck_assert_ptr_eq(r, s); 12400 ck_assert_str_eq(s, "shpy"); 12401 free(s); 12402 // start = end 12403 s = strdup("sheepy"); 12404 r = iDelUTF8(&s, 2,-4); 12405 ck_assert_ptr_eq(r, s); 12406 ck_assert_str_eq(s, "sheepy"); 12407 free(s); 12408 // delete entire string 12409 s = strdup("sheepy"); 12410 r = iDelUTF8(&s, 0,0); 12411 ck_assert_ptr_eq(r, s); 12412 ck_assert_str_eq(s, ""); 12413 free(s); 12414 // end of string 12415 s = strdup("sheepy"); 12416 r = iDelUTF8(&s, 2,6); 12417 ck_assert_ptr_eq(r, s); 12418 ck_assert_str_eq(s, "sh"); 12419 free(s); 12420 // NULL string 12421 s = NULL; 12422 r = iDelUTF8(&s, 2,-4); 12423 ck_assert_ptr_eq(r, s); 12424 ck_assert_ptr_eq(s, NULL); 12425 // start outside string 12426 s = strdup("sheepy"); 12427 r = iDelUTF8(&s, 20,-4); 12428 ck_assert_ptr_eq(r, null); 12429 ck_assert_str_eq(s, "sheepy"); 12430 r = iDelUTF8(&s, -20,-4); 12431 ck_assert_ptr_eq(r, s); 12432 ck_assert_str_eq(s, "eepy"); 12433 free(s); 12434 // end outside string 12435 s = strdup("sheepy"); 12436 r = iDelUTF8(&s, 2,40); 12437 ck_assert_ptr_eq(r, s); 12438 ck_assert_str_eq(s, "sh"); 12439 free(s); 12440 s = strdup("sheepy"); 12441 r = iDelUTF8(&s, 2,-40); 12442 ck_assert_ptr_eq(r, null); 12443 ck_assert_str_eq(s, "sheepy"); 12444 free(s); 12445 // end before start 12446 s = strdup("sheepy"); 12447 r = iDelUTF8(&s, 4,2); 12448 ck_assert_ptr_eq(r, null); 12449 ck_assert_str_eq(s, "sheepy"); 12450 free(s); 12451 // NULL var 12452 r = iDelUTF8(NULL, 4,2); 12453 ck_assert_ptr_eq(r, null); 12454 12455 12456 END_TEST 12457 12458 12459 START_TEST(bDelUTF8T) 12460 12461 char s[100]; 12462 char *r = null; 12463 12464 // del 12465 strcpy(s, "sheepy"); 12466 r = bDelUTF8(s, 0,2); 12467 ck_assert_ptr_eq(r, s); 12468 ck_assert_str_eq(s, "eepy"); 12469 // negative index 12470 strcpy(s, "sheepy"); 12471 r = bDelUTF8(s, -2,0); 12472 ck_assert_ptr_eq(r, s); 12473 ck_assert_str_eq(s, "shee"); 12474 // positive and negative indexes 12475 strcpy(s, "sheepy"); 12476 r = bDelUTF8(s, 2,-2); 12477 ck_assert_ptr_eq(r, s); 12478 ck_assert_str_eq(s, "shpy"); 12479 // start = end 12480 strcpy(s, "sheepy"); 12481 r = bDelUTF8(s, 2,-4); 12482 ck_assert_ptr_eq(r, s); 12483 ck_assert_str_eq(s, "sheepy"); 12484 // delete entire string 12485 strcpy(s, "sheepy"); 12486 r = bDelUTF8(s, 0,0); 12487 ck_assert_ptr_eq(r, s); 12488 ck_assert_str_eq(s, ""); 12489 // end of string 12490 strcpy(s, "sheepy"); 12491 r = bDelUTF8(s, 2,6); 12492 ck_assert_ptr_eq(r, s); 12493 ck_assert_str_eq(s, "sh"); 12494 // start outside string 12495 strcpy(s, "sheepy"); 12496 r = bDelUTF8(s, 20,-4); 12497 ck_assert_ptr_eq(r, null); 12498 ck_assert_str_eq(s, "sheepy"); 12499 r = bDelUTF8(s, -20,-4); 12500 ck_assert_ptr_eq(r, s); 12501 ck_assert_str_eq(s, "eepy"); 12502 // end outside string 12503 strcpy(s, "sheepy"); 12504 r = bDelUTF8(s, 2,40); 12505 ck_assert_ptr_eq(r, s); 12506 ck_assert_str_eq(s, "sh"); 12507 strcpy(s, "sheepy"); 12508 r = bDelUTF8(s, 2,-40); 12509 ck_assert_ptr_eq(r, null); 12510 ck_assert_str_eq(s, "sheepy"); 12511 // end before start 12512 strcpy(s, "sheepy"); 12513 r = bDelUTF8(s, 4,2); 12514 ck_assert_ptr_eq(r, null); 12515 ck_assert_str_eq(s, "sheepy"); 12516 // NULL var 12517 r = bDelUTF8(NULL, 4,2); 12518 ck_assert_ptr_eq(r, null); 12519 12520 12521 END_TEST 12522 12523 12524 START_TEST(bLDelUTF8T) 12525 12526 char s[100]; 12527 char *r = null; 12528 12529 // del 12530 strcpy(s, "sheepy"); 12531 r = bLDelUTF8(s, sizeof(s), 0,2); 12532 ck_assert_ptr_eq(r, s); 12533 ck_assert_str_eq(s, "eepy"); 12534 // buffer shorter than string 12535 strcpy(s, "sheepy"); 12536 r = bLDelUTF8(s, 5, 0,2); 12537 ck_assert_ptr_eq(r, s); 12538 ck_assert_str_eq(s, "ee"); 12539 // negative index 12540 strcpy(s, "sheepy"); 12541 r = bLDelUTF8(s, sizeof(s), -2,0); 12542 ck_assert_ptr_eq(r, s); 12543 ck_assert_str_eq(s, "shee"); 12544 // positive and negative indexes 12545 strcpy(s, "sheepy"); 12546 r = bLDelUTF8(s, sizeof(s), 2,-2); 12547 ck_assert_ptr_eq(r, s); 12548 ck_assert_str_eq(s, "shpy"); 12549 // start = end 12550 strcpy(s, "sheepy"); 12551 r = bLDelUTF8(s, sizeof(s), 2,-4); 12552 ck_assert_ptr_eq(r, s); 12553 ck_assert_str_eq(s, "sheepy"); 12554 // end of string 12555 strcpy(s, "sheepy"); 12556 r = bLDelUTF8(s, sizeof(s), 2,6); 12557 ck_assert_ptr_eq(r, s); 12558 ck_assert_str_eq(s, "sh"); 12559 // start outside string 12560 strcpy(s, "sheepy"); 12561 r = bLDelUTF8(s, sizeof(s), 20,-4); 12562 ck_assert_ptr_eq(r, null); 12563 ck_assert_str_eq(s, "sheepy"); 12564 // end outside string 12565 strcpy(s, "sheepy"); 12566 r = bLDelUTF8(s, sizeof(s), 2,40); 12567 ck_assert_ptr_eq(r, s); 12568 ck_assert_str_eq(s, "sh"); 12569 strcpy(s, "sheepy"); 12570 r = bLDelUTF8(s, sizeof(s), -22,3); 12571 ck_assert_ptr_eq(r, s); 12572 ck_assert_str_eq(s, "epy"); 12573 strcpy(s, "sheepy"); 12574 r = bLDelUTF8(s, sizeof(s), 2,-40); 12575 ck_assert_ptr_eq(r, null); 12576 ck_assert_str_eq(s, "sheepy"); 12577 // end before start 12578 strcpy(s, "sheepy"); 12579 r = bLDelUTF8(s, sizeof(s), 4,2); 12580 ck_assert_ptr_eq(r, null); 12581 ck_assert_str_eq(s, "sheepy"); 12582 // size 0 12583 r = bLDelUTF8(s, 0, 0, 0); 12584 ck_assert_ptr_eq(r, null); 12585 // NULL var 12586 r = bLDelUTF8(NULL, sizeof(s), 0, 0); 12587 ck_assert_ptr_eq(r, null); 12588 12589 12590 END_TEST 12591 12592 12593 START_TEST(indexOfUTF8T) 12594 12595 // indexOf string in the middle 12596 ck_assert_int_eq(indexOfUTF8("sheepy", "ee"), 2); 12597 // indexOf non existing string 12598 ck_assert_int_eq(indexOfUTF8("sheepy", "$"), -1); 12599 // indexOf NULL 12600 ck_assert_int_eq(indexOfUTF8("sheepy", NULL), -1); 12601 // NULL string 12602 ck_assert_int_eq(indexOfUTF8(NULL, "$"), -1); 12603 12604 12605 END_TEST 12606 12607 12608 START_TEST(icHasUTF8T) 12609 12610 // find string in the middle 12611 ck_assert(icHasUTF8("sheepy", "EE")); 12612 // find non existing string 12613 ck_assert(!icHasUTF8("sheepy", "$")); 12614 // find NULL 12615 ck_assert(!icHasUTF8("sheepy", NULL)); 12616 // NULL string 12617 ck_assert(!icHasUTF8(NULL, "$")); 12618 12619 12620 END_TEST 12621 12622 12623 START_TEST(icListSortUTF8T) 12624 12625 char **l = NULL; 12626 char **l2; 12627 char **r = null; 12628 12629 // list 12630 r = listPushS(&l, "1sdfdsf"); 12631 ck_assert_ptr_eq(r, l); 12632 r = listPushS(&l, "4444"); 12633 ck_assert_ptr_eq(r, l); 12634 r = listPushS(&l, "3"); 12635 ck_assert_ptr_eq(r, l); 12636 r = listPushS(&l, "22sdf"); 12637 ck_assert_ptr_eq(r, l); 12638 l2 = icListSortUTF8(l); 12639 ck_assert_str_eq(l2[0], "1sdfdsf"); 12640 ck_assert_str_eq(l2[3], "4444"); 12641 listFreeS(l); 12642 listFreeS(l2); 12643 // one element list 12644 l = NULL; 12645 r = listPushS(&l, "1sdfdsf"); 12646 ck_assert_ptr_eq(r, l); 12647 l2 = icListSortUTF8(l); 12648 ck_assert_uint_eq(listLengthS(l2),1); 12649 ck_assert_str_eq(l2[0], "1sdfdsf"); 12650 listFreeS(l); 12651 listFreeS(l2); 12652 // empty list 12653 listEmptyS(l2) 12654 l = icListSortUTF8(l2); 12655 ck_assert_uint_eq(listLengthS(l),0); 12656 ck_assert_ptr_eq(l[0], NULL); 12657 listFreeS(l); 12658 listFreeS(l2); 12659 // NULL list 12660 ck_assert_ptr_eq(icListSortUTF8(NULL), NULL); 12661 12662 12663 END_TEST 12664 12665 12666 START_TEST(iicListSortUTF8T) 12667 12668 char **l = NULL; 12669 char **r = null; 12670 12671 // list 12672 r = listPushS(&l, "1sdfdsf"); 12673 ck_assert_ptr_eq(r, l); 12674 r = listPushS(&l, "4444"); 12675 ck_assert_ptr_eq(r, l); 12676 r = listPushS(&l, "3"); 12677 ck_assert_ptr_eq(r, l); 12678 r = listPushS(&l, "22sdf"); 12679 ck_assert_ptr_eq(r, l); 12680 r = iicListSortUTF8(&l); 12681 ck_assert_ptr_eq(r, l); 12682 ck_assert_str_eq(l[0], "1sdfdsf"); 12683 ck_assert_str_eq(l[3], "4444"); 12684 listFreeS(l); 12685 // one element list 12686 l = NULL; 12687 r = listPushS(&l, "1sdfdsf"); 12688 ck_assert_ptr_eq(r, l); 12689 r = iicListSortUTF8(&l); 12690 ck_assert_ptr_eq(r, l); 12691 ck_assert_uint_eq(listLengthS(l),1); 12692 ck_assert_str_eq(l[0], "1sdfdsf"); 12693 listFreeS(l); 12694 // empty list 12695 listEmptyS(l) 12696 r = iicListSortUTF8(&l); 12697 ck_assert_ptr_eq(r, null); 12698 ck_assert_uint_eq(listLengthS(l),0); 12699 ck_assert_ptr_eq(l[0], NULL); 12700 listFreeS(l); 12701 // NULL list 12702 l = NULL; 12703 r = iicListSortUTF8(&l); 12704 ck_assert_ptr_eq(r, l); 12705 ck_assert_ptr_eq(l, NULL); 12706 // NULL var 12707 r = iicListSortUTF8(NULL); 12708 ck_assert_ptr_eq(r, null); 12709 12710 12711 END_TEST 12712 12713 12714 START_TEST(icListEqUTF8T) 12715 12716 char **l = NULL; 12717 char **l2; 12718 char **r = null; 12719 12720 // identical lists 12721 r = listPushS(&l, "1"); 12722 ck_assert_ptr_eq(r, l); 12723 r = listPushS(&l, "22"); 12724 ck_assert_ptr_eq(r, l); 12725 r = listPushS(&l, "333"); 12726 ck_assert_ptr_eq(r, l); 12727 r = listPushS(&l, "4444"); 12728 ck_assert_ptr_eq(r, l); 12729 l2 = listDupS(l); 12730 ck_assert(icListEqUTF8(l,l2)); 12731 // NULL lists 12732 ck_assert(!icListEqUTF8(NULL,l)); 12733 ck_assert(!icListEqUTF8(l,NULL)); 12734 ck_assert(!icListEqUTF8(NULL,NULL)); 12735 // different lists same number of elements 12736 l[3][0] = 'A'; 12737 ck_assert(!icListEqUTF8(l,l2)); 12738 // different number of elements 12739 char *s = listPopS(&l); 12740 free(s); 12741 ck_assert(!icListEqUTF8(l,l2)); 12742 listFreeS(l); 12743 listFreeS(l2); 12744 12745 12746 END_TEST 12747 12748 12749 START_TEST(icListHasUTF8T) 12750 12751 char **l = NULL; 12752 char **r = null; 12753 12754 // string 12755 r = listPushS(&l, "1"); 12756 ck_assert_ptr_eq(r, l); 12757 r = listPushS(&l, "22"); 12758 ck_assert_ptr_eq(r, l); 12759 r = listPushS(&l, "333"); 12760 ck_assert_ptr_eq(r, l); 12761 r = listPushS(&l, "4444"); 12762 ck_assert_ptr_eq(r, l); 12763 ck_assert(icListHasUTF8(l, "1")); 12764 // NULL list 12765 ck_assert(!icListHasUTF8(NULL, "1")); 12766 // NULL string 12767 ck_assert(!icListHasUTF8(l, NULL)); 12768 // non existing element 12769 ck_assert(!icListHasUTF8(l, "wfe")); 12770 // string in list 12771 ck_assert(icListHasUTF8(l, "333")); 12772 listFreeS(l); 12773 12774 12775 END_TEST 12776 12777 12778 START_TEST(icListIndexOfUTF8T) 12779 12780 char **l = NULL; 12781 char **r = null; 12782 12783 // string 12784 r = listPushS(&l, "1"); 12785 ck_assert_ptr_eq(r, l); 12786 r = listPushS(&l, "22"); 12787 ck_assert_ptr_eq(r, l); 12788 r = listPushS(&l, "333"); 12789 ck_assert_ptr_eq(r, l); 12790 r = listPushS(&l, "4444"); 12791 ck_assert_ptr_eq(r, l); 12792 ck_assert_uint_eq(icListIndexOfUTF8(l, "1"),0); 12793 // NULL list 12794 ck_assert_uint_eq(icListIndexOfUTF8(NULL, "1"),-1); 12795 // NULL string 12796 ck_assert_uint_eq(icListIndexOfUTF8(l, NULL),-1); 12797 // non existing element 12798 ck_assert_uint_eq(icListIndexOfUTF8(l, "wfe"),-1); 12799 // string in list 12800 ck_assert_uint_eq(icListIndexOfUTF8(l, "333"),2); 12801 listFreeS(l); 12802 12803 12804 END_TEST 12805 12806 12807 START_TEST(icListBinarySearchUTF8T) 12808 12809 char **l = NULL; 12810 char **r = null; 12811 12812 // string 12813 r = listPushS(&l, "1"); 12814 ck_assert_ptr_eq(r, l); 12815 r = listPushS(&l, "22"); 12816 ck_assert_ptr_eq(r, l); 12817 r = listPushS(&l, "333"); 12818 ck_assert_ptr_eq(r, l); 12819 r = listPushS(&l, "4444"); 12820 ck_assert_ptr_eq(r, l); 12821 r = listPushS(&l, "5"); 12822 ck_assert_ptr_eq(r, l); 12823 r = listPushS(&l, "6"); 12824 ck_assert_ptr_eq(r, l); 12825 ck_assert_uint_eq(icListBinarySearchUTF8(l, "1"),0); 12826 // NULL list 12827 ck_assert_uint_eq(icListBinarySearchUTF8(NULL, "1"),-1); 12828 // NULL string 12829 ck_assert_uint_eq(icListBinarySearchUTF8(l, NULL),-1); 12830 // non existing element 12831 ck_assert_uint_eq(icListBinarySearchUTF8(l, "wfe"),-1); 12832 // string in list 12833 ck_assert_uint_eq(icListBinarySearchUTF8(l, "333"),2); 12834 listFreeS(l); 12835 12836 12837 END_TEST 12838 12839 12840 START_TEST(icListUniqUTF8T) 12841 12842 char **l = NULL; 12843 char **l2; 12844 char **r = null; 12845 12846 // list with unique elements 12847 r = listPushS(&l, "1"); 12848 ck_assert_ptr_eq(r, l); 12849 r = listPushS(&l, "22"); 12850 ck_assert_ptr_eq(r, l); 12851 r = listPushS(&l, "333"); 12852 ck_assert_ptr_eq(r, l); 12853 r = listPushS(&l, "4444"); 12854 ck_assert_ptr_eq(r, l); 12855 l2 = icListUniqUTF8(l); 12856 ck_assert(listEqS(l,l2)); 12857 // list with identical elements 12858 l[2][0] = '2'; 12859 l[2][1] = '2'; 12860 l[2][2] = 0; 12861 listFreeS(l2); 12862 l2 = icListUniqUTF8(l); 12863 ck_assert_uint_eq(listLengthS(l2),3); 12864 ck_assert_str_eq(l2[2], "4444"); 12865 listFreeS(l); 12866 listFreeS(l2); 12867 // list with one element 12868 l = NULL; 12869 r = listPushS(&l, "1"); 12870 ck_assert_ptr_eq(r, l); 12871 l2 = icListUniqUTF8(l); 12872 ck_assert_uint_eq(listLengthS(l2),1); 12873 ck_assert_str_eq(l2[0], "1"); 12874 listFreeS(l); 12875 listFreeS(l2); 12876 // empty list 12877 listEmptyS(l) 12878 l2 = icListUniqUTF8(l); 12879 ck_assert_uint_eq(listLengthS(l2),0); 12880 ck_assert_ptr_eq(l2[0], NULL); 12881 listFreeS(l); 12882 listFreeS(l2); 12883 // NULL list 12884 ck_assert_ptr_eq(icListUniqUTF8(NULL), NULL); 12885 12886 12887 END_TEST 12888 12889 12890 START_TEST(iicListUniqUTF8T) 12891 12892 char **l = NULL; 12893 char **l2; 12894 char **r = null; 12895 12896 // list with unique elements 12897 r = listPushS(&l, "1"); 12898 ck_assert_ptr_eq(r, l); 12899 r = listPushS(&l, "22"); 12900 ck_assert_ptr_eq(r, l); 12901 r = listPushS(&l, "333"); 12902 ck_assert_ptr_eq(r, l); 12903 r = listPushS(&l, "4444"); 12904 ck_assert_ptr_eq(r, l); 12905 l2 = listDupS(l); 12906 r = iicListUniqUTF8(&l2); 12907 ck_assert_ptr_eq(r, l2); 12908 ck_assert(listEqS(l,l2)); 12909 // list with identical elements 12910 l[2][0] = '2'; 12911 l[2][1] = '2'; 12912 l[2][2] = 0; 12913 listFreeS(l2); 12914 l2 = listDupS(l); 12915 r = iicListUniqUTF8(&l2); 12916 ck_assert_ptr_eq(r, l2); 12917 ck_assert_uint_eq(listLengthS(l2),3); 12918 ck_assert_str_eq(l2[2], "4444"); 12919 listFreeS(l); 12920 listFreeS(l2); 12921 // list with one element 12922 l = NULL; 12923 r = listPushS(&l, "1"); 12924 ck_assert_ptr_eq(r, l); 12925 l2 = listDupS(l); 12926 r = iicListUniqUTF8(&l2); 12927 ck_assert_ptr_eq(r, l2); 12928 ck_assert_uint_eq(listLengthS(l2),1); 12929 ck_assert_str_eq(l2[0], "1"); 12930 listFreeS(l); 12931 listFreeS(l2); 12932 // empty list 12933 listEmptyS(l) 12934 l2 = listDupS(l); 12935 r = iicListUniqUTF8(&l2); 12936 ck_assert_ptr_eq(r, l2); 12937 ck_assert_uint_eq(listLengthS(l2),0); 12938 ck_assert_ptr_eq(l2[0], NULL); 12939 listFreeS(l); 12940 listFreeS(l2); 12941 // NULL list 12942 l = NULL; 12943 r = iicListUniqUTF8(&l); 12944 ck_assert_ptr_eq(r, l); 12945 ck_assert_ptr_eq(l, NULL); 12946 // NULL var 12947 r = iicListUniqUTF8(NULL); 12948 ck_assert_ptr_eq(r, null); 12949 12950 12951 END_TEST 12952 12953 12954 START_TEST(emptySFT) 12955 12956 char *s; 12957 12958 // empty string 12959 s = emptySF(); 12960 ck_assert(isEmptyS(s)); 12961 free(s); 12962 12963 END_TEST 12964 12965 12966 START_TEST(iEmptySFT) 12967 12968 char *s; 12969 char *r = null; 12970 12971 // empty string 12972 s = strdup("qwe"); 12973 r = iEmptySF(&s); 12974 ck_assert_ptr_eq(r, s); 12975 ck_assert(isEmptyS(s)); 12976 free(s); 12977 // NULL string 12978 s = NULL; 12979 r = iEmptySF(&s); 12980 ck_assert_ptr_eq(r, s); 12981 ck_assert(isEmptyS(s)); 12982 free(s); 12983 // NULL var 12984 r = iEmptySF(NULL); 12985 ck_assert_ptr_eq(r, null); 12986 12987 END_TEST 12988 12989 12990 START_TEST(isEmptyST) 12991 12992 char *s; 12993 12994 // non empty 12995 s = strdup("a"); 12996 ck_assert(!isEmptyS(s)); 12997 free(s); 12998 // empty 12999 emptyS(s) 13000 ck_assert(isEmptyS(s)); 13001 free(s); 13002 // NULL string 13003 ck_assert(isEmptyS(NULL)); 13004 13005 END_TEST 13006 13007 13008 START_TEST(isBlankST) 13009 13010 char *s; 13011 13012 // non empty 13013 s = strdup("a"); 13014 ck_assert(!isBlankS(s)); 13015 free(s); 13016 // white spaces 13017 ck_assert(isBlankS(" ")); 13018 // empty 13019 emptyS(s) 13020 ck_assert(isBlankS(s)); 13021 free(s); 13022 // NULL string 13023 ck_assert(isBlankS(NULL)); 13024 13025 END_TEST 13026 13027 13028 START_TEST(intIndexT) 13029 13030 ssize_t r; 13031 13032 // positive index 13033 r = intIndex(2,3); 13034 ck_assert_int_eq(r, 2); 13035 // negative index 13036 r = intIndex(-1,3); 13037 ck_assert_int_eq(r, 2); 13038 r = intIndex(-3,3); 13039 ck_assert_int_eq(r, 0); 13040 // outside length 13041 r = intIndex(3,3); 13042 ck_assert_int_eq(r, -1); 13043 r = intIndex(-4,3); 13044 ck_assert_int_eq(r, -1); 13045 // length 0 13046 r = intIndex(-1,0); 13047 ck_assert_int_eq(r, -1); 13048 13049 END_TEST 13050 13051 13052 START_TEST(listEmptySFT) 13053 13054 char **l; 13055 13056 // empty list 13057 l = listEmptySF(); 13058 ck_assert(listIsEmptyS(l)); 13059 listFreeS(l); 13060 13061 END_TEST 13062 13063 13064 START_TEST(iListEmptySFT) 13065 13066 char **l; 13067 char **r = null; 13068 13069 // empty list 13070 l = listCreateS("lib", "sheepy"); 13071 r = iListEmptySF(&l); 13072 ck_assert_ptr_eq(r, l); 13073 ck_assert(listIsEmptyS(l)); 13074 listFreeS(l); 13075 // NULL list 13076 l = NULL; 13077 r = iListEmptySF(&l); 13078 ck_assert_ptr_eq(r, l); 13079 ck_assert(listIsEmptyS(l)); 13080 listFreeS(l); 13081 // NULL var 13082 r = iListEmptySF(NULL); 13083 ck_assert_ptr_eq(r, null); 13084 13085 END_TEST 13086 13087 13088 START_TEST(listIsEmptyST) 13089 13090 char **l; 13091 13092 // non empty list 13093 l = listCreateS("sheepy", "SHEEPY", "sheepy"); 13094 // check ck_assert_ptr_null not available in jessie 13095 ck_assert_ptr_ne(l, NULL); 13096 ck_assert(!listIsEmptyS(l)); 13097 listFreeS(l); 13098 // empty list 13099 listEmptyS(l) 13100 ck_assert(listIsEmptyS(l)); 13101 listFreeS(l); 13102 ck_assert(listIsEmptyS(NULL)); 13103 13104 END_TEST 13105 13106 13107 START_TEST(listIsBlankST) 13108 13109 char **l; 13110 13111 // non empty list 13112 l = listCreateS("sheepy", "SHEEPY", "sheepy"); 13113 // check ck_assert_ptr_null not available in jessie 13114 ck_assert_ptr_ne(l, NULL); 13115 ck_assert(!listIsBlankS(l)); 13116 listFreeS(l); 13117 l = listCreateS("", " "); 13118 ck_assert(listIsBlankS(l)); 13119 listFreeS(l); 13120 // empty list 13121 listEmptyS(l) 13122 ck_assert(listIsBlankS(l)); 13123 listFreeS(l); 13124 ck_assert(listIsEmptyS(NULL)); 13125 13126 END_TEST 13127 13128 13129 START_TEST(listLengthST) 13130 13131 char **l; 13132 13133 // list length 13134 l = malloc(2 * sizeof(char *)); 13135 l[0] = (char *)1; 13136 l[1] = NULL; 13137 ck_assert_uint_eq(listLengthS(l),1); 13138 free(l); 13139 // empty list 13140 listEmptyS(l) 13141 ck_assert_uint_eq(listLengthS(l),0); 13142 free(l); 13143 // NULL list 13144 ck_assert_uint_eq(listLengthS(NULL),0); 13145 13146 13147 END_TEST 13148 13149 13150 START_TEST(listStrLengthST) 13151 13152 char **l = null; 13153 ssize_t r; 13154 char **r2 = null; 13155 13156 r2 = listPushS(&l, "lib"); 13157 ck_assert_ptr_eq(r2, l); 13158 r2 = listPushS(&l, "sheepy"); 13159 ck_assert_ptr_eq(r2, l); 13160 r = listStrLengthS(l); 13161 ck_assert_int_eq(r, 9); 13162 listFreeS(l); 13163 // null list 13164 r = listStrLengthS(null); 13165 ck_assert_int_eq(r, -1); 13166 13167 END_TEST 13168 13169 13170 START_TEST(listIntIndexST) 13171 13172 char **l = null; 13173 ssize_t r; 13174 char **r2 = null; 13175 13176 r2 = listPushS(&l, "lib"); 13177 ck_assert_ptr_eq(r2, l); 13178 r2 = listPushS(&l, "sheepy"); 13179 ck_assert_ptr_eq(r2, l); 13180 r2 = listPushS(&l, "sheepy"); 13181 ck_assert_ptr_eq(r2, l); 13182 // positive index 13183 r = listIntIndexS(l, 2); 13184 ck_assert_int_eq(r, 2); 13185 // negative index 13186 r = listIntIndexS(l, -1); 13187 ck_assert_int_eq(r, 2); 13188 r = listIntIndexS(l, -3); 13189 ck_assert_int_eq(r, 0); 13190 // outside length 13191 r = listIntIndexS(l, 3); 13192 ck_assert_int_eq(r, -1); 13193 r = listIntIndexS(l, -4); 13194 ck_assert_int_eq(r, -1); 13195 listFreeS(l); 13196 // length 0 13197 listEmptyS(l); 13198 r = listIntIndexS(l, -1); 13199 ck_assert_int_eq(r, -1); 13200 listFreeS(l); 13201 // null list 13202 ck_assert_int_eq(listIntIndexS(NULL, 1), -1); 13203 13204 END_TEST 13205 13206 13207 START_TEST(listAddrST) 13208 13209 char **l = null; 13210 char **r; 13211 13212 r = listPushS(&l, "lib"); 13213 ck_assert_ptr_eq(r, l); 13214 r = listPushS(&l, "sheepy"); 13215 ck_assert_ptr_eq(r, l); 13216 r = listPushS(&l, "sheepy"); 13217 ck_assert_ptr_eq(r, l); 13218 // positive index 13219 r = listAddrS(l, 2); 13220 ck_assert_ptr_eq(r, &l[2]); 13221 // negative index 13222 r = listAddrS(l, -1); 13223 ck_assert_ptr_eq(r, &l[2]); 13224 r = listAddrS(l, -3); 13225 ck_assert_ptr_eq(r, &l[0]); 13226 // outside length 13227 r = listAddrS(l, 3); 13228 ck_assert_ptr_eq(r, null); 13229 r = listAddrS(l, -4); 13230 ck_assert_ptr_eq(r, null); 13231 listFreeS(l); 13232 // length 0 13233 listEmptyS(l); 13234 r = listAddrS(l, -1); 13235 ck_assert_ptr_eq(r, null); 13236 listFreeS(l); 13237 // null list 13238 ck_assert_ptr_eq(listAddrS(NULL, 1), null); 13239 13240 13241 END_TEST 13242 13243 13244 START_TEST(listCreateST) 13245 13246 char **l; 13247 13248 // create list 13249 l = listCreateS("sheepy", "SHEEPY", "sheepy"); 13250 // check ck_assert_ptr_null not available in jessie 13251 ck_assert_ptr_ne(l, NULL); 13252 ck_assert_uint_eq(listLengthS(l),3); 13253 ck_assert_str_eq(l[0], "sheepy"); 13254 ck_assert_str_eq(l[1], "SHEEPY"); 13255 ck_assert_str_eq(l[2], "sheepy"); 13256 listFreeS(l); 13257 13258 // NULL first element 13259 ck_assert_ptr_eq(listCreateS(NULL, "sheepy"), NULL); 13260 13261 END_TEST 13262 13263 13264 START_TEST(listFromArrayST) 13265 13266 char **l = NULL; 13267 char *array[] = {"1", "22", "333"}; 13268 char *arrayNULL[] = {"1", NULL, "333"}; 13269 13270 // copy array to list 13271 l = listFromArrayS(array, 3); 13272 ck_assert_uint_eq(listLengthS(l),3); 13273 ck_assert_str_eq(l[0], "1"); 13274 ck_assert_str_eq(l[1], "22"); 13275 ck_assert_str_eq(l[2], "333"); 13276 listFreeS(l); 13277 // array with NULL inside 13278 l = listFromArrayS(arrayNULL, 3); 13279 ck_assert_uint_eq(listLengthS(l),2); 13280 ck_assert_str_eq(l[0], "1"); 13281 ck_assert_str_eq(l[1], "333"); 13282 listFreeS(l); 13283 // empty list 13284 l = listFromArrayS(array, 0); 13285 ck_assert(listIsEmptyS(l)); 13286 listFreeS(l); 13287 // NULL pointer to list 13288 ck_assert_ptr_eq(listFromArrayS(NULL, 1), NULL); 13289 13290 END_TEST 13291 13292 13293 START_TEST(listPushST) 13294 13295 char **l = NULL; 13296 char **r = null; 13297 13298 // push strings and NULL list 13299 r = listPushS(&l, "sheepy"); 13300 ck_assert_ptr_eq(r, l); 13301 // check ck_assert_ptr_null not available in jessie 13302 ck_assert_ptr_ne(l, NULL); 13303 ck_assert_str_eq(l[0], "sheepy"); 13304 r = listPushS(&l, "SHEEPY"); 13305 ck_assert_ptr_eq(r, l); 13306 ck_assert_str_eq(l[1], "SHEEPY"); 13307 ck_assert_str_eq(l[0], "sheepy"); 13308 // push NULL 13309 r = listPushS(&l, NULL); 13310 ck_assert_ptr_eq(r, null); 13311 ck_assert_ptr_eq(l[2], NULL); 13312 listFreeS(l); 13313 // NULL list and NULL string 13314 l = NULL; 13315 r = listPushS(&l, NULL); 13316 ck_assert_ptr_eq(r, null); 13317 ck_assert_ptr_eq(l, NULL); 13318 // empty list 13319 listEmptyS(l) 13320 r = listPushS(&l, "sheepy"); 13321 ck_assert_ptr_eq(r, l); 13322 ck_assert_str_eq(l[0], "sheepy"); 13323 ck_assert_ptr_eq(l[1], NULL); 13324 listFreeS(l); 13325 // NULL pointer to list 13326 r = listPushS(NULL, NULL); 13327 ck_assert_ptr_eq(r, null); 13328 13329 END_TEST 13330 13331 13332 START_TEST(listPushCharST) 13333 13334 char **l = NULL; 13335 char **r = null; 13336 13337 // push strings and NULL list 13338 r = listPushCharS(&l, 's'); 13339 ck_assert_ptr_eq(r, l); 13340 // check ck_assert_ptr_null not available in jessie 13341 ck_assert_ptr_ne(l, NULL); 13342 ck_assert_str_eq(l[0], "s"); 13343 r = listPushCharS(&l, 'S'); 13344 ck_assert_ptr_eq(r, l); 13345 ck_assert_str_eq(l[1], "S"); 13346 ck_assert_str_eq(l[0], "s"); 13347 listFreeS(l); 13348 // empty list 13349 listEmptyS(l) 13350 r = listPushCharS(&l, 's'); 13351 ck_assert_ptr_eq(r, l); 13352 ck_assert_str_eq(l[0], "s"); 13353 ck_assert_ptr_eq(l[1], NULL); 13354 listFreeS(l); 13355 // NULL pointer to list 13356 r = listPushCharS(NULL, 's'); 13357 ck_assert_ptr_eq(r, null); 13358 13359 13360 END_TEST 13361 13362 13363 START_TEST(iListPushST) 13364 13365 char **l = NULL; 13366 char *s; 13367 char **r = null; 13368 13369 // push strings and NULL list 13370 s = strdup("sheepy"); 13371 r = iListPushS(&l, s); 13372 ck_assert_ptr_eq(r, l); 13373 // check ck_assert_ptr_null not available in jessie 13374 ck_assert_ptr_ne(l, NULL); 13375 ck_assert_str_eq(l[0], "sheepy"); 13376 s = strdup("SHEEPY"); 13377 r = iListPushS(&l, s); 13378 ck_assert_ptr_eq(r, l); 13379 ck_assert_str_eq(l[0], "sheepy"); 13380 ck_assert_str_eq(l[1], "SHEEPY"); 13381 // push NULL 13382 r = iListPushS(&l, NULL); 13383 ck_assert_ptr_eq(r, null); 13384 ck_assert_ptr_eq(l[2], NULL); 13385 listFreeS(l); 13386 // NULL list and NULL string 13387 l = NULL; 13388 r = iListPushS(&l, NULL); 13389 ck_assert_ptr_eq(r, null); 13390 ck_assert_ptr_eq(l, NULL); 13391 // empty list 13392 listEmptyS(l) 13393 s = strdup("sheepy"); 13394 r = iListPushS(&l, s); 13395 ck_assert_ptr_eq(r, l); 13396 ck_assert_str_eq(l[0], "sheepy"); 13397 ck_assert_ptr_eq(l[1], NULL); 13398 listFreeS(l); 13399 // NULL pointer to list 13400 r = iListPushS(NULL, NULL); 13401 ck_assert_ptr_eq(r, null); 13402 13403 END_TEST 13404 13405 13406 START_TEST(listPopST) 13407 13408 char **l = NULL; 13409 char *s; 13410 char **r = null; 13411 13412 // pop string 13413 r = listPushS(&l, "sheepy"); 13414 ck_assert_ptr_eq(r, l); 13415 r = listPushS(&l, "SHEEPY"); 13416 ck_assert_ptr_eq(r, l); 13417 s = listPopS(&l); 13418 ck_assert_str_eq(s, "SHEEPY"); 13419 ck_assert_uint_eq(listLengthS(l),1); 13420 free(s); 13421 // last element 13422 s = listPopS(&l); 13423 ck_assert_str_eq(s, "sheepy"); 13424 free(s); 13425 ck_assert_uint_eq(listLengthS(l),0); 13426 // empty list 13427 ck_assert_ptr_eq(listPopS(&l), NULL); 13428 listFreeS(l); 13429 // NULL list 13430 l = NULL; 13431 ck_assert_ptr_eq(listPopS(&l), NULL); 13432 // NULL pointer to list 13433 ck_assert_ptr_eq(listPopS(NULL), NULL); 13434 13435 END_TEST 13436 13437 13438 START_TEST(listPrependST) 13439 13440 char **l = NULL; 13441 char **r = null; 13442 13443 // push strings and NULL list 13444 r = listPrependS(&l, "sheepy"); 13445 ck_assert_ptr_eq(r, l); 13446 // check ck_assert_ptr_null not available in jessie 13447 ck_assert_ptr_ne(l, NULL); 13448 ck_assert_str_eq(l[0], "sheepy"); 13449 r = listPrependS(&l, "SHEEPY"); 13450 ck_assert_ptr_eq(r, l); 13451 ck_assert_str_eq(l[0], "SHEEPY"); 13452 ck_assert_str_eq(l[1], "sheepy"); 13453 // push NULL 13454 r = listPrependS(&l, NULL); 13455 ck_assert_ptr_eq(r, null); 13456 ck_assert_str_eq(l[0], "SHEEPY"); 13457 listFreeS(l); 13458 // NULL list and NULL string` 13459 l = NULL; 13460 r = listPrependS(&l, NULL); 13461 ck_assert_ptr_eq(r, null); 13462 ck_assert_ptr_eq(l, NULL); 13463 // empty list 13464 listEmptyS(l) 13465 r = listPrependS(&l, "sheepy"); 13466 ck_assert_ptr_eq(r, l); 13467 ck_assert_str_eq(l[0], "sheepy"); 13468 ck_assert_ptr_eq(l[1], NULL); 13469 listFreeS(l); 13470 // NULL pointer to list 13471 r = listPrependS(NULL, NULL); 13472 ck_assert_ptr_eq(r, null); 13473 13474 END_TEST 13475 13476 13477 START_TEST(listPrependCharST) 13478 13479 char **l = NULL; 13480 char **r = null; 13481 13482 // push strings and NULL list 13483 r = listPrependCharS(&l, 's'); 13484 ck_assert_ptr_eq(r, l); 13485 // check ck_assert_ptr_null not available in jessie 13486 ck_assert_ptr_ne(l, NULL); 13487 ck_assert_str_eq(l[0], "s"); 13488 r = listPrependCharS(&l, 'S'); 13489 ck_assert_ptr_eq(r, l); 13490 ck_assert_str_eq(l[0], "S"); 13491 ck_assert_str_eq(l[1], "s"); 13492 listFreeS(l); 13493 // empty list 13494 listEmptyS(l) 13495 r = listPrependCharS(&l, 's'); 13496 ck_assert_ptr_eq(r, l); 13497 ck_assert_str_eq(l[0], "s"); 13498 ck_assert_ptr_eq(l[1], NULL); 13499 listFreeS(l); 13500 // NULL pointer to list 13501 r = listPrependCharS(NULL, 's'); 13502 ck_assert_ptr_eq(r, null); 13503 13504 13505 END_TEST 13506 13507 13508 START_TEST(iListPrependST) 13509 13510 char **l = NULL; 13511 char *s; 13512 char **r = null; 13513 13514 // prepend strings and NULL list 13515 s = strdup("sheepy"); 13516 r = iListPrependS(&l, s); 13517 ck_assert_ptr_eq(r, l); 13518 // check ck_assert_ptr_null not available in jessie 13519 ck_assert_ptr_ne(l, NULL); 13520 ck_assert_str_eq(l[0], "sheepy"); 13521 s = strdup("SHEEPY"); 13522 r = iListPrependS(&l, s); 13523 ck_assert_ptr_eq(r, l); 13524 ck_assert_str_eq(l[0], "SHEEPY"); 13525 ck_assert_str_eq(l[1], "sheepy"); 13526 // prepend NULL 13527 r = iListPrependS(&l, NULL); 13528 ck_assert_ptr_eq(r, null); 13529 ck_assert_str_eq(l[0], "SHEEPY"); 13530 listFreeS(l); 13531 // NULL list and NULL string 13532 l = NULL; 13533 r = iListPrependS(&l, NULL); 13534 ck_assert_ptr_eq(r, null); 13535 ck_assert_ptr_eq(l, NULL); 13536 // empty list 13537 listEmptyS(l) 13538 s = strdup("sheepy"); 13539 r = iListPrependS(&l, s); 13540 ck_assert_ptr_eq(r, l); 13541 ck_assert_str_eq(l[0], "sheepy"); 13542 ck_assert_ptr_eq(l[1], NULL); 13543 listFreeS(l); 13544 // NULL pointer to list 13545 r = iListPrependS(NULL, NULL); 13546 ck_assert_ptr_eq(r, null); 13547 13548 END_TEST 13549 13550 13551 START_TEST(listDequeueST) 13552 13553 char **l = NULL; 13554 char *s; 13555 char **r = null; 13556 13557 // dequeue string 13558 r = listPushS(&l, "sheepy"); 13559 ck_assert_ptr_eq(r, l); 13560 r = listPushS(&l, "SHEEPY"); 13561 ck_assert_ptr_eq(r, l); 13562 s = listDequeueS(&l); 13563 ck_assert_str_eq(s, "sheepy"); 13564 ck_assert_uint_eq(listLengthS(l),1); 13565 free(s); 13566 // last element 13567 s = listDequeueS(&l); 13568 ck_assert_str_eq(s, "SHEEPY"); 13569 free(s); 13570 ck_assert_uint_eq(listLengthS(l),0); 13571 // empty list 13572 ck_assert_ptr_eq(listDequeueS(&l), NULL); 13573 listFreeS(l); 13574 // NULL list 13575 l = NULL; 13576 ck_assert_ptr_eq(listDequeueS(&l), NULL); 13577 // NULL pointer to list 13578 ck_assert_ptr_eq(listDequeueS(NULL), NULL); 13579 13580 END_TEST 13581 13582 13583 START_TEST(listFreeST) 13584 13585 // not possible to know if a pointer is already freed 13586 char **l = listCreateS("we","sd"); 13587 listFreeS(l); 13588 // empty list 13589 listEmptyS(l); 13590 listFreeS(l); 13591 // NULL list 13592 listFreeS(NULL); 13593 13594 END_TEST 13595 13596 13597 START_TEST(listFreeManyST) 13598 13599 // not possible to know if a pointer is already freed 13600 char **l1 = listCreateS("we","sd"); 13601 char **l2 = listEmptySF(); 13602 listFreeManyS(l1, l2); 13603 13604 END_TEST 13605 13606 13607 START_TEST(listPrintST) 13608 13609 char **l; 13610 13611 // print text 13612 l = readText("textTest.null"); 13613 // TODO check stdout 13614 //listPrintS(l); 13615 listFreeS(l); 13616 // NULL list 13617 int r = listPrintS(NULL); 13618 ck_assert_int_eq(r, 0); 13619 13620 END_TEST 13621 13622 13623 START_TEST(listForEachT) 13624 13625 char **l = NULL; 13626 char **l2 = NULL; 13627 char **r = null; 13628 13629 // for each element in list 13630 r = listPushS(&l, "1sdfdsf"); 13631 ck_assert_ptr_eq(r, l); 13632 r = listPushS(&l, "4444"); 13633 ck_assert_ptr_eq(r, l); 13634 r = listPushS(&l, "3"); 13635 ck_assert_ptr_eq(r, l); 13636 r = listPushS(&l, "22sdf"); 13637 ck_assert_ptr_eq(r, l); 13638 forEachCharP(l, i) { 13639 //printf(*i); 13640 r = listPushS(&l2, *i); 13641 ck_assert_ptr_eq(r, l2); 13642 } 13643 ck_assert_str_eq(l2[0], "1sdfdsf"); 13644 ck_assert_str_eq(l2[3], "22sdf"); 13645 listFreeS(l); 13646 listFreeS(l2); 13647 13648 END_TEST 13649 13650 13651 START_TEST(listEnumerateT) 13652 13653 char **l = NULL; 13654 char **l2 = NULL; 13655 char **r = null; 13656 13657 // enumerateCharP elements 13658 r = listPushS(&l, "1sdfdsf"); 13659 ck_assert_ptr_eq(r, l); 13660 r = listPushS(&l, "4444"); 13661 ck_assert_ptr_eq(r, l); 13662 r = listPushS(&l, "3"); 13663 ck_assert_ptr_eq(r, l); 13664 r = listPushS(&l, "22sdf"); 13665 ck_assert_ptr_eq(r, l); 13666 enumerateCharP(l, i, j) { 13667 r = listPushS(&l2, *i); 13668 ck_assert_ptr_eq(r, l2); 13669 } 13670 ck_assert_uint_eq(j, 4); 13671 ck_assert_str_eq(l2[0], "1sdfdsf"); 13672 ck_assert_str_eq(l2[3], "22sdf"); 13673 listFreeS(l); 13674 listFreeS(l2); 13675 13676 END_TEST 13677 13678 13679 START_TEST(listSortST) 13680 13681 char **l = NULL; 13682 char **l2; 13683 char **r = null; 13684 13685 // list 13686 r = listPushS(&l, "1sdfdsf"); 13687 ck_assert_ptr_eq(r, l); 13688 r = listPushS(&l, "4444"); 13689 ck_assert_ptr_eq(r, l); 13690 r = listPushS(&l, "3"); 13691 ck_assert_ptr_eq(r, l); 13692 r = listPushS(&l, "22sdf"); 13693 ck_assert_ptr_eq(r, l); 13694 l2 = listSortS(l); 13695 ck_assert_str_eq(l2[0], "1sdfdsf"); 13696 ck_assert_str_eq(l2[3], "4444"); 13697 listFreeS(l); 13698 listFreeS(l2); 13699 // one element list 13700 l = NULL; 13701 r = listPushS(&l, "1sdfdsf"); 13702 ck_assert_ptr_eq(r, l); 13703 l2 = listSortS(l); 13704 ck_assert_uint_eq(listLengthS(l2),1); 13705 ck_assert_str_eq(l2[0], "1sdfdsf"); 13706 listFreeS(l); 13707 listFreeS(l2); 13708 // empty list 13709 listEmptyS(l2) 13710 l = listSortS(l2); 13711 ck_assert_uint_eq(listLengthS(l),0); 13712 ck_assert_ptr_eq(l[0], NULL); 13713 listFreeS(l); 13714 listFreeS(l2); 13715 // NULL list 13716 ck_assert_ptr_eq(listSortS(NULL), NULL); 13717 13718 END_TEST 13719 13720 13721 START_TEST(iListSortST) 13722 13723 char **l = NULL; 13724 char **r = null; 13725 13726 // list 13727 r = listPushS(&l, "1sdfdsf"); 13728 ck_assert_ptr_eq(r, l); 13729 r = listPushS(&l, "4444"); 13730 ck_assert_ptr_eq(r, l); 13731 r = listPushS(&l, "3"); 13732 ck_assert_ptr_eq(r, l); 13733 r = listPushS(&l, "22sdf"); 13734 ck_assert_ptr_eq(r, l); 13735 r = iListSortS(&l); 13736 ck_assert_ptr_eq(r, l); 13737 ck_assert_str_eq(l[0], "1sdfdsf"); 13738 ck_assert_str_eq(l[3], "4444"); 13739 listFreeS(l); 13740 // one element list 13741 l = NULL; 13742 r = listPushS(&l, "1sdfdsf"); 13743 ck_assert_ptr_eq(r, l); 13744 r = iListSortS(&l); 13745 ck_assert_ptr_eq(r, l); 13746 ck_assert_uint_eq(listLengthS(l),1); 13747 ck_assert_str_eq(l[0], "1sdfdsf"); 13748 listFreeS(l); 13749 // empty list 13750 listEmptyS(l) 13751 r = iListSortS(&l); 13752 ck_assert_ptr_eq(r, null); 13753 ck_assert_uint_eq(listLengthS(l),0); 13754 ck_assert_ptr_eq(l[0], NULL); 13755 listFreeS(l); 13756 // NULL list 13757 l = NULL; 13758 r = iListSortS(&l); 13759 ck_assert_ptr_eq(r, null); 13760 ck_assert_ptr_eq(l, NULL); 13761 // NULL var 13762 r = iListSortS(NULL); 13763 ck_assert_ptr_eq(r, null); 13764 13765 END_TEST 13766 13767 /** 13768 * list Sort String Compare function 13769 * 13770 * in: 13771 * a 13772 * b 13773 * out: 13774 * test result 13775 */ 13776 local int listSortSCmp(const void * a, const void * b) { 13777 13778 // sanity checks 13779 if (!a && !b) { 13780 return(0); 13781 } 13782 if (!a && b) { 13783 return(-1); 13784 } 13785 if (a && !b) { 13786 return(1); 13787 } 13788 return(strcmp(*(char **)a,*(char **)b)); 13789 } 13790 13791 START_TEST(listSortFST) 13792 13793 char **l = NULL; 13794 char **l2; 13795 char **r = null; 13796 13797 // list 13798 r = listPushS(&l, "1sdfdsf"); 13799 ck_assert_ptr_eq(r, l); 13800 r = listPushS(&l, "4444"); 13801 ck_assert_ptr_eq(r, l); 13802 r = listPushS(&l, "3"); 13803 ck_assert_ptr_eq(r, l); 13804 r = listPushS(&l, "22sdf"); 13805 ck_assert_ptr_eq(r, l); 13806 l2 = listSortFS(l, listSortSCmp); 13807 ck_assert_str_eq(l2[0], "1sdfdsf"); 13808 ck_assert_str_eq(l2[3], "4444"); 13809 listFreeS(l); 13810 listFreeS(l2); 13811 // one element list 13812 l = NULL; 13813 r = listPushS(&l, "1sdfdsf"); 13814 ck_assert_ptr_eq(r, l); 13815 l2 = listSortFS(l, listSortSCmp); 13816 ck_assert_uint_eq(listLengthS(l2),1); 13817 ck_assert_str_eq(l2[0], "1sdfdsf"); 13818 listFreeS(l); 13819 listFreeS(l2); 13820 // empty list 13821 listEmptyS(l2) 13822 l = listSortFS(l2, listSortSCmp); 13823 ck_assert_uint_eq(listLengthS(l),0); 13824 ck_assert_ptr_eq(l[0], NULL); 13825 listFreeS(l); 13826 // NULL compare function 13827 ck_assert_ptr_eq(listSortFS(l2, NULL), NULL); 13828 listFreeS(l2); 13829 // NULL list 13830 ck_assert_ptr_eq(listSortFS(NULL, listSortSCmp), NULL); 13831 13832 13833 END_TEST 13834 13835 13836 START_TEST(iListSortFST) 13837 13838 char **l = NULL; 13839 char **r = null; 13840 13841 // list 13842 r = listPushS(&l, "1sdfdsf"); 13843 ck_assert_ptr_eq(r, l); 13844 r = listPushS(&l, "4444"); 13845 ck_assert_ptr_eq(r, l); 13846 r = listPushS(&l, "3"); 13847 ck_assert_ptr_eq(r, l); 13848 r = listPushS(&l, "22sdf"); 13849 ck_assert_ptr_eq(r, l); 13850 r = iListSortFS(&l, listSortSCmp); 13851 ck_assert_ptr_eq(r, l); 13852 ck_assert_str_eq(l[0], "1sdfdsf"); 13853 ck_assert_str_eq(l[3], "4444"); 13854 listFreeS(l); 13855 // one element list 13856 l = NULL; 13857 r = listPushS(&l, "1sdfdsf"); 13858 ck_assert_ptr_eq(r, l); 13859 r = iListSortFS(&l, listSortSCmp); 13860 ck_assert_ptr_eq(r, l); 13861 ck_assert_uint_eq(listLengthS(l),1); 13862 ck_assert_str_eq(l[0], "1sdfdsf"); 13863 listFreeS(l); 13864 // empty list 13865 listEmptyS(l) 13866 r = iListSortFS(&l, listSortSCmp); 13867 ck_assert_ptr_eq(r, null); 13868 ck_assert_uint_eq(listLengthS(l),0); 13869 ck_assert_ptr_eq(l[0], NULL); 13870 // NULL compare function 13871 r = iListSortFS(&l, null); 13872 ck_assert_ptr_eq(r, null); 13873 listFreeS(l); 13874 // NULL list 13875 l = NULL; 13876 r = iListSortFS(&l, listSortSCmp); 13877 ck_assert_ptr_eq(r, null); 13878 ck_assert_ptr_eq(l, NULL); 13879 // NULL var 13880 r = iListSortFS(NULL, listSortSCmp); 13881 ck_assert_ptr_eq(r, null); 13882 13883 13884 END_TEST 13885 13886 13887 START_TEST(icListSortST) 13888 13889 char **l = NULL; 13890 char **l2; 13891 char **r = null; 13892 13893 // list 13894 r = listPushS(&l, "A1sdfdsf"); 13895 ck_assert_ptr_eq(r, l); 13896 r = listPushS(&l, "d4444"); 13897 ck_assert_ptr_eq(r, l); 13898 r = listPushS(&l, "c3"); 13899 ck_assert_ptr_eq(r, l); 13900 r = listPushS(&l, "B22sdf"); 13901 ck_assert_ptr_eq(r, l); 13902 l2 = icListSortS(l); 13903 ck_assert_str_eq(l2[0], "A1sdfdsf"); 13904 ck_assert_str_eq(l2[3], "d4444"); 13905 listFreeS(l); 13906 listFreeS(l2); 13907 // one element list 13908 l = NULL; 13909 r = listPushS(&l, "1sdfdsf"); 13910 ck_assert_ptr_eq(r, l); 13911 l2 = icListSortS(l); 13912 ck_assert_uint_eq(listLengthS(l2),1); 13913 ck_assert_str_eq(l2[0], "1sdfdsf"); 13914 listFreeS(l); 13915 listFreeS(l2); 13916 // empty list 13917 listEmptyS(l2) 13918 l = icListSortS(l2); 13919 ck_assert_uint_eq(listLengthS(l),0); 13920 ck_assert_ptr_eq(l[0], NULL); 13921 listFreeS(l); 13922 listFreeS(l2); 13923 // NULL list 13924 ck_assert_ptr_eq(icListSortS(NULL), NULL); 13925 13926 13927 END_TEST 13928 13929 13930 START_TEST(iicListSortST) 13931 13932 char **l = NULL; 13933 char **r = null; 13934 13935 // list 13936 r = listPushS(&l, "a1sdfdsf"); 13937 ck_assert_ptr_eq(r, l); 13938 r = listPushS(&l, "D4444"); 13939 ck_assert_ptr_eq(r, l); 13940 r = listPushS(&l, "B3"); 13941 ck_assert_ptr_eq(r, l); 13942 r = listPushS(&l, "c22sdf"); 13943 ck_assert_ptr_eq(r, l); 13944 r = iicListSortS(&l); 13945 ck_assert_ptr_eq(r, l); 13946 ck_assert_str_eq(l[0], "a1sdfdsf"); 13947 ck_assert_str_eq(l[3], "D4444"); 13948 listFreeS(l); 13949 // one element list 13950 l = NULL; 13951 r = listPushS(&l, "1sdfdsf"); 13952 ck_assert_ptr_eq(r, l); 13953 r = iicListSortS(&l); 13954 ck_assert_ptr_eq(r, l); 13955 ck_assert_uint_eq(listLengthS(l),1); 13956 ck_assert_str_eq(l[0], "1sdfdsf"); 13957 listFreeS(l); 13958 // empty list 13959 listEmptyS(l) 13960 r = iicListSortS(&l); 13961 ck_assert_ptr_eq(r, null); 13962 ck_assert_uint_eq(listLengthS(l),0); 13963 ck_assert_ptr_eq(l[0], NULL); 13964 listFreeS(l); 13965 // NULL list 13966 l = NULL; 13967 r = iicListSortS(&l); 13968 ck_assert_ptr_eq(r, null); 13969 ck_assert_ptr_eq(l, NULL); 13970 // NULL var 13971 r = iicListSortS(NULL); 13972 ck_assert_ptr_eq(r, null); 13973 13974 13975 END_TEST 13976 13977 13978 START_TEST(readTextT) 13979 13980 char **l; 13981 13982 // text 13983 l = readText("textTest.null"); 13984 ck_assert_uint_eq(listLengthS(l),2); 13985 ck_assert_str_eq(l[0], "LINE 1"); 13986 ck_assert_str_eq(l[1], "ANOTHER line"); 13987 listFreeS(l); 13988 // empty text 13989 l = readText("chmodTest.null"); 13990 ck_assert_uint_eq(listLengthS(l),0); 13991 ck_assert_ptr_eq(l[0], NULL); 13992 listFreeS(l); 13993 // NULL path 13994 ck_assert_ptr_eq(readText(NULL), NULL); 13995 // non existing path 13996 if (fileExists("nonExistingFile")) { 13997 int R = rmAll("nonExistingFile"); 13998 ck_assert_int_ne(R, 0); 13999 } 14000 ck_assert_ptr_eq(readText("nonExistingFile"), NULL); 14001 14002 END_TEST 14003 14004 14005 START_TEST(readStreamT) 14006 14007 char **l; 14008 FILE *fp; 14009 14010 // stream 14011 fp = fopen("textTest.null", "r"); 14012 l = readStream(fp); 14013 fclose(fp); 14014 ck_assert_uint_eq(listLengthS(l),2); 14015 ck_assert_str_eq(l[0], "LINE 1"); 14016 ck_assert_str_eq(l[1], "ANOTHER line"); 14017 listFreeS(l); 14018 // empty stream 14019 fp = fopen("chmodTest.null", "r"); 14020 l = readStream(fp); 14021 fclose(fp); 14022 ck_assert_uint_eq(listLengthS(l),0); 14023 ck_assert_ptr_eq(l[0], NULL); 14024 listFreeS(l); 14025 // NULL stream 14026 ck_assert_ptr_eq(readStream(NULL), NULL); 14027 14028 END_TEST 14029 14030 14031 START_TEST(writeTextT) 14032 14033 char **l; 14034 bool r; 14035 14036 // write textOutTest.null 14037 l = readText("textTest.null"); 14038 r = writeText("textOutTest.null", l); 14039 ck_assert(r); 14040 listFreeS(l); 14041 14042 // check textOutTest.null 14043 l = readText("textOutTest.null"); 14044 ck_assert_uint_eq(listLengthS(l),2); 14045 ck_assert_str_eq(l[0], "LINE 1"); 14046 ck_assert_str_eq(l[1], "ANOTHER line"); 14047 // non existing file 14048 // make sure the file doesnt exist 14049 if (fileExists("nonExistingFile")) { 14050 int R = rmAll("nonExistingFile"); 14051 ck_assert_int_ne(R, 0); 14052 } 14053 ck_assert(writeText("nonExistingFile",l)); 14054 if (fileExists("nonExistingFile")) { 14055 int R = rmAll("nonExistingFile"); 14056 ck_assert_int_ne(R, 0); 14057 } 14058 // NULL path 14059 ck_assert(!writeText(NULL,l)); 14060 listFreeS(l); 14061 // NULL list 14062 ck_assert(!writeText("a",NULL)); 14063 14064 END_TEST 14065 14066 14067 START_TEST(writeStreamT) 14068 14069 char **l; 14070 FILE *fp; 14071 bool r; 14072 14073 // write textOutTest.null 14074 fp = fopen("textTest.null", "r"); 14075 l = readStream(fp); 14076 fclose(fp); 14077 fp = fopen("textOutTest.null", "w"); 14078 r = writeStream(fp, l); 14079 ck_assert(r); 14080 // NULL list 14081 ck_assert(!writeStream(fp,NULL)); 14082 fclose(fp); 14083 listFreeS(l); 14084 14085 // check textOutTest.null 14086 fp = fopen("textOutTest.null", "r"); 14087 l = readStream(fp); 14088 fclose(fp); 14089 ck_assert_uint_eq(listLengthS(l),2); 14090 ck_assert_str_eq(l[0], "LINE 1"); 14091 ck_assert_str_eq(l[1], "ANOTHER line"); 14092 // NULL stream 14093 ck_assert(!writeStream(NULL,l)); 14094 listFreeS(l); 14095 14096 END_TEST 14097 14098 14099 START_TEST(appendTextT) 14100 14101 char **l; 14102 bool r; 14103 14104 // append to textOutTest.null 14105 l = readText("textTest.null"); 14106 r = writeText("textOutTest.null", l); 14107 ck_assert(r); 14108 char **c = listCreateS("A","B"); 14109 r = appendText("textOutTest.null", c); 14110 listFreeManyS(l,c); 14111 14112 // check textOutTest.null 14113 l = readText("textOutTest.null"); 14114 ck_assert_uint_eq(listLengthS(l),4); 14115 ck_assert_str_eq(l[0], "LINE 1"); 14116 ck_assert_str_eq(l[1], "ANOTHER line"); 14117 ck_assert_str_eq(l[2], "A"); 14118 ck_assert_str_eq(l[3], "B"); 14119 // non existing file 14120 // make sure the file doesnt exist 14121 if (fileExists("nonExistingFile")) { 14122 int R = rmAll("nonExistingFile"); 14123 ck_assert_int_ne(R, 0); 14124 } 14125 ck_assert(appendText("nonExistingFile",l)); 14126 if (fileExists("nonExistingFile")) { 14127 int R = rmAll("nonExistingFile"); 14128 ck_assert_int_ne(R, 0); 14129 } 14130 // NULL path 14131 ck_assert(!appendText(NULL,l)); 14132 listFreeS(l); 14133 // NULL list 14134 ck_assert(!appendText("a",NULL)); 14135 14136 END_TEST 14137 14138 14139 START_TEST(listGetST) 14140 14141 char **l = NULL; 14142 char **r = null; 14143 14144 // get string 14145 r = listPushS(&l, "1"); 14146 ck_assert_ptr_eq(r, l); 14147 r = listPushS(&l, "22"); 14148 ck_assert_ptr_eq(r, l); 14149 r = listPushS(&l, "333"); 14150 ck_assert_ptr_eq(r, l); 14151 r = listPushS(&l, "4444"); 14152 ck_assert_ptr_eq(r, l); 14153 char *s = listGetS(l, 0); 14154 ck_assert_str_eq(s, "1"); 14155 free(s); 14156 // negative index 14157 s = listGetS(l, -1); 14158 ck_assert_str_eq(s, "4444"); 14159 free(s); 14160 // outside list 14161 ck_assert_ptr_eq(listGetS(l, 10), NULL); 14162 ck_assert_ptr_eq(listGetS(l, -10), NULL); 14163 listFreeS(l); 14164 // negative index in a one element list 14165 l = NULL; 14166 r = listPushS(&l, "ASD"); 14167 ck_assert_ptr_eq(r, l); 14168 r = listPushS(&l, NULL); 14169 ck_assert_ptr_eq(r, null); 14170 s = listGetS(l,-1); 14171 ck_assert_ptr_ne(s, NULL); 14172 free(s); 14173 listFreeS(l); 14174 // empty list 14175 listEmptyS(l) 14176 ck_assert_ptr_eq(listGetS(l,0),NULL); 14177 free(l); 14178 // NULL list 14179 ck_assert_ptr_eq(listGetS(NULL, 0), NULL); 14180 14181 END_TEST 14182 14183 14184 START_TEST(iListGetST) 14185 14186 char **l = NULL; 14187 char **r = null; 14188 14189 // get string 14190 r = listPushS(&l, "1"); 14191 ck_assert_ptr_eq(r, l); 14192 r = listPushS(&l, "22"); 14193 ck_assert_ptr_eq(r, l); 14194 r = listPushS(&l, "333"); 14195 ck_assert_ptr_eq(r, l); 14196 r = listPushS(&l, "4444"); 14197 ck_assert_ptr_eq(r, l); 14198 ck_assert_str_eq(iListGetS(l, 0), "1"); 14199 // negative index 14200 ck_assert_str_eq(iListGetS(l, -1), "4444"); 14201 // outside list 14202 ck_assert_ptr_eq(iListGetS(l, 10), NULL); 14203 ck_assert_ptr_eq(iListGetS(l, -10), NULL); 14204 listFreeS(l); 14205 // negative index in a one element list 14206 l = NULL; 14207 r = listPushS(&l, "ASD"); 14208 ck_assert_ptr_eq(r, l); 14209 r = listPushS(&l, NULL); 14210 ck_assert_ptr_eq(r, null); 14211 ck_assert_ptr_ne(iListGetS(l,-1), NULL); 14212 listFreeS(l); 14213 // empty list 14214 listEmptyS(l) 14215 ck_assert_ptr_eq(iListGetS(l,0),NULL); 14216 free(l); 14217 // NULL list 14218 ck_assert_ptr_eq(iListGetS(NULL, 0), NULL); 14219 14220 END_TEST 14221 14222 14223 START_TEST(listSetST) 14224 14225 char **l = NULL; 14226 char **r = null; 14227 14228 // get string 14229 r = listPushS(&l, "@@"); 14230 ck_assert_ptr_eq(r, l); 14231 r = listPushS(&l, "22"); 14232 ck_assert_ptr_eq(r, l); 14233 r = listPushS(&l, "|"); 14234 ck_assert_ptr_eq(r, l); 14235 r = listPushS(&l, "4444"); 14236 ck_assert_ptr_eq(r, l); 14237 r = listSetS(l, 0, "1"); 14238 ck_assert_ptr_eq(r, l); 14239 char *s = listGetS(l, 0); 14240 ck_assert_str_eq(s, "1"); 14241 free(s); 14242 // negative index 14243 r = listSetS(l, -2, "333"); 14244 ck_assert_ptr_eq(r, l); 14245 s = listGetS(l, -2); 14246 ck_assert_str_eq(s, "333"); 14247 free(s); 14248 // outside list 14249 // list is unchanged 14250 r = listSetS(l, 10, "QWE"); 14251 ck_assert_ptr_eq(r, null); 14252 r = listSetS(l, -10, "QWE"); 14253 ck_assert_ptr_eq(r, null); 14254 // NULL s string 14255 r = listSetS(l, -2, NULL); 14256 ck_assert_ptr_eq(r, null); 14257 ck_assert_str_eq(l[0], "1"); 14258 ck_assert_str_eq(l[1], "22"); 14259 ck_assert_str_eq(l[2], "333"); 14260 ck_assert_str_eq(l[3], "4444"); 14261 listFreeS(l); 14262 // negative index in a one element list 14263 l = NULL; 14264 r = listPushS(&l, "ASD"); 14265 ck_assert_ptr_eq(r, l); 14266 r = listPushS(&l, NULL); 14267 ck_assert_ptr_eq(r, null); 14268 r = listSetS(l, -1, "QWE"); 14269 ck_assert_ptr_eq(r, l); 14270 s = listGetS(l,-1); 14271 ck_assert_str_eq(s, "QWE"); 14272 free(s); 14273 listFreeS(l); 14274 // empty list - should not crash 14275 listEmptyS(l) 14276 r = listSetS(l, 0, "QWE"); 14277 ck_assert_ptr_eq(r, null); 14278 ck_assert_ptr_eq(listGetS(l,0),NULL); 14279 free(l); 14280 // NULL list 14281 r = listSetS(NULL, 0, "QWE"); 14282 ck_assert_ptr_eq(r, null); 14283 ck_assert_ptr_eq(listGetS(NULL, 0), NULL); 14284 14285 END_TEST 14286 14287 14288 START_TEST(listSetCharST) 14289 14290 char **l = NULL; 14291 char **r = null; 14292 14293 // get string 14294 r = listPushS(&l, "@@"); 14295 ck_assert_ptr_eq(r, l); 14296 r = listPushS(&l, "22"); 14297 ck_assert_ptr_eq(r, l); 14298 r = listPushS(&l, "|"); 14299 ck_assert_ptr_eq(r, l); 14300 r = listPushS(&l, "4444"); 14301 ck_assert_ptr_eq(r, l); 14302 r = listSetCharS(l, 0, '1'); 14303 ck_assert_ptr_eq(r, l); 14304 char *s = listGetS(l, 0); 14305 ck_assert_str_eq(s, "1"); 14306 free(s); 14307 // negative index 14308 r = listSetCharS(l, -2, '3'); 14309 ck_assert_ptr_eq(r, l); 14310 s = listGetS(l, -2); 14311 ck_assert_str_eq(s, "3"); 14312 free(s); 14313 // outside list 14314 // list is unchanged 14315 r = listSetCharS(l, 10, 'Q'); 14316 ck_assert_ptr_eq(r, null); 14317 r = listSetCharS(l, -10, 'Q'); 14318 ck_assert_ptr_eq(r, null); 14319 ck_assert_str_eq(l[0], "1"); 14320 ck_assert_str_eq(l[1], "22"); 14321 ck_assert_str_eq(l[2], "3"); 14322 ck_assert_str_eq(l[3], "4444"); 14323 listFreeS(l); 14324 // negative index in a one element list 14325 l = NULL; 14326 r = listPushS(&l, "ASD"); 14327 ck_assert_ptr_eq(r, l); 14328 r = listPushS(&l, NULL); 14329 ck_assert_ptr_eq(r, null); 14330 r = listSetCharS(l, -1, 'Q'); 14331 ck_assert_ptr_eq(r, l); 14332 s = listGetS(l,-1); 14333 ck_assert_str_eq(s, "Q"); 14334 free(s); 14335 listFreeS(l); 14336 // empty list - should not crash 14337 listEmptyS(l) 14338 r = listSetCharS(l, 0, 'Q'); 14339 ck_assert_ptr_eq(r, null); 14340 ck_assert_ptr_eq(listGetS(l,0),NULL); 14341 free(l); 14342 // NULL list 14343 r = listSetCharS(NULL, 0, 'Q'); 14344 ck_assert_ptr_eq(r, null); 14345 ck_assert_ptr_eq(listGetS(NULL, 0), NULL); 14346 14347 14348 END_TEST 14349 14350 14351 START_TEST(iListSetST) 14352 14353 char **l = NULL; 14354 char *s; 14355 char **r = null; 14356 14357 // set string 14358 r = listPushS(&l, "@@"); 14359 ck_assert_ptr_eq(r, l); 14360 r = listPushS(&l, "22"); 14361 ck_assert_ptr_eq(r, l); 14362 r = listPushS(&l, "|"); 14363 ck_assert_ptr_eq(r, l); 14364 r = listPushS(&l, "4444"); 14365 ck_assert_ptr_eq(r, l); 14366 s = strdup("1"); 14367 r = iListSetS(l, 0, s); 14368 ck_assert_ptr_eq(r, l); 14369 ck_assert_str_eq(iListGetS(l, 0), "1"); 14370 // negative index 14371 s = strdup("333"); 14372 r = iListSetS(l, -2, s); 14373 ck_assert_ptr_eq(r, l); 14374 ck_assert_str_eq(iListGetS(l, -2), "333"); 14375 // outside list 14376 // list is unchanged 14377 s = strdup("QWE"); 14378 r = iListSetS(l, 10, s); 14379 ck_assert_ptr_eq(r, null); 14380 r = iListSetS(l, -10, s); 14381 ck_assert_ptr_eq(r, null); 14382 free(s); 14383 // NULL s string 14384 s = NULL; 14385 r = iListSetS(l, -2, s); 14386 ck_assert_ptr_eq(r, null); 14387 // NULL s var 14388 r = iListSetS(l, -2, NULL); 14389 ck_assert_ptr_eq(r, null); 14390 ck_assert_str_eq(l[0], "1"); 14391 ck_assert_str_eq(l[1], "22"); 14392 ck_assert_str_eq(l[2], "333"); 14393 ck_assert_str_eq(l[3], "4444"); 14394 listFreeS(l); 14395 // negative index in a one element list 14396 l = NULL; 14397 r = listPushS(&l, "ASD"); 14398 ck_assert_ptr_eq(r, l); 14399 r = listPushS(&l, NULL); 14400 ck_assert_ptr_eq(r, null); 14401 s = strdup("QWE"); 14402 r = iListSetS(l, -1, s); 14403 ck_assert_ptr_eq(r, l); 14404 ck_assert_str_eq(iListGetS(l,-1), "QWE"); 14405 listFreeS(l); 14406 // empty list - should not crash 14407 listEmptyS(l) 14408 s = strdup("QWE"); 14409 r = iListSetS(l, 0, s); 14410 ck_assert_ptr_eq(r, null); 14411 ck_assert_ptr_eq(listGetS(l,0),NULL); 14412 free(s); 14413 free(l); 14414 // NULL list 14415 s = strdup("QWE"); 14416 r = iListSetS(NULL, 0, s); 14417 ck_assert_ptr_eq(r, null); 14418 ck_assert_ptr_eq(listGetS(NULL, 0), NULL); 14419 free(s); 14420 14421 END_TEST 14422 14423 14424 START_TEST(listSwapST) 14425 14426 char **l = null; 14427 char **r; 14428 14429 r = listPushS(&l, "lib"); 14430 ck_assert_ptr_eq(r, l); 14431 r = listPushS(&l, "sheepy"); 14432 ck_assert_ptr_eq(r, l); 14433 r = listPushS(&l, "spm"); 14434 ck_assert_ptr_eq(r, l); 14435 // positive index 14436 r = listSwapS(l, 0, 2); 14437 ck_assert_str_eq(r[0], "spm"); 14438 ck_assert_str_eq(r[1], "sheepy"); 14439 ck_assert_str_eq(r[2], "lib"); 14440 listFreeS(r); 14441 // negative index 14442 r = listSwapS(l, -1, 1); 14443 ck_assert_str_eq(r[0], "lib"); 14444 ck_assert_str_eq(r[1], "spm"); 14445 ck_assert_str_eq(r[2], "sheepy"); 14446 listFreeS(r); 14447 r = listSwapS(l, -3, 1); 14448 ck_assert_str_eq(r[0], "sheepy"); 14449 ck_assert_str_eq(r[1], "lib"); 14450 ck_assert_str_eq(r[2], "spm"); 14451 listFreeS(r); 14452 // swap equal indexes 14453 r = listSwapS(l, -3, -3); 14454 ck_assert_str_eq(r[0], "lib"); 14455 ck_assert_str_eq(r[1], "sheepy"); 14456 ck_assert_str_eq(r[2], "spm"); 14457 listFreeS(r); 14458 r = listSwapS(&l[2], 0, -1); 14459 ck_assert_str_eq(r[0], "spm"); 14460 listFreeS(r); 14461 // 1 element list 14462 // outside length 14463 r = listSwapS(l, 0, 3); 14464 ck_assert_ptr_eq(r, null); 14465 r = listSwapS(l, 0, -4); 14466 ck_assert_ptr_eq(r, null); 14467 r = listSwapS(l, 3, 0); 14468 ck_assert_ptr_eq(r, null); 14469 r = listSwapS(l, -4, 0); 14470 ck_assert_ptr_eq(r, null); 14471 listFreeS(l); 14472 // length 0 14473 listEmptyS(l); 14474 r = listSwapS(l, -1, 0); 14475 ck_assert_ptr_eq(r, null); 14476 listFreeS(l); 14477 // null list 14478 ck_assert_ptr_eq(listSwapS(NULL, 1, 1), null); 14479 14480 14481 END_TEST 14482 14483 14484 START_TEST(iListSwapST) 14485 14486 char **l = null; 14487 char **r; 14488 14489 r = listPushS(&l, "lib"); 14490 ck_assert_ptr_eq(r, l); 14491 r = listPushS(&l, "sheepy"); 14492 ck_assert_ptr_eq(r, l); 14493 r = listPushS(&l, "spm"); 14494 ck_assert_ptr_eq(r, l); 14495 // positive index 14496 r = iListSwapS(l, 0, 2); 14497 ck_assert_str_eq(r[0], "spm"); 14498 ck_assert_str_eq(r[1], "sheepy"); 14499 ck_assert_str_eq(r[2], "lib"); 14500 // negative index 14501 r = iListSwapS(l, -1, 1); 14502 ck_assert_str_eq(r[0], "spm"); 14503 ck_assert_str_eq(r[1], "lib"); 14504 ck_assert_str_eq(r[2], "sheepy"); 14505 r = iListSwapS(l, -3, 1); 14506 ck_assert_str_eq(r[0], "lib"); 14507 ck_assert_str_eq(r[1], "spm"); 14508 ck_assert_str_eq(r[2], "sheepy"); 14509 // swap equal indexes 14510 r = iListSwapS(l, -3, -3); 14511 ck_assert_str_eq(r[0], "lib"); 14512 ck_assert_str_eq(r[1], "spm"); 14513 ck_assert_str_eq(r[2], "sheepy"); 14514 r = iListSwapS(&l[2], 0, -1); 14515 ck_assert_str_eq(r[0], "sheepy"); 14516 // 1 element list 14517 // outside length 14518 r = iListSwapS(l, 0, 3); 14519 ck_assert_ptr_eq(r, null); 14520 r = iListSwapS(l, 0, -4); 14521 ck_assert_ptr_eq(r, null); 14522 r = iListSwapS(l, 3, 0); 14523 ck_assert_ptr_eq(r, null); 14524 r = iListSwapS(l, -4, 0); 14525 ck_assert_ptr_eq(r, null); 14526 listFreeS(l); 14527 // length 0 14528 listEmptyS(l); 14529 r = iListSwapS(l, -1, 0); 14530 ck_assert_ptr_eq(r, null); 14531 listFreeS(l); 14532 // null list 14533 ck_assert_ptr_eq(iListSwapS(NULL, 1, 1), null); 14534 14535 14536 END_TEST 14537 14538 14539 START_TEST(splitT) 14540 14541 char **l; 14542 14543 // string 14544 l = split("one/two", "/"); 14545 ck_assert_uint_eq(listLengthS(l),2); 14546 ck_assert_str_eq(l[0], "one"); 14547 ck_assert_str_eq(l[1], "two"); 14548 listFreeS(l); 14549 // delimiter on the edge 14550 l = split("/one", "/"); 14551 ck_assert_uint_eq(listLengthS(l),2); 14552 ck_assert_str_eq(l[0], ""); 14553 ck_assert_str_eq(l[1], "one"); 14554 listFreeS(l); 14555 l = split("one/", "/"); 14556 ck_assert_uint_eq(listLengthS(l),2); 14557 ck_assert_str_eq(l[0], "one"); 14558 ck_assert_str_eq(l[1], ""); 14559 listFreeS(l); 14560 // delimiter not found 14561 l = split("one/two", "||"); 14562 ck_assert_uint_eq(listLengthS(l),1); 14563 ck_assert_str_eq(l[0], "one/two"); 14564 listFreeS(l); 14565 // split with several delimiters after each other 14566 l = split("one/two three ", " "); 14567 ck_assert_uint_eq(listLengthS(l),4); 14568 ck_assert_str_eq(l[0], "one/two"); 14569 ck_assert_str_eq(l[1], ""); 14570 ck_assert_str_eq(l[2], "three"); 14571 ck_assert_str_eq(l[3], ""); 14572 listFreeS(l); 14573 // multiple character delimiter 14574 l = split("AAe three extract", "e "); 14575 ck_assert_uint_eq(listLengthS(l),3); 14576 ck_assert_str_eq(l[0], "AA"); 14577 ck_assert_str_eq(l[1], "thre"); 14578 ck_assert_str_eq(l[2], "extract"); 14579 listFreeS(l); 14580 // empty delimiter 14581 l = split("AAd", ""); 14582 ck_assert_uint_eq(listLengthS(l),1); 14583 ck_assert_str_eq(l[0], "AAd"); 14584 listFreeS(l); 14585 // empty string 14586 l = split("", "$"); 14587 ck_assert_uint_eq(listLengthS(l),1); 14588 ck_assert_str_eq(l[0], ""); 14589 listFreeS(l); 14590 // NULL list 14591 ck_assert_ptr_eq(split(NULL, ";"), NULL); 14592 // NULL delimiter 14593 ck_assert_ptr_eq(split("test", NULL), NULL); 14594 14595 END_TEST 14596 14597 14598 START_TEST(splitCharT) 14599 14600 char **l; 14601 14602 // string 14603 l = splitChar("one/two", '/'); 14604 ck_assert_uint_eq(listLengthS(l),2); 14605 ck_assert_str_eq(l[0], "one"); 14606 ck_assert_str_eq(l[1], "two"); 14607 listFreeS(l); 14608 // delimiter on the edge 14609 l = splitChar("/one", '/'); 14610 ck_assert_uint_eq(listLengthS(l),2); 14611 ck_assert_str_eq(l[0], ""); 14612 ck_assert_str_eq(l[1], "one"); 14613 listFreeS(l); 14614 l = splitChar("one/", '/'); 14615 ck_assert_uint_eq(listLengthS(l),2); 14616 ck_assert_str_eq(l[0], "one"); 14617 ck_assert_str_eq(l[1], ""); 14618 listFreeS(l); 14619 // delimiter not found 14620 l = splitChar("one/two", '|'); 14621 ck_assert_uint_eq(listLengthS(l),1); 14622 ck_assert_str_eq(l[0], "one/two"); 14623 listFreeS(l); 14624 // split with several delimiters after each other 14625 l = splitChar("one/two three ", ' '); 14626 ck_assert_uint_eq(listLengthS(l),4); 14627 ck_assert_str_eq(l[0], "one/two"); 14628 ck_assert_str_eq(l[1], ""); 14629 ck_assert_str_eq(l[2], "three"); 14630 ck_assert_str_eq(l[3], ""); 14631 listFreeS(l); 14632 // empty string 14633 l = splitChar("", '$'); 14634 ck_assert_uint_eq(listLengthS(l),1); 14635 ck_assert_str_eq(l[0], ""); 14636 listFreeS(l); 14637 // NULL list 14638 ck_assert_ptr_eq(splitChar(NULL, ';'), NULL); 14639 14640 14641 END_TEST 14642 14643 14644 START_TEST(icSplitT) 14645 14646 char **l; 14647 14648 // string 14649 l = icSplit("one/two", "/"); 14650 ck_assert_uint_eq(listLengthS(l),2); 14651 ck_assert_str_eq(l[0], "one"); 14652 ck_assert_str_eq(l[1], "two"); 14653 listFreeS(l); 14654 // delimiter on the edge 14655 l = icSplit("/one", "/"); 14656 ck_assert_uint_eq(listLengthS(l),2); 14657 ck_assert_str_eq(l[0], ""); 14658 ck_assert_str_eq(l[1], "one"); 14659 listFreeS(l); 14660 l = icSplit("one/", "/"); 14661 ck_assert_uint_eq(listLengthS(l),2); 14662 ck_assert_str_eq(l[0], "one"); 14663 ck_assert_str_eq(l[1], ""); 14664 listFreeS(l); 14665 // delimiter not found 14666 l = icSplit("one/two", "||"); 14667 ck_assert_uint_eq(listLengthS(l),1); 14668 ck_assert_str_eq(l[0], "one/two"); 14669 listFreeS(l); 14670 // split with several delimiters after each other 14671 l = icSplit("one/two three ", " "); 14672 ck_assert_uint_eq(listLengthS(l),4); 14673 ck_assert_str_eq(l[0], "one/two"); 14674 ck_assert_str_eq(l[1], ""); 14675 ck_assert_str_eq(l[2], "three"); 14676 ck_assert_str_eq(l[3], ""); 14677 listFreeS(l); 14678 // multiple character delimiter 14679 l = icSplit("AAe three extract", "e "); 14680 ck_assert_uint_eq(listLengthS(l),3); 14681 ck_assert_str_eq(l[0], "AA"); 14682 ck_assert_str_eq(l[1], "thre"); 14683 ck_assert_str_eq(l[2], "extract"); 14684 listFreeS(l); 14685 // empty delimiter 14686 l = icSplit("AAd", ""); 14687 ck_assert_uint_eq(listLengthS(l),1); 14688 ck_assert_str_eq(l[0], "AAd"); 14689 listFreeS(l); 14690 // empty string 14691 l = icSplit("", "$"); 14692 ck_assert_uint_eq(listLengthS(l),1); 14693 ck_assert_str_eq(l[0], ""); 14694 listFreeS(l); 14695 // NULL list 14696 ck_assert_ptr_eq(icSplit(NULL, ";"), NULL); 14697 // NULL delimiter 14698 ck_assert_ptr_eq(icSplit("test", NULL), NULL); 14699 14700 14701 END_TEST 14702 14703 14704 START_TEST(icSplitCharT) 14705 14706 char **l; 14707 14708 // string 14709 l = icSplitChar("one/two", '/'); 14710 ck_assert_uint_eq(listLengthS(l),2); 14711 ck_assert_str_eq(l[0], "one"); 14712 ck_assert_str_eq(l[1], "two"); 14713 listFreeS(l); 14714 // delimiter on the edge 14715 l = icSplitChar("/one", '/'); 14716 ck_assert_uint_eq(listLengthS(l),2); 14717 ck_assert_str_eq(l[0], ""); 14718 ck_assert_str_eq(l[1], "one"); 14719 listFreeS(l); 14720 l = icSplitChar("one/", '/'); 14721 ck_assert_uint_eq(listLengthS(l),2); 14722 ck_assert_str_eq(l[0], "one"); 14723 ck_assert_str_eq(l[1], ""); 14724 listFreeS(l); 14725 // delimiter not found 14726 l = icSplitChar("one/two", '|'); 14727 ck_assert_uint_eq(listLengthS(l),1); 14728 ck_assert_str_eq(l[0], "one/two"); 14729 listFreeS(l); 14730 // split with several delimiters after each other 14731 l = icSplitChar("one/two three ", ' '); 14732 ck_assert_uint_eq(listLengthS(l),4); 14733 ck_assert_str_eq(l[0], "one/two"); 14734 ck_assert_str_eq(l[1], ""); 14735 ck_assert_str_eq(l[2], "three"); 14736 ck_assert_str_eq(l[3], ""); 14737 listFreeS(l); 14738 // empty string 14739 l = icSplitChar("", '$'); 14740 ck_assert_uint_eq(listLengthS(l),1); 14741 ck_assert_str_eq(l[0], ""); 14742 listFreeS(l); 14743 // NULL list 14744 ck_assert_ptr_eq(icSplitChar(NULL, ';'), NULL); 14745 14746 14747 END_TEST 14748 14749 14750 START_TEST(joinLengthT) 14751 14752 ssize_t r; 14753 char **l = listCreateS("","lib","sheepy"); 14754 char *s; 14755 14756 r = joinLength(l, "/"); 14757 s = join(l, "/"); 14758 ck_assert_int_eq(r, strlen(s)); 14759 free(s); 14760 listFreeS(l); 14761 // empty list 14762 listEmptyS(l) 14763 r = joinLength(l, "/"); 14764 ck_assert_int_eq(r, 0); 14765 listFreeS(l); 14766 // NULL delimiter 14767 ck_assert_int_eq(joinLength(l, NULL), -1); 14768 // NULL list 14769 ck_assert_int_eq(joinLength(NULL, ";"), -1); 14770 14771 END_TEST 14772 14773 14774 START_TEST(joinT) 14775 14776 char **l; 14777 char *s; 14778 char **r = null; 14779 14780 // list 14781 l = split("one/two", "/"); 14782 s = join(l, "/"); 14783 ck_assert_str_eq(s, "one/two"); 14784 // NULL delimiter 14785 ck_assert_ptr_eq(join(l, NULL), NULL); 14786 listFreeS(l); 14787 free(s); 14788 // empty list 14789 listEmptyS(l) 14790 s = join(l, "/"); 14791 ck_assert(isEmptyS(s)); 14792 listFreeS(l); 14793 free(s); 14794 // NULL list 14795 ck_assert_ptr_eq(join(NULL, ";"), NULL); 14796 // list with NULL first element 14797 l = NULL; 14798 r = listPushS(&l, NULL); 14799 ck_assert_ptr_eq(r, l); 14800 ck_assert_ptr_eq(join(l, "/"), NULL); 14801 listFreeS(l); 14802 14803 END_TEST 14804 14805 14806 START_TEST(joinCharT) 14807 14808 char **l; 14809 char *s; 14810 14811 // list 14812 l = split("one/two", "/"); 14813 s = joinChar(l, '/'); 14814 ck_assert_str_eq(s, "one/two"); 14815 listFreeS(l); 14816 free(s); 14817 // empty list 14818 listEmptyS(l) 14819 s = joinChar(l, '/'); 14820 ck_assert(isEmptyS(s)); 14821 listFreeS(l); 14822 free(s); 14823 // NULL list 14824 ck_assert_ptr_eq(joinChar(NULL, ';'), NULL); 14825 14826 14827 END_TEST 14828 14829 14830 START_TEST(bJoinT) 14831 14832 char **l; 14833 char s[100]; 14834 char **r = null; 14835 char *r2 = null; 14836 14837 // list 14838 l = split("one/two", "/"); 14839 r2 = bJoin(s, l, "/"); 14840 ck_assert_ptr_eq(r2, s); 14841 ck_assert_str_eq(s, "one/two"); 14842 // NULL delimiter 14843 r2 = bJoin(s, l, NULL); 14844 ck_assert_ptr_eq(r2, null); 14845 listFreeS(l); 14846 // empty list 14847 listEmptyS(l) 14848 r2 = bJoin(s, l, "/"); 14849 ck_assert_ptr_eq(r2, null); 14850 ck_assert_str_eq(s, "one/two"); 14851 listFreeS(l); 14852 // NULL list 14853 r2 = bJoin(s, NULL, ";"); 14854 ck_assert_ptr_eq(r2, null); 14855 // list with NULL first element 14856 l = NULL; 14857 r = listPushS(&l, NULL); 14858 ck_assert_ptr_eq(r, l); 14859 r2 = bJoin(s, l, "/"); 14860 ck_assert_ptr_eq(r2, null); 14861 listFreeS(l); 14862 14863 END_TEST 14864 14865 14866 START_TEST(bJoinCharT) 14867 14868 char **l; 14869 char s[100]; 14870 char *r = null; 14871 14872 // list 14873 l = split("one/two", "/"); 14874 r = bJoinChar(s, l, '/'); 14875 ck_assert_ptr_eq(r, s); 14876 ck_assert_str_eq(s, "one/two"); 14877 listFreeS(l); 14878 // empty list 14879 listEmptyS(l) 14880 r = bJoinChar(s, l, '/'); 14881 ck_assert_ptr_eq(r, null); 14882 ck_assert_str_eq(s, "one/two"); 14883 listFreeS(l); 14884 // NULL list 14885 r = bJoinChar(s, NULL, ';'); 14886 ck_assert_ptr_eq(r, null); 14887 14888 14889 END_TEST 14890 14891 14892 START_TEST(bLJoinT) 14893 14894 char **l; 14895 char s[100]; 14896 char **r = null; 14897 char *r2 = null; 14898 14899 // list 14900 l = split("one/two", "/"); 14901 r2 = bLJoin(s, sizeof s, l, "/"); 14902 ck_assert_ptr_eq(r2, s); 14903 ck_assert_str_eq(s, "one/two"); 14904 // shorter buffer 14905 r2 = bLJoin(s, 5, l, "/"); 14906 ck_assert_ptr_eq(r2, s); 14907 ck_assert_str_eq(s, "one/"); 14908 // size 0 - no change 14909 r2 = bLJoin(s, 0, l, "/"); 14910 ck_assert_ptr_eq(r2, s); 14911 ck_assert_str_eq(s, "one/"); 14912 // NULL delimiter 14913 r2 = bLJoin(s, sizeof s, l, NULL); 14914 ck_assert_ptr_eq(r2, null); 14915 listFreeS(l); 14916 // empty list 14917 listEmptyS(l) 14918 r2 = bLJoin(s, sizeof s, l, "/"); 14919 ck_assert_ptr_eq(r2, null); 14920 ck_assert_str_eq(s, "one/"); 14921 listFreeS(l); 14922 // NULL list 14923 r2 = bLJoin(s, sizeof s, NULL, ";"); 14924 ck_assert_ptr_eq(r2, null); 14925 // list with NULL first element 14926 l = NULL; 14927 r = listPushS(&l, NULL); 14928 ck_assert_ptr_eq(r, l); 14929 r2 = bLJoin(s, sizeof s, l, "/"); 14930 ck_assert_ptr_eq(r2, null); 14931 listFreeS(l); 14932 14933 END_TEST 14934 14935 14936 START_TEST(bLJoinCharT) 14937 14938 char **l; 14939 char s[100]; 14940 char *r = null; 14941 14942 // list 14943 l = split("one/two", "/"); 14944 r = bLJoinChar(s, sizeof s, l, '/'); 14945 ck_assert_ptr_eq(r, s); 14946 ck_assert_str_eq(s, "one/two"); 14947 // shorter buffer 14948 r = bLJoinChar(s, 5, l, '/'); 14949 ck_assert_ptr_eq(r, s); 14950 ck_assert_str_eq(s, "one/"); 14951 // size 0 - no change 14952 r = bLJoinChar(s, 0, l, '/'); 14953 ck_assert_ptr_eq(r, s); 14954 ck_assert_str_eq(s, "one/"); 14955 listFreeS(l); 14956 // empty list 14957 listEmptyS(l) 14958 r = bLJoinChar(s, sizeof s, l, '/'); 14959 ck_assert_ptr_eq(r, null); 14960 ck_assert_str_eq(s, "one/"); 14961 listFreeS(l); 14962 // NULL list 14963 r = bLJoinChar(s, sizeof s, NULL, ';'); 14964 ck_assert_ptr_eq(r, null); 14965 14966 14967 END_TEST 14968 14969 14970 START_TEST(extractST) 14971 14972 char **l; 14973 14974 // string 14975 l = extractS("one/two|", "/", "|"); 14976 ck_assert_uint_eq(listLengthS(l),1); 14977 ck_assert_str_eq(l[0], "two"); 14978 listFreeS(l); 14979 // delimiter not found 14980 l = extractS("one/two", "||", "/"); 14981 ck_assert_ptr_eq(l, NULL); 14982 // extractS with several delimiters after each other 14983 l = extractS("one/ two /three ", "/", " "); 14984 ck_assert_uint_eq(listLengthS(l),2); 14985 ck_assert_str_eq(l[0], ""); 14986 ck_assert_str_eq(l[1], "three"); 14987 listFreeS(l); 14988 // multiple character delimiter 14989 l = extractS("AAe thre|e extract", "e ", "|"); 14990 ck_assert_uint_eq(listLengthS(l),1); 14991 ck_assert_str_eq(l[0], "thre"); 14992 listFreeS(l); 14993 // empty delimiter 14994 l = extractS("AAd", "", "Ad"); 14995 ck_assert_ptr_eq(l, NULL); 14996 l = extractS("AAd", "A", ""); 14997 ck_assert_ptr_eq(l, NULL); 14998 // empty string 14999 l = extractS("", "$", "#"); 15000 ck_assert_ptr_eq(l, NULL); 15001 // delim1 = delim2 15002 l = extractS("", "$", "$"); 15003 ck_assert_ptr_eq(l, NULL); 15004 // NULL string 15005 ck_assert_ptr_eq(extractS(NULL, ";", ","), NULL); 15006 // NULL delimiter 15007 ck_assert_ptr_eq(extractS("test", NULL, ","), NULL); 15008 ck_assert_ptr_eq(extractS("test", ",", NULL), NULL); 15009 15010 END_TEST 15011 15012 15013 START_TEST(extractCharSST) 15014 15015 char **l; 15016 15017 // string 15018 l = extractCharSS("one/two|", '/', "|"); 15019 ck_assert_uint_eq(listLengthS(l),1); 15020 ck_assert_str_eq(l[0], "two"); 15021 listFreeS(l); 15022 // delimiter not found 15023 l = extractCharSS("one/two", '|', "/"); 15024 ck_assert_ptr_eq(l, NULL); 15025 // extractCharSS with several delimiters after each other 15026 l = extractCharSS("one/ two /three ", '/', " "); 15027 ck_assert_uint_eq(listLengthS(l),2); 15028 ck_assert_str_eq(l[0], ""); 15029 ck_assert_str_eq(l[1], "three"); 15030 listFreeS(l); 15031 // empty string 15032 l = extractCharSS("", '$', "#"); 15033 ck_assert_ptr_eq(l, NULL); 15034 // delim1 = delim2 15035 l = extractCharSS("", '$', "$"); 15036 ck_assert_ptr_eq(l, NULL); 15037 // NULL string 15038 ck_assert_ptr_eq(extractCharSS(NULL, ';', ","), NULL); 15039 // NULL delimiter 15040 ck_assert_ptr_eq(extractCharSS("test", ',', NULL), NULL); 15041 15042 15043 END_TEST 15044 15045 15046 START_TEST(extractSCharST) 15047 15048 char **l; 15049 15050 // string 15051 l = extractSCharS("one/two|", "/", '|'); 15052 ck_assert_uint_eq(listLengthS(l),1); 15053 ck_assert_str_eq(l[0], "two"); 15054 listFreeS(l); 15055 // delimiter not found 15056 l = extractSCharS("one/two", "||", '/'); 15057 ck_assert_ptr_eq(l, NULL); 15058 // extractSCharS with several delimiters after each other 15059 l = extractSCharS("one/ two /three ", "/", ' '); 15060 ck_assert_uint_eq(listLengthS(l),2); 15061 ck_assert_str_eq(l[0], ""); 15062 ck_assert_str_eq(l[1], "three"); 15063 listFreeS(l); 15064 // multiple character delimiter 15065 l = extractSCharS("AAe thre|e extract", "e ", '|'); 15066 ck_assert_uint_eq(listLengthS(l),1); 15067 ck_assert_str_eq(l[0], "thre"); 15068 listFreeS(l); 15069 // empty delimiter 15070 l = extractSCharS("AAd", "", 'A'); 15071 ck_assert_ptr_eq(l, NULL); 15072 // empty string 15073 l = extractSCharS("", "$", '#'); 15074 ck_assert_ptr_eq(l, NULL); 15075 // delim1 = delim2 15076 l = extractSCharS("", "$", '$'); 15077 ck_assert_ptr_eq(l, NULL); 15078 // NULL string 15079 ck_assert_ptr_eq(extractSCharS(NULL, ";", ','), NULL); 15080 // NULL delimiter 15081 ck_assert_ptr_eq(extractSCharS("test", NULL, ','), NULL); 15082 15083 15084 END_TEST 15085 15086 15087 START_TEST(extractCharCharST) 15088 15089 char **l; 15090 15091 // string 15092 l = extractCharCharS("one/two|", '/', '|'); 15093 ck_assert_uint_eq(listLengthS(l),1); 15094 ck_assert_str_eq(l[0], "two"); 15095 listFreeS(l); 15096 // delimiter not found 15097 l = extractCharCharS("one/two", '|', '/'); 15098 ck_assert_ptr_eq(l, NULL); 15099 // extractCharCharS with several delimiters after each other 15100 l = extractCharCharS("one/ two /three ", '/', ' '); 15101 ck_assert_uint_eq(listLengthS(l),2); 15102 ck_assert_str_eq(l[0], ""); 15103 ck_assert_str_eq(l[1], "three"); 15104 listFreeS(l); 15105 // empty string 15106 l = extractCharCharS("", '$', '#'); 15107 ck_assert_ptr_eq(l, NULL); 15108 // delim1 = delim2 15109 l = extractCharCharS("", '$', '$'); 15110 ck_assert_ptr_eq(l, NULL); 15111 // NULL string 15112 ck_assert_ptr_eq(extractCharCharS(NULL, ';', ','), NULL); 15113 15114 15115 END_TEST 15116 15117 15118 START_TEST(icExtractST) 15119 15120 char **l; 15121 15122 // string 15123 l = icExtractS("one/two|", "/", "|"); 15124 ck_assert_uint_eq(listLengthS(l),1); 15125 ck_assert_str_eq(l[0], "two"); 15126 listFreeS(l); 15127 // delimiter not found 15128 l = icExtractS("one/two", "||", "/"); 15129 ck_assert_ptr_eq(l, NULL); 15130 // icExtractS with several delimiters after each other 15131 l = icExtractS("one/ two /three ", "/", " "); 15132 ck_assert_uint_eq(listLengthS(l),2); 15133 ck_assert_str_eq(l[0], ""); 15134 ck_assert_str_eq(l[1], "three"); 15135 listFreeS(l); 15136 // multiple character delimiter 15137 l = icExtractS("AAe thre|e extract", "E ", "|"); 15138 ck_assert_uint_eq(listLengthS(l),1); 15139 ck_assert_str_eq(l[0], "thre"); 15140 listFreeS(l); 15141 // empty delimiter 15142 l = icExtractS("AAd", "", "Ad"); 15143 ck_assert_ptr_eq(l, NULL); 15144 l = icExtractS("AAd", "A", ""); 15145 ck_assert_ptr_eq(l, NULL); 15146 // empty string 15147 l = icExtractS("", "$", "#"); 15148 ck_assert_ptr_eq(l, NULL); 15149 // delim1 = delim2 15150 l = icExtractS("", "$", "$"); 15151 ck_assert_ptr_eq(l, NULL); 15152 // NULL string 15153 ck_assert_ptr_eq(icExtractS(NULL, ";", ","), NULL); 15154 // NULL delimiter 15155 ck_assert_ptr_eq(icExtractS("test", NULL, ","), NULL); 15156 ck_assert_ptr_eq(icExtractS("test", ",", NULL), NULL); 15157 15158 15159 END_TEST 15160 15161 15162 START_TEST(icExtractCharSST) 15163 15164 char **l; 15165 15166 // string 15167 l = icExtractCharSS("one/two|", '/', "|"); 15168 ck_assert_uint_eq(listLengthS(l),1); 15169 ck_assert_str_eq(l[0], "two"); 15170 listFreeS(l); 15171 // delimiter not found 15172 l = icExtractCharSS("one/two", '|', "/"); 15173 ck_assert_ptr_eq(l, NULL); 15174 // icExtractCharSS with several delimiters after each other 15175 l = icExtractCharSS("one/ two /three ", '/', " "); 15176 ck_assert_uint_eq(listLengthS(l),2); 15177 ck_assert_str_eq(l[0], ""); 15178 ck_assert_str_eq(l[1], "three"); 15179 listFreeS(l); 15180 // empty string 15181 l = icExtractCharSS("", '$', "#"); 15182 ck_assert_ptr_eq(l, NULL); 15183 // delim1 = delim2 15184 l = icExtractCharSS("", '$', "$"); 15185 ck_assert_ptr_eq(l, NULL); 15186 // NULL string 15187 ck_assert_ptr_eq(icExtractCharSS(NULL, ';', ","), NULL); 15188 // NULL delimiter 15189 ck_assert_ptr_eq(icExtractCharSS("test", ',', NULL), NULL); 15190 15191 15192 END_TEST 15193 15194 15195 START_TEST(icExtractSCharST) 15196 15197 char **l; 15198 15199 // string 15200 l = icExtractSCharS("one/two|", "/", '|'); 15201 ck_assert_uint_eq(listLengthS(l),1); 15202 ck_assert_str_eq(l[0], "two"); 15203 listFreeS(l); 15204 // delimiter not found 15205 l = icExtractSCharS("one/two", "||", '/'); 15206 ck_assert_ptr_eq(l, NULL); 15207 // icExtractSCharS with several delimiters after each other 15208 l = icExtractSCharS("one/ two /three ", "/", ' '); 15209 ck_assert_uint_eq(listLengthS(l),2); 15210 ck_assert_str_eq(l[0], ""); 15211 ck_assert_str_eq(l[1], "three"); 15212 listFreeS(l); 15213 // multiple character delimiter 15214 l = icExtractSCharS("AAe thre|e extract", "E ", '|'); 15215 ck_assert_uint_eq(listLengthS(l),1); 15216 ck_assert_str_eq(l[0], "thre"); 15217 listFreeS(l); 15218 // empty delimiter 15219 l = icExtractSCharS("AAd", "", 'A'); 15220 ck_assert_ptr_eq(l, NULL); 15221 // empty string 15222 l = icExtractSCharS("", "$", '#'); 15223 ck_assert_ptr_eq(l, NULL); 15224 // delim1 = delim2 15225 l = icExtractSCharS("", "$", '$'); 15226 ck_assert_ptr_eq(l, NULL); 15227 // NULL string 15228 ck_assert_ptr_eq(icExtractSCharS(NULL, ";", ','), NULL); 15229 // NULL delimiter 15230 ck_assert_ptr_eq(icExtractSCharS("test", NULL, ','), NULL); 15231 15232 15233 END_TEST 15234 15235 15236 START_TEST(icExtractCharCharST) 15237 15238 char **l; 15239 15240 // string 15241 l = icExtractCharCharS("one/two|", '/', '|'); 15242 ck_assert_uint_eq(listLengthS(l),1); 15243 ck_assert_str_eq(l[0], "two"); 15244 listFreeS(l); 15245 // delimiter not found 15246 l = icExtractCharCharS("one/two", '|', '/'); 15247 ck_assert_ptr_eq(l, NULL); 15248 // icExtractCharCharS with several delimiters after each other 15249 l = icExtractCharCharS("one/ two /three ", '/', ' '); 15250 ck_assert_uint_eq(listLengthS(l),2); 15251 ck_assert_str_eq(l[0], ""); 15252 ck_assert_str_eq(l[1], "three"); 15253 listFreeS(l); 15254 // empty string 15255 l = icExtractCharCharS("", '$', '#'); 15256 ck_assert_ptr_eq(l, NULL); 15257 // delim1 = delim2 15258 l = icExtractCharCharS("", '$', '$'); 15259 ck_assert_ptr_eq(l, NULL); 15260 // NULL string 15261 ck_assert_ptr_eq(icExtractCharCharS(NULL, ';', ','), NULL); 15262 15263 15264 END_TEST 15265 15266 15267 START_TEST(listDupST) 15268 15269 char **l = NULL; 15270 char **l2; 15271 char **r = null; 15272 15273 // list 15274 r = listPushS(&l, "1"); 15275 ck_assert_ptr_eq(r, l); 15276 r = listPushS(&l, "22"); 15277 ck_assert_ptr_eq(r, l); 15278 r = listPushS(&l, "333"); 15279 ck_assert_ptr_eq(r, l); 15280 r = listPushS(&l, "4444"); 15281 ck_assert_ptr_eq(r, l); 15282 l2 = listDupS(l); 15283 ck_assert_uint_eq(listLengthS(l2),4); 15284 ck_assert_str_eq(l2[0], "1"); 15285 ck_assert_str_eq(l2[3], "4444"); 15286 listFreeS(l); 15287 listFreeS(l2); 15288 // empty list 15289 listEmptyS(l) 15290 l2 = listDupS(l); 15291 ck_assert(listIsEmptyS(l2)); 15292 listFreeS(l); 15293 listFreeS(l2); 15294 // NULL list 15295 ck_assert_ptr_eq(listDupS(NULL), NULL); 15296 15297 END_TEST 15298 15299 15300 START_TEST(iListDupST) 15301 15302 char **l = NULL; 15303 char **l2; 15304 char **r = null; 15305 15306 // list 15307 r = listPushS(&l, "1"); 15308 ck_assert_ptr_eq(r, l); 15309 r = listPushS(&l, "22"); 15310 ck_assert_ptr_eq(r, l); 15311 r = listPushS(&l, "333"); 15312 ck_assert_ptr_eq(r, l); 15313 r = listPushS(&l, "4444"); 15314 ck_assert_ptr_eq(r, l); 15315 l2 = iListDupS(l); 15316 ck_assert_uint_eq(listLengthS(l2),4); 15317 ck_assert_str_eq(l2[0], "1"); 15318 ck_assert_str_eq(l2[3], "4444"); 15319 free(l); 15320 listFreeS(l2); 15321 // empty list 15322 listEmptyS(l); 15323 l2 = iListDupS(l); 15324 ck_assert(listIsEmptyS(l2)); 15325 free(l); 15326 listFreeS(l2); 15327 // NULL list 15328 ck_assert_ptr_eq(iListDupS(NULL), NULL); 15329 15330 END_TEST 15331 15332 15333 START_TEST(listReverseST) 15334 15335 char **l = NULL; 15336 char **l2; 15337 char **r = null; 15338 15339 // list 15340 r = listPushS(&l, "1"); 15341 ck_assert_ptr_eq(r, l); 15342 r = listPushS(&l, "22"); 15343 ck_assert_ptr_eq(r, l); 15344 r = listPushS(&l, "333"); 15345 ck_assert_ptr_eq(r, l); 15346 r = listPushS(&l, "4444"); 15347 ck_assert_ptr_eq(r, l); 15348 l2 = listReverseS(l); 15349 ck_assert_uint_eq(listLengthS(l2),4); 15350 ck_assert_str_eq(l2[0], "4444"); 15351 ck_assert_str_eq(l2[3], "1"); 15352 listFreeS(l); 15353 listFreeS(l2); 15354 // empty list 15355 listEmptyS(l) 15356 l2 = listReverseS(l); 15357 ck_assert(listIsEmptyS(l2)); 15358 listFreeS(l); 15359 listFreeS(l2); 15360 // NULL list 15361 ck_assert_ptr_eq(listReverseS(NULL), NULL); 15362 15363 END_TEST 15364 15365 15366 START_TEST(iListReverseST) 15367 15368 char **l = NULL; 15369 char **r = null; 15370 15371 // list 15372 r = listPushS(&l, "1"); 15373 ck_assert_ptr_eq(r, l); 15374 r = listPushS(&l, "22"); 15375 ck_assert_ptr_eq(r, l); 15376 r = listPushS(&l, "333"); 15377 ck_assert_ptr_eq(r, l); 15378 r = listPushS(&l, "4444"); 15379 ck_assert_ptr_eq(r, l); 15380 r = iListReverseS(&l); 15381 ck_assert_ptr_eq(r, l); 15382 ck_assert_uint_eq(listLengthS(l),4); 15383 ck_assert_str_eq(l[0], "4444"); 15384 ck_assert_str_eq(l[3], "1"); 15385 listFreeS(l); 15386 // empty list 15387 listEmptyS(l) 15388 r = iListReverseS(&l); 15389 ck_assert_ptr_eq(r, l); 15390 ck_assert(listIsEmptyS(l)); 15391 listFreeS(l); 15392 // NULL list 15393 l = NULL; 15394 r = iListReverseS(&l); 15395 ck_assert_ptr_eq(r, l); 15396 ck_assert_ptr_eq(l, NULL); 15397 // NULL var 15398 r = iListReverseS(NULL); 15399 ck_assert_ptr_eq(r, null); 15400 15401 END_TEST 15402 15403 15404 START_TEST(listCatST) 15405 15406 char **l; 15407 char **l2; 15408 char **r; 15409 15410 // cat lists 15411 l = listCreateS("#@#","1"); 15412 l2 = listCreateS("lib","sheepy"); 15413 r = listCatS(l,l2); 15414 ck_assert_str_eq(r[0], "#@#"); 15415 ck_assert_str_eq(r[1], "1"); 15416 ck_assert_str_eq(r[2], "lib"); 15417 ck_assert_str_eq(r[3], "sheepy"); 15418 listFreeManyS(l,l2,r); 15419 // empty list 15420 listEmptyS(l); 15421 r = listCatS(l); 15422 ck_assert(listIsEmptyS(r)); 15423 listFreeManyS(r,l); 15424 // cat empty list with list 15425 listEmptyS(l); 15426 l2 = listCreateS("lib","sheepy"); 15427 r = listCatS(l, l2); 15428 ck_assert_str_eq(r[0], "lib"); 15429 ck_assert_str_eq(r[1], "sheepy"); 15430 listFreeManyS(l,l2,r); 15431 15432 END_TEST 15433 15434 15435 START_TEST(listAppendST) 15436 15437 char **l = NULL; 15438 char **l2 = NULL; 15439 char **r = null; 15440 15441 // lists 15442 r = listPushS(&l, "1"); 15443 ck_assert_ptr_eq(r, l); 15444 r = listPushS(&l, "22"); 15445 ck_assert_ptr_eq(r, l); 15446 r = listPushS(&l, "333"); 15447 ck_assert_ptr_eq(r, l); 15448 r = listPushS(&l, "4444"); 15449 ck_assert_ptr_eq(r, l); 15450 r = listPushS(&l2, "A"); 15451 ck_assert_ptr_eq(r, l2); 15452 r = listPushS(&l2, "BB"); 15453 ck_assert_ptr_eq(r, l2); 15454 r = listPushS(&l2, "CCC"); 15455 ck_assert_ptr_eq(r, l2); 15456 r = listPushS(&l2, "DDDD"); 15457 ck_assert_ptr_eq(r, l2); 15458 r = listAppendS(&l2,l); 15459 ck_assert_ptr_eq(r, l2); 15460 ck_assert_uint_eq(listLengthS(l2),8); 15461 ck_assert_str_eq(l2[0], "A"); 15462 ck_assert_str_eq(l2[3], "DDDD"); 15463 ck_assert_str_eq(l2[4],"1"); 15464 ck_assert_str_eq(l2[7],"4444"); 15465 listFreeS(l); 15466 l = NULL; 15467 r = listPushS(&l, "1"); 15468 ck_assert_ptr_eq(r, l); 15469 r = listPushS(&l, "22"); 15470 ck_assert_ptr_eq(r, l); 15471 r = listPushS(&l, "333"); 15472 ck_assert_ptr_eq(r, l); 15473 r = listPushS(&l, "4444"); 15474 ck_assert_ptr_eq(r, l); 15475 r = listAppendS(&l,l); 15476 ck_assert_ptr_eq(r, l); 15477 ck_assert_uint_eq(listLengthS(l),8); 15478 ck_assert_str_eq(l[0], "1"); 15479 ck_assert_str_eq(l[3], "4444"); 15480 ck_assert_str_eq(l[4],"1"); 15481 ck_assert_str_eq(l[7],"4444"); 15482 listFreeS(l); 15483 // empty list + list 15484 listEmptyS(l) 15485 r = listAppendS(&l, l2); 15486 ck_assert_ptr_eq(r, l); 15487 ck_assert(listEqS(l,l2)); 15488 listFreeS(l); 15489 // list + empty list 15490 listEmptyS(l) 15491 r = listAppendS(&l2, l); 15492 ck_assert_ptr_eq(r, l2); 15493 ck_assert_uint_eq(listLengthS(l2),8); 15494 ck_assert_str_eq(l2[0], "A"); 15495 ck_assert_str_eq(l2[3], "DDDD"); 15496 ck_assert_str_eq(l2[4],"1"); 15497 ck_assert_str_eq(l2[7],"4444"); 15498 listFreeS(l); 15499 // empty list + empty list 15500 listEmptyS(l) 15501 r = listAppendS(&l, l); 15502 ck_assert_ptr_eq(r, l); 15503 ck_assert(listIsEmptyS(l)); 15504 listFreeS(l); 15505 // NULL list + list = duplicate 15506 l = NULL; 15507 r = listAppendS(&l,l2); 15508 ck_assert_ptr_eq(r, l); 15509 ck_assert(listEqS(l,l2)); 15510 listFreeS(l); 15511 // list + NULL list 15512 r = listAppendS(&l2, NULL); 15513 ck_assert_ptr_eq(r, l2); 15514 ck_assert_uint_eq(listLengthS(l2),8); 15515 ck_assert_str_eq(l2[0], "A"); 15516 ck_assert_str_eq(l2[3], "DDDD"); 15517 ck_assert_str_eq(l2[4],"1"); 15518 ck_assert_str_eq(l2[7],"4444"); 15519 listFreeS(l2); 15520 // NULL list pointer 15521 r = listAppendS(NULL,l2); 15522 ck_assert_ptr_eq(r, null); 15523 // should not crash 15524 15525 END_TEST 15526 15527 15528 START_TEST(iListAppendST) 15529 15530 char **l = NULL; 15531 char **l2 = NULL; 15532 char **r = null; 15533 15534 // lists 15535 r = listPushS(&l, "1"); 15536 ck_assert_ptr_eq(r, l); 15537 r = listPushS(&l, "22"); 15538 ck_assert_ptr_eq(r, l); 15539 r = listPushS(&l, "333"); 15540 ck_assert_ptr_eq(r, l); 15541 r = listPushS(&l, "4444"); 15542 ck_assert_ptr_eq(r, l); 15543 r = listPushS(&l2, "A"); 15544 ck_assert_ptr_eq(r, l2); 15545 r = listPushS(&l2, "BB"); 15546 ck_assert_ptr_eq(r, l2); 15547 r = listPushS(&l2, "CCC"); 15548 ck_assert_ptr_eq(r, l2); 15549 r = listPushS(&l2, "DDDD"); 15550 ck_assert_ptr_eq(r, l2); 15551 r = iListAppendS(&l2,l); 15552 ck_assert_ptr_eq(r, l2); 15553 ck_assert_uint_eq(listLengthS(l2),8); 15554 ck_assert_str_eq(l2[0], "A"); 15555 ck_assert_str_eq(l2[3], "DDDD"); 15556 ck_assert_str_eq(l2[4],"1"); 15557 ck_assert_str_eq(l2[7],"4444"); 15558 free(l); 15559 l = NULL; 15560 r = listPushS(&l, "1"); 15561 ck_assert_ptr_eq(r, l); 15562 r = listPushS(&l, "22"); 15563 ck_assert_ptr_eq(r, l); 15564 r = listPushS(&l, "333"); 15565 ck_assert_ptr_eq(r, l); 15566 r = listPushS(&l, "4444"); 15567 ck_assert_ptr_eq(r, l); 15568 r = iListAppendS(&l,l); 15569 ck_assert_ptr_eq(r, null); 15570 ck_assert_uint_eq(listLengthS(l),4); 15571 ck_assert_str_eq(l[0], "1"); 15572 ck_assert_str_eq(l[3], "4444"); 15573 listFreeS(l); 15574 // empty list + list 15575 listEmptyS(l) 15576 r = iListAppendS(&l, l2); 15577 ck_assert_ptr_eq(r, l); 15578 ck_assert(listEqS(l,l2)); 15579 free(l2); 15580 listFreeS(l); 15581 // list + empty list 15582 l2 = NULL; 15583 r = listPushS(&l2, "A"); 15584 ck_assert_ptr_eq(r, l2); 15585 r = listPushS(&l2, "BB"); 15586 ck_assert_ptr_eq(r, l2); 15587 r = listPushS(&l2, "CCC"); 15588 ck_assert_ptr_eq(r, l2); 15589 r = listPushS(&l2, "DDDD"); 15590 ck_assert_ptr_eq(r, l2); 15591 r = listPushS(&l2, "1"); 15592 ck_assert_ptr_eq(r, l2); 15593 r = listPushS(&l2, "22"); 15594 ck_assert_ptr_eq(r, l2); 15595 r = listPushS(&l2, "333"); 15596 ck_assert_ptr_eq(r, l2); 15597 r = listPushS(&l2, "4444"); 15598 ck_assert_ptr_eq(r, l2); 15599 listEmptyS(l) 15600 r = iListAppendS(&l2, l); 15601 ck_assert_ptr_eq(r, l2); 15602 ck_assert_uint_eq(listLengthS(l2),8); 15603 ck_assert_str_eq(l2[0], "A"); 15604 ck_assert_str_eq(l2[3], "DDDD"); 15605 ck_assert_str_eq(l2[4],"1"); 15606 ck_assert_str_eq(l2[7],"4444"); 15607 free(l); 15608 listFreeS(l2); 15609 // empty list + empty list 15610 listEmptyS(l); 15611 listEmptyS(l2); 15612 r = iListAppendS(&l, l2); 15613 ck_assert_ptr_eq(r, l); 15614 ck_assert(listIsEmptyS(l)); 15615 listFreeS(l); 15616 listFreeS(l2); 15617 // NULL list + list = duplicate 15618 l = NULL; 15619 l2 = NULL; 15620 r = listPushS(&l2, "A"); 15621 ck_assert_ptr_eq(r, l2); 15622 r = listPushS(&l2, "BB"); 15623 ck_assert_ptr_eq(r, l2); 15624 r = listPushS(&l2, "CCC"); 15625 ck_assert_ptr_eq(r, l2); 15626 r = listPushS(&l2, "DDDD"); 15627 ck_assert_ptr_eq(r, l2); 15628 r = iListAppendS(&l,l2); 15629 ck_assert_ptr_eq(r, l); 15630 ck_assert(listEqS(l,l2)); 15631 free(l); 15632 // list + NULL list 15633 r = iListAppendS(&l2, NULL); 15634 ck_assert_ptr_eq(r, l2); 15635 ck_assert_uint_eq(listLengthS(l2),4); 15636 ck_assert_str_eq(l2[0], "A"); 15637 ck_assert_str_eq(l2[3], "DDDD"); 15638 listFreeS(l2); 15639 // NULL list pointer 15640 r = iListAppendS(NULL,l2); 15641 ck_assert_ptr_eq(r, null); 15642 // should not crash 15643 15644 END_TEST 15645 15646 15647 START_TEST(iListAppendNSmashST) 15648 15649 char **l = NULL; 15650 char **l2 = NULL; 15651 char **r = null; 15652 15653 // lists 15654 r = listPushS(&l, "1"); 15655 ck_assert_ptr_eq(r, l); 15656 r = listPushS(&l, "22"); 15657 ck_assert_ptr_eq(r, l); 15658 r = listPushS(&l, "333"); 15659 ck_assert_ptr_eq(r, l); 15660 r = listPushS(&l, "4444"); 15661 ck_assert_ptr_eq(r, l); 15662 r = listPushS(&l2, "A"); 15663 ck_assert_ptr_eq(r, l2); 15664 r = listPushS(&l2, "BB"); 15665 ck_assert_ptr_eq(r, l2); 15666 r = listPushS(&l2, "CCC"); 15667 ck_assert_ptr_eq(r, l2); 15668 r = listPushS(&l2, "DDDD"); 15669 ck_assert_ptr_eq(r, l2); 15670 r = iListAppendNSmashS(&l2,l); 15671 ck_assert_ptr_eq(r, l2); 15672 ck_assert_uint_eq(listLengthS(l2),8); 15673 ck_assert_str_eq(l2[0], "A"); 15674 ck_assert_str_eq(l2[3], "DDDD"); 15675 ck_assert_str_eq(l2[4],"1"); 15676 ck_assert_str_eq(l2[7],"4444"); 15677 l = NULL; 15678 r = listPushS(&l, "1"); 15679 ck_assert_ptr_eq(r, l); 15680 r = listPushS(&l, "22"); 15681 ck_assert_ptr_eq(r, l); 15682 r = listPushS(&l, "333"); 15683 ck_assert_ptr_eq(r, l); 15684 r = listPushS(&l, "4444"); 15685 ck_assert_ptr_eq(r, l); 15686 r = iListAppendNSmashS(&l,l); 15687 ck_assert_ptr_eq(r, null); 15688 ck_assert_uint_eq(listLengthS(l),4); 15689 ck_assert_str_eq(l[0], "1"); 15690 ck_assert_str_eq(l[3], "4444"); 15691 listFreeS(l); 15692 // empty list + list 15693 listEmptyS(l) 15694 r = iListAppendNSmashS(&l, l2); 15695 ck_assert_ptr_eq(r, l); 15696 ck_assert_str_eq(l[0], "A"); 15697 ck_assert_str_eq(l[3], "DDDD"); 15698 ck_assert_str_eq(l[4],"1"); 15699 ck_assert_str_eq(l[7],"4444"); 15700 listFreeS(l); 15701 // list + empty list 15702 l2 = NULL; 15703 r = listPushS(&l2, "A"); 15704 ck_assert_ptr_eq(r, l2); 15705 r = listPushS(&l2, "BB"); 15706 ck_assert_ptr_eq(r, l2); 15707 r = listPushS(&l2, "CCC"); 15708 ck_assert_ptr_eq(r, l2); 15709 r = listPushS(&l2, "DDDD"); 15710 ck_assert_ptr_eq(r, l2); 15711 r = listPushS(&l2, "1"); 15712 ck_assert_ptr_eq(r, l2); 15713 r = listPushS(&l2, "22"); 15714 ck_assert_ptr_eq(r, l2); 15715 r = listPushS(&l2, "333"); 15716 ck_assert_ptr_eq(r, l2); 15717 r = listPushS(&l2, "4444"); 15718 ck_assert_ptr_eq(r, l2); 15719 listEmptyS(l) 15720 r = iListAppendNSmashS(&l2, l); 15721 ck_assert_ptr_eq(r, l2); 15722 ck_assert_uint_eq(listLengthS(l2),8); 15723 ck_assert_str_eq(l2[0], "A"); 15724 ck_assert_str_eq(l2[3], "DDDD"); 15725 ck_assert_str_eq(l2[4],"1"); 15726 ck_assert_str_eq(l2[7],"4444"); 15727 listFreeS(l2); 15728 // empty list + empty list 15729 listEmptyS(l); 15730 listEmptyS(l2); 15731 r = iListAppendNSmashS(&l, l2); 15732 ck_assert_ptr_eq(r, l); 15733 ck_assert(listIsEmptyS(l)); 15734 listFreeS(l); 15735 // NULL list + list = duplicate 15736 l = NULL; 15737 l2 = NULL; 15738 r = listPushS(&l2, "A"); 15739 ck_assert_ptr_eq(r, l2); 15740 r = listPushS(&l2, "BB"); 15741 ck_assert_ptr_eq(r, l2); 15742 r = listPushS(&l2, "CCC"); 15743 ck_assert_ptr_eq(r, l2); 15744 r = listPushS(&l2, "DDDD"); 15745 ck_assert_ptr_eq(r, l2); 15746 r = iListAppendNSmashS(&l,l2); 15747 ck_assert_ptr_eq(r, l); 15748 ck_assert_str_eq(l[0], "A"); 15749 ck_assert_str_eq(l[1], "BB"); 15750 ck_assert_str_eq(l[2], "CCC"); 15751 ck_assert_str_eq(l[3], "DDDD"); 15752 // list + NULL list 15753 r = iListAppendNSmashS(&l, NULL); 15754 ck_assert_ptr_eq(r, l); 15755 ck_assert_uint_eq(listLengthS(l),4); 15756 ck_assert_str_eq(l[0], "A"); 15757 ck_assert_str_eq(l[3], "DDDD"); 15758 listFreeS(l); 15759 // NULL list pointer 15760 r = iListAppendNSmashS(NULL,l); 15761 ck_assert_ptr_eq(r, null); 15762 // should not crash 15763 15764 END_TEST 15765 15766 15767 START_TEST(listShiftST) 15768 15769 char **l = NULL; 15770 char **l2 = NULL; 15771 char **r = null; 15772 15773 // lists 15774 r = listPushS(&l, "1"); 15775 ck_assert_ptr_eq(r, l); 15776 r = listPushS(&l, "22"); 15777 ck_assert_ptr_eq(r, l); 15778 r = listPushS(&l, "333"); 15779 ck_assert_ptr_eq(r, l); 15780 r = listPushS(&l, "4444"); 15781 ck_assert_ptr_eq(r, l); 15782 r = listPushS(&l2, "A"); 15783 ck_assert_ptr_eq(r, l2); 15784 r = listPushS(&l2, "BB"); 15785 ck_assert_ptr_eq(r, l2); 15786 r = listPushS(&l2, "CCC"); 15787 ck_assert_ptr_eq(r, l2); 15788 r = listPushS(&l2, "DDDD"); 15789 ck_assert_ptr_eq(r, l2); 15790 r = listShiftS(&l2,l); 15791 ck_assert_ptr_eq(r, l2); 15792 ck_assert_uint_eq(listLengthS(l2),8); 15793 ck_assert_str_eq(l2[4], "A"); 15794 ck_assert_str_eq(l2[7], "DDDD"); 15795 ck_assert_str_eq(l2[0],"1"); 15796 ck_assert_str_eq(l2[3],"4444"); 15797 listFreeS(l); 15798 l = NULL; 15799 r = listPushS(&l, "1"); 15800 ck_assert_ptr_eq(r, l); 15801 r = listPushS(&l, "22"); 15802 ck_assert_ptr_eq(r, l); 15803 r = listPushS(&l, "333"); 15804 ck_assert_ptr_eq(r, l); 15805 r = listPushS(&l, "4444"); 15806 ck_assert_ptr_eq(r, l); 15807 r = listShiftS(&l,l); 15808 ck_assert_ptr_eq(r, l); 15809 ck_assert_uint_eq(listLengthS(l),8); 15810 ck_assert_str_eq(l[0], "1"); 15811 ck_assert_str_eq(l[3], "4444"); 15812 ck_assert_str_eq(l[4],"1"); 15813 ck_assert_str_eq(l[7],"4444"); 15814 listFreeS(l); 15815 // empty list + list 15816 listEmptyS(l) 15817 r = listShiftS(&l, l2); 15818 ck_assert_ptr_eq(r, l); 15819 ck_assert(listEqS(l,l2)); 15820 listFreeS(l); 15821 // list + empty list 15822 listEmptyS(l) 15823 r = listShiftS(&l2, l); 15824 ck_assert_ptr_eq(r, l2); 15825 ck_assert_uint_eq(listLengthS(l2),8); 15826 ck_assert_str_eq(l2[4], "A"); 15827 ck_assert_str_eq(l2[7], "DDDD"); 15828 ck_assert_str_eq(l2[0],"1"); 15829 ck_assert_str_eq(l2[3],"4444"); 15830 listFreeS(l); 15831 // empty list + empty list 15832 listEmptyS(l) 15833 r = listShiftS(&l, l); 15834 ck_assert_ptr_eq(r, l); 15835 ck_assert(listIsEmptyS(l)); 15836 listFreeS(l); 15837 // NULL list + list = duplicate 15838 l = NULL; 15839 r = listShiftS(&l,l2); 15840 ck_assert_ptr_eq(r, l); 15841 ck_assert(listEqS(l,l2)); 15842 listFreeS(l); 15843 // list + NULL list 15844 r = listShiftS(&l2, NULL); 15845 ck_assert_ptr_eq(r, l2); 15846 ck_assert_uint_eq(listLengthS(l2),8); 15847 ck_assert_str_eq(l2[4], "A"); 15848 ck_assert_str_eq(l2[7], "DDDD"); 15849 ck_assert_str_eq(l2[0],"1"); 15850 ck_assert_str_eq(l2[3],"4444"); 15851 listFreeS(l2); 15852 // NULL list pointer 15853 r = listShiftS(NULL,l2); 15854 ck_assert_ptr_eq(r, null); 15855 // should not crash 15856 15857 15858 END_TEST 15859 15860 15861 START_TEST(iListShiftST) 15862 15863 char **l = NULL; 15864 char **l2 = NULL; 15865 char **r = null; 15866 15867 // lists 15868 r = listPushS(&l, "1"); 15869 ck_assert_ptr_eq(r, l); 15870 r = listPushS(&l, "22"); 15871 ck_assert_ptr_eq(r, l); 15872 r = listPushS(&l, "333"); 15873 ck_assert_ptr_eq(r, l); 15874 r = listPushS(&l, "4444"); 15875 ck_assert_ptr_eq(r, l); 15876 r = listPushS(&l2, "A"); 15877 ck_assert_ptr_eq(r, l2); 15878 r = listPushS(&l2, "BB"); 15879 ck_assert_ptr_eq(r, l2); 15880 r = listPushS(&l2, "CCC"); 15881 ck_assert_ptr_eq(r, l2); 15882 r = listPushS(&l2, "DDDD"); 15883 ck_assert_ptr_eq(r, l2); 15884 r = iListShiftS(&l2,l); 15885 ck_assert_ptr_eq(r, l2); 15886 ck_assert_uint_eq(listLengthS(l2),8); 15887 ck_assert_str_eq(l2[4], "A"); 15888 ck_assert_str_eq(l2[7], "DDDD"); 15889 ck_assert_str_eq(l2[0],"1"); 15890 ck_assert_str_eq(l2[3],"4444"); 15891 free(l); 15892 l = NULL; 15893 r = listPushS(&l, "1"); 15894 ck_assert_ptr_eq(r, l); 15895 r = listPushS(&l, "22"); 15896 ck_assert_ptr_eq(r, l); 15897 r = listPushS(&l, "333"); 15898 ck_assert_ptr_eq(r, l); 15899 r = listPushS(&l, "4444"); 15900 ck_assert_ptr_eq(r, l); 15901 r = iListShiftS(&l,l); 15902 ck_assert_ptr_eq(r, null); 15903 ck_assert_uint_eq(listLengthS(l),4); 15904 ck_assert_str_eq(l[0], "1"); 15905 ck_assert_str_eq(l[3], "4444"); 15906 listFreeS(l); 15907 // empty list + list 15908 listEmptyS(l) 15909 r = iListShiftS(&l, l2); 15910 ck_assert_ptr_eq(r, l); 15911 ck_assert(listEqS(l,l2)); 15912 free(l2); 15913 listFreeS(l); 15914 // list + empty list 15915 l2 = NULL; 15916 r = listPushS(&l2, "A"); 15917 ck_assert_ptr_eq(r, l2); 15918 r = listPushS(&l2, "BB"); 15919 ck_assert_ptr_eq(r, l2); 15920 r = listPushS(&l2, "CCC"); 15921 ck_assert_ptr_eq(r, l2); 15922 r = listPushS(&l2, "DDDD"); 15923 ck_assert_ptr_eq(r, l2); 15924 r = listPushS(&l2, "1"); 15925 ck_assert_ptr_eq(r, l2); 15926 r = listPushS(&l2, "22"); 15927 ck_assert_ptr_eq(r, l2); 15928 r = listPushS(&l2, "333"); 15929 ck_assert_ptr_eq(r, l2); 15930 r = listPushS(&l2, "4444"); 15931 ck_assert_ptr_eq(r, l2); 15932 listEmptyS(l) 15933 r = iListShiftS(&l2, l); 15934 ck_assert_ptr_eq(r, l2); 15935 ck_assert_uint_eq(listLengthS(l2),8); 15936 ck_assert_str_eq(l2[0], "A"); 15937 ck_assert_str_eq(l2[3], "DDDD"); 15938 ck_assert_str_eq(l2[4],"1"); 15939 ck_assert_str_eq(l2[7],"4444"); 15940 free(l); 15941 listFreeS(l2); 15942 // empty list + empty list 15943 listEmptyS(l); 15944 listEmptyS(l2); 15945 r = iListShiftS(&l, l2); 15946 ck_assert_ptr_eq(r, l); 15947 ck_assert(listIsEmptyS(l)); 15948 listFreeS(l); 15949 listFreeS(l2); 15950 // NULL list + list = duplicate 15951 l = NULL; 15952 l2 = NULL; 15953 r = listPushS(&l2, "A"); 15954 ck_assert_ptr_eq(r, l2); 15955 r = listPushS(&l2, "BB"); 15956 ck_assert_ptr_eq(r, l2); 15957 r = listPushS(&l2, "CCC"); 15958 ck_assert_ptr_eq(r, l2); 15959 r = listPushS(&l2, "DDDD"); 15960 ck_assert_ptr_eq(r, l2); 15961 r = iListShiftS(&l,l2); 15962 ck_assert_ptr_eq(r, l); 15963 ck_assert(listEqS(l,l2)); 15964 free(l); 15965 // list + NULL list 15966 r = iListShiftS(&l2, NULL); 15967 ck_assert_ptr_eq(r, null); 15968 ck_assert_uint_eq(listLengthS(l2),4); 15969 ck_assert_str_eq(l2[0], "A"); 15970 ck_assert_str_eq(l2[3], "DDDD"); 15971 listFreeS(l2); 15972 // NULL list pointer 15973 r = iListShiftS(NULL,l2); 15974 ck_assert_ptr_eq(r, null); 15975 // should not crash 15976 15977 15978 END_TEST 15979 15980 15981 START_TEST(iListShiftNSmashST) 15982 15983 char **l = NULL; 15984 char **l2 = NULL; 15985 char **r = null; 15986 15987 // lists 15988 r = listPushS(&l, "1"); 15989 ck_assert_ptr_eq(r, l); 15990 r = listPushS(&l, "22"); 15991 ck_assert_ptr_eq(r, l); 15992 r = listPushS(&l, "333"); 15993 ck_assert_ptr_eq(r, l); 15994 r = listPushS(&l, "4444"); 15995 ck_assert_ptr_eq(r, l); 15996 r = listPushS(&l2, "A"); 15997 ck_assert_ptr_eq(r, l2); 15998 r = listPushS(&l2, "BB"); 15999 ck_assert_ptr_eq(r, l2); 16000 r = listPushS(&l2, "CCC"); 16001 ck_assert_ptr_eq(r, l2); 16002 r = listPushS(&l2, "DDDD"); 16003 ck_assert_ptr_eq(r, l2); 16004 r = iListShiftNSmashS(&l2,l); 16005 ck_assert_ptr_eq(r, l2); 16006 ck_assert_uint_eq(listLengthS(l2),8); 16007 ck_assert_str_eq(l2[4], "A"); 16008 ck_assert_str_eq(l2[7], "DDDD"); 16009 ck_assert_str_eq(l2[0],"1"); 16010 ck_assert_str_eq(l2[3],"4444"); 16011 l = NULL; 16012 r = listPushS(&l, "1"); 16013 ck_assert_ptr_eq(r, l); 16014 r = listPushS(&l, "22"); 16015 ck_assert_ptr_eq(r, l); 16016 r = listPushS(&l, "333"); 16017 ck_assert_ptr_eq(r, l); 16018 r = listPushS(&l, "4444"); 16019 ck_assert_ptr_eq(r, l); 16020 r = iListShiftNSmashS(&l,l); 16021 ck_assert_ptr_eq(r, null); 16022 ck_assert_uint_eq(listLengthS(l),4); 16023 ck_assert_str_eq(l[0], "1"); 16024 ck_assert_str_eq(l[3], "4444"); 16025 listFreeS(l); 16026 // empty list + list 16027 listEmptyS(l) 16028 r = iListShiftNSmashS(&l, l2); 16029 ck_assert_ptr_eq(r, l); 16030 ck_assert_str_eq(l[4], "A"); 16031 ck_assert_str_eq(l[7], "DDDD"); 16032 ck_assert_str_eq(l[0],"1"); 16033 ck_assert_str_eq(l[3],"4444"); 16034 listFreeS(l); 16035 // list + empty list 16036 l2 = NULL; 16037 r = listPushS(&l2, "A"); 16038 ck_assert_ptr_eq(r, l2); 16039 r = listPushS(&l2, "BB"); 16040 ck_assert_ptr_eq(r, l2); 16041 r = listPushS(&l2, "CCC"); 16042 ck_assert_ptr_eq(r, l2); 16043 r = listPushS(&l2, "DDDD"); 16044 ck_assert_ptr_eq(r, l2); 16045 r = listPushS(&l2, "1"); 16046 ck_assert_ptr_eq(r, l2); 16047 r = listPushS(&l2, "22"); 16048 ck_assert_ptr_eq(r, l2); 16049 r = listPushS(&l2, "333"); 16050 ck_assert_ptr_eq(r, l2); 16051 r = listPushS(&l2, "4444"); 16052 ck_assert_ptr_eq(r, l2); 16053 listEmptyS(l) 16054 r = iListShiftNSmashS(&l2, l); 16055 ck_assert_ptr_eq(r, l2); 16056 ck_assert_uint_eq(listLengthS(l2),8); 16057 ck_assert_str_eq(l2[0], "A"); 16058 ck_assert_str_eq(l2[3], "DDDD"); 16059 ck_assert_str_eq(l2[4],"1"); 16060 ck_assert_str_eq(l2[7],"4444"); 16061 listFreeS(l2); 16062 // empty list + empty list 16063 listEmptyS(l); 16064 listEmptyS(l2); 16065 r = iListShiftNSmashS(&l, l2); 16066 ck_assert_ptr_eq(r, l); 16067 ck_assert(listIsEmptyS(l)); 16068 listFreeS(l); 16069 // NULL list + list = duplicate 16070 l = NULL; 16071 l2 = NULL; 16072 r = listPushS(&l2, "A"); 16073 ck_assert_ptr_eq(r, l2); 16074 r = listPushS(&l2, "BB"); 16075 ck_assert_ptr_eq(r, l2); 16076 r = listPushS(&l2, "CCC"); 16077 ck_assert_ptr_eq(r, l2); 16078 r = listPushS(&l2, "DDDD"); 16079 ck_assert_ptr_eq(r, l2); 16080 r = iListShiftNSmashS(&l,l2); 16081 ck_assert_ptr_eq(r, l); 16082 ck_assert_str_eq(l[0], "A"); 16083 ck_assert_str_eq(l[1], "BB"); 16084 ck_assert_str_eq(l[2], "CCC"); 16085 ck_assert_str_eq(l[3], "DDDD"); 16086 // list + NULL list 16087 r = iListShiftNSmashS(&l, NULL); 16088 ck_assert_ptr_eq(r, null); 16089 ck_assert_uint_eq(listLengthS(l),4); 16090 ck_assert_str_eq(l[0], "A"); 16091 ck_assert_str_eq(l[3], "DDDD"); 16092 listFreeS(l); 16093 // NULL list pointer 16094 r = iListShiftNSmashS(NULL,l); 16095 ck_assert_ptr_eq(r, null); 16096 // should not crash 16097 16098 16099 END_TEST 16100 16101 16102 START_TEST(listAddST) 16103 16104 char **l = NULL; 16105 char **l2 = NULL; 16106 char **l3; 16107 char **r = null; 16108 16109 // lists 16110 r = listPushS(&l, "1"); 16111 ck_assert_ptr_eq(r, l); 16112 r = listPushS(&l, "22"); 16113 ck_assert_ptr_eq(r, l); 16114 r = listPushS(&l, "333"); 16115 ck_assert_ptr_eq(r, l); 16116 r = listPushS(&l, "4444"); 16117 ck_assert_ptr_eq(r, l); 16118 r = listPushS(&l2, "A"); 16119 ck_assert_ptr_eq(r, l2); 16120 r = listPushS(&l2, "BB"); 16121 ck_assert_ptr_eq(r, l2); 16122 r = listPushS(&l2, "CCC"); 16123 ck_assert_ptr_eq(r, l2); 16124 r = listPushS(&l2, "DDDD"); 16125 ck_assert_ptr_eq(r, l2); 16126 l3 = listAddS(l2,l); 16127 ck_assert_uint_eq(listLengthS(l3),8); 16128 ck_assert_str_eq(l3[0], "A"); 16129 ck_assert_str_eq(l3[3], "DDDD"); 16130 ck_assert_str_eq(l3[4],"1"); 16131 ck_assert_str_eq(l3[7],"4444"); 16132 listFreeS(l3); 16133 listFreeS(l); 16134 // empty list + list 16135 listEmptyS(l) 16136 l3 = listAddS(l, l2); 16137 ck_assert(listEqS(l3,l2)); 16138 listFreeS(l3); 16139 listFreeS(l); 16140 // list + empty list 16141 listEmptyS(l) 16142 l3 = listAddS(l2, l); 16143 ck_assert(listEqS(l3,l2)); 16144 listFreeS(l3); 16145 listFreeS(l); 16146 // empty list + empty list 16147 listEmptyS(l) 16148 l3 = listAddS(l, l); 16149 ck_assert(listIsEmptyS(l3)); 16150 listFreeS(l3); 16151 listFreeS(l); 16152 // NULL list + list 16153 l3 = listAddS(NULL,l2); 16154 ck_assert(listEqS(l3,l2)); 16155 listFreeS(l3); 16156 // list + NULL list 16157 l3 = listAddS(l2, NULL); 16158 ck_assert(listEqS(l3,l2)); 16159 listFreeS(l3); 16160 listFreeS(l2); 16161 // NULL list + NULL list 16162 ck_assert_ptr_eq(listAddS(NULL,NULL), NULL); 16163 16164 END_TEST 16165 16166 16167 START_TEST(listSliceST) 16168 16169 char **l = NULL; 16170 char **l2; 16171 char **r = null; 16172 16173 // list negative index 16174 r = listPushS(&l, "1"); 16175 ck_assert_ptr_eq(r, l); 16176 r = listPushS(&l, "22"); 16177 ck_assert_ptr_eq(r, l); 16178 r = listPushS(&l, "333"); 16179 ck_assert_ptr_eq(r, l); 16180 r = listPushS(&l, "4444"); 16181 ck_assert_ptr_eq(r, l); 16182 l2 = listSliceS(l, 1,-1); 16183 ck_assert_uint_eq(listLengthS(l2),2); 16184 ck_assert_str_eq(l2[0], "22"); 16185 ck_assert_str_eq(l2[1], "333"); 16186 listFreeS(l2); 16187 // start outside 16188 ck_assert_ptr_eq(listSliceS(l, 20,-4), NULL); 16189 // end outside 16190 l2 = listSliceS(l, 2,40); 16191 ck_assert_uint_eq(listLengthS(l2),2); 16192 ck_assert_str_eq(l2[0], "333"); 16193 ck_assert_str_eq(l2[1], "4444"); 16194 listFreeS(l2); 16195 // end negative and outside 16196 ck_assert_ptr_eq(listSliceS(l, 2,-40), NULL); 16197 // end before start 16198 ck_assert_ptr_eq(listSliceS(l, 3,2), NULL); 16199 listFreeS(l); 16200 // negative start last element 16201 l = NULL; 16202 r = listPushS(&l, "1"); 16203 ck_assert_ptr_eq(r, l); 16204 r = listPushS(&l, "22"); 16205 ck_assert_ptr_eq(r, l); 16206 l2 = listSliceS(l, -1,0); 16207 ck_assert_uint_eq(listLengthS(l2),1); 16208 ck_assert_str_eq(l2[0], "22"); 16209 listFreeS(l); 16210 listFreeS(l2); 16211 // start = end 16212 l = NULL; 16213 r = listPushS(&l, "1"); 16214 ck_assert_ptr_eq(r, l); 16215 r = listPushS(&l, "22"); 16216 ck_assert_ptr_eq(r, l); 16217 l2 = listSliceS(l, 1,1); 16218 ck_assert_uint_eq(listLengthS(l2),0); 16219 ck_assert_ptr_eq(l2[0], NULL); 16220 listFreeS(l); 16221 listFreeS(l2); 16222 // empty list 16223 listEmptyS(l) 16224 ck_assert_ptr_eq(listSliceS(l, 0,0), NULL); 16225 ck_assert_ptr_eq(listSliceS(l, -1,0), NULL); 16226 listFreeS(l); 16227 // NULL list 16228 ck_assert_ptr_eq(listSliceS(NULL, 2,-4), NULL); 16229 16230 16231 END_TEST 16232 16233 16234 START_TEST(iListCopyST) 16235 16236 char **l = NULL; 16237 char **l2; 16238 char **r = null; 16239 16240 // list negative index 16241 r = listPushS(&l, "1"); 16242 ck_assert_ptr_eq(r, l); 16243 r = listPushS(&l, "22"); 16244 ck_assert_ptr_eq(r, l); 16245 r = listPushS(&l, "333"); 16246 ck_assert_ptr_eq(r, l); 16247 r = listPushS(&l, "4444"); 16248 ck_assert_ptr_eq(r, l); 16249 l2 = iListCopyS(l, 1,-1); 16250 ck_assert_uint_eq(listLengthS(l2),2); 16251 ck_assert_str_eq(l2[0], "22"); 16252 ck_assert_str_eq(l2[1], "333"); 16253 free(l2); 16254 listFreeS(l); 16255 // start outside 16256 l = NULL; 16257 r = listPushS(&l, "1"); 16258 ck_assert_ptr_eq(r, l); 16259 r = listPushS(&l, "22"); 16260 ck_assert_ptr_eq(r, l); 16261 r = listPushS(&l, "333"); 16262 ck_assert_ptr_eq(r, l); 16263 r = listPushS(&l, "4444"); 16264 ck_assert_ptr_eq(r, l); 16265 ck_assert_ptr_eq(iListCopyS(l, 20,-4), NULL); 16266 // end outside 16267 l2 = iListCopyS(l, 2,40); 16268 ck_assert_uint_eq(listLengthS(l2),2); 16269 ck_assert_str_eq(l2[0], "333"); 16270 ck_assert_str_eq(l2[1], "4444"); 16271 free(l2); 16272 listFreeS(l); 16273 // end negative and outside 16274 l = NULL; 16275 r = listPushS(&l, "1"); 16276 ck_assert_ptr_eq(r, l); 16277 r = listPushS(&l, "22"); 16278 ck_assert_ptr_eq(r, l); 16279 r = listPushS(&l, "333"); 16280 ck_assert_ptr_eq(r, l); 16281 r = listPushS(&l, "4444"); 16282 ck_assert_ptr_eq(r, l); 16283 ck_assert_ptr_eq(iListCopyS(l, 2,-40), NULL); 16284 // end before start 16285 ck_assert_ptr_eq(iListCopyS(l, 3,2), NULL); 16286 listFreeS(l); 16287 // negative start last element 16288 l = NULL; 16289 r = listPushS(&l, "1"); 16290 ck_assert_ptr_eq(r, l); 16291 r = listPushS(&l, "22"); 16292 ck_assert_ptr_eq(r, l); 16293 l2 = iListCopyS(l, -1,0); 16294 ck_assert_uint_eq(listLengthS(l2),1); 16295 ck_assert_str_eq(l2[0], "22"); 16296 free(l2); 16297 listFreeS(l); 16298 // start = end 16299 l = NULL; 16300 r = listPushS(&l, "1"); 16301 ck_assert_ptr_eq(r, l); 16302 r = listPushS(&l, "22"); 16303 ck_assert_ptr_eq(r, l); 16304 l2 = iListCopyS(l, 1,1); 16305 ck_assert_uint_eq(listLengthS(l2),0); 16306 ck_assert_ptr_eq(l2[0], NULL); 16307 free(l2); 16308 listFreeS(l); 16309 // empty list 16310 listEmptyS(l) 16311 ck_assert_ptr_eq(iListCopyS(l, 0,0), NULL); 16312 ck_assert_ptr_eq(iListCopyS(l, -1,0), NULL); 16313 listFreeS(l); 16314 // NULL list 16315 ck_assert_ptr_eq(iListCopyS(NULL, 2,-4), NULL); 16316 16317 16318 END_TEST 16319 16320 16321 START_TEST(iListSliceST) 16322 16323 char **l = NULL; 16324 char **r = null; 16325 16326 // list negative index 16327 r = listPushS(&l, "1"); 16328 ck_assert_ptr_eq(r, l); 16329 r = listPushS(&l, "22"); 16330 ck_assert_ptr_eq(r, l); 16331 r = listPushS(&l, "333"); 16332 ck_assert_ptr_eq(r, l); 16333 r = listPushS(&l, "4444"); 16334 ck_assert_ptr_eq(r, l); 16335 r = iListSliceS(&l, 1,-1); 16336 ck_assert_ptr_eq(r, l); 16337 ck_assert_uint_eq(listLengthS(l),2); 16338 ck_assert_str_eq(l[0], "22"); 16339 ck_assert_str_eq(l[1], "333"); 16340 // start outside 16341 r = listPushS(&l, "1"); 16342 ck_assert_ptr_eq(r, l); 16343 r = listPushS(&l, "22"); 16344 ck_assert_ptr_eq(r, l); 16345 r = iListSliceS(&l, 20,-4); 16346 ck_assert_ptr_eq(r, null); 16347 ck_assert_uint_eq(listLengthS(l),0); 16348 // end outside 16349 r = iListSliceS(&l, 2,40); 16350 ck_assert_ptr_eq(r, null); 16351 ck_assert_uint_eq(listLengthS(l),0); 16352 // end negative and outside 16353 r = iListSliceS(&l, 2,-40); 16354 ck_assert_ptr_eq(r, null); 16355 ck_assert_uint_eq(listLengthS(l),0); 16356 // end before start 16357 r = listPushS(&l, "333"); 16358 ck_assert_ptr_eq(r, l); 16359 r = listPushS(&l, "4444"); 16360 ck_assert_ptr_eq(r, l); 16361 r = listPushS(&l, "55555"); 16362 ck_assert_ptr_eq(r, l); 16363 r = iListSliceS(&l, 3,2); 16364 ck_assert_ptr_eq(r, null); 16365 ck_assert_uint_eq(listLengthS(l),0); 16366 listFreeS(l); 16367 // negative start last element 16368 l = NULL; 16369 r = listPushS(&l, "1"); 16370 ck_assert_ptr_eq(r, l); 16371 r = listPushS(&l, "22"); 16372 ck_assert_ptr_eq(r, l); 16373 r = iListSliceS(&l, -1,0); 16374 ck_assert_ptr_eq(r, l); 16375 ck_assert_uint_eq(listLengthS(l),1); 16376 ck_assert_str_eq(l[0], "22"); 16377 listFreeS(l); 16378 // start = end 16379 l = NULL; 16380 r = listPushS(&l, "1"); 16381 ck_assert_ptr_eq(r, l); 16382 r = listPushS(&l, "22"); 16383 ck_assert_ptr_eq(r, l); 16384 r = iListSliceS(&l, 1,1); 16385 ck_assert_ptr_eq(r, l); 16386 ck_assert_uint_eq(listLengthS(l),0); 16387 ck_assert_ptr_eq(l[0], NULL); 16388 listFreeS(l); 16389 // empty list 16390 listEmptyS(l) 16391 r = iListSliceS(&l, 0,0); 16392 ck_assert_ptr_eq(r, null); 16393 ck_assert(listIsEmptyS(l)); 16394 r = iListSliceS(&l, -1,0); 16395 ck_assert_ptr_eq(r, null); 16396 ck_assert(listIsEmptyS(l)); 16397 listFreeS(l); 16398 // NULL list 16399 l = NULL; 16400 r = iListSliceS(&l, 2,-4); 16401 ck_assert_ptr_eq(r, null); 16402 // NULL var 16403 r = iListSliceS(NULL, 2,-4); 16404 ck_assert_ptr_eq(r, null); 16405 16406 16407 END_TEST 16408 16409 16410 START_TEST(listCropST) 16411 16412 char **l = NULL; 16413 char **l2; 16414 char **r = null; 16415 16416 // list negative index 16417 r = listPushS(&l, "1"); 16418 ck_assert_ptr_eq(r, l); 16419 r = listPushS(&l, "22"); 16420 ck_assert_ptr_eq(r, l); 16421 r = listPushS(&l, "333"); 16422 ck_assert_ptr_eq(r, l); 16423 r = listPushS(&l, "4444"); 16424 ck_assert_ptr_eq(r, l); 16425 l2 = listCropS(l, 1,-1); 16426 ck_assert_uint_eq(listLengthS(l2),2); 16427 ck_assert_str_eq(l2[0], "22"); 16428 ck_assert_str_eq(l2[1], "333"); 16429 ck_assert_str_eq(l[0], "1"); 16430 ck_assert_str_eq(l[1], "4444"); 16431 ck_assert_ptr_eq(l[2], null); 16432 listFreeS(l2); 16433 // start outside 16434 ck_assert_ptr_eq(listCropS(l, 20,-4), NULL); 16435 // end outside 16436 l2 = listCropS(l, 0,40); 16437 ck_assert_uint_eq(listLengthS(l2),2); 16438 ck_assert_str_eq(l2[0], "1"); 16439 ck_assert_str_eq(l2[1], "4444"); 16440 ck_assert_ptr_eq(l[0], null); 16441 listFreeS(l2); 16442 listFreeS(l); 16443 // end negative and outside 16444 l = NULL; 16445 r = listPushS(&l, "1"); 16446 ck_assert_ptr_eq(r, l); 16447 r = listPushS(&l, "22"); 16448 ck_assert_ptr_eq(r, l); 16449 r = listPushS(&l, "333"); 16450 ck_assert_ptr_eq(r, l); 16451 r = listPushS(&l, "4444"); 16452 ck_assert_ptr_eq(r, l); 16453 ck_assert_ptr_eq(listCropS(l, 2,-40), NULL); 16454 ck_assert_str_eq(l[0], "1"); 16455 ck_assert_str_eq(l[1], "22"); 16456 ck_assert_str_eq(l[2], "333"); 16457 ck_assert_str_eq(l[3], "4444"); 16458 // end before start 16459 ck_assert_ptr_eq(listCropS(l, 3,2), NULL); 16460 ck_assert_str_eq(l[0], "1"); 16461 ck_assert_str_eq(l[1], "22"); 16462 ck_assert_str_eq(l[2], "333"); 16463 ck_assert_str_eq(l[3], "4444"); 16464 listFreeS(l); 16465 // negative start last element 16466 l = NULL; 16467 r = listPushS(&l, "1"); 16468 ck_assert_ptr_eq(r, l); 16469 r = listPushS(&l, "22"); 16470 ck_assert_ptr_eq(r, l); 16471 l2 = listCropS(l, -1,0); 16472 ck_assert_uint_eq(listLengthS(l2),1); 16473 ck_assert_str_eq(l2[0], "22"); 16474 ck_assert_str_eq(l[0], "1"); 16475 ck_assert_ptr_eq(l[1], null); 16476 listFreeS(l); 16477 listFreeS(l2); 16478 // start = end 16479 l = NULL; 16480 r = listPushS(&l, "1"); 16481 ck_assert_ptr_eq(r, l); 16482 r = listPushS(&l, "22"); 16483 ck_assert_ptr_eq(r, l); 16484 l2 = listCropS(l, 1,1); 16485 ck_assert_uint_eq(listLengthS(l2),0); 16486 ck_assert_ptr_eq(l2[0], NULL); 16487 ck_assert_str_eq(l[0], "1"); 16488 ck_assert_str_eq(l[1], "22"); 16489 ck_assert_ptr_eq(l[2], null); 16490 listFreeS(l); 16491 listFreeS(l2); 16492 // empty list 16493 listEmptyS(l) 16494 ck_assert_ptr_eq(listCropS(l, 0,0), NULL); 16495 ck_assert_ptr_eq(listCropS(l, -1,0), NULL); 16496 listFreeS(l); 16497 // NULL list 16498 ck_assert_ptr_eq(listCropS(NULL, 2,-4), NULL); 16499 16500 16501 END_TEST 16502 16503 16504 START_TEST(iListCropST) 16505 16506 char **l = NULL; 16507 char **l2; 16508 char **r = null; 16509 16510 // list negative index 16511 r = listPushS(&l, "1"); 16512 ck_assert_ptr_eq(r, l); 16513 r = listPushS(&l, "22"); 16514 ck_assert_ptr_eq(r, l); 16515 r = listPushS(&l, "333"); 16516 ck_assert_ptr_eq(r, l); 16517 r = listPushS(&l, "4444"); 16518 ck_assert_ptr_eq(r, l); 16519 l2 = iListCropS(&l, 1,-1); 16520 ck_assert_uint_eq(listLengthS(l2),2); 16521 ck_assert_str_eq(l2[0], "22"); 16522 ck_assert_str_eq(l2[1], "333"); 16523 ck_assert_str_eq(l[0], "1"); 16524 ck_assert_str_eq(l[1], "4444"); 16525 ck_assert_ptr_eq(l[2], null); 16526 listFreeS(l2); 16527 // start outside 16528 ck_assert_ptr_eq(iListCropS(&l, 20,-4), NULL); 16529 // end outside 16530 l2 = iListCropS(&l, 0,40); 16531 ck_assert_uint_eq(listLengthS(l2),2); 16532 ck_assert_str_eq(l2[0], "1"); 16533 ck_assert_str_eq(l2[1], "4444"); 16534 ck_assert_ptr_eq(l[0], null); 16535 listFreeS(l2); 16536 listFreeS(l); 16537 // end negative and outside 16538 l = NULL; 16539 r = listPushS(&l, "1"); 16540 ck_assert_ptr_eq(r, l); 16541 r = listPushS(&l, "22"); 16542 ck_assert_ptr_eq(r, l); 16543 r = listPushS(&l, "333"); 16544 ck_assert_ptr_eq(r, l); 16545 r = listPushS(&l, "4444"); 16546 ck_assert_ptr_eq(r, l); 16547 ck_assert_ptr_eq(iListCropS(&l, 2,-40), NULL); 16548 ck_assert_str_eq(l[0], "1"); 16549 ck_assert_str_eq(l[1], "22"); 16550 ck_assert_str_eq(l[2], "333"); 16551 ck_assert_str_eq(l[3], "4444"); 16552 // end before start 16553 ck_assert_ptr_eq(iListCropS(&l, 3,2), NULL); 16554 ck_assert_str_eq(l[0], "1"); 16555 ck_assert_str_eq(l[1], "22"); 16556 ck_assert_str_eq(l[2], "333"); 16557 ck_assert_str_eq(l[3], "4444"); 16558 listFreeS(l); 16559 // negative start last element 16560 l = NULL; 16561 r = listPushS(&l, "1"); 16562 ck_assert_ptr_eq(r, l); 16563 r = listPushS(&l, "22"); 16564 ck_assert_ptr_eq(r, l); 16565 l2 = iListCropS(&l, -1,0); 16566 ck_assert_uint_eq(listLengthS(l2),1); 16567 ck_assert_str_eq(l2[0], "22"); 16568 ck_assert_str_eq(l[0], "1"); 16569 ck_assert_ptr_eq(l[1], null); 16570 listFreeS(l); 16571 listFreeS(l2); 16572 // start = end 16573 l = NULL; 16574 r = listPushS(&l, "1"); 16575 ck_assert_ptr_eq(r, l); 16576 r = listPushS(&l, "22"); 16577 ck_assert_ptr_eq(r, l); 16578 l2 = iListCropS(&l, 1,1); 16579 ck_assert_uint_eq(listLengthS(l2),0); 16580 ck_assert_ptr_eq(l2[0], NULL); 16581 ck_assert_str_eq(l[0], "1"); 16582 ck_assert_str_eq(l[1], "22"); 16583 ck_assert_ptr_eq(l[2], null); 16584 listFreeS(l); 16585 listFreeS(l2); 16586 // empty list 16587 listEmptyS(l) 16588 ck_assert_ptr_eq(iListCropS(&l, 0,0), NULL); 16589 ck_assert_ptr_eq(iListCropS(&l, -1,0), NULL); 16590 listFreeS(l); 16591 // NULL list 16592 l = null; 16593 ck_assert_ptr_eq(iListCropS(&l, 2,-4), NULL); 16594 ck_assert_ptr_eq(iListCropS(NULL, 2,-4), NULL); 16595 16596 16597 END_TEST 16598 16599 16600 START_TEST(listCropElemST) 16601 16602 char **l = NULL; 16603 char *r; 16604 char **r2 = null; 16605 16606 // positive index 16607 r2 = listPushS(&l, "1"); 16608 ck_assert_ptr_eq(r2, l); 16609 r2 = listPushS(&l, "22"); 16610 ck_assert_ptr_eq(r2, l); 16611 r2 = listPushS(&l, "333"); 16612 ck_assert_ptr_eq(r2, l); 16613 r2 = listPushS(&l, "4444"); 16614 ck_assert_ptr_eq(r2, l); 16615 r = listCropElemS(l, 1); 16616 ck_assert_str_eq(r, "22"); 16617 ck_assert_str_eq(l[0], "1"); 16618 ck_assert_str_eq(l[1], "333"); 16619 ck_assert_str_eq(l[2], "4444"); 16620 ck_assert_ptr_eq(l[3], null); 16621 free(r); 16622 // list negative index 16623 r = listCropElemS(l, -1); 16624 ck_assert_str_eq(r, "4444"); 16625 ck_assert_str_eq(l[0], "1"); 16626 ck_assert_str_eq(l[1], "333"); 16627 ck_assert_ptr_eq(l[2], null); 16628 free(r); 16629 // index outside 16630 ck_assert_ptr_eq(listCropElemS(l, 20), NULL); 16631 ck_assert_ptr_eq(listCropElemS(l, -4), NULL); 16632 listFreeS(l); 16633 // empty list 16634 listEmptyS(l) 16635 ck_assert_ptr_eq(listCropElemS(l, 0), NULL); 16636 ck_assert_ptr_eq(listCropElemS(l, -1), NULL); 16637 listFreeS(l); 16638 // NULL list 16639 ck_assert_ptr_eq(listCropElemS(NULL, 2), NULL); 16640 16641 16642 END_TEST 16643 16644 16645 START_TEST(iListCropElemST) 16646 16647 char **l = NULL; 16648 char *r; 16649 char **r2 = null; 16650 16651 // positive index 16652 r2 = listPushS(&l, "1"); 16653 ck_assert_ptr_eq(r2, l); 16654 r2 = listPushS(&l, "22"); 16655 ck_assert_ptr_eq(r2, l); 16656 r2 = listPushS(&l, "333"); 16657 ck_assert_ptr_eq(r2, l); 16658 r2 = listPushS(&l, "4444"); 16659 ck_assert_ptr_eq(r2, l); 16660 r = iListCropElemS(&l, 1); 16661 ck_assert_str_eq(r, "22"); 16662 ck_assert_str_eq(l[0], "1"); 16663 ck_assert_str_eq(l[1], "333"); 16664 ck_assert_str_eq(l[2], "4444"); 16665 ck_assert_ptr_eq(l[3], null); 16666 free(r); 16667 // list negative index 16668 r = iListCropElemS(&l, -1); 16669 ck_assert_str_eq(r, "4444"); 16670 ck_assert_str_eq(l[0], "1"); 16671 ck_assert_str_eq(l[1], "333"); 16672 ck_assert_ptr_eq(l[2], null); 16673 free(r); 16674 // index outside 16675 ck_assert_ptr_eq(iListCropElemS(&l, 20), NULL); 16676 ck_assert_ptr_eq(iListCropElemS(&l, -4), NULL); 16677 listFreeS(l); 16678 // empty list 16679 listEmptyS(l) 16680 ck_assert_ptr_eq(iListCropElemS(&l, 0), NULL); 16681 ck_assert_ptr_eq(iListCropElemS(&l, -1), NULL); 16682 listFreeS(l); 16683 // NULL list 16684 l = null; 16685 ck_assert_ptr_eq(iListCropElemS(&l, 2), NULL); 16686 ck_assert_ptr_eq(iListCropElemS(NULL, 2), NULL); 16687 16688 16689 END_TEST 16690 16691 16692 START_TEST(listInsertST) 16693 16694 char **l; 16695 char **l2; 16696 char **r; 16697 16698 // insert 16699 l = listCreateS("1","22"); 16700 l2 = listCreateS("lib"); 16701 r = listInsertS(l, 0, l2); 16702 ck_assert_uint_eq(listLengthS(r),3); 16703 ck_assert_str_eq(r[0], "lib"); 16704 ck_assert_str_eq(r[1], "1"); 16705 ck_assert_str_eq(r[2], "22"); 16706 listFreeS(r); 16707 // negative index 16708 r = listInsertS(l, -1, l2); 16709 ck_assert_uint_eq(listLengthS(r),3); 16710 ck_assert_str_eq(r[0], "1"); 16711 ck_assert_str_eq(r[1], "22"); 16712 ck_assert_str_eq(r[2], "lib"); 16713 listFreeS(r); 16714 // edge 16715 r = listInsertS(l, 2, l2); 16716 ck_assert_uint_eq(listLengthS(r),3); 16717 ck_assert_str_eq(r[0], "1"); 16718 ck_assert_str_eq(r[1], "22"); 16719 ck_assert_str_eq(r[2], "lib"); 16720 listFreeS(r); 16721 // outside list 16722 r = listInsertS(l, 4, l2); 16723 ck_assert_ptr_eq(r, NULL); 16724 r = listInsertS(l, -4, l2); 16725 ck_assert_ptr_eq(r, NULL); 16726 listFreeS(l); 16727 // negative index in a one element list 16728 l = listCreateS("1"); 16729 r = listInsertS(l, -1, l2); 16730 ck_assert_str_eq(r[0], "1"); 16731 ck_assert_str_eq(r[1], "lib"); 16732 listFreeManyS(l,r); 16733 // empty list 16734 listEmptyS(l); 16735 r = listInsertS(l, 0, l2); 16736 ck_assert_str_eq(r[0], "lib"); 16737 listFreeManyS(r,l); 16738 listEmptyS(l); 16739 r = listInsertS(l, -1, l2); 16740 ck_assert_str_eq(r[0], "lib"); 16741 listFreeManyS(r,l, l2); 16742 // empty insert list 16743 l = listCreateS("1"); 16744 listEmptyS(l2); 16745 r = listInsertS(l, 0, l2); 16746 ck_assert_str_eq(r[0], "1"); 16747 listFreeManyS(r,l2); 16748 // NULL insert string 16749 r = listInsertS(l, 0, NULL); 16750 ck_assert_str_eq(r[0], "1"); 16751 listFreeManyS(r,l); 16752 // NULL list 16753 r = listInsertS(NULL, 0, NULL); 16754 ck_assert_ptr_eq(r, NULL); 16755 16756 16757 END_TEST 16758 16759 16760 START_TEST(iListInsertST) 16761 16762 char **l; 16763 char **l2; 16764 char **r = null; 16765 16766 // insert 16767 l = listCreateS("1","22"); 16768 l2 = listCreateS("lib"); 16769 r = iListInsertS(&l, 0, l2); 16770 ck_assert_ptr_eq(r, l); 16771 ck_assert_uint_eq(listLengthS(l),3); 16772 ck_assert_str_eq(l[0], "lib"); 16773 ck_assert_str_eq(l[1], "1"); 16774 ck_assert_str_eq(l[2], "22"); 16775 free(l2); 16776 listFreeS(l); 16777 // negative index 16778 l = listCreateS("1","22"); 16779 l2 = listCreateS("lib"); 16780 r = iListInsertS(&l, -1, l2); 16781 ck_assert_ptr_eq(r, l); 16782 ck_assert_uint_eq(listLengthS(l),3); 16783 ck_assert_str_eq(l[0], "1"); 16784 ck_assert_str_eq(l[1], "22"); 16785 ck_assert_str_eq(l[2], "lib"); 16786 free(l2); 16787 listFreeS(l); 16788 // edge 16789 l = listCreateS("1","22"); 16790 l2 = listCreateS("lib"); 16791 r = iListInsertS(&l, 2, l2); 16792 ck_assert_ptr_eq(r, l); 16793 ck_assert_uint_eq(listLengthS(l),3); 16794 ck_assert_str_eq(l[0], "1"); 16795 ck_assert_str_eq(l[1], "22"); 16796 ck_assert_str_eq(l[2], "lib"); 16797 free(l2); 16798 listFreeS(l); 16799 // outside list 16800 l = listCreateS("1","22"); 16801 l2 = listCreateS("lib"); 16802 r = iListInsertS(&l, 4, l2); 16803 ck_assert_ptr_eq(r, null); 16804 ck_assert_uint_eq(listLengthS(l),2); 16805 ck_assert_str_eq(l[0], "1"); 16806 ck_assert_str_eq(l[1], "22"); 16807 r = iListInsertS(&l, -4, l2); 16808 ck_assert_ptr_eq(r, null); 16809 ck_assert_uint_eq(listLengthS(l),2); 16810 ck_assert_str_eq(l[0], "1"); 16811 ck_assert_str_eq(l[1], "22"); 16812 listFreeS(l); 16813 // negative index in a one element list 16814 l = listCreateS("1"); 16815 r = iListInsertS(&l, -1, l2); 16816 ck_assert_ptr_eq(r, l); 16817 ck_assert_str_eq(l[0], "1"); 16818 ck_assert_str_eq(l[1], "lib"); 16819 free(l2); 16820 listFreeS(l); 16821 // empty list 16822 listEmptyS(l); 16823 l2 = listCreateS("lib"); 16824 r = iListInsertS(&l, 0, l2); 16825 ck_assert_ptr_eq(r, l); 16826 ck_assert_str_eq(l[0], "lib"); 16827 free(l2); 16828 listFreeS(l); 16829 listEmptyS(l); 16830 l2 = listCreateS("lib"); 16831 r = iListInsertS(&l, -1, l2); 16832 ck_assert_ptr_eq(r, l); 16833 ck_assert_str_eq(l[0], "lib"); 16834 free(l2); 16835 listFreeS(l); 16836 // empty insert list 16837 l = listCreateS("1"); 16838 listEmptyS(l2); 16839 r = iListInsertS(&l, 0, l2); 16840 ck_assert_ptr_eq(r, l); 16841 ck_assert_str_eq(l[0], "1"); 16842 listFreeS(l2); 16843 // NULL insert string 16844 r = iListInsertS(&l, 0, NULL); 16845 ck_assert_ptr_eq(r, null); 16846 ck_assert_str_eq(l[0], "1"); 16847 listFreeS(l); 16848 // NULL list and list to insert at index 0 16849 l = NULL; 16850 l2 = listCreateS("lib"); 16851 r = iListInsertS(&l, 0, l2); 16852 ck_assert_ptr_eq(r, l); 16853 ck_assert_str_eq(l[0], "lib"); 16854 free(l2); 16855 listFreeS(l); 16856 // NULL list and list to insert at non 0 index 16857 l = NULL; 16858 l2 = listCreateS("lib"); 16859 r = iListInsertS(&l, -1, l2); 16860 ck_assert_ptr_eq(r, null); 16861 ck_assert_ptr_eq(l, NULL); 16862 listFreeS(l2); 16863 // NULL list 16864 l = NULL; 16865 r = iListInsertS(&l, 0, NULL); 16866 ck_assert_ptr_eq(r, null); 16867 ck_assert_ptr_eq(l, NULL); 16868 // NULL var 16869 r = iListInsertS(NULL, 0, NULL); 16870 ck_assert_ptr_eq(r, null); 16871 16872 16873 END_TEST 16874 16875 16876 START_TEST(iListInsertNFreeST) 16877 16878 char **l, **r; 16879 char **l2; 16880 16881 // insert 16882 l = listCreateS("1","22"); 16883 l2 = listCreateS("lib"); 16884 r = iListInsertNFreeS(&l, 0, l2); 16885 ck_assert_ptr_eq(r, l); 16886 ck_assert_uint_eq(listLengthS(l),3); 16887 ck_assert_str_eq(l[0], "lib"); 16888 ck_assert_str_eq(l[1], "1"); 16889 ck_assert_str_eq(l[2], "22"); 16890 listFreeS(l); 16891 // negative index 16892 l = listCreateS("1","22"); 16893 l2 = listCreateS("lib"); 16894 r = iListInsertNFreeS(&l, -1, l2); 16895 ck_assert_ptr_eq(r, l); 16896 ck_assert_uint_eq(listLengthS(l),3); 16897 ck_assert_str_eq(l[0], "1"); 16898 ck_assert_str_eq(l[1], "22"); 16899 ck_assert_str_eq(l[2], "lib"); 16900 listFreeS(l); 16901 // edge 16902 l = listCreateS("1","22"); 16903 l2 = listCreateS("lib"); 16904 r = iListInsertNFreeS(&l, 2, l2); 16905 ck_assert_ptr_eq(r, l); 16906 ck_assert_uint_eq(listLengthS(l),3); 16907 ck_assert_str_eq(l[0], "1"); 16908 ck_assert_str_eq(l[1], "22"); 16909 ck_assert_str_eq(l[2], "lib"); 16910 listFreeS(l); 16911 // outside list 16912 l = listCreateS("1","22"); 16913 l2 = listCreateS("lib"); 16914 r = iListInsertNFreeS(&l, 4, l2); 16915 ck_assert_ptr_eq(r, NULL); 16916 // free L2 since it is not freed because iListInsertNFreeS failed 16917 listFreeS(l2); 16918 ck_assert_uint_eq(listLengthS(l),2); 16919 ck_assert_str_eq(l[0], "1"); 16920 ck_assert_str_eq(l[1], "22"); 16921 l2 = listCreateS("lib"); 16922 r = iListInsertNFreeS(&l, -4, l2); 16923 ck_assert_ptr_eq(r, NULL); 16924 // free L2 since it is not freed because iListInsertNFreeS failed 16925 listFreeS(l2); 16926 ck_assert_uint_eq(listLengthS(l),2); 16927 ck_assert_str_eq(l[0], "1"); 16928 ck_assert_str_eq(l[1], "22"); 16929 listFreeS(l); 16930 // negative index in a one element list 16931 l = listCreateS("1"); 16932 l2 = listCreateS("lib"); 16933 r = iListInsertNFreeS(&l, -1, l2); 16934 ck_assert_ptr_eq(r, l); 16935 ck_assert_str_eq(l[0], "1"); 16936 ck_assert_str_eq(l[1], "lib"); 16937 listFreeS(l); 16938 // empty list 16939 listEmptyS(l); 16940 l2 = listCreateS("lib"); 16941 r = iListInsertNFreeS(&l, 0, l2); 16942 ck_assert_ptr_eq(r, l); 16943 ck_assert_str_eq(l[0], "lib"); 16944 listFreeS(l); 16945 listEmptyS(l); 16946 l2 = listCreateS("lib"); 16947 r = iListInsertNFreeS(&l, -1, l2); 16948 ck_assert_ptr_eq(r, l); 16949 ck_assert_str_eq(l[0], "lib"); 16950 listFreeS(l); 16951 // empty insert list 16952 l = listCreateS("1"); 16953 listEmptyS(l2); 16954 r = iListInsertNFreeS(&l, 0, l2); 16955 ck_assert_ptr_eq(r, l); 16956 ck_assert_str_eq(l[0], "1"); 16957 // NULL insert string 16958 r = iListInsertNFreeS(&l, 0, NULL); 16959 ck_assert_ptr_eq(r, null); 16960 ck_assert_str_eq(l[0], "1"); 16961 listFreeS(l); 16962 // NULL list 16963 l = NULL; 16964 l2 = listCreateS("lib"); 16965 r = iListInsertNFreeS(&l, 0, l2); 16966 ck_assert_ptr_eq(r, l); 16967 ck_assert_str_eq(l[0], "lib"); 16968 listFreeS(l); 16969 // NULL var 16970 l2 = listCreateS("lib"); 16971 l = iListInsertNFreeS(NULL, 0, l2); 16972 ck_assert_ptr_eq(l, NULL); 16973 // free L2 since it is not freed because iListInsertNFreeS failed 16974 listFreeS(l2); 16975 16976 END_TEST 16977 16978 16979 START_TEST(listInjectST) 16980 16981 char **l; 16982 char **r; 16983 16984 // insert 16985 l = listCreateS("1","22"); 16986 r = listInjectS(l, 0, "lib"); 16987 ck_assert_uint_eq(listLengthS(r),3); 16988 ck_assert_str_eq(r[0], "lib"); 16989 ck_assert_str_eq(r[1], "1"); 16990 ck_assert_str_eq(r[2], "22"); 16991 listFreeS(r); 16992 // negative index 16993 r = listInjectS(l, -1, "lib"); 16994 ck_assert_uint_eq(listLengthS(r),3); 16995 ck_assert_str_eq(r[0], "1"); 16996 ck_assert_str_eq(r[1], "22"); 16997 ck_assert_str_eq(r[2], "lib"); 16998 listFreeS(r); 16999 // edge 17000 r = listInjectS(l, 2, "lib"); 17001 ck_assert_uint_eq(listLengthS(r),3); 17002 ck_assert_str_eq(r[0], "1"); 17003 ck_assert_str_eq(r[1], "22"); 17004 ck_assert_str_eq(r[2], "lib"); 17005 listFreeS(r); 17006 // outside list 17007 r = listInjectS(l, 4, "lib"); 17008 ck_assert_ptr_eq(r, NULL); 17009 r = listInjectS(l, -4, "lib"); 17010 ck_assert_ptr_eq(r, NULL); 17011 listFreeS(l); 17012 // negative index in a one element list 17013 l = listCreateS("1"); 17014 r = listInjectS(l, -1, "lib"); 17015 ck_assert_str_eq(r[0], "1"); 17016 ck_assert_str_eq(r[1], "lib"); 17017 listFreeManyS(l,r); 17018 // empty list 17019 listEmptyS(l); 17020 r = listInjectS(l, 0, "lib"); 17021 ck_assert_str_eq(r[0], "lib"); 17022 listFreeManyS(r,l); 17023 listEmptyS(l); 17024 r = listInjectS(l, -1, "lib"); 17025 ck_assert_str_eq(r[0], "lib"); 17026 listFreeManyS(r,l); 17027 // NULL insert string 17028 l = listCreateS("1"); 17029 r = listInjectS(l, 0, NULL); 17030 ck_assert_ptr_eq(r, NULL); 17031 listFreeManyS(l,r); 17032 // NULL list 17033 r = listInjectS(NULL, 0, NULL); 17034 ck_assert_ptr_eq(r, NULL); 17035 17036 17037 END_TEST 17038 17039 17040 START_TEST(listInjectCharST) 17041 17042 char **l; 17043 char **r; 17044 17045 // insert 17046 l = listCreateS("1","22"); 17047 r = listInjectCharS(l, 0, 'l'); 17048 ck_assert_uint_eq(listLengthS(r),3); 17049 ck_assert_str_eq(r[0], "l"); 17050 ck_assert_str_eq(r[1], "1"); 17051 ck_assert_str_eq(r[2], "22"); 17052 listFreeS(r); 17053 // negative index 17054 r = listInjectCharS(l, -1, 'l'); 17055 ck_assert_uint_eq(listLengthS(r),3); 17056 ck_assert_str_eq(r[0], "1"); 17057 ck_assert_str_eq(r[1], "22"); 17058 ck_assert_str_eq(r[2], "l"); 17059 listFreeS(r); 17060 // edge 17061 r = listInjectCharS(l, 2, 'l'); 17062 ck_assert_uint_eq(listLengthS(r),3); 17063 ck_assert_str_eq(r[0], "1"); 17064 ck_assert_str_eq(r[1], "22"); 17065 ck_assert_str_eq(r[2], "l"); 17066 listFreeS(r); 17067 // outside list 17068 r = listInjectCharS(l, 4, 'l'); 17069 ck_assert_ptr_eq(r, NULL); 17070 r = listInjectCharS(l, -4, 'l'); 17071 ck_assert_ptr_eq(r, NULL); 17072 listFreeS(l); 17073 // negative index in a one element list 17074 l = listCreateS("1"); 17075 r = listInjectCharS(l, -1, 'l'); 17076 ck_assert_str_eq(r[0], "1"); 17077 ck_assert_str_eq(r[1], "l"); 17078 listFreeManyS(l,r); 17079 // empty list 17080 listEmptyS(l); 17081 r = listInjectCharS(l, 0, 'l'); 17082 ck_assert_str_eq(r[0], "l"); 17083 listFreeManyS(r,l); 17084 listEmptyS(l); 17085 r = listInjectCharS(l, -1, 'l'); 17086 ck_assert_str_eq(r[0], "l"); 17087 listFreeManyS(r,l); 17088 // NULL list 17089 r = listInjectCharS(NULL, 0, 'l'); 17090 ck_assert_str_eq(r[0], "l"); 17091 ck_assert_ptr_eq(r[1], NULL); 17092 listFreeS(r); 17093 17094 17095 END_TEST 17096 17097 17098 START_TEST(iListInjectST) 17099 17100 char **l; 17101 char **r = null; 17102 17103 // insert 17104 l = listCreateS("1","22"); 17105 r = iListInjectS(&l, 0, strdup("lib")); 17106 ck_assert_ptr_eq(r, l); 17107 ck_assert_uint_eq(listLengthS(l),3); 17108 ck_assert_str_eq(l[0], "lib"); 17109 ck_assert_str_eq(l[1], "1"); 17110 ck_assert_str_eq(l[2], "22"); 17111 listFreeS(l); 17112 // negative index 17113 l = listCreateS("1","22"); 17114 r = iListInjectS(&l, -1, strdup("lib")); 17115 ck_assert_ptr_eq(r, l); 17116 ck_assert_uint_eq(listLengthS(l),3); 17117 ck_assert_str_eq(l[0], "1"); 17118 ck_assert_str_eq(l[1], "22"); 17119 ck_assert_str_eq(l[2], "lib"); 17120 listFreeS(l); 17121 // edge 17122 l = listCreateS("1","22"); 17123 r = iListInjectS(&l, 2, strdup("lib")); 17124 ck_assert_ptr_eq(r, l); 17125 ck_assert_uint_eq(listLengthS(l),3); 17126 ck_assert_str_eq(l[0], "1"); 17127 ck_assert_str_eq(l[1], "22"); 17128 ck_assert_str_eq(l[2], "lib"); 17129 listFreeS(l); 17130 // outside list 17131 l = listCreateS("1","22"); 17132 r = iListInjectS(&l, 4, "lib"); 17133 ck_assert_ptr_eq(r, null); 17134 ck_assert_uint_eq(listLengthS(l),2); 17135 ck_assert_str_eq(l[0], "1"); 17136 ck_assert_str_eq(l[1], "22"); 17137 r = iListInjectS(&l, -4, "lib"); 17138 ck_assert_ptr_eq(r, null); 17139 ck_assert_uint_eq(listLengthS(l),2); 17140 ck_assert_str_eq(l[0], "1"); 17141 ck_assert_str_eq(l[1], "22"); 17142 listFreeS(l); 17143 // negative index in a one element list 17144 l = listCreateS("1"); 17145 r = iListInjectS(&l, -1, strdup("lib")); 17146 ck_assert_ptr_eq(r, l); 17147 ck_assert_str_eq(l[0], "1"); 17148 ck_assert_str_eq(l[1], "lib"); 17149 listFreeS(l); 17150 // empty list 17151 listEmptyS(l); 17152 r = iListInjectS(&l, 0, strdup("lib")); 17153 ck_assert_ptr_eq(r, l); 17154 ck_assert_str_eq(l[0], "lib"); 17155 listFreeS(l); 17156 listEmptyS(l); 17157 r = iListInjectS(&l, -1, strdup("lib")); 17158 ck_assert_ptr_eq(r, l); 17159 ck_assert_str_eq(l[0], "lib"); 17160 listFreeS(l); 17161 // NULL insert string 17162 l = listCreateS("1"); 17163 r = iListInjectS(&l, 0, NULL); 17164 ck_assert_ptr_eq(r, null); 17165 ck_assert_str_eq(l[0], "1"); 17166 listFreeS(l); 17167 // NULL list and non zero index 17168 l = NULL; 17169 r = iListInjectS(&l, 1, ""); 17170 ck_assert_ptr_eq(r, null); 17171 ck_assert_ptr_eq(l, NULL); 17172 // NULL list and zero index 17173 l = NULL; 17174 r = iListInjectS(&l, 0, "aa"); 17175 ck_assert_ptr_eq(r, l); 17176 ck_assert_str_eq(l[0], "aa"); 17177 free(l); 17178 // NULL var 17179 r = iListInjectS(NULL, 0, ""); 17180 ck_assert_ptr_eq(r, null); 17181 17182 17183 END_TEST 17184 17185 17186 START_TEST(iListInjectCharST) 17187 17188 char **l; 17189 char **r = null; 17190 17191 // insert 17192 l = listCreateS("1","22"); 17193 r = iListInjectCharS(&l, 1, 'a'); 17194 ck_assert_ptr_eq(r, l); 17195 ck_assert_uint_eq(listLengthS(l),3); 17196 ck_assert_str_eq(l[0], "1"); 17197 ck_assert_str_eq(l[1], "a"); 17198 ck_assert_str_eq(l[2], "22"); 17199 listFreeS(l); 17200 // NULL list and zero index 17201 l = NULL; 17202 r = iListInjectCharS(&l, 0, 'a'); 17203 ck_assert_ptr_eq(r, l); 17204 ck_assert_str_eq(l[0], "a"); 17205 listFreeS(l); 17206 // NULL list and non zero index 17207 l = NULL; 17208 r = iListInjectCharS(&l, 1, 'a'); 17209 ck_assert_ptr_eq(r, l); 17210 ck_assert_ptr_eq(l, NULL); 17211 // NULL var 17212 r = iListInjectCharS(NULL, 1, 'a'); 17213 ck_assert_ptr_eq(r, null); 17214 17215 END_TEST 17216 17217 17218 START_TEST(listDelST) 17219 17220 char **l = NULL; 17221 char **l2; 17222 char **r = null; 17223 17224 // list negative index 17225 r = listPushS(&l, "1"); 17226 ck_assert_ptr_eq(r, l); 17227 r = listPushS(&l, "22"); 17228 ck_assert_ptr_eq(r, l); 17229 r = listPushS(&l, "333"); 17230 ck_assert_ptr_eq(r, l); 17231 r = listPushS(&l, "4444"); 17232 ck_assert_ptr_eq(r, l); 17233 l2 = listDelS(l, 1,-1); 17234 ck_assert_uint_eq(listLengthS(l2),2); 17235 ck_assert_str_eq(l2[0], "1"); 17236 ck_assert_str_eq(l2[1], "4444"); 17237 listFreeS(l2); 17238 // start outside 17239 ck_assert_ptr_eq(listDelS(l, 20,-4), NULL); 17240 // end outside 17241 l2 = listDelS(l, 2,40); 17242 ck_assert_uint_eq(listLengthS(l2),2); 17243 ck_assert_str_eq(l2[0], "1"); 17244 ck_assert_str_eq(l2[1], "22"); 17245 listFreeS(l2); 17246 // end negative and outside 17247 ck_assert_ptr_eq(listDelS(l, 2,-40), NULL); 17248 // end before start 17249 ck_assert_ptr_eq(listDelS(l, 3,2), NULL); 17250 listFreeS(l); 17251 // negative start last element 17252 l = NULL; 17253 r = listPushS(&l, "1"); 17254 ck_assert_ptr_eq(r, l); 17255 r = listPushS(&l, "22"); 17256 ck_assert_ptr_eq(r, l); 17257 l2 = listDelS(l, -1,0); 17258 ck_assert_uint_eq(listLengthS(l2),1); 17259 ck_assert_str_eq(l2[0], "1"); 17260 listFreeS(l); 17261 listFreeS(l2); 17262 // start negative and outside (delete complete list because end is 0 (=len)) 17263 l = NULL; 17264 r = listPushS(&l, "1"); 17265 ck_assert_ptr_eq(r, l); 17266 r = listPushS(&l, "22"); 17267 ck_assert_ptr_eq(r, l); 17268 l2 = listDelS(l, -3,0); 17269 ck_assert_uint_eq(listLengthS(l2),0); 17270 ck_assert_ptr_eq(l2[0], NULL); 17271 listFreeS(l); 17272 listFreeS(l2); 17273 // start = end 17274 l = NULL; 17275 r = listPushS(&l, "1"); 17276 ck_assert_ptr_eq(r, l); 17277 r = listPushS(&l, "22"); 17278 ck_assert_ptr_eq(r, l); 17279 l2 = listDelS(l, 1,1); 17280 ck_assert_uint_eq(listLengthS(l2),2); 17281 ck_assert_str_eq(l2[0], "1"); 17282 ck_assert_str_eq(l2[1], "22"); 17283 listFreeS(l); 17284 listFreeS(l2); 17285 // empty list 17286 listEmptyS(l) 17287 ck_assert_ptr_eq(listDelS(l, 0,0), NULL); 17288 ck_assert_ptr_eq(listDelS(l, -1,0), NULL); 17289 listFreeS(l); 17290 // NULL list 17291 ck_assert_ptr_eq(listDelS(NULL, 2,-4), NULL); 17292 17293 17294 END_TEST 17295 17296 17297 START_TEST(iListDelST) 17298 17299 char **l = NULL; 17300 char **r = null; 17301 17302 // list negative index 17303 r = listPushS(&l, "1"); 17304 ck_assert_ptr_eq(r, l); 17305 r = listPushS(&l, "22"); 17306 ck_assert_ptr_eq(r, l); 17307 r = listPushS(&l, "333"); 17308 ck_assert_ptr_eq(r, l); 17309 r = listPushS(&l, "4444"); 17310 ck_assert_ptr_eq(r, l); 17311 r = iListDelS(&l, 1,-1); 17312 ck_assert_ptr_eq(r, l); 17313 ck_assert_uint_eq(listLengthS(l),2); 17314 ck_assert_str_eq(l[0], "1"); 17315 ck_assert_str_eq(l[1], "4444"); 17316 r = iListEmptySF(&l); 17317 ck_assert_ptr_eq(r, l); 17318 // start outside 17319 r = listPushS(&l, "1"); 17320 ck_assert_ptr_eq(r, l); 17321 r = listPushS(&l, "22"); 17322 ck_assert_ptr_eq(r, l); 17323 r = listPushS(&l, "333"); 17324 ck_assert_ptr_eq(r, l); 17325 r = listPushS(&l, "4444"); 17326 ck_assert_ptr_eq(r, l); 17327 r = iListDelS(&l, 20,-4); 17328 ck_assert_ptr_eq(r, null); 17329 ck_assert_uint_eq(listLengthS(l),4); 17330 ck_assert_str_eq(l[0], "1"); 17331 ck_assert_str_eq(l[3], "4444"); 17332 // end outside 17333 r = iListDelS(&l, 2,40); 17334 ck_assert_ptr_eq(r, l); 17335 ck_assert_uint_eq(listLengthS(l),2); 17336 ck_assert_str_eq(l[0], "1"); 17337 ck_assert_str_eq(l[1], "22"); 17338 r = iListEmptySF(&l); 17339 ck_assert_ptr_eq(r, l); 17340 // end negative and outside 17341 r = listPushS(&l, "1"); 17342 ck_assert_ptr_eq(r, l); 17343 r = listPushS(&l, "22"); 17344 ck_assert_ptr_eq(r, l); 17345 r = listPushS(&l, "333"); 17346 ck_assert_ptr_eq(r, l); 17347 r = listPushS(&l, "4444"); 17348 ck_assert_ptr_eq(r, l); 17349 r = iListDelS(&l, 2,-40); 17350 ck_assert_ptr_eq(r, null); 17351 ck_assert_uint_eq(listLengthS(l),4); 17352 ck_assert_str_eq(l[0], "1"); 17353 ck_assert_str_eq(l[3], "4444"); 17354 // end before start 17355 r = iListDelS(&l, 3,2); 17356 ck_assert_ptr_eq(r, null); 17357 ck_assert_uint_eq(listLengthS(l),4); 17358 ck_assert_str_eq(l[0], "1"); 17359 ck_assert_str_eq(l[3], "4444"); 17360 r = iListEmptySF(&l); 17361 ck_assert_ptr_eq(r, l); 17362 // negative start last element 17363 r = listPushS(&l, "1"); 17364 ck_assert_ptr_eq(r, l); 17365 r = listPushS(&l, "22"); 17366 ck_assert_ptr_eq(r, l); 17367 r = iListDelS(&l, -1,0); 17368 ck_assert_ptr_eq(r, l); 17369 ck_assert_uint_eq(listLengthS(l),1); 17370 ck_assert_str_eq(l[0], "1"); 17371 r = iListEmptySF(&l); 17372 ck_assert_ptr_eq(r, l); 17373 // start negative and outside (delete complete list because end is 0 (=len)) 17374 r = listPushS(&l, "1"); 17375 ck_assert_ptr_eq(r, l); 17376 r = listPushS(&l, "22"); 17377 ck_assert_ptr_eq(r, l); 17378 r = iListDelS(&l, -3,0); 17379 ck_assert_ptr_eq(r, l); 17380 ck_assert_uint_eq(listLengthS(l),0); 17381 ck_assert_ptr_eq(l[0], NULL); 17382 // start = end 17383 // (l is empty from previous test) 17384 r = listPushS(&l, "1"); 17385 ck_assert_ptr_eq(r, l); 17386 r = listPushS(&l, "22"); 17387 ck_assert_ptr_eq(r, l); 17388 r = iListDelS(&l, 1,1); 17389 ck_assert_ptr_eq(r, l); 17390 ck_assert_uint_eq(listLengthS(l),2); 17391 ck_assert_str_eq(l[0], "1"); 17392 ck_assert_str_eq(l[1], "22"); 17393 listFreeS(l); 17394 // empty list 17395 listEmptyS(l); 17396 r = iListDelS(&l, 0,0); 17397 ck_assert_ptr_eq(r, null); 17398 ck_assert(listIsEmptyS(l)); 17399 r = iListDelS(&l, -1,0); 17400 ck_assert_ptr_eq(r, null); 17401 ck_assert(listIsEmptyS(l)); 17402 listFreeS(l); 17403 // NULL list 17404 l = NULL; 17405 r = iListDelS(&l, 2,-4); 17406 ck_assert_ptr_eq(r, null); 17407 ck_assert_ptr_eq(l, NULL); 17408 // NULL var 17409 r = iListDelS(NULL, 2,-4); 17410 ck_assert_ptr_eq(r, null); 17411 17412 17413 END_TEST 17414 17415 17416 START_TEST(iListRemoveST) 17417 17418 char **l = NULL; 17419 char **r = null; 17420 17421 // list negative index 17422 r = listPushS(&l, "1"); 17423 ck_assert_ptr_eq(r, l); 17424 r = iListPushS(&l, "22"); 17425 ck_assert_ptr_eq(r, l); 17426 r = iListPushS(&l, "333"); 17427 ck_assert_ptr_eq(r, l); 17428 r = listPushS(&l, "4444"); 17429 ck_assert_ptr_eq(r, l); 17430 iListRemoveS(&l, 1,-1); 17431 ck_assert_uint_eq(listLengthS(l),2); 17432 ck_assert_str_eq(l[0], "1"); 17433 ck_assert_str_eq(l[1], "4444"); 17434 r = iListEmptySF(&l); 17435 ck_assert_ptr_eq(r, l); 17436 // start outside 17437 r = listPushS(&l, "1"); 17438 ck_assert_ptr_eq(r, l); 17439 r = listPushS(&l, "22"); 17440 ck_assert_ptr_eq(r, l); 17441 r = iListPushS(&l, "333"); 17442 ck_assert_ptr_eq(r, l); 17443 r = iListPushS(&l, "4444"); 17444 ck_assert_ptr_eq(r, l); 17445 iListRemoveS(&l, 20,-4); 17446 ck_assert_uint_eq(listLengthS(l),4); 17447 ck_assert_str_eq(l[0], "1"); 17448 ck_assert_str_eq(l[3], "4444"); 17449 // end outside 17450 iListRemoveS(&l, 2,40); 17451 ck_assert_uint_eq(listLengthS(l),2); 17452 ck_assert_str_eq(l[0], "1"); 17453 ck_assert_str_eq(l[1], "22"); 17454 r = iListEmptySF(&l); 17455 ck_assert_ptr_eq(r, l); 17456 // end negative and outside 17457 r = listPushS(&l, "1"); 17458 ck_assert_ptr_eq(r, l); 17459 r = listPushS(&l, "22"); 17460 ck_assert_ptr_eq(r, l); 17461 r = listPushS(&l, "333"); 17462 ck_assert_ptr_eq(r, l); 17463 r = listPushS(&l, "4444"); 17464 ck_assert_ptr_eq(r, l); 17465 iListRemoveS(&l, 2,-40); 17466 ck_assert_uint_eq(listLengthS(l),4); 17467 ck_assert_str_eq(l[0], "1"); 17468 ck_assert_str_eq(l[3], "4444"); 17469 // end before start 17470 iListRemoveS(&l, 3,2); 17471 ck_assert_uint_eq(listLengthS(l),4); 17472 ck_assert_str_eq(l[0], "1"); 17473 ck_assert_str_eq(l[3], "4444"); 17474 r = iListEmptySF(&l); 17475 ck_assert_ptr_eq(r, l); 17476 // negative start last element 17477 r = listPushS(&l, "1"); 17478 ck_assert_ptr_eq(r, l); 17479 r = iListPushS(&l, "22"); 17480 ck_assert_ptr_eq(r, l); 17481 iListRemoveS(&l, -1,0); 17482 ck_assert_uint_eq(listLengthS(l),1); 17483 ck_assert_str_eq(l[0], "1"); 17484 r = iListEmptySF(&l); 17485 ck_assert_ptr_eq(r, l); 17486 // start negative and outside (delete complete list because end is 0 (=len)) 17487 r = iListPushS(&l, "1"); 17488 ck_assert_ptr_eq(r, l); 17489 r = iListPushS(&l, "22"); 17490 ck_assert_ptr_eq(r, l); 17491 iListRemoveS(&l, -3,0); 17492 ck_assert_uint_eq(listLengthS(l),0); 17493 ck_assert_ptr_eq(l[0], NULL); 17494 // start = end 17495 // (l is empty from previous test) 17496 r = listPushS(&l, "1"); 17497 ck_assert_ptr_eq(r, l); 17498 r = listPushS(&l, "22"); 17499 ck_assert_ptr_eq(r, l); 17500 iListRemoveS(&l, 1,1); 17501 ck_assert_uint_eq(listLengthS(l),2); 17502 ck_assert_str_eq(l[0], "1"); 17503 ck_assert_str_eq(l[1], "22"); 17504 listFreeS(l); 17505 // empty list 17506 listEmptyS(l); 17507 iListRemoveS(&l, 0,0); 17508 ck_assert(listIsEmptyS(l)); 17509 iListRemoveS(&l, -1,0); 17510 ck_assert(listIsEmptyS(l)); 17511 listFreeS(l); 17512 // NULL list 17513 l = NULL; 17514 iListRemoveS(&l, 2,-4); 17515 ck_assert_ptr_eq(l, NULL); 17516 // NULL var 17517 ck_assert_ptr_eq(iListRemoveS(NULL, 2,-4), NULL); 17518 17519 17520 END_TEST 17521 17522 17523 START_TEST(listDelElemST) 17524 17525 char **l = NULL; 17526 char **l2; 17527 char **r = null; 17528 17529 // positive index 17530 r = listPushS(&l, "1"); 17531 ck_assert_ptr_eq(r, l); 17532 r = listPushS(&l, "22"); 17533 ck_assert_ptr_eq(r, l); 17534 r = listPushS(&l, "333"); 17535 ck_assert_ptr_eq(r, l); 17536 r = listPushS(&l, "4444"); 17537 ck_assert_ptr_eq(r, l); 17538 l2 = listDelElemS(l, 1); 17539 ck_assert_str_eq(l2[0], "1"); 17540 ck_assert_str_eq(l2[1], "333"); 17541 ck_assert_str_eq(l2[2], "4444"); 17542 ck_assert_ptr_eq(l2[3], null); 17543 listFreeS(l2); 17544 // list negative index 17545 l2 = listDelElemS(l, -1); 17546 ck_assert_str_eq(l2[0], "1"); 17547 ck_assert_str_eq(l2[1], "22"); 17548 ck_assert_str_eq(l2[2], "333"); 17549 ck_assert_ptr_eq(l2[3], null); 17550 listFreeS(l2); 17551 // index outside 17552 ck_assert_ptr_eq(listDelElemS(l, 20), NULL); 17553 ck_assert_ptr_eq(listDelElemS(l, -5), NULL); 17554 listFreeS(l); 17555 // empty list 17556 listEmptyS(l) 17557 ck_assert_ptr_eq(listDelElemS(l, 0), NULL); 17558 ck_assert_ptr_eq(listDelElemS(l, -1), NULL); 17559 listFreeS(l); 17560 // NULL list 17561 ck_assert_ptr_eq(listDelElemS(NULL, 2), NULL); 17562 17563 17564 END_TEST 17565 17566 17567 START_TEST(iListDelElemST) 17568 17569 char **l = NULL; 17570 char **r; 17571 17572 // positive index 17573 r = listPushS(&l, "1"); 17574 ck_assert_ptr_eq(r, l); 17575 r = listPushS(&l, "22"); 17576 ck_assert_ptr_eq(r, l); 17577 r = listPushS(&l, "333"); 17578 ck_assert_ptr_eq(r, l); 17579 r = listPushS(&l, "4444"); 17580 ck_assert_ptr_eq(r, l); 17581 r = iListDelElemS(&l, 1); 17582 ck_assert_ptr_ne(r, null); 17583 ck_assert_str_eq(l[0], "1"); 17584 ck_assert_str_eq(l[1], "333"); 17585 ck_assert_str_eq(l[2], "4444"); 17586 ck_assert_ptr_eq(l[3], null); 17587 // list negative index 17588 r = iListDelElemS(&l, -1); 17589 ck_assert_ptr_ne(r, null); 17590 ck_assert_str_eq(l[0], "1"); 17591 ck_assert_str_eq(l[1], "333"); 17592 ck_assert_ptr_eq(l[2], null); 17593 // index outside 17594 ck_assert_ptr_eq(iListDelElemS(&l, 20), NULL); 17595 ck_assert_ptr_eq(iListDelElemS(&l, -4), NULL); 17596 listFreeS(l); 17597 // empty list 17598 listEmptyS(l) 17599 ck_assert_ptr_eq(iListDelElemS(&l, 0), NULL); 17600 ck_assert_ptr_eq(iListDelElemS(&l, -1), NULL); 17601 listFreeS(l); 17602 // NULL list 17603 l = null; 17604 ck_assert_ptr_eq(iListDelElemS(&l, 2), NULL); 17605 ck_assert_ptr_eq(iListDelElemS(NULL, 2), NULL); 17606 17607 17608 END_TEST 17609 17610 17611 START_TEST(iListRemoveElemST) 17612 17613 char **l = NULL; 17614 char **r; 17615 17616 // positive index 17617 r = listPushS(&l, "1"); 17618 ck_assert_ptr_eq(r, l); 17619 r = iListPushS(&l, "22"); 17620 ck_assert_ptr_eq(r, l); 17621 r = listPushS(&l, "333"); 17622 ck_assert_ptr_eq(r, l); 17623 r = iListPushS(&l, "4444"); 17624 ck_assert_ptr_eq(r, l); 17625 r = iListRemoveElemS(&l, 1); 17626 ck_assert_ptr_ne(r, null); 17627 ck_assert_str_eq(l[0], "1"); 17628 ck_assert_str_eq(l[1], "333"); 17629 ck_assert_str_eq(l[2], "4444"); 17630 ck_assert_ptr_eq(l[3], null); 17631 // list negative index 17632 r = iListRemoveElemS(&l, -1); 17633 ck_assert_ptr_ne(r, null); 17634 ck_assert_str_eq(l[0], "1"); 17635 ck_assert_str_eq(l[1], "333"); 17636 ck_assert_ptr_eq(l[2], null); 17637 // index outside 17638 ck_assert_ptr_eq(iListRemoveElemS(&l, 20), NULL); 17639 ck_assert_ptr_eq(iListRemoveElemS(&l, -4), NULL); 17640 listFreeS(l); 17641 // empty list 17642 listEmptyS(l) 17643 ck_assert_ptr_eq(iListRemoveElemS(&l, 0), NULL); 17644 ck_assert_ptr_eq(iListRemoveElemS(&l, -1), NULL); 17645 listFreeS(l); 17646 // NULL list 17647 l = null; 17648 ck_assert_ptr_eq(iListRemoveElemS(&l, 2), NULL); 17649 ck_assert_ptr_eq(iListRemoveElemS(NULL, 2), NULL); 17650 17651 17652 END_TEST 17653 17654 17655 START_TEST(execOutT) 17656 17657 char **l; 17658 17659 // command 17660 l = execOut("ls chmodTest.null"); 17661 ck_assert_uint_eq(listLengthS(l),1); 17662 ck_assert_str_eq(l[0], "chmodTest.null"); 17663 listFreeS(l); 17664 17665 // invalid command 17666 l = execOut("randomCommand"); 17667 ck_assert_uint_eq(listLengthS(l),0); 17668 ck_assert_ptr_eq(l[0], NULL); 17669 listFreeS(l); 17670 // NULL command 17671 ck_assert_ptr_eq(execOut(NULL), NULL); 17672 17673 END_TEST 17674 17675 17676 START_TEST(systemOutfT) 17677 17678 char **l; 17679 17680 // command 17681 l = systemOutf("ls %s", "chmodTest.null"); 17682 ck_assert_uint_eq(listLengthS(l),1); 17683 ck_assert_str_eq(l[0], "chmodTest.null"); 17684 listFreeS(l); 17685 17686 // invalid command 17687 l = systemOutf("randomCommand"); 17688 ck_assert_uint_eq(listLengthS(l),0); 17689 ck_assert_ptr_eq(l[0], NULL); 17690 listFreeS(l); 17691 // NULL command 17692 ck_assert_ptr_eq(systemOutf(NULL), NULL); 17693 17694 17695 END_TEST 17696 17697 17698 START_TEST(systemfT) 17699 17700 int r; 17701 17702 // command 17703 r = systemf("ls %s", "chmodTest.null"); 17704 ck_assert_int_eq(r,0); 17705 17706 // invalid command 17707 r = systemf("randomCommand"); 17708 ck_assert_int_ne(r,0); 17709 17710 // NULL command 17711 ck_assert_int_eq(systemf(NULL), -1); 17712 17713 17714 END_TEST 17715 17716 17717 START_TEST(commandFT) 17718 17719 int r; 17720 17721 // command 17722 r = command("ls chmodTest.null"); 17723 ck_assert_int_eq(r,0); 17724 17725 // invalid command 17726 r = command("randomCommand"); 17727 ck_assert_int_ne(r,0); 17728 // NULL command 17729 ck_assert_int_eq(command(NULL), -1); 17730 17731 17732 END_TEST 17733 17734 17735 START_TEST(commandfFT) 17736 17737 int r; 17738 17739 // command 17740 r = commandf("ls %s", "chmodTest.null"); 17741 ck_assert_int_eq(r,0); 17742 17743 // invalid command 17744 r = commandf("randomCommand"); 17745 ck_assert_int_ne(r,0); 17746 17747 // NULL command 17748 ck_assert_int_eq(commandf(NULL), -1); 17749 17750 17751 END_TEST 17752 17753 17754 START_TEST(commandNFreeFT) 17755 17756 int r; 17757 17758 // command 17759 r = commandNFree(strdup("ls chmodTest.null")); 17760 ck_assert_int_eq(r,0); 17761 17762 // invalid command 17763 r = commandNFree(strdup("randomCommand")); 17764 ck_assert_int_ne(r,0); 17765 // NULL command 17766 ck_assert_int_eq(commandNFree(NULL), -1); 17767 17768 17769 END_TEST 17770 17771 17772 START_TEST(listEqST) 17773 17774 char **l = NULL; 17775 char **l2; 17776 char **r = null; 17777 17778 // identical lists 17779 r = listPushS(&l, "1"); 17780 ck_assert_ptr_eq(r, l); 17781 r = listPushS(&l, "22"); 17782 ck_assert_ptr_eq(r, l); 17783 r = listPushS(&l, "333"); 17784 ck_assert_ptr_eq(r, l); 17785 r = listPushS(&l, "4444"); 17786 ck_assert_ptr_eq(r, l); 17787 l2 = listDupS(l); 17788 ck_assert(listEqS(l,l2)); 17789 // NULL lists 17790 ck_assert(!listEqS(NULL,l)); 17791 ck_assert(!listEqS(l,NULL)); 17792 ck_assert(!listEqS(NULL,NULL)); 17793 // different lists same number of elements 17794 l[3][0] = 'A'; 17795 ck_assert(!listEqS(l,l2)); 17796 // different number of elements 17797 char *s = listPopS(&l); 17798 free(s); 17799 ck_assert(!listEqS(l,l2)); 17800 listFreeS(l); 17801 listFreeS(l2); 17802 17803 END_TEST 17804 17805 17806 START_TEST(listHasST) 17807 17808 char **l = NULL; 17809 char **r = null; 17810 17811 // string 17812 r = listPushS(&l, "1"); 17813 ck_assert_ptr_eq(r, l); 17814 r = listPushS(&l, "22"); 17815 ck_assert_ptr_eq(r, l); 17816 r = listPushS(&l, "333"); 17817 ck_assert_ptr_eq(r, l); 17818 r = listPushS(&l, "4444"); 17819 ck_assert_ptr_eq(r, l); 17820 ck_assert(listHasS(l, "1")); 17821 // NULL list 17822 ck_assert(!listHasS(NULL, "1")); 17823 // NULL string 17824 ck_assert(!listHasS(l, NULL)); 17825 // non existing element 17826 ck_assert(!listHasS(l, "wfe")); 17827 // string in list 17828 ck_assert(listHasS(l, "333")); 17829 listFreeS(l); 17830 17831 END_TEST 17832 17833 17834 START_TEST(listHasCharST) 17835 17836 char **l = NULL; 17837 char **r = null; 17838 17839 // string 17840 r = listPushS(&l, "1"); 17841 ck_assert_ptr_eq(r, l); 17842 r = listPushS(&l, "22"); 17843 ck_assert_ptr_eq(r, l); 17844 r = listPushS(&l, "333"); 17845 ck_assert_ptr_eq(r, l); 17846 r = listPushS(&l, "4444"); 17847 ck_assert_ptr_eq(r, l); 17848 ck_assert(listHasCharS(l, '1')); 17849 // NULL list 17850 ck_assert(!listHasCharS(NULL, '1')); 17851 // non existing element 17852 ck_assert(!listHasCharS(l, 'w')); 17853 listFreeS(l); 17854 17855 17856 END_TEST 17857 17858 17859 START_TEST(listIndexOfST) 17860 17861 char **l = NULL; 17862 char **r = null; 17863 17864 // string 17865 r = listPushS(&l, "1"); 17866 ck_assert_ptr_eq(r, l); 17867 r = listPushS(&l, "22"); 17868 ck_assert_ptr_eq(r, l); 17869 r = listPushS(&l, "333"); 17870 ck_assert_ptr_eq(r, l); 17871 r = listPushS(&l, "4444"); 17872 ck_assert_ptr_eq(r, l); 17873 ck_assert_uint_eq(listIndexOfS(l, "1"),0); 17874 // NULL list 17875 ck_assert_uint_eq(listIndexOfS(NULL, "1"),-1); 17876 // NULL string 17877 ck_assert_uint_eq(listIndexOfS(l, NULL),-1); 17878 // non existing element 17879 ck_assert_uint_eq(listIndexOfS(l, "wfe"),-1); 17880 // string in list 17881 ck_assert_uint_eq(listIndexOfS(l, "333"),2); 17882 listFreeS(l); 17883 17884 END_TEST 17885 17886 17887 START_TEST(listIndexOfCharST) 17888 17889 char **l = NULL; 17890 char **r = null; 17891 17892 // string 17893 r = listPushS(&l, "1"); 17894 ck_assert_ptr_eq(r, l); 17895 r = listPushS(&l, "22"); 17896 ck_assert_ptr_eq(r, l); 17897 r = listPushS(&l, "333"); 17898 ck_assert_ptr_eq(r, l); 17899 r = listPushS(&l, "4444"); 17900 ck_assert_ptr_eq(r, l); 17901 ck_assert_uint_eq(listIndexOfCharS(l, '1'),0); 17902 // NULL list 17903 ck_assert_uint_eq(listIndexOfCharS(NULL, '1'),-1); 17904 // non existing element 17905 ck_assert_uint_eq(listIndexOfCharS(l, 'w'),-1); 17906 listFreeS(l); 17907 17908 17909 END_TEST 17910 17911 17912 START_TEST(listBinarySearchST) 17913 17914 char **l = NULL; 17915 char **r = null; 17916 17917 // string 17918 r = listPushS(&l, "1"); 17919 ck_assert_ptr_eq(r, l); 17920 r = listPushS(&l, "22"); 17921 ck_assert_ptr_eq(r, l); 17922 r = listPushS(&l, "333"); 17923 ck_assert_ptr_eq(r, l); 17924 r = listPushS(&l, "4444"); 17925 ck_assert_ptr_eq(r, l); 17926 r = listPushS(&l, "5"); 17927 ck_assert_ptr_eq(r, l); 17928 r = listPushS(&l, "6"); 17929 ck_assert_ptr_eq(r, l); 17930 ck_assert_uint_eq(listBinarySearchS(l, "1"),0); 17931 // NULL list 17932 ck_assert_uint_eq(listBinarySearchS(NULL, "1"),-1); 17933 // NULL string 17934 ck_assert_uint_eq(listBinarySearchS(l, NULL),-1); 17935 // non existing element 17936 ck_assert_uint_eq(listBinarySearchS(l, "wfe"),-1); 17937 // string in list 17938 ck_assert_uint_eq(listBinarySearchS(l, "333"),2); 17939 listFreeS(l); 17940 17941 END_TEST 17942 17943 17944 START_TEST(listBinarySearchCharST) 17945 17946 char **l = NULL; 17947 char **r = null; 17948 17949 // string 17950 r = listPushS(&l, "1"); 17951 ck_assert_ptr_eq(r, l); 17952 r = listPushS(&l, "22"); 17953 ck_assert_ptr_eq(r, l); 17954 r = listPushS(&l, "333"); 17955 ck_assert_ptr_eq(r, l); 17956 r = listPushS(&l, "4444"); 17957 ck_assert_ptr_eq(r, l); 17958 r = listPushS(&l, "5"); 17959 ck_assert_ptr_eq(r, l); 17960 r = listPushS(&l, "6"); 17961 ck_assert_ptr_eq(r, l); 17962 ck_assert_uint_eq(listBinarySearchCharS(l, '1'),0); 17963 // NULL list 17964 ck_assert_uint_eq(listBinarySearchCharS(NULL, '1'),-1); 17965 // non existing element 17966 ck_assert_uint_eq(listBinarySearchCharS(l, 'w'),-1); 17967 // string in list 17968 ck_assert_uint_eq(listBinarySearchCharS(l, '5'),4); 17969 listFreeS(l); 17970 17971 17972 END_TEST 17973 17974 17975 START_TEST(listUniqST) 17976 17977 char **l = NULL; 17978 char **l2; 17979 char **r = null; 17980 17981 // list with unique elements 17982 r = listPushS(&l, "1"); 17983 ck_assert_ptr_eq(r, l); 17984 r = listPushS(&l, "22"); 17985 ck_assert_ptr_eq(r, l); 17986 r = listPushS(&l, "333"); 17987 ck_assert_ptr_eq(r, l); 17988 r = listPushS(&l, "4444"); 17989 ck_assert_ptr_eq(r, l); 17990 l2 = listUniqS(l); 17991 ck_assert(listEqS(l,l2)); 17992 // list with identical elements 17993 l[2][0] = '2'; 17994 l[2][1] = '2'; 17995 l[2][2] = 0; 17996 listFreeS(l2); 17997 l2 = listUniqS(l); 17998 ck_assert_uint_eq(listLengthS(l2),3); 17999 ck_assert_str_eq(l2[2], "4444"); 18000 listFreeS(l); 18001 listFreeS(l2); 18002 // list with one element 18003 l = NULL; 18004 r = listPushS(&l, "1"); 18005 ck_assert_ptr_eq(r, l); 18006 l2 = listUniqS(l); 18007 ck_assert_uint_eq(listLengthS(l2),1); 18008 ck_assert_str_eq(l2[0], "1"); 18009 listFreeS(l); 18010 listFreeS(l2); 18011 // empty list 18012 listEmptyS(l) 18013 l2 = listUniqS(l); 18014 ck_assert_uint_eq(listLengthS(l2),0); 18015 ck_assert_ptr_eq(l2[0], NULL); 18016 listFreeS(l); 18017 listFreeS(l2); 18018 // NULL list 18019 ck_assert_ptr_eq(listUniqS(NULL), NULL); 18020 18021 END_TEST 18022 18023 18024 START_TEST(iListUniqST) 18025 18026 char **l = NULL; 18027 char **l2; 18028 char **r = null; 18029 18030 // list with unique elements 18031 r = listPushS(&l, "1"); 18032 ck_assert_ptr_eq(r, l); 18033 r = listPushS(&l, "22"); 18034 ck_assert_ptr_eq(r, l); 18035 r = listPushS(&l, "333"); 18036 ck_assert_ptr_eq(r, l); 18037 r = listPushS(&l, "4444"); 18038 ck_assert_ptr_eq(r, l); 18039 l2 = listDupS(l); 18040 r = iListUniqS(&l2); 18041 ck_assert_ptr_eq(r, l2); 18042 ck_assert(listEqS(l,l2)); 18043 // list with identical elements 18044 l[2][0] = '2'; 18045 l[2][1] = '2'; 18046 l[2][2] = 0; 18047 listFreeS(l2); 18048 l2 = listDupS(l); 18049 r = iListUniqS(&l2); 18050 ck_assert_ptr_eq(r, l2); 18051 ck_assert_uint_eq(listLengthS(l2),3); 18052 ck_assert_str_eq(l2[2], "4444"); 18053 listFreeS(l); 18054 listFreeS(l2); 18055 // list with one element 18056 l = NULL; 18057 r = listPushS(&l, "1"); 18058 ck_assert_ptr_eq(r, l); 18059 l2 = listDupS(l); 18060 r = iListUniqS(&l2); 18061 ck_assert_ptr_eq(r, l2); 18062 ck_assert_uint_eq(listLengthS(l2),1); 18063 ck_assert_str_eq(l2[0], "1"); 18064 listFreeS(l); 18065 listFreeS(l2); 18066 // empty list 18067 listEmptyS(l) 18068 l2 = listDupS(l); 18069 r = iListUniqS(&l2); 18070 ck_assert_ptr_eq(r, l2); 18071 ck_assert_uint_eq(listLengthS(l2),0); 18072 ck_assert_ptr_eq(l2[0], NULL); 18073 listFreeS(l); 18074 listFreeS(l2); 18075 // NULL list 18076 l = NULL; 18077 r = iListUniqS(&l); 18078 ck_assert_ptr_eq(r, l); 18079 ck_assert_ptr_eq(l, NULL); 18080 // NULL var 18081 r = iListUniqS(NULL); 18082 ck_assert_ptr_eq(r, null); 18083 18084 END_TEST 18085 18086 18087 START_TEST(icListEqST) 18088 18089 char **l = NULL; 18090 char **l2; 18091 char **r2 = null; 18092 char *r = null; 18093 18094 // identical lists 18095 r2 = listPushS(&l, "1"); 18096 ck_assert_ptr_eq(r2, l); 18097 r2 = listPushS(&l, "bb"); 18098 ck_assert_ptr_eq(r2, l); 18099 r2 = listPushS(&l, "333"); 18100 ck_assert_ptr_eq(r2, l); 18101 r2 = listPushS(&l, "4444"); 18102 ck_assert_ptr_eq(r2, l); 18103 l2 = listDupS(l); 18104 r = iUpperS(&l2[1]); 18105 ck_assert_ptr_eq(r, l2[1]); 18106 ck_assert(icListEqS(l,l2)); 18107 // NULL lists 18108 ck_assert(!icListEqS(NULL,l)); 18109 ck_assert(!icListEqS(l,NULL)); 18110 ck_assert(!icListEqS(NULL,NULL)); 18111 // different lists same number of elements 18112 l[3][0] = 'A'; 18113 ck_assert(!icListEqS(l,l2)); 18114 // different number of elements 18115 char *s = listPopS(&l); 18116 free(s); 18117 ck_assert(!icListEqS(l,l2)); 18118 listFreeS(l); 18119 listFreeS(l2); 18120 18121 18122 END_TEST 18123 18124 18125 START_TEST(icListHasST) 18126 18127 char **l = NULL; 18128 char **r = null; 18129 18130 // string 18131 r = listPushS(&l, "a"); 18132 ck_assert_ptr_eq(r, l); 18133 r = listPushS(&l, "22"); 18134 ck_assert_ptr_eq(r, l); 18135 r = listPushS(&l, "333"); 18136 ck_assert_ptr_eq(r, l); 18137 r = listPushS(&l, "4444"); 18138 ck_assert_ptr_eq(r, l); 18139 ck_assert(icListHasS(l, "A")); 18140 // NULL list 18141 ck_assert(!icListHasS(NULL, "1")); 18142 // NULL string 18143 ck_assert(!icListHasS(l, NULL)); 18144 // non existing element 18145 ck_assert(!icListHasS(l, "wfe")); 18146 // string in list 18147 ck_assert(icListHasS(l, "333")); 18148 listFreeS(l); 18149 18150 18151 END_TEST 18152 18153 18154 START_TEST(icListHasCharST) 18155 18156 char **l = NULL; 18157 char **r = null; 18158 18159 // string 18160 r = listPushS(&l, "A"); 18161 ck_assert_ptr_eq(r, l); 18162 r = listPushS(&l, "22"); 18163 ck_assert_ptr_eq(r, l); 18164 r = listPushS(&l, "333"); 18165 ck_assert_ptr_eq(r, l); 18166 r = listPushS(&l, "4444"); 18167 ck_assert_ptr_eq(r, l); 18168 ck_assert(icListHasCharS(l, 'a')); 18169 // NULL list 18170 ck_assert(!icListHasCharS(NULL, '1')); 18171 // non existing element 18172 ck_assert(!icListHasCharS(l, 'w')); 18173 listFreeS(l); 18174 18175 18176 END_TEST 18177 18178 18179 START_TEST(icListIndexOfST) 18180 18181 char **l = NULL; 18182 char **r = null; 18183 18184 // string 18185 r = listPushS(&l, "a"); 18186 ck_assert_ptr_eq(r, l); 18187 r = listPushS(&l, "22"); 18188 ck_assert_ptr_eq(r, l); 18189 r = listPushS(&l, "333"); 18190 ck_assert_ptr_eq(r, l); 18191 r = listPushS(&l, "4444"); 18192 ck_assert_ptr_eq(r, l); 18193 ck_assert_uint_eq(icListIndexOfS(l, "A"),0); 18194 // NULL list 18195 ck_assert_uint_eq(icListIndexOfS(NULL, "1"),-1); 18196 // NULL string 18197 ck_assert_uint_eq(icListIndexOfS(l, NULL),-1); 18198 // non existing element 18199 ck_assert_uint_eq(icListIndexOfS(l, "wfe"),-1); 18200 // string in list 18201 ck_assert_uint_eq(icListIndexOfS(l, "333"),2); 18202 listFreeS(l); 18203 18204 18205 END_TEST 18206 18207 18208 START_TEST(icListIndexOfCharST) 18209 18210 char **l = NULL; 18211 char **r = null; 18212 18213 // string 18214 r = listPushS(&l, "A"); 18215 ck_assert_ptr_eq(r, l); 18216 r = listPushS(&l, "22"); 18217 ck_assert_ptr_eq(r, l); 18218 r = listPushS(&l, "333"); 18219 ck_assert_ptr_eq(r, l); 18220 r = listPushS(&l, "4444"); 18221 ck_assert_ptr_eq(r, l); 18222 ck_assert_uint_eq(icListIndexOfCharS(l, 'a'),0); 18223 // NULL list 18224 ck_assert_uint_eq(icListIndexOfCharS(NULL, '1'),-1); 18225 // non existing element 18226 ck_assert_uint_eq(icListIndexOfCharS(l, 'w'),-1); 18227 listFreeS(l); 18228 18229 18230 END_TEST 18231 18232 18233 START_TEST(icListBinarySearchST) 18234 18235 char **l = NULL; 18236 char **r = null; 18237 18238 // string 18239 r = listPushS(&l, "a"); 18240 ck_assert_ptr_eq(r, l); 18241 r = listPushS(&l, "22"); 18242 ck_assert_ptr_eq(r, l); 18243 r = listPushS(&l, "333"); 18244 ck_assert_ptr_eq(r, l); 18245 r = listPushS(&l, "4444"); 18246 ck_assert_ptr_eq(r, l); 18247 r = listPushS(&l, "ccc"); 18248 ck_assert_ptr_eq(r, l); 18249 r = listPushS(&l, "6"); 18250 ck_assert_ptr_eq(r, l); 18251 r = iListSortS(&l); 18252 ck_assert_ptr_eq(r, l); 18253 ck_assert_uint_eq(icListBinarySearchS(l, "A"),4); 18254 // NULL list 18255 ck_assert_uint_eq(icListBinarySearchS(NULL, "1"),-1); 18256 // NULL string 18257 ck_assert_uint_eq(icListBinarySearchS(l, NULL),-1); 18258 // non existing element 18259 ck_assert_uint_eq(icListBinarySearchS(l, "wfe"),-1); 18260 // string in list 18261 ck_assert_uint_eq(icListBinarySearchS(l, "Ccc"),5); 18262 listFreeS(l); 18263 18264 18265 END_TEST 18266 18267 18268 START_TEST(icListBinarySearchCharST) 18269 18270 char **l = NULL; 18271 char **r = null; 18272 18273 // string 18274 r = listPushS(&l, "A"); 18275 ck_assert_ptr_eq(r, l); 18276 r = listPushS(&l, "22"); 18277 ck_assert_ptr_eq(r, l); 18278 r = listPushS(&l, "333"); 18279 ck_assert_ptr_eq(r, l); 18280 r = listPushS(&l, "4444"); 18281 ck_assert_ptr_eq(r, l); 18282 r = listPushS(&l, "C"); 18283 ck_assert_ptr_eq(r, l); 18284 r = listPushS(&l, "6"); 18285 ck_assert_ptr_eq(r, l); 18286 r = iListSortS(&l); 18287 ck_assert_ptr_eq(r, l); 18288 ck_assert_uint_eq(icListBinarySearchCharS(l, 'a'),4); 18289 // NULL list 18290 ck_assert_uint_eq(icListBinarySearchCharS(NULL, '1'),-1); 18291 // non existing element 18292 ck_assert_uint_eq(icListBinarySearchCharS(l, 'w'),-1); 18293 // string in list 18294 ck_assert_uint_eq(icListBinarySearchCharS(l, 'c'),5); 18295 listFreeS(l); 18296 18297 18298 END_TEST 18299 18300 18301 START_TEST(icListUniqST) 18302 18303 char **l = NULL; 18304 char **l2; 18305 char **r = null; 18306 18307 // list with unique elements 18308 r = listPushS(&l, "1"); 18309 ck_assert_ptr_eq(r, l); 18310 r = listPushS(&l, "bb"); 18311 ck_assert_ptr_eq(r, l); 18312 r = listPushS(&l, "333"); 18313 ck_assert_ptr_eq(r, l); 18314 r = listPushS(&l, "4444"); 18315 ck_assert_ptr_eq(r, l); 18316 l2 = icListUniqS(l); 18317 ck_assert(listEqS(l,l2)); 18318 // list with identical elements 18319 l[2][0] = 'B'; 18320 l[2][1] = 'B'; 18321 l[2][2] = 0; 18322 listFreeS(l2); 18323 l2 = icListUniqS(l); 18324 ck_assert_uint_eq(listLengthS(l2),3); 18325 ck_assert_str_eq(l2[2], "4444"); 18326 listFreeS(l); 18327 listFreeS(l2); 18328 // list with one element 18329 l = NULL; 18330 r = listPushS(&l, "1"); 18331 ck_assert_ptr_eq(r, l); 18332 l2 = icListUniqS(l); 18333 ck_assert_uint_eq(listLengthS(l2),1); 18334 ck_assert_str_eq(l2[0], "1"); 18335 listFreeS(l); 18336 listFreeS(l2); 18337 // empty list 18338 listEmptyS(l) 18339 l2 = icListUniqS(l); 18340 ck_assert_uint_eq(listLengthS(l2),0); 18341 ck_assert_ptr_eq(l2[0], NULL); 18342 listFreeS(l); 18343 listFreeS(l2); 18344 // NULL list 18345 ck_assert_ptr_eq(icListUniqS(NULL), NULL); 18346 18347 18348 END_TEST 18349 18350 18351 START_TEST(iicListUniqST) 18352 18353 char **l = NULL; 18354 char **l2; 18355 char **r = null; 18356 18357 // list with unique elements 18358 r = listPushS(&l, "1"); 18359 ck_assert_ptr_eq(r, l); 18360 r = listPushS(&l, "BB"); 18361 ck_assert_ptr_eq(r, l); 18362 r = listPushS(&l, "333"); 18363 ck_assert_ptr_eq(r, l); 18364 r = listPushS(&l, "4444"); 18365 ck_assert_ptr_eq(r, l); 18366 l2 = listDupS(l); 18367 r = iicListUniqS(&l2); 18368 ck_assert_ptr_eq(r, l2); 18369 ck_assert(listEqS(l,l2)); 18370 // list with identical elements 18371 l[2][0] = 'b'; 18372 l[2][1] = 'b'; 18373 l[2][2] = 0; 18374 listFreeS(l2); 18375 l2 = listDupS(l); 18376 r = iicListUniqS(&l2); 18377 ck_assert_ptr_eq(r, l2); 18378 ck_assert_uint_eq(listLengthS(l2),3); 18379 ck_assert_str_eq(l2[2], "4444"); 18380 listFreeS(l); 18381 listFreeS(l2); 18382 // list with one element 18383 l = NULL; 18384 r = listPushS(&l, "1"); 18385 ck_assert_ptr_eq(r, l); 18386 l2 = listDupS(l); 18387 r = iicListUniqS(&l2); 18388 ck_assert_ptr_eq(r, l2); 18389 ck_assert_uint_eq(listLengthS(l2),1); 18390 ck_assert_str_eq(l2[0], "1"); 18391 listFreeS(l); 18392 listFreeS(l2); 18393 // empty list 18394 listEmptyS(l) 18395 l2 = listDupS(l); 18396 r = iicListUniqS(&l2); 18397 ck_assert_ptr_eq(r, l2); 18398 ck_assert_uint_eq(listLengthS(l2),0); 18399 ck_assert_ptr_eq(l2[0], NULL); 18400 listFreeS(l); 18401 listFreeS(l2); 18402 // NULL list 18403 l = NULL; 18404 r = iicListUniqS(&l); 18405 ck_assert_ptr_eq(r, l); 18406 ck_assert_ptr_eq(l, NULL); 18407 // NULL var 18408 r = iicListUniqS(NULL); 18409 ck_assert_ptr_eq(r, null); 18410 18411 18412 END_TEST 18413 18414 18415 START_TEST(listCompactST) 18416 18417 char **l = NULL; 18418 char **l2; 18419 char **r = null; 18420 18421 // list with empty elements 18422 r = listPushS(&l, "1"); 18423 ck_assert_ptr_eq(r, l); 18424 r = listPushS(&l, ""); 18425 ck_assert_ptr_eq(r, l); 18426 r = listPushS(&l, ""); 18427 ck_assert_ptr_eq(r, l); 18428 r = listPushS(&l, "4444"); 18429 ck_assert_ptr_eq(r, l); 18430 l2 = listCompactS(l); 18431 ck_assert_uint_eq(listLengthS(l2),2); 18432 ck_assert_str_eq(l2[1], "4444"); 18433 listFreeS(l); 18434 listFreeS(l2); 18435 // empty list 18436 listEmptyS(l) 18437 l2 = listCompactS(l); 18438 ck_assert_uint_eq(listLengthS(l2),0); 18439 ck_assert_ptr_eq(l2[0], NULL); 18440 listFreeS(l); 18441 listFreeS(l2); 18442 // NULL list 18443 ck_assert_ptr_eq(listCompactS(NULL), NULL); 18444 18445 END_TEST 18446 18447 18448 START_TEST(iListCompactST) 18449 18450 char **l = NULL; 18451 char **l2; 18452 char **r = null; 18453 18454 // list with empty elements 18455 r = listPushS(&l, "1"); 18456 ck_assert_ptr_eq(r, l); 18457 r = listPushS(&l, ""); 18458 ck_assert_ptr_eq(r, l); 18459 r = listPushS(&l, ""); 18460 ck_assert_ptr_eq(r, l); 18461 r = listPushS(&l, "4444"); 18462 ck_assert_ptr_eq(r, l); 18463 l2 = listDupS(l); 18464 r = iListCompactS(&l2); 18465 ck_assert_ptr_eq(r, l2); 18466 ck_assert_uint_eq(listLengthS(l2),2); 18467 ck_assert_str_eq(l2[1], "4444"); 18468 listFreeS(l); 18469 listFreeS(l2); 18470 // list with an empty string 18471 l = NULL; 18472 r = listPushS(&l, ""); 18473 ck_assert_ptr_eq(r, l); 18474 r = iListCompactS(&l); 18475 ck_assert_ptr_eq(r, l); 18476 ck_assert_uint_eq(listLengthS(l),0); 18477 ck_assert_ptr_eq(l[0], NULL); 18478 listFreeS(l); 18479 // empty list 18480 listEmptyS(l) 18481 l2 = listDupS(l); 18482 r = iListCompactS(&l2); 18483 ck_assert_ptr_eq(r, l2); 18484 ck_assert_uint_eq(listLengthS(l2),0); 18485 ck_assert_ptr_eq(l2[0], NULL); 18486 listFreeS(l); 18487 listFreeS(l2); 18488 // NULL list 18489 l = NULL; 18490 r = iListCompactS(&l); 18491 ck_assert_ptr_eq(r, null); 18492 ck_assert_ptr_eq(l, NULL); 18493 // NULL var 18494 r = iListCompactS(NULL); 18495 ck_assert_ptr_eq(r, null); 18496 18497 END_TEST 18498 18499 18500 START_TEST(btraceEnableT) 18501 18502 btraceEnable(); 18503 ck_assert(btraceConfig()); 18504 btraceDisable(); 18505 ck_assert(!btraceConfig()); 18506 18507 18508 END_TEST 18509 18510 18511 START_TEST(btraceT) 18512 18513 char **r; 18514 18515 r = btrace(); 18516 ck_assert_ptr_ne(r, null); 18517 listFreeS(r); 18518 18519 18520 END_TEST 18521 18522 18523 START_TEST(listEmptyFT) 18524 18525 void **l = NULL; 18526 18527 // empty list 18528 l = listEmptyF(); 18529 ck_assert(listIsEmpty(l)); 18530 free(l); 18531 18532 END_TEST 18533 18534 18535 START_TEST(iListEmptyFT) 18536 18537 void **l = NULL; 18538 char *s1 = "lib"; 18539 char *s2 = "sheepy"; 18540 void **r = null; 18541 18542 // empty list 18543 r = listPush(&l, s1); 18544 ck_assert_ptr_eq(r, l); 18545 r = listPush(&l, s2); 18546 ck_assert_ptr_eq(r, l); 18547 r = iListEmptyF(&l); 18548 ck_assert_ptr_eq(r, l); 18549 ck_assert(listIsEmpty(l)); 18550 free(l); 18551 // NULL list 18552 l = NULL; 18553 r = iListEmptyF(&l); 18554 ck_assert_ptr_eq(r, l); 18555 ck_assert(listIsEmpty(l)); 18556 free(l); 18557 // NULL var 18558 r = iListEmptyF(NULL); 18559 ck_assert_ptr_eq(r, null); 18560 18561 END_TEST 18562 18563 18564 START_TEST(listIsEmptyT) 18565 18566 void **l = NULL; 18567 char *s1 = "lib"; 18568 char *s2 = "sheepy"; 18569 void **r = null; 18570 18571 // non empty list 18572 r = listPush(&l, s1); 18573 ck_assert_ptr_eq(r, l); 18574 r = listPush(&l, s2); 18575 ck_assert_ptr_eq(r, l); 18576 // check ck_assert_ptr_null not available in jessie 18577 ck_assert_ptr_ne(l, NULL); 18578 ck_assert(!listIsEmpty(l)); 18579 free(l); 18580 // empty list 18581 listEmpty(l); 18582 ck_assert(listIsEmpty(l)); 18583 free(l); 18584 ck_assert(listIsEmpty(NULL)); 18585 18586 END_TEST 18587 18588 18589 START_TEST(listCreateT) 18590 18591 void **l; 18592 char *s1 = "sheepy"; 18593 char *s2 = "SHEEPY"; 18594 18595 // create list 18596 l = listCreate((void *)s1, (void *)s2, (void *)s1); 18597 // check ck_assert_ptr_null not available in jessie 18598 ck_assert_ptr_ne(l, NULL); 18599 ck_assert_uint_eq(listLength(l),3); 18600 ck_assert_str_eq(l[0], "sheepy"); 18601 ck_assert_str_eq(l[1], "SHEEPY"); 18602 ck_assert_str_eq(l[2], "sheepy"); 18603 free(l); 18604 18605 // NULL first element 18606 ck_assert_ptr_eq(listCreate(NULL, "sheepy"), NULL); 18607 18608 END_TEST 18609 18610 18611 START_TEST(listFromArrayT) 18612 18613 void **l = NULL; 18614 char *array[] = {"1", "22", "333"}; 18615 char *arrayNULL[] = {"1", NULL, "333"}; 18616 18617 // copy array to list 18618 l = listFromArray((void *)array, 3); 18619 ck_assert_uint_eq(listLength(l),3); 18620 ck_assert_str_eq(l[0], "1"); 18621 ck_assert_str_eq(l[1], "22"); 18622 ck_assert_str_eq(l[2], "333"); 18623 free(l); 18624 // array with NULL inside 18625 l = listFromArray((void *)arrayNULL, 3); 18626 ck_assert_uint_eq(listLength(l),2); 18627 ck_assert_str_eq(l[0], "1"); 18628 ck_assert_str_eq(l[1], "333"); 18629 free(l); 18630 // empty list 18631 l = listFromArray((void *)array, 0); 18632 ck_assert(listIsEmpty(l)); 18633 free(l); 18634 // NULL pointer to list 18635 ck_assert_ptr_eq(listFromArray(NULL, 1), NULL); 18636 18637 END_TEST 18638 18639 18640 START_TEST(listPushT) 18641 18642 void **l = NULL; 18643 char *s = "sheepy"; 18644 char *s2 = "SHEEPY"; 18645 void **r = null; 18646 18647 // push strings and NULL list 18648 r = listPush(&l, (void *)s); 18649 ck_assert_ptr_eq(r, l); 18650 // check ck_assert_ptr_null not available in jessie 18651 ck_assert_ptr_ne(l, NULL); 18652 ck_assert_str_eq(l[0], "sheepy"); 18653 r = listPush(&l, (void *)s2); 18654 ck_assert_ptr_eq(r, l); 18655 ck_assert_str_eq(l[1], "SHEEPY"); 18656 ck_assert_str_eq(l[0], "sheepy"); 18657 // push NULL 18658 r = listPush(&l, NULL); 18659 ck_assert_ptr_eq(r, null); 18660 ck_assert_ptr_eq(l[2], NULL); 18661 free(l); 18662 // NULL list and NULL string 18663 l = NULL; 18664 r = listPush(&l, NULL); 18665 ck_assert_ptr_eq(r, null); 18666 ck_assert_ptr_eq(l, NULL); 18667 // empty list 18668 listEmpty(l); 18669 r = listPush(&l, (void *)s); 18670 ck_assert_ptr_eq(r, l); 18671 ck_assert_str_eq(l[0], "sheepy"); 18672 ck_assert_ptr_eq(l[1], NULL); 18673 free(l); 18674 // NULL pointer to list 18675 r = listPush(NULL, NULL); 18676 ck_assert_ptr_eq(r, null); 18677 18678 END_TEST 18679 18680 18681 START_TEST(listPopT) 18682 18683 void **l = NULL; 18684 char *s1 = "sheepy"; 18685 char *s2 = "SHEEPY"; 18686 char *s; 18687 void **r = null; 18688 18689 // pop string 18690 r = listPush(&l, (void *)s1); 18691 ck_assert_ptr_eq(r, l); 18692 r = listPush(&l, (void *)s2); 18693 ck_assert_ptr_eq(r, l); 18694 s = (char *)listPop(&l); 18695 ck_assert_str_eq(s, "SHEEPY"); 18696 ck_assert_uint_eq(listLength(l),1); 18697 // last element 18698 s = (char *)listPop(&l); 18699 ck_assert_str_eq(s, "sheepy"); 18700 ck_assert_uint_eq(listLength(l),0); 18701 // empty list 18702 ck_assert_ptr_eq(listPop(&l), NULL); 18703 free(l); 18704 // NULL list 18705 l = NULL; 18706 ck_assert_ptr_eq(listPop(&l), NULL); 18707 // NULL pointer to list 18708 ck_assert_ptr_eq(listPop(NULL), NULL); 18709 18710 END_TEST 18711 18712 18713 START_TEST(listPrependT) 18714 18715 void **l = NULL; 18716 char *s1 = "sheepy"; 18717 char *s2 = "SHEEPY"; 18718 void **r = null; 18719 18720 // push strings and NULL list 18721 r = listPrepend(&l, (void *)s1); 18722 ck_assert_ptr_eq(r, l); 18723 // check ck_assert_ptr_null not available in jessie 18724 ck_assert_ptr_ne(l, NULL); 18725 ck_assert_str_eq(l[0], "sheepy"); 18726 r = listPrepend(&l, (void *)s2); 18727 ck_assert_ptr_eq(r, l); 18728 ck_assert_str_eq(l[0], "SHEEPY"); 18729 ck_assert_str_eq(l[1], "sheepy"); 18730 // push NULL 18731 r = listPrepend(&l, NULL); 18732 ck_assert_ptr_eq(r, null); 18733 ck_assert_str_eq(l[0], "SHEEPY"); 18734 free(l); 18735 // NULL list and NULL string` 18736 l = NULL; 18737 r = listPrepend(&l, NULL); 18738 ck_assert_ptr_eq(r, null); 18739 ck_assert_ptr_eq(l, NULL); 18740 // empty list 18741 listEmpty(l) 18742 r = listPrepend(&l, (void *)s1); 18743 ck_assert_ptr_eq(r, l); 18744 ck_assert_str_eq(l[0], "sheepy"); 18745 ck_assert_ptr_eq(l[1], NULL); 18746 free(l); 18747 // NULL pointer to list 18748 r = listPrepend(NULL, NULL); 18749 ck_assert_ptr_eq(r, null); 18750 18751 END_TEST 18752 18753 18754 START_TEST(listDequeueT) 18755 18756 void **l = NULL; 18757 char *s1 = "sheepy"; 18758 char *s2 = "SHEEPY"; 18759 char *s; 18760 void **r = null; 18761 18762 // pop string 18763 r = listPush(&l, (void *)s1); 18764 ck_assert_ptr_eq(r, l); 18765 r = listPush(&l, (void *)s2); 18766 ck_assert_ptr_eq(r, l); 18767 s = listDequeue(&l); 18768 ck_assert_str_eq(s, "sheepy"); 18769 ck_assert_uint_eq(listLength(l),1); 18770 // last element 18771 s = listDequeue(&l); 18772 ck_assert_str_eq(s, "SHEEPY"); 18773 ck_assert_uint_eq(listLength(l),0); 18774 // empty list 18775 ck_assert_ptr_eq(listDequeue(&l), NULL); 18776 free(l); 18777 // NULL list 18778 l = NULL; 18779 ck_assert_ptr_eq(listDequeue(&l), NULL); 18780 // NULL pointer to list 18781 ck_assert_ptr_eq(listDequeue(NULL), NULL); 18782 18783 END_TEST 18784 18785 18786 START_TEST(listFreeT) 18787 18788 void **l = NULL; 18789 char *s1 = strdup("sheepy"); 18790 char *s2 = strdup("SHEEPY"); 18791 void **r = null; 18792 18793 // not possible to know if a pointer is already freed 18794 r = listPush(&l, (void *)s1); 18795 ck_assert_ptr_eq(r, l); 18796 r = listPush(&l, (void *)s2); 18797 ck_assert_ptr_eq(r, l); 18798 listFree(l); 18799 // empty list 18800 listEmpty(l); 18801 listFree(l); 18802 // NULL list 18803 listFree(NULL); 18804 18805 END_TEST 18806 18807 18808 START_TEST(listFreeManyT) 18809 18810 void **l1 = NULL; 18811 char *s1 = strdup("sheepy"); 18812 char *s2 = strdup("SHEEPY"); 18813 void **r = null; 18814 18815 // not possible to know if a pointer is already freed 18816 r = listPush(&l1, (void *)s1); 18817 ck_assert_ptr_eq(r, l1); 18818 r = listPush(&l1, (void *)s2); 18819 ck_assert_ptr_eq(r, l1); 18820 void **l2 = listEmptyF(); 18821 listFreeMany(l1, l2); 18822 18823 END_TEST 18824 18825 18826 START_TEST(listLengthT) 18827 18828 void **l; 18829 18830 // list length 18831 l = malloc(2 * sizeof(char *)); 18832 l[0] = (void *)1; 18833 l[1] = NULL; 18834 ck_assert_uint_eq(listLength(l),1); 18835 free(l); 18836 // empty list 18837 listEmpty(l) 18838 ck_assert_uint_eq(listLength(l),0); 18839 free(l); 18840 // NULL list 18841 ck_assert_uint_eq(listLength(NULL),0); 18842 18843 18844 END_TEST 18845 18846 18847 START_TEST(listGetT) 18848 18849 void **l = NULL; 18850 char *s1 = "1"; 18851 char *s2 = "22"; 18852 char *s3 = "333"; 18853 char *s4 = "4444"; 18854 void **r = null; 18855 18856 // get string 18857 r = listPush(&l, (void*)s1); 18858 ck_assert_ptr_eq(r, l); 18859 r = listPush(&l, (void*)s2); 18860 ck_assert_ptr_eq(r, l); 18861 r = listPush(&l, (void*)s3); 18862 ck_assert_ptr_eq(r, l); 18863 r = listPush(&l, (void*)s4); 18864 ck_assert_ptr_eq(r, l); 18865 ck_assert_str_eq(listGet(l, 0), "1"); 18866 // negative index 18867 ck_assert_str_eq(listGet(l, -1), "4444"); 18868 // outside list 18869 ck_assert_ptr_eq(listGet(l, 10), NULL); 18870 ck_assert_ptr_eq(listGet(l, -10), NULL); 18871 free(l); 18872 // negative index in a one element list 18873 l = NULL; 18874 r = listPush(&l, (void*)s1); 18875 ck_assert_ptr_eq(r, l); 18876 r = listPush(&l, NULL); 18877 ck_assert_ptr_eq(r, null); 18878 ck_assert_ptr_ne(listGet(l,-1), NULL); 18879 free(l); 18880 // empty list 18881 listEmpty(l) 18882 ck_assert_ptr_eq(listGet(l,0),NULL); 18883 free(l); 18884 // NULL list 18885 ck_assert_ptr_eq(listGet(NULL, 0), NULL); 18886 18887 END_TEST 18888 18889 18890 START_TEST(listSetT) 18891 18892 void **l = NULL; 18893 char *s1 = "1"; 18894 char *s2 = "22"; 18895 char *s3 = "333"; 18896 char *s4 = "4444"; 18897 char *sA = "@@"; 18898 char *sB = "|"; 18899 void **r = null; 18900 18901 // get string 18902 r = listPush(&l, (void*)sA); 18903 ck_assert_ptr_eq(r, l); 18904 r = listPush(&l, (void*)s2); 18905 ck_assert_ptr_eq(r, l); 18906 r = listPush(&l, (void*)sB); 18907 ck_assert_ptr_eq(r, l); 18908 r = listPush(&l, (void*)s4); 18909 ck_assert_ptr_eq(r, l); 18910 r = listSet(l, 0, (void*)s1); 18911 ck_assert_ptr_eq(r, l); 18912 ck_assert_str_eq(listGet(l, 0), "1"); 18913 // negative index 18914 r = listSet(l, -2, (void*)s3); 18915 ck_assert_ptr_eq(r, l); 18916 ck_assert_str_eq(listGet(l, -2), "333"); 18917 // outside list 18918 // list is unchanged 18919 r = listSet(l, 10, (void*)s1); 18920 ck_assert_ptr_eq(r, null); 18921 r = listSet(l, -10, (void*)s1); 18922 ck_assert_ptr_eq(r, null); 18923 // NULL s var 18924 r = listSet(l, -2, NULL); 18925 ck_assert_ptr_eq(r, l); 18926 ck_assert_str_eq(l[0], "1"); 18927 ck_assert_str_eq(l[1], "22"); 18928 ck_assert_str_eq(l[2], "333"); 18929 ck_assert_str_eq(l[3], "4444"); 18930 free(l); 18931 // negative index in a one element list 18932 l = NULL; 18933 r = listPush(&l, (void*)s1); 18934 ck_assert_ptr_eq(r, l); 18935 r = listPush(&l, NULL); 18936 ck_assert_ptr_eq(r, null); 18937 r = listSet(l, -1, (void*)s1); 18938 ck_assert_ptr_eq(r, l); 18939 ck_assert_str_eq(listGet(l,-1), "1"); 18940 free(l); 18941 // empty list - should not crash 18942 listEmpty(l); 18943 r = listSet(l, 0, (void*)s1); 18944 ck_assert_ptr_eq(r, null); 18945 ck_assert_ptr_eq(listGet(l,0),NULL); 18946 free(l); 18947 // NULL list 18948 r = listSet(NULL, 0, (void*)s1); 18949 ck_assert_ptr_eq(r, null); 18950 ck_assert_ptr_eq(listGet(NULL, 0), NULL); 18951 18952 END_TEST 18953 18954 18955 START_TEST(listDupT) 18956 18957 void **l = NULL; 18958 void **l2; 18959 char *s1 = "1"; 18960 char *s2 = "22"; 18961 char *s3 = "333"; 18962 char *s4 = "4444"; 18963 void **r = null; 18964 18965 // list 18966 r = listPush(&l, (void*)s1); 18967 ck_assert_ptr_eq(r, l); 18968 r = listPush(&l, (void*)s2); 18969 ck_assert_ptr_eq(r, l); 18970 r = listPush(&l, (void*)s3); 18971 ck_assert_ptr_eq(r, l); 18972 r = listPush(&l, (void*)s4); 18973 ck_assert_ptr_eq(r, l); 18974 l2 = listDup(l); 18975 ck_assert_uint_eq(listLength(l2),4); 18976 ck_assert_str_eq(l2[0], "1"); 18977 ck_assert_str_eq(l2[3], "4444"); 18978 free(l); 18979 free(l2); 18980 // empty list 18981 listEmpty(l); 18982 l2 = listDup(l); 18983 ck_assert(listIsEmpty(l2)); 18984 free(l); 18985 free(l2); 18986 // NULL list 18987 ck_assert_ptr_eq(listDup(NULL), NULL); 18988 18989 END_TEST 18990 18991 18992 START_TEST(listReverseT) 18993 18994 void **l = NULL; 18995 void **l2; 18996 char *s1 = "1"; 18997 char *s2 = "22"; 18998 char *s3 = "333"; 18999 char *s4 = "4444"; 19000 void **r = null; 19001 19002 // list 19003 r = listPush(&l, (void*)s1); 19004 ck_assert_ptr_eq(r, l); 19005 r = listPush(&l, (void*)s2); 19006 ck_assert_ptr_eq(r, l); 19007 r = listPush(&l, (void*)s3); 19008 ck_assert_ptr_eq(r, l); 19009 r = listPush(&l, (void*)s4); 19010 ck_assert_ptr_eq(r, l); 19011 l2 = listReverse(l); 19012 ck_assert_uint_eq(listLength(l2),4); 19013 ck_assert_str_eq(l2[0], "4444"); 19014 ck_assert_str_eq(l2[3], "1"); 19015 free(l); 19016 free(l2); 19017 // empty list 19018 listEmpty(l); 19019 l2 = listReverse(l); 19020 ck_assert(listIsEmpty(l2)); 19021 free(l); 19022 free(l2); 19023 // NULL list 19024 ck_assert_ptr_eq(listReverse(NULL), NULL); 19025 19026 END_TEST 19027 19028 19029 START_TEST(iListReverseT) 19030 19031 void **l = NULL; 19032 char *s1 = "1"; 19033 char *s2 = "22"; 19034 char *s3 = "333"; 19035 char *s4 = "4444"; 19036 void **r = null; 19037 19038 // list 19039 r = listPush(&l, (void*)s1); 19040 ck_assert_ptr_eq(r, l); 19041 r = listPush(&l, (void*)s2); 19042 ck_assert_ptr_eq(r, l); 19043 r = listPush(&l, (void*)s3); 19044 ck_assert_ptr_eq(r, l); 19045 r = listPush(&l, (void*)s4); 19046 ck_assert_ptr_eq(r, l); 19047 r = iListReverse(&l); 19048 ck_assert_ptr_eq(r, l); 19049 ck_assert_uint_eq(listLength(l),4); 19050 ck_assert_str_eq(l[0], "4444"); 19051 ck_assert_str_eq(l[3], "1"); 19052 free(l); 19053 /* // empty list */ 19054 listEmpty(l); 19055 r = iListReverse(&l); 19056 ck_assert_ptr_eq(r, l); 19057 ck_assert(listIsEmpty(l)); 19058 free(l); 19059 // NULL list 19060 l = NULL; 19061 r = iListReverse(&l); 19062 ck_assert_ptr_eq(r, l); 19063 ck_assert_ptr_eq(l, NULL); 19064 // NULL var 19065 r = iListReverse(NULL); 19066 ck_assert_ptr_eq(r, null); 19067 19068 END_TEST 19069 19070 19071 START_TEST(listCatT) 19072 19073 void **l = NULL; 19074 void **l2 = NULL; 19075 void **r; 19076 char *s1 = "1"; 19077 char *s2 = "#@#"; 19078 char *s3 = "lib"; 19079 char *s4 = "sheepy"; 19080 19081 // cat lists 19082 r = listPush(&l, (void*)s2); 19083 ck_assert_ptr_eq(r, l); 19084 r = listPush(&l, (void*)s1); 19085 ck_assert_ptr_eq(r, l); 19086 r = listPush(&l2, (void*)s3); 19087 ck_assert_ptr_eq(r, l2); 19088 r = listPush(&l2, (void*)s4); 19089 ck_assert_ptr_eq(r, l2); 19090 r = listCat(l,l2); 19091 ck_assert_str_eq(r[0], "#@#"); 19092 ck_assert_str_eq(r[1], "1"); 19093 ck_assert_str_eq(r[2], "lib"); 19094 ck_assert_str_eq(r[3], "sheepy"); 19095 freeManyS(l,l2,r); 19096 // empty list 19097 listEmpty(l); 19098 r = listCat(l); 19099 ck_assert(listIsEmpty(r)); 19100 freeManyS(r,l); 19101 // cat empty list with list 19102 listEmpty(l); 19103 l2 = NULL; 19104 r = listPush(&l2, (void*)s3); 19105 ck_assert_ptr_eq(r, l2); 19106 r = listPush(&l2, (void*)s4); 19107 ck_assert_ptr_eq(r, l2); 19108 r = listCat(l, l2); 19109 ck_assert_str_eq(r[0], "lib"); 19110 ck_assert_str_eq(r[1], "sheepy"); 19111 freeManyS(l,l2,r); 19112 19113 END_TEST 19114 19115 19116 START_TEST(listAppendT) 19117 19118 void **l = NULL; 19119 void **l2 = NULL; 19120 char *s1 = "1"; 19121 char *s2 = "22"; 19122 char *s3 = "333"; 19123 char *s4 = "4444"; 19124 char *sA = "A"; 19125 char *sB = "BB"; 19126 char *sC = "CCC"; 19127 char *sD = "DDDD"; 19128 void **r = null; 19129 19130 // lists 19131 r = listPush(&l, (void*)s1); 19132 ck_assert_ptr_eq(r, l); 19133 r = listPush(&l, (void*)s2); 19134 ck_assert_ptr_eq(r, l); 19135 r = listPush(&l, (void*)s3); 19136 ck_assert_ptr_eq(r, l); 19137 r = listPush(&l, (void*)s4); 19138 ck_assert_ptr_eq(r, l); 19139 r = listPush(&l2, (void*)sA); 19140 ck_assert_ptr_eq(r, l2); 19141 r = listPush(&l2, (void*)sB); 19142 ck_assert_ptr_eq(r, l2); 19143 r = listPush(&l2, (void*)sC); 19144 ck_assert_ptr_eq(r, l2); 19145 r = listPush(&l2, (void*)sD); 19146 ck_assert_ptr_eq(r, l2); 19147 r = listAppend(&l2,l); 19148 ck_assert_ptr_eq(r, l2); 19149 ck_assert_uint_eq(listLength(l2),8); 19150 ck_assert_str_eq(l2[0], "A"); 19151 ck_assert_str_eq(l2[3], "DDDD"); 19152 ck_assert_str_eq(l2[4],"1"); 19153 ck_assert_str_eq(l2[7],"4444"); 19154 free(l); 19155 // append list to itself - no change 19156 l = NULL; 19157 r = listPush(&l, (void*)s1); 19158 ck_assert_ptr_eq(r, l); 19159 r = listPush(&l, (void*)s2); 19160 ck_assert_ptr_eq(r, l); 19161 r = listPush(&l, (void*)s3); 19162 ck_assert_ptr_eq(r, l); 19163 r = listPush(&l, (void*)s4); 19164 ck_assert_ptr_eq(r, l); 19165 r = listAppend(&l,l); 19166 ck_assert_ptr_eq(r, null); 19167 ck_assert_uint_eq(listLength(l),4); 19168 ck_assert_str_eq(l[0], "1"); 19169 ck_assert_str_eq(l[3], "4444"); 19170 free(l); 19171 // empty list + list 19172 listEmpty(l); 19173 r = listAppend(&l, l2); 19174 ck_assert_ptr_eq(r, l); 19175 //ck_assert(listEqS(l,l2)); 19176 ck_assert_uint_eq(listLength(l),listLength(l2)); 19177 ck_assert_str_eq(l2[0], l[0]); 19178 ck_assert_str_eq(l2[3], l[3]); 19179 ck_assert_str_eq(l2[4], l[4]); 19180 ck_assert_str_eq(l2[7], l[7]); 19181 free(l); 19182 // list + empty list 19183 listEmptyS(l); 19184 r = listAppend(&l2, l); 19185 ck_assert_ptr_eq(r, l2); 19186 ck_assert_uint_eq(listLength(l2),8); 19187 ck_assert_str_eq(l2[0], "A"); 19188 ck_assert_str_eq(l2[3], "DDDD"); 19189 ck_assert_str_eq(l2[4],"1"); 19190 ck_assert_str_eq(l2[7],"4444"); 19191 free(l); 19192 free(l2); 19193 // empty list + empty list 19194 listEmpty(l); 19195 listEmpty(l2); 19196 r = listAppend(&l, l2); 19197 ck_assert_ptr_eq(r, l); 19198 ck_assert(listIsEmpty(l)); 19199 free(l); 19200 free(l2); 19201 // NULL list + list = duplicate 19202 l = NULL; 19203 l2 = NULL; 19204 r = listPush(&l2, (void*)sA); 19205 ck_assert_ptr_eq(r, l2); 19206 r = listPush(&l2, (void*)sB); 19207 ck_assert_ptr_eq(r, l2); 19208 r = listPush(&l2, (void*)sC); 19209 ck_assert_ptr_eq(r, l2); 19210 r = listPush(&l2, (void*)sD); 19211 ck_assert_ptr_eq(r, l2); 19212 r = listAppend(&l,l2); 19213 ck_assert_ptr_eq(r, l); 19214 //ck_assert(listEqS(l,l2)); 19215 ck_assert_uint_eq(listLength(l),listLength(l2)); 19216 ck_assert_str_eq(l2[0], l[0]); 19217 ck_assert_str_eq(l2[3], l[3]); 19218 free(l); 19219 // list + NULL list 19220 r = listAppend(&l2, NULL); 19221 ck_assert_ptr_eq(r, l2); 19222 ck_assert_uint_eq(listLength(l2),4); 19223 ck_assert_str_eq(l2[0], "A"); 19224 ck_assert_str_eq(l2[3], "DDDD"); 19225 free(l2); 19226 // NULL list pointer 19227 r = listAppend(NULL,l2); 19228 ck_assert_ptr_eq(r, null); 19229 // should not crash 19230 19231 END_TEST 19232 19233 19234 START_TEST(listAddT) 19235 19236 void **l = NULL; 19237 void **l2 = NULL; 19238 void **l3; 19239 char *s1 = "1"; 19240 char *s2 = "22"; 19241 char *s3 = "333"; 19242 char *s4 = "4444"; 19243 char *sA = "A"; 19244 char *sB = "BB"; 19245 char *sC = "CCC"; 19246 char *sD = "DDDD"; 19247 void **r = null; 19248 19249 // lists 19250 r = listPush(&l, (void*)s1); 19251 ck_assert_ptr_eq(r, l); 19252 r = listPush(&l, (void*)s2); 19253 ck_assert_ptr_eq(r, l); 19254 r = listPush(&l, (void*)s3); 19255 ck_assert_ptr_eq(r, l); 19256 r = listPush(&l, (void*)s4); 19257 ck_assert_ptr_eq(r, l); 19258 r = listPush(&l2, (void*)sA); 19259 ck_assert_ptr_eq(r, l2); 19260 r = listPush(&l2, (void*)sB); 19261 ck_assert_ptr_eq(r, l2); 19262 r = listPush(&l2, (void*)sC); 19263 ck_assert_ptr_eq(r, l2); 19264 r = listPush(&l2, (void*)sD); 19265 ck_assert_ptr_eq(r, l2); 19266 l3 = listAdd(l2,l); 19267 ck_assert_uint_eq(listLength(l3),8); 19268 ck_assert_str_eq(l3[0], "A"); 19269 ck_assert_str_eq(l3[3], "DDDD"); 19270 ck_assert_str_eq(l3[4],"1"); 19271 ck_assert_str_eq(l3[7],"4444"); 19272 free(l3); 19273 free(l); 19274 // empty list + list 19275 listEmpty(l); 19276 l3 = listAdd(l, l2); 19277 //ck_assert(listEqS(l3,l2)); 19278 ck_assert_uint_eq(listLength(l3),listLength(l2)); 19279 ck_assert_str_eq(l3[0], l2[0]); 19280 ck_assert_str_eq(l3[3], l2[3]); 19281 free(l3); 19282 free(l); 19283 // list + empty list 19284 listEmpty(l) 19285 l3 = listAdd(l2, l); 19286 //ck_assert(listEqS(l3,l2)); 19287 ck_assert_uint_eq(listLength(l3),listLength(l2)); 19288 ck_assert_str_eq(l3[0], l2[0]); 19289 ck_assert_str_eq(l3[3], l2[3]); 19290 free(l3); 19291 free(l); 19292 // empty list + empty list 19293 listEmpty(l); 19294 l3 = listAdd(l, l); 19295 ck_assert(listIsEmpty(l3)); 19296 free(l3); 19297 free(l); 19298 // NULL list + list 19299 l3 = listAdd(NULL,l2); 19300 //ck_assert(listEq(l3,l2)); 19301 ck_assert_uint_eq(listLength(l3),listLength(l2)); 19302 ck_assert_str_eq(l3[0], l2[0]); 19303 ck_assert_str_eq(l3[3], l2[3]); 19304 free(l3); 19305 // list + NULL list 19306 l3 = listAdd(l2, NULL); 19307 //ck_assert(listEqS(l3,l2)); 19308 ck_assert_uint_eq(listLength(l3),listLength(l2)); 19309 ck_assert_str_eq(l3[0], l2[0]); 19310 ck_assert_str_eq(l3[3], l2[3]); 19311 free(l3); 19312 free(l2); 19313 // NULL list + NULL list 19314 ck_assert_ptr_eq(listAdd(NULL,NULL), NULL); 19315 19316 END_TEST 19317 19318 19319 START_TEST(listSliceT) 19320 19321 void **l = NULL; 19322 void **l2; 19323 char *s1 = "1"; 19324 char *s2 = "22"; 19325 char *s3 = "333"; 19326 char *s4 = "4444"; 19327 void **r = null; 19328 19329 // list negative index 19330 r = listPush(&l, (void*)s1); 19331 ck_assert_ptr_eq(r, l); 19332 r = listPush(&l, (void*)s2); 19333 ck_assert_ptr_eq(r, l); 19334 r = listPush(&l, (void*)s3); 19335 ck_assert_ptr_eq(r, l); 19336 r = listPush(&l, (void*)s4); 19337 ck_assert_ptr_eq(r, l); 19338 l2 = listSlice(l, 1,-1); 19339 ck_assert_uint_eq(listLength(l2),2); 19340 ck_assert_str_eq(l2[0], "22"); 19341 ck_assert_str_eq(l2[1], "333"); 19342 free(l); 19343 free(l2); 19344 // start outside 19345 l = NULL; 19346 r = listPush(&l, (void*)s1); 19347 ck_assert_ptr_eq(r, l); 19348 r = listPush(&l, (void*)s2); 19349 ck_assert_ptr_eq(r, l); 19350 r = listPush(&l, (void*)s3); 19351 ck_assert_ptr_eq(r, l); 19352 r = listPush(&l, (void*)s4); 19353 ck_assert_ptr_eq(r, l); 19354 ck_assert_ptr_eq(listSlice(l, 20,-4), NULL); 19355 // end outside 19356 l2 = listSlice(l, 2,40); 19357 ck_assert_uint_eq(listLength(l2),2); 19358 ck_assert_str_eq(l2[0], "333"); 19359 ck_assert_str_eq(l2[1], "4444"); 19360 free(l); 19361 free(l2); 19362 // end negative and outside 19363 l = NULL; 19364 r = listPush(&l, (void*)s1); 19365 ck_assert_ptr_eq(r, l); 19366 r = listPush(&l, (void*)s2); 19367 ck_assert_ptr_eq(r, l); 19368 r = listPush(&l, (void*)s3); 19369 ck_assert_ptr_eq(r, l); 19370 r = listPush(&l, (void*)s4); 19371 ck_assert_ptr_eq(r, l); 19372 ck_assert_ptr_eq(listSlice(l, 2,-40), NULL); 19373 // end before start 19374 ck_assert_ptr_eq(listSlice(l, 3,2), NULL); 19375 free(l); 19376 // negative start last element 19377 l = NULL; 19378 r = listPush(&l, (void*)s1); 19379 ck_assert_ptr_eq(r, l); 19380 r = listPush(&l, (void*)s2); 19381 ck_assert_ptr_eq(r, l); 19382 l2 = listSlice(l, -1,0); 19383 ck_assert_uint_eq(listLength(l2),1); 19384 ck_assert_str_eq(l2[0], "22"); 19385 free(l); 19386 free(l2); 19387 // start = end 19388 l = NULL; 19389 r = listPush(&l, (void*)s1); 19390 ck_assert_ptr_eq(r, l); 19391 r = listPush(&l, (void*)s2); 19392 ck_assert_ptr_eq(r, l); 19393 l2 = listSlice(l, 1,1); 19394 ck_assert_uint_eq(listLength(l2),0); 19395 ck_assert_ptr_eq(l2[0], NULL); 19396 free(l); 19397 free(l2); 19398 // empty list 19399 listEmpty(l) 19400 ck_assert_ptr_eq(listSlice(l, 0,0), NULL); 19401 ck_assert_ptr_eq(listSlice(l, -1,0), NULL); 19402 free(l); 19403 // NULL list 19404 ck_assert_ptr_eq(listSlice(NULL, 2,-4), NULL); 19405 19406 19407 END_TEST 19408 19409 19410 START_TEST(iListSliceT) 19411 19412 void **l = NULL; 19413 char *s1 = "1"; 19414 char *s2 = "22"; 19415 char *s3 = "333"; 19416 char *s4 = "4444"; 19417 void **r = null; 19418 19419 // list negative index 19420 r = listPush(&l, (void*)s1); 19421 ck_assert_ptr_eq(r, l); 19422 r = listPush(&l, (void*)s2); 19423 ck_assert_ptr_eq(r, l); 19424 r = listPush(&l, (void*)s3); 19425 ck_assert_ptr_eq(r, l); 19426 r = listPush(&l, (void*)s4); 19427 ck_assert_ptr_eq(r, l); 19428 r = iListSlice(&l, 1,-1); 19429 ck_assert_ptr_eq(r, l); 19430 ck_assert_uint_eq(listLength(l),2); 19431 ck_assert_str_eq(l[0], "22"); 19432 ck_assert_str_eq(l[1], "333"); 19433 // start outside 19434 r = listPush(&l, (void*)s1); 19435 ck_assert_ptr_eq(r, l); 19436 r = listPush(&l, (void*)s2); 19437 ck_assert_ptr_eq(r, l); 19438 r = iListSlice(&l, 20,-4); 19439 ck_assert_ptr_eq(r, null); 19440 ck_assert_uint_eq(listLength(l),0); 19441 // end outside 19442 r = iListSlice(&l, 2,40); 19443 ck_assert_ptr_eq(r, null); 19444 ck_assert_uint_eq(listLength(l),0); 19445 // end negative and outside 19446 r = iListSlice(&l, 2,-40); 19447 ck_assert_ptr_eq(r, null); 19448 ck_assert_uint_eq(listLength(l),0); 19449 // end before start 19450 r = listPush(&l, (void*)s3); 19451 ck_assert_ptr_eq(r, l); 19452 r = listPush(&l, (void*)s4); 19453 ck_assert_ptr_eq(r, l); 19454 r = iListSlice(&l, 3,2); 19455 ck_assert_ptr_eq(r, null); 19456 ck_assert_uint_eq(listLength(l),0); 19457 free(l); 19458 // negative start last element 19459 l = NULL; 19460 r = listPush(&l, (void*)s1); 19461 ck_assert_ptr_eq(r, l); 19462 r = listPush(&l, (void*)s2); 19463 ck_assert_ptr_eq(r, l); 19464 r = iListSlice(&l, -1,0); 19465 ck_assert_ptr_eq(r, l); 19466 ck_assert_uint_eq(listLength(l),1); 19467 ck_assert_str_eq(l[0], "22"); 19468 free(l); 19469 // start = end 19470 l = NULL; 19471 r = listPush(&l, (void*)s1); 19472 ck_assert_ptr_eq(r, l); 19473 r = listPush(&l, (void*)s2); 19474 ck_assert_ptr_eq(r, l); 19475 r = iListSlice(&l, 1,1); 19476 ck_assert_ptr_eq(r, l); 19477 ck_assert_uint_eq(listLength(l),0); 19478 ck_assert_ptr_eq(l[0], NULL); 19479 free(l); 19480 // empty list 19481 listEmpty(l) 19482 r = iListSlice(&l, 0,0); 19483 ck_assert_ptr_eq(r, null); 19484 ck_assert(listIsEmpty(l)); 19485 r = iListSlice(&l, -1,0); 19486 ck_assert_ptr_eq(r, null); 19487 ck_assert(listIsEmpty(l)); 19488 free(l); 19489 // NULL list 19490 l = NULL; 19491 r = iListSlice(&l, 2,-4); 19492 ck_assert_ptr_eq(r, null); 19493 // NULL var 19494 r = iListSlice(NULL, 2,-4); 19495 ck_assert_ptr_eq(r, null); 19496 19497 19498 END_TEST 19499 19500 19501 START_TEST(listInsertT) 19502 19503 void **l; 19504 void **l2; 19505 void **r; 19506 char *s1 = "1"; 19507 char *s2 = "22"; 19508 char *s3 = "lib"; 19509 19510 // insert 19511 l = listCreate((void*)s1, (void*)s2); 19512 l2 = listCreate((void*)s3); 19513 r = listInsert(l, 0, l2); 19514 ck_assert_uint_eq(listLength(r),3); 19515 ck_assert_str_eq(r[0], "lib"); 19516 ck_assert_str_eq(r[1], "1"); 19517 ck_assert_str_eq(r[2], "22"); 19518 free(r); 19519 // negative index 19520 r = listInsert(l, -1, l2); 19521 ck_assert_uint_eq(listLength(r),3); 19522 ck_assert_str_eq(r[0], "1"); 19523 ck_assert_str_eq(r[1], "22"); 19524 ck_assert_str_eq(r[2], "lib"); 19525 free(r); 19526 // edge 19527 r = listInsert(l, 2, l2); 19528 ck_assert_uint_eq(listLength(r),3); 19529 ck_assert_str_eq(r[0], "1"); 19530 ck_assert_str_eq(r[1], "22"); 19531 ck_assert_str_eq(r[2], "lib"); 19532 free(r); 19533 // outside list 19534 r = listInsert(l, 4, l2); 19535 ck_assert_ptr_eq(r, NULL); 19536 r = listInsert(l, -4, l2); 19537 ck_assert_ptr_eq(r, NULL); 19538 free(l); 19539 // negative index in a one element list 19540 l = listCreate((void*)s1); 19541 r = listInsert(l, -1, l2); 19542 ck_assert_str_eq(r[0], "1"); 19543 ck_assert_str_eq(r[1], "lib"); 19544 freeManyS(l,r); 19545 // empty list 19546 listEmpty(l); 19547 r = listInsert(l, 0, l2); 19548 ck_assert_str_eq(r[0], "lib"); 19549 freeManyS(r,l, l2); 19550 // empty insert list 19551 l = listCreate((void*)s1); 19552 listEmpty(l2); 19553 r = listInsert(l, 0, l2); 19554 ck_assert_str_eq(r[0], "1"); 19555 freeManyS(r,l2); 19556 // NULL insert string 19557 r = listInsert(l, 0, NULL); 19558 ck_assert_ptr_eq(r, NULL); 19559 free(l); 19560 // NULL list 19561 r = listInsert(NULL, 0, NULL); 19562 ck_assert_ptr_eq(r, NULL); 19563 19564 19565 END_TEST 19566 19567 19568 START_TEST(iListInsertT) 19569 19570 void **l; 19571 void **l2; 19572 char *s1 = "1"; 19573 char *s2 = "22"; 19574 char *s3 = "lib"; 19575 void **r = null; 19576 19577 // insert 19578 l = listCreate((void*)s1, (void*)s2); 19579 l2 = listCreate((void*)s3); 19580 r = iListInsert(&l, 0, l2); 19581 ck_assert_ptr_eq(r, l); 19582 ck_assert_uint_eq(listLength(l),3); 19583 ck_assert_str_eq(l[0], "lib"); 19584 ck_assert_str_eq(l[1], "1"); 19585 ck_assert_str_eq(l[2], "22"); 19586 free(l2); 19587 free(l); 19588 // negative index 19589 l = listCreate((void*)s1, (void*)s2); 19590 l2 = listCreate((void*)s3); 19591 r = iListInsert(&l, -1, l2); 19592 ck_assert_ptr_eq(r, l); 19593 ck_assert_uint_eq(listLength(l),3); 19594 ck_assert_str_eq(l[0], "1"); 19595 ck_assert_str_eq(l[1], "22"); 19596 ck_assert_str_eq(l[2], "lib"); 19597 free(l2); 19598 free(l); 19599 // edge 19600 l = listCreate((void*)s1, (void*)s2); 19601 l2 = listCreate((void*)s3); 19602 r = iListInsert(&l, 2, l2); 19603 ck_assert_ptr_eq(r, l); 19604 ck_assert_uint_eq(listLength(l),3); 19605 ck_assert_str_eq(l[0], "1"); 19606 ck_assert_str_eq(l[1], "22"); 19607 ck_assert_str_eq(l[2], "lib"); 19608 free(l2); 19609 free(l); 19610 // outside list 19611 l = listCreate((void*)s1, (void*)s2); 19612 l2 = listCreate((void*)s3); 19613 r = iListInsert(&l, 4, l2); 19614 ck_assert_ptr_eq(r, null); 19615 ck_assert_uint_eq(listLength(l),2); 19616 ck_assert_str_eq(l[0], "1"); 19617 ck_assert_str_eq(l[1], "22"); 19618 r = iListInsert(&l, -4, l2); 19619 ck_assert_ptr_eq(r, null); 19620 ck_assert_uint_eq(listLength(l),2); 19621 ck_assert_str_eq(l[0], "1"); 19622 ck_assert_str_eq(l[1], "22"); 19623 free(l); 19624 // negative index in a one element list 19625 l = listCreate((void*)s1); 19626 r = iListInsert(&l, -1, l2); 19627 ck_assert_ptr_eq(r, l); 19628 ck_assert_str_eq(l[0], "1"); 19629 ck_assert_str_eq(l[1], "lib"); 19630 free(l2); 19631 free(l); 19632 // empty list 19633 listEmpty(l); 19634 l2 = listCreate((void*)s3); 19635 r = iListInsert(&l, 0, l2); 19636 ck_assert_ptr_eq(r, l); 19637 ck_assert_str_eq(l[0], "lib"); 19638 free(l2); 19639 free(l); 19640 // empty insert list 19641 l = listCreate((void*)s1); 19642 listEmpty(l2); 19643 r = iListInsert(&l, 0, l2); 19644 ck_assert_ptr_eq(r, l); 19645 ck_assert_str_eq(l[0], "1"); 19646 free(l2); 19647 // NULL insert string 19648 r = iListInsert(&l, 0, NULL); 19649 ck_assert_ptr_eq(r, null); 19650 ck_assert_str_eq(l[0], "1"); 19651 free(l); 19652 // NULL list 19653 l = NULL; 19654 r = iListInsert(&l, 0, NULL); 19655 ck_assert_ptr_eq(r, null); 19656 ck_assert_ptr_eq(l, NULL); 19657 // NULL var 19658 r = iListInsert(NULL, 0, NULL); 19659 ck_assert_ptr_eq(r, NULL); 19660 19661 19662 END_TEST 19663 19664 19665 START_TEST(listDelT) 19666 19667 void **l = NULL; 19668 void **l2; 19669 char *s1 = "1"; 19670 char *s2 = "22"; 19671 char *s3 = "333"; 19672 char *s4 = "4444"; 19673 void **r = null; 19674 19675 // list negative index 19676 r = listPush(&l, (void*)s1); 19677 ck_assert_ptr_eq(r, l); 19678 r = listPush(&l, (void*)s2); 19679 ck_assert_ptr_eq(r, l); 19680 r = listPush(&l, (void*)s3); 19681 ck_assert_ptr_eq(r, l); 19682 r = listPush(&l, (void*)s4); 19683 ck_assert_ptr_eq(r, l); 19684 l2 = listDel(l, 1,-1); 19685 ck_assert_uint_eq(listLength(l2),2); 19686 ck_assert_str_eq(l2[0], "1"); 19687 ck_assert_str_eq(l2[1], "4444"); 19688 free(l2); 19689 // start outside 19690 ck_assert_ptr_eq(listDel(l, 20,-4), NULL); 19691 // end outside 19692 l2 = listDel(l, 2,40); 19693 ck_assert_uint_eq(listLength(l2),2); 19694 ck_assert_str_eq(l2[0], "1"); 19695 ck_assert_str_eq(l2[1], "22"); 19696 free(l2); 19697 // end negative and outside 19698 ck_assert_ptr_eq(listDel(l, 2,-40), NULL); 19699 // end before start 19700 ck_assert_ptr_eq(listDel(l, 3,2), NULL); 19701 free(l); 19702 // negative start last element 19703 l = NULL; 19704 r = listPush(&l, (void*)s1); 19705 ck_assert_ptr_eq(r, l); 19706 r = listPush(&l, (void*)s2); 19707 ck_assert_ptr_eq(r, l); 19708 l2 = listDel(l, -1,0); 19709 ck_assert_uint_eq(listLength(l2),1); 19710 ck_assert_str_eq(l2[0], "1"); 19711 free(l); 19712 free(l2); 19713 // start negative and outside (delete complete list because end is 0 (=len)) 19714 l = NULL; 19715 r = listPush(&l, (void*)s1); 19716 ck_assert_ptr_eq(r, l); 19717 r = listPush(&l, (void*)s2); 19718 ck_assert_ptr_eq(r, l); 19719 l2 = listDel(l, -3,0); 19720 ck_assert_uint_eq(listLength(l2),0); 19721 ck_assert_ptr_eq(l2[0], NULL); 19722 free(l); 19723 free(l2); 19724 // start = end 19725 l = NULL; 19726 r = listPush(&l, (void*)s1); 19727 ck_assert_ptr_eq(r, l); 19728 r = listPush(&l, (void*)s2); 19729 ck_assert_ptr_eq(r, l); 19730 l2 = listDel(l, 1,1); 19731 ck_assert_uint_eq(listLength(l2),2); 19732 ck_assert_str_eq(l2[0], "1"); 19733 ck_assert_str_eq(l2[1], "22"); 19734 free(l); 19735 free(l2); 19736 // empty list 19737 listEmpty(l) 19738 ck_assert_ptr_eq(listDel(l, 0,0), NULL); 19739 ck_assert_ptr_eq(listDel(l, -1,0), NULL); 19740 free(l); 19741 // NULL list 19742 ck_assert_ptr_eq(listDel(NULL, 2,-4), NULL); 19743 19744 19745 END_TEST 19746 19747 19748 START_TEST(iListDelT) 19749 19750 void **l = NULL; 19751 char *s1 = "1"; 19752 char *s2 = "22"; 19753 char *s3 = "333"; 19754 char *s4 = "4444"; 19755 void **r = null; 19756 19757 // list negative index 19758 r = listPush(&l, (void*)s1); 19759 ck_assert_ptr_eq(r, l); 19760 r = listPush(&l, (void*)s2); 19761 ck_assert_ptr_eq(r, l); 19762 r = listPush(&l, (void*)s3); 19763 ck_assert_ptr_eq(r, l); 19764 r = listPush(&l, (void*)s4); 19765 ck_assert_ptr_eq(r, l); 19766 r = iListDel(&l, 1,-1); 19767 ck_assert_ptr_eq(r, l); 19768 ck_assert_uint_eq(listLength(l),2); 19769 ck_assert_str_eq(l[0], "1"); 19770 ck_assert_str_eq(l[1], "4444"); 19771 r = iListEmptyF(&l); 19772 ck_assert_ptr_eq(r, l); 19773 // start outside 19774 r = listPush(&l, (void*)s1); 19775 ck_assert_ptr_eq(r, l); 19776 r = listPush(&l, (void*)s2); 19777 ck_assert_ptr_eq(r, l); 19778 r = listPush(&l, (void*)s3); 19779 ck_assert_ptr_eq(r, l); 19780 r = listPush(&l, (void*)s4); 19781 ck_assert_ptr_eq(r, l); 19782 r = iListDel(&l, 20,-4); 19783 ck_assert_ptr_eq(r, null); 19784 ck_assert_uint_eq(listLength(l),4); 19785 ck_assert_str_eq(l[0], "1"); 19786 ck_assert_str_eq(l[3], "4444"); 19787 // end outside 19788 r = iListDel(&l, 2,40); 19789 ck_assert_ptr_eq(r, l); 19790 ck_assert_uint_eq(listLength(l),2); 19791 ck_assert_str_eq(l[0], "1"); 19792 ck_assert_str_eq(l[1], "22"); 19793 r = iListEmptyF(&l); 19794 ck_assert_ptr_eq(r, l); 19795 // end negative and outside 19796 r = listPush(&l, (void*)s1); 19797 ck_assert_ptr_eq(r, l); 19798 r = listPush(&l, (void*)s2); 19799 ck_assert_ptr_eq(r, l); 19800 r = listPush(&l, (void*)s3); 19801 ck_assert_ptr_eq(r, l); 19802 r = listPush(&l, (void*)s4); 19803 ck_assert_ptr_eq(r, l); 19804 r = iListDel(&l, 2,-40); 19805 ck_assert_ptr_eq(r, null); 19806 ck_assert_uint_eq(listLength(l),4); 19807 ck_assert_str_eq(l[0], "1"); 19808 ck_assert_str_eq(l[3], "4444"); 19809 // end before start 19810 r = iListDel(&l, 3,2); 19811 ck_assert_ptr_eq(r, null); 19812 ck_assert_uint_eq(listLength(l),4); 19813 ck_assert_str_eq(l[0], "1"); 19814 ck_assert_str_eq(l[3], "4444"); 19815 r = iListEmptyF(&l); 19816 ck_assert_ptr_eq(r, l); 19817 // negative start last element 19818 r = listPush(&l, (void*)s1); 19819 ck_assert_ptr_eq(r, l); 19820 r = listPush(&l, (void*)s2); 19821 ck_assert_ptr_eq(r, l); 19822 r = iListDel(&l, -1,0); 19823 ck_assert_ptr_eq(r, l); 19824 ck_assert_uint_eq(listLength(l),1); 19825 ck_assert_str_eq(l[0], "1"); 19826 r = iListEmptyF(&l); 19827 ck_assert_ptr_eq(r, l); 19828 // start negative and outside (delete complete list because end is 0 (=len)) 19829 r = listPush(&l, (void*)s1); 19830 ck_assert_ptr_eq(r, l); 19831 r = listPush(&l, (void*)s2); 19832 ck_assert_ptr_eq(r, l); 19833 r = iListDel(&l, -3,0); 19834 ck_assert_ptr_eq(r, l); 19835 ck_assert_uint_eq(listLength(l),0); 19836 ck_assert_ptr_eq(l[0], NULL); 19837 // start = end 19838 // (l is empty from previous test) 19839 r = listPush(&l, (void*)s1); 19840 ck_assert_ptr_eq(r, l); 19841 r = listPush(&l, (void*)s2); 19842 ck_assert_ptr_eq(r, l); 19843 r = iListDel(&l, 1,1); 19844 ck_assert_ptr_eq(r, l); 19845 ck_assert_uint_eq(listLength(l),2); 19846 ck_assert_str_eq(l[0], "1"); 19847 ck_assert_str_eq(l[1], "22"); 19848 free(l); 19849 // empty list 19850 listEmpty(l); 19851 r = iListDel(&l, 0,0); 19852 ck_assert_ptr_eq(r, null); 19853 ck_assert(listIsEmpty(l)); 19854 r = iListDel(&l, -1,0); 19855 ck_assert_ptr_eq(r, null); 19856 ck_assert(listIsEmpty(l)); 19857 free(l); 19858 // NULL list 19859 l = NULL; 19860 r = iListDel(&l, 2,-4); 19861 ck_assert_ptr_eq(r, null); 19862 ck_assert_ptr_eq(l, NULL); 19863 // NULL var 19864 r = iListDel(NULL, 2,-4); 19865 ck_assert_ptr_eq(r, null); 19866 19867 19868 END_TEST 19869 19870 ringMake(ringTestT, int, 4); 19871 19872 START_TEST(ringInitT) 19873 19874 ringTestT rg; 19875 19876 ck_assert_int_eq(ringInit(&rg, 4), 1); 19877 19878 // NULL 19879 ck_assert_int_eq(ringInit(NULL, 4), 0); 19880 19881 19882 END_TEST 19883 19884 19885 START_TEST(ringEmptyT) 19886 19887 ringTestT rg; 19888 ringInit(&rg, 4); 19889 19890 // empty 19891 ringPush(&rg); 19892 ck_assert_int_eq(ringEmpty(&rg), 1); 19893 ck_assert_int_eq(ringIsEmpty(&rg), 1); 19894 19895 // already empty 19896 ck_assert_int_eq(ringEmpty(&rg), 1); 19897 19898 // null ring 19899 ck_assert_int_eq(ringEmpty(null), 0); 19900 19901 END_TEST 19902 19903 19904 START_TEST(ringIsEmptyT) 19905 19906 ringTestT rg; 19907 ringInit(&rg, 4); 19908 19909 // empty 19910 ck_assert_int_eq(ringIsEmpty(&rg), 1); 19911 19912 // not empty 19913 ringPush(&rg); 19914 ck_assert_int_eq(ringIsEmpty(&rg), 0); 19915 19916 // NULL 19917 ck_assert_int_eq(ringIsEmpty(NULL), -1); 19918 19919 19920 END_TEST 19921 19922 19923 START_TEST(ringIsFullT) 19924 19925 ringTestT rg; 19926 ringInit(&rg, 4); 19927 19928 // full 19929 ringPush(&rg); 19930 rg.last = 2; 19931 rg.head = 3; 19932 ck_assert_int_eq(ringIsFull(&rg), 1); 19933 19934 // not full 19935 rg.last = 1; 19936 ck_assert_int_eq(ringIsFull(&rg), 0); 19937 19938 // NULL 19939 ck_assert_int_eq(ringIsFull(NULL), -1); 19940 19941 END_TEST 19942 19943 19944 START_TEST(ringCountT) 19945 19946 ringTestT rg; 19947 ringInit(&rg, 4); 19948 19949 // empty 19950 ck_assert_int_eq(ringCount(&rg), 0); 19951 // last < head 19952 ringPush(&rg); 19953 rg.last = 2; 19954 rg.head = 3; 19955 ck_assert_int_eq(ringCount(&rg), 4); 19956 // cound > head 19957 rg.head = 0; 19958 rg.last = 2; 19959 ck_assert_int_eq(ringCount(&rg), 3); 19960 // NULL 19961 ck_assert_int_eq(ringCount(NULL), -1); 19962 19963 END_TEST 19964 19965 19966 START_TEST(ringPushT) 19967 19968 ringTestT rg; 19969 ringInit(&rg, 4); 19970 19971 // push 19972 ck_assert_int_eq(ringPush(&rg), 0); 19973 ck_assert_int_eq(ringPush(&rg), 1); 19974 ck_assert_int_eq(ringPush(&rg), 2); 19975 ck_assert_int_eq(ringPush(&rg), 3); 19976 // full 19977 ck_assert_int_eq(ringPush(&rg), -1); 19978 ck_assert_int_eq(ringPush(&rg), -1); 19979 // NULL 19980 ck_assert_int_eq(ringPush(NULL), -2); 19981 19982 19983 END_TEST 19984 19985 19986 START_TEST(ringPopT) 19987 19988 ringTestT rg; 19989 ringInit(&rg, 4); 19990 19991 // empty ring 19992 ck_assert_int_eq(ringPop(&rg), 0); 19993 // pop 19994 ringPush(&rg); 19995 ringPush(&rg); 19996 ck_assert_int_eq(ringPop(&rg), 1); 19997 // pop last 19998 ck_assert_int_eq(ringPop(&rg), 1); 19999 // pop when head > last 20000 rg.isEmpty = false; 20001 rg.head = 3; 20002 ck_assert_int_eq(ringPop(&rg), 1); 20003 // NULL 20004 ck_assert_int_eq(ringPop(NULL), -1); 20005 20006 END_TEST 20007 20008 20009 START_TEST(ringPrependT) 20010 20011 ringTestT rg; 20012 ringInit(&rg, 4); 20013 20014 // push 20015 ck_assert_int_eq(ringPrepend(&rg), 0); 20016 ck_assert_int_eq(ringPrepend(&rg), 3); 20017 ck_assert_int_eq(ringPrepend(&rg), 2); 20018 ck_assert_int_eq(ringPrepend(&rg), 1); 20019 // full 20020 ck_assert_int_eq(ringPrepend(&rg), -1); 20021 ck_assert_int_eq(ringPrepend(&rg), -1); 20022 // NULL 20023 ck_assert_int_eq(ringPrepend(NULL), -2); 20024 20025 END_TEST 20026 20027 20028 START_TEST(ringDequeueT) 20029 20030 ringTestT rg; 20031 ringInit(&rg, 4); 20032 20033 // empty ring 20034 ck_assert_int_eq(ringDequeue(&rg), 0); 20035 // pop 20036 ringPush(&rg); 20037 ringPush(&rg); 20038 ck_assert_int_eq(ringDequeue(&rg), 1); 20039 // pop last 20040 ck_assert_int_eq(ringDequeue(&rg), 1); 20041 // pop when head > last 20042 rg.isEmpty = false; 20043 rg.head = 3; 20044 ck_assert_int_eq(ringDequeue(&rg), 1); 20045 // NULL 20046 ck_assert_int_eq(ringDequeue(NULL), -1); 20047 20048 END_TEST 20049 20050 #define chanMax 30 20051 ringMake(chanT, int, chanMax); 20052 20053 // context for fibers of type fiberA 20054 typedef struct {int slot; int a; chanT *c;} AArgs; 20055 20056 // declaration of fibers type fiberA 20057 void fiberATest(int thisSlot UNUSED) { 20058 return; 20059 } 20060 20061 START_TEST(fiberAddT) 20062 20063 staticArrayInit(fibers.L); 20064 staticArrayInit(fibers.startL); 20065 20066 AArgs Aa; 20067 chanT c; 20068 20069 ringInit(&c, chanMax); 20070 20071 Aa.c = &c; 20072 20073 ck_assert(fiberAdd(&Aa, 1, fiberATest)); 20074 20075 END_TEST 20076 20077 20078 START_TEST(fiberPrependT) 20079 20080 staticArrayInit(fibers.L); 20081 staticArrayInit(fibers.startL); 20082 20083 AArgs Aa; 20084 chanT c; 20085 20086 ringInit(&c, chanMax); 20087 20088 Aa.c = &c; 20089 20090 ck_assert(fiberPrepend(&Aa, 1, fiberATest)); 20091 20092 END_TEST 20093 20094 20095 START_TEST(schedulerT) 20096 20097 staticArrayInit(fibers.L); 20098 staticArrayInit(fibers.startL); 20099 20100 scheduler(); 20101 20102 AArgs Aa; 20103 chanT c; 20104 20105 ringInit(&c, chanMax); 20106 20107 Aa.c = &c; 20108 20109 fiberAdd(&Aa, 1, fiberATest); 20110 20111 scheduler(); 20112 20113 // TODO test 100% 20114 20115 END_TEST 20116 20117 20118 START_TEST(getMonotonicTimeT) 20119 20120 uint64_t r = getMonotonicTime(); 20121 ck_assert_uint_ne(r, 0); 20122 20123 END_TEST 20124 20125 20126 START_TEST(nanoSleepT) 20127 20128 int r; 20129 20130 nanoSleep(100); 20131 nanoSleepE(100, puts(BLD RED "nanosleep error" RST)); 20132 r = nanoSleepF(100); 20133 ck_assert_int_eq(r, 1); 20134 20135 END_TEST 20136 20137 20138 20139 Suite * libsheepySuite(void) { 20140 Suite *s; 20141 TCase *tc_core; 20142 20143 s = suite_create("libsheepy"); 20144 20145 /* Core test case */ 20146 tc_core = tcase_create("Core"); 20147 20148 // disable btrace to make the test run faster 20149 btraceDisable(); 20150 tcase_add_test(tc_core, cleanUpCharFreeT); 20151 tcase_add_test(tc_core, cleanUpListFreeT); 20152 tcase_add_test(tc_core, cleanUpFileFreeT); 20153 tcase_add_test(tc_core, cleanUpCharFreeNullT); 20154 tcase_add_test(tc_core, cleanUpListFreeNullT); 20155 tcase_add_test(tc_core, cleanUpFileFreeNullT); 20156 tcase_add_test(tc_core, setLogSymbolsT); 20157 tcase_add_test(tc_core, setMaxLogLevelT); 20158 tcase_add_test(tc_core, setLogShortPathT); 20159 tcase_add_test(tc_core, setLogStdoutT); 20160 tcase_add_test(tc_core, openProgLogFileT); 20161 tcase_add_test(tc_core, shStopwatchT); 20162 tcase_add_test(tc_core, setLogFileT); 20163 tcase_add_test(tc_core, closeLogFilesT); 20164 tcase_add_test(tc_core, getLogModeT); 20165 tcase_add_test(tc_core, setLogModeT); 20166 tcase_add_test(tc_core, _pLogT); 20167 tcase_add_test(tc_core, initLibsheepyFT); 20168 tcase_add_test(tc_core, setStackLimitT); 20169 tcase_add_test(tc_core, setProgNameT); 20170 tcase_add_test(tc_core, getProgPathT); 20171 tcase_add_test(tc_core, getRealProgPathT); 20172 tcase_add_test(tc_core, systemNFreeFT); 20173 tcase_add_test(tc_core, getModificationTimeT); 20174 tcase_add_test(tc_core, setModificationTimeT); 20175 tcase_add_test(tc_core, isReadableT); 20176 tcase_add_test(tc_core, isWritableT); 20177 tcase_add_test(tc_core, isExecutableT); 20178 tcase_add_test(tc_core, equalModificationTimesT); 20179 tcase_add_test(tc_core, getCurrentUnixTimeT); 20180 tcase_add_test(tc_core, strToUnixTimeT); 20181 tcase_add_test(tc_core, timeToST); 20182 tcase_add_test(tc_core, timeToYMDST); 20183 tcase_add_test(tc_core, getCurrentDateT); 20184 tcase_add_test(tc_core, getCurrentDateYMDT); 20185 tcase_add_test(tc_core, shDirnameT); 20186 tcase_add_test(tc_core, bDirnameT); 20187 tcase_add_test(tc_core, bLDirnameT); 20188 tcase_add_test(tc_core, expandHomeT); 20189 tcase_add_test(tc_core, iExpandHomeT); 20190 tcase_add_test(tc_core, bExpandHomeT); 20191 tcase_add_test(tc_core, bLExpandHomeT); 20192 tcase_add_test(tc_core, normalizePathT); 20193 tcase_add_test(tc_core, iNormalizePathT); 20194 tcase_add_test(tc_core, bNormalizePathT); 20195 tcase_add_test(tc_core, bLNormalizePathT); 20196 tcase_add_test(tc_core, relPathT); 20197 tcase_add_test(tc_core, iRelPathT); 20198 tcase_add_test(tc_core, bRelPathT); 20199 tcase_add_test(tc_core, bLRelPathT); 20200 tcase_add_test(tc_core, getHomePathT); 20201 tcase_add_test(tc_core, getCwdT); 20202 tcase_add_test(tc_core, chDirT); 20203 tcase_add_test(tc_core, isDirT); 20204 tcase_add_test(tc_core, shReadlinkT); 20205 tcase_add_test(tc_core, endlinkT); 20206 tcase_add_test(tc_core, isLinkT); 20207 tcase_add_test(tc_core, fileExistsT); 20208 tcase_add_test(tc_core, fileChmodT); 20209 tcase_add_test(tc_core, fileSizeT); 20210 tcase_add_test(tc_core, fileSizeFPT); 20211 tcase_add_test(tc_core, readFileToST); 20212 tcase_add_test(tc_core, readStreamToST); 20213 tcase_add_test(tc_core, bReadFileToST); 20214 tcase_add_test(tc_core, bReadStreamToST); 20215 tcase_add_test(tc_core, bLReadFileToST); 20216 tcase_add_test(tc_core, bLReadStreamToST); 20217 tcase_add_test(tc_core, readFileT); 20218 tcase_add_test(tc_core, bReadFileT); 20219 tcase_add_test(tc_core, bLReadFileT); 20220 tcase_add_test(tc_core, writeFileST); 20221 tcase_add_test(tc_core, writeFileT); 20222 tcase_add_test(tc_core, writeStreamST); 20223 tcase_add_test(tc_core, writeLStreamT); 20224 tcase_add_test(tc_core, appendFileST); 20225 tcase_add_test(tc_core, appendFileT); 20226 tcase_add_test(tc_core, walkDirT); 20227 tcase_add_test(tc_core, walkDirDirT); 20228 tcase_add_test(tc_core, readDirT); 20229 tcase_add_test(tc_core, readDirDirT); 20230 tcase_add_test(tc_core, walkDirAllT); 20231 tcase_add_test(tc_core, readDirAllT); 20232 tcase_add_test(tc_core, mkdirParentsT); 20233 tcase_add_test(tc_core, rmAllT); 20234 tcase_add_test(tc_core, copyT); 20235 tcase_add_test(tc_core, shRenameT); 20236 tcase_add_test(tc_core, shMoveT); 20237 tcase_add_test(tc_core, setSoftwareRandomT); 20238 tcase_add_test(tc_core, setHardwareRandomT); 20239 tcase_add_test(tc_core, randomOpenCloseT); 20240 tcase_add_test(tc_core, randomWordT); 20241 tcase_add_test(tc_core, randomWordFromHWT); 20242 tcase_add_test(tc_core, randomChoiceT); 20243 tcase_add_test(tc_core, randomST); 20244 tcase_add_test(tc_core, bRandomST); 20245 tcase_add_test(tc_core, randomAlphaNumST); 20246 tcase_add_test(tc_core, bRandomAlphaNumST); 20247 tcase_add_test(tc_core, readST); 20248 tcase_add_test(tc_core, bLReadST); 20249 tcase_add_test(tc_core, readPasswordST); 20250 tcase_add_test(tc_core, zeroST); 20251 tcase_add_test(tc_core, zeroBufT); 20252 tcase_add_test(tc_core, memdupT); 20253 tcase_add_test(tc_core, readEnterT); 20254 tcase_add_test(tc_core, readLineT); 20255 tcase_add_test(tc_core, dupST); 20256 tcase_add_test(tc_core, shPrintfST); 20257 tcase_add_test(tc_core, shEprintfT); 20258 tcase_add_test(tc_core, freeManyST); 20259 tcase_add_test(tc_core, logNFreeT); 20260 tcase_add_test(tc_core, loghexT); 20261 tcase_add_test(tc_core, toHexST); 20262 tcase_add_test(tc_core, toHexSepST); 20263 tcase_add_test(tc_core, toHexHeadSepST); 20264 tcase_add_test(tc_core, strCpyT); 20265 tcase_add_test(tc_core, strNCpyT); 20266 tcase_add_test(tc_core, strLCpyT); 20267 tcase_add_test(tc_core, strCatT); 20268 tcase_add_test(tc_core, strNCatT); 20269 tcase_add_test(tc_core, strLCatT); 20270 tcase_add_test(tc_core, strLNCatT); 20271 tcase_add_test(tc_core, catST); 20272 tcase_add_test(tc_core, iCatST); 20273 tcase_add_test(tc_core, bLCatST); 20274 tcase_add_test(tc_core, formatST); 20275 tcase_add_test(tc_core, appendST); 20276 tcase_add_test(tc_core, appendCharST); 20277 tcase_add_test(tc_core, appendSCharT); 20278 tcase_add_test(tc_core, iAppendST); 20279 tcase_add_test(tc_core, iAppendCharST); 20280 tcase_add_test(tc_core, iAppendNFreeST); 20281 tcase_add_test(tc_core, iAppendManyST); 20282 tcase_add_test(tc_core, bAppendManyST); 20283 tcase_add_test(tc_core, bLAppendManyST); 20284 tcase_add_test(tc_core, prependST); 20285 tcase_add_test(tc_core, prependCharST); 20286 tcase_add_test(tc_core, prependSCharT); 20287 tcase_add_test(tc_core, iPrependST); 20288 tcase_add_test(tc_core, iPrependCharST); 20289 tcase_add_test(tc_core, iPrependNFreeST); 20290 tcase_add_test(tc_core, bPrependST); 20291 tcase_add_test(tc_core, bLPrependST); 20292 tcase_add_test(tc_core, replaceST); 20293 tcase_add_test(tc_core, replaceCharSST); 20294 tcase_add_test(tc_core, replaceSCharST); 20295 tcase_add_test(tc_core, replaceCharCharST); 20296 tcase_add_test(tc_core, iReplaceST); 20297 tcase_add_test(tc_core, iReplaceCharSST); 20298 tcase_add_test(tc_core, iReplaceSCharST); 20299 tcase_add_test(tc_core, iReplaceCharCharST); 20300 tcase_add_test(tc_core, bReplaceST); 20301 tcase_add_test(tc_core, bLReplaceST); 20302 tcase_add_test(tc_core, icReplaceST); 20303 tcase_add_test(tc_core, iicReplaceST); 20304 tcase_add_test(tc_core, bicReplaceST); 20305 tcase_add_test(tc_core, bLicReplaceST); 20306 tcase_add_test(tc_core, replaceManyST); 20307 tcase_add_test(tc_core, iReplaceManyST); 20308 tcase_add_test(tc_core, bReplaceManyST); 20309 tcase_add_test(tc_core, bLReplaceManyST); 20310 tcase_add_test(tc_core, icReplaceManyST); 20311 tcase_add_test(tc_core, iicReplaceManyST); 20312 tcase_add_test(tc_core, bicReplaceManyST); 20313 tcase_add_test(tc_core, bLicReplaceManyST); 20314 tcase_add_test(tc_core, eqST); 20315 tcase_add_test(tc_core, eqCharST); 20316 tcase_add_test(tc_core, eqSCharT); 20317 tcase_add_test(tc_core, eqIST); 20318 tcase_add_test(tc_core, eqICharST); 20319 tcase_add_test(tc_core, startsWithST); 20320 tcase_add_test(tc_core, startsWithCharST); 20321 tcase_add_test(tc_core, endsWithST); 20322 tcase_add_test(tc_core, endsWithCharST); 20323 tcase_add_test(tc_core, countST); 20324 tcase_add_test(tc_core, countCharST); 20325 tcase_add_test(tc_core, icEqST); 20326 tcase_add_test(tc_core, icEqCharST); 20327 tcase_add_test(tc_core, icEqSCharT); 20328 tcase_add_test(tc_core, icEqIST); 20329 tcase_add_test(tc_core, icEqICharST); 20330 tcase_add_test(tc_core, icStartsWithST); 20331 tcase_add_test(tc_core, icStartsWithCharST); 20332 tcase_add_test(tc_core, icEndsWithST); 20333 tcase_add_test(tc_core, icEndsWithCharST); 20334 tcase_add_test(tc_core, icCountST); 20335 tcase_add_test(tc_core, icCountCharST); 20336 tcase_add_test(tc_core, hasCtrlCharT); 20337 tcase_add_test(tc_core, stripCtrlST); 20338 tcase_add_test(tc_core, iStripCtrlST); 20339 tcase_add_test(tc_core, bStripCtrlST); 20340 tcase_add_test(tc_core, quoteST); 20341 tcase_add_test(tc_core, bQuoteST); 20342 tcase_add_test(tc_core, bLQuoteST); 20343 tcase_add_test(tc_core, quoteLenST); 20344 tcase_add_test(tc_core, escapeST); 20345 tcase_add_test(tc_core, bEscapeST); 20346 tcase_add_test(tc_core, bLEscapeST); 20347 tcase_add_test(tc_core, escapeLenST); 20348 tcase_add_test(tc_core, nibbleToHexT); 20349 tcase_add_test(tc_core, cEscapeST); 20350 tcase_add_test(tc_core, bCEscapeST); 20351 tcase_add_test(tc_core, bLCEscapeST); 20352 tcase_add_test(tc_core, cEscapeLenST); 20353 tcase_add_test(tc_core, isNumberT); 20354 tcase_add_test(tc_core, isIntT); 20355 tcase_add_test(tc_core, parseIntT); 20356 tcase_add_test(tc_core, parseIntCharT); 20357 tcase_add_test(tc_core, parseI64T); 20358 tcase_add_test(tc_core, parseI64CharT); 20359 tcase_add_test(tc_core, parseDoubleT); 20360 tcase_add_test(tc_core, parseDoubleCharT); 20361 tcase_add_test(tc_core, parseHexT); 20362 tcase_add_test(tc_core, intToST); 20363 tcase_add_test(tc_core, bIntToST); 20364 tcase_add_test(tc_core, doubleToST); 20365 tcase_add_test(tc_core, bDoubleToST); 20366 tcase_add_test(tc_core, lenST); 20367 tcase_add_test(tc_core, sizeST); 20368 tcase_add_test(tc_core, upperST); 20369 tcase_add_test(tc_core, iUpperST); 20370 tcase_add_test(tc_core, bUpperST); 20371 tcase_add_test(tc_core, lowerST); 20372 tcase_add_test(tc_core, iLowerST); 20373 tcase_add_test(tc_core, bLowerST); 20374 tcase_add_test(tc_core, trimST); 20375 tcase_add_test(tc_core, iTrimST); 20376 tcase_add_test(tc_core, bTrimST); 20377 tcase_add_test(tc_core, lTrimST); 20378 tcase_add_test(tc_core, iLTrimST); 20379 tcase_add_test(tc_core, bLTrimST); 20380 tcase_add_test(tc_core, rTrimST); 20381 tcase_add_test(tc_core, iRTrimST); 20382 tcase_add_test(tc_core, bRTrimST); 20383 tcase_add_test(tc_core, uniqST); 20384 tcase_add_test(tc_core, iUniqST); 20385 tcase_add_test(tc_core, bUniqST); 20386 tcase_add_test(tc_core, icUniqST); 20387 tcase_add_test(tc_core, iicUniqST); 20388 tcase_add_test(tc_core, bicUniqST); 20389 tcase_add_test(tc_core, repeatST); 20390 tcase_add_test(tc_core, iRepeatST); 20391 tcase_add_test(tc_core, bRepeatST); 20392 tcase_add_test(tc_core, bLRepeatST); 20393 tcase_add_test(tc_core, repeatCharST); 20394 tcase_add_test(tc_core, bRepeatCharST); 20395 tcase_add_test(tc_core, bLRepeatCharST); 20396 tcase_add_test(tc_core, repeatLenST); 20397 tcase_add_test(tc_core, ellipsisStartST); 20398 tcase_add_test(tc_core, iEllipsisStartST); 20399 tcase_add_test(tc_core, bEllipsisStartST); 20400 tcase_add_test(tc_core, bLEllipsisStartST); 20401 tcase_add_test(tc_core, ellipsisStartCharST); 20402 tcase_add_test(tc_core, iEllipsisStartCharST); 20403 tcase_add_test(tc_core, bEllipsisStartCharST); 20404 tcase_add_test(tc_core, bLEllipsisStartCharST); 20405 tcase_add_test(tc_core, ellipsisLenST); 20406 tcase_add_test(tc_core, ellipsisEndST); 20407 tcase_add_test(tc_core, iEllipsisEndST); 20408 tcase_add_test(tc_core, bEllipsisEndST); 20409 tcase_add_test(tc_core, bLEllipsisEndST); 20410 tcase_add_test(tc_core, ellipsisEndCharST); 20411 tcase_add_test(tc_core, iEllipsisEndCharST); 20412 tcase_add_test(tc_core, bEllipsisEndCharST); 20413 tcase_add_test(tc_core, bLEllipsisEndCharST); 20414 tcase_add_test(tc_core, padStartST); 20415 tcase_add_test(tc_core, iPadStartST); 20416 tcase_add_test(tc_core, bPadStartST); 20417 tcase_add_test(tc_core, bLPadStartST); 20418 tcase_add_test(tc_core, padStartCharST); 20419 tcase_add_test(tc_core, iPadStartCharST); 20420 tcase_add_test(tc_core, bPadStartCharST); 20421 tcase_add_test(tc_core, bLPadStartCharST); 20422 tcase_add_test(tc_core, padStartLenST); 20423 tcase_add_test(tc_core, padEndST); 20424 tcase_add_test(tc_core, iPadEndST); 20425 tcase_add_test(tc_core, bPadEndST); 20426 tcase_add_test(tc_core, bLPadEndST); 20427 tcase_add_test(tc_core, padEndCharST); 20428 tcase_add_test(tc_core, iPadEndCharST); 20429 tcase_add_test(tc_core, bPadEndCharST); 20430 tcase_add_test(tc_core, bLPadEndCharST); 20431 tcase_add_test(tc_core, padEndLenST); 20432 tcase_add_test(tc_core, getST); 20433 tcase_add_test(tc_core, setST); 20434 tcase_add_test(tc_core, swapST); 20435 tcase_add_test(tc_core, iSwapST); 20436 tcase_add_test(tc_core, bSwapST); 20437 tcase_add_test(tc_core, bLSwapST); 20438 tcase_add_test(tc_core, sliceST); 20439 tcase_add_test(tc_core, iSliceST); 20440 tcase_add_test(tc_core, bSliceST); 20441 tcase_add_test(tc_core, bLSliceST); 20442 tcase_add_test(tc_core, cropST); 20443 tcase_add_test(tc_core, iCropST); 20444 tcase_add_test(tc_core, cropElemST); 20445 tcase_add_test(tc_core, iCropElemST); 20446 tcase_add_test(tc_core, insertST); 20447 tcase_add_test(tc_core, insertNFreeST); 20448 tcase_add_test(tc_core, iInsertST); 20449 tcase_add_test(tc_core, iInsertNFreeST); 20450 tcase_add_test(tc_core, bInsertST); 20451 tcase_add_test(tc_core, bLInsertST); 20452 tcase_add_test(tc_core, injectST); 20453 tcase_add_test(tc_core, iInjectST); 20454 tcase_add_test(tc_core, bInjectST); 20455 tcase_add_test(tc_core, bLInjectST); 20456 tcase_add_test(tc_core, delST); 20457 tcase_add_test(tc_core, iDelST); 20458 tcase_add_test(tc_core, bDelST); 20459 tcase_add_test(tc_core, bLDelST); 20460 tcase_add_test(tc_core, delElemST); 20461 tcase_add_test(tc_core, iDelElemST); 20462 tcase_add_test(tc_core, bDelElemST); 20463 tcase_add_test(tc_core, bLDelElemST); 20464 tcase_add_test(tc_core, findST); 20465 tcase_add_test(tc_core, findCharST); 20466 tcase_add_test(tc_core, indexOfST); 20467 tcase_add_test(tc_core, indexOfCharST); 20468 tcase_add_test(tc_core, hasST); 20469 tcase_add_test(tc_core, hasCharST); 20470 tcase_add_test(tc_core, icFindST); 20471 tcase_add_test(tc_core, icFindCharST); 20472 tcase_add_test(tc_core, icIndexOfST); 20473 tcase_add_test(tc_core, icIndexOfCharST); 20474 tcase_add_test(tc_core, icHasST); 20475 tcase_add_test(tc_core, icHasCharST); 20476 tcase_add_test(tc_core, tokST); 20477 tcase_add_test(tc_core, icTokST); 20478 tcase_add_test(tc_core, lenUTF8T); 20479 tcase_add_test(tc_core, bLLenUTF8T); 20480 tcase_add_test(tc_core, isUTF8T); 20481 tcase_add_test(tc_core, bLIsUTF8T); 20482 tcase_add_test(tc_core, isCodeUTF8T); 20483 tcase_add_test(tc_core, nextUTF8T); 20484 tcase_add_test(tc_core, bLNextUTF8T); 20485 tcase_add_test(tc_core, findNextUTF8T); 20486 tcase_add_test(tc_core, prevUTF8T); 20487 tcase_add_test(tc_core, bPrevUTF8T); 20488 tcase_add_test(tc_core, idx2PtrUTF8T); 20489 tcase_add_test(tc_core, bLIdx2PtrUTF8T); 20490 tcase_add_test(tc_core, ptr2IdxUTF8T); 20491 tcase_add_test(tc_core, bPtr2IdxUTF8T); 20492 tcase_add_test(tc_core, bLPtr2IdxUTF8T); 20493 tcase_add_test(tc_core, bLPtr2NegIdxUTF8T); 20494 tcase_add_test(tc_core, makeValidUTF8T); 20495 tcase_add_test(tc_core, bMakeValidUTF8T); 20496 tcase_add_test(tc_core, nMakeValidUTF8T); 20497 tcase_add_test(tc_core, bNMakeValidUTF8T); 20498 tcase_add_test(tc_core, bLMakeValidUTF8T); 20499 tcase_add_test(tc_core, bLNMakeValidUTF8T); 20500 tcase_add_test(tc_core, strNCpyUTF8T); 20501 tcase_add_test(tc_core, strLCpyUTF8T); 20502 tcase_add_test(tc_core, strNCatUTF8T); 20503 tcase_add_test(tc_core, strLCatUTF8T); 20504 tcase_add_test(tc_core, strLNCatUTF8T); 20505 tcase_add_test(tc_core, eqIUTF8T); 20506 tcase_add_test(tc_core, eqICharUTF8T); 20507 tcase_add_test(tc_core, icEqUTF8T); 20508 tcase_add_test(tc_core, icEqCharUTF8T); 20509 tcase_add_test(tc_core, icEqUTF8CharT); 20510 tcase_add_test(tc_core, icStartsWithUTF8T); 20511 tcase_add_test(tc_core, icEndsWithUTF8T); 20512 tcase_add_test(tc_core, icCountUTF8T); 20513 tcase_add_test(tc_core, code2RuneUTF8T); 20514 tcase_add_test(tc_core, code2RuneLUTF8T); 20515 tcase_add_test(tc_core, bRune2CodeUTF8T); 20516 tcase_add_test(tc_core, runeLenUTF8T); 20517 tcase_add_test(tc_core, toupperUTF8T); 20518 tcase_add_test(tc_core, upperUTF8T); 20519 tcase_add_test(tc_core, iUpperUTF8T); 20520 tcase_add_test(tc_core, tolowerUTF8T); 20521 tcase_add_test(tc_core, lowerUTF8T); 20522 tcase_add_test(tc_core, iLowerUTF8T); 20523 tcase_add_test(tc_core, uniqUTF8T); 20524 tcase_add_test(tc_core, iUniqUTF8T); 20525 tcase_add_test(tc_core, bUniqUTF8T); 20526 tcase_add_test(tc_core, getUTF8T); 20527 tcase_add_test(tc_core, setUTF8T); 20528 tcase_add_test(tc_core, sliceUTF8T); 20529 tcase_add_test(tc_core, iSliceUTF8T); 20530 tcase_add_test(tc_core, bSliceUTF8T); 20531 tcase_add_test(tc_core, bLSliceUTF8T); 20532 tcase_add_test(tc_core, insertUTF8T); 20533 tcase_add_test(tc_core, insertNFreeUTF8T); 20534 tcase_add_test(tc_core, iInsertUTF8T); 20535 tcase_add_test(tc_core, iInsertNFreeUTF8T); 20536 tcase_add_test(tc_core, bInsertUTF8T); 20537 tcase_add_test(tc_core, bLInsertUTF8T); 20538 tcase_add_test(tc_core, delUTF8T); 20539 tcase_add_test(tc_core, iDelUTF8T); 20540 tcase_add_test(tc_core, bDelUTF8T); 20541 tcase_add_test(tc_core, bLDelUTF8T); 20542 tcase_add_test(tc_core, indexOfUTF8T); 20543 tcase_add_test(tc_core, icHasUTF8T); 20544 tcase_add_test(tc_core, icListSortUTF8T); 20545 tcase_add_test(tc_core, iicListSortUTF8T); 20546 tcase_add_test(tc_core, icListEqUTF8T); 20547 tcase_add_test(tc_core, icListHasUTF8T); 20548 tcase_add_test(tc_core, icListIndexOfUTF8T); 20549 tcase_add_test(tc_core, icListBinarySearchUTF8T); 20550 tcase_add_test(tc_core, icListUniqUTF8T); 20551 tcase_add_test(tc_core, iicListUniqUTF8T); 20552 tcase_add_test(tc_core, emptySFT); 20553 tcase_add_test(tc_core, iEmptySFT); 20554 tcase_add_test(tc_core, isEmptyST); 20555 tcase_add_test(tc_core, isBlankST); 20556 tcase_add_test(tc_core, intIndexT); 20557 tcase_add_test(tc_core, listEmptySFT); 20558 tcase_add_test(tc_core, iListEmptySFT); 20559 tcase_add_test(tc_core, listIsEmptyST); 20560 tcase_add_test(tc_core, listIsBlankST); 20561 tcase_add_test(tc_core, listLengthST); 20562 tcase_add_test(tc_core, listStrLengthST); 20563 tcase_add_test(tc_core, listIntIndexST); 20564 tcase_add_test(tc_core, listAddrST); 20565 tcase_add_test(tc_core, listCreateST); 20566 tcase_add_test(tc_core, listFromArrayST); 20567 tcase_add_test(tc_core, listPushST); 20568 tcase_add_test(tc_core, listPushCharST); 20569 tcase_add_test(tc_core, iListPushST); 20570 tcase_add_test(tc_core, listPopST); 20571 tcase_add_test(tc_core, listPrependST); 20572 tcase_add_test(tc_core, listPrependCharST); 20573 tcase_add_test(tc_core, iListPrependST); 20574 tcase_add_test(tc_core, listDequeueST); 20575 tcase_add_test(tc_core, listFreeST); 20576 tcase_add_test(tc_core, listFreeManyST); 20577 tcase_add_test(tc_core, listPrintST); 20578 tcase_add_test(tc_core, listForEachT); 20579 tcase_add_test(tc_core, listEnumerateT); 20580 tcase_add_test(tc_core, listSortST); 20581 tcase_add_test(tc_core, iListSortST); 20582 tcase_add_test(tc_core, listSortFST); 20583 tcase_add_test(tc_core, iListSortFST); 20584 tcase_add_test(tc_core, icListSortST); 20585 tcase_add_test(tc_core, iicListSortST); 20586 tcase_add_test(tc_core, readTextT); 20587 tcase_add_test(tc_core, readStreamT); 20588 tcase_add_test(tc_core, writeTextT); 20589 tcase_add_test(tc_core, writeStreamT); 20590 tcase_add_test(tc_core, appendTextT); 20591 tcase_add_test(tc_core, listGetST); 20592 tcase_add_test(tc_core, iListGetST); 20593 tcase_add_test(tc_core, listSetST); 20594 tcase_add_test(tc_core, listSetCharST); 20595 tcase_add_test(tc_core, listSwapST); 20596 tcase_add_test(tc_core, iListSwapST); 20597 tcase_add_test(tc_core, iListSetST); 20598 tcase_add_test(tc_core, splitT); 20599 tcase_add_test(tc_core, splitCharT); 20600 tcase_add_test(tc_core, icSplitT); 20601 tcase_add_test(tc_core, icSplitCharT); 20602 tcase_add_test(tc_core, joinLengthT); 20603 tcase_add_test(tc_core, joinT); 20604 tcase_add_test(tc_core, joinCharT); 20605 tcase_add_test(tc_core, bJoinT); 20606 tcase_add_test(tc_core, bJoinCharT); 20607 tcase_add_test(tc_core, bLJoinT); 20608 tcase_add_test(tc_core, bLJoinCharT); 20609 tcase_add_test(tc_core, extractST); 20610 tcase_add_test(tc_core, extractCharSST); 20611 tcase_add_test(tc_core, extractSCharST); 20612 tcase_add_test(tc_core, extractCharCharST); 20613 tcase_add_test(tc_core, icExtractST); 20614 tcase_add_test(tc_core, icExtractCharSST); 20615 tcase_add_test(tc_core, icExtractSCharST); 20616 tcase_add_test(tc_core, icExtractCharCharST); 20617 tcase_add_test(tc_core, listDupST); 20618 tcase_add_test(tc_core, iListDupST); 20619 tcase_add_test(tc_core, listReverseST); 20620 tcase_add_test(tc_core, iListReverseST); 20621 tcase_add_test(tc_core, listCatST); 20622 tcase_add_test(tc_core, listAppendST); 20623 tcase_add_test(tc_core, iListAppendST); 20624 tcase_add_test(tc_core, iListAppendNSmashST); 20625 tcase_add_test(tc_core, listShiftST); 20626 tcase_add_test(tc_core, iListShiftST); 20627 tcase_add_test(tc_core, iListShiftNSmashST); 20628 tcase_add_test(tc_core, listAddST); 20629 tcase_add_test(tc_core, listSliceST); 20630 tcase_add_test(tc_core, iListCopyST); 20631 tcase_add_test(tc_core, iListSliceST); 20632 tcase_add_test(tc_core, listCropST); 20633 tcase_add_test(tc_core, iListCropST); 20634 tcase_add_test(tc_core, listCropElemST); 20635 tcase_add_test(tc_core, iListCropElemST); 20636 tcase_add_test(tc_core, listInsertST); 20637 tcase_add_test(tc_core, iListInsertST); 20638 tcase_add_test(tc_core, iListInsertNFreeST); 20639 tcase_add_test(tc_core, listInjectST); 20640 tcase_add_test(tc_core, listInjectCharST); 20641 tcase_add_test(tc_core, iListInjectST); 20642 tcase_add_test(tc_core, iListInjectCharST); 20643 tcase_add_test(tc_core, listDelST); 20644 tcase_add_test(tc_core, iListDelST); 20645 tcase_add_test(tc_core, iListRemoveST); 20646 tcase_add_test(tc_core, listDelElemST); 20647 tcase_add_test(tc_core, iListDelElemST); 20648 tcase_add_test(tc_core, iListRemoveElemST); 20649 tcase_add_test(tc_core, execOutT); 20650 tcase_add_test(tc_core, systemOutfT); 20651 tcase_add_test(tc_core, systemfT); 20652 tcase_add_test(tc_core, commandFT); 20653 tcase_add_test(tc_core, commandfFT); 20654 tcase_add_test(tc_core, commandNFreeFT); 20655 tcase_add_test(tc_core, listEqST); 20656 tcase_add_test(tc_core, listHasST); 20657 tcase_add_test(tc_core, listHasCharST); 20658 tcase_add_test(tc_core, listIndexOfST); 20659 tcase_add_test(tc_core, listIndexOfCharST); 20660 tcase_add_test(tc_core, listBinarySearchST); 20661 tcase_add_test(tc_core, listBinarySearchCharST); 20662 tcase_add_test(tc_core, listUniqST); 20663 tcase_add_test(tc_core, iListUniqST); 20664 tcase_add_test(tc_core, icListEqST); 20665 tcase_add_test(tc_core, icListHasST); 20666 tcase_add_test(tc_core, icListHasCharST); 20667 tcase_add_test(tc_core, icListIndexOfST); 20668 tcase_add_test(tc_core, icListIndexOfCharST); 20669 tcase_add_test(tc_core, icListBinarySearchST); 20670 tcase_add_test(tc_core, icListBinarySearchCharST); 20671 tcase_add_test(tc_core, icListUniqST); 20672 tcase_add_test(tc_core, iicListUniqST); 20673 tcase_add_test(tc_core, listCompactST); 20674 tcase_add_test(tc_core, iListCompactST); 20675 tcase_add_test(tc_core, btraceEnableT); 20676 tcase_add_test(tc_core, btraceT); 20677 tcase_add_test(tc_core, listEmptyFT); 20678 tcase_add_test(tc_core, iListEmptyFT); 20679 tcase_add_test(tc_core, listIsEmptyT); 20680 tcase_add_test(tc_core, listCreateT); 20681 tcase_add_test(tc_core, listFromArrayT); 20682 tcase_add_test(tc_core, listPushT); 20683 tcase_add_test(tc_core, listPopT); 20684 tcase_add_test(tc_core, listPrependT); 20685 tcase_add_test(tc_core, listDequeueT); 20686 tcase_add_test(tc_core, listFreeT); 20687 tcase_add_test(tc_core, listFreeManyT); 20688 tcase_add_test(tc_core, listLengthT); 20689 tcase_add_test(tc_core, listGetT); 20690 tcase_add_test(tc_core, listSetT); 20691 tcase_add_test(tc_core, listDupT); 20692 tcase_add_test(tc_core, listReverseT); 20693 tcase_add_test(tc_core, iListReverseT); 20694 tcase_add_test(tc_core, listCatT); 20695 tcase_add_test(tc_core, listAppendT); 20696 tcase_add_test(tc_core, listAddT); 20697 tcase_add_test(tc_core, listSliceT); 20698 tcase_add_test(tc_core, iListSliceT); 20699 tcase_add_test(tc_core, listInsertT); 20700 tcase_add_test(tc_core, iListInsertT); 20701 tcase_add_test(tc_core, listDelT); 20702 tcase_add_test(tc_core, iListDelT); 20703 //tcase_add_test(tc_core, listSortT); 20704 //tcase_add_test(tc_core, iListSortT); 20705 //tcase_add_test(tc_core, listEqT); 20706 //tcase_add_test(tc_core, listIndexOfT); 20707 //tcase_add_test(tc_core, listBinarySearchT); 20708 //tcase_add_test(tc_core, listUniqT); 20709 //tcase_add_test(tc_core, iListUniqT); 20710 //tcase_add_test(tc_core, listCompactT); 20711 //tcase_add_test(tc_core, iListCompactT); 20712 tcase_add_test(tc_core, ringInitT); 20713 tcase_add_test(tc_core, ringEmptyT); 20714 tcase_add_test(tc_core, ringIsEmptyT); 20715 tcase_add_test(tc_core, ringIsFullT); 20716 tcase_add_test(tc_core, ringCountT); 20717 tcase_add_test(tc_core, ringPushT); 20718 tcase_add_test(tc_core, ringPopT); 20719 tcase_add_test(tc_core, ringPrependT); 20720 tcase_add_test(tc_core, ringDequeueT); 20721 tcase_add_test(tc_core, fiberAddT); 20722 tcase_add_test(tc_core, fiberPrependT); 20723 tcase_add_test(tc_core, schedulerT); 20724 tcase_add_test(tc_core, getMonotonicTimeT); 20725 tcase_add_test(tc_core, nanoSleepT); 20726 20727 20728 suite_add_tcase(s, tc_core); 20729 20730 return s; 20731 } 20732 20733 int main(int ARGC, char** ARGV) { 20734 int number_failed; 20735 Suite *s; 20736 SRunner *sr; 20737 20738 s = libsheepySuite(); 20739 sr = srunner_create(s); 20740 20741 srunner_run_all(sr, CK_NORMAL); 20742 number_failed = srunner_ntests_failed(sr); 20743 srunner_free(sr); 20744 20745 exit((number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE); 20746 }