libsheepyCuTest.c (469987B)
1 #include <stdlib.h> 2 #include <stdio.h> 3 #include <string.h> 4 5 #include "CuTest/CuTest.h" 6 7 #define ck_assert_str_eq(a,b) CuAssertStrEquals(tc, b, a) 8 #define ck_assert_str_ne(a,b) CuAssertStrNotEquals(tc, b, a) 9 #define ck_assert_ptr_eq(a,b) CuAssertPtrEquals(tc, b, a) 10 #define ck_assert_ptr_ne(a,b) CuAssertPtrNotEquals(tc, b, a) 11 #define ck_assert_uint_eq(a,b) CuAssertUintEquals(tc, b, a) 12 #define ck_assert_uint_ne(a,b) CuAssertUintNotEquals(tc, b, a) 13 #define ck_assert_int_eq(a,b) CuAssertIntEquals(tc, b, a) 14 #define ck_assert_int_ne(a,b) CuAssertIntNotEquals(tc, b, a) 15 #define ck_assert(a) CuAssertTrue(tc, a) 16 17 18 #include "libsheepy.h" 19 20 // TODO redirect stderr 21 22 void cleanUpCharFreeT(CuTest *tc UNUSED) { 23 24 cleanCharP(s) = strdup("test"); 25 26 } 27 28 29 void cleanUpListFreeT(CuTest *tc UNUSED) { 30 31 cleanListP(l) = listCreateS("a","b"); 32 33 } 34 35 36 void cleanUpFileFreeT(CuTest *tc UNUSED) { 37 38 cleanFileP(f) = fopen("renameTest.null", "r"); 39 40 } 41 42 43 void cleanUpCharFreeNullT(CuTest *tc UNUSED) { 44 45 cleanCharP(s) = null; 46 47 } 48 49 50 void cleanUpListFreeNullT(CuTest *tc UNUSED) { 51 52 cleanListP(l) = null; 53 54 } 55 56 57 void cleanUpFileFreeNullT(CuTest *tc UNUSED) { 58 59 cleanFileP(f) = null; 60 61 } 62 63 64 void shStopwatchT(CuTest *tc UNUSED) { 65 66 stopwatchStart; 67 stopwatchLog; 68 69 } 70 71 72 void setLogSymbolsT(CuTest *tc UNUSED) { 73 74 int m; 75 76 // set mode utf8 77 setLogSymbols(LOG_UTF8); 78 m = getLogSymbols(); 79 ck_assert_int_eq(m, LOG_UTF8); 80 81 // set invalid mode 82 setLogSymbols(LOG_INVALID_MODE); 83 m = getLogSymbols(); 84 ck_assert_int_eq(m, LOG_INVALID_MODE); 85 86 setLogSymbols(LOG_UTF8); 87 setLogSymbols(LOG_INVALID_MODE+10); 88 m = getLogSymbols(); 89 ck_assert_int_eq(m, LOG_INVALID_MODE); 90 91 } 92 93 94 void setMaxLogLevelT(CuTest *tc UNUSED) { 95 96 int lv; 97 98 // set max level 99 setMaxLogLevel(LOG_DISABLE); 100 lv = getMaxLogLevel(); 101 ck_assert_int_eq(lv, LOG_DISABLE); 102 103 // set invalid max level (all levels) 104 setMaxLogLevel(LOG_INVALID); 105 lv = getMaxLogLevel(); 106 ck_assert_int_eq(lv, LOG_MAX_LEVEL); 107 108 109 } 110 111 112 void setLogShortPathT(CuTest *tc UNUSED) { 113 114 bool sp; 115 116 // set long path 117 setLogShortPath(no); 118 sp = getLogShortPath(); 119 ck_assert(!sp); 120 121 // set short path 122 setLogShortPath(yes); 123 sp = getLogShortPath(); 124 ck_assert(sp); 125 126 } 127 128 129 void setLogStdoutT(CuTest *tc UNUSED) { 130 131 bool std; 132 133 // set long path 134 setLogStdout(no); 135 std = getLogStdout(); 136 ck_assert(!std); 137 138 // set short path 139 setLogStdout(yes); 140 std = getLogStdout(); 141 ck_assert(std); 142 143 } 144 145 146 void openProgLogFileT(CuTest *tc UNUSED) { 147 148 const char *pn; 149 bool r; 150 151 // check that prog name is not set 152 pn = getProgName(); 153 ck_assert_ptr_eq(pn, null); 154 r = openProgLogFile(); 155 ck_assert(!r); 156 157 // set progname and open file 158 r = setProgName("openProgLogFileT"); 159 ck_assert(r); 160 r = openProgLogFile(); 161 ck_assert(r); 162 163 freeProgName(); 164 closeLogFiles(); 165 int R = rmAll("openProgLogFileT.log"); 166 ck_assert_int_ne(R, 0); 167 168 } 169 170 171 void setLogFileT(CuTest *tc UNUSED) { 172 173 FILE *f; 174 175 // open log file 176 f = setLogFile("test.log"); 177 ck_assert_ptr_ne(f, NULL); 178 179 // read only location 180 f = setLogFile("/test.log"); 181 ck_assert_ptr_eq(f, NULL); 182 183 // open all log slots 184 f = setLogFile("test1.log"); 185 ck_assert_ptr_ne(f, NULL); 186 187 f = setLogFile("test2.log"); 188 ck_assert_ptr_ne(f, NULL); 189 190 f = setLogFile("test3.log"); 191 ck_assert_ptr_ne(f, NULL); 192 193 f = setLogFile("test4.log"); 194 ck_assert_ptr_ne(f, NULL); 195 196 f = setLogFile("test5.log"); 197 ck_assert_ptr_ne(f, NULL); 198 199 f = setLogFile("test6.log"); 200 ck_assert_ptr_ne(f, NULL); 201 202 f = setLogFile("test7.log"); 203 ck_assert_ptr_ne(f, NULL); 204 205 f = setLogFile("test8.log"); 206 ck_assert_ptr_ne(f, NULL); 207 208 f = setLogFile("test9.log"); 209 ck_assert_ptr_ne(f, NULL); 210 211 f = setLogFile("test10.log"); 212 ck_assert_ptr_ne(f, NULL); 213 214 f = setLogFile("test11.log"); 215 ck_assert_ptr_ne(f, NULL); 216 217 f = setLogFile("test12.log"); 218 ck_assert_ptr_ne(f, NULL); 219 220 f = setLogFile("test13.log"); 221 ck_assert_ptr_ne(f, NULL); 222 223 f = setLogFile("test14.log"); 224 ck_assert_ptr_ne(f, NULL); 225 226 f = setLogFile("test15.log"); 227 ck_assert_ptr_eq(f, NULL); 228 229 closeLogFiles(); 230 int R; 231 R = rmAll("test1.log"); 232 ck_assert_int_ne(R, 0); 233 R = rmAll("test2.log"); 234 ck_assert_int_ne(R, 0); 235 R = rmAll("test3.log"); 236 ck_assert_int_ne(R, 0); 237 R = rmAll("test4.log"); 238 ck_assert_int_ne(R, 0); 239 R = rmAll("test5.log"); 240 ck_assert_int_ne(R, 0); 241 R = rmAll("test6.log"); 242 ck_assert_int_ne(R, 0); 243 R = rmAll("test7.log"); 244 ck_assert_int_ne(R, 0); 245 R = rmAll("test8.log"); 246 ck_assert_int_ne(R, 0); 247 R = rmAll("test9.log"); 248 ck_assert_int_ne(R, 0); 249 R = rmAll("test10.log"); 250 ck_assert_int_ne(R, 0); 251 R = rmAll("test11.log"); 252 ck_assert_int_ne(R, 0); 253 R = rmAll("test12.log"); 254 ck_assert_int_ne(R, 0); 255 R = rmAll("test13.log"); 256 ck_assert_int_ne(R, 0); 257 R = rmAll("test14.log"); 258 ck_assert_int_ne(R, 0); 259 260 // NULL 261 ck_assert_ptr_eq(setLogFile(NULL), NULL); 262 263 } 264 265 266 void closeLogFilesT(CuTest *tc UNUSED) { 267 268 closeLogFiles(); 269 closeLogFiles(); 270 271 } 272 273 274 void getLogModeT(CuTest *tc UNUSED) { 275 276 ck_assert_int_eq(getLogMode(), LOG_DATE); 277 278 } 279 280 281 void setLogModeT(CuTest *tc UNUSED) { 282 283 // set mode 284 setLogMode(LOG_CONCISE); 285 ck_assert_int_eq(getLogMode(), LOG_CONCISE); 286 287 setLogMode(LOG_DATE); 288 ck_assert_int_eq(getLogMode(), LOG_DATE); 289 290 setLogMode(LOG_FUNC); 291 ck_assert_int_eq(getLogMode(), LOG_FUNC); 292 293 setLogMode(LOG_PROG); 294 ck_assert_int_eq(getLogMode(), LOG_PROG); 295 296 setLogMode(LOG_PROGNDATE); 297 ck_assert_int_eq(getLogMode(), LOG_PROGNDATE); 298 299 setLogMode(LOG_VOID); 300 ck_assert_int_eq(getLogMode(), LOG_VOID); 301 302 setLogMode(LOG_UTF8); 303 ck_assert_int_eq(getLogMode(), LOG_UTF8); 304 305 setLogMode(LOG_VERBOSE); 306 ck_assert_int_eq(getLogMode(), LOG_VERBOSE); 307 308 // set invalid value 309 setLogMode(LOG_CONCISE+10); 310 ck_assert_int_eq(getLogMode(), LOG_VERBOSE); 311 312 // invalid log mode 313 setLogMode(-1); 314 setLogMode(LOG_INVALID_MODE); 315 316 } 317 318 319 void _pLogT(CuTest *tc UNUSED) { 320 321 setLogFile("test.log"); 322 323 // default log mode 324 puts("Default mode"); 325 pLog(LOG_EMERGENCY, "pLog test"); 326 pLog(LOG_ALERT, "pLog test"); 327 pLog(LOG_CRITICAL, "pLog test"); 328 pLog(LOG_ERROR, "pLog test"); 329 pLog(LOG_WARNING, "pLog test"); 330 pLog(LOG_NOTICE, "pLog test"); 331 pLog(LOG_PASS, "pLog test"); 332 pLog(LOG_INFO, "pLog test\nmultiline"); 333 pLog(LOG_DEBUG, "pLog test"); 334 // invalid log level 335 pLog(LOG_INFO+20, "pLog test"); 336 pLog(-1, "pLog test"); 337 338 // concise mode 339 puts("LOG_CONCISE mode"); 340 setLogMode(LOG_CONCISE); 341 pLog(LOG_EMERGENCY, "pLog test"); 342 pLog(LOG_ALERT, "pLog test"); 343 pLog(LOG_CRITICAL, "pLog test"); 344 pLog(LOG_ERROR, "pLog test"); 345 pLog(LOG_WARNING, "pLog test"); 346 pLog(LOG_NOTICE, "pLog test"); 347 pLog(LOG_PASS, "pLog test"); 348 pLog(LOG_INFO, "pLog test"); 349 pLog(LOG_DEBUG, "pLog test"); 350 // invalid log level 351 pLog(LOG_INFO+20, "pLog test"); 352 353 // verbose mode 354 puts("LOG_VERBOSE mode"); 355 setLogMode(LOG_VERBOSE); 356 pLog(LOG_EMERGENCY, "pLog test"); 357 pLog(LOG_ALERT, "pLog test"); 358 pLog(LOG_CRITICAL, "pLog test"); 359 pLog(LOG_ERROR, "pLog test"); 360 pLog(LOG_WARNING, "pLog test"); 361 pLog(LOG_NOTICE, "pLog test"); 362 pLog(LOG_PASS, "pLog test"); 363 pLog(LOG_INFO, "pLog test"); 364 pLog(LOG_DEBUG, "pLog test"); 365 // invalid log level 366 pLog(LOG_INFO+20, "pLog test"); 367 368 // date mode 369 puts("LOG_DATE mode"); 370 setLogMode(LOG_DATE); 371 pLog(LOG_EMERGENCY, "pLog test"); 372 pLog(LOG_ALERT, "pLog test"); 373 pLog(LOG_CRITICAL, "pLog test"); 374 pLog(LOG_ERROR, "pLog test"); 375 pLog(LOG_WARNING, "pLog test"); 376 pLog(LOG_NOTICE, "pLog test"); 377 pLog(LOG_PASS, "pLog test"); 378 pLog(LOG_INFO, "pLog test"); 379 pLog(LOG_DEBUG, "pLog test"); 380 // invalid log level 381 pLog(LOG_INFO+20, "pLog test"); 382 383 // function mode 384 puts("LOG_FUNC mode"); 385 setLogMode(LOG_FUNC); 386 pLog(LOG_EMERGENCY, "pLog test"); 387 pLog(LOG_ALERT, "pLog test"); 388 pLog(LOG_CRITICAL, "pLog test"); 389 pLog(LOG_ERROR, "pLog test"); 390 pLog(LOG_WARNING, "pLog test"); 391 pLog(LOG_NOTICE, "pLog test"); 392 pLog(LOG_PASS, "pLog test"); 393 pLog(LOG_INFO, "pLog test"); 394 pLog(LOG_DEBUG, "pLog test"); 395 // invalid log level 396 pLog(LOG_INFO+20, "pLog test"); 397 398 // program name mode 399 puts("LOG_PROG mode"); 400 setLogMode(LOG_PROG); 401 pLog(LOG_EMERGENCY, "pLog test"); 402 pLog(LOG_ALERT, "pLog test"); 403 pLog(LOG_CRITICAL, "pLog test"); 404 pLog(LOG_ERROR, "pLog test"); 405 pLog(LOG_WARNING, "pLog test"); 406 pLog(LOG_NOTICE, "pLog test"); 407 pLog(LOG_PASS, "pLog test"); 408 pLog(LOG_INFO, "pLog test"); 409 pLog(LOG_DEBUG, "pLog test"); 410 // invalid log level 411 pLog(LOG_INFO+20, "pLog test"); 412 413 // program name and date mode 414 puts("LOG_PROGNDATE mode"); 415 setLogMode(LOG_PROGNDATE); 416 pLog(LOG_EMERGENCY, "pLog test"); 417 pLog(LOG_ALERT, "pLog test"); 418 pLog(LOG_CRITICAL, "pLog test"); 419 pLog(LOG_ERROR, "pLog test"); 420 pLog(LOG_WARNING, "pLog test"); 421 pLog(LOG_NOTICE, "pLog test"); 422 pLog(LOG_PASS, "pLog test"); 423 pLog(LOG_INFO, "pLog test"); 424 pLog(LOG_DEBUG, "pLog test"); 425 // invalid log level 426 pLog(LOG_INFO+20, "pLog test"); 427 428 // void mode 429 puts("LOG_VOID mode"); 430 setLogMode(LOG_VOID); 431 pLog(LOG_EMERGENCY, "pLog test"); 432 pLog(LOG_ALERT, "pLog test"); 433 pLog(LOG_CRITICAL, "pLog test"); 434 pLog(LOG_ERROR, "pLog test"); 435 pLog(LOG_WARNING, "pLog test"); 436 pLog(LOG_NOTICE, "pLog test"); 437 pLog(LOG_PASS, "pLog test"); 438 pLog(LOG_INFO, "pLog test"); 439 pLog(LOG_DEBUG, "pLog test"); 440 // invalid log level 441 pLog(LOG_INFO+20, "pLog test"); 442 443 // void mode 444 puts("LOG_UTF8 mode"); 445 setLogMode(LOG_UTF8); 446 pLog(LOG_EMERGENCY, "pLog test"); 447 pLog(LOG_ALERT, "pLog test"); 448 pLog(LOG_CRITICAL, "pLog test"); 449 pLog(LOG_ERROR, "pLog test"); 450 pLog(LOG_WARNING, "pLog test"); 451 pLog(LOG_NOTICE, "pLog test"); 452 pLog(LOG_PASS, "pLog test"); 453 pLog(LOG_INFO, "pLog test"); 454 pLog(LOG_DEBUG, "pLog test"); 455 // invalid log level 456 pLog(LOG_INFO+20, "pLog test"); 457 458 closeLogFiles(); 459 int R = rmAll("test.log"); 460 ck_assert_int_ne(R, 0); 461 462 } 463 464 465 void setProgNameT(CuTest *tc UNUSED) { 466 467 bool r; 468 469 // set default prog name (null since init is not called yet) 470 setDefaultProgName(); 471 ck_assert_ptr_eq(getProgName(), null); 472 473 // set prog name 474 r = setProgName("name"); 475 ck_assert(r); 476 477 // set null prog name 478 r = setProgName(NULL); 479 ck_assert(!r); 480 ck_assert_ptr_ne(getProgName(), null); 481 ck_assert_str_eq(getProgName(), "name"); 482 483 freeProgName(); 484 485 // set prog name and then set default prog name 486 // no memory leak should happen 487 r = setProgName("name"); 488 ck_assert(r); 489 setDefaultProgName(); 490 491 } 492 493 494 void initTest(void) { } 495 496 497 void initLibsheepyFT(CuTest *tc UNUSED) { 498 499 // regular program 500 initLibsheepy("test"); 501 502 // program compiled with sheepy with init function 503 initLibsheepyF("/.sheepy/build/test", initTest); 504 505 } 506 507 508 void setStackLimitT(CuTest *tc UNUSED) { 509 510 int r; 511 i64 stackSize; 512 513 // set bigger stack 514 r = setStackLimit(16 * 1024 * 1024); 515 ck_assert(r!=0); 516 stackSize = getStackLimit(); 517 ck_assert_int_eq(stackSize, 16 * 1024 * 1024); 518 519 // set unlimited stack 520 r = setStackLimit(-1); 521 ck_assert(r!=0); 522 523 } 524 525 526 void getProgPathT(CuTest *tc UNUSED) { 527 528 const char *s; 529 530 // getProgPath stored prog path 531 s = getProgPath(); 532 ck_assert_ptr_ne(s, NULL); 533 534 initLibsheepy("test"); 535 536 // getProgPath stored prog path 537 s = getProgPath(); 538 ck_assert_str_eq(s, "test"); 539 540 // program compiled with sheepy with init function 541 initLibsheepyF("/.sheepy/build/test", initTest); 542 543 // getProgPath stored prog path 544 s = getProgPath(); 545 ck_assert_str_eq(s, "/test"); 546 547 } 548 549 550 void getRealProgPathT(CuTest *tc UNUSED) { 551 552 const char *s; 553 554 // getProgPath real prog path 555 s = getProgPath(); 556 ck_assert_ptr_ne(s, NULL); 557 558 initLibsheepy("test"); 559 560 s = getRealProgPath(); 561 ck_assert_ptr_ne(s, NULL); 562 freeRealProgPath(); 563 564 } 565 566 567 void systemNFreeFT(CuTest *tc UNUSED) { 568 569 int r; 570 571 // normal command 572 r = systemNFree(strdup("echo TEST")); 573 ck_assert_int_eq(r, 0); 574 575 // NULL 576 r = systemNFree(NULL); 577 ck_assert_int_ne(r, 0); 578 579 } 580 581 582 void getModificationTimeT(CuTest *tc UNUSED) { 583 584 // get time 585 ck_assert_int_ne(getModificationTime("libsheepy.c"), 0); 586 587 // missing file 588 ck_assert_int_eq(getModificationTime("nonexistingfile"), 0); 589 590 // NULL 591 ck_assert_int_eq(getModificationTime(NULL), 0); 592 593 } 594 595 596 void setModificationTimeT(CuTest *tc UNUSED) { 597 598 time_t t; 599 600 // set time 601 t = getModificationTime("chmodTest.null"); 602 ck_assert_int_eq(setModificationTime("chmodTest.null", t), 1); 603 604 // non existing file 605 ck_assert_int_eq(setModificationTime("/chmodTest.null", t), 0); 606 607 // NULL 608 ck_assert_int_eq(setModificationTime(NULL, t), 0); 609 610 } 611 612 613 void isReadableT(CuTest *tc UNUSED) { 614 615 bool r; 616 617 // check readable file 618 r = isReadable("sizeTest.null"); 619 ck_assert(r); 620 621 // non readable file 622 r = isReadable("writeOnlyText.null"); 623 ck_assert(!r); 624 625 // non existing file 626 r = isReadable("random.null"); 627 ck_assert(!r); 628 629 // null 630 r = isReadable(null); 631 ck_assert(!r); 632 633 } 634 635 636 void isWritableT(CuTest *tc UNUSED) { 637 638 bool r; 639 640 // check writable file 641 r = isWritable("writeOnlyText.null"); 642 ck_assert(r); 643 644 // non writable file 645 r = isWritable("sizeTest.null"); 646 ck_assert(!r); 647 648 // non existing file 649 r = isWritable("random.null"); 650 ck_assert(!r); 651 652 // null 653 r = isWritable(null); 654 ck_assert(!r); 655 656 } 657 658 659 void isExecutableT(CuTest *tc UNUSED) { 660 661 bool r; 662 663 // check executable file 664 r = isExecutable("runCuTest.sh"); 665 ck_assert(r); 666 667 // non executable file 668 r = isExecutable("sizeTest.null"); 669 ck_assert(!r); 670 671 // non existing file 672 r = isExecutable("random.null"); 673 ck_assert(!r); 674 675 // null 676 r = isExecutable(null); 677 ck_assert(!r); 678 679 } 680 681 682 void equalModificationTimesT(CuTest *tc UNUSED) { 683 684 // equal time 685 ck_assert(equalModificationTimes("chmodTest.null", "chmodTest.null")); 686 687 // not equal 688 ck_assert(!equalModificationTimes("chmodTest.null", "libsheepy.c")); 689 690 // non existing 691 ck_assert(!equalModificationTimes("/chmodTest.null", "libsheepy.c")); 692 ck_assert(!equalModificationTimes("chmodTest.null", "/libsheepy.c")); 693 694 // NULL 695 ck_assert(!equalModificationTimes(NULL, "libsheepy.c")); 696 ck_assert(!equalModificationTimes("chmodTest.null", NULL)); 697 698 } 699 700 701 void getCurrentUnixTimeT(CuTest *tc UNUSED) { 702 703 time_t t = getCurrentUnixTime(); 704 ck_assert_int_ne(t, 0); 705 706 } 707 708 709 void strToUnixTimeT(CuTest *tc UNUSED) { 710 711 time_t t; 712 713 // convert 714 t = strToUnixTime("2020-05-15 13:59:58", "%Y-%m-%d %H:%M"); 715 ck_assert_int_ne(t, -1); 716 // depends on local settings - ck_assert_int_eq(t, 1589547540); 717 718 719 // bad date or format 720 t = strToUnixTime("", "%Y-%m-%d %H:%M"); 721 ck_assert_int_eq(t, -1); 722 723 // null date 724 t = strToUnixTime(null, "%Y-%m-%d %H:%M"); 725 ck_assert_int_eq(t, -1); 726 727 // null format 728 t = strToUnixTime("", null); 729 ck_assert_int_eq(t, -1); 730 731 } 732 733 734 void timeToST(CuTest *tc UNUSED) { 735 736 char *s; 737 738 s = timeToS(0); 739 ck_assert_str_eq(s, "Thu Jan 1 01:00:00 1970"); 740 free(s); 741 742 // bTimeToS 743 char b[80] = init0Var; 744 s = bTimeToS(b, 0); 745 ck_assert_ptr_ne(s, null); 746 ck_assert_str_eq(b, "Thu Jan 1 01:00:00 1970"); 747 748 // bLTimeToS 749 char bL[50] = init0Var; 750 s = bLTimeToS(bL, sizeof(bL), 0); 751 ck_assert_ptr_ne(s, null); 752 ck_assert_str_eq(bL, "Thu Jan 1 01:00:00 1970"); 753 754 // null parameter 755 s = bTimeToS(null, 0); 756 ck_assert_ptr_eq(s, null); 757 s = bLTimeToS(null, sizeof(bL), 0); 758 ck_assert_ptr_eq(s, null); 759 760 } 761 762 763 void timeToYMDST(CuTest *tc UNUSED) { 764 765 char *s; 766 767 s = timeToYMDS(0); 768 ck_assert_str_eq(s, "1970-01-01 01:00:00"); 769 free(s); 770 771 // bTimeToYMDS 772 char b[80] = init0Var; 773 s = bTimeToYMDS(b, 0); 774 ck_assert_ptr_ne(s, null); 775 ck_assert_str_eq(b, "1970-01-01 01:00:00"); 776 777 // bLTimeToYMDS 778 char bL[50] = init0Var; 779 s = bLTimeToYMDS(bL, sizeof(bL), 0); 780 ck_assert_ptr_ne(s, null); 781 ck_assert_str_eq(bL, "1970-01-01 01:00:00"); 782 783 // null parameter 784 s = bTimeToYMDS(null, 0); 785 ck_assert_ptr_eq(s, null); 786 s = bLTimeToYMDS(null, sizeof(bL), 0); 787 ck_assert_ptr_eq(s, null); 788 789 } 790 791 792 void getCurrentDateT(CuTest *tc UNUSED) { 793 794 char *s; 795 796 s = getCurrentDate(); 797 ck_assert_ptr_ne(s, null); 798 free(s); 799 800 char b[80] = init0Var; 801 s = bGetCurrentDate(b); 802 ck_assert_ptr_ne(s, null); 803 804 char bL[50] = init0Var; 805 s = bLGetCurrentDate(bL, sizeof(bL)); 806 ck_assert_ptr_ne(s, null); 807 808 // null parameter 809 s = bGetCurrentDate(null); 810 ck_assert_ptr_eq(s, null); 811 s = bLGetCurrentDate(null, sizeof(bL)); 812 ck_assert_ptr_eq(s, null); 813 814 } 815 816 817 void getCurrentDateYMDT(CuTest *tc UNUSED) { 818 819 char *s; 820 821 s = getCurrentDateYMD(); 822 ck_assert_ptr_ne(s, null); 823 free(s); 824 825 char b[80] = init0Var; 826 s = bGetCurrentDateYMD(b); 827 ck_assert_ptr_ne(s, null); 828 829 char bL[50] = init0Var; 830 s = bLGetCurrentDateYMD(bL, sizeof(bL)); 831 ck_assert_ptr_ne(s, null); 832 833 // null parameter 834 s = bGetCurrentDateYMD(null); 835 ck_assert_ptr_eq(s, null); 836 s = bLGetCurrentDateYMD(null, sizeof(bL)); 837 ck_assert_ptr_eq(s, null); 838 839 } 840 841 842 void shDirnameT(CuTest *tc UNUSED) { 843 844 char *s; 845 846 // path 847 s = shDirname("release/libsheepy.a"); 848 ck_assert_str_eq(s, "release"); 849 free(s); 850 851 // one item path 852 s = shDirname("sheepy.lib"); 853 ck_assert_str_eq(s, "./"); 854 free(s); 855 856 // empty 857 s = shDirname(" "); 858 ck_assert_str_eq(s, "./"); 859 free(s); 860 861 // NULL 862 ck_assert_ptr_eq(shDirname(NULL), NULL); 863 864 } 865 866 867 void bDirnameT(CuTest *tc UNUSED) { 868 869 char s[100] = "release/libsheepy.a"; 870 char *r = null; 871 872 // path 873 r = bDirname(s); 874 ck_assert_ptr_eq(r, s); 875 ck_assert_str_eq(s, "release"); 876 877 // one item path 878 r = strCpy(s, "sheepy.lib"); 879 ck_assert_ptr_eq(r, s); 880 r = bDirname(s); 881 ck_assert_ptr_eq(r, s); 882 ck_assert_str_eq(s, "./"); 883 884 // empty 885 r = strCpy(s, " "); 886 ck_assert_ptr_eq(r, s); 887 r = bDirname(s); 888 ck_assert_ptr_eq(r, s); 889 ck_assert_str_eq(s, "./"); 890 891 // NULL 892 r = bDirname(NULL); 893 ck_assert_ptr_eq(r, null); 894 895 } 896 897 898 void bLDirnameT(CuTest *tc UNUSED) { 899 900 char s[100] = "release/libsheepy.a"; 901 char *r = null; 902 903 // path 904 r = bLDirname(s, sizeof s); 905 ck_assert_ptr_eq(r, s); 906 ck_assert_str_eq(s, "release"); 907 908 // buffer shorter than path 909 strcpy(s, "release/anotherdir/libsheepy.a"); 910 r = bLDirname(s, 10); 911 ck_assert_ptr_eq(r, s); 912 ck_assert_str_eq(s, "release"); 913 strcpy(s, "release/anotherdir/libsheepy.a"); 914 r = bLDirname(s, 9); 915 ck_assert_ptr_eq(r, s); 916 ck_assert_str_eq(s, "release/"); 917 918 // one item path 919 r = strCpy(s, "sheepy.lib"); 920 ck_assert_ptr_eq(r, s); 921 r = bLDirname(s, sizeof s); 922 ck_assert_ptr_eq(r, s); 923 ck_assert_str_eq(s, "./"); 924 925 // empty 926 r = strCpy(s, " "); 927 ck_assert_ptr_eq(r, s); 928 r = bLDirname(s, sizeof s); 929 ck_assert_ptr_eq(r, s); 930 ck_assert_str_eq(s, "./"); 931 932 // size 0 - no change in s 933 r = bLDirname(s, 0); 934 ck_assert_ptr_eq(r, null); 935 ck_assert_str_eq(s, "./"); 936 937 // NULL 938 r = bLDirname(NULL, 0); 939 ck_assert_ptr_eq(r, null); 940 941 } 942 943 944 void expandHomeT(CuTest *tc UNUSED) { 945 946 // no ~/ 947 char *s; 948 s = expandHome("sheepy"); 949 ck_assert_str_eq(s, "sheepy"); 950 free(s); 951 // NULL path 952 ck_assert_ptr_eq(expandHome(NULL), NULL); 953 954 } 955 956 957 void iExpandHomeT(CuTest *tc UNUSED) { 958 959 // no ~/ 960 char *s = strdup("sheepy"); 961 char *r = null; 962 963 r = iExpandHome(&s); 964 ck_assert_ptr_eq(r, s); 965 ck_assert_str_eq(s, "sheepy"); 966 free(s); 967 // NULL path 968 s = NULL; 969 r = iExpandHome(&s); 970 ck_assert_ptr_eq(r, s); 971 ck_assert_ptr_eq(s, NULL); 972 // NULL var 973 r = iExpandHome(NULL); 974 ck_assert_ptr_eq(r, null); 975 976 } 977 978 979 void bExpandHomeT(CuTest *tc UNUSED) { 980 981 // no ~/ 982 char s[100] = "sheepy"; 983 char *r = null; 984 985 r = bExpandHome(s); 986 ck_assert_ptr_eq(r, s); 987 ck_assert_str_eq(s, "sheepy"); 988 // NULL 989 r = bExpandHome(NULL); 990 ck_assert_ptr_eq(r, null); 991 992 } 993 994 995 void bLExpandHomeT(CuTest *tc UNUSED) { 996 997 // no ~/ 998 char s[100] = "sheepy"; 999 char *r = null; 1000 1001 r = bLExpandHome(s, sizeof s); 1002 ck_assert_ptr_eq(r, s); 1003 ck_assert_str_eq(s, "sheepy"); 1004 // shorter buffer size 1005 r = bLExpandHome(s, 3); 1006 ck_assert_ptr_eq(r, s); 1007 ck_assert_str_eq(s, "sh"); 1008 // size 0 1009 r = bLExpandHome(s, 0); 1010 ck_assert_ptr_eq(r, s); 1011 ck_assert_str_eq(s, "sh"); 1012 // NULL 1013 r = bLExpandHome(NULL, sizeof s); 1014 ck_assert_ptr_eq(r, null); 1015 1016 } 1017 1018 1019 void normalizePathT(CuTest *tc UNUSED) { 1020 1021 // test 1022 char *s; 1023 s = normalizePath("test/.././file.txt"); 1024 ck_assert_str_eq(s, "file.txt"); 1025 free(s); 1026 // remove end / 1027 s = normalizePath("/home/"); 1028 ck_assert_str_eq(s, "/home"); 1029 free(s); 1030 // cancel path and keep leading / 1031 s = normalizePath("/home/.."); 1032 ck_assert_str_eq(s, "/"); 1033 free(s); 1034 // cancel path 1035 s = normalizePath("home/.."); 1036 ck_assert_str_eq(s, ""); 1037 free(s); 1038 // multiple / 1039 s = normalizePath("/home///stuff"); 1040 ck_assert_str_eq(s, "/home/stuff"); 1041 free(s); 1042 // remove . and .. and keep leading / 1043 s = normalizePath("/a/./b/../../c/"); 1044 ck_assert_str_eq(s, "/c"); 1045 free(s); 1046 // keep leading / 1047 s = normalizePath("/../"); 1048 ck_assert_str_eq(s, "/"); 1049 free(s); 1050 // keep leading .. 1051 s = normalizePath(".././/"); 1052 ck_assert_str_eq(s, ".."); 1053 free(s); 1054 // remove . 1055 s = normalizePath("./"); 1056 ck_assert_str_eq(s, ""); 1057 free(s); 1058 // keep / before . 1059 s = normalizePath("/."); 1060 ck_assert_str_eq(s, "/"); 1061 free(s); 1062 // remove . 1063 s = normalizePath("."); 1064 ck_assert_str_eq(s, ""); 1065 free(s); 1066 // / not changed 1067 s = normalizePath("/"); 1068 ck_assert_str_eq(s, "/"); 1069 free(s); 1070 // // becomes / 1071 s = normalizePath("//"); 1072 ck_assert_str_eq(s, "/"); 1073 free(s); 1074 // remove leading . 1075 s = normalizePath("/./werwer"); 1076 ck_assert_str_eq(s, "/werwer"); 1077 free(s); 1078 // keep leading .. and remove .. in path 1079 s = normalizePath(".././test/../test/file"); 1080 ck_assert_str_eq(s, "../test/file"); 1081 free(s); 1082 s = normalizePath("../d1/./d2/../f1"); 1083 ck_assert_str_eq(s, "../d1/f1"); 1084 free(s); 1085 s = normalizePath("a/b/c/../d/../e"); 1086 ck_assert_str_eq(s, "a/b/e"); 1087 free(s); 1088 // dont remove .. when there are only .. in front 1089 s = normalizePath("../../test/test/file"); 1090 ck_assert_str_eq(s, "../../test/test/file"); 1091 free(s); 1092 // empty path 1093 s = normalizePath(""); 1094 ck_assert_str_eq(s, ""); 1095 free(s); 1096 // NULL path 1097 ck_assert_ptr_eq(normalizePath(NULL), NULL); 1098 1099 } 1100 1101 1102 void iNormalizePathT(CuTest *tc UNUSED) { 1103 1104 // test 1105 char *s = strdup("test/.././file.txt"); 1106 char *r = null; 1107 1108 r = iNormalizePath(&s); 1109 ck_assert_ptr_eq(r, s); 1110 ck_assert_str_eq(s, "file.txt"); 1111 free(s); 1112 // remove end / 1113 s = strdup("/home/"); 1114 r = iNormalizePath(&s); 1115 ck_assert_ptr_eq(r, s); 1116 ck_assert_str_eq(s, "/home"); 1117 free(s); 1118 // cancel path and keep leading / 1119 s = strdup("/home/.."); 1120 r = iNormalizePath(&s); 1121 ck_assert_ptr_eq(r, s); 1122 ck_assert_str_eq(s, "/"); 1123 free(s); 1124 // cancel path 1125 s = strdup("home/.."); 1126 r = iNormalizePath(&s); 1127 ck_assert_ptr_eq(r, s); 1128 ck_assert_str_eq(s, ""); 1129 free(s); 1130 // multiple / 1131 s = strdup("/home///stuff"); 1132 r = iNormalizePath(&s); 1133 ck_assert_ptr_eq(r, s); 1134 ck_assert_str_eq(s, "/home/stuff"); 1135 free(s); 1136 // remove . and .. and keep leading / 1137 s = strdup("/a/./b/../../c/"); 1138 r = iNormalizePath(&s); 1139 ck_assert_ptr_eq(r, s); 1140 ck_assert_str_eq(s, "/c"); 1141 free(s); 1142 // keep leading / 1143 s = strdup("/../"); 1144 r = iNormalizePath(&s); 1145 ck_assert_ptr_eq(r, s); 1146 ck_assert_str_eq(s, "/"); 1147 free(s); 1148 // keep leading .. 1149 s = strdup(".././/"); 1150 r = iNormalizePath(&s); 1151 ck_assert_ptr_eq(r, s); 1152 ck_assert_str_eq(s, ".."); 1153 free(s); 1154 // remove . 1155 s = strdup("./"); 1156 r = iNormalizePath(&s); 1157 ck_assert_ptr_eq(r, s); 1158 ck_assert_str_eq(s, ""); 1159 free(s); 1160 // keep / before . 1161 s = strdup("/."); 1162 r = iNormalizePath(&s); 1163 ck_assert_ptr_eq(r, s); 1164 ck_assert_str_eq(s, "/"); 1165 free(s); 1166 // remove . 1167 s = strdup("."); 1168 r = iNormalizePath(&s); 1169 ck_assert_ptr_eq(r, s); 1170 ck_assert_str_eq(s, ""); 1171 free(s); 1172 // / not changed 1173 s = strdup("/"); 1174 r = iNormalizePath(&s); 1175 ck_assert_ptr_eq(r, s); 1176 ck_assert_str_eq(s, "/"); 1177 free(s); 1178 // // becomes / 1179 s = strdup("//"); 1180 r = iNormalizePath(&s); 1181 ck_assert_ptr_eq(r, s); 1182 ck_assert_str_eq(s, "/"); 1183 free(s); 1184 // remove leading . 1185 s = strdup("/./werwer"); 1186 r = iNormalizePath(&s); 1187 ck_assert_ptr_eq(r, s); 1188 ck_assert_str_eq(s, "/werwer"); 1189 free(s); 1190 // keep leading .. and remove .. in path 1191 s = strdup(".././test/../test/file"); 1192 r = iNormalizePath(&s); 1193 ck_assert_ptr_eq(r, s); 1194 ck_assert_str_eq(s, "../test/file"); 1195 free(s); 1196 s = strdup("../d1/./d2/../f1"); 1197 r = iNormalizePath(&s); 1198 ck_assert_ptr_eq(r, s); 1199 ck_assert_str_eq(s, "../d1/f1"); 1200 free(s); 1201 s = strdup("a/b/c/../d/../e"); 1202 r = iNormalizePath(&s); 1203 ck_assert_ptr_eq(r, s); 1204 ck_assert_str_eq(s, "a/b/e"); 1205 free(s); 1206 // dont remove .. when there are only .. in front 1207 s = strdup("../../test/test/file"); 1208 r = iNormalizePath(&s); 1209 ck_assert_ptr_eq(r, s); 1210 ck_assert_str_eq(s, "../../test/test/file"); 1211 free(s); 1212 // empty path 1213 s = strdup(""); 1214 r = iNormalizePath(&s); 1215 ck_assert_ptr_eq(r, s); 1216 ck_assert_str_eq(s, ""); 1217 free(s); 1218 // empty NULL path 1219 s = NULL; 1220 r = iNormalizePath(&s); 1221 ck_assert_ptr_eq(r, null); 1222 // NULL path 1223 r = iNormalizePath(NULL); 1224 ck_assert_ptr_eq(r, null); 1225 1226 } 1227 1228 1229 void bNormalizePathT(CuTest *tc UNUSED) { 1230 1231 // test 1232 char s[100] = "test/.././file.txt"; 1233 char *r = null; 1234 1235 r = bNormalizePath(s); 1236 ck_assert_ptr_eq(r, s); 1237 ck_assert_str_eq(s, "file.txt"); 1238 // remove end / 1239 strcpy(s, "/home/"); 1240 r = bNormalizePath(s); 1241 ck_assert_ptr_eq(r, s); 1242 ck_assert_str_eq(s, "/home"); 1243 // cancel path and keep leading / 1244 strcpy(s, "/home/.."); 1245 r = bNormalizePath(s); 1246 ck_assert_ptr_eq(r, s); 1247 ck_assert_str_eq(s, "/"); 1248 // cancel path 1249 strcpy(s, "home/.."); 1250 r = bNormalizePath(s); 1251 ck_assert_ptr_eq(r, s); 1252 ck_assert_str_eq(s, ""); 1253 // multiple / 1254 strcpy(s, "/home///stuff"); 1255 r = bNormalizePath(s); 1256 ck_assert_ptr_eq(r, s); 1257 ck_assert_str_eq(s, "/home/stuff"); 1258 // remove . and .. and keep leading / 1259 strcpy(s, "/a/./b/../../c/"); 1260 r = bNormalizePath(s); 1261 ck_assert_ptr_eq(r, s); 1262 ck_assert_str_eq(s, "/c"); 1263 // keep leading / 1264 strcpy(s, "/../"); 1265 r = bNormalizePath(s); 1266 ck_assert_ptr_eq(r, s); 1267 ck_assert_str_eq(s, "/"); 1268 // keep leading .. 1269 strcpy(s, ".././/"); 1270 r = bNormalizePath(s); 1271 ck_assert_ptr_eq(r, s); 1272 ck_assert_str_eq(s, ".."); 1273 // remove . 1274 strcpy(s, "./"); 1275 r = bNormalizePath(s); 1276 ck_assert_ptr_eq(r, s); 1277 ck_assert_str_eq(s, ""); 1278 // keep / before . 1279 strcpy(s, "/."); 1280 r = bNormalizePath(s); 1281 ck_assert_ptr_eq(r, s); 1282 ck_assert_str_eq(s, "/"); 1283 // remove . 1284 strcpy(s, "."); 1285 r = bNormalizePath(s); 1286 ck_assert_ptr_eq(r, s); 1287 ck_assert_str_eq(s, ""); 1288 // / not changed 1289 strcpy(s, "/"); 1290 r = bNormalizePath(s); 1291 ck_assert_ptr_eq(r, s); 1292 ck_assert_str_eq(s, "/"); 1293 // // becomes / 1294 strcpy(s, "//"); 1295 r = bNormalizePath(s); 1296 ck_assert_ptr_eq(r, s); 1297 ck_assert_str_eq(s, "/"); 1298 // remove leading . 1299 strcpy(s, "/./werwer"); 1300 r = bNormalizePath(s); 1301 ck_assert_ptr_eq(r, s); 1302 ck_assert_str_eq(s, "/werwer"); 1303 // keep leading .. and remove .. in path 1304 strcpy(s, ".././test/../test/file"); 1305 r = bNormalizePath(s); 1306 ck_assert_ptr_eq(r, s); 1307 ck_assert_str_eq(s, "../test/file"); 1308 strcpy(s, "../d1/./d2/../f1"); 1309 r = bNormalizePath(s); 1310 ck_assert_ptr_eq(r, s); 1311 ck_assert_str_eq(s, "../d1/f1"); 1312 strcpy(s, "a/b/c/../d/../e"); 1313 r = bNormalizePath(s); 1314 ck_assert_ptr_eq(r, s); 1315 ck_assert_str_eq(s, "a/b/e"); 1316 // dont remove .. when there are only .. in front 1317 strcpy(s, "../../test/test/file"); 1318 r = bNormalizePath(s); 1319 ck_assert_ptr_eq(r, s); 1320 ck_assert_str_eq(s, "../../test/test/file"); 1321 // empty path 1322 strcpy(s, ""); 1323 r = bNormalizePath(s); 1324 ck_assert_ptr_eq(r, s); 1325 ck_assert_str_eq(s, ""); 1326 // NULL path 1327 r = bNormalizePath(NULL); 1328 ck_assert_ptr_eq(r, null); 1329 1330 } 1331 1332 1333 void bLNormalizePathT(CuTest *tc UNUSED) { 1334 1335 // test 1336 char s[100] = "test/.././file.txt"; 1337 char *r = null; 1338 1339 r = bLNormalizePath(s, sizeof s); 1340 ck_assert_ptr_eq(r, s); 1341 ck_assert_str_eq(s, "file.txt"); 1342 // remove end / 1343 strcpy(s, "/home/"); 1344 r = bLNormalizePath(s, sizeof s); 1345 ck_assert_ptr_eq(r, s); 1346 ck_assert_str_eq(s, "/home"); 1347 // cancel path and keep leading / 1348 strcpy(s, "/home/.."); 1349 r = bLNormalizePath(s, sizeof s); 1350 ck_assert_ptr_eq(r, s); 1351 ck_assert_str_eq(s, "/"); 1352 // cancel path 1353 strcpy(s, "home/.."); 1354 r = bLNormalizePath(s, sizeof s); 1355 ck_assert_ptr_eq(r, s); 1356 ck_assert_str_eq(s, ""); 1357 // multiple / 1358 strcpy(s, "/home///stuff"); 1359 r = bLNormalizePath(s, sizeof s); 1360 ck_assert_ptr_eq(r, s); 1361 ck_assert_str_eq(s, "/home/stuff"); 1362 // remove . and .. and keep leading / 1363 strcpy(s, "/a/./b/../../c/"); 1364 r = bLNormalizePath(s, sizeof s); 1365 ck_assert_ptr_eq(r, s); 1366 ck_assert_str_eq(s, "/c"); 1367 // keep leading / 1368 strcpy(s, "/../"); 1369 r = bLNormalizePath(s, sizeof s); 1370 ck_assert_ptr_eq(r, s); 1371 ck_assert_str_eq(s, "/"); 1372 // keep leading .. 1373 strcpy(s, ".././/"); 1374 r = bLNormalizePath(s, sizeof s); 1375 ck_assert_ptr_eq(r, s); 1376 ck_assert_str_eq(s, ".."); 1377 // remove . 1378 strcpy(s, "./"); 1379 r = bLNormalizePath(s, sizeof s); 1380 ck_assert_ptr_eq(r, s); 1381 ck_assert_str_eq(s, ""); 1382 // keep / before . 1383 strcpy(s, "/."); 1384 r = bLNormalizePath(s, sizeof s); 1385 ck_assert_ptr_eq(r, s); 1386 ck_assert_str_eq(s, "/"); 1387 // remove . 1388 strcpy(s, "."); 1389 r = bLNormalizePath(s, sizeof s); 1390 ck_assert_ptr_eq(r, s); 1391 ck_assert_str_eq(s, ""); 1392 // / not changed 1393 strcpy(s, "/"); 1394 r = bLNormalizePath(s, sizeof s); 1395 ck_assert_ptr_eq(r, s); 1396 ck_assert_str_eq(s, "/"); 1397 // // becomes / 1398 strcpy(s, "//"); 1399 r = bLNormalizePath(s, sizeof s); 1400 ck_assert_ptr_eq(r, s); 1401 ck_assert_str_eq(s, "/"); 1402 // remove leading . 1403 strcpy(s, "/./werwer"); 1404 r = bLNormalizePath(s, sizeof s); 1405 ck_assert_ptr_eq(r, s); 1406 ck_assert_str_eq(s, "/werwer"); 1407 // keep leading .. and remove .. in path 1408 strcpy(s, ".././test/../test/file"); 1409 r = bLNormalizePath(s, sizeof s); 1410 ck_assert_ptr_eq(r, s); 1411 ck_assert_str_eq(s, "../test/file"); 1412 strcpy(s, "../d1/./d2/../f1"); 1413 r = bLNormalizePath(s, sizeof s); 1414 ck_assert_ptr_eq(r, s); 1415 ck_assert_str_eq(s, "../d1/f1"); 1416 strcpy(s, "a/b/c/../d/../e"); 1417 r = bLNormalizePath(s, sizeof s); 1418 ck_assert_ptr_eq(r, s); 1419 ck_assert_str_eq(s, "a/b/e"); 1420 // dont remove .. when there are only .. in front 1421 strcpy(s, "../../test/test/file"); 1422 r = bLNormalizePath(s, sizeof s); 1423 ck_assert_ptr_eq(r, s); 1424 ck_assert_str_eq(s, "../../test/test/file"); 1425 // empty path 1426 strcpy(s, ""); 1427 r = bLNormalizePath(s, sizeof s); 1428 ck_assert_ptr_eq(r, s); 1429 ck_assert_str_eq(s, ""); 1430 // shorter buffer than path 1431 strcpy(s, "a/b/c/../d/../e"); 1432 r = bLNormalizePath(s, 4); 1433 ck_assert_ptr_eq(r, s); 1434 ck_assert_str_eq(s, "a/b"); 1435 strcpy(s, "a/b/c/../d/../e"); 1436 // size 0 - no change in path 1437 r = bLNormalizePath(s, 0); 1438 ck_assert_ptr_eq(r, s); 1439 ck_assert_str_eq(s, "a/b/c/../d/../e"); 1440 // NULL path 1441 r = bLNormalizePath(NULL, sizeof s); 1442 ck_assert_ptr_eq(r, null); 1443 1444 } 1445 1446 1447 void relPathT(CuTest *tc UNUSED) { 1448 1449 char *r; 1450 char *cwd; 1451 1452 // relative to cwd 1453 cwd = getCwd(); 1454 r = iAppendS(&cwd, "/../sheepy"); 1455 ck_assert_ptr_eq(r, cwd); 1456 r = relPath(cwd, null); 1457 ck_assert_str_eq(r, "../sheepy"); 1458 free(r); 1459 free(cwd); 1460 1461 // relative to cwd and path starts with cwd but is a different path 1462 // (no slash between cwd and "../sheepy") 1463 cwd = getCwd(); 1464 r = iAppendS(&cwd, "../sheepy"); 1465 ck_assert_ptr_eq(r, cwd); 1466 r = relPath(cwd, null); 1467 ck_assert_str_eq(r, "../src../sheepy"); 1468 free(r); 1469 free(cwd); 1470 1471 // subdirectory to cwd 1472 cwd = getCwd(); 1473 r = iAppendS(&cwd, "/sheepy"); 1474 ck_assert_ptr_eq(r, cwd); 1475 r = relPath(cwd, null); 1476 ck_assert_str_eq(r, "sheepy"); 1477 free(r); 1478 free(cwd); 1479 1480 // path = start 1481 cwd = getCwd(); 1482 r = relPath(cwd, null); 1483 ck_assert_str_eq(r, "."); 1484 free(r); 1485 free(cwd); 1486 1487 // start = root 1488 cwd = getCwd(); 1489 r = iAppendS(&cwd, "/sheepy"); 1490 ck_assert_ptr_eq(r, cwd); 1491 r = relPath(cwd, "/../"); 1492 ck_assert_str_eq(r, cwd+1); 1493 free(r); 1494 free(cwd); 1495 1496 // relative to start 1497 r = relPath("/home/sheepy", "/home/test"); 1498 ck_assert_str_eq(r, "../sheepy"); 1499 free(r); 1500 1501 // path is relative (no leading slash), start is cwd 1502 r = relPath("../src/sheepy", null); 1503 ck_assert_str_eq(r, "sheepy"); 1504 free(r); 1505 1506 // path is relative (no leading slash) 1507 r = relPath("../test/sheepy", "/home/test"); 1508 ck_assert_str_eq(r, "sheepy"); 1509 free(r); 1510 1511 // start is relative to cwd 1512 cwd = getCwd(); 1513 r = iAppendS(&cwd, "/../sheepy"); 1514 ck_assert_ptr_eq(r, cwd); 1515 r = relPath(cwd, "test/"); 1516 ck_assert_str_eq(r, "../../sheepy"); 1517 free(r); 1518 free(cwd); 1519 1520 // all relative paths 1521 // the reference for path and start parameters is an arbitrary directory 1522 r = relPath("sheepy", "shefjf/test/src/"); 1523 ck_assert_str_eq(r, "../../../sheepy"); 1524 free(r); 1525 1526 r = relPath("sheepy", "shee"); 1527 ck_assert_str_eq(r, "../sheepy"); 1528 free(r); 1529 1530 // null path 1531 r = relPath(null, null); 1532 ck_assert_ptr_eq(r, null); 1533 1534 } 1535 1536 1537 void iRelPathT(CuTest *tc UNUSED) { 1538 1539 char *r; 1540 char *cwd; 1541 1542 // relative to cwd 1543 cwd = getCwd(); 1544 r = iAppendS(&cwd, "/../sheepy"); 1545 ck_assert_ptr_eq(r, cwd); 1546 r = iRelPath(&cwd, null); 1547 ck_assert_str_eq(r, "../sheepy"); 1548 free(r); 1549 1550 // relative to cwd and path starts with cwd but is a different path 1551 // (no slash between cwd and "../sheepy") 1552 cwd = getCwd(); 1553 r = iAppendS(&cwd, "../sheepy"); 1554 ck_assert_ptr_eq(r, cwd); 1555 r = iRelPath(&cwd, null); 1556 ck_assert_str_eq(r, "../src../sheepy"); 1557 free(r); 1558 1559 // subdirectory to cwd 1560 cwd = getCwd(); 1561 r = iAppendS(&cwd, "/sheepy"); 1562 ck_assert_ptr_eq(r, cwd); 1563 r = iRelPath(&cwd, null); 1564 ck_assert_str_eq(r, "sheepy"); 1565 free(r); 1566 1567 // path = start 1568 cwd = getCwd(); 1569 r = iRelPath(&cwd, null); 1570 ck_assert_str_eq(r, "."); 1571 free(r); 1572 1573 // start = root 1574 cwd = getCwd(); 1575 r = iAppendS(&cwd, "/sheepy"); 1576 ck_assert_ptr_eq(r, cwd); 1577 char *expected = strdup(cwd+1); 1578 r = iRelPath(&cwd, "/../"); 1579 ck_assert_str_eq(r, expected); 1580 free(r); 1581 free(expected); 1582 1583 // relative to start 1584 cwd = strdup("/home/sheepy"); 1585 r = iRelPath(&cwd, "/home/test"); 1586 ck_assert_str_eq(r, "../sheepy"); 1587 free(r); 1588 1589 // path is relative (no leading slash), start is cwd 1590 cwd = strdup("../src/sheepy"); 1591 r = iRelPath(&cwd, null); 1592 ck_assert_str_eq(r, "sheepy"); 1593 free(r); 1594 1595 // path is relative (no leading slash) 1596 cwd = strdup("../test/sheepy"); 1597 r = iRelPath(&cwd, "/home/test"); 1598 ck_assert_str_eq(r, "sheepy"); 1599 free(r); 1600 1601 // start is relative to cwd 1602 cwd = getCwd(); 1603 r = iAppendS(&cwd, "/../sheepy"); 1604 ck_assert_ptr_eq(r, cwd); 1605 r = iRelPath(&cwd, "test/"); 1606 ck_assert_str_eq(r, "../../sheepy"); 1607 free(r); 1608 1609 // all relative paths 1610 // the reference for path and start parameters is an arbitrary directory 1611 cwd = strdup("sheepy"); 1612 r = iRelPath(&cwd, "shefjf/test/src/"); 1613 ck_assert_str_eq(r, "../../../sheepy"); 1614 free(r); 1615 1616 cwd = strdup("sheepy"); 1617 r = iRelPath(&cwd, "shee"); 1618 ck_assert_str_eq(r, "../sheepy"); 1619 free(r); 1620 1621 // null path 1622 cwd = null; 1623 r = iRelPath(&cwd, null); 1624 ck_assert_ptr_eq(r, null); 1625 1626 // null var 1627 r = iRelPath(null, null); 1628 ck_assert_ptr_eq(r, null); 1629 1630 } 1631 1632 1633 void bRelPathT(CuTest *tc UNUSED) { 1634 1635 char b[8192] = init0Var; 1636 char *r; 1637 char *cwd; 1638 1639 // relative to cwd 1640 cwd = getCwd(); 1641 r = iAppendS(&cwd, "/../sheepy"); 1642 ck_assert_ptr_eq(r, cwd); 1643 r = bRelPath(b, cwd, null); 1644 ck_assert_str_eq(r, "../sheepy"); 1645 free(cwd); 1646 1647 // relative to cwd and path starts with cwd but is a different path 1648 // (no slash between cwd and "../sheepy") 1649 cwd = getCwd(); 1650 r = iAppendS(&cwd, "../sheepy"); 1651 ck_assert_ptr_eq(r, cwd); 1652 r = bRelPath(b, cwd, null); 1653 ck_assert_str_eq(r, "../src../sheepy"); 1654 free(cwd); 1655 1656 // subdirectory to cwd 1657 cwd = getCwd(); 1658 r = iAppendS(&cwd, "/sheepy"); 1659 ck_assert_ptr_eq(r, cwd); 1660 r = bRelPath(b, cwd, null); 1661 ck_assert_str_eq(r, "sheepy"); 1662 free(cwd); 1663 1664 // path = start 1665 cwd = getCwd(); 1666 r = bRelPath(b, cwd, null); 1667 ck_assert_str_eq(r, "."); 1668 free(cwd); 1669 1670 // start = root 1671 cwd = getCwd(); 1672 r = iAppendS(&cwd, "/sheepy"); 1673 ck_assert_ptr_eq(r, cwd); 1674 r = bRelPath(b, cwd, "/../"); 1675 ck_assert_str_eq(r, cwd+1); 1676 free(cwd); 1677 1678 // relative to start 1679 r = bRelPath(b, "/home/sheepy", "/home/test"); 1680 ck_assert_str_eq(r, "../sheepy"); 1681 1682 // path is relative (no leading slash), start is cwd 1683 r = bRelPath(b, "../src/sheepy", null); 1684 ck_assert_str_eq(r, "sheepy"); 1685 1686 // path is relative (no leading slash) 1687 r = bRelPath(b, "../test/sheepy", "/home/test"); 1688 ck_assert_str_eq(r, "sheepy"); 1689 1690 // start is relative to cwd 1691 cwd = getCwd(); 1692 r = iAppendS(&cwd, "/../sheepy"); 1693 ck_assert_ptr_eq(r, cwd); 1694 r = bRelPath(b, cwd, "test/"); 1695 ck_assert_str_eq(r, "../../sheepy"); 1696 free(cwd); 1697 1698 // all relative paths 1699 // the reference for path and start parameters is an arbitrary directory 1700 r = bRelPath(b, "sheepy", "shefjf/test/src/"); 1701 ck_assert_str_eq(r, "../../../sheepy"); 1702 1703 r = bRelPath(b, "sheepy", "shee"); 1704 ck_assert_str_eq(r, "../sheepy"); 1705 1706 // null path 1707 r = bRelPath(b, null, null); 1708 ck_assert_ptr_eq(r, null); 1709 1710 // null dest 1711 r = bRelPath(null, "", null); 1712 ck_assert_ptr_eq(r, null); 1713 1714 1715 } 1716 1717 1718 void bLRelPathT(CuTest *tc UNUSED) { 1719 1720 char b[8192] = init0Var; 1721 char *r; 1722 char *cwd; 1723 1724 // relative to cwd 1725 cwd = getCwd(); 1726 r = iAppendS(&cwd, "/../sheepy"); 1727 ck_assert_ptr_eq(r, cwd); 1728 r = bLRelPath(b, sizeof(b), cwd, null); 1729 ck_assert_str_eq(r, "../sheepy"); 1730 free(cwd); 1731 1732 // relative to cwd and path starts with cwd but is a different path 1733 // (no slash between cwd and "../sheepy") 1734 cwd = getCwd(); 1735 r = iAppendS(&cwd, "../sheepy"); 1736 ck_assert_ptr_eq(r, cwd); 1737 r = bLRelPath(b, sizeof(b), cwd, null); 1738 ck_assert_str_eq(r, "../src../sheepy"); 1739 free(cwd); 1740 1741 // subdirectory to cwd 1742 cwd = getCwd(); 1743 r = iAppendS(&cwd, "/sheepy"); 1744 ck_assert_ptr_eq(r, cwd); 1745 r = bLRelPath(b, sizeof(b), cwd, null); 1746 ck_assert_str_eq(r, "sheepy"); 1747 free(cwd); 1748 1749 // path = start 1750 cwd = getCwd(); 1751 r = bLRelPath(b, sizeof(b), cwd, null); 1752 ck_assert_str_eq(r, "."); 1753 free(cwd); 1754 1755 // start = root 1756 cwd = getCwd(); 1757 r = iAppendS(&cwd, "/sheepy"); 1758 ck_assert_ptr_eq(r, cwd); 1759 r = bLRelPath(b, sizeof(b), cwd, "/../"); 1760 ck_assert_str_eq(r, cwd+1); 1761 free(cwd); 1762 1763 // relative to start 1764 r = bLRelPath(b, sizeof(b), "/home/sheepy", "/home/test"); 1765 ck_assert_str_eq(r, "../sheepy"); 1766 1767 // path is relative (no leading slash), start is cwd 1768 r = bLRelPath(b, sizeof(b), "../src/sheepy", null); 1769 ck_assert_str_eq(r, "sheepy"); 1770 1771 // path is relative (no leading slash) 1772 r = bLRelPath(b, sizeof(b), "../test/sheepy", "/home/test"); 1773 ck_assert_str_eq(r, "sheepy"); 1774 1775 // start is relative to cwd 1776 cwd = getCwd(); 1777 r = iAppendS(&cwd, "/../sheepy"); 1778 ck_assert_ptr_eq(r, cwd); 1779 r = bLRelPath(b, sizeof(b), cwd, "test/"); 1780 ck_assert_str_eq(r, "../../sheepy"); 1781 free(cwd); 1782 1783 // all relative paths 1784 // the reference for path and start parameters is an arbitrary directory 1785 r = bLRelPath(b, sizeof(b), "sheepy", "shefjf/test/src/"); 1786 ck_assert_str_eq(r, "../../../sheepy"); 1787 1788 r = bLRelPath(b, sizeof(b), "sheepy", "shee"); 1789 ck_assert_str_eq(r, "../sheepy"); 1790 1791 // null path 1792 r = bLRelPath(b, sizeof(b), null, null); 1793 ck_assert_ptr_eq(r, null); 1794 1795 // null dest 1796 r = bLRelPath(null, sizeof(b), "", null); 1797 ck_assert_ptr_eq(r, null); 1798 1799 } 1800 1801 1802 void getHomePathT(CuTest *tc UNUSED) { 1803 1804 char *r = getHomePath(); 1805 ck_assert_ptr_ne(r, null); 1806 ck_assert_int_eq(r[0], '/'); 1807 free(r); 1808 1809 char b[8192] = init0Var; 1810 r = bGetHomePath(b); 1811 ck_assert_ptr_ne(r, null); 1812 ck_assert_int_eq(r[0], '/'); 1813 1814 r = bLGetHomePath(b, sizeof(b)); 1815 ck_assert_ptr_ne(r, null); 1816 ck_assert_int_eq(r[0], '/'); 1817 1818 // buffer too short 1819 char bL[2] = init0Var; 1820 r = bLGetHomePath(bL, sizeof(bL)); 1821 ck_assert_ptr_eq(r, null); 1822 1823 const char *cR = getCHomePath(); 1824 ck_assert_ptr_ne(cR, null); 1825 ck_assert_int_eq(cR[0], '/'); 1826 1827 } 1828 1829 1830 void getCwdT(CuTest *tc UNUSED) { 1831 1832 char *r = getCwd(); 1833 ck_assert_ptr_ne(r, null); 1834 ck_assert_int_eq(r[0], '/'); 1835 free(r); 1836 1837 // buffer 1838 char b[8192] = init0Var; 1839 r = bLGetCwd(b, sizeof(b)); 1840 ck_assert_ptr_ne(r, null); 1841 ck_assert_int_eq(r[0], '/'); 1842 1843 // buffer too short 1844 char bL[2] = init0Var; 1845 r = bLGetCwd(bL, sizeof(bL)); 1846 ck_assert_ptr_eq(r, null); 1847 1848 } 1849 1850 1851 void chDirT(CuTest *tc UNUSED) { 1852 1853 // change directory 1854 char *c = getCwd(); 1855 ck_assert(chDir("dirTest.null")); 1856 char *s = getCwd(); 1857 ck_assert((size_t)findS(s, "dirTest.null")); 1858 bool r = chDir(c); 1859 ck_assert(r); 1860 freeManyS(c,s); 1861 // non existing dir 1862 ck_assert(!chDir("RandomNonExistingDir")); 1863 // NULL path 1864 ck_assert(!chDir(NULL)); 1865 1866 } 1867 1868 1869 void isDirT(CuTest *tc UNUSED) { 1870 1871 // dir 1872 ck_assert(isDir("dirTest.null")); 1873 1874 // non existing dir 1875 ck_assert(!isDir("RandomNonExistingDir")); 1876 1877 // blank 1878 ck_assert(!isDir(" ")); 1879 1880 // NULL path 1881 ck_assert(!isDir(NULL)); 1882 1883 } 1884 1885 1886 void shReadlinkT(CuTest *tc UNUSED) { 1887 1888 char *r; 1889 1890 // read a link 1891 r = shReadlink("linkTest.null"); 1892 ck_assert_ptr_ne(r, null); 1893 ck_assert_str_eq(r, "textTest.null"); 1894 free(r); 1895 1896 // not a link, regular file 1897 r = shReadlink("textTest.null"); 1898 ck_assert_ptr_eq(r, null); 1899 1900 // non existing path 1901 r = shReadlink("random"); 1902 ck_assert_ptr_eq(r, null); 1903 1904 // blank path 1905 r = shReadlink(" "); 1906 ck_assert_ptr_eq(r, null); 1907 1908 // null path 1909 r = shReadlink(null); 1910 ck_assert_ptr_eq(r, null); 1911 1912 } 1913 1914 1915 void endlinkT(CuTest *tc UNUSED) { 1916 1917 char *r; 1918 1919 // read a link 1920 r = endlink("linkTest.null"); 1921 ck_assert_ptr_ne(r, null); 1922 ck_assert_str_eq(r, "textTest.null"); 1923 free(r); 1924 1925 // read a link to absolute path 1926 r = endlink("absLinkTest.null"); 1927 ck_assert_ptr_ne(r, null); 1928 ck_assert_str_eq(r, "/usr/local/bin/sheepy"); 1929 free(r); 1930 1931 // not a link, regular file 1932 r = endlink("textTest.null"); 1933 ck_assert_ptr_eq(r, null); 1934 1935 // non existing path 1936 r = endlink("random"); 1937 ck_assert_ptr_eq(r, null); 1938 1939 // blank path 1940 r = endlink(" "); 1941 ck_assert_ptr_eq(r, null); 1942 1943 // null path 1944 r = endlink(null); 1945 ck_assert_ptr_eq(r, null); 1946 1947 } 1948 1949 1950 void isLinkT(CuTest *tc UNUSED) { 1951 1952 // link 1953 ck_assert(isLink("linkTest.null")); 1954 1955 // not link 1956 ck_assert(!isLink("textTest.null")); 1957 1958 // non existing link 1959 ck_assert(!isLink("RandomNonExistingDir")); 1960 1961 // blank 1962 ck_assert(!isLink(" ")); 1963 1964 // NULL path 1965 ck_assert(!isLink(NULL)); 1966 1967 } 1968 1969 1970 void fileExistsT(CuTest *tc UNUSED) { 1971 1972 // detect existing file 1973 ck_assert(fileExists("libsheepyTest.c")); 1974 // non existing file 1975 ck_assert(!fileExists("wefwepfk34.c")); 1976 // folder 1977 ck_assert(fileExists("../src")); 1978 // empty path 1979 ck_assert(!fileExists("")); 1980 // NULL path 1981 ck_assert(!fileExists(NULL)); 1982 1983 } 1984 1985 1986 void fileChmodT(CuTest *tc UNUSED) { 1987 1988 // existing file 1989 ck_assert(fileChmod("chmodTest.null", S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH)); 1990 ck_assert(fileChmod("chmodTest.null", S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)); 1991 // non existing file 1992 ck_assert(!fileChmod("qweqwe_null", S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)); 1993 // empty path 1994 ck_assert(!fileChmod("",0)); 1995 // NULL path 1996 ck_assert(!fileChmod(NULL,0)); 1997 1998 } 1999 2000 2001 void fileSizeT(CuTest *tc UNUSED) { 2002 2003 // existing file 2004 ck_assert_uint_eq(fileSize("sizeTest.null"), 743); 2005 // empty file 2006 ck_assert_uint_eq(fileSize("chmodTest.null"), 0); 2007 // non existing file 2008 ck_assert_int_eq(fileSize("qweqwe_null"), -1); 2009 // empty path 2010 ck_assert_int_eq(fileSize(""), -1); 2011 // NULL path 2012 ck_assert_int_eq(fileSize(NULL), -1); 2013 2014 } 2015 2016 2017 void fileSizeFPT(CuTest *tc UNUSED) { 2018 2019 FILE *f; 2020 2021 // existing file 2022 f = fopen("sizeTest.null", "r"); 2023 ck_assert_int_eq(fileSizeFP(f), 743); 2024 fclose(f); 2025 2026 // empty file 2027 f = fopen("chmodTest.null", "r"); 2028 ck_assert_int_eq(fileSizeFP(f), 0); 2029 fclose(f); 2030 2031 // null file 2032 ck_assert_int_eq(fileSizeFP(null), -1); 2033 2034 } 2035 2036 2037 void readFileToST(CuTest *tc UNUSED) { 2038 2039 char *l; 2040 2041 // text 2042 l = readFileToS("textTest.null"); 2043 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2044 free(l); 2045 2046 // empty text 2047 l = readFileToS("chmodTest.null"); 2048 ck_assert_str_eq(l, ""); 2049 free(l); 2050 2051 // write only file 2052 bool r = fileChmod("writeOnlyText.null", S_IWUSR | S_IWGRP | S_IWOTH); 2053 ck_assert(r); 2054 ck_assert_ptr_eq(readFileToS("writeOnlyText.null"), NULL); 2055 2056 // blank path 2057 ck_assert_ptr_eq(readFileToS(""), NULL); 2058 2059 // NULL path 2060 ck_assert_ptr_eq(readFileToS(NULL), NULL); 2061 2062 // non existing path 2063 if (fileExists("nonExistingFile")) { 2064 int R = rmAll("nonExistingFile"); 2065 ck_assert_int_ne(R, 0); 2066 } 2067 ck_assert_ptr_eq(readFileToS("nonExistingFile"), NULL); 2068 2069 } 2070 2071 2072 void readStreamToST(CuTest *tc UNUSED) { 2073 2074 FILE *f; 2075 char *l; 2076 2077 // text 2078 f = fopen("textTest.null", "r"); 2079 l = readStreamToS(f); 2080 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2081 free(l); 2082 fclose(f); 2083 2084 // empty text 2085 f = fopen("chmodTest.null", "r"); 2086 l = readStreamToS(f); 2087 ck_assert_str_eq(l, ""); 2088 free(l); 2089 fclose(f); 2090 2091 // null file 2092 ck_assert_ptr_eq(readStreamToS(null), null); 2093 2094 } 2095 2096 2097 void bReadFileToST(CuTest *tc UNUSED) { 2098 2099 char l[100]; 2100 void *r = null; 2101 2102 // text 2103 r = bReadFileToS("textTest.null", l); 2104 ck_assert_ptr_eq(r, l); 2105 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2106 2107 // empty text 2108 r = bReadFileToS("chmodTest.null", l); 2109 ck_assert_ptr_eq(r, l); 2110 ck_assert_str_eq(l, ""); 2111 2112 // write only file 2113 r = bReadFileToS("writeOnlyText.null", l); 2114 ck_assert_ptr_eq(r, null); 2115 2116 // blank path 2117 r = bReadFileToS("", l); 2118 ck_assert_ptr_eq(r, null); 2119 2120 // NULL path 2121 r = bReadFileToS(NULL, l); 2122 ck_assert_ptr_eq(r, null); 2123 2124 // NULL buffer 2125 r = bReadFileToS("wqe", NULL); 2126 ck_assert_ptr_eq(r, null); 2127 2128 // non existing path 2129 if (fileExists("nonExistingFile")) { 2130 int R = rmAll("nonExistingFile"); 2131 ck_assert_int_ne(R, 0); 2132 } 2133 r = bReadFileToS("nonExistingFile", l); 2134 ck_assert_ptr_eq(r, null); 2135 2136 } 2137 2138 2139 void bReadStreamToST(CuTest *tc UNUSED) { 2140 2141 FILE *f; 2142 char l[1024] = init0Var; 2143 char *r; 2144 2145 // text 2146 f = fopen("textTest.null", "r"); 2147 r = bReadStreamToS(f, l); 2148 ck_assert_str_eq(r, "LINE 1\nANOTHER line\n"); 2149 fclose(f); 2150 2151 // empty text 2152 f = fopen("chmodTest.null", "r"); 2153 r = bReadStreamToS(f, l); 2154 ck_assert_str_eq(r, ""); 2155 fclose(f); 2156 2157 // null dst 2158 ck_assert_ptr_eq(bReadStreamToS(f, null), null); 2159 2160 // null file 2161 ck_assert_ptr_eq(bReadStreamToS(null, l), null); 2162 2163 2164 } 2165 2166 2167 void bLReadFileToST(CuTest *tc UNUSED) { 2168 2169 char l[100]; 2170 void *r = null; 2171 2172 // text 2173 r = bLReadFileToS("textTest.null", l, sizeof l); 2174 ck_assert_ptr_eq(r, l); 2175 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2176 2177 // shorter buffer 2178 r = bLReadFileToS("textTest.null", l, 3); 2179 ck_assert_ptr_eq(r, l); 2180 ck_assert_str_eq(l, "LI"); 2181 2182 // empty text 2183 r = bLReadFileToS("chmodTest.null", l, sizeof l); 2184 ck_assert_ptr_eq(r, l); 2185 ck_assert_str_eq(l, ""); 2186 2187 // size 0 buffer - no change 2188 strcpy(l, "libsheepy"); 2189 r = bLReadFileToS("textTest.null", l, 0); 2190 ck_assert_ptr_eq(r, l); 2191 ck_assert_str_eq(l, "libsheepy"); 2192 2193 // write only file 2194 r = bLReadFileToS("writeOnlyText.null", l, sizeof l); 2195 ck_assert_ptr_eq(r, null); 2196 2197 // blank path 2198 r = bLReadFileToS("", l, sizeof l); 2199 ck_assert_ptr_eq(r, null); 2200 2201 // NULL path 2202 r = bLReadFileToS(NULL, l, sizeof l); 2203 ck_assert_ptr_eq(r, null); 2204 2205 // NULL buffer 2206 r = bLReadFileToS("wqe", NULL, sizeof l); 2207 ck_assert_ptr_eq(r, null); 2208 2209 // non existing path 2210 if (fileExists("nonExistingFile")) { 2211 int R = rmAll("nonExistingFile"); 2212 ck_assert_int_ne(R, 0); 2213 } 2214 r = bLReadFileToS("nonExistingFile", l, sizeof l); 2215 ck_assert_ptr_eq(r, null); 2216 2217 } 2218 2219 2220 void bLReadStreamToST(CuTest *tc UNUSED) { 2221 2222 FILE *f; 2223 char l[1024] = init0Var; 2224 char *r; 2225 2226 // text 2227 f = fopen("textTest.null", "r"); 2228 r = bLReadStreamToS(f, l, sizeof(l)); 2229 ck_assert_str_eq(r, "LINE 1\nANOTHER line\n"); 2230 fclose(f); 2231 2232 // shorter buffer 2233 l[0] = 'a'; 2234 l[1] = 'a'; 2235 f = fopen("textTest.null", "r"); 2236 r = bLReadStreamToS(f, l, 2); 2237 ck_assert_str_eq(r, "L"); 2238 fclose(f); 2239 2240 // empty text 2241 f = fopen("chmodTest.null", "r"); 2242 r = bLReadStreamToS(f, l, sizeof(l)); 2243 ck_assert_str_eq(r, ""); 2244 fclose(f); 2245 2246 // dst size 0, no changes 2247 r = bLReadStreamToS(f, l, 0); 2248 ck_assert_str_eq(r, ""); 2249 2250 // null dst 2251 ck_assert_ptr_eq(bLReadStreamToS(f, null, sizeof(l)), null); 2252 2253 // null file 2254 ck_assert_ptr_eq(bLReadStreamToS(null, l, sizeof(l)), null); 2255 2256 } 2257 2258 2259 void readFileT(CuTest *tc UNUSED) { 2260 2261 char *l; 2262 ssize_t sz; 2263 2264 // text 2265 sz = readFile("textTest.null", (void **) &l); 2266 l[19] = 0; 2267 ck_assert_str_eq(l, "LINE 1\nANOTHER line"); 2268 ck_assert_int_eq(sz, 20); 2269 free(l); 2270 2271 // empty text 2272 // allocated 0 bytes 2273 sz = readFile("chmodTest.null", (void **) &l); 2274 ck_assert_ptr_ne(l, NULL); 2275 ck_assert_int_eq(sz, 0); 2276 free(l); 2277 2278 // write only file 2279 bool r = fileChmod("writeOnlyText.null", S_IWUSR | S_IWGRP | S_IWOTH); 2280 ck_assert(r); 2281 ck_assert_int_eq(readFile("writeOnlyText.null", (void **) &l), -1); 2282 2283 // blank path 2284 ck_assert_int_eq(readFile("", (void **) &l), -1); 2285 2286 // NULL buffer 2287 ck_assert_int_eq(readFile("lib", NULL), -1); 2288 2289 // NULL path 2290 ck_assert_int_eq(readFile(NULL, (void **) &l), -1); 2291 2292 // non existing path 2293 if (fileExists("nonExistingFile")) { 2294 int R = rmAll("nonExistingFile"); 2295 ck_assert_int_ne(R, 0); 2296 } 2297 ck_assert_int_eq(readFile("nonExistingFile", (void **) &l), -1); 2298 2299 } 2300 2301 2302 void bReadFileT(CuTest *tc UNUSED) { 2303 2304 char l[100]; 2305 ssize_t sz; 2306 2307 // text 2308 sz = bReadFile("textTest.null", l); 2309 l[19] = 0; 2310 ck_assert_str_eq(l, "LINE 1\nANOTHER line"); 2311 ck_assert_int_eq(sz, 20); 2312 2313 // empty text 2314 sz = bReadFile("chmodTest.null", l); 2315 ck_assert_str_eq(l, "LINE 1\nANOTHER line"); 2316 ck_assert_int_eq(sz, 0); 2317 2318 // write only file 2319 ck_assert_int_eq(bReadFile("writeOnlyText.null", l), -1); 2320 2321 // blank path 2322 ck_assert_int_eq(bReadFile("", l), -1); 2323 2324 // NULL buffer 2325 ck_assert_int_eq(bReadFile("lib", NULL), -1); 2326 2327 // NULL path 2328 ck_assert_int_eq(bReadFile(NULL, l), -1); 2329 2330 // non existing path 2331 if (fileExists("nonExistingFile")) { 2332 int R = rmAll("nonExistingFile"); 2333 ck_assert_int_ne(R, 0); 2334 } 2335 ck_assert_int_eq(bReadFile("nonExistingFile", l), -1); 2336 2337 } 2338 2339 2340 void bLReadFileT(CuTest *tc UNUSED) { 2341 2342 char l[100]; 2343 ssize_t sz; 2344 2345 // text 2346 sz = bLReadFile("textTest.null", l, sizeof l); 2347 l[19] = 0; 2348 ck_assert_str_eq(l, "LINE 1\nANOTHER line"); 2349 ck_assert_int_eq(sz, 20); 2350 2351 // shorter buffer 2352 l[0] = 'a'; 2353 l[1] = 'a'; 2354 sz = bLReadFile("textTest.null", l, 1); 2355 ck_assert_str_eq(l, "LaNE 1\nANOTHER line"); 2356 ck_assert_int_eq(sz, 1); 2357 2358 // empty text - l not changed 2359 sz = bLReadFile("chmodTest.null", l, sizeof l); 2360 ck_assert_str_eq(l, "LaNE 1\nANOTHER line"); 2361 ck_assert_int_eq(sz, 0); 2362 2363 // size 0 - l not changed 2364 sz = bLReadFile("chmodTest.null", l, 0); 2365 ck_assert_str_eq(l, "LaNE 1\nANOTHER line"); 2366 ck_assert_int_eq(sz, 0); 2367 2368 // write only file 2369 ck_assert_int_eq(bLReadFile("writeOnlyText.null", l, sizeof l), -1); 2370 2371 // blank path 2372 ck_assert_int_eq(bLReadFile("", l, sizeof l), -1); 2373 2374 // NULL buffer 2375 ck_assert_int_eq(bLReadFile("lib", NULL, sizeof l), -1); 2376 2377 // NULL path 2378 ck_assert_int_eq(bLReadFile(NULL, l, sizeof l), -1); 2379 2380 // non existing path 2381 if (fileExists("nonExistingFile")) { 2382 int R = rmAll("nonExistingFile"); 2383 ck_assert_int_ne(R, 0); 2384 } 2385 ck_assert_int_eq(bLReadFile("nonExistingFile", l, sizeof l), -1); 2386 2387 } 2388 2389 2390 void writeFileST(CuTest *tc UNUSED) { 2391 2392 char *l; 2393 int r; 2394 2395 // write textOutTest.null 2396 l = readFileToS("textTest.null"); 2397 r = writeFileS("textOutTest.null", l); 2398 ck_assert(r); 2399 free(l); 2400 2401 // check textOutTest.null 2402 l = readFileToS("textOutTest.null"); 2403 ck_assert_uint_eq(strlen(l),20); 2404 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2405 // non existing file 2406 // make sure the file doesnt exist 2407 if (fileExists("nonExistingFile")) { 2408 int R = rmAll("nonExistingFile"); 2409 ck_assert_int_ne(R, 0); 2410 } 2411 ck_assert(writeFileS("nonExistingFile",l)); 2412 if (fileExists("nonExistingFile")) { 2413 int R = rmAll("nonExistingFile"); 2414 ck_assert_int_ne(R, 0); 2415 } 2416 // blank file name 2417 ck_assert(!writeFileS(" ",l)); 2418 // read only path 2419 ck_assert(!writeFileS("/nonExistingFile",l)); 2420 // NULL path 2421 ck_assert(!writeFileS(NULL,l)); 2422 free(l); 2423 // NULL string 2424 ck_assert(!writeFileS("a",NULL)); 2425 2426 } 2427 2428 2429 void writeFileT(CuTest *tc UNUSED) { 2430 2431 char *l; 2432 int r; 2433 2434 // write textOutTest.null 2435 l = readFileToS("textTest.null"); 2436 r = writeFile("textOutTest.null", l, strlen(l)+1); 2437 ck_assert(r); 2438 free(l); 2439 2440 // check textOutTest.null 2441 l = readFileToS("textOutTest.null"); 2442 ck_assert_uint_eq(strlen(l),20); 2443 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2444 // non existing file 2445 // make sure the file doesnt exist 2446 if (fileExists("nonExistingFile")) { 2447 int R = rmAll("nonExistingFile"); 2448 ck_assert_int_ne(R, 0); 2449 } 2450 ck_assert(writeFile("nonExistingFile",l, strlen(l)+1)); 2451 // 0 length 2452 ck_assert(writeFile("nonExistingFile", l, 0)); 2453 if (fileExists("nonExistingFile")) { 2454 int R = rmAll("nonExistingFile"); 2455 ck_assert_int_ne(R, 0); 2456 } 2457 // blank file name 2458 ck_assert(!writeFile(" ",l, 1)); 2459 // read only path 2460 ck_assert(!writeFile("/nonExistingFile",l, 1)); 2461 // NULL path 2462 ck_assert(!writeFile(NULL,l, 1)); 2463 free(l); 2464 // NULL buffer 2465 ck_assert(!writeFile("a",NULL, 1)); 2466 2467 } 2468 2469 2470 void writeStreamST(CuTest *tc UNUSED) { 2471 2472 char *l; 2473 int r; 2474 FILE *f; 2475 2476 // write textOutTest.null 2477 l = readFileToS("textTest.null"); 2478 f = fopen("textOutTest.null", "w"); 2479 r = writeStreamS(f, l); 2480 ck_assert(r); 2481 free(l); 2482 fclose(f); 2483 2484 // check textOutTest.null 2485 l = readFileToS("textOutTest.null"); 2486 ck_assert_uint_eq(strlen(l),20); 2487 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2488 2489 // NULL file 2490 ck_assert(!writeStreamS(NULL,l)); 2491 free(l); 2492 // NULL string 2493 ck_assert(!writeStreamS(f,NULL)); 2494 2495 2496 } 2497 2498 2499 void writeLStreamT(CuTest *tc UNUSED) { 2500 2501 char *l; 2502 int r; 2503 FILE *f; 2504 2505 // write textOutTest.null 2506 l = readFileToS("textTest.null"); 2507 f = fopen("textOutTest.null", "w"); 2508 r = writeLStream(f, l, strlen(l)); 2509 ck_assert(r); 2510 free(l); 2511 fclose(f); 2512 2513 // check textOutTest.null 2514 l = readFileToS("textOutTest.null"); 2515 ck_assert_uint_eq(strlen(l),20); 2516 ck_assert_str_eq(l, "LINE 1\nANOTHER line\n"); 2517 2518 // NULL file 2519 ck_assert(!writeLStream(NULL,l, strlen(l))); 2520 free(l); 2521 // NULL string 2522 ck_assert(!writeLStream(f,NULL, 10)); 2523 2524 2525 } 2526 2527 2528 void appendFileST(CuTest *tc UNUSED) { 2529 2530 char *l; 2531 int r; 2532 2533 // write textOutTest.null 2534 l = "appended line\n"; 2535 r = appendFileS("appendTextOutTest.null", l); 2536 ck_assert(r); 2537 l = "appended line 2\n"; 2538 r = appendFileS("appendTextOutTest.null", l); 2539 ck_assert(r); 2540 2541 // check textOutTest.null 2542 l = readFileToS("appendTextOutTest.null"); 2543 ck_assert_uint_eq(strlen(l),30); 2544 ck_assert_str_eq(l, "appended line\nappended line 2\n"); 2545 if (fileExists("appendTextOutTest.null")) { 2546 int R = rmAll("appendTextOutTest.null"); 2547 ck_assert_int_ne(R, 0); 2548 } 2549 // blank file name 2550 ck_assert(!appendFileS(" ",l)); 2551 // read only path 2552 ck_assert(!appendFileS("/nonExistingFile",l)); 2553 // NULL path 2554 ck_assert(!appendFileS(NULL,l)); 2555 free(l); 2556 // NULL string 2557 ck_assert(!appendFileS("a",NULL)); 2558 2559 2560 } 2561 2562 2563 void appendFileT(CuTest *tc UNUSED) { 2564 2565 char *l; 2566 int r; 2567 2568 // write textOutTest.null 2569 l = "appended line\n"; 2570 r = appendFile("appendTextOutTest.null", l, strlen(l)); 2571 ck_assert(r); 2572 l = "appended line 2\n"; 2573 r = appendFile("appendTextOutTest.null", l, strlen(l)); 2574 ck_assert(r); 2575 2576 // check textOutTest.null 2577 l = readFileToS("appendTextOutTest.null"); 2578 ck_assert_uint_eq(strlen(l),30); 2579 ck_assert_str_eq(l, "appended line\nappended line 2\n"); 2580 if (fileExists("appendTextOutTest.null")) { 2581 int R = rmAll("appendTextOutTest.null"); 2582 ck_assert_int_ne(R, 0); 2583 } 2584 // blank file name 2585 ck_assert(!appendFile(" ",l, strlen(l))); 2586 // read only path 2587 ck_assert(!appendFile("/nonExistingFile",l, strlen(l))); 2588 // NULL path 2589 ck_assert(!appendFile(NULL,l, strlen(l))); 2590 free(l); 2591 // NULL string 2592 ck_assert(!appendFile("a",NULL, 0)); 2593 2594 2595 } 2596 2597 2598 void walkDirT(CuTest *tc UNUSED) { 2599 2600 char **l; 2601 2602 // existing directory 2603 l = walkDir("dirTest.null"); 2604 ck_assert_uint_eq(listLengthS(l),3); 2605 ck_assert_str_eq(l[0], "dirTest.null/one"); 2606 ck_assert_str_eq(l[1], "dirTest.null/two/four"); 2607 ck_assert_str_eq(l[2], "dirTest.null/two/three"); 2608 listFreeS(l); 2609 // empty path 2610 ck_assert_ptr_eq(walkDir(""), NULL); 2611 // non existing directory 2612 l = walkDir("nonExisting.null"); 2613 ck_assert(listIsEmptyS(l)); 2614 listFreeS(l); 2615 // NULL path 2616 ck_assert_ptr_eq(walkDir(NULL), NULL); 2617 2618 } 2619 2620 2621 void walkDirDirT(CuTest *tc UNUSED) { 2622 2623 char **l; 2624 2625 // existing directory 2626 l = walkDirDir("dirTest.null"); 2627 ck_assert_uint_eq(listLengthS(l),2); 2628 ck_assert_str_eq(l[0], "dirTest.null/symlinkLoop"); 2629 ck_assert_str_eq(l[1], "dirTest.null/two"); 2630 listFreeS(l); 2631 // empty path 2632 ck_assert_ptr_eq(walkDirDir(""), NULL); 2633 // non existing directory 2634 l = walkDirDir("nonExisting.null"); 2635 ck_assert(listIsEmptyS(l)); 2636 listFreeS(l); 2637 // NULL path 2638 ck_assert_ptr_eq(walkDirDir(NULL), NULL); 2639 2640 } 2641 2642 2643 void readDirT(CuTest *tc UNUSED) { 2644 2645 char **l; 2646 2647 // existing directory 2648 l = readDir("dirTest.null"); 2649 ck_assert_uint_eq(listLengthS(l),1); 2650 ck_assert_str_eq(l[0], "one"); 2651 listFreeS(l); 2652 // empty path 2653 ck_assert_ptr_eq(readDir(""), NULL); 2654 // non existing directory 2655 l = readDir("nonExisting.null"); 2656 ck_assert(listIsEmptyS(l)); 2657 listFreeS(l); 2658 // NULL path 2659 ck_assert_ptr_eq(readDir(NULL), NULL); 2660 2661 } 2662 2663 2664 void readDirDirT(CuTest *tc UNUSED) { 2665 2666 char **l; 2667 2668 // existing directory 2669 l = readDirDir("dirTest.null"); 2670 ck_assert_uint_eq(listLengthS(l),2); 2671 ck_assert_str_eq(l[0], "symlinkLoop"); 2672 ck_assert_str_eq(l[1], "two"); 2673 listFreeS(l); 2674 // empty path 2675 ck_assert_ptr_eq(readDirDir(""), NULL); 2676 // non existing directory 2677 l = readDirDir("nonExisting.null"); 2678 ck_assert(listIsEmptyS(l)); 2679 listFreeS(l); 2680 // NULL path 2681 ck_assert_ptr_eq(readDirDir(NULL), NULL); 2682 2683 } 2684 2685 2686 void walkDirAllT(CuTest *tc UNUSED) { 2687 2688 char **l; 2689 2690 // existing directory 2691 l = walkDirAll("dirTest.null"); 2692 ck_assert_uint_eq(listLengthS(l),5); 2693 ck_assert_str_eq(l[0], "dirTest.null/one"); 2694 ck_assert_str_eq(l[1], "dirTest.null/symlinkLoop"); 2695 ck_assert_str_eq(l[2], "dirTest.null/two"); 2696 ck_assert_str_eq(l[3], "dirTest.null/two/four"); 2697 ck_assert_str_eq(l[4], "dirTest.null/two/three"); 2698 listFreeS(l); 2699 // empty path 2700 ck_assert_ptr_eq(walkDirAll(""), NULL); 2701 // non existing directory 2702 l = walkDirAll("nonExisting.null"); 2703 ck_assert(listIsEmptyS(l)); 2704 listFreeS(l); 2705 // NULL path 2706 ck_assert_ptr_eq(walkDirAll(NULL), NULL); 2707 2708 } 2709 2710 2711 void readDirAllT(CuTest *tc UNUSED) { 2712 2713 char **l; 2714 2715 // existing directory 2716 l = readDirAll("dirTest.null"); 2717 ck_assert_uint_eq(listLengthS(l),3); 2718 ck_assert_str_eq(l[0], "one"); 2719 ck_assert_str_eq(l[1], "symlinkLoop"); 2720 ck_assert_str_eq(l[2], "two"); 2721 listFreeS(l); 2722 // empty path 2723 ck_assert_ptr_eq(readDirAll(""), NULL); 2724 // non existing directory 2725 l = readDirAll("nonExisting.null"); 2726 ck_assert(listIsEmptyS(l)); 2727 listFreeS(l); 2728 // NULL path 2729 ck_assert_ptr_eq(readDirAll(NULL), NULL); 2730 2731 } 2732 2733 2734 void mkdirParentsT(CuTest *tc UNUSED) { 2735 2736 // directory 2737 int R = rmAll("mkdirTest.null/null"); 2738 ck_assert_int_ne(R, 0); 2739 ck_assert_int_eq(mkdirParents("mkdirTest.null/null"),1); 2740 ck_assert_int_eq(mkdirParents("mkdirTest.null/null/"),1); 2741 // not allowed 2742 ck_assert_int_eq(mkdirParents("/usr/null"),0); 2743 ck_assert_int_eq(mkdirParents("/usr/null/null"),0); 2744 // empty path 2745 ck_assert_int_eq(mkdirParents(""),0); 2746 // NULL path 2747 ck_assert_int_eq(mkdirParents(NULL),0); 2748 2749 } 2750 2751 2752 void rmAllT(CuTest *tc UNUSED) { 2753 2754 // directory 2755 int r = mkdirParents("rmAllTest.null/null"); 2756 ck_assert_int_ne(r, 0); 2757 ck_assert_int_eq(rmAll("rmAllTest.null"),1); 2758 // empty path 2759 ck_assert_int_eq(rmAll(""),0); 2760 // too little permissions 2761 ck_assert_int_eq(rmAll("/var/lock"),0); 2762 // NULL path 2763 ck_assert_int_eq(rmAll(NULL),0); 2764 2765 } 2766 2767 2768 void copyT(CuTest *tc UNUSED) { 2769 2770 // file 2771 int R = rmAll("copyTest.null"); 2772 printf("%d\n",R); 2773 R = rmAll("copy2Test.null"); 2774 printf("%d\n",R); 2775 ck_assert_int_eq(copy("chmodTest.null", "copyTest.null"),1); 2776 ck_assert(fileExists("copyTest.null")); 2777 // too little permissions 2778 bool r = fileChmod("copyTest.null", 0); 2779 ck_assert(r); 2780 ck_assert_int_eq(copy("copyTest.null", "copy2Test.null"),0); 2781 r = fileChmod("copyTest.null", S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH); 2782 ck_assert(r); 2783 R = rmAll("copyTest.null"); 2784 ck_assert_int_ne(R, 0); 2785 // give dir another name 2786 ck_assert_int_eq(copy("dirTest.null", "copyTest.null"),1); 2787 // copy dir to non existing dir 2788 ck_assert_int_eq(copy("dirTest.null", "copyTest.null/we/"),1); 2789 // copy file to dir (wrong final slash in dst missing) 2790 ck_assert_int_eq(copy("chmodTest.null", "copyTest.null"),0); 2791 // copy file to dir (with final slash in dst) 2792 ck_assert_int_eq(copy("chmodTest.null", "copyTest.null/"),1); 2793 // copy content of source dir to new dst 2794 ck_assert_int_eq(copy("dirTest.null/", "copyTest.null/content"),1); 2795 char **l = walkDirAll("copyTest.null"); 2796 // copy results 2797 ck_assert_int_eq(listLengthS(l), 17); 2798 ck_assert_str_eq(l[0], "copyTest.null/chmodTest.null"); 2799 ck_assert_str_eq(l[1], "copyTest.null/content"); 2800 ck_assert_str_eq(l[2], "copyTest.null/content/one"); 2801 ck_assert_str_eq(l[3], "copyTest.null/content/two"); 2802 ck_assert_str_eq(l[4], "copyTest.null/content/two/four"); 2803 ck_assert_str_eq(l[5], "copyTest.null/content/two/three"); 2804 ck_assert_str_eq(l[6], "copyTest.null/dirTest.null"); 2805 ck_assert_str_eq(l[7], "copyTest.null/dirTest.null/one"); 2806 ck_assert_str_eq(l[8], "copyTest.null/dirTest.null/two"); 2807 ck_assert_str_eq(l[9], "copyTest.null/dirTest.null/two/four"); 2808 ck_assert_str_eq(l[10], "copyTest.null/dirTest.null/two/three"); 2809 ck_assert_str_eq(l[11], "copyTest.null/we"); 2810 ck_assert_str_eq(l[12], "copyTest.null/we/dirTest.null"); 2811 ck_assert_str_eq(l[13], "copyTest.null/we/dirTest.null/one"); 2812 ck_assert_str_eq(l[14], "copyTest.null/we/dirTest.null/two"); 2813 ck_assert_str_eq(l[15], "copyTest.null/we/dirTest.null/two/four"); 2814 ck_assert_str_eq(l[16], "copyTest.null/we/dirTest.null/two/three"); 2815 listFreeS(l); 2816 R = rmAll("copyTest.null"); 2817 ck_assert_int_ne(R, 0); 2818 // copy dir to read only destination, no mkdir 2819 ck_assert_int_eq(copy("mkdirTest.null/", "/newdir"),0); 2820 // copy dir to read only destination, new dir 2821 ck_assert_int_eq(copy("mkdirTest.null", "/newdir"),0); 2822 // non existing source 2823 ck_assert_int_eq(copy("nonExistingFile", "copyTest.null"),0); 2824 // empty path 2825 ck_assert_int_eq(copy("", "copyTest.null"),0); 2826 ck_assert(!fileExists("copyTest.null")); 2827 ck_assert_int_eq(copy("chmodTest.null", ""),0); 2828 ck_assert(!fileExists("copyTest.null")); 2829 // NULL path 2830 ck_assert_int_eq(copy(NULL, "copyTest.null"),0); 2831 ck_assert_int_eq(copy("chmodTest.null", NULL),0); 2832 ck_assert_int_eq(copy(NULL, NULL),0); 2833 2834 } 2835 2836 2837 void shRenameT(CuTest *tc UNUSED) { 2838 2839 // regualar file 2840 ck_assert_int_eq(shRename("renameTest.null", "rename2Test.null"), 1); 2841 ck_assert_int_eq(shRename("rename2Test.null", "renameTest.null"), 1); 2842 // dir 2843 ck_assert_int_eq(shRename("mkdirTest.null", "rename2Test.null"), 1); 2844 ck_assert_int_eq(shRename("rename2Test.null", "mkdirTest.null"), 1); 2845 // non existing source 2846 ck_assert_int_eq(shRename("rename2Test.null", "renameTest.null"), 0); 2847 // already existing destination 2848 ck_assert_int_eq(shRename("mkdirTest.null", "renameTest.null"), 0); 2849 // blank paths 2850 ck_assert_int_eq(shRename(" ", "renameTest.null"), 0); 2851 ck_assert_int_eq(shRename("qwe", ""), 0); 2852 // NULL 2853 ck_assert_int_eq(shRename(NULL, "renameTest.null"), 0); 2854 ck_assert_int_eq(shRename("mkdirTest.null", NULL), 0); 2855 2856 } 2857 2858 2859 void shMoveT(CuTest *tc UNUSED) { 2860 2861 // regualar file 2862 ck_assert_int_eq(shMove("renameTest.null", "rename2Test.null"), 1); 2863 ck_assert_int_eq(shMove("rename2Test.null", "renameTest.null"), 1); 2864 // dir 2865 ck_assert_int_eq(shMove("mkdirTest.null", "rename2Test.null"), 1); 2866 ck_assert_int_eq(shMove("rename2Test.null/mkdirTest.null", "."), 1); 2867 int R = rmAll("rename2Test.null"); 2868 ck_assert_int_ne(R, 0); 2869 // non existing source 2870 ck_assert_int_eq(shMove("rename2Test.null", "renameTest.null"), 0); 2871 // already existing destination 2872 ck_assert_int_eq(shMove("mkdirTest.null", "renameTest.null"), 0); 2873 // blank paths 2874 ck_assert_int_eq(shMove(" ", "renameTest.null"), 0); 2875 ck_assert_int_eq(shMove("qwe", ""), 0); 2876 // NULL 2877 ck_assert_int_eq(shMove(NULL, "renameTest.null"), 0); 2878 ck_assert_int_eq(shMove("mkdirTest.null", NULL), 0); 2879 2880 } 2881 2882 2883 void setSoftwareRandomT(CuTest *tc UNUSED) { 2884 2885 // open /dev/urandom 2886 setSoftwareRandom(); 2887 randomUrandomClose(); 2888 2889 } 2890 2891 2892 void setHardwareRandomT(CuTest *tc UNUSED) { 2893 2894 // open /dev/urandom 2895 setHardwareRandom(); 2896 setSoftwareRandom(); 2897 randomUrandomClose(); 2898 2899 } 2900 2901 2902 void randomOpenCloseT(CuTest *tc UNUSED) { 2903 2904 int r; 2905 2906 // open /dev/urandom 2907 r = randomUrandomOpen(); 2908 ck_assert_int_eq(r,1); 2909 randomUrandomClose(); 2910 2911 } 2912 2913 2914 void randomWordT(CuTest *tc UNUSED) { 2915 2916 // get random value 2917 int r = randomUrandomOpen(); 2918 ck_assert_int_eq(r,1); 2919 ck_assert_int_ne(randomWord(),0); 2920 randomUrandomClose(); 2921 // error when /dev/urandom is closed 2922 ck_assert_int_eq(randomWord(),0); 2923 2924 } 2925 2926 2927 void randomWordFromHWT(CuTest *tc UNUSED) { 2928 2929 // get random value 2930 setHardwareRandom(); 2931 uint64_t r = randomWordFromHW(); 2932 printf("%"PRIu64"\n", r); 2933 2934 // string 2935 char *s = randomS(10); 2936 ck_assert_ptr_ne(s, NULL); 2937 free(s); 2938 setSoftwareRandom(); 2939 randomUrandomClose(); 2940 2941 } 2942 2943 2944 void randomChoiceT(CuTest *tc UNUSED) { 2945 2946 // get random value 2947 int r = randomUrandomOpen(); 2948 ck_assert_int_eq(r,1); 2949 ck_assert_int_ne(randomChoice(10),10); 2950 // invalid range (0) 2951 ck_assert_int_eq(randomChoice(0),0); 2952 randomUrandomClose(); 2953 // error when /dev/urandom is closed 2954 ck_assert_int_eq(randomChoice(10),10); 2955 2956 } 2957 2958 2959 void randomST(CuTest *tc UNUSED) { 2960 2961 // get random string 2962 char *s = randomS(10); 2963 ck_assert_ptr_ne(s, NULL); 2964 free(s); 2965 // invalid length (0) 2966 ck_assert_ptr_eq(randomS(0), NULL); 2967 2968 } 2969 2970 2971 void bRandomST(CuTest *tc UNUSED) { 2972 2973 char s[11]; 2974 char *r; 2975 // get random string 2976 r = bRandomS(s, 10); 2977 ck_assert_ptr_ne(r, NULL); 2978 // invalid length (0) 2979 ck_assert_ptr_eq(bRandomS(s, 0), NULL); 2980 // NULL 2981 ck_assert_ptr_eq(bRandomS(NULL, 10), NULL); 2982 2983 } 2984 2985 2986 void randomAlphaNumST(CuTest *tc UNUSED) { 2987 2988 // get random string 2989 char *s = randomAlphaNumS(10); 2990 ck_assert_ptr_ne(s, NULL); 2991 free(s); 2992 // invalid length (0) 2993 ck_assert_ptr_eq(randomAlphaNumS(0), NULL); 2994 2995 } 2996 2997 2998 void bRandomAlphaNumST(CuTest *tc UNUSED) { 2999 3000 char s[11]; 3001 char *r; 3002 // get random string 3003 r = bRandomAlphaNumS(s, 10); 3004 ck_assert_ptr_ne(r, NULL); 3005 // invalid length (0) 3006 ck_assert_ptr_eq(bRandomAlphaNumS(s, 0), NULL); 3007 // NULL 3008 ck_assert_ptr_eq(bRandomAlphaNumS(NULL, 10), NULL); 3009 3010 } 3011 3012 3013 void readST(CuTest *tc UNUSED) { 3014 3015 char *s = readS(); 3016 ck_assert_str_eq(s, "aaaaaaaaaaaaaaaaaaaa"); 3017 free(s); 3018 3019 } 3020 3021 3022 void bLReadST(CuTest *tc UNUSED) { 3023 3024 char s[21]; 3025 char *r = null; 3026 3027 r = bLReadS(s, 21); 3028 ck_assert_ptr_eq(r, s); 3029 ck_assert_str_eq(s, "aaaaaaaaaaaaaaaaaaaa"); 3030 // size 1 3031 r = bLReadS(s, 1); 3032 ck_assert_ptr_eq(r, null); 3033 // NULL 3034 r = bLReadS(NULL, 2); 3035 ck_assert_ptr_eq(r, null); 3036 3037 } 3038 3039 3040 void readPasswordST(CuTest *tc UNUSED) { 3041 3042 char *r = readPasswordS(); 3043 ck_assert_str_eq(r, "*****"); 3044 free(r); 3045 3046 } 3047 3048 3049 void zeroST(CuTest *tc UNUSED) { 3050 3051 bool r; 3052 3053 // clear string 3054 char *s = strdup("zero"); 3055 r = zeroS(s); 3056 ck_assert_str_eq(s, ""); 3057 ck_assert(r); 3058 free(s); 3059 3060 // null string 3061 r = zeroS(null); 3062 ck_assert(!r); 3063 3064 } 3065 3066 3067 void zeroBufT(CuTest *tc UNUSED) { 3068 3069 bool r; 3070 3071 // clear string 3072 char *s = strdup("zero"); 3073 r = zeroBuf(s, strlen(s)); 3074 ck_assert_str_eq(s, ""); 3075 ck_assert(r); 3076 free(s); 3077 3078 // 0 length 3079 r = zeroBuf(s, 0); 3080 ck_assert(!r); 3081 3082 // null string 3083 r = zeroBuf(null, 1); 3084 ck_assert(!r); 3085 3086 } 3087 3088 3089 void memdupT(CuTest *tc UNUSED) { 3090 3091 char *r; 3092 3093 // clear string 3094 r = memdup("memdup", sizeof("memdup")); 3095 ck_assert_str_eq(r, "memdup"); 3096 free(r); 3097 3098 // 0 length 3099 r = memdup("wef", 0); 3100 ck_assert_ptr_eq(r, null); 3101 3102 // null string 3103 r = memdup(null, 1); 3104 ck_assert_ptr_eq(r, null); 3105 3106 } 3107 3108 3109 void readEnterT(CuTest *tc UNUSED) { 3110 3111 readEnter(); 3112 3113 } 3114 3115 3116 void readLineT(CuTest *tc UNUSED) { 3117 3118 FILE *fp; 3119 char *s; 3120 3121 // file with data 3122 fp = fopen("textTest.null", "r"); 3123 s = readLine(fp); 3124 fclose(fp); 3125 ck_assert_str_eq(s, "LINE 1"); 3126 free(s); 3127 // empty file or end of stream 3128 fp = fopen("chmodTest.null", "r"); 3129 s = readLine(fp); 3130 ck_assert_ptr_ne(s, NULL); 3131 ck_assert(isEmptyS(s)); 3132 free(s); 3133 fclose(fp); 3134 // NULL stream 3135 ck_assert_ptr_eq(readLine(NULL), NULL); 3136 3137 3138 } 3139 3140 3141 void dupST(CuTest *tc UNUSED) { 3142 3143 // string 3144 char *s = dupS("sheepy"); 3145 ck_assert_str_eq(s, "sheepy"); 3146 free(s); 3147 // NULL string 3148 ck_assert_ptr_eq(dupS(NULL), NULL); 3149 3150 } 3151 3152 3153 void shPrintfST(CuTest *tc UNUSED) { 3154 3155 shPrintfS("\nWEE %d\n", 234); 3156 shPrintfS(NULL); 3157 3158 } 3159 3160 3161 void shEprintfT(CuTest *tc UNUSED) { 3162 3163 shEPrintfS("\nWEE %d\n", 234); 3164 shEPrintfS(NULL); 3165 3166 } 3167 3168 void freeManyST(CuTest *tc UNUSED) { 3169 3170 // not possible to know if a pointer is already freed 3171 char *s1 = emptySF(); 3172 char *s2 = emptySF(); 3173 freeManyS(s1, s2); 3174 3175 } 3176 3177 3178 void logNFreeT(CuTest *tc UNUSED) { 3179 3180 char *s = strdup("libsheepy"); 3181 logNFree(s); 3182 logNFree(NULL); 3183 3184 } 3185 3186 3187 void loghexT(CuTest *tc UNUSED) { 3188 3189 char *b = "abc"; 3190 3191 // print hex 3192 loghex(b, strlen(b)+1); 3193 3194 // size zero 3195 loghex(b, 0); 3196 3197 // null buf 3198 loghex(null, 1); 3199 3200 } 3201 3202 3203 void toHexST(CuTest *tc UNUSED) { 3204 3205 char *b = "abc"; 3206 char *r; 3207 3208 // print hex 3209 r = toHexS(b, strlen(b)+1); 3210 ck_assert_str_eq(r, "0x61, 0x62, 0x63, 0x00"); 3211 free(r); 3212 3213 // size zero 3214 r = toHexS(b, 0); 3215 ck_assert_ptr_eq(r, null); 3216 3217 // null buf 3218 r = toHexS(null, 1); 3219 ck_assert_ptr_eq(r, null); 3220 3221 3222 } 3223 3224 3225 void toHexSepST(CuTest *tc UNUSED) { 3226 3227 char *b = "abc"; 3228 char *r; 3229 3230 // print hex 3231 r = toHexSepS(b, strlen(b)+1, ","); 3232 ck_assert_str_eq(r, "0x61,0x62,0x63,0x00"); 3233 free(r); 3234 3235 // size zero 3236 r = toHexSepS(b, 0, ""); 3237 ck_assert_ptr_eq(r, null); 3238 3239 // null sep 3240 r = toHexSepS(b, 1, null); 3241 ck_assert_ptr_eq(r, null); 3242 3243 // null buf 3244 r = toHexSepS(null, 1, ""); 3245 ck_assert_ptr_eq(r, null); 3246 3247 } 3248 3249 3250 void toHexHeadSepST(CuTest *tc UNUSED) { 3251 3252 char *b = "abc"; 3253 char *r; 3254 3255 // print hex 3256 r = toHexHeadSepS(b, strlen(b)+1, "x", ","); 3257 ck_assert_str_eq(r, "x61,x62,x63,x00"); 3258 free(r); 3259 3260 // size zero 3261 r = toHexHeadSepS(b, 0, "", ""); 3262 ck_assert_ptr_eq(r, null); 3263 3264 // null head 3265 r = toHexHeadSepS(b, 1, null, ""); 3266 ck_assert_ptr_eq(r, null); 3267 3268 // null sep 3269 r = toHexHeadSepS(b, 1, "", null); 3270 ck_assert_ptr_eq(r, null); 3271 3272 // null buf 3273 r = toHexHeadSepS(null, 1, "", ""); 3274 ck_assert_ptr_eq(r, null); 3275 3276 } 3277 3278 3279 void strCpyT(CuTest *tc UNUSED) { 3280 3281 char s[1024] = init0Var; 3282 char *r; 3283 3284 // copy string 3285 r = strCpy(s, "lib"); 3286 ck_assert_ptr_eq(r, s); 3287 ck_assert_str_eq(s, "lib"); 3288 // NULL 3289 s[0] = 0; 3290 r = strCpy(s, NULL); 3291 ck_assert_ptr_eq(r, null); 3292 ck_assert_str_eq(s, ""); 3293 r = strCpy(NULL, "lib"); 3294 ck_assert_ptr_eq(r, null); 3295 3296 } 3297 3298 3299 void strNCpyT(CuTest *tc UNUSED) { 3300 3301 char s[1024] = init0Var; 3302 char *r; 3303 3304 // copy string 3305 r = strNCpy(s, "lib", 4); 3306 ck_assert_ptr_ne(r, null); 3307 ck_assert_str_eq(s, "lib"); 3308 3309 // size 0 3310 r = strNCpy(s, "AAA", 0); 3311 ck_assert_ptr_ne(r, null); 3312 ck_assert_str_eq(s, "lib"); 3313 3314 // NULL 3315 s[0] = 0; 3316 r = strNCpy(s, NULL, 10); 3317 ck_assert_ptr_eq(r, null); 3318 ck_assert_str_eq(s, ""); 3319 ck_assert_ptr_eq(strNCpy(NULL, "lib", 1), NULL); 3320 3321 } 3322 3323 3324 void strLCpyT(CuTest *tc UNUSED) { 3325 3326 char s[1024]; 3327 char *r = null; 3328 3329 // copy string 3330 r = strLCpy(s, 100, "lib"); 3331 ck_assert_ptr_eq(r, s); 3332 ck_assert_str_eq(s, "lib"); 3333 // truncate src 3334 s[0] = 0; 3335 s[1] = 0; 3336 s[2] = 0; 3337 r = strLCpy(s, 3, "lib"); 3338 ck_assert_ptr_eq(r, s); 3339 ck_assert_str_eq(s, "li"); 3340 s[0] = 'a'; 3341 s[1] = 'a'; 3342 s[2] = 'a'; 3343 s[3] = 0; 3344 r = strLCpy(s, 3, "lib"); 3345 ck_assert_ptr_eq(r, s); 3346 ck_assert_str_eq(s, "li"); 3347 // size 0 - no change in s 3348 r = strLCpy(s, 0, "libsheepy"); 3349 ck_assert_ptr_eq(r, s); 3350 ck_assert_str_eq(s, "li"); 3351 // NULL 3352 s[0] = 0; 3353 r = strLCpy(s, 1, NULL); 3354 ck_assert_ptr_eq(r, null); 3355 ck_assert_str_eq(s, ""); 3356 r = strLCpy(NULL,1, "lib"); 3357 ck_assert_ptr_eq(r, null); 3358 3359 } 3360 3361 3362 void strCatT(CuTest *tc UNUSED) { 3363 3364 char s[1024]; 3365 char *r = null; 3366 3367 // append string 3368 r = strCpy(s, "lib"); 3369 ck_assert_ptr_eq(r, s); 3370 r = strCat(s, "sheepy"); 3371 ck_assert_ptr_eq(r, s); 3372 ck_assert_str_eq(s, "libsheepy"); 3373 // empty string2 3374 r = strCat(s, ""); 3375 ck_assert_ptr_eq(r, s); 3376 ck_assert_str_eq(s, "libsheepy"); 3377 // NULL string2 3378 r = strCat(s, NULL); 3379 ck_assert_ptr_eq(r, null); 3380 ck_assert_str_eq(s, "libsheepy"); 3381 // NULL parameter 3382 r = strCat(NULL, "ad"); 3383 ck_assert_ptr_eq(r, null); 3384 3385 } 3386 3387 3388 void strNCatT(CuTest *tc UNUSED) { 3389 3390 char s[1024]; 3391 char *r = null; 3392 3393 // append string 3394 r = strCpy(s, "lib"); 3395 ck_assert_ptr_eq(r, s); 3396 r = strNCat(s, "sheepy", 100); 3397 ck_assert_ptr_eq(r, s); 3398 ck_assert_str_eq(s, "libsheepy"); 3399 // empty string2 3400 r = strNCat(s, "", 10); 3401 ck_assert_ptr_eq(r, s); 3402 ck_assert_str_eq(s, "libsheepy"); 3403 // truncate src 3404 s[0] = 'a'; 3405 s[1] = 'a'; 3406 s[2] = 'a'; 3407 s[3] = 'a'; 3408 s[4] = 'a'; 3409 s[5] = 'a'; 3410 r = strCpy(s, "lib"); 3411 ck_assert_ptr_eq(r, s); 3412 ck_assert_str_eq(s, "lib"); 3413 r = strNCat(s, "sheepy", 2); 3414 ck_assert_ptr_eq(r, s); 3415 ck_assert_str_eq(s, "libsh"); 3416 // NULL string2 3417 r = strNCat(s, NULL, 1); 3418 ck_assert_ptr_eq(r, null); 3419 ck_assert_str_eq(s, "libsh"); 3420 // NULL parameter 3421 r = strNCat(NULL, "ad", 1); 3422 ck_assert_ptr_eq(r, null); 3423 3424 } 3425 3426 3427 void strLCatT(CuTest *tc UNUSED) { 3428 3429 char s[1024]; 3430 char *r = null; 3431 3432 // append string 3433 r = strCpy(s, "lib"); 3434 ck_assert_ptr_eq(r, s); 3435 r = strLCat(s, 100, "sheepy"); 3436 ck_assert_ptr_eq(r, s); 3437 ck_assert_str_eq(s, "libsheepy"); 3438 // empty string2 3439 r = strLCat(s, 20, ""); 3440 ck_assert_ptr_eq(r, s); 3441 ck_assert_str_eq(s, "libsheepy"); 3442 // s strlen bigger than s size - keep s as it is 3443 r = strLCat(s, 6, "qwqwe"); 3444 ck_assert_ptr_eq(r, s); 3445 ck_assert_str_eq(s, "libsheepy"); 3446 // truncate src 3447 s[0] = 'a'; 3448 s[1] = 'a'; 3449 s[2] = 'a'; 3450 s[3] = 'a'; 3451 s[4] = 'a'; 3452 s[5] = 'a'; 3453 r = strCpy(s, "lib"); 3454 ck_assert_ptr_eq(r, s); 3455 ck_assert_str_eq(s, "lib"); 3456 r = strLNCat(s,100, "sheepy", 2); 3457 ck_assert_ptr_eq(r, s); 3458 ck_assert_str_eq(s, "libsh"); 3459 // truncate dst 3460 s[0] = 'a'; 3461 s[1] = 'a'; 3462 s[2] = 'a'; 3463 s[3] = 'a'; 3464 s[4] = 'a'; 3465 s[5] = 'a'; 3466 r = strCpy(s, "lib"); 3467 ck_assert_ptr_eq(r, s); 3468 ck_assert_str_eq(s, "lib"); 3469 r = strLCat(s, 6, "sheepy"); 3470 ck_assert_ptr_eq(r, s); 3471 ck_assert_str_eq(s, "libsh"); 3472 // NULL string2 3473 r = strLCat(s, 1, NULL); 3474 ck_assert_ptr_eq(r, null); 3475 ck_assert_str_eq(s, "libsh"); 3476 // NULL parameter 3477 r = strLCat(NULL, 1, "ad"); 3478 ck_assert_ptr_eq(r, null); 3479 3480 } 3481 3482 3483 void strLNCatT(CuTest *tc UNUSED) { 3484 3485 char s[1024]; 3486 char *r = null; 3487 3488 // append string 3489 r = strCpy(s, "lib"); 3490 ck_assert_ptr_eq(r, s); 3491 r = strLNCat(s, 100, "sheepy", 100); 3492 ck_assert_ptr_eq(r, s); 3493 ck_assert_str_eq(s, "libsheepy"); 3494 // empty string2 3495 r = strLNCat(s, 20, "", 10); 3496 ck_assert_ptr_eq(r, s); 3497 ck_assert_str_eq(s, "libsheepy"); 3498 // s strlen bigger than s size - keep s as it is 3499 r = strLNCat(s, 6, "qwqwe", 1); 3500 ck_assert_ptr_eq(r, s); 3501 ck_assert_str_eq(s, "libsheepy"); 3502 // truncate dst 3503 s[0] = 'a'; 3504 s[1] = 'a'; 3505 s[2] = 'a'; 3506 s[3] = 'a'; 3507 s[4] = 'a'; 3508 s[5] = 'a'; 3509 r = strCpy(s, "lib"); 3510 ck_assert_ptr_eq(r, s); 3511 ck_assert_str_eq(s, "lib"); 3512 r = strLNCat(s, 6, "sheepy", 4); 3513 ck_assert_ptr_eq(r, s); 3514 ck_assert_str_eq(s, "libsh"); 3515 // NULL string2 3516 r = strLNCat(s, 1, NULL, 1); 3517 ck_assert_ptr_eq(r, null); 3518 ck_assert_str_eq(s, "libsh"); 3519 // NULL parameter 3520 r = strLNCat(NULL, 1, "ad", 1); 3521 ck_assert_ptr_eq(r, null); 3522 3523 } 3524 3525 3526 void catST(CuTest *tc UNUSED) { 3527 3528 char *s; 3529 char *r; 3530 3531 // cat strings 3532 s = strdup("#@#"); 3533 r = catS(s,"asd"); 3534 ck_assert_str_eq(r, "#@#asd"); 3535 free(s); 3536 free(r); 3537 // empty string 3538 r = catS(""); 3539 ck_assert(isEmptyS(r)); 3540 free(r); 3541 // cat empty string with string 3542 r = catS("", "asd"); 3543 ck_assert_str_eq(r, "asd"); 3544 free(r); 3545 3546 } 3547 3548 3549 void iCatST(CuTest *tc UNUSED) { 3550 3551 char *s; 3552 char r[100]; 3553 char *r2 = null; 3554 3555 // cat strings 3556 s = strdup("#@#"); 3557 r2 = iCatS(r, s,"asd"); 3558 ck_assert_ptr_eq(r2, r); 3559 ck_assert_str_eq(r, "#@#asd"); 3560 free(s); 3561 // empty string 3562 r2 = iCatS(r, ""); 3563 ck_assert_ptr_eq(r2, r); 3564 ck_assert(isEmptyS(r)); 3565 // cat empty string with string 3566 r2 = iCatS(r, "", "asd"); 3567 ck_assert_ptr_eq(r2, r); 3568 ck_assert_str_eq(r, "asd"); 3569 // NULL 3570 r2 = iCatS(NULL, "wef","wef"); 3571 ck_assert_ptr_eq(r2, null); 3572 3573 } 3574 3575 3576 void bLCatST(CuTest *tc UNUSED) { 3577 3578 char *s; 3579 char r[100]; 3580 char *r2 = null; 3581 3582 // cat strings 3583 s = strdup("#@#"); 3584 r2 = bLCatS(r, sizeof r, s,"asd"); 3585 ck_assert_ptr_eq(r2, r); 3586 ck_assert_str_eq(r, "#@#asd"); 3587 // shorter buffer 3588 r2 = bLCatS(r, 3, s,"asd"); 3589 ck_assert_ptr_eq(r2, r); 3590 ck_assert_str_eq(r, "#@"); 3591 free(s); 3592 // empty string 3593 r2 = bLCatS(r, sizeof r, ""); 3594 ck_assert_ptr_eq(r2, r); 3595 ck_assert(isEmptyS(r)); 3596 // cat empty string with string 3597 r2 = bLCatS(r, sizeof r, "", "asd"); 3598 ck_assert_ptr_eq(r2, r); 3599 ck_assert_str_eq(r, "asd"); 3600 // size 0 - no change in r 3601 r2 = bLCatS(r, 0, "", "asd"); 3602 ck_assert_ptr_eq(r2, r); 3603 ck_assert_str_eq(r, "asd"); 3604 // NULL 3605 r2 = bLCatS(NULL, sizeof r, "wef","wef"); 3606 ck_assert_ptr_eq(r2, null); 3607 3608 } 3609 3610 3611 void formatST(CuTest *tc UNUSED) { 3612 3613 char *s; 3614 char r[128] = init0Var; 3615 3616 // format 3617 s = formatS("sheepy is num %d", 1); 3618 ck_assert_str_eq(s, "sheepy is num 1"); 3619 free(s); 3620 // NULL 3621 ck_assert_ptr_eq(formatS(NULL), NULL); 3622 3623 // bFormatS 3624 s = bFormatS(r, "sheepy is num %d", 1); 3625 ck_assert_str_eq(s, "sheepy is num 1"); 3626 // NULL 3627 ck_assert_ptr_eq(bFormatS(r,NULL), NULL); 3628 ck_assert_ptr_eq(bFormatS(NULL,"ojoi"), NULL); 3629 3630 // bLFormatS 3631 s = bLFormatS(r, sizeof(r), "sheepy is num %d", 1); 3632 ck_assert_str_eq(s, "sheepy is num 1"); 3633 // shorter buffer 3634 s = bLFormatS(r, 7, "sheepy is num %d", 1); 3635 ck_assert_str_eq(s, "sheepy"); 3636 // buffer size 0 3637 s = bLFormatS(r, 0, "sheepy is num %d", 1); 3638 ck_assert_str_eq(s, "sheepy"); 3639 // NULL 3640 ck_assert_ptr_eq(bLFormatS(r,1,NULL), NULL); 3641 ck_assert_ptr_eq(bLFormatS(NULL,1,"ojoi"), NULL); 3642 3643 } 3644 3645 3646 void appendST(CuTest *tc UNUSED) { 3647 3648 char *s; 3649 3650 // append string 3651 s = appendS("lib", "sheepy"); 3652 ck_assert_str_eq(s, "libsheepy"); 3653 free(s); 3654 // empty string2 3655 s = appendS("libsheepy", ""); 3656 ck_assert_str_eq(s, "libsheepy"); 3657 free(s); 3658 // NULL string2 3659 s = appendS("libsheepy", NULL); 3660 ck_assert_str_eq(s, "libsheepy"); 3661 free(s); 3662 // NULL string 3663 s = appendS(NULL, "ad"); 3664 ck_assert_ptr_eq(s, NULL); 3665 3666 } 3667 3668 3669 void appendCharST(CuTest *tc UNUSED) { 3670 3671 char *s; 3672 3673 // append string 3674 s = appendCharS("lib", 'C'); 3675 ck_assert_str_eq(s, "libC"); 3676 free(s); 3677 // empty string2 3678 s = appendCharS("libsheepy", 0); 3679 ck_assert_str_eq(s, "libsheepy"); 3680 free(s); 3681 // NULL string 3682 s = appendCharS(NULL, 'C'); 3683 ck_assert_ptr_eq(s, NULL); 3684 3685 } 3686 3687 3688 void appendSCharT(CuTest *tc UNUSED) { 3689 3690 char *s; 3691 3692 // append string 3693 s = appendSChar('l', "sheepy"); 3694 ck_assert_str_eq(s, "lsheepy"); 3695 free(s); 3696 // empty string2 3697 s = appendSChar('l', ""); 3698 ck_assert_str_eq(s, "l"); 3699 free(s); 3700 // NULL string2 3701 s = appendSChar('l', NULL); 3702 ck_assert_str_eq(s, "l"); 3703 free(s); 3704 3705 } 3706 3707 3708 void iAppendST(CuTest *tc UNUSED) { 3709 3710 char *s; 3711 char *r = null; 3712 3713 // append string 3714 s = strdup("lib"); 3715 r = iAppendS(&s, "sheepy"); 3716 ck_assert_ptr_eq(r, s); 3717 ck_assert_str_eq(s, "libsheepy"); 3718 // empty string2 3719 r = iAppendS(&s, ""); 3720 ck_assert_ptr_eq(r, s); 3721 ck_assert_str_eq(s, "libsheepy"); 3722 // NULL string2 3723 r = iAppendS(&s, NULL); 3724 ck_assert_ptr_eq(r, s); 3725 ck_assert_str_eq(s, "libsheepy"); 3726 free(s); 3727 // NULL string 3728 s = NULL; 3729 r = iAppendS(&s, "ad"); 3730 ck_assert_ptr_eq(r, s); 3731 ck_assert_str_eq(s, "ad"); 3732 free(s); 3733 // NULL parameter 3734 r = iAppendS(NULL, "ad"); 3735 ck_assert_ptr_eq(r, null); 3736 3737 } 3738 3739 3740 void iAppendCharST(CuTest *tc UNUSED) { 3741 3742 char *s; 3743 char *r = null; 3744 3745 // append string 3746 s = strdup("lib"); 3747 r = iAppendCharS(&s, 'C'); 3748 ck_assert_ptr_eq(r, s); 3749 ck_assert_str_eq(s, "libC"); 3750 // empty string2 3751 r = iAppendCharS(&s, 0); 3752 ck_assert_ptr_eq(r, s); 3753 ck_assert_str_eq(s, "libC"); 3754 free(s); 3755 // NULL string 3756 s = NULL; 3757 r = iAppendCharS(&s, 'C'); 3758 ck_assert_ptr_eq(r, s); 3759 ck_assert_str_eq(s, "C"); 3760 free(s); 3761 // NULL parameter 3762 r = iAppendCharS(NULL, 'C'); 3763 ck_assert_ptr_eq(r, null); 3764 3765 } 3766 3767 3768 void iAppendNFreeST(CuTest *tc UNUSED) { 3769 3770 char *s; 3771 char *r = null; 3772 3773 // append string 3774 s = strdup("lib"); 3775 r = iAppendNFreeS(&s, strdup("sheepy")); 3776 ck_assert_ptr_eq(r, s); 3777 ck_assert_str_eq(s, "libsheepy"); 3778 // empty string2 3779 r = iAppendNFreeS(&s, strdup("")); 3780 ck_assert_ptr_eq(r, s); 3781 ck_assert_str_eq(s, "libsheepy"); 3782 // NULL string2 3783 r = iAppendNFreeS(&s, NULL); 3784 ck_assert_ptr_eq(r, s); 3785 ck_assert_str_eq(s, "libsheepy"); 3786 free(s); 3787 // NULL string 3788 s = NULL; 3789 r = iAppendNFreeS(&s, strdup("ad")); 3790 ck_assert_ptr_eq(r, s); 3791 ck_assert_str_eq(s, "ad"); 3792 free(s); 3793 // NULL parameter 3794 s = strdup("ad"); 3795 r = iAppendNFreeS(NULL, s); 3796 ck_assert_ptr_eq(r, null); 3797 free(s); 3798 3799 } 3800 3801 3802 void iAppendManyST(CuTest *tc UNUSED) { 3803 3804 char *s; 3805 char *r = null; 3806 3807 // append string 3808 s = strdup("lib"); 3809 r = iAppendManyS(&s, "sheepy","2"); 3810 ck_assert_ptr_eq(r, s); 3811 ck_assert_str_eq(s, "libsheepy2"); 3812 // empty string2 3813 r = iAppendManyS(&s, "", ""); 3814 ck_assert_ptr_eq(r, s); 3815 ck_assert_str_eq(s, "libsheepy2"); 3816 // NULL string2 3817 r = iAppendManyS(&s, "a", NULL); 3818 ck_assert_ptr_eq(r, s); 3819 ck_assert_str_eq(s, "libsheepy2a"); 3820 //not allowed - iAppendManyS(&s, NULL); 3821 free(s); 3822 // NULL string (allocate) 3823 s = NULL; 3824 r = iAppendManyS(&s, "ad", ""); 3825 ck_assert_ptr_eq(r, s); 3826 ck_assert_str_eq(s, "ad"); 3827 free(s); 3828 // NULL parameter 3829 r = iAppendManyS(NULL, "ad", ""); 3830 ck_assert_ptr_eq(r, null); 3831 3832 } 3833 3834 3835 void bAppendManyST(CuTest *tc UNUSED) { 3836 3837 char s[100]; 3838 char *r = null; 3839 3840 // append string 3841 strcpy(s, "lib"); 3842 r = bAppendManyS(s, "sheepy","2"); 3843 ck_assert_ptr_eq(r, s); 3844 ck_assert_str_eq(s, "libsheepy2"); 3845 // empty string2 3846 r = bAppendManyS(s, "", ""); 3847 ck_assert_ptr_eq(r, s); 3848 ck_assert_str_eq(s, "libsheepy2"); 3849 // NULL string2 3850 r = bAppendManyS(s, "a", NULL); 3851 ck_assert_ptr_eq(r, s); 3852 ck_assert_str_eq(s, "libsheepy2a"); 3853 //not allowed - bAppendManyS(s, NULL); 3854 // NULL parameter 3855 r = bAppendManyS(NULL, "ad", ""); 3856 ck_assert_ptr_eq(r, null); 3857 3858 } 3859 3860 3861 void bLAppendManyST(CuTest *tc UNUSED) { 3862 3863 char s[100]; 3864 char *r = null; 3865 3866 // append string 3867 strcpy(s, "lib"); 3868 r = bLAppendManyS(s, sizeof s, "sheepy","2"); 3869 ck_assert_ptr_eq(r, s); 3870 ck_assert_str_eq(s, "libsheepy2"); 3871 // shorter buffer 3872 strcpy(s, "lib"); 3873 r = bLAppendManyS(s, 5, "sheepy","2"); 3874 ck_assert_ptr_eq(r, s); 3875 ck_assert_str_eq(s, "libs"); 3876 // empty string2 3877 r = bLAppendManyS(s, sizeof s, "", ""); 3878 ck_assert_ptr_eq(r, s); 3879 ck_assert_str_eq(s, "libs"); 3880 // NULL string2 3881 r = bLAppendManyS(s, sizeof s, "a", NULL); 3882 ck_assert_ptr_eq(r, s); 3883 ck_assert_str_eq(s, "libsa"); 3884 // size 0 - no change 3885 r = bLAppendManyS(s, 0, "a", NULL); 3886 ck_assert_ptr_eq(r, s); 3887 ck_assert_str_eq(s, "libsa"); 3888 //not allowed - bLAppendManyS(s, sizeof s, NULL); 3889 // NULL parameter 3890 r = bLAppendManyS(NULL, sizeof s, "ad", ""); 3891 ck_assert_ptr_eq(r, null); 3892 3893 } 3894 3895 3896 void prependST(CuTest *tc UNUSED) { 3897 3898 char *s; 3899 3900 s = prependS("sheepy", "lib"); 3901 ck_assert_str_eq(s, "libsheepy"); 3902 free(s); 3903 3904 } 3905 3906 3907 void prependCharST(CuTest *tc UNUSED) { 3908 3909 char *s; 3910 3911 s = prependCharS("sheepy", 'l'); 3912 ck_assert_str_eq(s, "lsheepy"); 3913 free(s); 3914 3915 } 3916 3917 3918 void prependSCharT(CuTest *tc UNUSED) { 3919 3920 char *s; 3921 3922 s = prependSChar('C', "lib"); 3923 ck_assert_str_eq(s, "libC"); 3924 free(s); 3925 3926 } 3927 3928 3929 void iPrependST(CuTest *tc UNUSED) { 3930 3931 char *s; 3932 char *r = null; 3933 3934 // append string 3935 s = strdup("lib"); 3936 r = iPrependS(&s, "sheepy"); 3937 ck_assert_ptr_eq(r, s); 3938 ck_assert_str_eq(s, "sheepylib"); 3939 // empty string2 3940 r = iPrependS(&s, ""); 3941 ck_assert_ptr_eq(r, s); 3942 ck_assert_str_eq(s, "sheepylib"); 3943 // NULL string2 3944 r = iPrependS(&s, NULL); 3945 ck_assert_ptr_eq(r, s); 3946 ck_assert_str_eq(s, "sheepylib"); 3947 free(s); 3948 // NULL string 3949 s = NULL; 3950 r = iPrependS(&s, "ad"); 3951 ck_assert_ptr_eq(r, s); 3952 ck_assert_str_eq(s, "ad"); 3953 free(s); 3954 // NULL parameter 3955 r = iPrependS(NULL, "ad"); 3956 ck_assert_ptr_eq(r, null); 3957 3958 } 3959 3960 3961 void iPrependCharST(CuTest *tc UNUSED) { 3962 3963 char *s; 3964 char *r = null; 3965 3966 // append string 3967 s = strdup("lib"); 3968 r = iPrependCharS(&s, 'C'); 3969 ck_assert_ptr_eq(r, s); 3970 ck_assert_str_eq(s, "Clib"); 3971 // empty string2 3972 r = iPrependCharS(&s, 0); 3973 ck_assert_ptr_eq(r, s); 3974 ck_assert_str_eq(s, "Clib"); 3975 free(s); 3976 // NULL string 3977 s = NULL; 3978 r = iPrependCharS(&s, 'C'); 3979 ck_assert_ptr_eq(r, s); 3980 ck_assert_str_eq(s, "C"); 3981 free(s); 3982 // NULL parameter 3983 r = iPrependCharS(NULL, 'a'); 3984 ck_assert_ptr_eq(r, null); 3985 3986 } 3987 3988 3989 void iPrependNFreeST(CuTest *tc UNUSED) { 3990 3991 char *s; 3992 char *r = null; 3993 3994 // append string 3995 s = strdup("lib"); 3996 r = iPrependNFreeS(&s, strdup("sheepy")); 3997 ck_assert_ptr_eq(r, s); 3998 ck_assert_str_eq(s, "sheepylib"); 3999 // empty string2 4000 r = iPrependNFreeS(&s, strdup("")); 4001 ck_assert_ptr_eq(r, s); 4002 ck_assert_str_eq(s, "sheepylib"); 4003 // NULL string2 4004 r = iPrependNFreeS(&s, NULL); 4005 ck_assert_ptr_eq(r, s); 4006 ck_assert_str_eq(s, "sheepylib"); 4007 free(s); 4008 // NULL string 4009 s = NULL; 4010 r = iPrependNFreeS(&s, strdup("ad")); 4011 ck_assert_ptr_eq(r, s); 4012 ck_assert_str_eq(s, "ad"); 4013 free(s); 4014 // NULL parameter 4015 s = strdup("ad"); 4016 r = iPrependNFreeS(NULL, s); 4017 ck_assert_ptr_eq(r, null); 4018 free(s); 4019 4020 } 4021 4022 4023 void bPrependST(CuTest *tc UNUSED) { 4024 4025 char s[100]; 4026 char *r = null; 4027 4028 // append string 4029 strcpy(s, "lib"); 4030 r = bPrependS(s, "sheepy"); 4031 ck_assert_ptr_eq(r, s); 4032 ck_assert_str_eq(s, "sheepylib"); 4033 // empty string2 4034 r = bPrependS(s, ""); 4035 ck_assert_ptr_eq(r, s); 4036 ck_assert_str_eq(s, "sheepylib"); 4037 // NULL string2 4038 r = bPrependS(s, NULL); 4039 ck_assert_ptr_eq(r, null); 4040 ck_assert_str_eq(s, "sheepylib"); 4041 // empty string 4042 bEmptyS(s); 4043 r = bPrependS(s, "ad"); 4044 ck_assert_ptr_eq(r, s); 4045 ck_assert_str_eq(s, "ad"); 4046 // NULL parameter 4047 r = bPrependS(NULL, "ad"); 4048 ck_assert_ptr_eq(r, null); 4049 4050 } 4051 4052 4053 void bLPrependST(CuTest *tc UNUSED) { 4054 4055 char s[100]; 4056 char *r = null; 4057 4058 // append string 4059 strcpy(s, "lib"); 4060 r = bLPrependS(s, sizeof s, "sheepy"); 4061 ck_assert_ptr_eq(r, s); 4062 ck_assert_str_eq(s, "sheepylib"); 4063 // shorter buffer 4064 strcpy(s, "lib"); 4065 r = bLPrependS(s, 5, "sheepy"); 4066 ck_assert_ptr_eq(r, s); 4067 ck_assert_str_eq(s, "shee"); 4068 // empty string2 4069 r = bLPrependS(s, sizeof s, ""); 4070 ck_assert_ptr_eq(r, s); 4071 ck_assert_str_eq(s, "shee"); 4072 // NULL string2 4073 r = bLPrependS(s, sizeof s, NULL); 4074 ck_assert_ptr_eq(r, null); 4075 ck_assert_str_eq(s, "shee"); 4076 // empty string 4077 bEmptyS(s); 4078 r = bLPrependS(s, sizeof s, "ad"); 4079 ck_assert_ptr_eq(r, s); 4080 ck_assert_str_eq(s, "ad"); 4081 // size 0 - no change 4082 r = bLPrependS(s, 0, "ad"); 4083 ck_assert_ptr_eq(r, s); 4084 ck_assert_str_eq(s, "ad"); 4085 // NULL parameter 4086 r = bLPrependS(NULL, sizeof s, "ad"); 4087 ck_assert_ptr_eq(r, null); 4088 4089 } 4090 4091 4092 void replaceST(CuTest *tc UNUSED) { 4093 4094 // replace string, multiple character new delimeter 4095 char *s = replaceS_max("#ee#ee#ad", "#","^^"); 4096 ck_assert_str_eq(s, "^^ee^^ee^^ad"); 4097 free(s); 4098 // replace string, multiple character old delimeter 4099 s = replaceS_max("AA##ee##ee#", "##","|"); 4100 ck_assert_str_eq(s, "AA|ee|ee#"); 4101 free(s); 4102 // replace one time at the start of string 4103 s = replaceS("#ee#ee#ad", "#","^^",1); 4104 ck_assert_str_eq(s, "^^ee#ee#ad"); 4105 free(s); 4106 // replace one time 4107 s = replaceS("AA##ee##ee#", "##","|",1); 4108 ck_assert_str_eq(s, "AA|ee##ee#"); 4109 free(s); 4110 // NULL new delimiter, one time: same as empty delimiter 4111 s = replaceS("AA##ee##ee#", "##",NULL,1); 4112 ck_assert_str_eq(s, "AAee##ee#"); 4113 free(s); 4114 // empty string 4115 s = replaceS("", "##",NULL,1); 4116 ck_assert_str_eq(s, ""); 4117 free(s); 4118 // empty old delimiter 4119 ck_assert_ptr_eq(replaceS("qwe", "","|",1), NULL); 4120 // NULL old delimiter 4121 ck_assert_ptr_eq(replaceS("qwe", NULL,"|",1), NULL); 4122 // NULL string 4123 ck_assert_ptr_eq(replaceS(NULL, "##","|",1), NULL); 4124 // empty old delimiter 4125 ck_assert_ptr_eq(replaceS("AA##ee##ee#", "","|",1), NULL); 4126 4127 } 4128 4129 4130 void replaceCharSST(CuTest *tc UNUSED) { 4131 4132 // replace string, multiple character new delimeter 4133 char *s = replaceCharSS("#ee#ee#ad", '#',"^^", 0); 4134 ck_assert_str_eq(s, "^^ee^^ee^^ad"); 4135 free(s); 4136 // replace one time at the start of string 4137 s = replaceCharSS("#ee#ee#ad", '#',"^^",1); 4138 ck_assert_str_eq(s, "^^ee#ee#ad"); 4139 free(s); 4140 // replace one time 4141 s = replaceCharSS("AA##ee##ee#", '#',"|",1); 4142 ck_assert_str_eq(s, "AA|#ee##ee#"); 4143 free(s); 4144 // NULL new delimiter, one time: same as empty delimiter 4145 s = replaceCharSS("AA#ee##ee#", '#',NULL,1); 4146 ck_assert_str_eq(s, "AAee##ee#"); 4147 free(s); 4148 // empty string 4149 s = replaceCharSS("", '#',NULL,1); 4150 ck_assert_str_eq(s, ""); 4151 free(s); 4152 // empty old delimiter 4153 ck_assert_ptr_eq(replaceCharSS("qwe", 0,"|",1), NULL); 4154 // NULL string 4155 ck_assert_ptr_eq(replaceCharSS(NULL, '#',"|",1), NULL); 4156 // empty old delimiter 4157 ck_assert_ptr_eq(replaceCharSS("AA##ee##ee#", 0,"|",1), NULL); 4158 4159 } 4160 4161 4162 void replaceSCharST(CuTest *tc UNUSED) { 4163 4164 // replace string, multiple character new delimeter 4165 char *s = replaceSCharS("#ee#ee#ad", "#",'^',0); 4166 ck_assert_str_eq(s, "^ee^ee^ad"); 4167 free(s); 4168 // replace string, multiple character old delimeter 4169 s = replaceSCharS("AA##ee##ee#", "##",'|',0); 4170 ck_assert_str_eq(s, "AA|ee|ee#"); 4171 free(s); 4172 // replace string empty char, multiple character old delimeter 4173 s = replaceSCharS("AA##ee##ee#", "##", 0,0); 4174 ck_assert_str_eq(s, "AAeeee#"); 4175 free(s); 4176 // replace one time at the start of string 4177 s = replaceSCharS("#ee#ee#ad", "#",'^',1); 4178 ck_assert_str_eq(s, "^ee#ee#ad"); 4179 free(s); 4180 // replace one time 4181 s = replaceSCharS("AA##ee##ee#", "##",'|',1); 4182 ck_assert_str_eq(s, "AA|ee##ee#"); 4183 free(s); 4184 // empty string 4185 s = replaceSCharS("", "##",0,1); 4186 ck_assert_str_eq(s, ""); 4187 free(s); 4188 // empty old delimiter 4189 ck_assert_ptr_eq(replaceSCharS("qwe", "",'|',1), NULL); 4190 // NULL old delimiter 4191 ck_assert_ptr_eq(replaceSCharS("qwe", NULL,'|',1), NULL); 4192 // NULL string 4193 ck_assert_ptr_eq(replaceSCharS(NULL, "##",'|',1), NULL); 4194 // empty old delimiter 4195 ck_assert_ptr_eq(replaceSCharS("AA##ee##ee#", "",'|',1), NULL); 4196 4197 } 4198 4199 4200 void replaceCharCharST(CuTest *tc UNUSED) { 4201 4202 // replace string, multiple character new delimeter 4203 char *s = replaceCharCharS("#ee#ee#ad", '#','^', 0); 4204 ck_assert_str_eq(s, "^ee^ee^ad"); 4205 free(s); 4206 // replace one time at the start of string 4207 s = replaceCharCharS("#ee#ee#ad", '#','^',1); 4208 ck_assert_str_eq(s, "^ee#ee#ad"); 4209 free(s); 4210 // replace one time 4211 s = replaceCharCharS("AA#ee##ee#", '#','|',1); 4212 ck_assert_str_eq(s, "AA|ee##ee#"); 4213 free(s); 4214 // empty string 4215 s = replaceCharCharS("", '#','^',1); 4216 ck_assert_str_eq(s, ""); 4217 free(s); 4218 // empty old delimiter 4219 ck_assert_ptr_eq(replaceCharCharS("qwe", 0,'|',1), NULL); 4220 // NULL string 4221 ck_assert_ptr_eq(replaceCharCharS(NULL, '#','|',1), NULL); 4222 // empty old delimiter 4223 ck_assert_ptr_eq(replaceCharCharS("AA##ee##ee#", 0,'|',1), NULL); 4224 4225 } 4226 4227 4228 void iReplaceST(CuTest *tc UNUSED) { 4229 4230 char *s; 4231 char *r = null; 4232 4233 // replace string, multiple character new delimeter 4234 s = strdup("#ee#ee#ad"); 4235 r = iReplaceS_max(&s, "#","^^"); 4236 ck_assert_ptr_eq(r, s); 4237 ck_assert_str_eq(s, "^^ee^^ee^^ad"); 4238 free(s); 4239 // replace string, multiple character old delimeter 4240 s = strdup("AA##ee##ee#"); 4241 r = iReplaceS_max(&s, "##","|"); 4242 ck_assert_ptr_eq(r, s); 4243 ck_assert_str_eq(s, "AA|ee|ee#"); 4244 free(s); 4245 // replace one time at the start of string 4246 s = strdup("#ee#ee#ad"); 4247 r = iReplaceS(&s, "#","^^",1); 4248 ck_assert_ptr_eq(r, s); 4249 ck_assert_str_eq(s, "^^ee#ee#ad"); 4250 free(s); 4251 // replace one time 4252 s = strdup("AA##ee##ee#"); 4253 r = iReplaceS(&s, "##","|",1); 4254 ck_assert_ptr_eq(r, s); 4255 ck_assert_str_eq(s, "AA|ee##ee#"); 4256 free(s); 4257 // NULL new delimiter, one time: same as empty delimiter 4258 s = strdup("AA##ee##ee#"); 4259 r = iReplaceS(&s, "##",NULL,1); 4260 ck_assert_ptr_eq(r, s); 4261 ck_assert_str_eq(s, "AAee##ee#"); 4262 free(s); 4263 // empty string 4264 emptyS(s); 4265 r = iReplaceS(&s, "##",NULL,1); 4266 ck_assert_ptr_eq(r, null); 4267 ck_assert_str_eq(s, ""); 4268 free(s); 4269 // empty old delimiter 4270 s = strdup("qwe"); 4271 r = iReplaceS(&s, "","|",1); 4272 ck_assert_ptr_eq(r, null); 4273 ck_assert_str_eq(s, "qwe"); 4274 free(s); 4275 // NULL old delimiter 4276 s = strdup("qwe"); 4277 r = iReplaceS(&s, NULL,"|",1); 4278 ck_assert_ptr_eq(r, null); 4279 ck_assert_str_eq(s, "qwe"); 4280 free(s); 4281 // NULL string 4282 s = NULL; 4283 r = iReplaceS(&s, "##","|",1); 4284 ck_assert_ptr_eq(r, null); 4285 // NULL var 4286 r = iReplaceS(NULL, "##","|",1); 4287 ck_assert_ptr_eq(r, null); 4288 4289 } 4290 4291 4292 void iReplaceCharSST(CuTest *tc UNUSED) { 4293 4294 char *s; 4295 char *r = null; 4296 4297 // replace string, multiple character new delimeter 4298 s = strdup("#ee#ee#ad"); 4299 r = iReplaceCharSS(&s, '#',"^^", 0); 4300 ck_assert_ptr_eq(r, s); 4301 ck_assert_str_eq(s, "^^ee^^ee^^ad"); 4302 free(s); 4303 // replace one time at the start of string 4304 s = strdup("#ee#ee#ad"); 4305 r = iReplaceCharSS(&s, '#',"^^",1); 4306 ck_assert_ptr_eq(r, s); 4307 ck_assert_str_eq(s, "^^ee#ee#ad"); 4308 free(s); 4309 // replace one time 4310 s = strdup("AA#ee##ee#"); 4311 r = iReplaceCharSS(&s, '#',"|",1); 4312 ck_assert_ptr_eq(r, s); 4313 ck_assert_str_eq(s, "AA|ee##ee#"); 4314 free(s); 4315 // NULL new delimiter, one time: same as empty delimiter 4316 s = strdup("AA#ee##ee#"); 4317 r = iReplaceCharSS(&s, '#',NULL,1); 4318 ck_assert_ptr_eq(r, s); 4319 ck_assert_str_eq(s, "AAee##ee#"); 4320 free(s); 4321 // empty string 4322 emptyS(s); 4323 r = iReplaceCharSS(&s, '#',NULL,1); 4324 ck_assert_ptr_eq(r, null); 4325 ck_assert_str_eq(s, ""); 4326 free(s); 4327 // empty old delimiter 4328 s = strdup("qwe"); 4329 r = iReplaceCharSS(&s, 0,"|",1); 4330 ck_assert_ptr_eq(r, null); 4331 ck_assert_str_eq(s, "qwe"); 4332 free(s); 4333 // NULL string 4334 s = NULL; 4335 r = iReplaceCharSS(&s, '#',"|",1); 4336 ck_assert_ptr_eq(r, s); 4337 // NULL var 4338 r = iReplaceCharSS(NULL, '#',"|",1); 4339 ck_assert_ptr_eq(r, null); 4340 4341 } 4342 4343 4344 void iReplaceSCharST(CuTest *tc UNUSED) { 4345 4346 char *s; 4347 char *r = null; 4348 4349 // replace string, multiple character new delimeter 4350 s = strdup("#ee#ee#ad"); 4351 r = iReplaceSCharS(&s, "#",'^', 0); 4352 ck_assert_ptr_eq(r, s); 4353 ck_assert_str_eq(s, "^ee^ee^ad"); 4354 free(s); 4355 // replace string, multiple character old delimeter 4356 s = strdup("AA##ee##ee#"); 4357 r = iReplaceSCharS(&s, "##",'|', 0); 4358 ck_assert_ptr_eq(r, s); 4359 ck_assert_str_eq(s, "AA|ee|ee#"); 4360 free(s); 4361 // replace one time at the start of string 4362 s = strdup("#ee#ee#ad"); 4363 r = iReplaceSCharS(&s, "#",'^',1); 4364 ck_assert_ptr_eq(r, s); 4365 ck_assert_str_eq(s, "^ee#ee#ad"); 4366 free(s); 4367 // replace one time 4368 s = strdup("AA##ee##ee#"); 4369 r = iReplaceSCharS(&s, "##",'|',1); 4370 ck_assert_ptr_eq(r, s); 4371 ck_assert_str_eq(s, "AA|ee##ee#"); 4372 free(s); 4373 // empty string 4374 emptyS(s); 4375 r = iReplaceSCharS(&s, "##", 0,1); 4376 ck_assert_ptr_eq(r, null); 4377 ck_assert_str_eq(s, ""); 4378 free(s); 4379 // empty old delimiter 4380 s = strdup("qwe"); 4381 r = iReplaceSCharS(&s, "",'|',1); 4382 ck_assert_ptr_eq(r, null); 4383 ck_assert_str_eq(s, "qwe"); 4384 free(s); 4385 // NULL old delimiter 4386 s = strdup("qwe"); 4387 r = iReplaceSCharS(&s, NULL,'|',1); 4388 ck_assert_ptr_eq(r, null); 4389 ck_assert_str_eq(s, "qwe"); 4390 free(s); 4391 // NULL string 4392 s = NULL; 4393 r = iReplaceSCharS(&s, "##",'|',1); 4394 ck_assert_ptr_eq(r, null); 4395 // NULL var 4396 r = iReplaceSCharS(NULL, "##",'|',1); 4397 ck_assert_ptr_eq(r, null); 4398 4399 } 4400 4401 4402 void iReplaceCharCharST(CuTest *tc UNUSED) { 4403 4404 char *s; 4405 char *r = null; 4406 4407 // replace string, multiple character new delimeter 4408 s = strdup("#ee#ee#ad"); 4409 r = iReplaceCharCharS(&s, '#','^', 0); 4410 ck_assert_ptr_eq(r, s); 4411 ck_assert_str_eq(s, "^ee^ee^ad"); 4412 free(s); 4413 // replace one time at the start of string 4414 s = strdup("#ee#ee#ad"); 4415 r = iReplaceCharCharS(&s, '#','^',1); 4416 ck_assert_ptr_eq(r, s); 4417 ck_assert_str_eq(s, "^ee#ee#ad"); 4418 free(s); 4419 // replace one time 4420 s = strdup("AA#ee##ee#"); 4421 r = iReplaceCharCharS(&s, '#','|',1); 4422 ck_assert_ptr_eq(r, s); 4423 ck_assert_str_eq(s, "AA|ee##ee#"); 4424 free(s); 4425 // empty string 4426 emptyS(s); 4427 r = iReplaceCharCharS(&s, '#', 0,1); 4428 ck_assert_ptr_eq(r, null); 4429 ck_assert_str_eq(s, ""); 4430 free(s); 4431 // empty old delimiter 4432 s = strdup("qwe"); 4433 r = iReplaceCharCharS(&s, 0,'|',1); 4434 ck_assert_ptr_eq(r, null); 4435 ck_assert_str_eq(s, "qwe"); 4436 free(s); 4437 // NULL string 4438 s = NULL; 4439 r = iReplaceCharCharS(&s, '#','|',1); 4440 ck_assert_ptr_eq(r, s); 4441 // NULL var 4442 r = iReplaceCharCharS(NULL, '#','|',1); 4443 ck_assert_ptr_eq(r, null); 4444 4445 } 4446 4447 4448 void bReplaceST(CuTest *tc UNUSED) { 4449 4450 char s[100]; 4451 char *r = null; 4452 4453 // replace string, multiple character new delimeter 4454 strcpy(s, "#ee#ee#ad"); 4455 r = bReplaceS_max(s, "#","^^"); 4456 ck_assert_ptr_eq(r, s); 4457 ck_assert_str_eq(s, "^^ee^^ee^^ad"); 4458 // replace string, multiple character old delimeter 4459 strcpy(s, "AA##ee##ee#"); 4460 r = bReplaceS_max(s, "##","|"); 4461 ck_assert_ptr_eq(r, s); 4462 ck_assert_str_eq(s, "AA|ee|ee#"); 4463 // replace one time at the start of string 4464 strcpy(s, "#ee#ee#ad"); 4465 r = bReplaceS(s, "#","^^",1); 4466 ck_assert_ptr_eq(r, s); 4467 ck_assert_str_eq(s, "^^ee#ee#ad"); 4468 // replace one time 4469 strcpy(s, "AA##ee##ee#"); 4470 r = bReplaceS(s, "##","|",1); 4471 ck_assert_ptr_eq(r, s); 4472 ck_assert_str_eq(s, "AA|ee##ee#"); 4473 // NULL new delimiter, one time: same as empty delimiter 4474 strcpy(s, "AA##ee##ee#"); 4475 r = bReplaceS(s, "##",NULL,1); 4476 ck_assert_ptr_eq(r, s); 4477 ck_assert_str_eq(s, "AAee##ee#"); 4478 // empty string 4479 bEmptyS(s); 4480 r = bReplaceS(s, "##",NULL,1); 4481 ck_assert_ptr_eq(r, null); 4482 ck_assert_str_eq(s, ""); 4483 // empty old delimiter 4484 strcpy(s, "qwe"); 4485 r = bReplaceS(s, "","|",1); 4486 ck_assert_ptr_eq(r, null); 4487 ck_assert_str_eq(s, "qwe"); 4488 // NULL old delimiter 4489 strcpy(s, "qwe"); 4490 r = bReplaceS(s, NULL,"|",1); 4491 ck_assert_ptr_eq(r, null); 4492 ck_assert_str_eq(s, "qwe"); 4493 // NULL var 4494 r = bReplaceS(NULL, "##","|",1); 4495 ck_assert_ptr_eq(r, null); 4496 4497 } 4498 4499 4500 void bLReplaceST(CuTest *tc UNUSED) { 4501 4502 char s[100]; 4503 char *r = null; 4504 4505 // replace string, multiple character new delimeter 4506 strcpy(s, "#ee#ee#ad"); 4507 r = bLReplaceS_max(s, sizeof s, "#","^^"); 4508 ck_assert_ptr_eq(r, s); 4509 ck_assert_str_eq(s, "^^ee^^ee^^ad"); 4510 // shorter buffer 4511 strcpy(s, "#ee#ee#ad"); 4512 r = bLReplaceS_max(s, 5, "#","^^"); 4513 ck_assert_ptr_eq(r, s); 4514 ck_assert_str_eq(s, "^^ee"); 4515 // replace string, multiple character old delimeter 4516 strcpy(s, "AA##ee##ee#"); 4517 r = bLReplaceS_max(s, sizeof s, "##","|"); 4518 ck_assert_ptr_eq(r, s); 4519 ck_assert_str_eq(s, "AA|ee|ee#"); 4520 // replace one time at the start of string 4521 strcpy(s, "#ee#ee#ad"); 4522 r = bLReplaceS(s, sizeof s, "#","^^",1); 4523 ck_assert_ptr_eq(r, s); 4524 ck_assert_str_eq(s, "^^ee#ee#ad"); 4525 // replace one time 4526 strcpy(s, "AA##ee##ee#"); 4527 r = bLReplaceS(s, sizeof s, "##","|",1); 4528 ck_assert_ptr_eq(r, s); 4529 ck_assert_str_eq(s, "AA|ee##ee#"); 4530 // NULL new delimiter, one time: same as empty delimiter 4531 strcpy(s, "AA##ee##ee#"); 4532 r = bLReplaceS(s, sizeof s, "##",NULL,1); 4533 ck_assert_ptr_eq(r, s); 4534 ck_assert_str_eq(s, "AAee##ee#"); 4535 // empty string 4536 bEmptyS(s); 4537 r = bLReplaceS(s, sizeof s, "##",NULL,1); 4538 ck_assert_ptr_eq(r, null); 4539 ck_assert_str_eq(s, ""); 4540 // empty old delimiter 4541 strcpy(s, "qwe"); 4542 r = bLReplaceS(s, sizeof s, "","|",1); 4543 ck_assert_ptr_eq(r, null); 4544 ck_assert_str_eq(s, "qwe"); 4545 // NULL old delimiter 4546 strcpy(s, "qwe"); 4547 r = bLReplaceS(s, sizeof s, NULL,"|",1); 4548 ck_assert_ptr_eq(r, null); 4549 ck_assert_str_eq(s, "qwe"); 4550 // size 0 - no change 4551 strcpy(s, "qwe"); 4552 r = bLReplaceS(s, 0, "q","|",1); 4553 ck_assert_ptr_eq(r, s); 4554 ck_assert_str_eq(s, "qwe"); 4555 // NULL var 4556 r = bLReplaceS(NULL, sizeof s, "##","|",1); 4557 ck_assert_ptr_eq(r, null); 4558 4559 } 4560 4561 4562 void icReplaceST(CuTest *tc UNUSED) { 4563 4564 char *s; 4565 4566 // replace string, multiple character new delimeter 4567 s = icReplaceS("#EE#ee#ad", "ee","VV", 0); 4568 ck_assert_str_eq(s, "#VV#VV#ad"); 4569 free(s); 4570 // icReplaceCharSS 4571 s = icReplaceCharSS("#EE#ee#ad", 'e',"V", 0); 4572 ck_assert_str_eq(s, "#VV#VV#ad"); 4573 free(s); 4574 // icReplaceSCharS 4575 s = icReplaceSCharS("#EE#ee#ad", "e",'V', 0); 4576 ck_assert_str_eq(s, "#VV#VV#ad"); 4577 free(s); 4578 // icReplaceCharCharS 4579 s = icReplaceCharCharS("#EE#ee#ad", 'e','V', 0); 4580 ck_assert_str_eq(s, "#VV#VV#ad"); 4581 free(s); 4582 4583 // replace string, multiple character old delimeter 4584 s = icReplaceS("AA##ee##ee#", "##","|", 0); 4585 ck_assert_str_eq(s, "AA|ee|ee#"); 4586 free(s); 4587 // replace one time at the start of string 4588 s = icReplaceS("#ee#ee#ad", "#","^^",1); 4589 ck_assert_str_eq(s, "^^ee#ee#ad"); 4590 free(s); 4591 // replace one time 4592 s = icReplaceS("AA##ee##ee#", "##","|",1); 4593 ck_assert_str_eq(s, "AA|ee##ee#"); 4594 free(s); 4595 // NULL new delimiter, one time: same as empty delimiter 4596 s = icReplaceS("AA##ee##ee#", "##",NULL,1); 4597 ck_assert_str_eq(s, "AAee##ee#"); 4598 free(s); 4599 // empty string 4600 s = icReplaceS("", "##",NULL,1); 4601 ck_assert_str_eq(s, ""); 4602 free(s); 4603 // empty old delimiter 4604 ck_assert_ptr_eq(icReplaceS("qwe", "","|",1), NULL); 4605 // NULL old delimiter 4606 ck_assert_ptr_eq(icReplaceS("qwe", NULL,"|",1), NULL); 4607 // NULL string 4608 ck_assert_ptr_eq(icReplaceS(NULL, "##","|",1), NULL); 4609 // empty old delimiter 4610 ck_assert_ptr_eq(icReplaceS("AA##ee##ee#", "","|",1), NULL); 4611 4612 4613 } 4614 4615 4616 void iicReplaceST(CuTest *tc UNUSED) { 4617 4618 char *s; 4619 char *r = null; 4620 4621 // replace string, multiple character new delimeter 4622 s = strdup("#EE#ee#ad"); 4623 r = iicReplaceS(&s, "EE","VV", 0); 4624 ck_assert_ptr_eq(r, s); 4625 ck_assert_str_eq(s, "#VV#VV#ad"); 4626 free(s); 4627 // iicReplaceCharSS 4628 s = strdup("#EE#ee#ad"); 4629 s = iicReplaceCharSS(&s, 'e',"V", 0); 4630 ck_assert_str_eq(s, "#VV#VV#ad"); 4631 free(s); 4632 // iicReplaceSCharS 4633 s = strdup("#EE#ee#ad"); 4634 s = iicReplaceSCharS(&s, "e",'V', 0); 4635 ck_assert_str_eq(s, "#VV#VV#ad"); 4636 free(s); 4637 // iicReplaceCharCharS 4638 s = strdup("#EE#ee#ad"); 4639 s = iicReplaceCharCharS(&s, 'e','V', 0); 4640 ck_assert_str_eq(s, "#VV#VV#ad"); 4641 free(s); 4642 // replace string, multiple character old delimeter 4643 s = strdup("AA##ee##ee#"); 4644 r = iicReplaceS(&s, "##","|", 0); 4645 ck_assert_ptr_eq(r, s); 4646 ck_assert_str_eq(s, "AA|ee|ee#"); 4647 free(s); 4648 // replace one time at the start of string 4649 s = strdup("#ee#ee#ad"); 4650 r = iicReplaceS(&s, "#","^^",1); 4651 ck_assert_ptr_eq(r, s); 4652 ck_assert_str_eq(s, "^^ee#ee#ad"); 4653 free(s); 4654 // replace one time 4655 s = strdup("AA##ee##ee#"); 4656 r = iicReplaceS(&s, "##","|",1); 4657 ck_assert_ptr_eq(r, s); 4658 ck_assert_str_eq(s, "AA|ee##ee#"); 4659 free(s); 4660 // NULL new delimiter, one time: same as empty delimiter 4661 s = strdup("AA##ee##ee#"); 4662 r = iicReplaceS(&s, "##",NULL,1); 4663 ck_assert_ptr_eq(r, s); 4664 ck_assert_str_eq(s, "AAee##ee#"); 4665 free(s); 4666 // empty string 4667 emptyS(s); 4668 r = iicReplaceS(&s, "##",NULL,1); 4669 ck_assert_ptr_eq(r, null); 4670 ck_assert_str_eq(s, ""); 4671 free(s); 4672 // empty old delimiter 4673 s = strdup("qwe"); 4674 r = iicReplaceS(&s, "","|",1); 4675 ck_assert_ptr_eq(r, null); 4676 ck_assert_str_eq(s, "qwe"); 4677 free(s); 4678 // NULL old delimiter 4679 s = strdup("qwe"); 4680 r = iicReplaceS(&s, NULL,"|",1); 4681 ck_assert_ptr_eq(r, null); 4682 ck_assert_str_eq(s, "qwe"); 4683 free(s); 4684 // NULL string 4685 s = NULL; 4686 r = iicReplaceS(&s, "##","|",1); 4687 ck_assert_ptr_eq(r, null); 4688 // NULL var 4689 r = iicReplaceS(NULL, "##","|",1); 4690 ck_assert_ptr_eq(r, null); 4691 4692 4693 } 4694 4695 4696 void bicReplaceST(CuTest *tc UNUSED) { 4697 4698 char s[100]; 4699 char *r = null; 4700 4701 // replace string, multiple character new delimeter 4702 strcpy(s, "#EE#ee#ad"); 4703 r = bicReplaceS(s, "ee","VV", 0); 4704 ck_assert_ptr_eq(r, s); 4705 ck_assert_str_eq(s, "#VV#VV#ad"); 4706 // replace string, multiple character old delimeter 4707 strcpy(s, "AA##ee##ee#"); 4708 r = bicReplaceS(s, "##","|", 0); 4709 ck_assert_ptr_eq(r, s); 4710 ck_assert_str_eq(s, "AA|ee|ee#"); 4711 // replace one time at the start of string 4712 strcpy(s, "#ee#ee#ad"); 4713 r = bicReplaceS(s, "#","^^",1); 4714 ck_assert_ptr_eq(r, s); 4715 ck_assert_str_eq(s, "^^ee#ee#ad"); 4716 // replace one time 4717 strcpy(s, "AA##ee##ee#"); 4718 r = bicReplaceS(s, "##","|",1); 4719 ck_assert_ptr_eq(r, s); 4720 ck_assert_str_eq(s, "AA|ee##ee#"); 4721 // NULL new delimiter, one time: same as empty delimiter 4722 strcpy(s, "AA##ee##ee#"); 4723 r = bicReplaceS(s, "##",NULL,1); 4724 ck_assert_ptr_eq(r, s); 4725 ck_assert_str_eq(s, "AAee##ee#"); 4726 // empty string 4727 bEmptyS(s); 4728 r = bicReplaceS(s, "##",NULL,1); 4729 ck_assert_ptr_eq(r, null); 4730 ck_assert_str_eq(s, ""); 4731 // empty old delimiter 4732 strcpy(s, "qwe"); 4733 r = bicReplaceS(s, "","|",1); 4734 ck_assert_ptr_eq(r, null); 4735 ck_assert_str_eq(s, "qwe"); 4736 // NULL old delimiter 4737 strcpy(s, "qwe"); 4738 r = bicReplaceS(s, NULL,"|",1); 4739 ck_assert_ptr_eq(r, null); 4740 ck_assert_str_eq(s, "qwe"); 4741 // NULL var 4742 r = bicReplaceS(NULL, "##","|",1); 4743 ck_assert_ptr_eq(r, null); 4744 4745 4746 } 4747 4748 4749 void bLicReplaceST(CuTest *tc UNUSED) { 4750 4751 char s[100]; 4752 char *r = null; 4753 4754 // replace string, multiple character new delimeter 4755 strcpy(s, "#ee#EE#ad"); 4756 r = bLicReplaceS(s, sizeof s, "ee","vv", 0); 4757 ck_assert_ptr_eq(r, s); 4758 ck_assert_str_eq(s, "#vv#vv#ad"); 4759 // shorter buffer 4760 strcpy(s, "#ee#ee#ad"); 4761 r = bLicReplaceS(s, 5, "#","^^", 0); 4762 ck_assert_ptr_eq(r, s); 4763 ck_assert_str_eq(s, "^^ee"); 4764 // replace string, multiple character old delimeter 4765 strcpy(s, "AA##ee##ee#"); 4766 r = bLicReplaceS(s, sizeof s, "##","|", 0); 4767 ck_assert_ptr_eq(r, s); 4768 ck_assert_str_eq(s, "AA|ee|ee#"); 4769 // replace one time at the start of string 4770 strcpy(s, "#ee#ee#ad"); 4771 r = bLicReplaceS(s, sizeof s, "#","^^",1); 4772 ck_assert_ptr_eq(r, s); 4773 ck_assert_str_eq(s, "^^ee#ee#ad"); 4774 // replace one time 4775 strcpy(s, "AA##ee##ee#"); 4776 r = bLicReplaceS(s, sizeof s, "##","|",1); 4777 ck_assert_ptr_eq(r, s); 4778 ck_assert_str_eq(s, "AA|ee##ee#"); 4779 // NULL new delimiter, one time: same as empty delimiter 4780 strcpy(s, "AA##ee##ee#"); 4781 r = bLicReplaceS(s, sizeof s, "##",NULL,1); 4782 ck_assert_ptr_eq(r, s); 4783 ck_assert_str_eq(s, "AAee##ee#"); 4784 // empty string 4785 bEmptyS(s); 4786 r = bLicReplaceS(s, sizeof s, "##",NULL,1); 4787 ck_assert_ptr_eq(r, null); 4788 ck_assert_str_eq(s, ""); 4789 // empty old delimiter 4790 strcpy(s, "qwe"); 4791 r = bLicReplaceS(s, sizeof s, "","|",1); 4792 ck_assert_ptr_eq(r, null); 4793 ck_assert_str_eq(s, "qwe"); 4794 // NULL old delimiter 4795 strcpy(s, "qwe"); 4796 r = bLicReplaceS(s, sizeof s, NULL,"|",1); 4797 ck_assert_ptr_eq(r, null); 4798 ck_assert_str_eq(s, "qwe"); 4799 // size 0 - no change 4800 strcpy(s, "qwe"); 4801 r = bLicReplaceS(s, 0, "q","|",1); 4802 ck_assert_ptr_eq(r, s); 4803 ck_assert_str_eq(s, "qwe"); 4804 // NULL var 4805 r = bLicReplaceS(NULL, sizeof s, "##","|",1); 4806 ck_assert_ptr_eq(r, null); 4807 4808 4809 } 4810 4811 4812 void replaceManyST(CuTest *tc UNUSED) { 4813 4814 // replace string, multiple character new delimeter 4815 char *s = replaceManyS("#ee#ee#ad", "#","^^","ad","AD"); 4816 ck_assert_str_eq(s, "^^ee^^ee^^AD"); 4817 free(s); 4818 // replace string, empty new delimeter 4819 s = replaceManyS("#ee#ee#ad", "#","","ad","AD"); 4820 ck_assert_str_eq(s, "eeeeAD"); 4821 free(s); 4822 // not enough olds:news pairs 4823 s = replaceManyS("#ee#ee#ad", "#","","ad"); 4824 ck_assert_str_eq(s, "eeeead"); 4825 free(s); 4826 // only 2 parameters 4827 s = replaceManyS("#ee#ee#ad", "#"); 4828 ck_assert_ptr_eq(s, NULL); 4829 free(s); 4830 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 4831 s = replaceManyS("AA##ee##ee#", "##",NULL); 4832 ck_assert_ptr_eq(s, NULL); 4833 free(s); 4834 // empty string 4835 s = replaceManyS("", "##", ""); 4836 ck_assert_str_eq(s, ""); 4837 free(s); 4838 // empty string many pairs 4839 s = replaceManyS("", "##", "", "$$", ""); 4840 ck_assert_str_eq(s, ""); 4841 free(s); 4842 // empty string many pairs empty olds 4843 s = replaceManyS("", "##", "", "", ""); 4844 ck_assert_str_eq(s, ""); 4845 free(s); 4846 // empty string and NULL old delimiter 4847 s = replaceManyS("", NULL,"|"); 4848 ck_assert_str_eq(s, ""); 4849 free(s); 4850 // empty string and NULL old delimiter not first - same as replace empty string 4851 s = replaceManyS("","##","|", NULL,"|"); 4852 ck_assert_str_eq(s, ""); 4853 free(s); 4854 // empty old delimiter 4855 ck_assert_ptr_eq(replaceManyS("AA##ee##ee#", "","|", "AA", "BB"), NULL); 4856 // empty old delimiter not first 4857 ck_assert_ptr_eq(replaceManyS("AA##ee##ee#", "##","|", "", "BB"), NULL); 4858 // NULL string 4859 ck_assert_ptr_eq(replaceManyS(NULL, "##","|"), NULL); 4860 // NULL string many pairs 4861 ck_assert_ptr_eq(replaceManyS(NULL, "##","|", "$$", ""), NULL); 4862 4863 } 4864 4865 4866 void iReplaceManyST(CuTest *tc UNUSED) { 4867 4868 char *s; 4869 char *r = null; 4870 4871 // replace string, multiple character new delimeter 4872 s = strdup("#ee#ee#ad"); 4873 r = iReplaceManyS(&s, "#","^^","ad","AD"); 4874 ck_assert_ptr_eq(r, s); 4875 ck_assert_str_eq(s, "^^ee^^ee^^AD"); 4876 free(s); 4877 // replace string, empty new delimeter 4878 s = strdup("#ee#ee#ad"); 4879 r = iReplaceManyS(&s, "#","","ad","AD"); 4880 ck_assert_ptr_eq(r, s); 4881 ck_assert_str_eq(s, "eeeeAD"); 4882 free(s); 4883 // not enough olds:news pairs 4884 s = strdup("#ee#ee#ad"); 4885 r = iReplaceManyS(&s, "#","","ad"); 4886 ck_assert_ptr_eq(r, s); 4887 ck_assert_str_eq(s, "eeeead"); 4888 free(s); 4889 // only 2 parameters 4890 // doesn't compile 4891 /* s = strdup("#ee#ee#ad"); */ 4892 /* iReplaceManyS(&s, "#"); */ 4893 /* ck_assert_str_eq(s, "#ee#ee#ad"); */ 4894 /* free(s); */ 4895 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 4896 s = strdup("#ee#ee#ad"); 4897 r = iReplaceManyS(&s, "#", NULL); 4898 ck_assert_ptr_eq(r, s); 4899 ck_assert_str_eq(s, "#ee#ee#ad"); 4900 free(s); 4901 // empty string 4902 emptyS(s); 4903 r = iReplaceManyS(&s, "#", ""); 4904 ck_assert_ptr_eq(r, null); 4905 ck_assert_str_eq(s, ""); 4906 free(s); 4907 // empty string many pairs 4908 emptyS(s); 4909 r = iReplaceManyS(&s, "#", "", "%", ""); 4910 ck_assert_ptr_eq(r, null); 4911 ck_assert_str_eq(s, ""); 4912 free(s); 4913 // many pairs empty olds 4914 s = strdup("qw#e"); 4915 r = iReplaceManyS(&s, "#", "", "", ""); 4916 ck_assert_ptr_eq(r, s); 4917 ck_assert_str_eq(s, "qwe"); 4918 free(s); 4919 // NULL old delimiter 4920 s = strdup("qw#e"); 4921 r = iReplaceManyS(&s, NULL, ""); 4922 ck_assert_ptr_eq(r, s); 4923 ck_assert_str_eq(s, "qw#e"); 4924 free(s); 4925 // NULL old delimiter not first - same as replace empty string 4926 s = strdup("qw#e"); 4927 r = iReplaceManyS(&s, "#","|", NULL, ""); 4928 ck_assert_ptr_eq(r, s); 4929 ck_assert_str_eq(s, "qw|e"); 4930 free(s); 4931 // empty old delimiter 4932 s = strdup("qw#e"); 4933 r = iReplaceManyS(&s, "","|", NULL, ""); 4934 ck_assert_ptr_eq(r, s); 4935 ck_assert_str_eq(s, "qw#e"); 4936 free(s); 4937 // empty old delimiter not first 4938 s = strdup("qw#e"); 4939 r = iReplaceManyS(&s, "#","|", "", "*"); 4940 ck_assert_ptr_eq(r, s); 4941 ck_assert_str_eq(s, "qw|e"); 4942 free(s); 4943 // NULL string 4944 s = NULL; 4945 r = iReplaceManyS(&s, "#","|", "$", "*"); 4946 ck_assert_ptr_eq(r, null); 4947 ck_assert_ptr_eq(s, NULL); 4948 free(s); 4949 // NULL var 4950 r = iReplaceManyS(NULL, "#","|", "$", "*"); 4951 ck_assert_ptr_eq(r, null); 4952 4953 } 4954 4955 4956 void bReplaceManyST(CuTest *tc UNUSED) { 4957 4958 char s[100]; 4959 char *r = null; 4960 4961 // replace string, multiple character new delimeter 4962 strcpy(s, "#ee#ee#ad"); 4963 r = bReplaceManyS(s, "#","^^","ad","AD"); 4964 ck_assert_ptr_eq(r, s); 4965 ck_assert_str_eq(s, "^^ee^^ee^^AD"); 4966 // replace string, empty new delimeter 4967 strcpy(s, "#ee#ee#ad"); 4968 r = bReplaceManyS(s, "#","","ad","AD"); 4969 ck_assert_ptr_eq(r, s); 4970 ck_assert_str_eq(s, "eeeeAD"); 4971 // not enough olds:news pairs 4972 strcpy(s, "#ee#ee#ad"); 4973 r = bReplaceManyS(s, "#","","ad"); 4974 ck_assert_ptr_eq(r, s); 4975 ck_assert_str_eq(s, "eeeead"); 4976 // only 2 parameters 4977 // doesn't compile 4978 /* strcpy(s, "#ee#ee#ad"); */ 4979 /* bReplaceManyS(s, "#"); */ 4980 /* ck_assert_str_eq(s, "#ee#ee#ad"); */ 4981 /* free(s); */ 4982 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 4983 strcpy(s, "#ee#ee#ad"); 4984 r = bReplaceManyS(s, "#", NULL); 4985 ck_assert_ptr_eq(r, s); 4986 ck_assert_str_eq(s, "#ee#ee#ad"); 4987 // empty string 4988 bEmptyS(s); 4989 r = bReplaceManyS(s, "#", ""); 4990 ck_assert_ptr_eq(r, null); 4991 ck_assert_str_eq(s, ""); 4992 // empty string many pairs 4993 bEmptyS(s); 4994 r = bReplaceManyS(s, "#", "", "%", ""); 4995 ck_assert_ptr_eq(r, null); 4996 ck_assert_str_eq(s, ""); 4997 // many pairs empty olds 4998 strcpy(s, "qw#e"); 4999 r = bReplaceManyS(s, "#", "", "", ""); 5000 ck_assert_ptr_eq(r, s); 5001 ck_assert_str_eq(s, "qwe"); 5002 // NULL old delimiter 5003 strcpy(s, "qw#e"); 5004 r = bReplaceManyS(s, NULL, ""); 5005 ck_assert_ptr_eq(r, s); 5006 ck_assert_str_eq(s, "qw#e"); 5007 // NULL old delimiter not first - same as replace empty string 5008 strcpy(s, "qw#e"); 5009 r = bReplaceManyS(s, "#","|", NULL, ""); 5010 ck_assert_ptr_eq(r, s); 5011 ck_assert_str_eq(s, "qw|e"); 5012 // empty old delimiter 5013 strcpy(s, "qw#e"); 5014 r = bReplaceManyS(s, "","|", NULL, ""); 5015 ck_assert_ptr_eq(r, s); 5016 ck_assert_str_eq(s, "qw#e"); 5017 // empty old delimiter not first 5018 strcpy(s, "qw#e"); 5019 r = bReplaceManyS(s, "#","|", "", "*"); 5020 ck_assert_ptr_eq(r, s); 5021 ck_assert_str_eq(s, "qw|e"); 5022 // NULL var 5023 r = bReplaceManyS(NULL, "#","|", "$", "*"); 5024 ck_assert_ptr_eq(r, null); 5025 5026 } 5027 5028 5029 void bLReplaceManyST(CuTest *tc UNUSED) { 5030 5031 char s[100]; 5032 char *r = null; 5033 5034 // replace string, multiple character new delimeter 5035 strcpy(s, "#ee#ee#ad"); 5036 r = bLReplaceManyS(s, sizeof s, "#","^^","ad","AD"); 5037 ck_assert_ptr_eq(r, s); 5038 ck_assert_str_eq(s, "^^ee^^ee^^AD"); 5039 // shorter buffer 5040 strcpy(s, "#ee#ee#ad"); 5041 r = bLReplaceManyS(s, 5, "#","^^","ad","AD"); 5042 ck_assert_ptr_eq(r, s); 5043 ck_assert_str_eq(s, "^^ee"); 5044 // replace string, empty new delimeter 5045 strcpy(s, "#ee#ee#ad"); 5046 r = bLReplaceManyS(s, sizeof s, "#","","ad","AD"); 5047 ck_assert_ptr_eq(r, s); 5048 ck_assert_str_eq(s, "eeeeAD"); 5049 // not enough olds:news pairs 5050 strcpy(s, "#ee#ee#ad"); 5051 r = bLReplaceManyS(s, sizeof s, "#","","ad"); 5052 ck_assert_ptr_eq(r, s); 5053 ck_assert_str_eq(s, "eeeead"); 5054 // only 2 parameters 5055 // doesn't compile 5056 /* strcpy(s, "#ee#ee#ad"); */ 5057 /* bLReplaceManyS(s, sizeof s, "#"); */ 5058 /* ck_assert_str_eq(s, "#ee#ee#ad"); */ 5059 /* free(s); */ 5060 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 5061 strcpy(s, "#ee#ee#ad"); 5062 r = bLReplaceManyS(s, sizeof s, "#", NULL); 5063 ck_assert_ptr_eq(r, s); 5064 ck_assert_str_eq(s, "#ee#ee#ad"); 5065 // empty string 5066 bEmptyS(s); 5067 r = bLReplaceManyS(s, sizeof s, "#", ""); 5068 ck_assert_ptr_eq(r, null); 5069 ck_assert_str_eq(s, ""); 5070 // empty string many pairs 5071 bEmptyS(s); 5072 r = bLReplaceManyS(s, sizeof s, "#", "", "%", ""); 5073 ck_assert_ptr_eq(r, null); 5074 ck_assert_str_eq(s, ""); 5075 // many pairs empty olds 5076 strcpy(s, "qw#e"); 5077 r = bLReplaceManyS(s, sizeof s, "#", "", "", ""); 5078 ck_assert_ptr_eq(r, s); 5079 ck_assert_str_eq(s, "qwe"); 5080 // NULL old delimiter 5081 strcpy(s, "qw#e"); 5082 r = bLReplaceManyS(s, sizeof s, NULL, ""); 5083 ck_assert_ptr_eq(r, s); 5084 ck_assert_str_eq(s, "qw#e"); 5085 // NULL old delimiter not first - same as replace empty string 5086 strcpy(s, "qw#e"); 5087 r = bLReplaceManyS(s, sizeof s, "#","|", NULL, ""); 5088 ck_assert_ptr_eq(r, s); 5089 ck_assert_str_eq(s, "qw|e"); 5090 // empty old delimiter 5091 strcpy(s, "qw#e"); 5092 r = bLReplaceManyS(s, sizeof s, "","|", NULL, ""); 5093 ck_assert_ptr_eq(r, s); 5094 ck_assert_str_eq(s, "qw#e"); 5095 // empty old delimiter not first 5096 strcpy(s, "qw#e"); 5097 r = bLReplaceManyS(s, sizeof s, "#","|", "", "*"); 5098 ck_assert_ptr_eq(r, s); 5099 ck_assert_str_eq(s, "qw|e"); 5100 // size 0 - no change 5101 r = bLReplaceManyS(s, 0, "#","|", "", "*"); 5102 ck_assert_ptr_eq(r, s); 5103 ck_assert_str_eq(s, "qw|e"); 5104 // NULL var 5105 r = bLReplaceManyS(NULL, sizeof s, "#","|", "$", "*"); 5106 ck_assert_ptr_eq(r, null); 5107 5108 } 5109 5110 5111 void icReplaceManyST(CuTest *tc UNUSED) { 5112 5113 // replace string, multiple character new delimeter 5114 char *s = icReplaceManyS("#ee#ee#ad", "#","^^","AD","vv"); 5115 ck_assert_str_eq(s, "^^ee^^ee^^vv"); 5116 free(s); 5117 // replace string, empty new delimeter 5118 s = icReplaceManyS("#ee#ee#ad", "#","","ad","AD"); 5119 ck_assert_str_eq(s, "eeeeAD"); 5120 free(s); 5121 // not enough olds:news pairs 5122 s = icReplaceManyS("#ee#ee#ad", "#","","ad"); 5123 ck_assert_str_eq(s, "eeeead"); 5124 free(s); 5125 // only 2 parameters 5126 s = icReplaceManyS("#ee#ee#ad", "#"); 5127 ck_assert_ptr_eq(s, NULL); 5128 free(s); 5129 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 5130 s = icReplaceManyS("AA##ee##ee#", "##",NULL); 5131 ck_assert_ptr_eq(s, NULL); 5132 free(s); 5133 // empty string 5134 s = icReplaceManyS("", "##", ""); 5135 ck_assert_str_eq(s, ""); 5136 free(s); 5137 // empty string many pairs 5138 s = icReplaceManyS("", "##", "", "$$", ""); 5139 ck_assert_str_eq(s, ""); 5140 free(s); 5141 // empty string many pairs empty olds 5142 s = icReplaceManyS("", "##", "", "", ""); 5143 ck_assert_str_eq(s, ""); 5144 free(s); 5145 // empty string and NULL old delimiter 5146 s = icReplaceManyS("", NULL,"|"); 5147 ck_assert_str_eq(s, ""); 5148 free(s); 5149 // empty string and NULL old delimiter not first - same as replace empty string 5150 s = icReplaceManyS("","##","|", NULL,"|"); 5151 ck_assert_str_eq(s, ""); 5152 free(s); 5153 // empty old delimiter 5154 ck_assert_ptr_eq(icReplaceManyS("AA##ee##ee#", "","|", "AA", "BB"), NULL); 5155 // empty old delimiter not first 5156 ck_assert_ptr_eq(icReplaceManyS("AA##ee##ee#", "##","|", "", "BB"), NULL); 5157 // NULL string 5158 ck_assert_ptr_eq(icReplaceManyS(NULL, "##","|"), NULL); 5159 // NULL string many pairs 5160 ck_assert_ptr_eq(icReplaceManyS(NULL, "##","|", "$$", ""), NULL); 5161 5162 5163 } 5164 5165 5166 void iicReplaceManyST(CuTest *tc UNUSED) { 5167 5168 char *s; 5169 char *r = null; 5170 5171 // replace string, multiple character new delimeter 5172 s = strdup("#ee#ee#ad"); 5173 r = iicReplaceManyS(&s, "#","^^","ad","vv"); 5174 ck_assert_ptr_eq(r, s); 5175 ck_assert_str_eq(s, "^^ee^^ee^^vv"); 5176 free(s); 5177 // replace string, empty new delimeter 5178 s = strdup("#ee#ee#ad"); 5179 r = iicReplaceManyS(&s, "#","","ad","AD"); 5180 ck_assert_ptr_eq(r, s); 5181 ck_assert_str_eq(s, "eeeeAD"); 5182 free(s); 5183 // not enough olds:news pairs 5184 s = strdup("#ee#ee#ad"); 5185 r = iicReplaceManyS(&s, "#","","ad"); 5186 ck_assert_ptr_eq(r, s); 5187 ck_assert_str_eq(s, "eeeead"); 5188 free(s); 5189 // only 2 parameters 5190 // doesn't compile 5191 /* s = strdup("#ee#ee#ad"); */ 5192 /* iicReplaceManyS(&s, "#"); */ 5193 /* ck_assert_str_eq(s, "#ee#ee#ad"); */ 5194 /* free(s); */ 5195 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 5196 s = strdup("#ee#ee#ad"); 5197 r = iicReplaceManyS(&s, "#", NULL); 5198 ck_assert_ptr_eq(r, s); 5199 ck_assert_str_eq(s, "#ee#ee#ad"); 5200 free(s); 5201 // empty string 5202 emptyS(s); 5203 r = iicReplaceManyS(&s, "#", ""); 5204 ck_assert_ptr_eq(r, null); 5205 ck_assert_str_eq(s, ""); 5206 free(s); 5207 // empty string many pairs 5208 emptyS(s); 5209 r = iicReplaceManyS(&s, "#", "", "%", ""); 5210 ck_assert_ptr_eq(r, null); 5211 ck_assert_str_eq(s, ""); 5212 free(s); 5213 // many pairs empty olds 5214 s = strdup("qw#e"); 5215 r = iicReplaceManyS(&s, "#", "", "", ""); 5216 ck_assert_ptr_eq(r, s); 5217 ck_assert_str_eq(s, "qwe"); 5218 free(s); 5219 // NULL old delimiter 5220 s = strdup("qw#e"); 5221 r = iicReplaceManyS(&s, NULL, ""); 5222 ck_assert_ptr_eq(r, s); 5223 ck_assert_str_eq(s, "qw#e"); 5224 free(s); 5225 // NULL old delimiter not first - same as replace empty string 5226 s = strdup("qw#e"); 5227 r = iicReplaceManyS(&s, "#","|", NULL, ""); 5228 ck_assert_ptr_eq(r, s); 5229 ck_assert_str_eq(s, "qw|e"); 5230 free(s); 5231 // empty old delimiter 5232 s = strdup("qw#e"); 5233 r = iicReplaceManyS(&s, "","|", NULL, ""); 5234 ck_assert_ptr_eq(r, s); 5235 ck_assert_str_eq(s, "qw#e"); 5236 free(s); 5237 // empty old delimiter not first 5238 s = strdup("qw#e"); 5239 r = iicReplaceManyS(&s, "#","|", "", "*"); 5240 ck_assert_ptr_eq(r, s); 5241 ck_assert_str_eq(s, "qw|e"); 5242 free(s); 5243 // NULL string 5244 s = NULL; 5245 r = iicReplaceManyS(&s, "#","|", "$", "*"); 5246 ck_assert_ptr_eq(r, null); 5247 ck_assert_ptr_eq(s, NULL); 5248 free(s); 5249 // NULL var 5250 r = iicReplaceManyS(NULL, "#","|", "$", "*"); 5251 ck_assert_ptr_eq(r, null); 5252 5253 5254 } 5255 5256 5257 void bicReplaceManyST(CuTest *tc UNUSED) { 5258 5259 char s[100]; 5260 char *r = null; 5261 5262 // replace string, multiple character new delimeter 5263 strcpy(s, "#ee#ee#ad"); 5264 r = bicReplaceManyS(s, "#","^^","AD","vv"); 5265 ck_assert_ptr_eq(r, s); 5266 ck_assert_str_eq(s, "^^ee^^ee^^vv"); 5267 // replace string, empty new delimeter 5268 strcpy(s, "#ee#ee#ad"); 5269 r = bicReplaceManyS(s, "#","","ad","AD"); 5270 ck_assert_ptr_eq(r, s); 5271 ck_assert_str_eq(s, "eeeeAD"); 5272 // not enough olds:news pairs 5273 strcpy(s, "#ee#ee#ad"); 5274 r = bicReplaceManyS(s, "#","","ad"); 5275 ck_assert_ptr_eq(r, s); 5276 ck_assert_str_eq(s, "eeeead"); 5277 // only 2 parameters 5278 // doesn't compile 5279 /* strcpy(s, "#ee#ee#ad"); */ 5280 /* bicReplaceManyS(s, "#"); */ 5281 /* ck_assert_str_eq(s, "#ee#ee#ad"); */ 5282 /* free(s); */ 5283 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 5284 strcpy(s, "#ee#ee#ad"); 5285 r = bicReplaceManyS(s, "#", NULL); 5286 ck_assert_ptr_eq(r, s); 5287 ck_assert_str_eq(s, "#ee#ee#ad"); 5288 // empty string 5289 bEmptyS(s); 5290 r = bicReplaceManyS(s, "#", ""); 5291 ck_assert_ptr_eq(r, null); 5292 ck_assert_str_eq(s, ""); 5293 // empty string many pairs 5294 bEmptyS(s); 5295 r = bicReplaceManyS(s, "#", "", "%", ""); 5296 ck_assert_ptr_eq(r, null); 5297 ck_assert_str_eq(s, ""); 5298 // many pairs empty olds 5299 strcpy(s, "qw#e"); 5300 r = bicReplaceManyS(s, "#", "", "", ""); 5301 ck_assert_ptr_eq(r, s); 5302 ck_assert_str_eq(s, "qwe"); 5303 // NULL old delimiter 5304 strcpy(s, "qw#e"); 5305 r = bicReplaceManyS(s, NULL, ""); 5306 ck_assert_ptr_eq(r, s); 5307 ck_assert_str_eq(s, "qw#e"); 5308 // NULL old delimiter not first - same as replace empty string 5309 strcpy(s, "qw#e"); 5310 r = bicReplaceManyS(s, "#","|", NULL, ""); 5311 ck_assert_ptr_eq(r, s); 5312 ck_assert_str_eq(s, "qw|e"); 5313 // empty old delimiter 5314 strcpy(s, "qw#e"); 5315 r = bicReplaceManyS(s, "","|", NULL, ""); 5316 ck_assert_ptr_eq(r, s); 5317 ck_assert_str_eq(s, "qw#e"); 5318 // empty old delimiter not first 5319 strcpy(s, "qw#e"); 5320 r = bicReplaceManyS(s, "#","|", "", "*"); 5321 ck_assert_ptr_eq(r, s); 5322 ck_assert_str_eq(s, "qw|e"); 5323 // NULL var 5324 r = bicReplaceManyS(NULL, "#","|", "$", "*"); 5325 ck_assert_ptr_eq(r, null); 5326 5327 5328 } 5329 5330 5331 void bLicReplaceManyST(CuTest *tc UNUSED) { 5332 5333 char s[100]; 5334 char *r = null; 5335 5336 // replace string, multiple character new delimeter 5337 strcpy(s, "#ee#ee#ad"); 5338 r = bLicReplaceManyS(s, sizeof s, "#","^^","AD","vv"); 5339 ck_assert_ptr_eq(r, s); 5340 ck_assert_str_eq(s, "^^ee^^ee^^vv"); 5341 // shorter buffer 5342 strcpy(s, "#ee#ee#ad"); 5343 r = bLicReplaceManyS(s, 5, "#","^^","ad","AD"); 5344 ck_assert_ptr_eq(r, s); 5345 ck_assert_str_eq(s, "^^ee"); 5346 // replace string, empty new delimeter 5347 strcpy(s, "#ee#ee#ad"); 5348 r = bLicReplaceManyS(s, sizeof s, "#","","ad","AD"); 5349 ck_assert_ptr_eq(r, s); 5350 ck_assert_str_eq(s, "eeeeAD"); 5351 // not enough olds:news pairs 5352 strcpy(s, "#ee#ee#ad"); 5353 r = bLicReplaceManyS(s, sizeof s, "#","","ad"); 5354 ck_assert_ptr_eq(r, s); 5355 ck_assert_str_eq(s, "eeeead"); 5356 // only 2 parameters 5357 // doesn't compile 5358 /* strcpy(s, "#ee#ee#ad"); */ 5359 /* bLicReplaceManyS(s, sizeof s, "#"); */ 5360 /* ck_assert_str_eq(s, "#ee#ee#ad"); */ 5361 /* free(s); */ 5362 // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs 5363 strcpy(s, "#ee#ee#ad"); 5364 r = bLicReplaceManyS(s, sizeof s, "#", NULL); 5365 ck_assert_ptr_eq(r, s); 5366 ck_assert_str_eq(s, "#ee#ee#ad"); 5367 // empty string 5368 bEmptyS(s); 5369 r = bLicReplaceManyS(s, sizeof s, "#", ""); 5370 ck_assert_ptr_eq(r, null); 5371 ck_assert_str_eq(s, ""); 5372 // empty string many pairs 5373 bEmptyS(s); 5374 r = bLicReplaceManyS(s, sizeof s, "#", "", "%", ""); 5375 ck_assert_ptr_eq(r, null); 5376 ck_assert_str_eq(s, ""); 5377 // many pairs empty olds 5378 strcpy(s, "qw#e"); 5379 r = bLicReplaceManyS(s, sizeof s, "#", "", "", ""); 5380 ck_assert_ptr_eq(r, s); 5381 ck_assert_str_eq(s, "qwe"); 5382 // NULL old delimiter 5383 strcpy(s, "qw#e"); 5384 r = bLicReplaceManyS(s, sizeof s, NULL, ""); 5385 ck_assert_ptr_eq(r, s); 5386 ck_assert_str_eq(s, "qw#e"); 5387 // NULL old delimiter not first - same as replace empty string 5388 strcpy(s, "qw#e"); 5389 r = bLicReplaceManyS(s, sizeof s, "#","|", NULL, ""); 5390 ck_assert_ptr_eq(r, s); 5391 ck_assert_str_eq(s, "qw|e"); 5392 // empty old delimiter 5393 strcpy(s, "qw#e"); 5394 r = bLicReplaceManyS(s, sizeof s, "","|", NULL, ""); 5395 ck_assert_ptr_eq(r, s); 5396 ck_assert_str_eq(s, "qw#e"); 5397 // empty old delimiter not first 5398 strcpy(s, "qw#e"); 5399 r = bLicReplaceManyS(s, sizeof s, "#","|", "", "*"); 5400 ck_assert_ptr_eq(r, s); 5401 ck_assert_str_eq(s, "qw|e"); 5402 // size 0 - no change 5403 r = bLicReplaceManyS(s, 0, "#","|", "", "*"); 5404 ck_assert_ptr_eq(r, s); 5405 ck_assert_str_eq(s, "qw|e"); 5406 // NULL var 5407 r = bLicReplaceManyS(NULL, sizeof s, "#","|", "$", "*"); 5408 ck_assert_ptr_eq(r, null); 5409 5410 5411 } 5412 5413 5414 void eqST(CuTest *tc UNUSED) { 5415 5416 // identical strings 5417 ck_assert(eqS("shee", "shee")); 5418 // different strings 5419 ck_assert(!eqS("shee", "SH")); 5420 // empty strings 5421 ck_assert(!eqS("shee", "")); 5422 ck_assert(!eqS("", "SH")); 5423 ck_assert(eqS("", "")); 5424 // NULL string 5425 ck_assert(!eqS(NULL,"a")); 5426 ck_assert(!eqS("a", NULL)); 5427 5428 } 5429 5430 5431 void eqCharST(CuTest *tc UNUSED) { 5432 5433 // identical strings 5434 ck_assert(eqCharS('s', "s")); 5435 // different strings 5436 ck_assert(!eqCharS('s', "SH")); 5437 // empty strings 5438 ck_assert(!eqCharS('s', "")); 5439 ck_assert(!eqCharS(0, "SH")); 5440 ck_assert(eqCharS(0, "")); 5441 // NULL string 5442 ck_assert(!eqCharS(0,"a")); 5443 ck_assert(!eqCharS('a', NULL)); 5444 5445 } 5446 5447 5448 void eqSCharT(CuTest *tc UNUSED) { 5449 5450 // identical strings 5451 ck_assert(eqSChar("s", 's')); 5452 // different strings 5453 ck_assert(!eqSChar("shee", 'S')); 5454 // empty strings 5455 ck_assert(!eqSChar("shee", 0)); 5456 ck_assert(!eqSChar("", 'S')); 5457 ck_assert(eqSChar("", 0)); 5458 // NULL string 5459 ck_assert(!eqSChar(NULL,'a')); 5460 ck_assert(!eqS("a", 0)); 5461 5462 } 5463 5464 5465 void eqIST(CuTest *tc UNUSED) { 5466 5467 // identical strings 5468 ck_assert(eqIS("Ashee|", "shee", 1)); 5469 ck_assert(eqIS("Ashee", "shee", -4)); 5470 // string at index shorter than string2 5471 ck_assert(!eqIS("Ashee", "shee", 2)); 5472 // empty string 5473 ck_assert(!eqIS("", "shee", 0)); 5474 ck_assert(!eqIS("Ashee", "", 0)); 5475 ck_assert(eqIS("", "", 0)); 5476 // index mismatch 5477 ck_assert(!eqIS("Ashee", "shee", 0)); 5478 // index outside 5479 ck_assert(!eqIS("Ashee", "shee", 10)); 5480 ck_assert(!eqIS("Ashee", "shee", -10)); 5481 // different strings 5482 ck_assert(!eqIS("shee", "SH",0)); 5483 // NULL string 5484 ck_assert(!eqIS(NULL,"a", 0)); 5485 ck_assert(!eqIS("a", NULL, 0)); 5486 5487 } 5488 5489 5490 void eqICharST(CuTest *tc UNUSED) { 5491 5492 // identical strings 5493 ck_assert(eqICharS("Ashee", 's', 1)); 5494 ck_assert(eqICharS("Ashee", 's', -4)); 5495 // string at index shorter than string2 5496 ck_assert(!eqICharS("Ashee", 's', 2)); 5497 // empty string 5498 ck_assert(!eqICharS("", 's', 0)); 5499 ck_assert(!eqICharS("Ashee", 0, 0)); 5500 ck_assert(eqICharS("", 0, 0)); 5501 // index mismatch 5502 ck_assert(!eqICharS("Ashee", 's', 0)); 5503 // index outside 5504 ck_assert(!eqICharS("Ashee", 's', 10)); 5505 ck_assert(!eqICharS("Ashee", 's', -10)); 5506 // different strings 5507 ck_assert(!eqICharS("shee", 'S',0)); 5508 // NULL string 5509 ck_assert(!eqICharS(NULL,'a', 0)); 5510 ck_assert(!eqICharS("a", 0, 0)); 5511 5512 } 5513 5514 5515 void startsWithST(CuTest *tc UNUSED) { 5516 5517 // identical strings 5518 ck_assert(startsWithS("shee", "shee")); 5519 ck_assert(startsWithS("sheepy", "shee")); 5520 // different strings 5521 ck_assert(!startsWithS("shee", "SH")); 5522 ck_assert(!startsWithS("shee", "sheep")); 5523 ck_assert(!startsWithS("-shee", "shee")); 5524 // NULL string 5525 ck_assert(!startsWithS(NULL,"a")); 5526 ck_assert(!startsWithS("a", NULL)); 5527 5528 } 5529 5530 5531 void startsWithCharST(CuTest *tc UNUSED) { 5532 5533 // identical strings 5534 ck_assert(startsWithCharS("shee", 's')); 5535 ck_assert(startsWithCharS("sheepy", 's')); 5536 ck_assert(startsWithCharS("", 0)); 5537 // different strings 5538 ck_assert(!startsWithCharS("shee", 'S')); 5539 ck_assert(!startsWithCharS("-shee", 's')); 5540 ck_assert(!startsWithCharS("", '0')); 5541 // NULL string 5542 ck_assert(!startsWithCharS(NULL,'a')); 5543 ck_assert(!startsWithCharS("a", 0)); 5544 5545 } 5546 5547 5548 void endsWithST(CuTest *tc UNUSED) { 5549 5550 // identical strings 5551 ck_assert(endsWithS("shee", "shee")); 5552 ck_assert(endsWithS("sheepy", "eepy")); 5553 // different strings 5554 ck_assert(!endsWithS("shee", "SH")); 5555 ck_assert(!endsWithS("shee", "sheep")); 5556 ck_assert(!endsWithS("shee-", "shee")); 5557 // NULL string 5558 ck_assert(!endsWithS(NULL,"a")); 5559 ck_assert(!endsWithS("a", NULL)); 5560 5561 } 5562 5563 5564 void endsWithCharST(CuTest *tc UNUSED) { 5565 5566 // identical strings 5567 ck_assert(endsWithCharS("shee", 'e')); 5568 ck_assert(endsWithCharS("sheepy", 'y')); 5569 ck_assert(endsWithCharS("", 0)); 5570 // different strings 5571 ck_assert(!endsWithCharS("shee", 'E')); 5572 ck_assert(!endsWithCharS("shee", 'p')); 5573 ck_assert(!endsWithCharS("shee-", 'e')); 5574 ck_assert(!endsWithCharS("", '0')); 5575 // NULL string 5576 ck_assert(!endsWithCharS(NULL,'a')); 5577 ck_assert(!endsWithCharS("a", 0)); 5578 5579 } 5580 5581 5582 void countST(CuTest *tc UNUSED) { 5583 5584 // positive count 5585 ck_assert_int_eq(countS("shee", "shee"), 1); 5586 ck_assert_int_eq(countS("aaa aaa", "a"), 6); 5587 ck_assert_int_eq(countS("aaa aaa", "aa"), 2); 5588 // 0 count 5589 ck_assert_int_eq(countS("shee", "SH"), 0); 5590 ck_assert_int_eq(countS("shee", "sheepy"), 0); 5591 ck_assert_int_eq(countS("aaa aaa", "ab"), 0); 5592 // empty string 5593 ck_assert_int_eq(countS("shee", ""), -1); 5594 // NULL string 5595 ck_assert_int_eq(countS(NULL,"a"), -1); 5596 ck_assert_int_eq(countS("a", NULL), -1); 5597 5598 } 5599 5600 5601 void countCharST(CuTest *tc UNUSED) { 5602 5603 // positive count 5604 ck_assert_int_eq(countCharS("shee", 's'), 1); 5605 ck_assert_int_eq(countCharS("aaa aaa", 'a'), 6); 5606 // 0 count 5607 ck_assert_int_eq(countCharS("shee", 'S'), 0); 5608 ck_assert_int_eq(countCharS("shee", 'y'), 0); 5609 ck_assert_int_eq(countCharS("aaa aaa", 'b'), 0); 5610 // empty string 5611 ck_assert_int_eq(countCharS("", 'a'), 0); 5612 ck_assert_int_eq(countCharS("", 0), -1); 5613 // NULL string 5614 ck_assert_int_eq(countCharS(NULL,'a'), -1); 5615 ck_assert_int_eq(countCharS("a", 0), -1); 5616 5617 } 5618 5619 5620 void icEqST(CuTest *tc UNUSED) { 5621 5622 // identical strings 5623 ck_assert(icEqS("SHEE", "shee")); 5624 // different strings 5625 ck_assert(!icEqS("shee", "SH")); 5626 // empty strings 5627 ck_assert(!icEqS("shee", "")); 5628 ck_assert(!icEqS("", "SH")); 5629 ck_assert(icEqS("", "")); 5630 // NULL string 5631 ck_assert(!icEqS(NULL,"a")); 5632 ck_assert(!icEqS("a", NULL)); 5633 5634 5635 } 5636 5637 5638 void icEqCharST(CuTest *tc UNUSED) { 5639 5640 // identical strings 5641 ck_assert(icEqCharS('S', "s")); 5642 // different strings 5643 ck_assert(!icEqCharS('s', "SH")); 5644 // empty strings 5645 ck_assert(!icEqCharS('s', "")); 5646 ck_assert(!icEqCharS(0, "SH")); 5647 ck_assert(icEqCharS(0, "")); 5648 // NULL string 5649 ck_assert(!icEqCharS(0,"a")); 5650 ck_assert(!icEqCharS('a', NULL)); 5651 5652 5653 } 5654 5655 5656 void icEqSCharT(CuTest *tc UNUSED) { 5657 5658 // identical strings 5659 ck_assert(icEqSChar("S", 's')); 5660 // different strings 5661 ck_assert(!icEqSChar("shee", 'S')); 5662 // empty strings 5663 ck_assert(!icEqSChar("shee", 0)); 5664 ck_assert(!icEqSChar("", 'S')); 5665 ck_assert(icEqSChar("", 0)); 5666 // NULL string 5667 ck_assert(!icEqSChar(NULL,'a')); 5668 ck_assert(!eqS("a", 0)); 5669 5670 5671 } 5672 5673 5674 void icEqIST(CuTest *tc UNUSED) { 5675 5676 // identical strings 5677 ck_assert(icEqIS("AshEe|", "shee", 1)); 5678 ck_assert(icEqIS("AshEE", "shee", -4)); 5679 // string at index shorter than string2 5680 ck_assert(!icEqIS("Ashee", "shee", 2)); 5681 // empty string 5682 ck_assert(!icEqIS("", "shee", 0)); 5683 ck_assert(!icEqIS("Ashee", "", 0)); 5684 ck_assert(icEqIS("", "", 0)); 5685 // index mismatch 5686 ck_assert(!icEqIS("Ashee", "shee", 0)); 5687 // index outside 5688 ck_assert(!icEqIS("Ashee", "shee", 10)); 5689 ck_assert(!icEqIS("Ashee", "shee", -10)); 5690 // different strings 5691 ck_assert(!icEqIS("shee", "Sg",0)); 5692 // NULL string 5693 ck_assert(!icEqIS(NULL,"a", 0)); 5694 ck_assert(!icEqIS("a", NULL, 0)); 5695 5696 5697 } 5698 5699 5700 void icEqICharST(CuTest *tc UNUSED) { 5701 5702 // identical strings 5703 ck_assert(icEqICharS("ASHEE", 's', 1)); 5704 ck_assert(icEqICharS("Ashee", 's', -4)); 5705 // string at index shorter than string2 5706 ck_assert(!icEqICharS("Ashee", 's', 2)); 5707 // empty string 5708 ck_assert(!icEqICharS("", 's', 0)); 5709 ck_assert(!icEqICharS("Ashee", 0, 0)); 5710 ck_assert(icEqICharS("", 0, 0)); 5711 // index mismatch 5712 ck_assert(!icEqICharS("Ashee", 's', 0)); 5713 // index outside 5714 ck_assert(!icEqICharS("Ashee", 's', 10)); 5715 ck_assert(!icEqICharS("Ashee", 's', -10)); 5716 // different strings 5717 ck_assert(!icEqICharS("shee", 'd',0)); 5718 // NULL string 5719 ck_assert(!icEqICharS(NULL,'a', 0)); 5720 ck_assert(!icEqICharS("a", 0, 0)); 5721 5722 5723 } 5724 5725 5726 void icStartsWithST(CuTest *tc UNUSED) { 5727 5728 // identical strings 5729 ck_assert(icStartsWithS("SHEE", "shee")); 5730 ck_assert(icStartsWithS("SHEEPY", "shee")); 5731 // different strings 5732 ck_assert(!icStartsWithS("shee", "aH")); 5733 ck_assert(!icStartsWithS("shee", "sheep")); 5734 ck_assert(!icStartsWithS("-shee", "shee")); 5735 // NULL string 5736 ck_assert(!icStartsWithS(NULL,"a")); 5737 ck_assert(!icStartsWithS("a", NULL)); 5738 5739 5740 } 5741 5742 5743 void icStartsWithCharST(CuTest *tc UNUSED) { 5744 5745 // identical strings 5746 ck_assert(icStartsWithCharS("Shee", 's')); 5747 ck_assert(icStartsWithCharS("Sheepy", 's')); 5748 ck_assert(icStartsWithCharS("", 0)); 5749 // different strings 5750 ck_assert(!icStartsWithCharS("shee", 'a')); 5751 ck_assert(!icStartsWithCharS("-shee", 's')); 5752 ck_assert(!icStartsWithCharS("", '0')); 5753 // NULL string 5754 ck_assert(!icStartsWithCharS(NULL,'a')); 5755 ck_assert(!icStartsWithCharS("a", 0)); 5756 5757 5758 } 5759 5760 5761 void icEndsWithST(CuTest *tc UNUSED) { 5762 5763 // identical strings 5764 ck_assert(icEndsWithS("SHEE", "shee")); 5765 ck_assert(icEndsWithS("SHEEPY", "eepy")); 5766 // different strings 5767 ck_assert(!icEndsWithS("shee", "SH")); 5768 ck_assert(!icEndsWithS("shee", "sheep")); 5769 ck_assert(!icEndsWithS("shee-", "shee")); 5770 // NULL string 5771 ck_assert(!icEndsWithS(NULL,"a")); 5772 ck_assert(!icEndsWithS("a", NULL)); 5773 5774 5775 } 5776 5777 5778 void icEndsWithCharST(CuTest *tc UNUSED) { 5779 5780 // identical strings 5781 ck_assert(icEndsWithCharS("sheE", 'e')); 5782 ck_assert(icEndsWithCharS("sheepY", 'y')); 5783 ck_assert(icEndsWithCharS("", 0)); 5784 // different strings 5785 ck_assert(!icEndsWithCharS("shee", 'R')); 5786 ck_assert(!icEndsWithCharS("shee", 'p')); 5787 ck_assert(!icEndsWithCharS("shee-", 'e')); 5788 ck_assert(!icEndsWithCharS("", '0')); 5789 // NULL string 5790 ck_assert(!icEndsWithCharS(NULL,'a')); 5791 ck_assert(!icEndsWithCharS("a", 0)); 5792 5793 5794 } 5795 5796 5797 void icCountST(CuTest *tc UNUSED) { 5798 5799 // positive count 5800 ck_assert_int_eq(icCountS("SHEE", "shee"), 1); 5801 ck_assert_int_eq(icCountS("AAA AAA", "a"), 6); 5802 ck_assert_int_eq(icCountS("AAA AAA", "aa"), 2); 5803 // 0 count 5804 ck_assert_int_eq(icCountS("shee", "eSH"), 0); 5805 ck_assert_int_eq(icCountS("shee", "sheepy"), 0); 5806 ck_assert_int_eq(icCountS("aaa aaa", "ab"), 0); 5807 // empty needle 5808 ck_assert_int_eq(icCountS("aaa aaa", ""), -1); 5809 // NULL string 5810 ck_assert_int_eq(icCountS(NULL,"a"), -1); 5811 ck_assert_int_eq(icCountS("a", NULL), -1); 5812 5813 5814 } 5815 5816 5817 void icCountCharST(CuTest *tc UNUSED) { 5818 5819 // positive count 5820 ck_assert_int_eq(icCountCharS("Shee", 's'), 1); 5821 ck_assert_int_eq(icCountCharS("AAA aaa", 'a'), 6); 5822 // 0 count 5823 ck_assert_int_eq(icCountCharS("shee", '0'), 0); 5824 ck_assert_int_eq(icCountCharS("shee", 'y'), 0); 5825 ck_assert_int_eq(icCountCharS("aaa aaa", 'b'), 0); 5826 // empty string 5827 ck_assert_int_eq(icCountCharS("", 'a'), 0); 5828 ck_assert_int_eq(icCountCharS("", 0), -1); 5829 // NULL string 5830 ck_assert_int_eq(icCountCharS(NULL,'a'), -1); 5831 ck_assert_int_eq(icCountCharS("a", 0), -1); 5832 5833 5834 } 5835 5836 5837 void hasCtrlCharT(CuTest *tc UNUSED) { 5838 5839 // string with control char 5840 ck_assert(hasCtrlChar("\tsheepy\n")); 5841 // no control char 5842 ck_assert(!hasCtrlChar("sheepy")); 5843 // null string 5844 ck_assert(!hasCtrlChar(null)); 5845 5846 5847 } 5848 5849 5850 void stripCtrlST(CuTest *tc UNUSED) { 5851 5852 char *r; 5853 5854 // string with control char 5855 r = stripCtrlS("\tsheepy\n"); 5856 ck_assert_str_eq(r, "sheepy"); 5857 free(r); 5858 // no control char 5859 r = stripCtrlS("sheepy"); 5860 ck_assert_str_eq(r, "sheepy"); 5861 free(r); 5862 // null string 5863 r = stripCtrlS(null); 5864 ck_assert_ptr_eq(r, null); 5865 5866 5867 } 5868 5869 5870 void iStripCtrlST(CuTest *tc UNUSED) { 5871 5872 char *r, *s; 5873 5874 // string with control char 5875 s = strdup("\tsheepy\n"); 5876 r = iStripCtrlS(&s); 5877 ck_assert_str_eq(r, "sheepy"); 5878 free(r); 5879 // no control char 5880 s = strdup("sheepy"); 5881 r = iStripCtrlS(&s); 5882 ck_assert_str_eq(r, "sheepy"); 5883 free(r); 5884 // null string 5885 s = null; 5886 r = iStripCtrlS(&s); 5887 ck_assert_ptr_eq(r, null); 5888 r = iStripCtrlS(null); 5889 ck_assert_ptr_eq(r, null); 5890 5891 5892 } 5893 5894 5895 void bStripCtrlST(CuTest *tc UNUSED) { 5896 5897 char *r; 5898 char s[40]; 5899 5900 // string with control char 5901 r = strLCpy(s, sizeof(s), "\tsheepy\n"); 5902 ck_assert_ptr_eq(r, s); 5903 r = bStripCtrlS(s); 5904 ck_assert_str_eq(r, "sheepy"); 5905 // no control char 5906 r = strLCpy(s, sizeof(s), "sheepy"); 5907 ck_assert_ptr_eq(r, s); 5908 r = bStripCtrlS(s); 5909 ck_assert_str_eq(r, "sheepy"); 5910 // null string 5911 r = bStripCtrlS(null); 5912 ck_assert_ptr_eq(r, null); 5913 5914 5915 } 5916 5917 5918 void quoteST(CuTest *tc UNUSED) { 5919 5920 char *r; 5921 5922 // no change 5923 r = quoteS("abc", '"'); 5924 ck_assert_str_eq(r, "abc"); 5925 free(r); 5926 // add backslashes 5927 r = quoteS("\"abc\\", '"'); 5928 ck_assert_str_eq(r, "\\\"abc\\\\"); 5929 free(r); 5930 // null string 5931 ck_assert_ptr_eq(quoteS(null, 0), null); 5932 5933 } 5934 5935 5936 void bQuoteST(CuTest *tc UNUSED) { 5937 5938 char *r; 5939 char s[40]; 5940 5941 // no change 5942 r = bQuoteS(s, "abc", '"'); 5943 ck_assert_str_eq(r, "abc"); 5944 // add backslashes 5945 r = bQuoteS(s, "\"abc\\", '"'); 5946 ck_assert_str_eq(r, "\\\"abc\\\\"); 5947 // null string 5948 ck_assert_ptr_eq(bQuoteS(s, null, 0), null); 5949 // null dest 5950 ck_assert_ptr_eq(bQuoteS(null, "asd", 0), null); 5951 5952 } 5953 5954 5955 void bLQuoteST(CuTest *tc UNUSED) { 5956 5957 char *r; 5958 char s[40]; 5959 5960 // no change 5961 r = bLQuoteS(s, sizeof(s), "abc", '"'); 5962 ck_assert_str_eq(r, "abc"); 5963 // add backslashes 5964 r = bLQuoteS(s, sizeof(s), "\"abc\\", '"'); 5965 ck_assert_str_eq(r, "\\\"abc\\\\"); 5966 // too small dest buffer 5967 r = bLQuoteS(s, 3, "abc", '"'); 5968 ck_assert_str_eq(r, "ab"); 5969 r = bLQuoteS(s, 3, "a\\\"", '"'); 5970 ck_assert_str_eq(r, "a"); 5971 r = bLQuoteS(s, 3, "ab\"", '"'); 5972 ck_assert_str_eq(r, "ab"); 5973 // null string 5974 ck_assert_ptr_eq(bLQuoteS(s, 10, null, 0), null); 5975 // null dest 5976 ck_assert_ptr_eq(bLQuoteS(null, 10, "asd", 0), null); 5977 // 0 dest size 5978 ck_assert_ptr_eq(bLQuoteS(s, 0, "asd", 0), null); 5979 5980 } 5981 5982 5983 void quoteLenST(CuTest *tc UNUSED) { 5984 5985 size_t r; 5986 5987 // no change 5988 r = quoteLenS("abc", '"'); 5989 ck_assert_int_eq(r, 3); 5990 // add backslashes 5991 r = quoteLenS("\"abc\\", '"'); 5992 ck_assert_int_eq(r, 7); 5993 // null string 5994 ck_assert_int_eq(quoteLenS(null, 0), 0); 5995 5996 } 5997 5998 5999 void escapeST(CuTest *tc UNUSED) { 6000 6001 char *r; 6002 6003 // no change 6004 r = escapeS("abc", '"'); 6005 ck_assert_str_eq(r, "abc"); 6006 free(r); 6007 // add backslashes 6008 r = escapeS("\b\f\r\t\"abc\n\\", '"'); 6009 ck_assert_str_eq(r, "\\b\\f\\r\\t\\\"abc\\n\\\\"); 6010 free(r); 6011 // null string 6012 ck_assert_ptr_eq(escapeS(null, 0), null); 6013 6014 } 6015 6016 6017 void bEscapeST(CuTest *tc UNUSED) { 6018 6019 char *r; 6020 char s[40]; 6021 6022 // no change 6023 r = bEscapeS(s, "abc", '"'); 6024 ck_assert_str_eq(r, "abc"); 6025 // add backslashes 6026 r = bEscapeS(s, "\b\f\r\t\"abc\n\\", '"'); 6027 ck_assert_str_eq(r, "\\b\\f\\r\\t\\\"abc\\n\\\\"); 6028 // null string 6029 ck_assert_ptr_eq(bEscapeS(s, null, 0), null); 6030 // null dest 6031 ck_assert_ptr_eq(bEscapeS(null, "asd", 0), null); 6032 6033 } 6034 6035 6036 void bLEscapeST(CuTest *tc UNUSED) { 6037 6038 char *r; 6039 char s[40]; 6040 6041 // no change 6042 r = bLEscapeS(s, sizeof(s), "abc", '"'); 6043 ck_assert_str_eq(r, "abc"); 6044 // add backslashes 6045 r = bLEscapeS(s, sizeof(s), "\b\f\r\t\"abc\n\\", '"'); 6046 ck_assert_str_eq(r, "\\b\\f\\r\\t\\\"abc\\n\\\\"); 6047 // too small dest buffer 6048 r = bLEscapeS(s, 3, "abc", '"'); 6049 ck_assert_str_eq(r, "ab"); 6050 r = bLEscapeS(s, 3, "a\\\"", '"'); 6051 ck_assert_str_eq(r, "a"); 6052 r = bLEscapeS(s, 3, "ab\"", '"'); 6053 ck_assert_str_eq(r, "ab"); 6054 r = bLEscapeS(s, 3, "a\t", '"'); 6055 ck_assert_str_eq(r, "a"); 6056 // null string 6057 ck_assert_ptr_eq(bLEscapeS(s, 10, null, 0), null); 6058 // null dest 6059 ck_assert_ptr_eq(bLEscapeS(null, 10, "asd", 0), null); 6060 // 0 dest size 6061 ck_assert_ptr_eq(bLEscapeS(s, 0, "asd", 0), null); 6062 6063 } 6064 6065 6066 void escapeLenST(CuTest *tc UNUSED) { 6067 6068 size_t r; 6069 6070 // no change 6071 r = escapeLenS("abc", '"'); 6072 ck_assert_int_eq(r, 3); 6073 // add backslashes 6074 r = escapeLenS("\"abc\b", '"'); 6075 ck_assert_int_eq(r, 7); 6076 // null string 6077 ck_assert_int_eq(escapeLenS(null, 0), 0); 6078 6079 } 6080 6081 6082 void nibbleToHexT(CuTest *tc UNUSED) { 6083 6084 char r; 6085 6086 r = nibbleToHex(9); 6087 ck_assert_int_eq(r, '9'); 6088 r = nibbleToHex(15); 6089 ck_assert_int_eq(r, 'F'); 6090 // out of range 6091 r = nibbleToHex(30); 6092 ck_assert_int_eq(r, 'X'); 6093 6094 } 6095 6096 6097 void cEscapeST(CuTest *tc UNUSED) { 6098 6099 char *r; 6100 6101 // no change 6102 r = cEscapeS("abc"); 6103 ck_assert_str_eq(r, "abc"); 6104 free(r); 6105 // add backslashes 6106 r = cEscapeS("\n\a\b\f\r\t\"ab\x03\v\\"); 6107 ck_assert_str_eq(r, "\\n\\a\\b\\f\\r\\t\\\"ab\"\"\\x03\"\"\\v\\\\"); 6108 free(r); 6109 // null string 6110 ck_assert_ptr_eq(cEscapeS(null), null); 6111 6112 } 6113 6114 6115 void bCEscapeST(CuTest *tc UNUSED) { 6116 6117 char *r; 6118 char s[40]; 6119 6120 // no change 6121 r = bCEscapeS(s, "abc"); 6122 ck_assert_str_eq(r, "abc"); 6123 // add backslashes 6124 r = bCEscapeS(s, "\n\a\b\f\r\t\"ab\x03\v\\"); 6125 ck_assert_str_eq(r, "\\n\\a\\b\\f\\r\\t\\\"ab\"\"\\x03\"\"\\v\\\\"); 6126 // null string 6127 ck_assert_ptr_eq(bCEscapeS(s, null), null); 6128 // null dest 6129 ck_assert_ptr_eq(bCEscapeS(null, "asd"), null); 6130 6131 } 6132 6133 6134 void bLCEscapeST(CuTest *tc UNUSED) { 6135 6136 char *r; 6137 char s[40]; 6138 6139 // no change 6140 r = bLCEscapeS(s, sizeof(s), "abc"); 6141 ck_assert_str_eq(r, "abc"); 6142 // add backslashes 6143 r = bLCEscapeS(s, sizeof(s), "\n\a\b\f\r\t\"ab\x03\v\\"); 6144 ck_assert_str_eq(r, "\\n\\a\\b\\f\\r\\t\\\"ab\"\"\\x03\"\"\\v\\\\"); 6145 // too small dest buffer 6146 r = bLCEscapeS(s, 3, "abc"); 6147 ck_assert_str_eq(r, "ab"); 6148 r = bLCEscapeS(s, 3, "a\\\""); 6149 ck_assert_str_eq(r, "a"); 6150 r = bLCEscapeS(s, 3, "ab\""); 6151 ck_assert_str_eq(r, "ab"); 6152 r = bLCEscapeS(s, 3, "a\a"); 6153 ck_assert_str_eq(r, "a"); 6154 r = bLCEscapeS(s, 3, "a\b"); 6155 ck_assert_str_eq(r, "a"); 6156 r = bLCEscapeS(s, 3, "a\t"); 6157 ck_assert_str_eq(r, "a"); 6158 r = bLCEscapeS(s, 3, "a\n"); 6159 ck_assert_str_eq(r, "a"); 6160 r = bLCEscapeS(s, 3, "a\v"); 6161 ck_assert_str_eq(r, "a"); 6162 r = bLCEscapeS(s, 3, "a\f"); 6163 ck_assert_str_eq(r, "a"); 6164 r = bLCEscapeS(s, 3, "a\r"); 6165 ck_assert_str_eq(r, "a"); 6166 r = bLCEscapeS(s, 3, "a\x01"); 6167 ck_assert_str_eq(r, "a"); 6168 // null string 6169 ck_assert_ptr_eq(bLCEscapeS(s, 10, null), null); 6170 // null dest 6171 ck_assert_ptr_eq(bLCEscapeS(null, 10, "asd"), null); 6172 // 0 dest size 6173 ck_assert_ptr_eq(bLCEscapeS(s, 0, "asd"), null); 6174 6175 } 6176 6177 6178 void cEscapeLenST(CuTest *tc UNUSED) { 6179 6180 size_t r; 6181 6182 // no change 6183 r = cEscapeLenS("abc"); 6184 ck_assert_int_eq(r, 3); 6185 // add backslashes 6186 r = cEscapeLenS("\"abc\b\x01"); 6187 ck_assert_int_eq(r, 15); 6188 // null string 6189 ck_assert_int_eq(cEscapeLenS(null), 0); 6190 6191 } 6192 6193 6194 void isNumberT(CuTest *tc UNUSED) { 6195 6196 // number 6197 ck_assert(isNumber("-12.3")); 6198 ck_assert(isNumber("-123")); 6199 ck_assert(isNumber("123")); 6200 ck_assert(isNumber("1e23")); 6201 ck_assert(isNumber("12E-3")); 6202 ck_assert(isNumber(".123")); 6203 ck_assert(isNumber("-.123")); 6204 ck_assert(isNumber("1E+32")); 6205 // not a number 6206 ck_assert(!isNumber(".12e3")); 6207 ck_assert(!isNumber("-.12e3")); 6208 ck_assert(!isNumber("-1-23")); 6209 ck_assert(!isNumber("123-")); 6210 ck_assert(!isNumber("-")); 6211 ck_assert(!isNumber("-123.")); 6212 ck_assert(!isNumber("-1.2.3")); 6213 ck_assert(!isNumber("1-2.3")); 6214 ck_assert(!isNumber("12..3")); 6215 ck_assert(!isNumber(".12.3")); 6216 ck_assert(!isNumber(".")); 6217 ck_assert(!isNumber("E12")); 6218 ck_assert(!isNumber("E1E2")); 6219 ck_assert(!isNumber("E1.2")); 6220 ck_assert(!isNumber("1E")); 6221 ck_assert(!isNumber("1E2.3")); 6222 ck_assert(!isNumber("1-")); 6223 ck_assert(!isNumber("1E-")); 6224 ck_assert(!isNumber("lib123sheepy")); 6225 // string without number 6226 ck_assert(!isNumber("s")); 6227 // empty string 6228 ck_assert(!isNumber("")); 6229 // NULL string 6230 ck_assert(!isNumber(NULL)); 6231 6232 } 6233 6234 6235 void isIntT(CuTest *tc UNUSED) { 6236 6237 // integer 6238 ck_assert(isInt("-123")); 6239 ck_assert(isInt("123")); 6240 // not a integer 6241 ck_assert(!isInt("1e23")); 6242 ck_assert(!isInt("12E-3")); 6243 ck_assert(!isInt("-12.3")); 6244 ck_assert(!isInt("-1-23")); 6245 ck_assert(!isInt("123-")); 6246 ck_assert(!isInt("-")); 6247 ck_assert(!isInt("-123.")); 6248 ck_assert(!isInt(".123")); 6249 ck_assert(!isInt("-1.2.3")); 6250 ck_assert(!isInt("1-2.3")); 6251 ck_assert(!isInt("12..3")); 6252 ck_assert(!isInt(".")); 6253 ck_assert(!isInt("1E")); 6254 ck_assert(!isInt("1-")); 6255 ck_assert(!isInt("1E-")); 6256 ck_assert(!isInt("lib123sheepy")); 6257 // string without number 6258 ck_assert(!isInt("s")); 6259 // empty string 6260 ck_assert(!isInt("")); 6261 // NULL string 6262 ck_assert(!isInt(NULL)); 6263 6264 } 6265 6266 6267 void parseIntT(CuTest *tc UNUSED) { 6268 6269 // number 6270 ck_assert_int_eq(parseInt("123sheepy"), 123); 6271 ck_assert_int_eq(parseInt("lib123sheepy"), 123); 6272 ck_assert_int_eq(parseInt("-123"), -123); 6273 // out of range - TODO check stderr 6274 int r = parseInt("999999999999999999999999999999999999999"); 6275 ck_assert_int_eq(r, -1); 6276 // string without number 6277 ck_assert_int_eq(parseInt("sheepy"), 0); 6278 // NULL string 6279 ck_assert_int_eq(parseInt(NULL), 0); 6280 6281 } 6282 6283 6284 void parseIntCharT(CuTest *tc UNUSED) { 6285 6286 // number 6287 ck_assert_int_eq(parseIntChar('1'),1); 6288 ck_assert_int_eq(parseIntChar('0'),0); 6289 ck_assert_int_eq(parseIntChar('9'),9); 6290 // not a number 6291 ck_assert_int_eq(parseIntChar('a'),-1); 6292 ck_assert_int_eq(parseIntChar(0),-1); 6293 6294 } 6295 6296 6297 void parseI64T(CuTest *tc UNUSED) { 6298 6299 // number 6300 ck_assert_int_eq(parseI64("123sheepy"), 123); 6301 ck_assert_int_eq(parseI64("lib123sheepy"), 123); 6302 ck_assert_int_eq(parseI64("-123"), -123); 6303 // out of range - TODO check stderr 6304 int r = parseI64("999999999999999999999999999999999999999"); 6305 ck_assert_int_eq(r, -1); 6306 // string without number 6307 ck_assert_int_eq(parseI64("sheepy"), 0); 6308 // NULL string 6309 ck_assert_int_eq(parseI64(NULL), 0); 6310 6311 6312 } 6313 6314 6315 void parseI64CharT(CuTest *tc UNUSED) { 6316 6317 // number 6318 ck_assert_int_eq(parseI64Char('1'),1); 6319 ck_assert_int_eq(parseI64Char('0'),0); 6320 ck_assert_int_eq(parseI64Char('9'),9); 6321 // not a number 6322 ck_assert_int_eq(parseI64Char('a'),-1); 6323 ck_assert_int_eq(parseI64Char(0),-1); 6324 6325 6326 } 6327 6328 6329 void parseDoubleT(CuTest *tc UNUSED) { 6330 6331 // number 6332 ck_assert_int_eq(parseDouble("123.2sheepy"), 123); 6333 ck_assert_int_eq(parseDouble("lib123sheepy"), 123); 6334 ck_assert_int_eq(parseDouble("-123"), -123); 6335 // out of range - TODO check stderr 6336 int r = parseDouble("999999999999999999999999999999999999999"); 6337 ck_assert_int_eq(r, -2147483648); 6338 // string without number 6339 ck_assert_int_eq(parseDouble("sheepy"), 0); 6340 // NULL string 6341 ck_assert_int_eq(parseDouble(NULL), 0); 6342 6343 } 6344 6345 6346 void parseDoubleCharT(CuTest *tc UNUSED) { 6347 6348 // number 6349 ck_assert_int_eq(parseDoubleChar('1'),1); 6350 ck_assert_int_eq(parseDoubleChar('0'),0); 6351 ck_assert_int_eq(parseDoubleChar('9'),9); 6352 // not a number 6353 ck_assert_int_eq(parseDoubleChar('a'),-1); 6354 ck_assert_int_eq(parseDoubleChar(0),-1); 6355 6356 } 6357 6358 6359 void parseHexT(CuTest *tc UNUSED) { 6360 6361 u64 r; 6362 6363 // hex to int 6364 r = parseHex("0x04"); 6365 ck_assert_int_eq(r, 4); 6366 r = parseHex("aoij0xaa"); 6367 ck_assert_int_eq(r, 170); 6368 // null string 6369 r = parseHex(null); 6370 ck_assert_int_eq(r, 0); 6371 6372 6373 } 6374 6375 6376 void intToST(CuTest *tc UNUSED) { 6377 6378 // number 6379 char *s = intToS(123); 6380 ck_assert_str_eq(s, "123"); 6381 free(s); 6382 s = intToS(-465464123); 6383 ck_assert_str_eq(s, "-465464123"); 6384 free(s); 6385 6386 } 6387 6388 6389 void bIntToST(CuTest *tc UNUSED) { 6390 6391 // number 6392 char s[50]; 6393 char *r = null; 6394 6395 r = bIntToS(s, 123); 6396 ck_assert_ptr_eq(r, s); 6397 ck_assert_str_eq(s, "123"); 6398 r = bIntToS(s, -465464123); 6399 ck_assert_ptr_eq(r, s); 6400 ck_assert_str_eq(s, "-465464123"); 6401 // NULL 6402 r = bIntToS(NULL, 123); 6403 ck_assert_ptr_eq(r, null); 6404 6405 } 6406 6407 6408 void doubleToST(CuTest *tc UNUSED) { 6409 6410 // number 6411 char *s = doubleToS(123.4); 6412 ck_assert_str_eq(s, "1.234000e+02"); 6413 free(s); 6414 s = doubleToS(-4652445e5); 6415 ck_assert_str_eq(s, "-4.652445e+11"); 6416 free(s); 6417 6418 } 6419 6420 6421 void bDoubleToST(CuTest *tc UNUSED) { 6422 6423 // number 6424 char s[256]; 6425 char *r = null; 6426 6427 r = bDoubleToS(s, 123.4); 6428 ck_assert_ptr_eq(r, s); 6429 ck_assert_str_eq(s, "1.234000e+02"); 6430 r = bDoubleToS(s, -4652445e5); 6431 ck_assert_ptr_eq(r, s); 6432 ck_assert_str_eq(s, "-4.652445e+11"); 6433 // NULL 6434 r = bDoubleToS(NULL, 123.4); 6435 ck_assert_ptr_eq(r, null); 6436 6437 } 6438 6439 6440 void lenST(CuTest *tc UNUSED) { 6441 6442 // string 6443 ck_assert_uint_eq(lenS("sheepy"), 6); 6444 // NULL string 6445 ck_assert_uint_eq(lenS(NULL), 0); 6446 6447 } 6448 6449 6450 void sizeST(CuTest *tc UNUSED) { 6451 6452 // string 6453 ck_assert_uint_eq(sizeS("sheepy"), 7); 6454 // NULL string 6455 ck_assert_uint_eq(sizeS(NULL), 0); 6456 6457 } 6458 6459 6460 void upperST(CuTest *tc UNUSED) { 6461 6462 // string 6463 char *s = upperS("sheepy"); 6464 ck_assert_str_eq(s, "SHEEPY"); 6465 free(s); 6466 // NULL string 6467 ck_assert_ptr_eq(upperS(NULL), NULL); 6468 6469 } 6470 6471 6472 void iUpperST(CuTest *tc UNUSED) { 6473 6474 char *s; 6475 char *r; 6476 6477 // string 6478 s = strdup("sheepy"); 6479 r = iUpperS(&s); 6480 ck_assert_ptr_eq(r, s); 6481 ck_assert_str_eq(s, "SHEEPY"); 6482 free(s); 6483 // NULL string 6484 s = NULL; 6485 r = iUpperS(&s); 6486 ck_assert_ptr_eq(r, s); 6487 ck_assert_ptr_eq(s, NULL); 6488 // NULL var 6489 r = iUpperS(NULL); 6490 ck_assert_ptr_eq(r, null); 6491 6492 } 6493 6494 6495 void bUpperST(CuTest *tc UNUSED) { 6496 6497 char s[50]; 6498 char *r = null; 6499 6500 // string 6501 strcpy(s, "sheepy"); 6502 r = bUpperS(s); 6503 ck_assert_ptr_eq(r, s); 6504 ck_assert_str_eq(s, "SHEEPY"); 6505 // NULL var 6506 r = bUpperS(NULL); 6507 ck_assert_ptr_eq(r, null); 6508 6509 } 6510 6511 6512 void lowerST(CuTest *tc UNUSED) { 6513 6514 // string 6515 char *s = lowerS("SHeePY"); 6516 ck_assert_str_eq(s, "sheepy"); 6517 free(s); 6518 // NULL string 6519 ck_assert_ptr_eq(lowerS(NULL), NULL); 6520 6521 } 6522 6523 6524 void iLowerST(CuTest *tc UNUSED) { 6525 6526 char *s; 6527 char *r = null; 6528 6529 // string 6530 s = strdup("SHEEPY"); 6531 r = iLowerS(&s); 6532 ck_assert_ptr_eq(r, s); 6533 ck_assert_str_eq(s, "sheepy"); 6534 free(s); 6535 // NULL string 6536 s = NULL; 6537 r = iLowerS(&s); 6538 ck_assert_ptr_eq(r, s); 6539 ck_assert_ptr_eq(s, NULL); 6540 // NULL var 6541 r = iLowerS(NULL); 6542 ck_assert_ptr_eq(r, null); 6543 6544 } 6545 6546 6547 void bLowerST(CuTest *tc UNUSED) { 6548 6549 char s[50]; 6550 char *r = null; 6551 6552 // string 6553 strcpy(s, "SHEEPY"); 6554 r = bLowerS(s); 6555 ck_assert_ptr_eq(r, s); 6556 ck_assert_str_eq(s, "sheepy"); 6557 // NULL var 6558 r = bLowerS(NULL); 6559 ck_assert_ptr_eq(r, null); 6560 6561 } 6562 6563 6564 void trimST(CuTest *tc UNUSED) { 6565 6566 // no spaces 6567 char *s = trimS("SHeePY"); 6568 ck_assert_str_eq(s, "SHeePY"); 6569 free(s); 6570 // heading spaces 6571 s = trimS(" SHeePY"); 6572 ck_assert_str_eq(s, "SHeePY"); 6573 free(s); 6574 // trailing spaces 6575 s = trimS("SHeePY "); 6576 ck_assert_str_eq(s, "SHeePY"); 6577 free(s); 6578 // string with spaces in the middle 6579 s = trimS(" SHe ePY "); 6580 ck_assert_str_eq(s, "SHe ePY"); 6581 free(s); 6582 // all spaces 6583 s = trimS(" "); 6584 ck_assert_str_eq(s, ""); 6585 free(s); 6586 // NULL string 6587 ck_assert_ptr_eq(trimS(NULL), NULL); 6588 6589 } 6590 6591 6592 void iTrimST(CuTest *tc UNUSED) { 6593 6594 char *s; 6595 char *r = null; 6596 6597 // no spaces 6598 s = strdup("SHeePY"); 6599 r = iTrimS(&s); 6600 ck_assert_ptr_eq(r, s); 6601 ck_assert_str_eq(s, "SHeePY"); 6602 free(s); 6603 // heading spaces 6604 s = strdup(" SHeePY"); 6605 r = iTrimS(&s); 6606 ck_assert_ptr_eq(r, s); 6607 ck_assert_str_eq(s, "SHeePY"); 6608 free(s); 6609 // trailing spaces 6610 s = strdup("SHeePY "); 6611 r = iTrimS(&s); 6612 ck_assert_ptr_eq(r, s); 6613 ck_assert_str_eq(s, "SHeePY"); 6614 free(s); 6615 // string with spaces in the middle 6616 s = strdup(" SHe ePY "); 6617 r = iTrimS(&s); 6618 ck_assert_ptr_eq(r, s); 6619 ck_assert_str_eq(s, "SHe ePY"); 6620 free(s); 6621 // all spaces 6622 s = strdup(" "); 6623 r = iTrimS(&s); 6624 ck_assert_ptr_eq(r, s); 6625 ck_assert_str_eq(s, ""); 6626 free(s); 6627 // NULL string 6628 s = NULL; 6629 r = iTrimS(&s); 6630 ck_assert_ptr_eq(r, s); 6631 ck_assert_ptr_eq(s, NULL); 6632 // NULL var 6633 r = iTrimS(NULL); 6634 ck_assert_ptr_eq(r, null); 6635 6636 } 6637 6638 6639 void bTrimST(CuTest *tc UNUSED) { 6640 6641 char s[50]; 6642 char *r = null; 6643 6644 // no spaces 6645 strcpy(s, "SHeePY"); 6646 r = bTrimS(s); 6647 ck_assert_ptr_eq(r, s); 6648 ck_assert_str_eq(s, "SHeePY"); 6649 // heading spaces 6650 strcpy(s, " SHeePY"); 6651 r = bTrimS(s); 6652 ck_assert_ptr_eq(r, s); 6653 ck_assert_str_eq(s, "SHeePY"); 6654 // trailing spaces 6655 strcpy(s, "SHeePY "); 6656 r = bTrimS(s); 6657 ck_assert_ptr_eq(r, s); 6658 ck_assert_str_eq(s, "SHeePY"); 6659 // string with spaces in the middle 6660 strcpy(s, " SHe ePY "); 6661 r = bTrimS(s); 6662 ck_assert_ptr_eq(r, s); 6663 ck_assert_str_eq(s, "SHe ePY"); 6664 // all spaces 6665 strcpy(s, " "); 6666 r = bTrimS(s); 6667 ck_assert_ptr_eq(r, s); 6668 ck_assert_str_eq(s, ""); 6669 // NULL var 6670 r = bTrimS(NULL); 6671 ck_assert_ptr_eq(r, null); 6672 6673 } 6674 6675 6676 void lTrimST(CuTest *tc UNUSED) { 6677 6678 // no spaces 6679 char *s = lTrimS("SHeePY"); 6680 ck_assert_str_eq(s, "SHeePY"); 6681 free(s); 6682 // heading spaces 6683 s = lTrimS(" SHeePY"); 6684 ck_assert_str_eq(s, "SHeePY"); 6685 free(s); 6686 // trailing spaces 6687 s = lTrimS("SHeePY "); 6688 ck_assert_str_eq(s, "SHeePY "); 6689 free(s); 6690 // string with spaces in the middle 6691 s = lTrimS(" SHe ePY "); 6692 ck_assert_str_eq(s, "SHe ePY "); 6693 free(s); 6694 // all spaces 6695 s = lTrimS(" "); 6696 ck_assert_str_eq(s, ""); 6697 free(s); 6698 // NULL string 6699 ck_assert_ptr_eq(lTrimS(NULL), NULL); 6700 6701 } 6702 6703 6704 void iLTrimST(CuTest *tc UNUSED) { 6705 6706 char *s; 6707 char *r = null; 6708 6709 // no spaces 6710 s = strdup("SHeePY"); 6711 r = iLTrimS(&s); 6712 ck_assert_ptr_eq(r, s); 6713 ck_assert_str_eq(s, "SHeePY"); 6714 free(s); 6715 // heading spaces 6716 s = strdup(" SHeePY"); 6717 r = iLTrimS(&s); 6718 ck_assert_ptr_eq(r, s); 6719 ck_assert_str_eq(s, "SHeePY"); 6720 free(s); 6721 // trailing spaces 6722 s = strdup("SHeePY "); 6723 r = iLTrimS(&s); 6724 ck_assert_ptr_eq(r, s); 6725 ck_assert_str_eq(s, "SHeePY "); 6726 free(s); 6727 // string with spaces in the middle 6728 s = strdup(" SHe ePY "); 6729 r = iLTrimS(&s); 6730 ck_assert_ptr_eq(r, s); 6731 ck_assert_str_eq(s, "SHe ePY "); 6732 free(s); 6733 // all spaces 6734 s = strdup(" "); 6735 r = iLTrimS(&s); 6736 ck_assert_ptr_eq(r, s); 6737 ck_assert_str_eq(s, ""); 6738 free(s); 6739 // NULL string 6740 s = NULL; 6741 r = iLTrimS(&s); 6742 ck_assert_ptr_eq(r, s); 6743 ck_assert_ptr_eq(s, NULL); 6744 // NULL var 6745 r = iLTrimS(NULL); 6746 ck_assert_ptr_eq(r, null); 6747 6748 } 6749 6750 6751 void bLTrimST(CuTest *tc UNUSED) { 6752 6753 char s[50]; 6754 char *r = null; 6755 6756 // no spaces 6757 strcpy(s, "SHeePY"); 6758 r = bLTrimS(s); 6759 ck_assert_ptr_eq(r, s); 6760 ck_assert_str_eq(s, "SHeePY"); 6761 // heading spaces 6762 strcpy(s, " SHeePY"); 6763 r = bLTrimS(s); 6764 ck_assert_ptr_eq(r, s); 6765 ck_assert_str_eq(s, "SHeePY"); 6766 // trailing spaces 6767 strcpy(s, "SHeePY "); 6768 r = bLTrimS(s); 6769 ck_assert_ptr_eq(r, s); 6770 ck_assert_str_eq(s, "SHeePY "); 6771 // string with spaces in the middle 6772 strcpy(s, " SHe ePY "); 6773 r = bLTrimS(s); 6774 ck_assert_ptr_eq(r, s); 6775 ck_assert_str_eq(s, "SHe ePY "); 6776 // all spaces 6777 strcpy(s, " "); 6778 r = bLTrimS(s); 6779 ck_assert_ptr_eq(r, s); 6780 ck_assert_str_eq(s, ""); 6781 // NULL var 6782 r = bLTrimS(NULL); 6783 ck_assert_ptr_eq(r, null); 6784 6785 } 6786 6787 6788 void rTrimST(CuTest *tc UNUSED) { 6789 6790 // no spaces 6791 char *s = rTrimS("SHeePY"); 6792 ck_assert_str_eq(s, "SHeePY"); 6793 free(s); 6794 // heading spaces 6795 s = rTrimS(" SHeePY"); 6796 ck_assert_str_eq(s, " SHeePY"); 6797 free(s); 6798 // trailing spaces 6799 s = rTrimS("SHeePY "); 6800 ck_assert_str_eq(s, "SHeePY"); 6801 free(s); 6802 // string with spaces in the middle 6803 s = rTrimS(" SHe ePY "); 6804 ck_assert_str_eq(s, " SHe ePY"); 6805 free(s); 6806 // all spaces 6807 s = rTrimS(" "); 6808 ck_assert_str_eq(s, ""); 6809 free(s); 6810 // NULL string 6811 ck_assert_ptr_eq(rTrimS(NULL), NULL); 6812 6813 } 6814 6815 6816 void iRTrimST(CuTest *tc UNUSED) { 6817 6818 char *s; 6819 char *r = null; 6820 6821 // no spaces 6822 s = strdup("SHeePY"); 6823 r = iRTrimS(&s); 6824 ck_assert_ptr_eq(r, s); 6825 ck_assert_str_eq(s, "SHeePY"); 6826 free(s); 6827 // heading spaces 6828 s = strdup(" SHeePY"); 6829 r = iRTrimS(&s); 6830 ck_assert_ptr_eq(r, s); 6831 ck_assert_str_eq(s, " SHeePY"); 6832 free(s); 6833 // trailing spaces 6834 s = strdup("SHeePY "); 6835 r = iRTrimS(&s); 6836 ck_assert_ptr_eq(r, s); 6837 ck_assert_str_eq(s, "SHeePY"); 6838 free(s); 6839 // string with spaces in the middle 6840 s = strdup(" SHe ePY "); 6841 r = iRTrimS(&s); 6842 ck_assert_ptr_eq(r, s); 6843 ck_assert_str_eq(s, " SHe ePY"); 6844 free(s); 6845 // all spaces 6846 s = strdup(" "); 6847 r = iRTrimS(&s); 6848 ck_assert_ptr_eq(r, s); 6849 ck_assert_str_eq(s, ""); 6850 free(s); 6851 // NULL string 6852 s = NULL; 6853 r = iRTrimS(&s); 6854 ck_assert_ptr_eq(r, s); 6855 ck_assert_ptr_eq(s, NULL); 6856 // NULL var 6857 r = iRTrimS(NULL); 6858 ck_assert_ptr_eq(r, null); 6859 6860 } 6861 6862 6863 void bRTrimST(CuTest *tc UNUSED) { 6864 6865 char s[100]; 6866 char *r = null; 6867 6868 // no spaces 6869 strcpy(s, "SHeePY"); 6870 r = bRTrimS(s); 6871 ck_assert_ptr_eq(r, s); 6872 ck_assert_str_eq(s, "SHeePY"); 6873 // heading spaces 6874 strcpy(s, " SHeePY"); 6875 r = bRTrimS(s); 6876 ck_assert_ptr_eq(r, s); 6877 ck_assert_str_eq(s, " SHeePY"); 6878 // trailing spaces 6879 strcpy(s, "SHeePY "); 6880 r = bRTrimS(s); 6881 ck_assert_ptr_eq(r, s); 6882 ck_assert_str_eq(s, "SHeePY"); 6883 // string with spaces in the middle 6884 strcpy(s, " SHe ePY "); 6885 r = bRTrimS(s); 6886 ck_assert_ptr_eq(r, s); 6887 ck_assert_str_eq(s, " SHe ePY"); 6888 // all spaces 6889 strcpy(s, " "); 6890 r = bRTrimS(s); 6891 ck_assert_ptr_eq(r, s); 6892 ck_assert_str_eq(s, ""); 6893 // NULL var 6894 r = bRTrimS(NULL); 6895 ck_assert_ptr_eq(r, null); 6896 6897 } 6898 6899 6900 void uniqST(CuTest *tc UNUSED) { 6901 6902 char *s; 6903 6904 // uniquify 6905 s = uniqS("/qwd///", '/'); 6906 ck_assert_str_eq(s, "/qwd/"); 6907 free(s); 6908 // short string 6909 s = uniqS("?", '/'); 6910 ck_assert_str_eq(s, "?"); 6911 free(s); 6912 // NULL 6913 ck_assert_ptr_eq(uniqS(NULL, '/'), NULL); 6914 6915 } 6916 6917 6918 void iUniqST(CuTest *tc UNUSED) { 6919 6920 char *s; 6921 6922 // uniquify 6923 s = strdup("/qwd///"); 6924 ck_assert_str_eq(iUniqS(&s, '/'), "/qwd/"); 6925 free(s); 6926 // short string 6927 s = strdup("?"); 6928 ck_assert_str_eq(iUniqS(&s, '/'), "?"); 6929 free(s); 6930 // NULL string 6931 s = NULL; 6932 ck_assert_ptr_eq(iUniqS(&s, '/'), NULL); 6933 // NULL 6934 ck_assert_ptr_eq(iUniqS(NULL, '/'), NULL); 6935 6936 } 6937 6938 6939 void bUniqST(CuTest *tc UNUSED) { 6940 6941 char s[100]; 6942 6943 // uniquify 6944 strcpy(s, "/qwd///"); 6945 ck_assert_str_eq(bUniqS(s, '/'), "/qwd/"); 6946 // short string 6947 strcpy(s, "?"); 6948 ck_assert_str_eq(bUniqS(s, '/'), "?"); 6949 // NULL 6950 ck_assert_ptr_eq(bUniqS(NULL, '/'), NULL); 6951 6952 } 6953 6954 6955 void icUniqST(CuTest *tc UNUSED) { 6956 6957 char *s; 6958 6959 // uniquify 6960 s = icUniqS("/qQqwd///", 'q'); 6961 ck_assert_str_eq(s, "/qwd///"); 6962 free(s); 6963 // short string 6964 s = icUniqS("?", '/'); 6965 ck_assert_str_eq(s, "?"); 6966 free(s); 6967 // NULL 6968 ck_assert_ptr_eq(icUniqS(NULL, '/'), NULL); 6969 6970 6971 } 6972 6973 6974 void iicUniqST(CuTest *tc UNUSED) { 6975 6976 char *s; 6977 6978 // uniquify 6979 s = strdup("/qQqwd///"); 6980 ck_assert_str_eq(iicUniqS(&s, 'Q'), "/qwd///"); 6981 free(s); 6982 // short string 6983 s = strdup("?"); 6984 ck_assert_str_eq(iicUniqS(&s, '/'), "?"); 6985 free(s); 6986 // NULL string 6987 s = NULL; 6988 ck_assert_ptr_eq(iicUniqS(&s, '/'), NULL); 6989 // NULL 6990 ck_assert_ptr_eq(iicUniqS(NULL, '/'), NULL); 6991 6992 6993 } 6994 6995 6996 void bicUniqST(CuTest *tc UNUSED) { 6997 6998 char s[100]; 6999 7000 // uniquify 7001 strcpy(s, "/qQqwd///"); 7002 ck_assert_str_eq(bicUniqS(s, 'q'), "/qwd///"); 7003 // short string 7004 strcpy(s, "?"); 7005 ck_assert_str_eq(bicUniqS(s, '/'), "?"); 7006 // NULL 7007 ck_assert_ptr_eq(bicUniqS(NULL, '/'), NULL); 7008 7009 7010 } 7011 7012 7013 void repeatST(CuTest *tc UNUSED) { 7014 7015 char *r; 7016 7017 // repeat 7018 r = repeatS("abc", 2); 7019 ck_assert_str_eq(r, "abcabc"); 7020 free(r); 7021 7022 // empty string 7023 r = repeatS("", 2); 7024 ck_assert_str_eq(r, ""); 7025 free(r); 7026 7027 // once 7028 r = repeatS("ab", 1); 7029 ck_assert_str_eq(r, "ab"); 7030 free(r); 7031 7032 // 0 times 7033 r = repeatS("jhgjgh", 0); 7034 ck_assert_str_eq(r, ""); 7035 free(r); 7036 7037 // null string 7038 r = repeatS(null, 2); 7039 ck_assert_ptr_eq(r, null); 7040 7041 } 7042 7043 7044 void iRepeatST(CuTest *tc UNUSED) { 7045 7046 char *s, *r; 7047 7048 // repeat 7049 s = strdup("abc"); 7050 r = iRepeatS(&s, 2); 7051 ck_assert_ptr_eq(r, s); 7052 ck_assert_str_eq(r, "abcabc"); 7053 free(r); 7054 7055 // empty string 7056 s = strdup(""); 7057 r = iRepeatS(&s, 2); 7058 ck_assert_str_eq(r, ""); 7059 free(r); 7060 7061 // once 7062 s = strdup("ab"); 7063 r = iRepeatS(&s, 1); 7064 ck_assert_str_eq(r, "ab"); 7065 free(r); 7066 7067 // 0 times 7068 s = strdup("jhgjgh"); 7069 r = iRepeatS(&s, 0); 7070 ck_assert_str_eq(r, ""); 7071 free(r); 7072 7073 // null string 7074 s = null; 7075 r = iRepeatS(&s, 2); 7076 ck_assert_ptr_eq(r, null); 7077 7078 r = iRepeatS(null, 2); 7079 ck_assert_ptr_eq(r, null); 7080 7081 } 7082 7083 7084 void bRepeatST(CuTest *tc UNUSED) { 7085 7086 char s[128] = init0Var; 7087 char *r; 7088 7089 // repeat 7090 r = bRepeatS(s, "abc", 2); 7091 ck_assert_str_eq(r, "abcabc"); 7092 7093 // empty string 7094 r = bRepeatS(s, "", 2); 7095 ck_assert_str_eq(r, ""); 7096 7097 // once 7098 r = bRepeatS(s, "ab", 1); 7099 ck_assert_str_eq(r, "ab"); 7100 7101 // 0 times 7102 r = bRepeatS(s, "adsad", 0); 7103 ck_assert_str_eq(r, ""); 7104 7105 // null string 7106 r = bRepeatS(s, null, 2); 7107 ck_assert_ptr_eq(r, null); 7108 7109 // null dest 7110 r = bRepeatS(null, "asd", 2); 7111 ck_assert_ptr_eq(r, null); 7112 7113 } 7114 7115 7116 void bLRepeatST(CuTest *tc UNUSED) { 7117 7118 char s[6] = init0Var; 7119 char *r; 7120 7121 // repeat 7122 r = bLRepeatS(s, sizeof(s), "ab", 2); 7123 ck_assert_str_eq(r, "abab"); 7124 7125 // empty string 7126 r = bLRepeatS(s, sizeof(s), "", 2); 7127 ck_assert_str_eq(r, ""); 7128 7129 // once 7130 r = bLRepeatS(s, sizeof(s), "ab", 1); 7131 ck_assert_str_eq(r, "ab"); 7132 7133 // 0 times 7134 r = bLRepeatS(s, sizeof(s), "asdasd", 0); 7135 ck_assert_str_eq(r, ""); 7136 7137 // once bigger than buffer 7138 r = bLRepeatS(s, sizeof(s), "123456", 1); 7139 ck_assert_ptr_eq(r, null); 7140 7141 // dest size 0 7142 r = bLRepeatS(s, 0, "123", 2); 7143 ck_assert_ptr_eq(r, null); 7144 7145 // null string 7146 r = bLRepeatS(s, sizeof(s), null, 2); 7147 ck_assert_ptr_eq(r, null); 7148 7149 // null dest 7150 r = bLRepeatS(null, sizeof(s), "asd", 2); 7151 ck_assert_ptr_eq(r, null); 7152 7153 7154 } 7155 7156 7157 void repeatCharST(CuTest *tc UNUSED) { 7158 7159 char *r; 7160 7161 // repeat 7162 r = repeatCharS('$', 2); 7163 ck_assert_str_eq(r, "$$"); 7164 free(r); 7165 7166 // once 7167 r = repeatCharS('!', 1); 7168 ck_assert_str_eq(r, "!"); 7169 free(r); 7170 7171 // 0 times 7172 r = repeatCharS('0', 0); 7173 ck_assert_str_eq(r, ""); 7174 free(r); 7175 7176 } 7177 7178 7179 void bRepeatCharST(CuTest *tc UNUSED) { 7180 7181 char s[128] = init0Var; 7182 char *r; 7183 7184 // repeat 7185 r = bRepeatCharS(s, 'a', 2); 7186 ck_assert_str_eq(r, "aa"); 7187 7188 // once 7189 r = bRepeatCharS(s, 'a', 1); 7190 ck_assert_str_eq(r, "a"); 7191 7192 // 0 times 7193 r = bRepeatCharS(s, '0', 0); 7194 ck_assert_str_eq(r, ""); 7195 7196 // null dest 7197 r = bRepeatCharS(null, 'd', 2); 7198 ck_assert_ptr_eq(r, null); 7199 7200 7201 } 7202 7203 7204 void bLRepeatCharST(CuTest *tc UNUSED) { 7205 7206 char s[6] = init0Var; 7207 char *r; 7208 7209 // repeat 7210 r = bLRepeatCharS(s, sizeof(s), '$', 4); 7211 ck_assert_str_eq(r, "$$$$"); 7212 7213 // once 7214 r = bLRepeatCharS(s, sizeof(s), '+', 1); 7215 ck_assert_str_eq(r, "+"); 7216 7217 // 0 times 7218 r = bLRepeatCharS(s, sizeof(s), '1', 0); 7219 ck_assert_str_eq(r, ""); 7220 7221 // once bigger than buffer 7222 r = bLRepeatCharS(s, sizeof(s), '=', 6); 7223 ck_assert_ptr_eq(r, null); 7224 7225 // dest size 0 7226 r = bLRepeatCharS(s, 0, '/', 2); 7227 ck_assert_ptr_eq(r, null); 7228 7229 // null dest 7230 r = bLRepeatCharS(null, sizeof(s), '\'', 2); 7231 ck_assert_ptr_eq(r, null); 7232 7233 7234 } 7235 7236 7237 void repeatLenST(CuTest *tc UNUSED) { 7238 7239 ssize_t r; 7240 7241 r = repeatLenS("asd", 3); 7242 ck_assert_int_eq(r, 9); 7243 7244 // 0 times 7245 r = repeatLenS("asd", 0); 7246 ck_assert_int_eq(r, 0); 7247 7248 // empty string 7249 r = repeatLenS("", 3); 7250 ck_assert_int_eq(r, 0); 7251 7252 // null string 7253 r = repeatLenS(null, 3); 7254 ck_assert_int_eq(r, -1); 7255 7256 } 7257 7258 7259 void ellipsisStartST(CuTest *tc UNUSED) { 7260 7261 char *r; 7262 7263 // no ellipsis 7264 r = ellipsisStartS("sheepy", 10, "..."); 7265 ck_assert_str_eq(r, "sheepy"); 7266 free(r); 7267 r = ellipsisStartS("sheepy", 6, "..."); 7268 ck_assert_str_eq(r, "sheepy"); 7269 free(r); 7270 7271 // ellipsis 7272 r = ellipsisStartS("sheepy", 5, "..."); 7273 ck_assert_str_eq(r, "...py"); 7274 free(r); 7275 7276 // ellipsis longer than target length 7277 r = ellipsisStartS("sheepy", 5, "......"); 7278 ck_assert_str_eq(r, "....."); 7279 free(r); 7280 7281 // empty ellipsis 7282 r = ellipsisStartS("sheepy", 5, ""); 7283 ck_assert_str_eq(r, "heepy"); 7284 free(r); 7285 7286 // target length 0 7287 r = ellipsisStartS("sheepy", 0, "..."); 7288 ck_assert_str_eq(r, ""); 7289 free(r); 7290 7291 // null string 7292 ck_assert_ptr_eq(ellipsisStartS(null,4,""), null); 7293 // null ellipsis 7294 ck_assert_ptr_eq(ellipsisStartS("",4,null), null); 7295 7296 } 7297 7298 7299 void iEllipsisStartST(CuTest *tc UNUSED) { 7300 7301 char *s, *r; 7302 7303 // no ellipsis 7304 s = strdup("sheepy"); 7305 r = iEllipsisStartS(&s, 10, "..."); 7306 ck_assert_str_eq(r, "sheepy"); 7307 free(r); 7308 s = strdup("sheepy"); 7309 r = iEllipsisStartS(&s, 6, "..."); 7310 ck_assert_str_eq(r, "sheepy"); 7311 free(r); 7312 7313 // ellipsis 7314 s = strdup("sheepy"); 7315 r = iEllipsisStartS(&s, 5, "..."); 7316 ck_assert_str_eq(r, "...py"); 7317 free(r); 7318 7319 // ellipsis longer than target length 7320 s = strdup("sheepy"); 7321 r = iEllipsisStartS(&s, 5, "......"); 7322 ck_assert_str_eq(r, "....."); 7323 free(r); 7324 7325 // empty ellipsis 7326 s = strdup("sheepy"); 7327 r = iEllipsisStartS(&s, 5, ""); 7328 ck_assert_str_eq(r, "heepy"); 7329 free(r); 7330 7331 // target length 0 7332 s = strdup("sheepy"); 7333 r = iEllipsisStartS(&s, 0, "..."); 7334 ck_assert_str_eq(r, ""); 7335 free(r); 7336 7337 // null string 7338 s = null; 7339 ck_assert_ptr_eq(iEllipsisStartS(&s,4,""), null); 7340 ck_assert_ptr_eq(iEllipsisStartS(null,4,""), null); 7341 // null ellipsis 7342 s = strdup("sd"); 7343 ck_assert_ptr_eq(iEllipsisStartS(&s,4,null), null); 7344 free(s); 7345 7346 7347 } 7348 7349 7350 void bEllipsisStartST(CuTest *tc UNUSED) { 7351 7352 char *r; 7353 char dest[48]; 7354 7355 // no ellipsis 7356 r = bEllipsisStartS(dest, "sheepy", 10, "..."); 7357 ck_assert_str_eq(r, "sheepy"); 7358 r = bEllipsisStartS(dest, "sheepy", 6, "..."); 7359 ck_assert_str_eq(r, "sheepy"); 7360 7361 // ellipsis 7362 r = bEllipsisStartS(dest, "sheepy", 5, "..."); 7363 ck_assert_str_eq(r, "...py"); 7364 7365 // ellipsis longer than target length 7366 r = bEllipsisStartS(dest, "sheepy", 5, "......"); 7367 ck_assert_str_eq(r, "....."); 7368 7369 // empty ellipsis 7370 r = bEllipsisStartS(dest, "sheepy", 5, ""); 7371 ck_assert_str_eq(r, "heepy"); 7372 7373 // target length 0 7374 r = bEllipsisStartS(dest, "sheepy", 0, "..."); 7375 ck_assert_str_eq(r, ""); 7376 7377 // null string 7378 ck_assert_ptr_eq(bEllipsisStartS(dest, null,4,""), null); 7379 // null ellipsis 7380 ck_assert_ptr_eq(bEllipsisStartS(dest, "",4,null), null); 7381 // null dest 7382 ck_assert_ptr_eq(bEllipsisStartS(null, "",4,""), null); 7383 7384 7385 } 7386 7387 7388 void bLEllipsisStartST(CuTest *tc UNUSED) { 7389 7390 char *r; 7391 char dest[6]; 7392 7393 // no ellipsis 7394 r = bLEllipsisStartS(dest, sizeof(dest), "sheepy", 10, "..."); 7395 ck_assert_str_eq(r, "sheep"); 7396 r = bLEllipsisStartS(dest, sizeof(dest), "sheepy", 6, "..."); 7397 ck_assert_str_eq(r, "sheep"); 7398 7399 // ellipsis 7400 r = bLEllipsisStartS(dest, sizeof(dest), "sheepy", 5, "..."); 7401 ck_assert_str_eq(r, "...py"); 7402 7403 // ellipsis longer than target length 7404 r = bLEllipsisStartS(dest, sizeof(dest), "sheepy", 5, "......"); 7405 ck_assert_str_eq(r, "....."); 7406 7407 // empty ellipsis 7408 r = bLEllipsisStartS(dest, sizeof(dest), "sheepy", 5, ""); 7409 ck_assert_str_eq(r, "heepy"); 7410 7411 // target length 0 7412 r = bLEllipsisStartS(dest, sizeof(dest), "sheepy", 0, "..."); 7413 ck_assert_str_eq(r, ""); 7414 7415 // dest size 0, dest unchanged 7416 dest[0] = 'a'; 7417 dest[1] = 0; 7418 r = bLEllipsisStartS(dest, 0, "sheepy", 5, ""); 7419 ck_assert_str_eq(r, "a"); 7420 7421 // null string 7422 ck_assert_ptr_eq(bLEllipsisStartS(dest, sizeof(dest), null,4,""), null); 7423 // null ellipsis 7424 ck_assert_ptr_eq(bLEllipsisStartS(dest, sizeof(dest), "",4,null), null); 7425 // null dest 7426 ck_assert_ptr_eq(bLEllipsisStartS(null, sizeof(dest), "",4,""), null); 7427 7428 7429 } 7430 7431 7432 void ellipsisStartCharST(CuTest *tc UNUSED) { 7433 7434 char *r; 7435 7436 // no ellipsis 7437 r = ellipsisStartCharS("sheepy", 10, '-'); 7438 ck_assert_str_eq(r, "sheepy"); 7439 free(r); 7440 r = ellipsisStartCharS("sheepy", 6, '-'); 7441 ck_assert_str_eq(r, "sheepy"); 7442 free(r); 7443 7444 // ellipsis 7445 r = ellipsisStartCharS("sheepy", 5, '-'); 7446 ck_assert_str_eq(r, "-eepy"); 7447 free(r); 7448 7449 // target length 0 7450 r = ellipsisStartCharS("sheepy", 0, '-'); 7451 ck_assert_str_eq(r, ""); 7452 free(r); 7453 7454 // null string 7455 ck_assert_ptr_eq(ellipsisStartCharS(null,4,'-'), null); 7456 7457 7458 } 7459 7460 7461 void iEllipsisStartCharST(CuTest *tc UNUSED) { 7462 7463 char *s, *r; 7464 7465 // no ellipsis 7466 s = strdup("sheepy"); 7467 r = iEllipsisStartCharS(&s, 10, '-'); 7468 ck_assert_str_eq(r, "sheepy"); 7469 free(r); 7470 s = strdup("sheepy"); 7471 r = iEllipsisStartCharS(&s, 6, '-'); 7472 ck_assert_str_eq(r, "sheepy"); 7473 free(r); 7474 7475 // ellipsis 7476 s = strdup("sheepy"); 7477 r = iEllipsisStartCharS(&s, 5, '-'); 7478 ck_assert_str_eq(r, "-eepy"); 7479 free(r); 7480 7481 // target length 0 7482 s = strdup("sheepy"); 7483 r = iEllipsisStartCharS(&s, 0, '-'); 7484 ck_assert_str_eq(r, ""); 7485 free(r); 7486 7487 // null string 7488 s = null; 7489 ck_assert_ptr_eq(iEllipsisStartCharS(&s,4,'-'), null); 7490 ck_assert_ptr_eq(iEllipsisStartCharS(null,4,'-'), null); 7491 7492 7493 } 7494 7495 7496 void bEllipsisStartCharST(CuTest *tc UNUSED) { 7497 7498 char *r; 7499 char dest[48]; 7500 7501 // no ellipsis 7502 r = bEllipsisStartCharS(dest, "sheepy", 10, '-'); 7503 ck_assert_str_eq(r, "sheepy"); 7504 r = bEllipsisStartCharS(dest, "sheepy", 6, '-'); 7505 ck_assert_str_eq(r, "sheepy"); 7506 7507 // ellipsis 7508 r = bEllipsisStartCharS(dest, "sheepy", 5, '-'); 7509 ck_assert_str_eq(r, "-eepy"); 7510 7511 // target length 0 7512 r = bEllipsisStartCharS(dest, "sheepy", 0, '-'); 7513 ck_assert_str_eq(r, ""); 7514 7515 // null string 7516 ck_assert_ptr_eq(bEllipsisStartCharS(dest, null,4,'-'), null); 7517 // null dest 7518 ck_assert_ptr_eq(bEllipsisStartCharS(null, "",4,'-'), null); 7519 7520 7521 } 7522 7523 7524 void bLEllipsisStartCharST(CuTest *tc UNUSED) { 7525 7526 char *r; 7527 char dest[6]; 7528 7529 // no ellipsis 7530 r = bLEllipsisStartCharS(dest, sizeof(dest), "sheepy", 10, '-'); 7531 ck_assert_str_eq(r, "sheep"); 7532 r = bLEllipsisStartCharS(dest, sizeof(dest), "sheepy", 6, '-'); 7533 ck_assert_str_eq(r, "sheep"); 7534 7535 // ellipsis 7536 r = bLEllipsisStartCharS(dest, sizeof(dest), "sheepy", 5, '-'); 7537 ck_assert_str_eq(r, "-eepy"); 7538 7539 // target length 0 7540 r = bLEllipsisStartCharS(dest, sizeof(dest), "sheepy", 0, '-'); 7541 ck_assert_str_eq(r, ""); 7542 7543 // dest size 0, dest unchanged 7544 dest[0] = 'a'; 7545 dest[1] = 0; 7546 r = bLEllipsisStartCharS(dest, 0, "sheepy", 5, '-'); 7547 ck_assert_str_eq(r, "a"); 7548 7549 // null string 7550 ck_assert_ptr_eq(bLEllipsisStartCharS(dest, sizeof(dest), null,4,'-'), null); 7551 // null dest 7552 ck_assert_ptr_eq(bLEllipsisStartCharS(null, sizeof(dest), "",4,'-'), null); 7553 7554 7555 } 7556 7557 7558 void ellipsisLenST(CuTest *tc UNUSED) { 7559 7560 ssize_t r; 7561 7562 // no ellipsis 7563 r = ellipsisLenS("sheepy", 10, "..."); 7564 ck_assert_int_eq(r, 6); 7565 r = ellipsisLenS("sheepy", 6, "..."); 7566 ck_assert_int_eq(r, 6); 7567 7568 // ellipsis 7569 r = ellipsisLenS("sheepy", 5, "..."); 7570 ck_assert_int_eq(r, 5); 7571 7572 // ellipsis longer than target length 7573 r = ellipsisLenS("sheepy", 5, "......"); 7574 ck_assert_int_eq(r, 5); 7575 7576 // empty ellipsis 7577 r = ellipsisLenS("sheepy", 5, ""); 7578 ck_assert_int_eq(r, 5); 7579 7580 // target length 0 7581 r = ellipsisLenS("sheepy", 0, "..."); 7582 ck_assert_int_eq(r, 0); 7583 7584 // null string 7585 ck_assert_int_eq(ellipsisLenS(null,4,""), -1); 7586 // null ellipsis 7587 ck_assert_int_eq(ellipsisLenS("",4,null), -1); 7588 7589 7590 } 7591 7592 7593 void ellipsisEndST(CuTest *tc UNUSED) { 7594 7595 char *r; 7596 7597 // no ellipsis 7598 r = ellipsisEndS("sheepy", 10, "..."); 7599 ck_assert_str_eq(r, "sheepy"); 7600 free(r); 7601 r = ellipsisEndS("sheepy", 6, "..."); 7602 ck_assert_str_eq(r, "sheepy"); 7603 free(r); 7604 7605 // ellipsis 7606 r = ellipsisEndS("sheepy", 5, "..."); 7607 ck_assert_str_eq(r, "sh..."); 7608 free(r); 7609 7610 // ellipsis longer than target length 7611 r = ellipsisEndS("sheepy", 5, "......"); 7612 ck_assert_str_eq(r, "....."); 7613 free(r); 7614 7615 // empty ellipsis 7616 r = ellipsisEndS("sheepy", 5, ""); 7617 ck_assert_str_eq(r, "sheep"); 7618 free(r); 7619 7620 // target length 0 7621 r = ellipsisEndS("sheepy", 0, "..."); 7622 ck_assert_str_eq(r, ""); 7623 free(r); 7624 7625 // null string 7626 ck_assert_ptr_eq(ellipsisEndS(null,4,""), null); 7627 // null ellipsis 7628 ck_assert_ptr_eq(ellipsisEndS("",4,null), null); 7629 7630 7631 } 7632 7633 7634 void iEllipsisEndST(CuTest *tc UNUSED) { 7635 7636 char *s, *r; 7637 7638 // no ellipsis 7639 s = strdup("sheepy"); 7640 r = iEllipsisEndS(&s, 10, "..."); 7641 ck_assert_str_eq(r, "sheepy"); 7642 free(r); 7643 s = strdup("sheepy"); 7644 r = iEllipsisEndS(&s, 6, "..."); 7645 ck_assert_str_eq(r, "sheepy"); 7646 free(r); 7647 7648 // ellipsis 7649 s = strdup("sheepy"); 7650 r = iEllipsisEndS(&s, 5, "..."); 7651 ck_assert_str_eq(r, "sh..."); 7652 free(r); 7653 7654 // ellipsis longer than target length 7655 s = strdup("sheepy"); 7656 r = iEllipsisEndS(&s, 5, "......"); 7657 ck_assert_str_eq(r, "....."); 7658 free(r); 7659 7660 // empty ellipsis 7661 s = strdup("sheepy"); 7662 r = iEllipsisEndS(&s, 5, ""); 7663 ck_assert_str_eq(r, "sheep"); 7664 free(r); 7665 7666 // target length 0 7667 s = strdup("sheepy"); 7668 r = iEllipsisEndS(&s, 0, "..."); 7669 ck_assert_str_eq(r, ""); 7670 free(r); 7671 7672 // null string 7673 s = null; 7674 ck_assert_ptr_eq(iEllipsisEndS(&s,4,""), null); 7675 ck_assert_ptr_eq(iEllipsisEndS(null,4,""), null); 7676 // null ellipsis 7677 s = strdup("sd"); 7678 ck_assert_ptr_eq(iEllipsisEndS(&s,4,null), null); 7679 free(s); 7680 7681 7682 } 7683 7684 7685 void bEllipsisEndST(CuTest *tc UNUSED) { 7686 7687 char *r; 7688 char dest[48]; 7689 7690 // no ellipsis 7691 r = bEllipsisEndS(dest, "sheepy", 10, "..."); 7692 ck_assert_str_eq(r, "sheepy"); 7693 r = bEllipsisEndS(dest, "sheepy", 6, "..."); 7694 ck_assert_str_eq(r, "sheepy"); 7695 7696 // ellipsis 7697 r = bEllipsisEndS(dest, "sheepy", 5, "..."); 7698 ck_assert_str_eq(r, "sh..."); 7699 7700 // ellipsis longer than target length 7701 r = bEllipsisEndS(dest, "sheepy", 5, "......"); 7702 ck_assert_str_eq(r, "....."); 7703 7704 // empty ellipsis 7705 r = bEllipsisEndS(dest, "sheepy", 5, ""); 7706 ck_assert_str_eq(r, "sheep"); 7707 7708 // target length 0 7709 r = bEllipsisEndS(dest, "sheepy", 0, "..."); 7710 ck_assert_str_eq(r, ""); 7711 7712 // null string 7713 ck_assert_ptr_eq(bEllipsisEndS(dest, null,4,""), null); 7714 // null ellipsis 7715 ck_assert_ptr_eq(bEllipsisEndS(dest, "",4,null), null); 7716 // null dest 7717 ck_assert_ptr_eq(bEllipsisEndS(null, "",4,""), null); 7718 7719 7720 } 7721 7722 7723 void bLEllipsisEndST(CuTest *tc UNUSED) { 7724 7725 char *r; 7726 char dest[6]; 7727 7728 // no ellipsis 7729 r = bLEllipsisEndS(dest, sizeof(dest), "sheepy", 10, "..."); 7730 ck_assert_str_eq(r, "sheep"); 7731 r = bLEllipsisEndS(dest, sizeof(dest), "sheepy", 6, "..."); 7732 ck_assert_str_eq(r, "sheep"); 7733 7734 // ellipsis 7735 r = bLEllipsisEndS(dest, sizeof(dest), "sheepy", 5, "..."); 7736 ck_assert_str_eq(r, "sh..."); 7737 7738 // ellipsis longer than target length 7739 r = bLEllipsisEndS(dest, sizeof(dest), "sheepy", 5, "......"); 7740 ck_assert_str_eq(r, "....."); 7741 7742 // empty ellipsis 7743 r = bLEllipsisEndS(dest, sizeof(dest), "sheepy", 4, ""); 7744 ck_assert_str_eq(r, "shee"); 7745 7746 // target length 0 7747 r = bLEllipsisEndS(dest, sizeof(dest), "sheepy", 0, "..."); 7748 ck_assert_str_eq(r, ""); 7749 7750 // dest size 0, dest unchanged 7751 dest[0] = 'a'; 7752 dest[1] = 0; 7753 r = bLEllipsisEndS(dest, 0, "sheepy", 5, ""); 7754 ck_assert_str_eq(r, "a"); 7755 7756 // null string 7757 ck_assert_ptr_eq(bLEllipsisEndS(dest, sizeof(dest), null,4,""), null); 7758 // null ellipsis 7759 ck_assert_ptr_eq(bLEllipsisEndS(dest, sizeof(dest), "",4,null), null); 7760 // null dest 7761 ck_assert_ptr_eq(bLEllipsisEndS(null, sizeof(dest), "",4,""), null); 7762 7763 7764 } 7765 7766 7767 void ellipsisEndCharST(CuTest *tc UNUSED) { 7768 7769 char *r; 7770 7771 // no ellipsis 7772 r = ellipsisEndCharS("sheepy", 10, '-'); 7773 ck_assert_str_eq(r, "sheepy"); 7774 free(r); 7775 r = ellipsisEndCharS("sheepy", 6, '-'); 7776 ck_assert_str_eq(r, "sheepy"); 7777 free(r); 7778 7779 // ellipsis 7780 r = ellipsisEndCharS("sheepy", 5, '-'); 7781 ck_assert_str_eq(r, "shee-"); 7782 free(r); 7783 7784 // target length 0 7785 r = ellipsisEndCharS("sheepy", 0, '-'); 7786 ck_assert_str_eq(r, ""); 7787 free(r); 7788 7789 // null string 7790 ck_assert_ptr_eq(ellipsisEndCharS(null,4,'-'), null); 7791 7792 7793 } 7794 7795 7796 void iEllipsisEndCharST(CuTest *tc UNUSED) { 7797 7798 char *s, *r; 7799 7800 // no ellipsis 7801 s = strdup("sheepy"); 7802 r = iEllipsisEndCharS(&s, 10, '-'); 7803 ck_assert_str_eq(r, "sheepy"); 7804 free(r); 7805 s = strdup("sheepy"); 7806 r = iEllipsisEndCharS(&s, 6, '-'); 7807 ck_assert_str_eq(r, "sheepy"); 7808 free(r); 7809 7810 // ellipsis 7811 s = strdup("sheepy"); 7812 r = iEllipsisEndCharS(&s, 5, '-'); 7813 ck_assert_str_eq(r, "shee-"); 7814 free(r); 7815 7816 // target length 0 7817 s = strdup("sheepy"); 7818 r = iEllipsisEndCharS(&s, 0, '-'); 7819 ck_assert_str_eq(r, ""); 7820 free(r); 7821 7822 // null string 7823 s = null; 7824 ck_assert_ptr_eq(iEllipsisEndCharS(&s,4,'-'), null); 7825 ck_assert_ptr_eq(iEllipsisEndCharS(null,4,'-'), null); 7826 7827 7828 } 7829 7830 7831 void bEllipsisEndCharST(CuTest *tc UNUSED) { 7832 7833 char *r; 7834 char dest[48]; 7835 7836 // no ellipsis 7837 r = bEllipsisEndCharS(dest, "sheepy", 10, '-'); 7838 ck_assert_str_eq(r, "sheepy"); 7839 r = bEllipsisEndCharS(dest, "sheepy", 6, '-'); 7840 ck_assert_str_eq(r, "sheepy"); 7841 7842 // ellipsis 7843 r = bEllipsisEndCharS(dest, "sheepy", 5, '-'); 7844 ck_assert_str_eq(r, "shee-"); 7845 7846 // target length 0 7847 r = bEllipsisEndCharS(dest, "sheepy", 0, '-'); 7848 ck_assert_str_eq(r, ""); 7849 7850 // null string 7851 ck_assert_ptr_eq(bEllipsisEndCharS(dest, null,4,'-'), null); 7852 // null dest 7853 ck_assert_ptr_eq(bEllipsisEndCharS(null, "",4,'-'), null); 7854 7855 7856 } 7857 7858 7859 void bLEllipsisEndCharST(CuTest *tc UNUSED) { 7860 7861 char *r; 7862 char dest[6]; 7863 7864 // no ellipsis 7865 r = bLEllipsisEndCharS(dest, sizeof(dest), "sheepy", 10, '-'); 7866 ck_assert_str_eq(r, "sheep"); 7867 r = bLEllipsisEndCharS(dest, sizeof(dest), "sheepy", 6, '-'); 7868 ck_assert_str_eq(r, "sheep"); 7869 7870 // ellipsis 7871 r = bLEllipsisEndCharS(dest, sizeof(dest), "sheepy", 5, '-'); 7872 ck_assert_str_eq(r, "shee-"); 7873 7874 // target length 0 7875 r = bLEllipsisEndCharS(dest, sizeof(dest), "sheepy", 0, '-'); 7876 ck_assert_str_eq(r, ""); 7877 7878 // dest size 0, dest unchanged 7879 dest[0] = 'a'; 7880 dest[1] = 0; 7881 r = bLEllipsisEndCharS(dest, 0, "sheepy", 5, '-'); 7882 ck_assert_str_eq(r, "a"); 7883 7884 // null string 7885 ck_assert_ptr_eq(bLEllipsisEndCharS(dest, sizeof(dest), null,4,'-'), null); 7886 // null dest 7887 ck_assert_ptr_eq(bLEllipsisEndCharS(null, sizeof(dest), "",4,'-'), null); 7888 7889 7890 } 7891 7892 7893 void padStartST(CuTest *tc UNUSED) { 7894 7895 char *r; 7896 7897 // pad string 7898 r = padStartS("sheepy", 10, ">>>"); 7899 ck_assert_str_eq(r, ">>>>sheepy"); 7900 free(r); 7901 7902 r = padStartS("sheepy", 7, ">>>"); 7903 ck_assert_str_eq(r, ">sheepy"); 7904 free(r); 7905 7906 // string bigger than target length 7907 r = padStartS("sheepy", 4, ">>>"); 7908 ck_assert_str_eq(r, "sheepy"); 7909 free(r); 7910 7911 // empty pad string 7912 r = padStartS("sheepy", 10, ""); 7913 ck_assert_str_eq(r, "sheepy"); 7914 free(r); 7915 7916 // null pad string 7917 r = padStartS("sheepy", 4, null); 7918 ck_assert_str_eq(r, "sheepy"); 7919 free(r); 7920 r = padStartS("sheepy", 10, null); 7921 ck_assert_ptr_eq(r, null); 7922 7923 // null string 7924 r = padStartS(null, 4, "q"); 7925 ck_assert_ptr_eq(r, null); 7926 7927 } 7928 7929 7930 void iPadStartST(CuTest *tc UNUSED) { 7931 7932 char *s, *r; 7933 7934 // pad string 7935 s = strdup("sheepy"); 7936 r = iPadStartS(&s, 10, ">>>"); 7937 ck_assert_str_eq(r, ">>>>sheepy"); 7938 free(r); 7939 7940 s = strdup("sheepy"); 7941 r = iPadStartS(&s, 7, ">>>"); 7942 ck_assert_str_eq(r, ">sheepy"); 7943 free(r); 7944 7945 // string bigger than target length 7946 s = strdup("sheepy"); 7947 r = iPadStartS(&s, 4, ">>>"); 7948 ck_assert_str_eq(r, "sheepy"); 7949 free(r); 7950 7951 // empty pad string 7952 s = strdup("sheepy"); 7953 r = iPadStartS(&s, 10, ""); 7954 ck_assert_str_eq(r, "sheepy"); 7955 free(r); 7956 7957 // null pad string 7958 s = strdup("sheepy"); 7959 r = iPadStartS(&s, 4, null); 7960 ck_assert_str_eq(r, "sheepy"); 7961 free(r); 7962 s = strdup("sheepy"); 7963 r = iPadStartS(&s, 10, null); 7964 ck_assert_ptr_eq(r, null); 7965 free(s); 7966 7967 // null string 7968 s = null; 7969 r = iPadStartS(&s, 4, "q"); 7970 ck_assert_ptr_eq(r, null); 7971 r = iPadStartS(null, 4, "q"); 7972 ck_assert_ptr_eq(r, null); 7973 7974 7975 } 7976 7977 7978 void bPadStartST(CuTest *tc UNUSED) { 7979 7980 char *r; 7981 char b[48]; 7982 7983 // pad string 7984 r = bPadStartS(b, "sheepy", 10, ">>>"); 7985 ck_assert_str_eq(r, ">>>>sheepy"); 7986 7987 r = bPadStartS(b, "sheepy", 7, ">>>"); 7988 ck_assert_str_eq(r, ">sheepy"); 7989 7990 // string bigger than target length 7991 r = bPadStartS(b, "sheepy", 4, ">>>"); 7992 ck_assert_str_eq(r, "sheepy"); 7993 7994 // empty pad string 7995 r = bPadStartS(b, "sheepy", 10, ""); 7996 ck_assert_str_eq(r, "sheepy"); 7997 7998 // null pad string 7999 r = bPadStartS(b, "sheepy", 4, null); 8000 ck_assert_str_eq(r, "sheepy"); 8001 r = bPadStartS(b, "sheepy", 10, null); 8002 ck_assert_ptr_eq(r, null); 8003 8004 // null string 8005 r = bPadStartS(b, null, 4, "q"); 8006 ck_assert_ptr_eq(r, null); 8007 8008 // null dest 8009 r = bPadStartS(null, "d", 4, "q"); 8010 ck_assert_ptr_eq(r, null); 8011 8012 8013 } 8014 8015 8016 void bLPadStartST(CuTest *tc UNUSED) { 8017 8018 char *r; 8019 char b[48]; 8020 8021 // pad string 8022 r = bLPadStartS(b, sizeof(b), "sheepy", 10, ">>>"); 8023 ck_assert_str_eq(r, ">>>>sheepy"); 8024 r = bLPadStartS(b, sizeof(b), "sheepy", 7, ">>>"); 8025 ck_assert_str_eq(r, ">sheepy"); 8026 // smaller dest size 8027 r = bLPadStartS(b, 4, "sheepy", 7, ">>>"); 8028 ck_assert_str_eq(r, ">sh"); 8029 8030 // string bigger than target length 8031 r = bLPadStartS(b, sizeof(b), "sheepy", 4, ">>>"); 8032 ck_assert_str_eq(r, "sheepy"); 8033 // smaller dest size 8034 r = bLPadStartS(b, 4, "sheepy", 4, ">>>"); 8035 ck_assert_str_eq(r, "she"); 8036 8037 // empty pad string 8038 r = bLPadStartS(b, sizeof(b), "sheepy", 10, ""); 8039 ck_assert_str_eq(r, "sheepy"); 8040 // smaller dest size 8041 r = bLPadStartS(b, 4, "sheepy", 10, ""); 8042 ck_assert_str_eq(r, "she"); 8043 8044 8045 // null pad string 8046 r = bLPadStartS(b, sizeof(b), "sheepy", 4, null); 8047 ck_assert_str_eq(r, "sheepy"); 8048 r = bLPadStartS(b, sizeof(b), "sheepy", 10, null); 8049 ck_assert_ptr_eq(r, null); 8050 8051 // null string 8052 r = bLPadStartS(b, sizeof(b), null, 4, "q"); 8053 ck_assert_ptr_eq(r, null); 8054 8055 // null dest 8056 r = bLPadStartS(null, sizeof(b), "d", 4, "q"); 8057 ck_assert_ptr_eq(r, null); 8058 8059 8060 } 8061 8062 8063 void padStartCharST(CuTest *tc UNUSED) { 8064 8065 char *r; 8066 8067 // pad string 8068 r = padStartCharS("sheepy", 10, '>'); 8069 ck_assert_str_eq(r, ">>>>sheepy"); 8070 free(r); 8071 8072 r = padStartCharS("sheepy", 7, '>'); 8073 ck_assert_str_eq(r, ">sheepy"); 8074 free(r); 8075 8076 // string bigger than target length 8077 r = padStartCharS("sheepy", 4, '>'); 8078 ck_assert_str_eq(r, "sheepy"); 8079 free(r); 8080 8081 // null string 8082 r = padStartCharS(null, 4, 'q'); 8083 ck_assert_ptr_eq(r, null); 8084 8085 8086 } 8087 8088 8089 void iPadStartCharST(CuTest *tc UNUSED) { 8090 8091 char *s, *r; 8092 8093 // pad string 8094 s = strdup("sheepy"); 8095 r = iPadStartCharS(&s, 10, '>'); 8096 ck_assert_str_eq(r, ">>>>sheepy"); 8097 free(r); 8098 8099 s = strdup("sheepy"); 8100 r = iPadStartCharS(&s, 7, '>'); 8101 ck_assert_str_eq(r, ">sheepy"); 8102 free(r); 8103 8104 // string bigger than target length 8105 s = strdup("sheepy"); 8106 r = iPadStartCharS(&s, 4, '>'); 8107 ck_assert_str_eq(r, "sheepy"); 8108 free(r); 8109 8110 // null string 8111 s = null; 8112 r = iPadStartCharS(&s, 4, 'q'); 8113 ck_assert_ptr_eq(r, null); 8114 r = iPadStartCharS(null, 4, 'q'); 8115 ck_assert_ptr_eq(r, null); 8116 8117 8118 } 8119 8120 8121 void bPadStartCharST(CuTest *tc UNUSED) { 8122 8123 char *r; 8124 char b[48]; 8125 8126 // pad string 8127 r = bPadStartCharS(b, "sheepy", 10, '>'); 8128 ck_assert_str_eq(r, ">>>>sheepy"); 8129 8130 r = bPadStartCharS(b, "sheepy", 7, '>'); 8131 ck_assert_str_eq(r, ">sheepy"); 8132 8133 // string bigger than target length 8134 r = bPadStartCharS(b, "sheepy", 4, '>'); 8135 ck_assert_str_eq(r, "sheepy"); 8136 8137 // null string 8138 r = bPadStartCharS(b, null, 4, 'q'); 8139 ck_assert_ptr_eq(r, null); 8140 8141 // null dest 8142 r = bPadStartCharS(null, "d", 4, 'q'); 8143 ck_assert_ptr_eq(r, null); 8144 8145 8146 } 8147 8148 8149 void bLPadStartCharST(CuTest *tc UNUSED) { 8150 8151 char *r; 8152 char b[48]; 8153 8154 // pad string 8155 r = bLPadStartCharS(b, sizeof(b), "sheepy", 10, '>'); 8156 ck_assert_str_eq(r, ">>>>sheepy"); 8157 r = bLPadStartCharS(b, sizeof(b), "sheepy", 7, '>'); 8158 ck_assert_str_eq(r, ">sheepy"); 8159 // smaller dest size 8160 r = bLPadStartCharS(b, 4, "sheepy", 7, '>'); 8161 ck_assert_str_eq(r, ">sh"); 8162 8163 // string bigger than target length 8164 r = bLPadStartCharS(b, sizeof(b), "sheepy", 4, '>'); 8165 ck_assert_str_eq(r, "sheepy"); 8166 // smaller dest size 8167 r = bLPadStartCharS(b, 4, "sheepy", 4, '>'); 8168 ck_assert_str_eq(r, "she"); 8169 8170 // null string 8171 r = bLPadStartCharS(b, sizeof(b), null, 4, 'q'); 8172 ck_assert_ptr_eq(r, null); 8173 8174 // null dest 8175 r = bLPadStartCharS(null, sizeof(b), "d", 4, 'q'); 8176 ck_assert_ptr_eq(r, null); 8177 8178 8179 } 8180 8181 8182 void padStartLenST(CuTest *tc UNUSED) { 8183 8184 ssize_t r; 8185 8186 // pad string 8187 r = padStartLenS("sheepy", 10, ">>>"); 8188 ck_assert_int_eq(r, 10); 8189 8190 r = padStartLenS("sheepy", 7, ">>>"); 8191 ck_assert_int_eq(r, 7); 8192 8193 // string bigger than target length 8194 r = padStartLenS("sheepy", 4, ">>>"); 8195 ck_assert_int_eq(r, 6); 8196 8197 // empty pad string 8198 r = padStartLenS("sheepy", 10, ""); 8199 ck_assert_int_eq(r, 6); 8200 8201 // null pad string 8202 r = padStartLenS("sheepy", 4, null); 8203 ck_assert_int_eq(r, 6); 8204 r = padStartLenS("sheepy", 10, null); 8205 ck_assert_int_eq(r, -1); 8206 8207 // null string 8208 r = padStartLenS(null, 4, "q"); 8209 ck_assert_int_eq(r, -1); 8210 8211 8212 } 8213 8214 8215 void padEndST(CuTest *tc UNUSED) { 8216 8217 char *r; 8218 8219 // pad string 8220 r = padEndS("sheepy", 10, ">>>"); 8221 ck_assert_str_eq(r, "sheepy>>>>"); 8222 free(r); 8223 8224 r = padEndS("sheepy", 7, ">>>"); 8225 ck_assert_str_eq(r, "sheepy>"); 8226 free(r); 8227 8228 // string bigger than target length 8229 r = padEndS("sheepy", 4, ">>>"); 8230 ck_assert_str_eq(r, "sheepy"); 8231 free(r); 8232 8233 // empty pad string 8234 r = padEndS("sheepy", 10, ""); 8235 ck_assert_str_eq(r, "sheepy"); 8236 free(r); 8237 8238 // null pad string 8239 r = padEndS("sheepy", 4, null); 8240 ck_assert_str_eq(r, "sheepy"); 8241 free(r); 8242 r = padEndS("sheepy", 10, null); 8243 ck_assert_ptr_eq(r, null); 8244 8245 // null string 8246 r = padEndS(null, 4, "q"); 8247 ck_assert_ptr_eq(r, null); 8248 8249 8250 } 8251 8252 8253 void iPadEndST(CuTest *tc UNUSED) { 8254 8255 char *s, *r; 8256 8257 // pad string 8258 s = strdup("sheepy"); 8259 r = iPadEndS(&s, 10, ">>>"); 8260 ck_assert_str_eq(r, "sheepy>>>>"); 8261 free(r); 8262 8263 s = strdup("sheepy"); 8264 r = iPadEndS(&s, 7, ">>>"); 8265 ck_assert_str_eq(r, "sheepy>"); 8266 free(r); 8267 8268 // string bigger than target length 8269 s = strdup("sheepy"); 8270 r = iPadEndS(&s, 4, ">>>"); 8271 ck_assert_str_eq(r, "sheepy"); 8272 free(r); 8273 8274 // empty pad string 8275 s = strdup("sheepy"); 8276 r = iPadEndS(&s, 10, ""); 8277 ck_assert_str_eq(r, "sheepy"); 8278 free(r); 8279 8280 // null pad string 8281 s = strdup("sheepy"); 8282 r = iPadEndS(&s, 4, null); 8283 ck_assert_str_eq(r, "sheepy"); 8284 free(r); 8285 s = strdup("sheepy"); 8286 r = iPadEndS(&s, 10, null); 8287 ck_assert_ptr_eq(r, null); 8288 free(s); 8289 8290 // null string 8291 s = null; 8292 r = iPadEndS(&s, 4, "q"); 8293 ck_assert_ptr_eq(r, null); 8294 r = iPadEndS(null, 4, "q"); 8295 ck_assert_ptr_eq(r, null); 8296 8297 8298 } 8299 8300 8301 void bPadEndST(CuTest *tc UNUSED) { 8302 8303 char *r; 8304 char b[48]; 8305 8306 // pad string 8307 r = bPadEndS(b, "sheepy", 10, ">>>"); 8308 ck_assert_str_eq(r, "sheepy>>>>"); 8309 8310 r = bPadEndS(b, "sheepy", 7, ">>>"); 8311 ck_assert_str_eq(r, "sheepy>"); 8312 8313 // string bigger than target length 8314 r = bPadEndS(b, "sheepy", 4, ">>>"); 8315 ck_assert_str_eq(r, "sheepy"); 8316 8317 // empty pad string 8318 r = bPadEndS(b, "sheepy", 10, ""); 8319 ck_assert_str_eq(r, "sheepy"); 8320 8321 // null pad string 8322 r = bPadEndS(b, "sheepy", 4, null); 8323 ck_assert_str_eq(r, "sheepy"); 8324 r = bPadEndS(b, "sheepy", 10, null); 8325 ck_assert_ptr_eq(r, null); 8326 8327 // null string 8328 r = bPadEndS(b, null, 4, "q"); 8329 ck_assert_ptr_eq(r, null); 8330 8331 // null dest 8332 r = bPadEndS(null, "d", 4, "q"); 8333 ck_assert_ptr_eq(r, null); 8334 8335 8336 } 8337 8338 8339 void bLPadEndST(CuTest *tc UNUSED) { 8340 8341 char *r; 8342 char b[48]; 8343 8344 // pad string 8345 r = bLPadEndS(b, sizeof(b), "sheepy", 10, ">>>"); 8346 ck_assert_str_eq(r, "sheepy>>>>"); 8347 r = bLPadEndS(b, sizeof(b), "sheepy", 7, ">>>"); 8348 ck_assert_str_eq(r, "sheepy>"); 8349 // smaller dest size 8350 r = bLPadEndS(b, 4, "sheepy", 7, ">>>"); 8351 ck_assert_str_eq(r, "she"); 8352 8353 // string bigger than target length 8354 r = bLPadEndS(b, sizeof(b), "sheepy", 4, ">>>"); 8355 ck_assert_str_eq(r, "sheepy"); 8356 // smaller dest size 8357 r = bLPadEndS(b, 4, "sheepy", 4, ">>>"); 8358 ck_assert_str_eq(r, "she"); 8359 8360 // empty pad string 8361 r = bLPadEndS(b, sizeof(b), "sheepy", 10, ""); 8362 ck_assert_str_eq(r, "sheepy"); 8363 // smaller dest size 8364 r = bLPadEndS(b, 4, "sheepy", 10, ""); 8365 ck_assert_str_eq(r, "she"); 8366 8367 8368 // null pad string 8369 r = bLPadEndS(b, sizeof(b), "sheepy", 4, null); 8370 ck_assert_str_eq(r, "sheepy"); 8371 r = bLPadEndS(b, sizeof(b), "sheepy", 10, null); 8372 ck_assert_ptr_eq(r, null); 8373 8374 // null string 8375 r = bLPadEndS(b, sizeof(b), null, 4, "q"); 8376 ck_assert_ptr_eq(r, null); 8377 8378 // null dest 8379 r = bLPadEndS(null, sizeof(b), "d", 4, "q"); 8380 ck_assert_ptr_eq(r, null); 8381 8382 8383 } 8384 8385 8386 void padEndCharST(CuTest *tc UNUSED) { 8387 8388 char *r; 8389 8390 // pad string 8391 r = padEndCharS("sheepy", 10, '>'); 8392 ck_assert_str_eq(r, "sheepy>>>>"); 8393 free(r); 8394 8395 r = padEndCharS("sheepy", 7, '>'); 8396 ck_assert_str_eq(r, "sheepy>"); 8397 free(r); 8398 8399 // string bigger than target length 8400 r = padEndCharS("sheepy", 4, '>'); 8401 ck_assert_str_eq(r, "sheepy"); 8402 free(r); 8403 8404 // null string 8405 r = padEndCharS(null, 4, 'q'); 8406 ck_assert_ptr_eq(r, null); 8407 8408 8409 } 8410 8411 8412 void iPadEndCharST(CuTest *tc UNUSED) { 8413 8414 char *s, *r; 8415 8416 // pad string 8417 s = strdup("sheepy"); 8418 r = iPadEndCharS(&s, 10, '>'); 8419 ck_assert_str_eq(r, "sheepy>>>>"); 8420 free(r); 8421 8422 s = strdup("sheepy"); 8423 r = iPadEndCharS(&s, 7, '>'); 8424 ck_assert_str_eq(r, "sheepy>"); 8425 free(r); 8426 8427 // string bigger than target length 8428 s = strdup("sheepy"); 8429 r = iPadEndCharS(&s, 4, '>'); 8430 ck_assert_str_eq(r, "sheepy"); 8431 free(r); 8432 8433 // null string 8434 s = null; 8435 r = iPadEndCharS(&s, 4, 'q'); 8436 ck_assert_ptr_eq(r, null); 8437 r = iPadEndCharS(null, 4, 'q'); 8438 ck_assert_ptr_eq(r, null); 8439 8440 8441 } 8442 8443 8444 void bPadEndCharST(CuTest *tc UNUSED) { 8445 8446 char *r; 8447 char b[48]; 8448 8449 // pad string 8450 r = bPadEndCharS(b, "sheepy", 10, '>'); 8451 ck_assert_str_eq(r, "sheepy>>>>"); 8452 8453 r = bPadEndCharS(b, "sheepy", 7, '>'); 8454 ck_assert_str_eq(r, "sheepy>"); 8455 8456 // string bigger than target length 8457 r = bPadEndCharS(b, "sheepy", 4, '>'); 8458 ck_assert_str_eq(r, "sheepy"); 8459 8460 // null string 8461 r = bPadEndCharS(b, null, 4, 'q'); 8462 ck_assert_ptr_eq(r, null); 8463 8464 // null dest 8465 r = bPadEndCharS(null, "d", 4, 'q'); 8466 ck_assert_ptr_eq(r, null); 8467 8468 8469 } 8470 8471 8472 void bLPadEndCharST(CuTest *tc UNUSED) { 8473 8474 char *r; 8475 char b[48]; 8476 8477 // pad string 8478 r = bLPadEndCharS(b, sizeof(b), "sheepy", 10, '>'); 8479 ck_assert_str_eq(r, "sheepy>>>>"); 8480 r = bLPadEndCharS(b, sizeof(b), "sheepy", 7, '>'); 8481 ck_assert_str_eq(r, "sheepy>"); 8482 // smaller dest size 8483 r = bLPadEndCharS(b, 4, "sheepy", 7, '>'); 8484 ck_assert_str_eq(r, "she"); 8485 8486 // string bigger than target length 8487 r = bLPadEndCharS(b, sizeof(b), "sheepy", 4, '>'); 8488 ck_assert_str_eq(r, "sheepy"); 8489 // smaller dest size 8490 r = bLPadEndCharS(b, 4, "sheepy", 4, '>'); 8491 ck_assert_str_eq(r, "she"); 8492 8493 // null string 8494 r = bLPadEndCharS(b, sizeof(b), null, 4, 'q'); 8495 ck_assert_ptr_eq(r, null); 8496 8497 // null dest 8498 r = bLPadEndCharS(null, sizeof(b), "d", 4, 'q'); 8499 ck_assert_ptr_eq(r, null); 8500 8501 8502 } 8503 8504 8505 void padEndLenST(CuTest *tc UNUSED) { 8506 8507 ssize_t r; 8508 8509 // pad string 8510 r = padEndLenS("sheepy", 10, ">>>"); 8511 ck_assert_int_eq(r, 10); 8512 8513 r = padEndLenS("sheepy", 7, ">>>"); 8514 ck_assert_int_eq(r, 7); 8515 8516 // string bigger than target length 8517 r = padEndLenS("sheepy", 4, ">>>"); 8518 ck_assert_int_eq(r, 6); 8519 8520 // empty pad string 8521 r = padEndLenS("sheepy", 10, ""); 8522 ck_assert_int_eq(r, 6); 8523 8524 // null pad string 8525 r = padEndLenS("sheepy", 4, null); 8526 ck_assert_int_eq(r, 6); 8527 r = padEndLenS("sheepy", 10, null); 8528 ck_assert_int_eq(r, -1); 8529 8530 // null string 8531 r = padEndLenS(null, 4, "q"); 8532 ck_assert_int_eq(r, -1); 8533 8534 8535 } 8536 8537 8538 void getST(CuTest *tc UNUSED) { 8539 8540 // get char 8541 ck_assert_uint_eq(getS("sheepy", 0), 's'); 8542 // negative index 8543 ck_assert_uint_eq(getS("sheepy", -1), 'y'); 8544 // outside string 8545 ck_assert_uint_eq(getS("sheepy", 10), 0); 8546 ck_assert_uint_eq(getS("sheepy", -10), 0); 8547 // negative index in a one char string 8548 ck_assert_uint_eq(getS("z", -1), 'z'); 8549 // empty string 8550 ck_assert_uint_eq(getS("", 0), 0); 8551 // NULL string 8552 ck_assert_uint_eq(getS(NULL, 0), 0); 8553 8554 } 8555 8556 8557 void setST(CuTest *tc UNUSED) { 8558 8559 char *s; 8560 char *r = null; 8561 8562 s = strdup("sheepy"); 8563 8564 // set char 8565 r = setS(s, 0, 'S'); 8566 ck_assert_ptr_eq(r, s); 8567 ck_assert_uint_eq(s[0], 'S'); 8568 // negative index 8569 r = setS(s, -2, 'P'); 8570 ck_assert_ptr_eq(r, s); 8571 ck_assert_uint_eq(s[4], 'P'); 8572 // outside string 8573 r = setS(s, 20, 'Y'); 8574 ck_assert_ptr_eq(r, null); 8575 r = setS(s, -20, 'Y'); 8576 ck_assert_ptr_eq(r, null); 8577 ck_assert_str_eq(s, "SheePy"); 8578 free(s); 8579 // negative index in a one char string 8580 s = strdup("s"); 8581 r = setS(s, -1, 'S'); 8582 ck_assert_ptr_eq(r, s); 8583 ck_assert_uint_eq(s[0], 'S'); 8584 free(s); 8585 // empty string 8586 emptyS(s); 8587 r = setS(s, -1, 'S'); 8588 ck_assert_ptr_eq(r, null); 8589 ck_assert_str_eq(s, ""); 8590 free(s); 8591 // NULL string 8592 r = setS(NULL, 0, 's'); 8593 ck_assert_ptr_eq(r, null); 8594 8595 8596 } 8597 8598 8599 void swapST(CuTest *tc UNUSED) { 8600 8601 char *r; 8602 8603 // swap 8604 r = swapS("sheepy", 0, 2); 8605 ck_assert_str_eq(r, "ehsepy"); 8606 free(r); 8607 r = swapS("sheepy", -6, 2); 8608 ck_assert_str_eq(r, "ehsepy"); 8609 free(r); 8610 r = swapS("sheepy", 2, 0); 8611 ck_assert_str_eq(r, "ehsepy"); 8612 free(r); 8613 r = swapS("sheepy", 2, -6); 8614 ck_assert_str_eq(r, "ehsepy"); 8615 free(r); 8616 8617 // index1 >= len 8618 r = swapS("sheepy", 6, 2); 8619 ck_assert_ptr_eq(r, null); 8620 8621 // index2 >= len 8622 r = swapS("sheepy", 2, 6); 8623 ck_assert_ptr_eq(r, null); 8624 8625 // index1 < -len 8626 r = swapS("sheepy", -10, 2); 8627 ck_assert_ptr_eq(r, null); 8628 8629 // index2 < -len 8630 r = swapS("sheepy", 2, -7); 8631 ck_assert_ptr_eq(r, null); 8632 8633 // null string 8634 r = swapS(null, 0, 2); 8635 ck_assert_ptr_eq(r, null); 8636 8637 } 8638 8639 8640 void iSwapST(CuTest *tc UNUSED) { 8641 8642 char *b; 8643 char *r; 8644 8645 // swap 8646 b = strdup("sheepy"); 8647 r = iSwapS(&b, 0, 2); 8648 ck_assert_str_eq(r, "ehsepy"); 8649 free(r); 8650 b = strdup("sheepy"); 8651 r = iSwapS(&b, -6, 2); 8652 ck_assert_str_eq(r, "ehsepy"); 8653 free(r); 8654 b = strdup("sheepy"); 8655 r = iSwapS(&b, 2, 0); 8656 ck_assert_str_eq(r, "ehsepy"); 8657 free(r); 8658 b = strdup("sheepy"); 8659 r = iSwapS(&b, 2, -6); 8660 ck_assert_str_eq(r, "ehsepy"); 8661 free(r); 8662 8663 b = strdup("sheepy"); 8664 8665 // index1 >= len 8666 r = iSwapS(&b, 6, 2); 8667 ck_assert_ptr_eq(r, null); 8668 8669 // index2 >= len 8670 r = iSwapS(&b, 2, 6); 8671 ck_assert_ptr_eq(r, null); 8672 8673 // index1 < -len 8674 r = iSwapS(&b, -10, 2); 8675 ck_assert_ptr_eq(r, null); 8676 8677 // index2 < -len 8678 r = iSwapS(&b, 2, -7); 8679 ck_assert_ptr_eq(r, null); 8680 8681 free(b); 8682 8683 // null string 8684 b = null; 8685 r = iSwapS(&b, 0, 2); 8686 ck_assert_ptr_eq(r, null); 8687 r = iSwapS(null, 0, 2); 8688 ck_assert_ptr_eq(r, null); 8689 8690 8691 } 8692 8693 8694 void bSwapST(CuTest *tc UNUSED) { 8695 8696 char b[20]; 8697 char *r; 8698 8699 // swap 8700 strcpy(b, "sheepy"); 8701 r = bSwapS(b, 0, 2); 8702 ck_assert_str_eq(r, "ehsepy"); 8703 strcpy(b, "sheepy"); 8704 r = bSwapS(b, -6, 2); 8705 ck_assert_str_eq(r, "ehsepy"); 8706 strcpy(b, "sheepy"); 8707 r = bSwapS(b, 2, 0); 8708 ck_assert_str_eq(r, "ehsepy"); 8709 strcpy(b, "sheepy"); 8710 r = bSwapS(b, 2, -6); 8711 ck_assert_str_eq(r, "ehsepy"); 8712 8713 // index1 >= len 8714 r = bSwapS("sheepy", 6, 2); 8715 ck_assert_ptr_eq(r, null); 8716 8717 // index2 >= len 8718 r = bSwapS("sheepy", 2, 6); 8719 ck_assert_ptr_eq(r, null); 8720 8721 // index1 < -len 8722 r = bSwapS("sheepy", -10, 2); 8723 ck_assert_ptr_eq(r, null); 8724 8725 // index2 < -len 8726 r = bSwapS("sheepy", 2, -7); 8727 ck_assert_ptr_eq(r, null); 8728 8729 // null string 8730 r = bSwapS(null, 0, 2); 8731 ck_assert_ptr_eq(r, null); 8732 8733 8734 } 8735 8736 8737 void bLSwapST(CuTest *tc UNUSED) { 8738 8739 char b[20]; 8740 char *r; 8741 8742 // swap 8743 strcpy(b, "sheepy"); 8744 r = bLSwapS(b, sizeof(b), 0, 2); 8745 ck_assert_str_eq(r, "ehsepy"); 8746 strcpy(b, "sheepy"); 8747 r = bLSwapS(b, sizeof(b), -6, 2); 8748 ck_assert_str_eq(r, "ehsepy"); 8749 strcpy(b, "sheepy"); 8750 r = bLSwapS(b, sizeof(b), 2, 0); 8751 ck_assert_str_eq(r, "ehsepy"); 8752 strcpy(b, "sheepy"); 8753 r = bLSwapS(b, sizeof(b), 2, -6); 8754 ck_assert_str_eq(r, "ehsepy"); 8755 8756 // buffer = strlen+1 8757 strcpy(b, "sheepy"); 8758 r = bLSwapS(b, 7, -1, 0); 8759 ck_assert_str_eq(r, "yheeps"); 8760 // buffer shorter than strlen 8761 strcpy(b, "sheepy"); 8762 r = bLSwapS(b, 6, -1, 0); 8763 ck_assert_str_eq(r, "pheesy"); 8764 8765 // size 0 8766 strcpy(b, "sheepy"); 8767 r = bLSwapS(b, 0, -1, 0); 8768 ck_assert_str_eq(r, "sheepy"); 8769 8770 // index1 >= len 8771 r = bLSwapS("sheepy", sizeof(b), 6, 2); 8772 ck_assert_ptr_eq(r, null); 8773 8774 // index2 >= len 8775 r = bLSwapS("sheepy", sizeof(b), 2, 6); 8776 ck_assert_ptr_eq(r, null); 8777 8778 // index1 < -len 8779 r = bLSwapS("sheepy", sizeof(b), -10, 2); 8780 ck_assert_ptr_eq(r, null); 8781 8782 // index2 < -len 8783 r = bLSwapS("sheepy", sizeof(b), 2, -7); 8784 ck_assert_ptr_eq(r, null); 8785 8786 // null string 8787 r = bLSwapS(null, sizeof(b), 0, 2); 8788 ck_assert_ptr_eq(r, null); 8789 8790 8791 } 8792 8793 8794 void sliceST(CuTest *tc UNUSED) { 8795 8796 // slice 8797 char *s = sliceS("sheepy", 0,2); 8798 ck_assert_str_eq(s, "sh"); 8799 free(s); 8800 // negative index 8801 s = sliceS("sheepy", -2,0); 8802 ck_assert_str_eq(s, "py"); 8803 free(s); 8804 // positive and negative indexes 8805 s = sliceS("sheepy", 2,-2); 8806 ck_assert_str_eq(s, "ee"); 8807 free(s); 8808 // start = end 8809 s = sliceS("sheepy", 2,-4); 8810 ck_assert_str_eq(s, ""); 8811 free(s); 8812 // end of string 8813 s = sliceS("sheepy", 2,6); 8814 ck_assert_str_eq(s, "eepy"); 8815 free(s); 8816 // NULL string 8817 ck_assert_ptr_eq(sliceS(NULL, 2,-4), NULL); 8818 // start outside string 8819 ck_assert_ptr_eq(sliceS("sheepy", 20,-4), NULL); 8820 // end outside string 8821 s = sliceS("sheepy", 2,40); 8822 ck_assert_str_eq(s, "eepy"); 8823 free(s); 8824 s = sliceS("sheepy", -22,3); 8825 ck_assert_str_eq(s, "she"); 8826 free(s); 8827 ck_assert_ptr_eq(sliceS("sheepy", 2,-40), NULL); 8828 // end before start 8829 ck_assert_ptr_eq(sliceS("sheepy", 4,2), NULL); 8830 8831 } 8832 8833 8834 void iSliceST(CuTest *tc UNUSED) { 8835 8836 char *s; 8837 char *r = null; 8838 8839 // slice 8840 s = strdup("sheepy"); 8841 r = iSliceS(&s, 0,2); 8842 ck_assert_ptr_eq(r, s); 8843 ck_assert_str_eq(s, "sh"); 8844 free(s); 8845 // negative index 8846 s = strdup("sheepy"); 8847 r = iSliceS(&s, -2,0); 8848 ck_assert_ptr_eq(r, s); 8849 ck_assert_str_eq(s, "py"); 8850 free(s); 8851 // positive and negative indexes 8852 s = strdup("sheepy"); 8853 r = iSliceS(&s, 2,-2); 8854 ck_assert_ptr_eq(r, s); 8855 ck_assert_str_eq(s, "ee"); 8856 free(s); 8857 // start = end 8858 s = strdup("sheepy"); 8859 r = iSliceS(&s, 2,-4); 8860 ck_assert_ptr_eq(r, s); 8861 ck_assert_str_eq(s, ""); 8862 free(s); 8863 // end of string 8864 s = strdup("sheepy"); 8865 r = iSliceS(&s, 2,6); 8866 ck_assert_ptr_eq(r, s); 8867 ck_assert_str_eq(s, "eepy"); 8868 free(s); 8869 // NULL string 8870 s = NULL; 8871 r = iSliceS(&s, 2,-4); 8872 ck_assert_ptr_eq(r, s); 8873 ck_assert_ptr_eq(s, NULL); 8874 // start outside string 8875 s = strdup("sheepy"); 8876 r = iSliceS(&s, 20,-4); 8877 ck_assert_ptr_eq(r, null); 8878 ck_assert_str_eq(s, ""); 8879 free(s); 8880 // end outside string 8881 s = strdup("sheepy"); 8882 r = iSliceS(&s, 2,40); 8883 ck_assert_ptr_eq(r, s); 8884 ck_assert_str_eq(s, "eepy"); 8885 free(s); 8886 s = strdup("sheepy"); 8887 r = iSliceS(&s, -22,3); 8888 ck_assert_ptr_eq(r, s); 8889 ck_assert_str_eq(s, "she"); 8890 free(s); 8891 s = strdup("sheepy"); 8892 r = iSliceS(&s, 2,-40); 8893 ck_assert_ptr_eq(r, null); 8894 ck_assert_str_eq(s, ""); 8895 free(s); 8896 // end before start 8897 s = strdup("sheepy"); 8898 r = iSliceS(&s, 4,2); 8899 ck_assert_ptr_eq(r, null); 8900 ck_assert_str_eq(s, ""); 8901 free(s); 8902 // NULL var 8903 r = iSliceS(NULL, 0, 0); 8904 ck_assert_ptr_eq(r, null); 8905 8906 } 8907 8908 8909 void bSliceST(CuTest *tc UNUSED) { 8910 8911 char s[100]; 8912 char *r = null; 8913 8914 // slice 8915 strcpy(s, "sheepy"); 8916 r = bSliceS(s, 0,2); 8917 ck_assert_ptr_eq(r, s); 8918 ck_assert_str_eq(s, "sh"); 8919 // negative index 8920 strcpy(s, "sheepy"); 8921 r = bSliceS(s, -2,0); 8922 ck_assert_ptr_eq(r, s); 8923 ck_assert_str_eq(s, "py"); 8924 // positive and negative indexes 8925 strcpy(s, "sheepy"); 8926 r = bSliceS(s, 2,-2); 8927 ck_assert_ptr_eq(r, s); 8928 ck_assert_str_eq(s, "ee"); 8929 // start = end 8930 strcpy(s, "sheepy"); 8931 r = bSliceS(s, 2,-4); 8932 ck_assert_ptr_eq(r, s); 8933 ck_assert_str_eq(s, ""); 8934 // end of string 8935 strcpy(s, "sheepy"); 8936 r = bSliceS(s, 2,6); 8937 ck_assert_ptr_eq(r, s); 8938 ck_assert_str_eq(s, "eepy"); 8939 // start outside string 8940 strcpy(s, "sheepy"); 8941 r = bSliceS(s, 20,-4); 8942 ck_assert_ptr_eq(r, null); 8943 ck_assert_str_eq(s, ""); 8944 // end outside string 8945 strcpy(s, "sheepy"); 8946 r = bSliceS(s, 2,40); 8947 ck_assert_ptr_eq(r, s); 8948 ck_assert_str_eq(s, "eepy"); 8949 strcpy(s, "sheepy"); 8950 r = bSliceS(s, -22,3); 8951 ck_assert_ptr_eq(r, s); 8952 ck_assert_str_eq(s, "she"); 8953 strcpy(s, "sheepy"); 8954 r = bSliceS(s, 2,-40); 8955 ck_assert_ptr_eq(r, null); 8956 ck_assert_str_eq(s, ""); 8957 // end before start 8958 strcpy(s, "sheepy"); 8959 r = bSliceS(s, 4,2); 8960 ck_assert_ptr_eq(r, null); 8961 ck_assert_str_eq(s, ""); 8962 // NULL var 8963 r = bSliceS(NULL, 0, 0); 8964 ck_assert_ptr_eq(r, null); 8965 8966 } 8967 8968 8969 void bLSliceST(CuTest *tc UNUSED) { 8970 8971 char s[100]; 8972 char *r = null; 8973 8974 // slice 8975 strcpy(s, "sheepy"); 8976 r = bLSliceS(s, sizeof(s), 0,2); 8977 ck_assert_ptr_eq(r, s); 8978 ck_assert_str_eq(s, "sh"); 8979 // buffer shorter than string 8980 strcpy(s, "sheepy"); 8981 r = bLSliceS(s, 5, 0,2); 8982 ck_assert_ptr_eq(r, s); 8983 ck_assert_str_eq(s, "sh"); 8984 // negative index 8985 strcpy(s, "sheepy"); 8986 r = bLSliceS(s, sizeof(s), -2,0); 8987 ck_assert_ptr_eq(r, s); 8988 ck_assert_str_eq(s, "py"); 8989 // positive and negative indexes 8990 strcpy(s, "sheepy"); 8991 r = bLSliceS(s, sizeof(s), 2,-2); 8992 ck_assert_ptr_eq(r, s); 8993 ck_assert_str_eq(s, "ee"); 8994 // start = end 8995 strcpy(s, "sheepy"); 8996 r = bLSliceS(s, sizeof(s), 2,-4); 8997 ck_assert_ptr_eq(r, s); 8998 ck_assert_str_eq(s, ""); 8999 // end of string 9000 strcpy(s, "sheepy"); 9001 r = bLSliceS(s, sizeof(s), 2,6); 9002 ck_assert_ptr_eq(r, s); 9003 ck_assert_str_eq(s, "eepy"); 9004 // start outside string 9005 strcpy(s, "sheepy"); 9006 r = bLSliceS(s, sizeof(s), 20,-4); 9007 ck_assert_ptr_eq(r, null); 9008 ck_assert_str_eq(s, ""); 9009 // end outside string 9010 strcpy(s, "sheepy"); 9011 r = bLSliceS(s, sizeof(s), 2,40); 9012 ck_assert_ptr_eq(r, s); 9013 ck_assert_str_eq(s, "eepy"); 9014 strcpy(s, "sheepy"); 9015 r = bLSliceS(s, sizeof(s), -22,3); 9016 ck_assert_ptr_eq(r, s); 9017 ck_assert_str_eq(s, "she"); 9018 strcpy(s, "sheepy"); 9019 r = bLSliceS(s, sizeof(s), 2,-40); 9020 ck_assert_ptr_eq(r, null); 9021 ck_assert_str_eq(s, ""); 9022 // end before start 9023 strcpy(s, "sheepy"); 9024 r = bLSliceS(s, sizeof(s), 4,2); 9025 ck_assert_ptr_eq(r, null); 9026 ck_assert_str_eq(s, ""); 9027 // size 0 9028 r = bLSliceS(s, 0, 0, 0); 9029 ck_assert_ptr_eq(r, null); 9030 // NULL var 9031 r = bLSliceS(NULL, sizeof(s), 0, 0); 9032 ck_assert_ptr_eq(r, null); 9033 9034 9035 } 9036 9037 9038 void cropST(CuTest *tc UNUSED) { 9039 9040 char b[20]; 9041 char *s; 9042 9043 // crop 9044 strcpy(b, "sheepy"); 9045 s = cropS(b, 0,2); 9046 ck_assert_str_eq(s, "sh"); 9047 ck_assert_str_eq(b, "eepy"); 9048 free(s); 9049 // negative index 9050 strcpy(b, "sheepy"); 9051 s = cropS(b, -2,0); 9052 ck_assert_str_eq(s, "py"); 9053 ck_assert_str_eq(b, "shee"); 9054 free(s); 9055 // positive and negative indexes 9056 strcpy(b, "sheepy"); 9057 s = cropS(b, 2,-2); 9058 ck_assert_str_eq(s, "ee"); 9059 ck_assert_str_eq(b, "shpy"); 9060 free(s); 9061 // start = end 9062 strcpy(b, "sheepy"); 9063 s = cropS(b, 2,-4); 9064 ck_assert_str_eq(s, ""); 9065 ck_assert_str_eq(b, "sheepy"); 9066 free(s); 9067 // end of string 9068 strcpy(b, "sheepy"); 9069 s = cropS(b, 2,6); 9070 ck_assert_str_eq(s, "eepy"); 9071 ck_assert_str_eq(b, "sh"); 9072 free(s); 9073 // NULL string 9074 ck_assert_ptr_eq(cropS(NULL, 2,-4), NULL); 9075 // start outside string 9076 ck_assert_ptr_eq(cropS("sheepy", 20,-4), NULL); 9077 // end outside string 9078 strcpy(b, "sheepy"); 9079 s = cropS(b, 2,40); 9080 ck_assert_str_eq(s, "eepy"); 9081 ck_assert_str_eq(b, "sh"); 9082 free(s); 9083 strcpy(b, "sheepy"); 9084 s = cropS(b, -22,3); 9085 ck_assert_str_eq(s, "she"); 9086 ck_assert_str_eq(b, "epy"); 9087 free(s); 9088 ck_assert_ptr_eq(cropS("sheepy", 2,-40), NULL); 9089 // end before start 9090 ck_assert_ptr_eq(cropS("sheepy", 4,2), NULL); 9091 9092 9093 } 9094 9095 9096 void iCropST(CuTest *tc UNUSED) { 9097 9098 char *b; 9099 char *s; 9100 9101 // crop 9102 b = strdup("sheepy"); 9103 s = iCropS(&b, 0,2); 9104 ck_assert_str_eq(s, "sh"); 9105 ck_assert_str_eq(b, "eepy"); 9106 free(s); 9107 free(b); 9108 // negative index 9109 b = strdup("sheepy"); 9110 s = iCropS(&b, -2,0); 9111 ck_assert_str_eq(s, "py"); 9112 ck_assert_str_eq(b, "shee"); 9113 free(s); 9114 free(b); 9115 // positive and negative indexes 9116 b = strdup("sheepy"); 9117 s = iCropS(&b, 2,-2); 9118 ck_assert_str_eq(s, "ee"); 9119 ck_assert_str_eq(b, "shpy"); 9120 free(s); 9121 free(b); 9122 // start = end 9123 b = strdup("sheepy"); 9124 s = iCropS(&b, 2,-4); 9125 ck_assert_str_eq(s, ""); 9126 ck_assert_str_eq(b, "sheepy"); 9127 free(s); 9128 free(b); 9129 // end of string 9130 b = strdup("sheepy"); 9131 s = iCropS(&b, 2,6); 9132 ck_assert_str_eq(s, "eepy"); 9133 ck_assert_str_eq(b, "sh"); 9134 free(s); 9135 free(b); 9136 // NULL string 9137 b = null; 9138 ck_assert_ptr_eq(iCropS(&b, 2,-4), NULL); 9139 ck_assert_ptr_eq(iCropS(NULL, 2,-4), NULL); 9140 // start outside string 9141 b = strdup("sheepy"); 9142 ck_assert_ptr_eq(iCropS(&b, 20,-4), NULL); 9143 free(b); 9144 // end outside string 9145 b = strdup("sheepy"); 9146 s = iCropS(&b, 2,40); 9147 ck_assert_str_eq(s, "eepy"); 9148 ck_assert_str_eq(b, "sh"); 9149 free(s); 9150 free(b); 9151 b = strdup("sheepy"); 9152 s = iCropS(&b, -22,3); 9153 ck_assert_str_eq(s, "she"); 9154 ck_assert_str_eq(b, "epy"); 9155 free(s); 9156 free(b); 9157 b = strdup("sheepy"); 9158 ck_assert_ptr_eq(iCropS(&b, 2,-40), NULL); 9159 free(b); 9160 // end before start 9161 b = strdup("sheepy"); 9162 ck_assert_ptr_eq(iCropS(&b, 4,2), NULL); 9163 free(b); 9164 9165 9166 } 9167 9168 9169 void cropElemST(CuTest *tc UNUSED) { 9170 9171 char b[20]; 9172 char r; 9173 9174 // crop 9175 strcpy(b, "sheepy"); 9176 r = cropElemS(b, 0); 9177 ck_assert_int_eq(r, 's'); 9178 ck_assert_str_eq(b, "heepy"); 9179 strcpy(b, "sheepy"); 9180 r = cropElemS(b, 5); 9181 ck_assert_int_eq(r, 'y'); 9182 ck_assert_str_eq(b, "sheep"); 9183 // negative index 9184 strcpy(b, "sheepy"); 9185 r = cropElemS(b, -1); 9186 ck_assert_int_eq(r, 'y'); 9187 ck_assert_str_eq(b, "sheep"); 9188 strcpy(b, "sheepy"); 9189 r = cropElemS(b, -6); 9190 ck_assert_int_eq(r, 's'); 9191 ck_assert_str_eq(b, "heepy"); 9192 // index outside string 9193 strcpy(b, "sheepy"); 9194 r = cropElemS(b, 6); 9195 ck_assert_int_eq(r, 0); 9196 ck_assert_str_eq(b, "sheepy"); 9197 strcpy(b, "sheepy"); 9198 r = cropElemS(b, -7); 9199 ck_assert_int_eq(r, 0); 9200 ck_assert_str_eq(b, "sheepy"); 9201 // null string 9202 ck_assert_int_eq(cropElemS(null, 0), 0); 9203 9204 } 9205 9206 9207 void iCropElemST(CuTest *tc UNUSED) { 9208 9209 char *b; 9210 char r; 9211 9212 // crop 9213 b = strdup("sheepy"); 9214 r = iCropElemS(&b, 0); 9215 ck_assert_int_eq(r, 's'); 9216 ck_assert_str_eq(b, "heepy"); 9217 free(b); 9218 b = strdup("sheepy"); 9219 r = iCropElemS(&b, 5); 9220 ck_assert_int_eq(r, 'y'); 9221 ck_assert_str_eq(b, "sheep"); 9222 free(b); 9223 // negative index 9224 b = strdup("sheepy"); 9225 r = iCropElemS(&b, -1); 9226 ck_assert_int_eq(r, 'y'); 9227 ck_assert_str_eq(b, "sheep"); 9228 free(b); 9229 b = strdup("sheepy"); 9230 r = iCropElemS(&b, -6); 9231 ck_assert_int_eq(r, 's'); 9232 ck_assert_str_eq(b, "heepy"); 9233 free(b); 9234 // index outside string 9235 b = strdup("sheepy"); 9236 r = iCropElemS(&b, 6); 9237 ck_assert_int_eq(r, 0); 9238 ck_assert_str_eq(b, "sheepy"); 9239 free(b); 9240 b = strdup("sheepy"); 9241 r = iCropElemS(&b, -7); 9242 ck_assert_int_eq(r, 0); 9243 ck_assert_str_eq(b, "sheepy"); 9244 free(b); 9245 // null string 9246 b = null; 9247 ck_assert_int_eq(iCropElemS(&b, 0), 0); 9248 ck_assert_int_eq(iCropElemS(null, 0), 0); 9249 9250 9251 } 9252 9253 9254 void insertST(CuTest *tc UNUSED) { 9255 9256 char *s; 9257 9258 // insert 9259 s = insertS("sheepy", 0, "lib"); 9260 ck_assert_str_eq(s, "libsheepy"); 9261 free(s); 9262 // negative index 9263 s = insertS("libsheepy", -2, "P"); 9264 ck_assert_str_eq(s, "libsheepPy"); 9265 free(s); 9266 // edge 9267 s = insertS("qwe", 3, "C"); 9268 ck_assert_str_eq(s, "qweC"); 9269 free(s); 9270 // outside string 9271 s = insertS("qwe", 4, "C"); 9272 ck_assert_ptr_eq(s, NULL); 9273 s = insertS("qwe", -5, "C"); 9274 ck_assert_ptr_eq(s, NULL); 9275 // negative index in a one char string 9276 s = insertS("s", -1, "S"); 9277 ck_assert_str_eq(s, "sS"); 9278 free(s); 9279 // empty string 9280 s = insertS("", 0, "s"); 9281 ck_assert_str_eq(s, "s"); 9282 free(s); 9283 s = insertS("", -1, "s"); 9284 ck_assert_str_eq(s, "s"); 9285 free(s); 9286 // empty insert string 9287 s = insertS("a", 0, ""); 9288 ck_assert_str_eq(s, "a"); 9289 free(s); 9290 // NULL insert string 9291 s = insertS("a", 0, NULL); 9292 ck_assert_str_eq(s, "a"); 9293 free(s); 9294 // NULL string 9295 s = insertS(NULL, 0, "s"); 9296 ck_assert_str_eq(s, "s"); 9297 free(s); 9298 9299 9300 } 9301 9302 9303 void insertNFreeST(CuTest *tc UNUSED) { 9304 9305 char *s, *a; 9306 9307 // insert 9308 s = insertNFreeS("sheepy", 0, strdup("lib")); 9309 ck_assert_str_eq(s, "libsheepy"); 9310 free(s); 9311 // negative index 9312 s = insertNFreeS("libsheepy", -2, strdup("P")); 9313 ck_assert_str_eq(s, "libsheepPy"); 9314 free(s); 9315 // edge 9316 s = insertNFreeS("qwe", 3, strdup("C")); 9317 ck_assert_str_eq(s, "qweC"); 9318 free(s); 9319 // outside string 9320 a = strdup("C"); 9321 s = insertNFreeS("qwe", 4, a); 9322 ck_assert_ptr_eq(s, NULL); 9323 s = insertNFreeS("qwe", -5, a); 9324 ck_assert_ptr_eq(s, NULL); 9325 free(a); 9326 // negative index in a one char string 9327 s = insertNFreeS("s", -1, strdup("S")); 9328 ck_assert_str_eq(s, "sS"); 9329 free(s); 9330 // empty string 9331 s = insertNFreeS("", 0, strdup("s")); 9332 ck_assert_str_eq(s, "s"); 9333 free(s); 9334 s = insertNFreeS("", -1, strdup("s")); 9335 ck_assert_str_eq(s, "s"); 9336 free(s); 9337 // empty insert string 9338 s = insertNFreeS("a", 0, strdup("")); 9339 ck_assert_str_eq(s, "a"); 9340 free(s); 9341 // NULL insert string 9342 s = insertNFreeS("a", 0, NULL); 9343 ck_assert_str_eq(s, "a"); 9344 free(s); 9345 // NULL string 9346 s = insertNFreeS(NULL, 0, strdup("s")); 9347 ck_assert_str_eq(s, "s"); 9348 free(s); 9349 9350 9351 } 9352 9353 9354 void iInsertST(CuTest *tc UNUSED) { 9355 9356 char *s; 9357 char *r = null; 9358 9359 // insert 9360 s = strdup("sheepy"); 9361 r = iInsertS(&s, 0, "lib"); 9362 ck_assert_ptr_eq(r, s); 9363 ck_assert_str_eq(s, "libsheepy"); 9364 free(s); 9365 // negative index 9366 s = strdup("libsheepy"); 9367 r = iInsertS(&s, -2, "P"); 9368 ck_assert_ptr_eq(r, s); 9369 ck_assert_str_eq(s, "libsheepPy"); 9370 free(s); 9371 // edge 9372 s = strdup("qwe"); 9373 r = iInsertS(&s, 3, "C"); 9374 ck_assert_ptr_eq(r, s); 9375 ck_assert_str_eq(s, "qweC"); 9376 free(s); 9377 // outside string 9378 s = strdup("qwe"); 9379 r = iInsertS(&s, 4, "C"); 9380 ck_assert_ptr_eq(r, null); 9381 ck_assert_str_eq(s, "qwe"); 9382 r = iInsertS(&s, -5, "C"); 9383 ck_assert_ptr_eq(r, null); 9384 ck_assert_str_eq(s, "qwe"); 9385 free(s); 9386 // negative index in a one char string 9387 s = strdup("s"); 9388 r = iInsertS(&s, -1, "S"); 9389 ck_assert_ptr_eq(r, s); 9390 ck_assert_str_eq(s, "sS"); 9391 free(s); 9392 // empty string 9393 emptyS(s); 9394 r = iInsertS(&s, 0, "s"); 9395 ck_assert_ptr_eq(r, s); 9396 ck_assert_str_eq(s, "s"); 9397 free(s); 9398 emptyS(s); 9399 r = iInsertS(&s, -1, "s"); 9400 ck_assert_ptr_eq(r, s); 9401 ck_assert_str_eq(s, "s"); 9402 free(s); 9403 // empty insert string 9404 s = strdup("a"); 9405 r = iInsertS(&s, 0, ""); 9406 ck_assert_ptr_eq(r, s); 9407 ck_assert_str_eq(s, "a"); 9408 free(s); 9409 // NULL insert string 9410 s = strdup("a"); 9411 r = iInsertS(&s, 0, NULL); 9412 ck_assert_ptr_eq(r, s); 9413 ck_assert_str_eq(s, "a"); 9414 free(s); 9415 // NULL string 9416 s = NULL; 9417 r = iInsertS(&s, 0, "s"); 9418 ck_assert_ptr_eq(r, s); 9419 ck_assert_str_eq(s, "s"); 9420 free(s); 9421 // NULL var 9422 r = iInsertS(NULL, 0, "s"); 9423 ck_assert_ptr_eq(r, null); 9424 9425 } 9426 9427 9428 void iInsertNFreeST(CuTest *tc UNUSED) { 9429 9430 char *s, *a, *r; 9431 9432 // insert 9433 s = strdup("sheepy"); 9434 r = iInsertNFreeS(&s, 0, strdup("lib")); 9435 ck_assert_ptr_eq(r, s); 9436 ck_assert_str_eq(s, "libsheepy"); 9437 free(s); 9438 // negative index 9439 s = strdup("libsheepy"); 9440 r = iInsertNFreeS(&s, -2, strdup("P")); 9441 ck_assert_ptr_eq(r, s); 9442 ck_assert_str_eq(s, "libsheepPy"); 9443 free(s); 9444 // edge 9445 s = strdup("qwe"); 9446 r = iInsertNFreeS(&s, 3, strdup("C")); 9447 ck_assert_ptr_eq(r, s); 9448 ck_assert_str_eq(s, "qweC"); 9449 free(s); 9450 // outside string 9451 s = strdup("qwe"); 9452 a = strdup("C"); 9453 r = iInsertNFreeS(&s, 4, a); 9454 ck_assert_ptr_eq(r, NULL); 9455 ck_assert_str_eq(s, "qwe"); 9456 r = iInsertNFreeS(&s, -5, a); 9457 ck_assert_ptr_eq(r, NULL); 9458 free(a); 9459 ck_assert_str_eq(s, "qwe"); 9460 free(s); 9461 // negative index in a one char string 9462 s = strdup("s"); 9463 r = iInsertNFreeS(&s, -1, strdup("S")); 9464 ck_assert_ptr_eq(r, s); 9465 ck_assert_str_eq(s, "sS"); 9466 free(s); 9467 // empty string 9468 emptyS(s); 9469 r = iInsertNFreeS(&s, 0, strdup("s")); 9470 ck_assert_ptr_eq(r, s); 9471 ck_assert_str_eq(s, "s"); 9472 free(s); 9473 emptyS(s); 9474 r = iInsertNFreeS(&s, -1, strdup("s")); 9475 ck_assert_ptr_eq(r, s); 9476 ck_assert_str_eq(s, "s"); 9477 free(s); 9478 // empty insert string 9479 s = strdup("a"); 9480 r = iInsertNFreeS(&s, 0, strdup("")); 9481 ck_assert_ptr_eq(r, s); 9482 ck_assert_str_eq(s, "a"); 9483 free(s); 9484 // NULL insert string 9485 s = strdup("a"); 9486 r = iInsertNFreeS(&s, 0, NULL); 9487 ck_assert_ptr_eq(r, s); 9488 ck_assert_str_eq(s, "a"); 9489 free(s); 9490 // NULL string 9491 s = NULL; 9492 r = iInsertNFreeS(&s, 0, strdup("s")); 9493 ck_assert_ptr_eq(r, s); 9494 ck_assert_str_eq(s, "s"); 9495 free(s); 9496 // NULL var 9497 s = strdup("s"); 9498 r = iInsertNFreeS(NULL, 0, s); 9499 ck_assert_ptr_eq(r, NULL); 9500 free(s); 9501 9502 } 9503 9504 9505 void bInsertST(CuTest *tc UNUSED) { 9506 9507 char s[100]; 9508 char *r = null; 9509 9510 // insert 9511 strcpy(s, "sheepy"); 9512 r = bInsertS(s, 0, "lib"); 9513 ck_assert_ptr_eq(r, s); 9514 ck_assert_str_eq(s, "libsheepy"); 9515 // negative index 9516 strcpy(s, "libsheepy"); 9517 r = bInsertS(s, -2, "P"); 9518 ck_assert_ptr_eq(r, s); 9519 ck_assert_str_eq(s, "libsheepPy"); 9520 // edge 9521 strcpy(s, "qwe"); 9522 r = bInsertS(s, 3, "C"); 9523 ck_assert_ptr_eq(r, s); 9524 ck_assert_str_eq(s, "qweC"); 9525 // outside string 9526 strcpy(s, "qwe"); 9527 r = bInsertS(s, 4, "C"); 9528 ck_assert_ptr_eq(r, null); 9529 ck_assert_str_eq(s, "qwe"); 9530 r = bInsertS(s, -5, "C"); 9531 ck_assert_ptr_eq(r, null); 9532 ck_assert_str_eq(s, "qwe"); 9533 // negative index in a one char string 9534 strcpy(s, "s"); 9535 r = bInsertS(s, -1, "S"); 9536 ck_assert_ptr_eq(r, s); 9537 ck_assert_str_eq(s, "sS"); 9538 // empty string 9539 bEmptyS(s); 9540 r = bInsertS(s, 0, "s"); 9541 ck_assert_ptr_eq(r, s); 9542 ck_assert_str_eq(s, "s"); 9543 bEmptyS(s); 9544 r = bInsertS(s, -1, "s"); 9545 ck_assert_ptr_eq(r, s); 9546 ck_assert_str_eq(s, "s"); 9547 // empty insert string 9548 strcpy(s, "a"); 9549 r = bInsertS(s, 0, ""); 9550 ck_assert_ptr_eq(r, s); 9551 ck_assert_str_eq(s, "a"); 9552 // NULL insert string 9553 strcpy(s, "a"); 9554 r = bInsertS(s, 0, NULL); 9555 ck_assert_ptr_eq(r, s); 9556 ck_assert_str_eq(s, "a"); 9557 // NULL var 9558 r = bInsertS(NULL, 0, "s"); 9559 ck_assert_ptr_eq(r, null); 9560 9561 } 9562 9563 9564 void bLInsertST(CuTest *tc UNUSED) { 9565 9566 char s[100]; 9567 char *r = null; 9568 9569 // insert 9570 strcpy(s, "sheepy"); 9571 r = bLInsertS(s, sizeof s, 0, "lib"); 9572 ck_assert_ptr_eq(r, s); 9573 ck_assert_str_eq(s, "libsheepy"); 9574 // shorter buffer 9575 strcpy(s, "sheepy"); 9576 r = bLInsertS(s, 5, 0, "lib"); 9577 ck_assert_ptr_eq(r, s); 9578 ck_assert_str_eq(s, "libs"); 9579 // negative index 9580 strcpy(s, "libsheepy"); 9581 r = bLInsertS(s, sizeof s, -2, "P"); 9582 ck_assert_ptr_eq(r, s); 9583 ck_assert_str_eq(s, "libsheepPy"); 9584 // edge 9585 strcpy(s, "qwe"); 9586 r = bLInsertS(s, sizeof s, 3, "C"); 9587 ck_assert_ptr_eq(r, s); 9588 ck_assert_str_eq(s, "qweC"); 9589 // outside string 9590 strcpy(s, "qwe"); 9591 r = bLInsertS(s, sizeof s, 4, "C"); 9592 ck_assert_ptr_eq(r, null); 9593 ck_assert_str_eq(s, "qwe"); 9594 r = bLInsertS(s, sizeof s, -5, "C"); 9595 ck_assert_ptr_eq(r, null); 9596 ck_assert_str_eq(s, "qwe"); 9597 // negative index in a one char string 9598 strcpy(s, "s"); 9599 r = bLInsertS(s, sizeof s, -1, "S"); 9600 ck_assert_ptr_eq(r, s); 9601 ck_assert_str_eq(s, "sS"); 9602 // empty string 9603 bEmptyS(s); 9604 r = bLInsertS(s, sizeof s, 0, "s"); 9605 ck_assert_ptr_eq(r, s); 9606 ck_assert_str_eq(s, "s"); 9607 bEmptyS(s); 9608 r = bLInsertS(s, sizeof s, -1, "s"); 9609 ck_assert_ptr_eq(r, s); 9610 ck_assert_str_eq(s, "s"); 9611 // empty insert string 9612 strcpy(s, "a"); 9613 r = bLInsertS(s, sizeof s, 0, ""); 9614 ck_assert_ptr_eq(r, s); 9615 ck_assert_str_eq(s, "a"); 9616 // size 0 - no change 9617 r = bLInsertS(s, 0, 0, "qwe"); 9618 ck_assert_ptr_eq(r, s); 9619 ck_assert_str_eq(s, "a"); 9620 // NULL insert string 9621 strcpy(s, "a"); 9622 r = bLInsertS(s, sizeof s, 0, NULL); 9623 ck_assert_ptr_eq(r, s); 9624 ck_assert_str_eq(s, "a"); 9625 // NULL var 9626 r = bLInsertS(NULL, sizeof s, 0, "s"); 9627 ck_assert_ptr_eq(r, null); 9628 9629 } 9630 9631 9632 void injectST(CuTest *tc UNUSED) { 9633 9634 char *s; 9635 9636 // insert 9637 s = injectS("sheepy", 0, 'L'); 9638 ck_assert_str_eq(s, "Lsheepy"); 9639 free(s); 9640 // negative index 9641 s = injectS("libsheepy", -2, 'P'); 9642 ck_assert_str_eq(s, "libsheepPy"); 9643 free(s); 9644 // edge 9645 s = injectS("qwe", 3, 'C'); 9646 ck_assert_str_eq(s, "qweC"); 9647 free(s); 9648 // outside string 9649 s = injectS("qwe", 4, 'C'); 9650 ck_assert_ptr_eq(s, NULL); 9651 s = injectS("qwe", -5, 'C'); 9652 ck_assert_ptr_eq(s, NULL); 9653 // negative index in a one char string 9654 s = injectS("s", -2, 'S'); 9655 ck_assert_str_eq(s, "Ss"); 9656 free(s); 9657 // empty string 9658 s = injectS("", 0, 's'); 9659 ck_assert_str_eq(s, "s"); 9660 free(s); 9661 s = injectS("", -1, 's'); 9662 ck_assert_str_eq(s, "s"); 9663 free(s); 9664 // NULL string 9665 s = injectS(NULL, 0, 's'); 9666 ck_assert_str_eq(s, "s"); 9667 free(s); 9668 9669 9670 } 9671 9672 9673 void iInjectST(CuTest *tc UNUSED) { 9674 9675 char *s; 9676 char *r = null; 9677 9678 // insert 9679 s = strdup("sheepy"); 9680 r = iInjectS(&s, 0, 'L'); 9681 ck_assert_ptr_eq(r, s); 9682 ck_assert_str_eq(s, "Lsheepy"); 9683 free(s); 9684 // negative index 9685 s = strdup("libsheepy"); 9686 r = iInjectS(&s, -2, 'P'); 9687 ck_assert_ptr_eq(r, s); 9688 ck_assert_str_eq(s, "libsheepPy"); 9689 free(s); 9690 // edge 9691 s = strdup("qwe"); 9692 r = iInjectS(&s, 3, 'C'); 9693 ck_assert_ptr_eq(r, s); 9694 ck_assert_str_eq(s, "qweC"); 9695 free(s); 9696 // outside string 9697 s = strdup("qwe"); 9698 r = iInjectS(&s, 4, 'C'); 9699 ck_assert_ptr_eq(r, null); 9700 ck_assert_str_eq(s, "qwe"); 9701 r = iInjectS(&s, -5, 'C'); 9702 ck_assert_ptr_eq(r, null); 9703 ck_assert_str_eq(s, "qwe"); 9704 free(s); 9705 // negative index in a one char string 9706 s = strdup("s"); 9707 r = iInjectS(&s, -1, 'S'); 9708 ck_assert_ptr_eq(r, s); 9709 ck_assert_str_eq(s, "sS"); 9710 free(s); 9711 // empty string 9712 emptyS(s); 9713 r = iInjectS(&s, 0, 's'); 9714 ck_assert_ptr_eq(r, s); 9715 ck_assert_str_eq(s, "s"); 9716 free(s); 9717 emptyS(s); 9718 r = iInjectS(&s, -1, 's'); 9719 ck_assert_ptr_eq(r, s); 9720 ck_assert_str_eq(s, "s"); 9721 free(s); 9722 // NULL string 9723 s = NULL; 9724 r = iInjectS(&s, 0, 's'); 9725 ck_assert_ptr_eq(r, s); 9726 ck_assert_str_eq(s, "s"); 9727 free(s); 9728 // NULL var 9729 r = iInjectS(NULL, 0, 's'); 9730 ck_assert_ptr_eq(r, null); 9731 9732 } 9733 9734 9735 void bInjectST(CuTest *tc UNUSED) { 9736 9737 char s[100]; 9738 char *r = null; 9739 9740 // insert 9741 strcpy(s, "sheepy"); 9742 r = bInjectS(s, 0, 'L'); 9743 ck_assert_ptr_eq(r, s); 9744 ck_assert_str_eq(s, "Lsheepy"); 9745 // negative index 9746 strcpy(s, "libsheepy"); 9747 r = bInjectS(s, -2, 'P'); 9748 ck_assert_ptr_eq(r, s); 9749 ck_assert_str_eq(s, "libsheepPy"); 9750 // edge 9751 strcpy(s, "qwe"); 9752 r = bInjectS(s, 3, 'C'); 9753 ck_assert_ptr_eq(r, s); 9754 ck_assert_str_eq(s, "qweC"); 9755 // outside string 9756 strcpy(s, "qwe"); 9757 r = bInjectS(s, 4, 'C'); 9758 ck_assert_ptr_eq(r, null); 9759 ck_assert_str_eq(s, "qwe"); 9760 r = bInjectS(s, -5, 'C'); 9761 ck_assert_ptr_eq(r, null); 9762 ck_assert_str_eq(s, "qwe"); 9763 // negative index in a one char string 9764 strcpy(s, "s"); 9765 r = bInjectS(s, -1, 'S'); 9766 ck_assert_ptr_eq(r, s); 9767 ck_assert_str_eq(s, "sS"); 9768 // empty string 9769 bEmptyS(s); 9770 r = bInjectS(s, 0, 's'); 9771 ck_assert_ptr_eq(r, s); 9772 ck_assert_str_eq(s, "s"); 9773 bEmptyS(s); 9774 r = bInjectS(s, -1, 's'); 9775 ck_assert_ptr_eq(r, s); 9776 ck_assert_str_eq(s, "s"); 9777 // NULL var 9778 r = bInjectS(NULL, 0, 's'); 9779 ck_assert_ptr_eq(r, null); 9780 9781 } 9782 9783 9784 void bLInjectST(CuTest *tc UNUSED) { 9785 9786 char s[100]; 9787 char *r = null; 9788 9789 // insert 9790 strcpy(s, "sheepy"); 9791 r = bLInjectS(s, sizeof s, 0, 'L'); 9792 ck_assert_ptr_eq(r, s); 9793 ck_assert_str_eq(s, "Lsheepy"); 9794 // shorter buffer 9795 strcpy(s, "sheepy"); 9796 r = bLInjectS(s, 5, 0, 'L'); 9797 ck_assert_ptr_eq(r, s); 9798 ck_assert_str_eq(s, "Lshe"); 9799 // negative index 9800 strcpy(s, "libsheepy"); 9801 r = bLInjectS(s, sizeof s, -2, 'P'); 9802 ck_assert_ptr_eq(r, s); 9803 ck_assert_str_eq(s, "libsheepPy"); 9804 // edge 9805 strcpy(s, "qwe"); 9806 r = bLInjectS(s, sizeof s, 3, 'C'); 9807 ck_assert_ptr_eq(r, s); 9808 ck_assert_str_eq(s, "qweC"); 9809 // outside string 9810 strcpy(s, "qwe"); 9811 r = bLInjectS(s, sizeof s, 4, 'C'); 9812 ck_assert_ptr_eq(r, null); 9813 ck_assert_str_eq(s, "qwe"); 9814 r = bLInjectS(s, sizeof s, -5, 'C'); 9815 ck_assert_ptr_eq(r, null); 9816 ck_assert_str_eq(s, "qwe"); 9817 // negative index in a one char string 9818 strcpy(s, "s"); 9819 r = bLInjectS(s, sizeof s, -1, 'S'); 9820 ck_assert_ptr_eq(r, s); 9821 ck_assert_str_eq(s, "sS"); 9822 // empty string 9823 bEmptyS(s); 9824 r = bLInjectS(s, sizeof s, 0, 's'); 9825 ck_assert_ptr_eq(r, s); 9826 ck_assert_str_eq(s, "s"); 9827 bEmptyS(s); 9828 r = bLInjectS(s, sizeof s, -1, 's'); 9829 ck_assert_ptr_eq(r, s); 9830 ck_assert_str_eq(s, "s"); 9831 // size 0 - no change 9832 r = bLInjectS(s, 0, -1, 's'); 9833 ck_assert_ptr_eq(r, s); 9834 ck_assert_str_eq(s, "s"); 9835 // NULL var 9836 r = bLInjectS(NULL, sizeof s, 0, 's'); 9837 ck_assert_ptr_eq(r, null); 9838 9839 } 9840 9841 9842 void delST(CuTest *tc UNUSED) { 9843 9844 // del 9845 char *s = delS("sheepy", 0,2); 9846 ck_assert_str_eq(s, "eepy"); 9847 free(s); 9848 // negative index 9849 s = delS("sheepy", -2,0); 9850 ck_assert_str_eq(s, "shee"); 9851 free(s); 9852 // positive and negative indexes 9853 s = delS("sheepy", 2,-2); 9854 ck_assert_str_eq(s, "shpy"); 9855 free(s); 9856 // start = end 9857 s = delS("sheepy", 2,-4); 9858 ck_assert_str_eq(s, "sheepy"); 9859 free(s); 9860 // delete entire string 9861 s = delS("sheepy", 0,0); 9862 ck_assert_str_eq(s, ""); 9863 free(s); 9864 // end of string 9865 s = delS("sheepy", 2,6); 9866 ck_assert_str_eq(s, "sh"); 9867 free(s); 9868 // NULL string 9869 ck_assert_ptr_eq(delS(NULL, 2,-4), NULL); 9870 // start outside string 9871 ck_assert_ptr_eq(delS("sheepy", 20,-4), NULL); 9872 s = delS("sheepy", -20,-4); 9873 ck_assert_str_eq(s, "eepy"); 9874 free(s); 9875 // end outside string 9876 s = delS("sheepy", 2,40); 9877 ck_assert_str_eq(s, "sh"); 9878 free(s); 9879 ck_assert_ptr_eq(delS("sheepy", 2,-40), NULL); 9880 // end before start 9881 ck_assert_ptr_eq(delS("sheepy", 4,2), NULL); 9882 9883 } 9884 9885 9886 void iDelST(CuTest *tc UNUSED) { 9887 9888 char *s, *r; 9889 // del 9890 s = strdup("sheepy"); 9891 r = iDelS(&s, 0,2); 9892 ck_assert_str_eq(s, "eepy"); 9893 free(s); 9894 // negative index 9895 s = strdup("sheepy"); 9896 r = iDelS(&s, -2,0); 9897 ck_assert_str_eq(s, "shee"); 9898 free(s); 9899 // positive and negative indexes 9900 s = strdup("sheepy"); 9901 r = iDelS(&s, 2,-2); 9902 ck_assert_str_eq(s, "shpy"); 9903 free(s); 9904 // start = end 9905 s = strdup("sheepy"); 9906 r = iDelS(&s, 2,-4); 9907 ck_assert_str_eq(s, "sheepy"); 9908 free(s); 9909 // delete entire string 9910 s = strdup("sheepy"); 9911 r = iDelS(&s, 0,0); 9912 ck_assert_str_eq(s, ""); 9913 free(s); 9914 // end of string 9915 s = strdup("sheepy"); 9916 r = iDelS(&s, 2,6); 9917 ck_assert_str_eq(s, "sh"); 9918 free(s); 9919 // NULL string 9920 s = NULL; 9921 r = iDelS(&s, 2,-4); 9922 ck_assert_ptr_eq(s, NULL); 9923 // start outside string 9924 s = strdup("sheepy"); 9925 r = iDelS(&s, 20,-4); 9926 ck_assert_str_eq(s, "sheepy"); 9927 r = iDelS(&s, -20,-4); 9928 ck_assert_str_eq(s, "eepy"); 9929 free(s); 9930 // end outside string 9931 s = strdup("sheepy"); 9932 r = iDelS(&s, 2,40); 9933 ck_assert_str_eq(s, "sh"); 9934 free(s); 9935 s = strdup("sheepy"); 9936 r = iDelS(&s, 2,-40); 9937 ck_assert_str_eq(s, "sheepy"); 9938 free(s); 9939 // end before start 9940 s = strdup("sheepy"); 9941 r = iDelS(&s, 4,2); 9942 ck_assert_str_eq(s, "sheepy"); 9943 free(s); 9944 // NULL var 9945 r = iDelS(NULL, 4,2); 9946 ck_assert_ptr_eq(r, null); 9947 9948 } 9949 9950 9951 void bDelST(CuTest *tc UNUSED) { 9952 9953 char s[100]; 9954 char *r = null; 9955 9956 // del 9957 strcpy(s, "sheepy"); 9958 r = bDelS(s, 0,2); 9959 ck_assert_ptr_eq(r, s); 9960 ck_assert_str_eq(s, "eepy"); 9961 // negative index 9962 strcpy(s, "sheepy"); 9963 r = bDelS(s, -2,0); 9964 ck_assert_ptr_eq(r, s); 9965 ck_assert_str_eq(s, "shee"); 9966 // positive and negative indexes 9967 strcpy(s, "sheepy"); 9968 r = bDelS(s, 2,-2); 9969 ck_assert_ptr_eq(r, s); 9970 ck_assert_str_eq(s, "shpy"); 9971 // start = end 9972 strcpy(s, "sheepy"); 9973 r = bDelS(s, 2,-4); 9974 ck_assert_ptr_eq(r, s); 9975 ck_assert_str_eq(s, "sheepy"); 9976 // delete entire string 9977 strcpy(s, "sheepy"); 9978 r = bDelS(s, 0,0); 9979 ck_assert_ptr_eq(r, s); 9980 ck_assert_str_eq(s, ""); 9981 // end of string 9982 strcpy(s, "sheepy"); 9983 r = bDelS(s, 2,6); 9984 ck_assert_ptr_eq(r, s); 9985 ck_assert_str_eq(s, "sh"); 9986 // start outside string 9987 strcpy(s, "sheepy"); 9988 r = bDelS(s, 20,-4); 9989 ck_assert_ptr_eq(r, null); 9990 ck_assert_str_eq(s, "sheepy"); 9991 r = bDelS(s, -20,-4); 9992 ck_assert_ptr_eq(r, s); 9993 ck_assert_str_eq(s, "eepy"); 9994 // end outside string 9995 strcpy(s, "sheepy"); 9996 r = bDelS(s, 2,40); 9997 ck_assert_ptr_eq(r, s); 9998 ck_assert_str_eq(s, "sh"); 9999 strcpy(s, "sheepy"); 10000 r = bDelS(s, 2,-40); 10001 ck_assert_ptr_eq(r, null); 10002 ck_assert_str_eq(s, "sheepy"); 10003 // end before start 10004 strcpy(s, "sheepy"); 10005 r = bDelS(s, 4,2); 10006 ck_assert_ptr_eq(r, null); 10007 ck_assert_str_eq(s, "sheepy"); 10008 // NULL var 10009 r = bDelS(NULL, 4,2); 10010 ck_assert_ptr_eq(r, null); 10011 10012 } 10013 10014 10015 void bLDelST(CuTest *tc UNUSED) { 10016 10017 char s[100]; 10018 char *r = null; 10019 10020 // del 10021 strcpy(s, "sheepy"); 10022 r = bLDelS(s, sizeof(s), 0,2); 10023 ck_assert_ptr_eq(r, s); 10024 ck_assert_str_eq(s, "eepy"); 10025 // buffer shorter than string 10026 strcpy(s, "sheepy"); 10027 r = bLDelS(s, 5, 0,2); 10028 ck_assert_ptr_eq(r, s); 10029 ck_assert_str_eq(s, "ee"); 10030 // negative index 10031 strcpy(s, "sheepy"); 10032 r = bLDelS(s, sizeof(s), -2,0); 10033 ck_assert_ptr_eq(r, s); 10034 ck_assert_str_eq(s, "shee"); 10035 // positive and negative indexes 10036 strcpy(s, "sheepy"); 10037 r = bLDelS(s, sizeof(s), 2,-2); 10038 ck_assert_ptr_eq(r, s); 10039 ck_assert_str_eq(s, "shpy"); 10040 // start = end 10041 strcpy(s, "sheepy"); 10042 r = bLDelS(s, sizeof(s), 2,-4); 10043 ck_assert_ptr_eq(r, s); 10044 ck_assert_str_eq(s, "sheepy"); 10045 // end of string 10046 strcpy(s, "sheepy"); 10047 r = bLDelS(s, sizeof(s), 2,6); 10048 ck_assert_ptr_eq(r, s); 10049 ck_assert_str_eq(s, "sh"); 10050 // start outside string 10051 strcpy(s, "sheepy"); 10052 r = bLDelS(s, sizeof(s), 20,-4); 10053 ck_assert_ptr_eq(r, null); 10054 ck_assert_str_eq(s, "sheepy"); 10055 // end outside string 10056 strcpy(s, "sheepy"); 10057 r = bLDelS(s, sizeof(s), 2,40); 10058 ck_assert_ptr_eq(r, s); 10059 ck_assert_str_eq(s, "sh"); 10060 strcpy(s, "sheepy"); 10061 r = bLDelS(s, sizeof(s), -22,3); 10062 ck_assert_ptr_eq(r, s); 10063 ck_assert_str_eq(s, "epy"); 10064 strcpy(s, "sheepy"); 10065 r = bLDelS(s, sizeof(s), 2,-40); 10066 ck_assert_ptr_eq(r, null); 10067 ck_assert_str_eq(s, "sheepy"); 10068 // end before start 10069 strcpy(s, "sheepy"); 10070 r = bLDelS(s, sizeof(s), 4,2); 10071 ck_assert_ptr_eq(r, null); 10072 ck_assert_str_eq(s, "sheepy"); 10073 // size 0 10074 r = bLDelS(s, 0, 0, 0); 10075 ck_assert_ptr_eq(r, null); 10076 // NULL var 10077 r = bLDelS(NULL, sizeof(s), 0, 0); 10078 ck_assert_ptr_eq(r, null); 10079 10080 10081 } 10082 10083 10084 void delElemST(CuTest *tc UNUSED) { 10085 10086 char b[20]; 10087 char *r; 10088 10089 // del 10090 strcpy(b, "sheepy"); 10091 r = delElemS(b, 0); 10092 ck_assert_str_eq(r, "heepy"); 10093 free(r); 10094 strcpy(b, "sheepy"); 10095 r = delElemS(b, 5); 10096 ck_assert_str_eq(r, "sheep"); 10097 free(r); 10098 // negative index 10099 strcpy(b, "sheepy"); 10100 r = delElemS(b, -1); 10101 ck_assert_str_eq(r, "sheep"); 10102 free(r); 10103 strcpy(b, "sheepy"); 10104 r = delElemS(b, -6); 10105 ck_assert_str_eq(r, "heepy"); 10106 free(r); 10107 // index outside string 10108 strcpy(b, "sheepy"); 10109 r = delElemS(b, 6); 10110 ck_assert_ptr_eq(r, null); 10111 free(r); 10112 strcpy(b, "sheepy"); 10113 r = delElemS(b, -7); 10114 ck_assert_ptr_eq(r, null); 10115 free(r); 10116 // null string 10117 ck_assert_ptr_eq(delElemS(null, 0), null); 10118 10119 10120 } 10121 10122 10123 void iDelElemST(CuTest *tc UNUSED) { 10124 10125 char *b; 10126 char *r; 10127 10128 // del 10129 b = strdup("sheepy"); 10130 r = iDelElemS(&b, 0); 10131 ck_assert_str_eq(r, "heepy"); 10132 free(r); 10133 b = strdup("sheepy"); 10134 r = iDelElemS(&b, 5); 10135 ck_assert_str_eq(r, "sheep"); 10136 free(r); 10137 // negative index 10138 b = strdup("sheepy"); 10139 r = iDelElemS(&b, -1); 10140 ck_assert_str_eq(r, "sheep"); 10141 free(r); 10142 b = strdup("sheepy"); 10143 r = iDelElemS(&b, -6); 10144 ck_assert_str_eq(r, "heepy"); 10145 free(r); 10146 // index outside string 10147 b = strdup("sheepy"); 10148 r = iDelElemS(&b, 6); 10149 ck_assert_ptr_eq(r, null); 10150 free(b); 10151 b = strdup("sheepy"); 10152 r = iDelElemS(&b, -7); 10153 ck_assert_ptr_eq(r, null); 10154 free(b); 10155 // null string 10156 ck_assert_ptr_eq(iDelElemS(null, 0), null); 10157 10158 10159 } 10160 10161 10162 void bDelElemST(CuTest *tc UNUSED) { 10163 10164 char b[20]; 10165 char *r; 10166 10167 // del 10168 strcpy(b, "sheepy"); 10169 r = bDelElemS(b, 0); 10170 ck_assert_str_eq(r, "heepy"); 10171 strcpy(b, "sheepy"); 10172 r = bDelElemS(b, 5); 10173 ck_assert_str_eq(r, "sheep"); 10174 // negative index 10175 strcpy(b, "sheepy"); 10176 r = bDelElemS(b, -1); 10177 ck_assert_str_eq(r, "sheep"); 10178 strcpy(b, "sheepy"); 10179 r = bDelElemS(b, -6); 10180 ck_assert_str_eq(r, "heepy"); 10181 // index outside string 10182 strcpy(b, "sheepy"); 10183 r = bDelElemS(b, 6); 10184 ck_assert_ptr_eq(r, null); 10185 strcpy(b, "sheepy"); 10186 r = bDelElemS(b, -7); 10187 ck_assert_ptr_eq(r, null); 10188 // null string 10189 ck_assert_ptr_eq(bDelElemS(null, 0), null); 10190 10191 10192 } 10193 10194 10195 void bLDelElemST(CuTest *tc UNUSED) { 10196 10197 char b[20]; 10198 char *r; 10199 10200 // del 10201 strcpy(b, "sheepy"); 10202 r = bLDelElemS(b, sizeof(b), 0); 10203 ck_assert_str_eq(r, "heepy"); 10204 strcpy(b, "sheepy"); 10205 r = bLDelElemS(b, sizeof(b), 5); 10206 ck_assert_str_eq(r, "sheep"); 10207 // negative index 10208 strcpy(b, "sheepy"); 10209 r = bLDelElemS(b, sizeof(b), -1); 10210 ck_assert_str_eq(r, "sheep"); 10211 strcpy(b, "sheepy"); 10212 r = bLDelElemS(b, sizeof(b), -6); 10213 ck_assert_str_eq(r, "heepy"); 10214 // dest size shorter than strlen 10215 strcpy(b, "sheepy"); 10216 r = bLDelElemS(b, 4, -1); 10217 ck_assert_str_eq(r, "sh"); 10218 // index outside string 10219 strcpy(b, "sheepy"); 10220 r = bLDelElemS(b, sizeof(b), 6); 10221 ck_assert_ptr_eq(r, null); 10222 strcpy(b, "sheepy"); 10223 r = bLDelElemS(b, sizeof(b), -7); 10224 ck_assert_ptr_eq(r, null); 10225 r = bLDelElemS(b, sizeof(b), -8); 10226 ck_assert_ptr_eq(r, null); 10227 // size 0 10228 ck_assert_ptr_eq(bLDelElemS(b, 0, 0), null); 10229 // null string 10230 ck_assert_ptr_eq(bLDelElemS(null, sizeof(b), 0), null); 10231 10232 10233 } 10234 10235 10236 void findST(CuTest *tc UNUSED) { 10237 10238 // find string in the middle 10239 ck_assert_str_eq(findS("sheepy", "ee"), "eepy"); 10240 // find non existing string 10241 ck_assert_ptr_eq(findS("sheepy", "$"), NULL); 10242 // find NULL 10243 ck_assert_ptr_eq(findS("sheepy", NULL), NULL); 10244 // NULL string 10245 ck_assert_ptr_eq(findS(NULL, "$"), NULL); 10246 10247 } 10248 10249 10250 void findCharST(CuTest *tc UNUSED) { 10251 10252 // find string in the middle 10253 ck_assert_str_eq(findCharS("sheepy", 'e'), "eepy"); 10254 // find non existing string 10255 ck_assert_ptr_eq(findCharS("sheepy", '$'), NULL); 10256 // find 0 10257 ck_assert_str_eq(findCharS("sheepy", 0), ""); 10258 // NULL string 10259 ck_assert_ptr_eq(findCharS(NULL, '$'), NULL); 10260 10261 } 10262 10263 10264 void indexOfST(CuTest *tc UNUSED) { 10265 10266 // indexOf string in the middle 10267 ck_assert_int_eq(indexOfS("sheepy", "ee"), 2); 10268 // indexOf non existing string 10269 ck_assert_int_eq(indexOfS("sheepy", "$"), -1); 10270 // indexOf NULL 10271 ck_assert_int_eq(indexOfS("sheepy", NULL), -1); 10272 // NULL string 10273 ck_assert_int_eq(indexOfS(NULL, "$"), -1); 10274 10275 10276 } 10277 10278 10279 void indexOfCharST(CuTest *tc UNUSED) { 10280 10281 // indexOf string in the middle 10282 ck_assert_int_eq(indexOfCharS("sheepy", 'e'), 2); 10283 // indexOf non existing string 10284 ck_assert_int_eq(indexOfCharS("sheepy", '$'), -1); 10285 // indexOf 0 10286 ck_assert_int_eq(indexOfCharS("sheepy", 0), 6); 10287 // NULL string 10288 ck_assert_int_eq(indexOfCharS(NULL, '$'), -1); 10289 10290 10291 } 10292 10293 10294 void hasST(CuTest *tc UNUSED) { 10295 10296 // find string in the middle 10297 ck_assert(hasS("sheepy", "ee")); 10298 // find non existing string 10299 ck_assert(!hasS("sheepy", "$")); 10300 // find NULL 10301 ck_assert(!hasS("sheepy", NULL)); 10302 // NULL string 10303 ck_assert(!hasS(NULL, "$")); 10304 10305 } 10306 10307 10308 void hasCharST(CuTest *tc UNUSED) { 10309 10310 // find string in the middle 10311 ck_assert(hasCharS("sheepy", 'e')); 10312 // find non existing string 10313 ck_assert(!hasCharS("sheepy", '$')); 10314 // find 0 10315 ck_assert(hasCharS("sheepy", 0)); 10316 // NULL string 10317 ck_assert(!hasCharS(NULL, '$')); 10318 10319 } 10320 10321 10322 void icFindST(CuTest *tc UNUSED) { 10323 10324 // find string in the middle 10325 ck_assert_str_eq(icFindS("shEepy", "eE"), "Eepy"); 10326 // find non existing string 10327 ck_assert_ptr_eq(icFindS("sheepy", "$"), NULL); 10328 // find NULL 10329 ck_assert_ptr_eq(icFindS("sheepy", NULL), NULL); 10330 // NULL string 10331 ck_assert_ptr_eq(icFindS(NULL, "$"), NULL); 10332 10333 10334 } 10335 10336 10337 void icFindCharST(CuTest *tc UNUSED) { 10338 10339 // find string in the middle 10340 ck_assert_str_eq(icFindCharS("shEEpy", 'e'), "EEpy"); 10341 // find non existing string 10342 ck_assert_ptr_eq(icFindCharS("sheepy", '$'), NULL); 10343 // find 0 10344 ck_assert_str_eq(icFindCharS("sheepy", 0), ""); 10345 // NULL string 10346 ck_assert_ptr_eq(icFindCharS(NULL, '$'), NULL); 10347 10348 10349 } 10350 10351 10352 void icIndexOfST(CuTest *tc UNUSED) { 10353 10354 // indexOf string in the middle 10355 ck_assert_int_eq(icIndexOfS("sheepy", "EE"), 2); 10356 // indexOf non existing string 10357 ck_assert_int_eq(icIndexOfS("sheepy", "$"), -1); 10358 // indexOf NULL 10359 ck_assert_int_eq(icIndexOfS("sheepy", NULL), -1); 10360 // NULL string 10361 ck_assert_int_eq(icIndexOfS(NULL, "$"), -1); 10362 10363 10364 } 10365 10366 10367 void icIndexOfCharST(CuTest *tc UNUSED) { 10368 10369 // indexOf string in the middle 10370 ck_assert_int_eq(icIndexOfCharS("sheepy", 'E'), 2); 10371 // indexOf non existing string 10372 ck_assert_int_eq(icIndexOfCharS("sheepy", '$'), -1); 10373 // indexOf 0 10374 ck_assert_int_eq(icIndexOfCharS("sheepy", 0), 6); 10375 // NULL string 10376 ck_assert_int_eq(icIndexOfCharS(NULL, '$'), -1); 10377 10378 10379 } 10380 10381 10382 void icHasST(CuTest *tc UNUSED) { 10383 10384 // find string in the middle 10385 ck_assert(icHasS("sheepy", "EE")); 10386 // find non existing string 10387 ck_assert(!icHasS("sheepy", "$")); 10388 // find NULL 10389 ck_assert(!icHasS("sheepy", NULL)); 10390 // NULL string 10391 ck_assert(!icHasS(NULL, "$")); 10392 10393 10394 } 10395 10396 10397 void icHasCharST(CuTest *tc UNUSED) { 10398 10399 // find string in the middle 10400 ck_assert(icHasCharS("shEepy", 'e')); 10401 // find non existing string 10402 ck_assert(!icHasCharS("sheepy", '$')); 10403 // find 0 10404 ck_assert(icHasCharS("sheepy", 0)); 10405 // NULL string 10406 ck_assert(!icHasCharS(NULL, '$')); 10407 10408 10409 } 10410 10411 10412 void tokST(CuTest *tc UNUSED) { 10413 10414 // string 10415 char *s; 10416 char *w; 10417 s = strdup("172.16.43.0/24 dev ens32 dev proto"); 10418 w = s; 10419 ck_assert_str_eq(tokS(s, "dev ", &w), "172.16.43.0/24 "); 10420 free(s); 10421 // delimiter not found 10422 s = strdup("172.16.43.0/24 dev ens32 dev proto"); 10423 ck_assert_str_eq(tokS(s, "ANYTHING", &w), "172.16.43.0/24 dev ens32 dev proto"); 10424 ck_assert_ptr_eq(w, NULL); 10425 free(s); 10426 // same with w initialized to NULL 10427 s = strdup("172.16.43.0/24 dev ens32 dev proto"); 10428 w = NULL; 10429 ck_assert_str_eq(tokS(s, "dev ", &w), "172.16.43.0/24 "); 10430 ck_assert_str_eq(w, "ens32 dev proto"); 10431 ck_assert_str_eq(tokS(NULL, "dev ", &w), "ens32 "); 10432 ck_assert_str_eq(w, "proto"); 10433 ck_assert_str_eq(tokS(NULL, "dev ", &w), "proto"); 10434 ck_assert_ptr_eq(w, NULL); 10435 free(s); 10436 // NULL string 10437 w = NULL; 10438 ck_assert_ptr_eq(tokS(NULL, ";", &w), NULL); 10439 // NULL delimiter 10440 ck_assert_ptr_eq(tokS("test", NULL, &w), NULL); 10441 10442 } 10443 10444 10445 void icTokST(CuTest *tc UNUSED) { 10446 10447 // string 10448 char *s; 10449 char *w; 10450 s = strdup("172.16.43.0/24 dev ens32 dev proto"); 10451 w = s; 10452 ck_assert_str_eq(icTokS(s, "DEV ", &w), "172.16.43.0/24 "); 10453 free(s); 10454 // delimiter not found 10455 s = strdup("172.16.43.0/24 dev ens32 dev proto"); 10456 ck_assert_str_eq(icTokS(s, "ANYTHING", &w), "172.16.43.0/24 dev ens32 dev proto"); 10457 ck_assert_ptr_eq(w, NULL); 10458 free(s); 10459 // same with w initialized to NULL 10460 s = strdup("172.16.43.0/24 DEV ens32 dev proto"); 10461 w = NULL; 10462 ck_assert_str_eq(icTokS(s, "dev ", &w), "172.16.43.0/24 "); 10463 ck_assert_str_eq(w, "ens32 dev proto"); 10464 ck_assert_str_eq(icTokS(NULL, "dev ", &w), "ens32 "); 10465 ck_assert_str_eq(w, "proto"); 10466 ck_assert_str_eq(icTokS(NULL, "dev ", &w), "proto"); 10467 ck_assert_ptr_eq(w, NULL); 10468 free(s); 10469 // NULL string 10470 w = NULL; 10471 ck_assert_ptr_eq(icTokS(NULL, ";", &w), NULL); 10472 // NULL delimiter 10473 ck_assert_ptr_eq(icTokS("test", NULL, &w), NULL); 10474 10475 10476 } 10477 10478 10479 void lenUTF8T(CuTest *tc UNUSED) { 10480 10481 // string 10482 ck_assert_uint_eq(lenUTF8("sheepy"), 6); 10483 // UTF8 10484 ck_assert_uint_eq(lenUTF8("sheepy£"), 7); 10485 ck_assert_uint_eq(lenS("sheepy£"), 8); 10486 // NULL string 10487 ck_assert_uint_eq(lenUTF8(NULL), 0); 10488 10489 10490 } 10491 10492 10493 void bLLenUTF8T(CuTest *tc UNUSED) { 10494 10495 // string 10496 ck_assert_uint_eq(bLLenUTF8("sheepy", 7), 6); 10497 // UTF8 10498 ck_assert_uint_eq(bLLenUTF8("sheepy£",9), 7); 10499 ck_assert_uint_eq(bLLenUTF8("sheepy£", 6), 5); 10500 ck_assert_uint_eq(lenS("sheepy£"), 8); 10501 // size 0 10502 ck_assert_uint_eq(bLLenUTF8("sheepy£", 0), 0); 10503 // NULL string 10504 ck_assert_uint_eq(bLLenUTF8(NULL, 1), 0); 10505 10506 10507 } 10508 10509 10510 void isUTF8T(CuTest *tc UNUSED) { 10511 10512 char b[8]; 10513 char *r = null; 10514 10515 // string 10516 ck_assert(isUTF8("sheepy")); 10517 // UTF8 10518 ck_assert(isUTF8("sheepy£")); 10519 // invalid UTF8 10520 r = strLCpy(b, sizeof(b), "sheepy£"); 10521 ck_assert_ptr_eq(r, b); 10522 ck_assert(!isUTF8(b)); 10523 // null string 10524 ck_assert(!isUTF8(null)); 10525 10526 10527 } 10528 10529 10530 void bLIsUTF8T(CuTest *tc UNUSED) { 10531 10532 // string 10533 ck_assert(bLIsUTF8("sheepy", 7)); 10534 // UTF8 10535 ck_assert(bLIsUTF8("sheepy£", 9)); 10536 // buffer shorter than string (string is not nul terminated) 10537 ck_assert(!bLIsUTF8("sheepy", 6)); 10538 // invalid UTF8 10539 ck_assert(!bLIsUTF8("sheepy£", 8)); 10540 // size 0 10541 ck_assert(!bLIsUTF8("sheepy£", 0)); 10542 // null string 10543 ck_assert(!bLIsUTF8(null, 1)); 10544 10545 10546 } 10547 10548 10549 void isCodeUTF8T(CuTest *tc UNUSED) { 10550 10551 // valid 10552 ck_assert(isCodeUTF8("as")); 10553 ck_assert(isCodeUTF8("£s")); 10554 // invalid 10555 u8 b[3] = init0Var; 10556 b[0] = 128; 10557 ck_assert(!isCodeUTF8((char*)b)); 10558 // null string 10559 ck_assert(!isCodeUTF8(null)); 10560 10561 10562 } 10563 10564 10565 void nextUTF8T(CuTest *tc UNUSED) { 10566 10567 const char *r; 10568 10569 // next 10570 r = nextUTF8("£sheepy"); 10571 ck_assert_str_eq(r, "sheepy"); 10572 // empty string 10573 r = nextUTF8(""); 10574 ck_assert_ptr_eq(r, null); 10575 // null string 10576 r = nextUTF8(null); 10577 ck_assert_ptr_eq(r, null); 10578 10579 10580 } 10581 10582 10583 void bLNextUTF8T(CuTest *tc UNUSED) { 10584 10585 char b[20] = init0Var; 10586 const char *r; 10587 strcpy(b, "£sheepy"); 10588 10589 // next 10590 r = bLNextUTF8(b, sizeof(b), &b[3]); 10591 ck_assert_str_eq(r, "eepy"); 10592 // last char 10593 r = bLNextUTF8(b, sizeof(b), &b[7]); 10594 ck_assert_ptr_eq(r, null); 10595 // empty string 10596 r = bLNextUTF8(b, sizeof(b), &b[10]); 10597 ck_assert_ptr_eq(r, null); 10598 // string longer than buffer 10599 r = bLNextUTF8(b, 6, &b[7]); 10600 ck_assert_ptr_eq(r, null); 10601 r = bLNextUTF8(b, 6, &b[5]); 10602 ck_assert_ptr_eq(r, null); 10603 // size 0 10604 r = bLNextUTF8(b, 0, b); 10605 ck_assert_ptr_eq(r, null); 10606 // null string 10607 r = bLNextUTF8(null, 1, b); 10608 ck_assert_ptr_eq(r, null); 10609 r = bLNextUTF8(b, 1, null); 10610 ck_assert_ptr_eq(r, null); 10611 10612 10613 } 10614 10615 10616 void findNextUTF8T(CuTest *tc UNUSED) { 10617 10618 char b[20] = init0Var; 10619 const char *r; 10620 strcpy(b, "£sheepy"); 10621 10622 // next 10623 r = findNextUTF8(b, sizeof(b), &b[3]); 10624 ck_assert_str_eq(r, "eepy"); 10625 // in a code point, find first valid code point in utf8 parameter 10626 // same as findNextUTF8(b, sizeof(b), &b[2]) 10627 r = findNextUTF8(b, sizeof(b), &b[1]); 10628 ck_assert_str_eq(r, "heepy"); 10629 // last char 10630 r = findNextUTF8(b, sizeof(b), &b[7]); 10631 ck_assert_ptr_eq(r, null); 10632 // empty string 10633 r = findNextUTF8(b, sizeof(b), &b[10]); 10634 ck_assert_ptr_eq(r, null); 10635 // string longer than buffer 10636 r = findNextUTF8(b, 6, &b[7]); 10637 ck_assert_ptr_eq(r, null); 10638 r = findNextUTF8(b, 6, &b[5]); 10639 ck_assert_ptr_eq(r, null); 10640 // size 0 10641 r = findNextUTF8(b, 0, b); 10642 ck_assert_ptr_eq(r, null); 10643 // null string 10644 r = findNextUTF8(null, 1, b); 10645 ck_assert_ptr_eq(r, null); 10646 r = findNextUTF8(b, 1, null); 10647 ck_assert_ptr_eq(r, null); 10648 10649 10650 } 10651 10652 10653 void prevUTF8T(CuTest *tc UNUSED) { 10654 10655 char b[20] = init0Var; 10656 const char *r; 10657 strcpy(b, "£sheepy"); 10658 10659 // prev 10660 r = prevUTF8(&b[2]); 10661 ck_assert_str_eq(r, "£sheepy"); 10662 // null string 10663 r = prevUTF8(null); 10664 ck_assert_ptr_eq(r, null); 10665 10666 10667 } 10668 10669 10670 void bPrevUTF8T(CuTest *tc UNUSED) { 10671 10672 char b[20] = init0Var; 10673 const char *r; 10674 strcpy(b, "£sheepy"); 10675 10676 // prev 10677 r = bPrevUTF8(b, &b[2]); 10678 ck_assert_str_eq(r, "£sheepy"); 10679 // string start 10680 r = bPrevUTF8(b, b); 10681 ck_assert_ptr_eq(r, null); 10682 // null string 10683 r = bPrevUTF8(null, b); 10684 ck_assert_ptr_eq(r, null); 10685 r = bPrevUTF8(b, null); 10686 ck_assert_ptr_eq(r, null); 10687 10688 } 10689 10690 10691 void idx2PtrUTF8T(CuTest *tc UNUSED) { 10692 10693 char *emptys = ""; 10694 const char *r; 10695 10696 // index 10697 r = idx2PtrUTF8("£sheepy", 1); 10698 ck_assert_str_eq(r, "sheepy"); 10699 r = idx2PtrUTF8("£sheepy", 2); 10700 ck_assert_str_eq(r, "heepy"); 10701 r = idx2PtrUTF8("£sheepy", 0); 10702 ck_assert_str_eq(r, "£sheepy"); 10703 // NUL byte index 10704 r = idx2PtrUTF8("£sheepy", strlen("£sheepy")-1); 10705 ck_assert_str_eq(r, ""); 10706 // negative index 10707 r = idx2PtrUTF8("£sheepy", -1); 10708 ck_assert_str_eq(r, "y"); 10709 // empty string 10710 r = idx2PtrUTF8(emptys, -1); 10711 ck_assert_ptr_eq(r, emptys); 10712 // index outside buffer 10713 r = idx2PtrUTF8("£sheepy", 8); 10714 ck_assert_ptr_eq(r, null); 10715 r = idx2PtrUTF8("£sheepy", 9); 10716 ck_assert_ptr_eq(r, null); 10717 r = idx2PtrUTF8("£sheepy", -9); 10718 ck_assert_ptr_eq(r, null); 10719 // null string 10720 r = idx2PtrUTF8(null, 1); 10721 ck_assert_ptr_eq(r, null); 10722 10723 } 10724 10725 10726 void bLIdx2PtrUTF8T(CuTest *tc UNUSED) { 10727 10728 char b[20] = init0Var; 10729 const char *r; 10730 strcpy(b, "£sheepy"); 10731 10732 // index 10733 r = bLIdx2PtrUTF8(b, sizeof(b), 3); 10734 ck_assert_str_eq(r, "eepy"); 10735 r = bLIdx2PtrUTF8(b, sizeof(b), 0); 10736 ck_assert_str_eq(r, b); 10737 // NUL byte index 10738 r = bLIdx2PtrUTF8(b, sizeS(b), strlen(b)-1); 10739 ck_assert_str_eq(r, ""); 10740 // negative index 10741 r = bLIdx2PtrUTF8(b, sizeof(b), -2); 10742 ck_assert_str_eq(r, "py"); 10743 r = bLIdx2PtrUTF8(b, sizeof(b), -1); 10744 ck_assert_str_eq(r, "y"); 10745 // string longer than buffer and negative index 10746 r = bLIdx2PtrUTF8(b, 8, -1); 10747 ck_assert_str_eq(r, "py"); 10748 // last char 10749 r = bLIdx2PtrUTF8(b, sizeof(b), 7); 10750 ck_assert_str_eq(r, ""); 10751 // empty string 10752 r = bLIdx2PtrUTF8(&b[10], 2, 1); 10753 ck_assert_str_eq(r, &b[10]); 10754 // index outside string 10755 r = bLIdx2PtrUTF8(b, 6, 7); 10756 ck_assert_ptr_eq(r, null); 10757 r = bLIdx2PtrUTF8(b, 6, 5); 10758 ck_assert_ptr_eq(r, null); 10759 r = bLIdx2PtrUTF8(b, 6, -7); 10760 ck_assert_ptr_eq(r, null); 10761 // size 0 10762 r = bLIdx2PtrUTF8(b, 0, 0); 10763 ck_assert_ptr_eq(r, b); 10764 // null string 10765 r = bLIdx2PtrUTF8(null, 1, 0); 10766 ck_assert_ptr_eq(r, null); 10767 10768 10769 } 10770 10771 10772 void ptr2IdxUTF8T(CuTest *tc UNUSED) { 10773 10774 char b[20] = init0Var; 10775 int64_t r; 10776 strcpy(b, "£sheepy"); 10777 10778 // pointer to index 10779 r = ptr2IdxUTF8(b, &b[1]); 10780 ck_assert_int_eq(r, 0); 10781 r = ptr2IdxUTF8(b, &b[2]); 10782 ck_assert_int_eq(r, 1); 10783 r = ptr2IdxUTF8(&b[2], &b[4]); 10784 ck_assert_int_eq(r, 2); 10785 r = ptr2IdxUTF8(b, &b[7]); 10786 ck_assert_int_eq(r, 6); 10787 // negative index 10788 r = ptr2IdxUTF8(&b[8], &b[7]); 10789 ck_assert_int_eq(r, -1); 10790 r = ptr2IdxUTF8(&b[8], &b[6]); 10791 ck_assert_int_eq(r, -2); 10792 r = ptr2IdxUTF8(&b[8], b); 10793 ck_assert_int_eq(r, -7); 10794 // string start 10795 r = ptr2IdxUTF8(b, b); 10796 ck_assert_int_eq(r, 0); 10797 // null pos 10798 r = ptr2IdxUTF8(b, null); 10799 ck_assert_int_eq(r, 0); 10800 // null string 10801 r = ptr2IdxUTF8(null, b); 10802 ck_assert_int_eq(r, 0); 10803 10804 } 10805 10806 10807 void bPtr2IdxUTF8T(CuTest *tc UNUSED) { 10808 10809 char b[20] = init0Var; 10810 int64_t r; 10811 strcpy(b, "£sheepy"); 10812 10813 // pointer to index 10814 r = bPtr2IdxUTF8(b, b, &b[1]); 10815 ck_assert_int_eq(r, 0); 10816 r = bPtr2IdxUTF8(b, b, &b[2]); 10817 ck_assert_int_eq(r, 1); 10818 r = bPtr2IdxUTF8(b, b, &b[7]); 10819 ck_assert_int_eq(r, 6); 10820 // negative index 10821 r = bPtr2IdxUTF8(b, &b[8], &b[7]); 10822 ck_assert_int_eq(r, -1); 10823 r = bPtr2IdxUTF8(b, &b[8], &b[6]); 10824 ck_assert_int_eq(r, -2); 10825 r = bPtr2IdxUTF8(b, &b[8], b); 10826 ck_assert_int_eq(r, -7); 10827 // string start 10828 r = bPtr2IdxUTF8(b, b, b); 10829 ck_assert_int_eq(r, 0); 10830 // null pos 10831 r = bPtr2IdxUTF8(b, b, null); 10832 ck_assert_int_eq(r, 0); 10833 // null string 10834 r = bPtr2IdxUTF8(b, null, b); 10835 ck_assert_int_eq(r, 0); 10836 r = bPtr2IdxUTF8(null, b, b); 10837 ck_assert_int_eq(r, 0); 10838 10839 10840 } 10841 10842 10843 void bLPtr2IdxUTF8T(CuTest *tc UNUSED) { 10844 10845 char b[20] = init0Var; 10846 int64_t r; 10847 strcpy(b, "£sheepy"); 10848 10849 // pointer to index 10850 r = bLPtr2IdxUTF8(b, sizeof(b), &b[1]); 10851 ck_assert_int_eq(r, 0); 10852 r = bLPtr2IdxUTF8(b, sizeof(b), &b[2]); 10853 ck_assert_int_eq(r, 1); 10854 r = bLPtr2IdxUTF8(b, sizeof(b), &b[7]); 10855 ck_assert_int_eq(r, 6); 10856 // string start 10857 r = bLPtr2IdxUTF8(b, sizeof(b), b); 10858 ck_assert_int_eq(r, 0); 10859 // null pos 10860 r = bLPtr2IdxUTF8(b, sizeof(b), null); 10861 ck_assert_int_eq(r, -1); 10862 // pos outside buffer 10863 r = bLPtr2IdxUTF8(b, 8, &b[10]); 10864 ck_assert_int_eq(r, -1); 10865 // pos before buffer start 10866 r = bLPtr2IdxUTF8(&b[1], 8, b); 10867 ck_assert_int_eq(r, -1); 10868 // size 0 buffer 10869 r = bLPtr2IdxUTF8(b, 0, b); 10870 ck_assert_int_eq(r, -1); 10871 r = bLPtr2IdxUTF8(null, sizeof(b), b); 10872 ck_assert_int_eq(r, -1); 10873 10874 10875 } 10876 10877 10878 void bLPtr2NegIdxUTF8T(CuTest *tc UNUSED) { 10879 10880 char b[20] = init0Var; 10881 int64_t r; 10882 strcpy(b, "£sheepy"); 10883 10884 // negative index 10885 r = bLPtr2NegIdxUTF8(b, 9, &b[7]); 10886 ck_assert_int_eq(r, -1); 10887 r = bLPtr2NegIdxUTF8(b, 9, &b[6]); 10888 ck_assert_int_eq(r, -2); 10889 r = bLPtr2NegIdxUTF8(b, 9, b); 10890 ck_assert_int_eq(r, -7); 10891 // null pos 10892 r = bLPtr2NegIdxUTF8(b, sizeof(b), null); 10893 ck_assert_int_eq(r, 0); 10894 // pos outside buffer 10895 r = bLPtr2NegIdxUTF8(b, 9, &b[10]); 10896 ck_assert_int_eq(r, 0); 10897 // pos before buffer start 10898 r = bLPtr2NegIdxUTF8(&b[1], 9, b); 10899 ck_assert_int_eq(r, 0); 10900 // size 0 buffer 10901 r = bLPtr2NegIdxUTF8(b, 0, b); 10902 ck_assert_int_eq(r, 0); 10903 r = bLPtr2NegIdxUTF8(null, sizeof(b), b); 10904 ck_assert_int_eq(r, 0); 10905 10906 } 10907 10908 10909 void makeValidUTF8T(CuTest *tc UNUSED) { 10910 10911 char b[20] = init0Var; 10912 char *r; 10913 strcpy(b, "£sheepy"); 10914 10915 // valid utf8, no change 10916 r = makeValidUTF8(b); 10917 ck_assert_str_eq(r, b); 10918 free(r); 10919 // invalid utf8 string 10920 r = makeValidUTF8(&b[1]); 10921 ck_assert_str_eq(r, "?sheepy"); 10922 free(r); 10923 // null string 10924 ck_assert_ptr_eq(makeValidUTF8(null), null); 10925 10926 10927 } 10928 10929 10930 void bMakeValidUTF8T(CuTest *tc UNUSED) { 10931 10932 char b[20] = init0Var; 10933 char *r; 10934 strcpy(b, "£sheepy"); 10935 10936 // valid utf8, no change 10937 r = bMakeValidUTF8(b); 10938 ck_assert_str_eq(r, "£sheepy"); 10939 // invalid utf8 string 10940 r = bMakeValidUTF8(&b[1]); 10941 ck_assert_str_eq(r, "?sheepy"); 10942 // null string 10943 ck_assert_ptr_eq(bMakeValidUTF8(null), null); 10944 10945 10946 } 10947 10948 10949 void nMakeValidUTF8T(CuTest *tc UNUSED) { 10950 10951 char b[20] = init0Var; 10952 char *r; 10953 strcpy(b, "£sheepy"); 10954 10955 // valid utf8, no change 10956 r = nMakeValidUTF8(b, 4); 10957 ck_assert_str_eq(r, "£sh"); 10958 free(r); 10959 // invalid utf8 string 10960 r = nMakeValidUTF8(&b[1], 4); 10961 ck_assert_str_eq(r, "?she"); 10962 free(r); 10963 // len 0 10964 ck_assert_ptr_eq(nMakeValidUTF8(b, 0), null); 10965 // null string 10966 ck_assert_ptr_eq(nMakeValidUTF8(null, 1), null); 10967 10968 10969 } 10970 10971 10972 void bNMakeValidUTF8T(CuTest *tc UNUSED) { 10973 10974 char b[20] = init0Var; 10975 char s[20] = init0Var; 10976 char *r; 10977 10978 // valid utf8, no change 10979 strcpy(b, "£sheepy"); 10980 r = bNMakeValidUTF8(s, b, 4); 10981 ck_assert_str_eq(r, "£sh"); 10982 // invalid utf8 string 10983 strcpy(b, "£sheepy"); 10984 r = bNMakeValidUTF8(s, &b[1], 4); 10985 ck_assert_str_eq(r, "?she"); 10986 // len 0 10987 ck_assert_ptr_eq(bNMakeValidUTF8(s, b, 0), null); 10988 // null string 10989 ck_assert_ptr_eq(bNMakeValidUTF8(s, null, 1), null); 10990 // null dest 10991 ck_assert_ptr_eq(bNMakeValidUTF8(null, b, 1), null); 10992 10993 10994 } 10995 10996 10997 void bLMakeValidUTF8T(CuTest *tc UNUSED) { 10998 10999 char b[20] = init0Var; 11000 char s[20] = init0Var; 11001 char *r; 11002 11003 // valid utf8, no change 11004 strcpy(b, "£sheepy"); 11005 r = bLMakeValidUTF8(s, 5, b); 11006 ck_assert_str_eq(r, "£sh"); 11007 // invalid utf8 string 11008 strcpy(b, "£sheepy"); 11009 r = bLMakeValidUTF8(s, 5, &b[1]); 11010 ck_assert_str_eq(r, "?she"); 11011 // len 0 11012 ck_assert_ptr_eq(bLMakeValidUTF8(s, 0, b), null); 11013 // null string 11014 ck_assert_ptr_eq(bLMakeValidUTF8(s, 1, null), null); 11015 // null dest 11016 ck_assert_ptr_eq(bLMakeValidUTF8(null, 1, b), null); 11017 11018 11019 } 11020 11021 11022 void bLNMakeValidUTF8T(CuTest *tc UNUSED) { 11023 11024 char b[20] = init0Var; 11025 char s[20] = init0Var; 11026 char *r; 11027 11028 // valid utf8, no change 11029 strcpy(b, "£sheepy"); 11030 r = bLNMakeValidUTF8(s, 5, b, 4); 11031 ck_assert_str_eq(r, "£sh"); 11032 r = bLNMakeValidUTF8(s, 5, b, 3); 11033 ck_assert_str_eq(r, "£s"); 11034 r = bLNMakeValidUTF8(s, 5, b, 6); 11035 ck_assert_str_eq(r, "£sh"); 11036 // invalid utf8 string 11037 strcpy(b, "£sheepy"); 11038 r = bLNMakeValidUTF8(s, 5, &b[1],4); 11039 ck_assert_str_eq(r, "?she"); 11040 // len 0 11041 ck_assert_ptr_eq(bLNMakeValidUTF8(s, 0, b, 1), null); 11042 ck_assert_ptr_eq(bLNMakeValidUTF8(s, 2, b, 0), null); 11043 // null string 11044 ck_assert_ptr_eq(bLNMakeValidUTF8(s, 1, null, 1), null); 11045 // null dest 11046 ck_assert_ptr_eq(bLNMakeValidUTF8(null, 1, b, 1), null); 11047 11048 11049 } 11050 11051 11052 void strNCpyUTF8T(CuTest *tc UNUSED) { 11053 11054 char s[1024] = init0Var; 11055 char *r; 11056 11057 // copy string 11058 r = strNCpyUTF8(s, "lib", 4); 11059 ck_assert_ptr_ne(r, null); 11060 ck_assert_str_eq(s, "lib"); 11061 11062 // size 0 11063 r = strNCpyUTF8(s, "AAA", 0); 11064 ck_assert_ptr_ne(r, null); 11065 ck_assert_str_eq(s, "lib"); 11066 11067 // NULL 11068 s[0] = 0; 11069 r = strNCpyUTF8(s, NULL, 10); 11070 ck_assert_ptr_eq(r, null); 11071 ck_assert_str_eq(s, ""); 11072 ck_assert_ptr_eq(strNCpyUTF8(NULL, "lib", 1), NULL); 11073 11074 11075 } 11076 11077 11078 void strLCpyUTF8T(CuTest *tc UNUSED) { 11079 11080 char s[1024]; 11081 char *r = null; 11082 11083 // copy string 11084 r = strLCpyUTF8(s, 100, "lib"); 11085 ck_assert_ptr_eq(r, s); 11086 ck_assert_str_eq(s, "lib"); 11087 // truncate src 11088 s[0] = 0; 11089 s[1] = 0; 11090 s[2] = 0; 11091 r = strLCpyUTF8(s, 3, "lib"); 11092 ck_assert_ptr_eq(r, s); 11093 ck_assert_str_eq(s, "li"); 11094 s[0] = 'a'; 11095 s[1] = 'a'; 11096 s[2] = 'a'; 11097 s[3] = 0; 11098 r = strLCpyUTF8(s, 3, "lib"); 11099 ck_assert_ptr_eq(r, s); 11100 ck_assert_str_eq(s, "li"); 11101 // size 0 - no change in s 11102 r = strLCpyUTF8(s, 0, "libsheepy"); 11103 ck_assert_ptr_eq(r, s); 11104 ck_assert_str_eq(s, "li"); 11105 // NULL 11106 s[0] = 0; 11107 r = strLCpyUTF8(s, 1, NULL); 11108 ck_assert_ptr_eq(r, null); 11109 ck_assert_str_eq(s, ""); 11110 r = strLCpyUTF8(NULL,1, "lib"); 11111 ck_assert_ptr_eq(r, null); 11112 11113 11114 } 11115 11116 11117 void strNCatUTF8T(CuTest *tc UNUSED) { 11118 11119 char s[1024]; 11120 char *r = null; 11121 11122 // append string 11123 r = strCpy(s, "lib"); 11124 ck_assert_ptr_eq(r, s); 11125 r = strNCatUTF8(s, "sheepy", 100); 11126 ck_assert_ptr_eq(r, s); 11127 ck_assert_str_eq(s, "libsheepy"); 11128 // empty string2 11129 r = strNCatUTF8(s, "", 10); 11130 ck_assert_ptr_eq(r, s); 11131 ck_assert_str_eq(s, "libsheepy"); 11132 // truncate src 11133 s[0] = 'a'; 11134 s[1] = 'a'; 11135 s[2] = 'a'; 11136 s[3] = 'a'; 11137 s[4] = 'a'; 11138 s[5] = 'a'; 11139 r = strCpy(s, "lib"); 11140 ck_assert_ptr_eq(r, s); 11141 ck_assert_str_eq(s, "lib"); 11142 r = strNCatUTF8(s, "sheepy", 2); 11143 ck_assert_ptr_eq(r, s); 11144 ck_assert_str_eq(s, "libsh"); 11145 // length 0 11146 r = strNCatUTF8(s, "sheepy", 0); 11147 ck_assert_ptr_eq(r, s); 11148 ck_assert_str_eq(s, "libsh"); 11149 // NULL string2 11150 r = strNCatUTF8(s, NULL, 1); 11151 ck_assert_ptr_eq(r, null); 11152 ck_assert_str_eq(s, "libsh"); 11153 // NULL parameter 11154 r = strNCatUTF8(NULL, "ad", 1); 11155 ck_assert_ptr_eq(r, null); 11156 11157 11158 } 11159 11160 11161 void strLCatUTF8T(CuTest *tc UNUSED) { 11162 11163 char s[1024]; 11164 char *r = null; 11165 11166 // append string 11167 r = strCpy(s, "lib"); 11168 ck_assert_ptr_eq(r, s); 11169 r = strLCatUTF8(s, 100, "sheepy"); 11170 ck_assert_ptr_eq(r, s); 11171 ck_assert_str_eq(s, "libsheepy"); 11172 // empty string2 11173 r = strLCatUTF8(s, 20, ""); 11174 ck_assert_ptr_eq(r, s); 11175 ck_assert_str_eq(s, "libsheepy"); 11176 // s strlen bigger than s size - keep s as it is 11177 r = strLCatUTF8(s, 6, "qwqwe"); 11178 ck_assert_ptr_eq(r, s); 11179 ck_assert_str_eq(s, "libsheepy"); 11180 // truncate src 11181 s[0] = 'a'; 11182 s[1] = 'a'; 11183 s[2] = 'a'; 11184 s[3] = 'a'; 11185 s[4] = 'a'; 11186 s[5] = 'a'; 11187 r = strCpy(s, "lib"); 11188 ck_assert_ptr_eq(r, s); 11189 ck_assert_str_eq(s, "lib"); 11190 r = strLNCat(s,100, "sheepy", 2); 11191 ck_assert_ptr_eq(r, s); 11192 ck_assert_str_eq(s, "libsh"); 11193 // truncate dst 11194 s[0] = 'a'; 11195 s[1] = 'a'; 11196 s[2] = 'a'; 11197 s[3] = 'a'; 11198 s[4] = 'a'; 11199 s[5] = 'a'; 11200 r = strCpy(s, "lib"); 11201 ck_assert_ptr_eq(r, s); 11202 ck_assert_str_eq(s, "lib"); 11203 r = strLCatUTF8(s, 6, "sheepy"); 11204 ck_assert_ptr_eq(r, s); 11205 ck_assert_str_eq(s, "libsh"); 11206 // NULL string2 11207 r = strLCatUTF8(s, 1, NULL); 11208 ck_assert_ptr_eq(r, null); 11209 ck_assert_str_eq(s, "libsh"); 11210 // NULL parameter 11211 r = strLCatUTF8(NULL, 1, "ad"); 11212 ck_assert_ptr_eq(r, null); 11213 11214 11215 } 11216 11217 11218 void strLNCatUTF8T(CuTest *tc UNUSED) { 11219 11220 char s[1024]; 11221 char *r = null; 11222 11223 // append string 11224 r = strCpy(s, "lib"); 11225 ck_assert_ptr_eq(r, s); 11226 r = strLNCatUTF8(s, 100, "sheepy", 100); 11227 ck_assert_ptr_eq(r, s); 11228 ck_assert_str_eq(s, "libsheepy"); 11229 // empty string2 11230 r = strLNCatUTF8(s, 20, "", 10); 11231 ck_assert_ptr_eq(r, s); 11232 ck_assert_str_eq(s, "libsheepy"); 11233 // s strlen bigger than s size - keep s as it is 11234 r = strLNCatUTF8(s, 6, "qwqwe", 1); 11235 ck_assert_ptr_eq(r, s); 11236 ck_assert_str_eq(s, "libsheepy"); 11237 // truncate dst 11238 s[0] = 'a'; 11239 s[1] = 'a'; 11240 s[2] = 'a'; 11241 s[3] = 'a'; 11242 s[4] = 'a'; 11243 s[5] = 'a'; 11244 r = strCpy(s, "lib"); 11245 ck_assert_ptr_eq(r, s); 11246 ck_assert_str_eq(s, "lib"); 11247 r = strLNCatUTF8(s, 6, "sheepy", 4); 11248 ck_assert_ptr_eq(r, s); 11249 ck_assert_str_eq(s, "libsh"); 11250 // 0 source length 11251 r = strLNCatUTF8(s, 6, "sheepy", 0); 11252 ck_assert_ptr_eq(r, s); 11253 ck_assert_str_eq(s, "libsh"); 11254 // NULL string2 11255 r = strLNCatUTF8(s, 1, NULL, 1); 11256 ck_assert_ptr_eq(r, null); 11257 ck_assert_str_eq(s, "libsh"); 11258 // NULL parameter 11259 r = strLNCatUTF8(NULL, 1, "ad", 1); 11260 ck_assert_ptr_eq(r, null); 11261 11262 11263 } 11264 11265 11266 void eqIUTF8T(CuTest *tc UNUSED) { 11267 11268 // identical strings 11269 ck_assert(eqIUTF8("Ashee|", "shee", 1)); 11270 ck_assert(eqIUTF8("Ashee", "shee", -4)); 11271 // string at index shorter than string2 11272 ck_assert(!eqIUTF8("Ashee", "shee", 2)); 11273 // empty string 11274 ck_assert(!eqIUTF8("", "shee", 0)); 11275 ck_assert(!eqIUTF8("Ashee", "", 0)); 11276 ck_assert(eqIUTF8("", "", 0)); 11277 // index mismatch 11278 ck_assert(!eqIUTF8("Ashee", "shee", 0)); 11279 // index outside 11280 ck_assert(!eqIUTF8("Ashee", "shee", 10)); 11281 ck_assert(!eqIUTF8("Ashee", "shee", -10)); 11282 // different strings 11283 ck_assert(!eqIUTF8("shee", "SH",0)); 11284 // NULL string 11285 ck_assert(!eqIUTF8(NULL,"a", 0)); 11286 ck_assert(!eqIUTF8("a", NULL, 0)); 11287 11288 11289 } 11290 11291 11292 void eqICharUTF8T(CuTest *tc UNUSED) { 11293 11294 // identical strings 11295 ck_assert(eqICharUTF8("Ashee", 's', 1)); 11296 ck_assert(eqICharUTF8("Ashee", 's', -4)); 11297 // string at index shorter than string2 11298 ck_assert(!eqICharUTF8("Ashee", 's', 2)); 11299 // empty string 11300 ck_assert(!eqICharUTF8("", 's', 0)); 11301 ck_assert(!eqICharUTF8("Ashee", 0, 0)); 11302 ck_assert(eqICharUTF8("", 0, 0)); 11303 // index mismatch 11304 ck_assert(!eqICharUTF8("Ashee", 's', 0)); 11305 // index outside 11306 ck_assert(!eqICharUTF8("Ashee", 's', 10)); 11307 ck_assert(!eqICharUTF8("Ashee", 's', -10)); 11308 // different strings 11309 ck_assert(!eqICharUTF8("shee", 'S',0)); 11310 // NULL string 11311 ck_assert(!eqICharUTF8(NULL,'a', 0)); 11312 ck_assert(!eqICharUTF8("a", 0, 0)); 11313 11314 11315 } 11316 11317 11318 void icEqUTF8T(CuTest *tc UNUSED) { 11319 11320 // identical strings 11321 ck_assert(icEqUTF8("SHEE", "shee")); 11322 // different strings 11323 ck_assert(!icEqUTF8("shee", "SH")); 11324 // empty strings 11325 ck_assert(!icEqUTF8("shee", "")); 11326 ck_assert(!icEqUTF8("", "SH")); 11327 ck_assert(icEqUTF8("", "")); 11328 // NULL string 11329 ck_assert(!icEqUTF8(NULL,"a")); 11330 ck_assert(!icEqUTF8("a", NULL)); 11331 11332 11333 } 11334 11335 11336 void icEqCharUTF8T(CuTest *tc UNUSED) { 11337 11338 // identical strings 11339 ck_assert(icEqCharUTF8('S', "s")); 11340 // different strings 11341 ck_assert(!icEqCharUTF8('s', "SH")); 11342 // empty strings 11343 ck_assert(!icEqCharUTF8('s', "")); 11344 ck_assert(!icEqCharUTF8(0, "SH")); 11345 ck_assert(icEqCharUTF8(0, "")); 11346 // NULL string 11347 ck_assert(!icEqCharUTF8(0,"a")); 11348 ck_assert(!icEqCharUTF8('a', NULL)); 11349 11350 11351 } 11352 11353 11354 void icEqUTF8CharT(CuTest *tc UNUSED) { 11355 11356 // identical strings 11357 ck_assert(icEqUTF8Char("S", 's')); 11358 // different strings 11359 ck_assert(!icEqUTF8Char("shee", 'S')); 11360 // empty strings 11361 ck_assert(!icEqUTF8Char("shee", 0)); 11362 ck_assert(!icEqUTF8Char("", 'S')); 11363 ck_assert(icEqUTF8Char("", 0)); 11364 // NULL string 11365 ck_assert(!icEqUTF8Char(NULL,'a')); 11366 ck_assert(!icEqUTF8Char("a", 0)); 11367 11368 11369 } 11370 11371 11372 void icStartsWithUTF8T(CuTest *tc UNUSED) { 11373 11374 // identical strings 11375 ck_assert(icStartsWithUTF8("SHEE", "shee")); 11376 ck_assert(icStartsWithUTF8("SHEEPY", "shee")); 11377 // different strings 11378 ck_assert(!icStartsWithUTF8("shee", "aH")); 11379 ck_assert(!icStartsWithUTF8("shee", "sheep")); 11380 ck_assert(!icStartsWithUTF8("-shee", "shee")); 11381 // NULL string 11382 ck_assert(!icStartsWithUTF8(NULL,"a")); 11383 ck_assert(!icStartsWithUTF8("a", NULL)); 11384 11385 11386 } 11387 11388 11389 void icEndsWithUTF8T(CuTest *tc UNUSED) { 11390 11391 // identical strings 11392 ck_assert(icEndsWithUTF8("SHEE", "shee")); 11393 ck_assert(icEndsWithUTF8("SHEEPY", "eepy")); 11394 // different strings 11395 ck_assert(!icEndsWithUTF8("shee", "SH")); 11396 ck_assert(!icEndsWithUTF8("shee", "sheep")); 11397 ck_assert(!icEndsWithUTF8("shee-", "shee")); 11398 // NULL string 11399 ck_assert(!icEndsWithUTF8(NULL,"a")); 11400 ck_assert(!icEndsWithUTF8("a", NULL)); 11401 11402 11403 } 11404 11405 11406 void icCountUTF8T(CuTest *tc UNUSED) { 11407 11408 // positive count 11409 ck_assert_int_eq(icCountUTF8("SHEE", "shee"), 1); 11410 ck_assert_int_eq(icCountUTF8("AAA AAA", "a"), 6); 11411 ck_assert_int_eq(icCountUTF8("AAA AAA", "aa"), 2); 11412 // 0 count 11413 ck_assert_int_eq(icCountUTF8("shee", "eSH"), 0); 11414 ck_assert_int_eq(icCountUTF8("shee", "sheepy"), 0); 11415 ck_assert_int_eq(icCountUTF8("aaa aaa", "ab"), 0); 11416 // NULL string 11417 ck_assert_int_eq(icCountUTF8(NULL,"a"), -1); 11418 ck_assert_int_eq(icCountUTF8("a", NULL), -1); 11419 11420 11421 } 11422 11423 11424 void code2RuneUTF8T(CuTest *tc UNUSED) { 11425 11426 u32 r; 11427 11428 r = code2RuneUTF8("£"); 11429 ck_assert_int_eq(r, 163); 11430 11431 } 11432 11433 11434 void code2RuneLUTF8T(CuTest *tc UNUSED) { 11435 11436 u8 n; 11437 u32 r; 11438 11439 r = code2RuneLUTF8("£", &n); 11440 ck_assert_int_eq(r, 163); 11441 ck_assert_int_eq(n, 2); 11442 // empty string 11443 r = code2RuneLUTF8("", &n); 11444 ck_assert_int_eq(r, 0); 11445 // null length 11446 r = code2RuneLUTF8("£", null); 11447 ck_assert_int_eq(r, 0); 11448 // null string 11449 r = code2RuneLUTF8(null, &n); 11450 ck_assert_int_eq(r, 0); 11451 11452 11453 } 11454 11455 11456 void bRune2CodeUTF8T(CuTest *tc UNUSED) { 11457 11458 u8 n; 11459 char r[20] = init0Var; 11460 11461 // pound 11462 n = bRune2CodeUTF8(r, 163); 11463 ck_assert_str_eq(r, "£"); 11464 ck_assert_int_eq(n, 2); 11465 11466 // null dst 11467 n = 0; 11468 n = bRune2CodeUTF8(null, 163); 11469 ck_assert_int_eq(n, 2); 11470 11471 } 11472 11473 11474 void runeLenUTF8T(CuTest *tc UNUSED) { 11475 11476 u8 r; 11477 11478 r = runeLenUTF8(163); 11479 ck_assert_int_eq(r, 2); 11480 11481 11482 } 11483 11484 11485 void toupperUTF8T(CuTest *tc UNUSED) { 11486 11487 rune r; 11488 char dst[20] = init0Var; 11489 11490 r = toupperUTF8(163); 11491 ck_assert_int_eq(r, 163); 11492 11493 r = code2RuneUTF8("å"); 11494 r = toupperUTF8(r); 11495 u8 r2 = bRune2CodeUTF8(dst,r); 11496 ck_assert_str_eq(dst, "Å"); 11497 ck_assert_int_eq(r2, 2); 11498 11499 } 11500 11501 11502 void upperUTF8T(CuTest *tc UNUSED) { 11503 11504 // string 11505 char *s = upperUTF8("sheepyå"); 11506 ck_assert_str_eq(s, "SHEEPYÅ"); 11507 free(s); 11508 // NULL string 11509 ck_assert_ptr_eq(upperUTF8(NULL), NULL); 11510 11511 11512 } 11513 11514 11515 void iUpperUTF8T(CuTest *tc UNUSED) { 11516 11517 char *s; 11518 char *r = null; 11519 11520 // string 11521 s = strdup("sheepy"); 11522 r = iUpperUTF8(&s); 11523 ck_assert_ptr_eq(r, s); 11524 ck_assert_str_eq(s, "SHEEPY"); 11525 free(s); 11526 // NULL string 11527 s = NULL; 11528 r = iUpperUTF8(&s); 11529 ck_assert_ptr_eq(r, s); 11530 ck_assert_ptr_eq(s, NULL); 11531 // NULL var 11532 r = iUpperUTF8(NULL); 11533 ck_assert_ptr_eq(r, null); 11534 11535 11536 } 11537 11538 11539 void tolowerUTF8T(CuTest *tc UNUSED) { 11540 11541 rune r; 11542 char dst[20] = init0Var; 11543 11544 r = tolowerUTF8(163); 11545 ck_assert_int_eq(r, 163); 11546 11547 r = code2RuneUTF8("Å"); 11548 r = tolowerUTF8(r); 11549 u8 r2 = bRune2CodeUTF8(dst,r); 11550 ck_assert_str_eq(dst, "å"); 11551 ck_assert_int_eq(r2, 2); 11552 11553 11554 } 11555 11556 11557 void lowerUTF8T(CuTest *tc UNUSED) { 11558 11559 // string 11560 char *s = lowerUTF8("SHeePY"); 11561 ck_assert_str_eq(s, "sheepy"); 11562 free(s); 11563 // NULL string 11564 ck_assert_ptr_eq(lowerUTF8(NULL), NULL); 11565 11566 11567 } 11568 11569 11570 void iLowerUTF8T(CuTest *tc UNUSED) { 11571 11572 char *s; 11573 char *r = null; 11574 11575 // string 11576 s = strdup("SHEEPY"); 11577 r = iLowerUTF8(&s); 11578 ck_assert_ptr_eq(r, s); 11579 ck_assert_str_eq(s, "sheepy"); 11580 free(s); 11581 // NULL string 11582 s = NULL; 11583 r = iLowerUTF8(&s); 11584 ck_assert_ptr_eq(r, s); 11585 ck_assert_ptr_eq(s, NULL); 11586 // NULL var 11587 r = iLowerUTF8(NULL); 11588 ck_assert_ptr_eq(r, null); 11589 11590 11591 } 11592 11593 11594 void uniqUTF8T(CuTest *tc UNUSED) { 11595 11596 char *s; 11597 11598 // uniquify 11599 s = uniqUTF8("∑qwd∑∑∑", "∑"); 11600 ck_assert_str_eq(s, "∑qwd∑"); 11601 free(s); 11602 // short string 11603 s = uniqUTF8("?", "/"); 11604 ck_assert_str_eq(s, "?"); 11605 free(s); 11606 // NULL 11607 ck_assert_ptr_eq(uniqUTF8(NULL, "/"), NULL); 11608 ck_assert_ptr_eq(uniqUTF8("sd", null), NULL); 11609 11610 11611 } 11612 11613 11614 void iUniqUTF8T(CuTest *tc UNUSED) { 11615 11616 char *s; 11617 11618 // uniquify 11619 s = strdup("/qwd///"); 11620 ck_assert_str_eq(iUniqUTF8(&s, "/"), "/qwd/"); 11621 free(s); 11622 // short string 11623 s = strdup("?"); 11624 ck_assert_str_eq(iUniqUTF8(&s, "/"), "?"); 11625 free(s); 11626 // NULL string 11627 ck_assert_ptr_eq(iUniqUTF8(&s, null), NULL); 11628 s = NULL; 11629 ck_assert_ptr_eq(iUniqUTF8(&s, "/"), NULL); 11630 // NULL 11631 ck_assert_ptr_eq(iUniqUTF8(NULL, "/"), NULL); 11632 11633 11634 } 11635 11636 11637 void bUniqUTF8T(CuTest *tc UNUSED) { 11638 11639 char s[100]; 11640 11641 // uniquify 11642 strcpy(s, "/qwd///"); 11643 ck_assert_str_eq(bUniqUTF8(s, "/"), "/qwd/"); 11644 // short string 11645 strcpy(s, "?"); 11646 ck_assert_str_eq(bUniqUTF8(s, "/"), "?"); 11647 // NULL 11648 ck_assert_ptr_eq(bUniqUTF8(s, null), NULL); 11649 ck_assert_ptr_eq(bUniqUTF8(NULL, "/"), NULL); 11650 11651 11652 } 11653 11654 11655 void getUTF8T(CuTest *tc UNUSED) { 11656 11657 // get char 11658 ck_assert_uint_eq(getUTF8("sheepy", 0), 's'); 11659 // negative index 11660 ck_assert_uint_eq(getUTF8("sheepy", -1), 'y'); 11661 // outside string 11662 ck_assert_uint_eq(getUTF8("sheepy", 10), 0); 11663 ck_assert_uint_eq(getUTF8("sheepy", -10), 0); 11664 // negative index in a one char string 11665 ck_assert_uint_eq(getUTF8("z", -1), 'z'); 11666 // empty string 11667 ck_assert_uint_eq(getUTF8("", 0), 0); 11668 // NULL string 11669 ck_assert_uint_eq(getUTF8(NULL, 0), 0); 11670 11671 11672 } 11673 11674 11675 void setUTF8T(CuTest *tc UNUSED) { 11676 11677 char *s; 11678 s = strdup("sheepy"); 11679 char *r = null; 11680 11681 // set char 11682 r = setUTF8(s, 0, 'S'); 11683 ck_assert_ptr_eq(r, s); 11684 ck_assert_uint_eq(s[0], 'S'); 11685 // negative index 11686 r = setUTF8(s, -2, 'P'); 11687 ck_assert_ptr_eq(r, s); 11688 ck_assert_uint_eq(s[4], 'P'); 11689 // outside string 11690 r = setUTF8(s, 20, 'Y'); 11691 ck_assert_ptr_eq(r, null); 11692 r = setUTF8(s, -20, 'Y'); 11693 ck_assert_ptr_eq(r, null); 11694 ck_assert_str_eq(s, "SheePy"); 11695 free(s); 11696 // negative index in a one char string 11697 s = strdup("s"); 11698 r = setUTF8(s, -1, 'S'); 11699 ck_assert_ptr_eq(r, s); 11700 ck_assert_uint_eq(s[0], 'S'); 11701 free(s); 11702 // empty string 11703 emptyS(s); 11704 r = setUTF8(s, -1, 'S'); 11705 ck_assert_ptr_eq(r, null); 11706 ck_assert_str_eq(s, ""); 11707 free(s); 11708 // NULL string 11709 r = setUTF8(NULL, 0, 's'); 11710 ck_assert_ptr_eq(r, null); 11711 11712 11713 } 11714 11715 11716 void sliceUTF8T(CuTest *tc UNUSED) { 11717 11718 // slice 11719 char *s = sliceUTF8("sheepy", 0,2); 11720 ck_assert_str_eq(s, "sh"); 11721 free(s); 11722 // negative index 11723 s = sliceUTF8("sheepy", -2,0); 11724 ck_assert_str_eq(s, "py"); 11725 free(s); 11726 // positive and negative indexes 11727 s = sliceUTF8("sheepy", 2,-2); 11728 ck_assert_str_eq(s, "ee"); 11729 free(s); 11730 // start = end 11731 s = sliceUTF8("sheepy", 2,-4); 11732 ck_assert_str_eq(s, ""); 11733 free(s); 11734 // end of string 11735 s = sliceUTF8("sheepy", 2,6); 11736 ck_assert_str_eq(s, "eepy"); 11737 free(s); 11738 // NULL string 11739 ck_assert_ptr_eq(sliceUTF8(NULL, 2,-4), NULL); 11740 // start outside string 11741 ck_assert_ptr_eq(sliceUTF8("sheepy", 20,-4), NULL); 11742 // end outside string 11743 s = sliceUTF8("sheepy", 2,40); 11744 ck_assert_str_eq(s, "eepy"); 11745 free(s); 11746 s = sliceUTF8("sheepy", -22,3); 11747 ck_assert_str_eq(s, "she"); 11748 free(s); 11749 ck_assert_ptr_eq(sliceUTF8("sheepy", 2,-40), NULL); 11750 // end before start 11751 ck_assert_ptr_eq(sliceUTF8("sheepy", 4,2), NULL); 11752 11753 11754 } 11755 11756 11757 void iSliceUTF8T(CuTest *tc UNUSED) { 11758 11759 char *s; 11760 char *r = null; 11761 11762 // slice 11763 s = strdup("sheepy"); 11764 r = iSliceUTF8(&s, 0,2); 11765 ck_assert_ptr_eq(r, s); 11766 ck_assert_str_eq(s, "sh"); 11767 free(s); 11768 // negative index 11769 s = strdup("sheepy"); 11770 r = iSliceUTF8(&s, -2,0); 11771 ck_assert_ptr_eq(r, s); 11772 ck_assert_str_eq(s, "py"); 11773 free(s); 11774 // positive and negative indexes 11775 s = strdup("sheepy"); 11776 r = iSliceUTF8(&s, 2,-2); 11777 ck_assert_ptr_eq(r, s); 11778 ck_assert_str_eq(s, "ee"); 11779 free(s); 11780 // start = end 11781 s = strdup("sheepy"); 11782 r = iSliceUTF8(&s, 2,-4); 11783 ck_assert_ptr_eq(r, s); 11784 ck_assert_str_eq(s, ""); 11785 free(s); 11786 // end of string 11787 s = strdup("sheepy"); 11788 r = iSliceUTF8(&s, 2,6); 11789 ck_assert_ptr_eq(r, s); 11790 ck_assert_str_eq(s, "eepy"); 11791 free(s); 11792 // NULL string 11793 s = NULL; 11794 r = iSliceUTF8(&s, 2,-4); 11795 ck_assert_ptr_eq(r, s); 11796 ck_assert_ptr_eq(s, NULL); 11797 // start outside string 11798 s = strdup("sheepy"); 11799 r = iSliceUTF8(&s, 20,-4); 11800 ck_assert_ptr_eq(r, null); 11801 ck_assert_str_eq(s, ""); 11802 free(s); 11803 // end outside string 11804 s = strdup("sheepy"); 11805 r = iSliceUTF8(&s, 2,40); 11806 ck_assert_ptr_eq(r, s); 11807 ck_assert_str_eq(s, "eepy"); 11808 free(s); 11809 s = strdup("sheepy"); 11810 r = iSliceUTF8(&s, -22,3); 11811 ck_assert_ptr_eq(r, s); 11812 ck_assert_str_eq(s, "she"); 11813 free(s); 11814 s = strdup("sheepy"); 11815 r = iSliceUTF8(&s, 2,-40); 11816 ck_assert_ptr_eq(r, null); 11817 ck_assert_str_eq(s, ""); 11818 free(s); 11819 // end before start 11820 s = strdup("sheepy"); 11821 r = iSliceUTF8(&s, 4,2); 11822 ck_assert_ptr_eq(r, null); 11823 ck_assert_str_eq(s, ""); 11824 free(s); 11825 // NULL var 11826 r = iSliceUTF8(NULL, 0, 0); 11827 ck_assert_ptr_eq(r, null); 11828 11829 11830 } 11831 11832 11833 void bSliceUTF8T(CuTest *tc UNUSED) { 11834 11835 char s[100]; 11836 char *r = null; 11837 11838 // slice 11839 strcpy(s, "sheepy"); 11840 r = bSliceUTF8(s, 0,2); 11841 ck_assert_ptr_eq(r, s); 11842 ck_assert_str_eq(s, "sh"); 11843 // negative index 11844 strcpy(s, "sheepy"); 11845 r = bSliceUTF8(s, -2,0); 11846 ck_assert_ptr_eq(r, s); 11847 ck_assert_str_eq(s, "py"); 11848 // positive and negative indexes 11849 strcpy(s, "sheepy"); 11850 r = bSliceUTF8(s, 2,-2); 11851 ck_assert_ptr_eq(r, s); 11852 ck_assert_str_eq(s, "ee"); 11853 // start = end 11854 strcpy(s, "sheepy"); 11855 r = bSliceUTF8(s, 2,-4); 11856 ck_assert_ptr_eq(r, s); 11857 ck_assert_str_eq(s, ""); 11858 // end of string 11859 strcpy(s, "sheepy"); 11860 r = bSliceUTF8(s, 2,6); 11861 ck_assert_ptr_eq(r, s); 11862 ck_assert_str_eq(s, "eepy"); 11863 // start outside string 11864 strcpy(s, "sheepy"); 11865 r = bSliceUTF8(s, 20,-4); 11866 ck_assert_ptr_eq(r, null); 11867 ck_assert_str_eq(s, ""); 11868 // end outside string 11869 strcpy(s, "sheepy"); 11870 r = bSliceUTF8(s, 2,40); 11871 ck_assert_ptr_eq(r, s); 11872 ck_assert_str_eq(s, "eepy"); 11873 strcpy(s, "sheepy"); 11874 r = bSliceUTF8(s, -22,3); 11875 ck_assert_ptr_eq(r, s); 11876 ck_assert_str_eq(s, "she"); 11877 strcpy(s, "sheepy"); 11878 r = bSliceUTF8(s, 2,-40); 11879 ck_assert_ptr_eq(r, null); 11880 ck_assert_str_eq(s, ""); 11881 // end before start 11882 strcpy(s, "sheepy"); 11883 r = bSliceUTF8(s, 4,2); 11884 ck_assert_ptr_eq(r, null); 11885 ck_assert_str_eq(s, ""); 11886 // NULL var 11887 r = bSliceUTF8(NULL, 0, 0); 11888 ck_assert_ptr_eq(r, null); 11889 11890 11891 } 11892 11893 11894 void bLSliceUTF8T(CuTest *tc UNUSED) { 11895 11896 char s[100]; 11897 char *r = null; 11898 11899 // slice 11900 strcpy(s, "sheepy"); 11901 r = bLSliceUTF8(s, sizeof(s), 0,2); 11902 ck_assert_ptr_eq(r, s); 11903 ck_assert_str_eq(s, "sh"); 11904 // buffer shorter than string 11905 strcpy(s, "sheepy"); 11906 r = bLSliceUTF8(s, 5, 0,2); 11907 ck_assert_ptr_eq(r, s); 11908 ck_assert_str_eq(s, "sh"); 11909 // negative index 11910 strcpy(s, "sheepy"); 11911 r = bLSliceUTF8(s, sizeof(s), -2,0); 11912 ck_assert_ptr_eq(r, s); 11913 ck_assert_str_eq(s, "py"); 11914 // positive and negative indexes 11915 strcpy(s, "sheepy"); 11916 r = bLSliceUTF8(s, sizeof(s), 2,-2); 11917 ck_assert_ptr_eq(r, s); 11918 ck_assert_str_eq(s, "ee"); 11919 // start = end 11920 strcpy(s, "sheepy"); 11921 r = bLSliceUTF8(s, sizeof(s), 2,-4); 11922 ck_assert_ptr_eq(r, s); 11923 ck_assert_str_eq(s, ""); 11924 // end of string 11925 strcpy(s, "sheepy"); 11926 r = bLSliceUTF8(s, sizeof(s), 2,6); 11927 ck_assert_ptr_eq(r, s); 11928 ck_assert_str_eq(s, "eepy"); 11929 // start outside string 11930 strcpy(s, "sheepy"); 11931 r = bLSliceUTF8(s, sizeof(s), 20,-4); 11932 ck_assert_ptr_eq(r, null); 11933 ck_assert_str_eq(s, ""); 11934 // end outside string 11935 strcpy(s, "sheepy"); 11936 r = bLSliceUTF8(s, sizeof(s), 2,40); 11937 ck_assert_ptr_eq(r, s); 11938 ck_assert_str_eq(s, "eepy"); 11939 strcpy(s, "sheepy"); 11940 r = bLSliceUTF8(s, sizeof(s), -22,3); 11941 ck_assert_ptr_eq(r, s); 11942 ck_assert_str_eq(s, "she"); 11943 strcpy(s, "sheepy"); 11944 r = bLSliceUTF8(s, sizeof(s), 2,-40); 11945 ck_assert_ptr_eq(r, null); 11946 ck_assert_str_eq(s, ""); 11947 // end before start 11948 strcpy(s, "sheepy"); 11949 r = bLSliceUTF8(s, sizeof(s), 4,2); 11950 ck_assert_ptr_eq(r, null); 11951 ck_assert_str_eq(s, ""); 11952 // size 0 11953 r = bLSliceUTF8(s, 0, 0, 0); 11954 ck_assert_ptr_eq(r, null); 11955 // NULL var 11956 r = bLSliceUTF8(NULL, sizeof(s), 0, 0); 11957 ck_assert_ptr_eq(r, null); 11958 11959 11960 } 11961 11962 11963 void insertUTF8T(CuTest *tc UNUSED) { 11964 11965 char *s; 11966 11967 // insert 11968 s = insertUTF8("sheepy", 0, "lib"); 11969 ck_assert_str_eq(s, "libsheepy"); 11970 free(s); 11971 // negative index 11972 s = insertUTF8("libsheepy", -2, "P"); 11973 ck_assert_str_eq(s, "libsheepPy"); 11974 free(s); 11975 // edge 11976 s = insertUTF8("qwe", 3, "C"); 11977 ck_assert_str_eq(s, "qweC"); 11978 free(s); 11979 // outside string 11980 s = insertUTF8("qwe", 4, "C"); 11981 ck_assert_ptr_eq(s, NULL); 11982 s = insertUTF8("qwe", -5, "C"); 11983 ck_assert_ptr_eq(s, NULL); 11984 // negative index in a one char string 11985 s = insertUTF8("s", -1, "S"); 11986 ck_assert_str_eq(s, "sS"); 11987 free(s); 11988 // empty string 11989 s = insertUTF8("", 0, "s"); 11990 ck_assert_str_eq(s, "s"); 11991 free(s); 11992 s = insertUTF8("", -1, "s"); 11993 ck_assert_str_eq(s, "s"); 11994 free(s); 11995 // empty insert string 11996 s = insertUTF8("a", 0, ""); 11997 ck_assert_str_eq(s, "a"); 11998 free(s); 11999 // NULL insert string 12000 s = insertUTF8("a", 0, NULL); 12001 ck_assert_str_eq(s, "a"); 12002 free(s); 12003 // NULL string 12004 s = insertUTF8(NULL, 0, "s"); 12005 ck_assert_str_eq(s, "s"); 12006 free(s); 12007 12008 12009 } 12010 12011 12012 void insertNFreeUTF8T(CuTest *tc UNUSED) { 12013 12014 char *s, *a; 12015 12016 // insert 12017 s = insertNFreeUTF8("sheepy", 0, strdup("lib")); 12018 ck_assert_str_eq(s, "libsheepy"); 12019 free(s); 12020 // negative index 12021 s = insertNFreeUTF8("libsheepy", -2, strdup("P")); 12022 ck_assert_str_eq(s, "libsheepPy"); 12023 free(s); 12024 // edge 12025 s = insertNFreeUTF8("qwe", 3, strdup("C")); 12026 ck_assert_str_eq(s, "qweC"); 12027 free(s); 12028 // outside string 12029 a = strdup("C"); 12030 s = insertNFreeUTF8("qwe", 4, a); 12031 ck_assert_ptr_eq(s, NULL); 12032 s = insertNFreeUTF8("qwe", -5, a); 12033 ck_assert_ptr_eq(s, NULL); 12034 free(a); 12035 // negative index in a one char string 12036 s = insertNFreeUTF8("s", -1, strdup("S")); 12037 ck_assert_str_eq(s, "sS"); 12038 free(s); 12039 // empty string 12040 s = insertNFreeUTF8("", 0, strdup("s")); 12041 ck_assert_str_eq(s, "s"); 12042 free(s); 12043 s = insertNFreeUTF8("", -1, strdup("s")); 12044 ck_assert_str_eq(s, "s"); 12045 free(s); 12046 // empty insert string 12047 s = insertNFreeUTF8("a", 0, strdup("")); 12048 ck_assert_str_eq(s, "a"); 12049 free(s); 12050 // NULL insert string 12051 s = insertNFreeUTF8("a", 0, NULL); 12052 ck_assert_str_eq(s, "a"); 12053 free(s); 12054 // NULL string 12055 s = insertNFreeUTF8(NULL, 0, strdup("s")); 12056 ck_assert_str_eq(s, "s"); 12057 free(s); 12058 12059 12060 } 12061 12062 12063 void iInsertUTF8T(CuTest *tc UNUSED) { 12064 12065 char *s; 12066 char *r = null; 12067 12068 // insert 12069 s = strdup("sheepy"); 12070 r = iInsertUTF8(&s, 0, "lib"); 12071 ck_assert_ptr_eq(r, s); 12072 ck_assert_str_eq(s, "libsheepy"); 12073 free(s); 12074 // negative index 12075 s = strdup("libsheepy"); 12076 r = iInsertUTF8(&s, -2, "P"); 12077 ck_assert_ptr_eq(r, s); 12078 ck_assert_str_eq(s, "libsheepPy"); 12079 free(s); 12080 // edge 12081 s = strdup("qwe"); 12082 r = iInsertUTF8(&s, 3, "C"); 12083 ck_assert_ptr_eq(r, s); 12084 ck_assert_str_eq(s, "qweC"); 12085 free(s); 12086 // outside string 12087 s = strdup("qwe"); 12088 r = iInsertUTF8(&s, 4, "C"); 12089 ck_assert_ptr_eq(r, null); 12090 ck_assert_str_eq(s, "qwe"); 12091 r = iInsertUTF8(&s, -5, "C"); 12092 ck_assert_ptr_eq(r, null); 12093 ck_assert_str_eq(s, "qwe"); 12094 free(s); 12095 // negative index in a one char string 12096 s = strdup("s"); 12097 r = iInsertUTF8(&s, -1, "S"); 12098 ck_assert_ptr_eq(r, s); 12099 ck_assert_str_eq(s, "sS"); 12100 free(s); 12101 // empty string 12102 emptyS(s); 12103 r = iInsertUTF8(&s, 0, "s"); 12104 ck_assert_ptr_eq(r, s); 12105 ck_assert_str_eq(s, "s"); 12106 free(s); 12107 emptyS(s); 12108 r = iInsertUTF8(&s, -1, "s"); 12109 ck_assert_ptr_eq(r, s); 12110 ck_assert_str_eq(s, "s"); 12111 free(s); 12112 // empty insert string 12113 s = strdup("a"); 12114 r = iInsertUTF8(&s, 0, ""); 12115 ck_assert_ptr_eq(r, s); 12116 ck_assert_str_eq(s, "a"); 12117 free(s); 12118 // NULL insert string 12119 s = strdup("a"); 12120 r = iInsertUTF8(&s, 0, NULL); 12121 ck_assert_ptr_eq(r, s); 12122 ck_assert_str_eq(s, "a"); 12123 free(s); 12124 // NULL string 12125 s = NULL; 12126 r = iInsertUTF8(&s, 0, "s"); 12127 ck_assert_ptr_eq(r, s); 12128 ck_assert_str_eq(s, "s"); 12129 free(s); 12130 // NULL var 12131 r = iInsertUTF8(NULL, 0, "s"); 12132 ck_assert_ptr_eq(r, null); 12133 12134 12135 } 12136 12137 12138 void iInsertNFreeUTF8T(CuTest *tc UNUSED) { 12139 12140 char *s, *a, *r; 12141 12142 // insert 12143 s = strdup("sheepy"); 12144 r = iInsertNFreeUTF8(&s, 0, strdup("lib")); 12145 ck_assert_ptr_eq(r, s); 12146 ck_assert_str_eq(s, "libsheepy"); 12147 free(s); 12148 // negative index 12149 s = strdup("libsheepy"); 12150 r = iInsertNFreeUTF8(&s, -2, strdup("P")); 12151 ck_assert_ptr_eq(r, s); 12152 ck_assert_str_eq(s, "libsheepPy"); 12153 free(s); 12154 // edge 12155 s = strdup("qwe"); 12156 r = iInsertNFreeUTF8(&s, 3, strdup("C")); 12157 ck_assert_ptr_eq(r, s); 12158 ck_assert_str_eq(s, "qweC"); 12159 free(s); 12160 // outside string 12161 s = strdup("qwe"); 12162 a = strdup("C"); 12163 r = iInsertNFreeUTF8(&s, 4, a); 12164 ck_assert_ptr_eq(r, NULL); 12165 ck_assert_str_eq(s, "qwe"); 12166 r = iInsertNFreeUTF8(&s, -5, a); 12167 ck_assert_ptr_eq(r, NULL); 12168 free(a); 12169 ck_assert_str_eq(s, "qwe"); 12170 free(s); 12171 // negative index in a one char string 12172 s = strdup("s"); 12173 r = iInsertNFreeUTF8(&s, -1, strdup("S")); 12174 ck_assert_ptr_eq(r, s); 12175 ck_assert_str_eq(s, "sS"); 12176 free(s); 12177 // empty string 12178 emptyS(s); 12179 r = iInsertNFreeUTF8(&s, 0, strdup("s")); 12180 ck_assert_ptr_eq(r, s); 12181 ck_assert_str_eq(s, "s"); 12182 free(s); 12183 emptyS(s); 12184 r = iInsertNFreeUTF8(&s, -1, strdup("s")); 12185 ck_assert_ptr_eq(r, s); 12186 ck_assert_str_eq(s, "s"); 12187 free(s); 12188 // empty insert string 12189 s = strdup("a"); 12190 r = iInsertNFreeUTF8(&s, 0, strdup("")); 12191 ck_assert_ptr_eq(r, s); 12192 ck_assert_str_eq(s, "a"); 12193 free(s); 12194 // NULL insert string 12195 s = strdup("a"); 12196 r = iInsertNFreeUTF8(&s, 0, NULL); 12197 ck_assert_ptr_eq(r, s); 12198 ck_assert_str_eq(s, "a"); 12199 free(s); 12200 // NULL string 12201 s = NULL; 12202 r = iInsertNFreeUTF8(&s, 0, strdup("s")); 12203 ck_assert_ptr_eq(r, s); 12204 ck_assert_str_eq(s, "s"); 12205 free(s); 12206 // NULL var 12207 s = strdup("s"); 12208 r = iInsertNFreeUTF8(NULL, 0, s); 12209 ck_assert_ptr_eq(r, NULL); 12210 free(s); 12211 12212 12213 } 12214 12215 12216 void bInsertUTF8T(CuTest *tc UNUSED) { 12217 12218 char s[100]; 12219 char *r = null; 12220 12221 // insert 12222 strcpy(s, "sheepy"); 12223 r = bInsertUTF8(s, 0, "lib"); 12224 ck_assert_ptr_eq(r, s); 12225 ck_assert_str_eq(s, "libsheepy"); 12226 // negative index 12227 strcpy(s, "libsheepy"); 12228 r = bInsertUTF8(s, -2, "P"); 12229 ck_assert_ptr_eq(r, s); 12230 ck_assert_str_eq(s, "libsheepPy"); 12231 // edge 12232 strcpy(s, "qwe"); 12233 r = bInsertUTF8(s, 3, "C"); 12234 ck_assert_ptr_eq(r, s); 12235 ck_assert_str_eq(s, "qweC"); 12236 // outside string 12237 strcpy(s, "qwe"); 12238 r = bInsertUTF8(s, 4, "C"); 12239 ck_assert_ptr_eq(r, null); 12240 ck_assert_str_eq(s, "qwe"); 12241 r = bInsertUTF8(s, -5, "C"); 12242 ck_assert_ptr_eq(r, null); 12243 ck_assert_str_eq(s, "qwe"); 12244 // negative index in a one char string 12245 strcpy(s, "s"); 12246 r = bInsertUTF8(s, -1, "S"); 12247 ck_assert_ptr_eq(r, s); 12248 ck_assert_str_eq(s, "sS"); 12249 // empty string 12250 bEmptyS(s); 12251 r = bInsertUTF8(s, 0, "s"); 12252 ck_assert_ptr_eq(r, s); 12253 ck_assert_str_eq(s, "s"); 12254 bEmptyS(s); 12255 r = bInsertUTF8(s, -1, "s"); 12256 ck_assert_ptr_eq(r, s); 12257 ck_assert_str_eq(s, "s"); 12258 // empty insert string 12259 strcpy(s, "a"); 12260 r = bInsertUTF8(s, 0, ""); 12261 ck_assert_ptr_eq(r, s); 12262 ck_assert_str_eq(s, "a"); 12263 // NULL insert string 12264 strcpy(s, "a"); 12265 r = bInsertUTF8(s, 0, NULL); 12266 ck_assert_ptr_eq(r, s); 12267 ck_assert_str_eq(s, "a"); 12268 // NULL var 12269 r = bInsertUTF8(NULL, 0, "s"); 12270 ck_assert_ptr_eq(r, null); 12271 12272 12273 } 12274 12275 12276 void bLInsertUTF8T(CuTest *tc UNUSED) { 12277 12278 char s[100]; 12279 char *r = null; 12280 12281 // insert 12282 strcpy(s, "sheepy"); 12283 r = bLInsertUTF8(s, sizeof s, 0, "lib"); 12284 ck_assert_ptr_eq(r, s); 12285 ck_assert_str_eq(s, "libsheepy"); 12286 // shorter buffer 12287 strcpy(s, "sheepy"); 12288 r = bLInsertUTF8(s, 5, 0, "lib"); 12289 ck_assert_ptr_eq(r, s); 12290 ck_assert_str_eq(s, "libs"); 12291 // negative index 12292 strcpy(s, "libsheepy"); 12293 r = bLInsertUTF8(s, sizeof s, -2, "P"); 12294 ck_assert_ptr_eq(r, s); 12295 ck_assert_str_eq(s, "libsheepPy"); 12296 // edge 12297 strcpy(s, "qwe"); 12298 r = bLInsertUTF8(s, sizeof s, 3, "C"); 12299 ck_assert_ptr_eq(r, s); 12300 ck_assert_str_eq(s, "qweC"); 12301 // outside string 12302 strcpy(s, "qwe"); 12303 r = bLInsertUTF8(s, sizeof s, 4, "C"); 12304 ck_assert_ptr_eq(r, null); 12305 ck_assert_str_eq(s, "qwe"); 12306 r = bLInsertUTF8(s, sizeof s, -5, "C"); 12307 ck_assert_ptr_eq(r, null); 12308 ck_assert_str_eq(s, "qwe"); 12309 // negative index in a one char string 12310 strcpy(s, "s"); 12311 r = bLInsertUTF8(s, sizeof s, -1, "S"); 12312 ck_assert_ptr_eq(r, s); 12313 ck_assert_str_eq(s, "sS"); 12314 // empty string 12315 bEmptyS(s); 12316 r = bLInsertUTF8(s, sizeof s, 0, "s"); 12317 ck_assert_ptr_eq(r, s); 12318 ck_assert_str_eq(s, "s"); 12319 bEmptyS(s); 12320 r = bLInsertUTF8(s, sizeof s, -1, "s"); 12321 ck_assert_ptr_eq(r, s); 12322 ck_assert_str_eq(s, "s"); 12323 // empty insert string 12324 strcpy(s, "a"); 12325 r = bLInsertUTF8(s, sizeof s, 0, ""); 12326 ck_assert_ptr_eq(r, s); 12327 ck_assert_str_eq(s, "a"); 12328 // size 0 - no change 12329 r = bLInsertUTF8(s, 0, 0, "qwe"); 12330 ck_assert_ptr_eq(r, s); 12331 ck_assert_str_eq(s, "a"); 12332 // NULL insert string 12333 strcpy(s, "a"); 12334 r = bLInsertUTF8(s, sizeof s, 0, NULL); 12335 ck_assert_ptr_eq(r, s); 12336 ck_assert_str_eq(s, "a"); 12337 // NULL var 12338 r = bLInsertUTF8(NULL, sizeof s, 0, "s"); 12339 ck_assert_ptr_eq(r, null); 12340 12341 12342 } 12343 12344 12345 void delUTF8T(CuTest *tc UNUSED) { 12346 12347 // del 12348 char *s = delUTF8("sheepy", 0,2); 12349 ck_assert_str_eq(s, "eepy"); 12350 free(s); 12351 // negative index 12352 s = delUTF8("sheepy", -2,0); 12353 ck_assert_str_eq(s, "shee"); 12354 free(s); 12355 // positive and negative indexes 12356 s = delUTF8("sheepy", 2,-2); 12357 ck_assert_str_eq(s, "shpy"); 12358 free(s); 12359 // start = end 12360 s = delUTF8("sheepy", 2,-4); 12361 ck_assert_str_eq(s, "sheepy"); 12362 free(s); 12363 // delete entire string 12364 s = delUTF8("sheepy", 0,0); 12365 ck_assert_str_eq(s, ""); 12366 free(s); 12367 // end of string 12368 s = delUTF8("sheepy", 2,6); 12369 ck_assert_str_eq(s, "sh"); 12370 free(s); 12371 // NULL string 12372 ck_assert_ptr_eq(delUTF8(NULL, 2,-4), NULL); 12373 // start outside string 12374 ck_assert_ptr_eq(delUTF8("sheepy", 20,-4), NULL); 12375 s = delUTF8("sheepy", -20,-4); 12376 ck_assert_str_eq(s, "eepy"); 12377 free(s); 12378 // end outside string 12379 s = delUTF8("sheepy", 2,40); 12380 ck_assert_str_eq(s, "sh"); 12381 free(s); 12382 ck_assert_ptr_eq(delUTF8("sheepy", 2,-40), NULL); 12383 // end before start 12384 ck_assert_ptr_eq(delUTF8("sheepy", 4,2), NULL); 12385 12386 12387 } 12388 12389 12390 void iDelUTF8T(CuTest *tc UNUSED) { 12391 12392 char *s; 12393 char *r = null; 12394 12395 // del 12396 s = strdup("sheepy"); 12397 r = iDelUTF8(&s, 0,2); 12398 ck_assert_ptr_eq(r, s); 12399 ck_assert_str_eq(s, "eepy"); 12400 free(s); 12401 // negative index 12402 s = strdup("sheepy"); 12403 r = iDelUTF8(&s, -2,0); 12404 ck_assert_ptr_eq(r, s); 12405 ck_assert_str_eq(s, "shee"); 12406 free(s); 12407 // positive and negative indexes 12408 s = strdup("sheepy"); 12409 r = iDelUTF8(&s, 2,-2); 12410 ck_assert_ptr_eq(r, s); 12411 ck_assert_str_eq(s, "shpy"); 12412 free(s); 12413 // start = end 12414 s = strdup("sheepy"); 12415 r = iDelUTF8(&s, 2,-4); 12416 ck_assert_ptr_eq(r, s); 12417 ck_assert_str_eq(s, "sheepy"); 12418 free(s); 12419 // delete entire string 12420 s = strdup("sheepy"); 12421 r = iDelUTF8(&s, 0,0); 12422 ck_assert_ptr_eq(r, s); 12423 ck_assert_str_eq(s, ""); 12424 free(s); 12425 // end of string 12426 s = strdup("sheepy"); 12427 r = iDelUTF8(&s, 2,6); 12428 ck_assert_ptr_eq(r, s); 12429 ck_assert_str_eq(s, "sh"); 12430 free(s); 12431 // NULL string 12432 s = NULL; 12433 r = iDelUTF8(&s, 2,-4); 12434 ck_assert_ptr_eq(r, s); 12435 ck_assert_ptr_eq(s, NULL); 12436 // start outside string 12437 s = strdup("sheepy"); 12438 r = iDelUTF8(&s, 20,-4); 12439 ck_assert_ptr_eq(r, null); 12440 ck_assert_str_eq(s, "sheepy"); 12441 r = iDelUTF8(&s, -20,-4); 12442 ck_assert_ptr_eq(r, s); 12443 ck_assert_str_eq(s, "eepy"); 12444 free(s); 12445 // end outside string 12446 s = strdup("sheepy"); 12447 r = iDelUTF8(&s, 2,40); 12448 ck_assert_ptr_eq(r, s); 12449 ck_assert_str_eq(s, "sh"); 12450 free(s); 12451 s = strdup("sheepy"); 12452 r = iDelUTF8(&s, 2,-40); 12453 ck_assert_ptr_eq(r, null); 12454 ck_assert_str_eq(s, "sheepy"); 12455 free(s); 12456 // end before start 12457 s = strdup("sheepy"); 12458 r = iDelUTF8(&s, 4,2); 12459 ck_assert_ptr_eq(r, null); 12460 ck_assert_str_eq(s, "sheepy"); 12461 free(s); 12462 // NULL var 12463 r = iDelUTF8(NULL, 4,2); 12464 ck_assert_ptr_eq(r, null); 12465 12466 12467 } 12468 12469 12470 void bDelUTF8T(CuTest *tc UNUSED) { 12471 12472 char s[100]; 12473 char *r = null; 12474 12475 // del 12476 strcpy(s, "sheepy"); 12477 r = bDelUTF8(s, 0,2); 12478 ck_assert_ptr_eq(r, s); 12479 ck_assert_str_eq(s, "eepy"); 12480 // negative index 12481 strcpy(s, "sheepy"); 12482 r = bDelUTF8(s, -2,0); 12483 ck_assert_ptr_eq(r, s); 12484 ck_assert_str_eq(s, "shee"); 12485 // positive and negative indexes 12486 strcpy(s, "sheepy"); 12487 r = bDelUTF8(s, 2,-2); 12488 ck_assert_ptr_eq(r, s); 12489 ck_assert_str_eq(s, "shpy"); 12490 // start = end 12491 strcpy(s, "sheepy"); 12492 r = bDelUTF8(s, 2,-4); 12493 ck_assert_ptr_eq(r, s); 12494 ck_assert_str_eq(s, "sheepy"); 12495 // delete entire string 12496 strcpy(s, "sheepy"); 12497 r = bDelUTF8(s, 0,0); 12498 ck_assert_ptr_eq(r, s); 12499 ck_assert_str_eq(s, ""); 12500 // end of string 12501 strcpy(s, "sheepy"); 12502 r = bDelUTF8(s, 2,6); 12503 ck_assert_ptr_eq(r, s); 12504 ck_assert_str_eq(s, "sh"); 12505 // start outside string 12506 strcpy(s, "sheepy"); 12507 r = bDelUTF8(s, 20,-4); 12508 ck_assert_ptr_eq(r, null); 12509 ck_assert_str_eq(s, "sheepy"); 12510 r = bDelUTF8(s, -20,-4); 12511 ck_assert_ptr_eq(r, s); 12512 ck_assert_str_eq(s, "eepy"); 12513 // end outside string 12514 strcpy(s, "sheepy"); 12515 r = bDelUTF8(s, 2,40); 12516 ck_assert_ptr_eq(r, s); 12517 ck_assert_str_eq(s, "sh"); 12518 strcpy(s, "sheepy"); 12519 r = bDelUTF8(s, 2,-40); 12520 ck_assert_ptr_eq(r, null); 12521 ck_assert_str_eq(s, "sheepy"); 12522 // end before start 12523 strcpy(s, "sheepy"); 12524 r = bDelUTF8(s, 4,2); 12525 ck_assert_ptr_eq(r, null); 12526 ck_assert_str_eq(s, "sheepy"); 12527 // NULL var 12528 r = bDelUTF8(NULL, 4,2); 12529 ck_assert_ptr_eq(r, null); 12530 12531 12532 } 12533 12534 12535 void bLDelUTF8T(CuTest *tc UNUSED) { 12536 12537 char s[100]; 12538 char *r = null; 12539 12540 // del 12541 strcpy(s, "sheepy"); 12542 r = bLDelUTF8(s, sizeof(s), 0,2); 12543 ck_assert_ptr_eq(r, s); 12544 ck_assert_str_eq(s, "eepy"); 12545 // buffer shorter than string 12546 strcpy(s, "sheepy"); 12547 r = bLDelUTF8(s, 5, 0,2); 12548 ck_assert_ptr_eq(r, s); 12549 ck_assert_str_eq(s, "ee"); 12550 // negative index 12551 strcpy(s, "sheepy"); 12552 r = bLDelUTF8(s, sizeof(s), -2,0); 12553 ck_assert_ptr_eq(r, s); 12554 ck_assert_str_eq(s, "shee"); 12555 // positive and negative indexes 12556 strcpy(s, "sheepy"); 12557 r = bLDelUTF8(s, sizeof(s), 2,-2); 12558 ck_assert_ptr_eq(r, s); 12559 ck_assert_str_eq(s, "shpy"); 12560 // start = end 12561 strcpy(s, "sheepy"); 12562 r = bLDelUTF8(s, sizeof(s), 2,-4); 12563 ck_assert_ptr_eq(r, s); 12564 ck_assert_str_eq(s, "sheepy"); 12565 // end of string 12566 strcpy(s, "sheepy"); 12567 r = bLDelUTF8(s, sizeof(s), 2,6); 12568 ck_assert_ptr_eq(r, s); 12569 ck_assert_str_eq(s, "sh"); 12570 // start outside string 12571 strcpy(s, "sheepy"); 12572 r = bLDelUTF8(s, sizeof(s), 20,-4); 12573 ck_assert_ptr_eq(r, null); 12574 ck_assert_str_eq(s, "sheepy"); 12575 // end outside string 12576 strcpy(s, "sheepy"); 12577 r = bLDelUTF8(s, sizeof(s), 2,40); 12578 ck_assert_ptr_eq(r, s); 12579 ck_assert_str_eq(s, "sh"); 12580 strcpy(s, "sheepy"); 12581 r = bLDelUTF8(s, sizeof(s), -22,3); 12582 ck_assert_ptr_eq(r, s); 12583 ck_assert_str_eq(s, "epy"); 12584 strcpy(s, "sheepy"); 12585 r = bLDelUTF8(s, sizeof(s), 2,-40); 12586 ck_assert_ptr_eq(r, null); 12587 ck_assert_str_eq(s, "sheepy"); 12588 // end before start 12589 strcpy(s, "sheepy"); 12590 r = bLDelUTF8(s, sizeof(s), 4,2); 12591 ck_assert_ptr_eq(r, null); 12592 ck_assert_str_eq(s, "sheepy"); 12593 // size 0 12594 r = bLDelUTF8(s, 0, 0, 0); 12595 ck_assert_ptr_eq(r, null); 12596 // NULL var 12597 r = bLDelUTF8(NULL, sizeof(s), 0, 0); 12598 ck_assert_ptr_eq(r, null); 12599 12600 12601 } 12602 12603 12604 void indexOfUTF8T(CuTest *tc UNUSED) { 12605 12606 // indexOf string in the middle 12607 ck_assert_int_eq(indexOfUTF8("sheepy", "ee"), 2); 12608 // indexOf non existing string 12609 ck_assert_int_eq(indexOfUTF8("sheepy", "$"), -1); 12610 // indexOf NULL 12611 ck_assert_int_eq(indexOfUTF8("sheepy", NULL), -1); 12612 // NULL string 12613 ck_assert_int_eq(indexOfUTF8(NULL, "$"), -1); 12614 12615 12616 } 12617 12618 12619 void icHasUTF8T(CuTest *tc UNUSED) { 12620 12621 // find string in the middle 12622 ck_assert(icHasUTF8("sheepy", "EE")); 12623 // find non existing string 12624 ck_assert(!icHasUTF8("sheepy", "$")); 12625 // find NULL 12626 ck_assert(!icHasUTF8("sheepy", NULL)); 12627 // NULL string 12628 ck_assert(!icHasUTF8(NULL, "$")); 12629 12630 12631 } 12632 12633 12634 void icListSortUTF8T(CuTest *tc UNUSED) { 12635 12636 char **l = NULL; 12637 char **l2; 12638 char **r = null; 12639 12640 // list 12641 r = listPushS(&l, "1sdfdsf"); 12642 ck_assert_ptr_eq(r, l); 12643 r = listPushS(&l, "4444"); 12644 ck_assert_ptr_eq(r, l); 12645 r = listPushS(&l, "3"); 12646 ck_assert_ptr_eq(r, l); 12647 r = listPushS(&l, "22sdf"); 12648 ck_assert_ptr_eq(r, l); 12649 l2 = icListSortUTF8(l); 12650 ck_assert_str_eq(l2[0], "1sdfdsf"); 12651 ck_assert_str_eq(l2[3], "4444"); 12652 listFreeS(l); 12653 listFreeS(l2); 12654 // one element list 12655 l = NULL; 12656 r = listPushS(&l, "1sdfdsf"); 12657 ck_assert_ptr_eq(r, l); 12658 l2 = icListSortUTF8(l); 12659 ck_assert_uint_eq(listLengthS(l2),1); 12660 ck_assert_str_eq(l2[0], "1sdfdsf"); 12661 listFreeS(l); 12662 listFreeS(l2); 12663 // empty list 12664 listEmptyS(l2) 12665 l = icListSortUTF8(l2); 12666 ck_assert_uint_eq(listLengthS(l),0); 12667 ck_assert_ptr_eq(l[0], NULL); 12668 listFreeS(l); 12669 listFreeS(l2); 12670 // NULL list 12671 ck_assert_ptr_eq(icListSortUTF8(NULL), NULL); 12672 12673 12674 } 12675 12676 12677 void iicListSortUTF8T(CuTest *tc UNUSED) { 12678 12679 char **l = NULL; 12680 char **r = null; 12681 12682 // list 12683 r = listPushS(&l, "1sdfdsf"); 12684 ck_assert_ptr_eq(r, l); 12685 r = listPushS(&l, "4444"); 12686 ck_assert_ptr_eq(r, l); 12687 r = listPushS(&l, "3"); 12688 ck_assert_ptr_eq(r, l); 12689 r = listPushS(&l, "22sdf"); 12690 ck_assert_ptr_eq(r, l); 12691 r = iicListSortUTF8(&l); 12692 ck_assert_ptr_eq(r, l); 12693 ck_assert_str_eq(l[0], "1sdfdsf"); 12694 ck_assert_str_eq(l[3], "4444"); 12695 listFreeS(l); 12696 // one element list 12697 l = NULL; 12698 r = listPushS(&l, "1sdfdsf"); 12699 ck_assert_ptr_eq(r, l); 12700 r = iicListSortUTF8(&l); 12701 ck_assert_ptr_eq(r, l); 12702 ck_assert_uint_eq(listLengthS(l),1); 12703 ck_assert_str_eq(l[0], "1sdfdsf"); 12704 listFreeS(l); 12705 // empty list 12706 listEmptyS(l) 12707 r = iicListSortUTF8(&l); 12708 ck_assert_ptr_eq(r, null); 12709 ck_assert_uint_eq(listLengthS(l),0); 12710 ck_assert_ptr_eq(l[0], NULL); 12711 listFreeS(l); 12712 // NULL list 12713 l = NULL; 12714 r = iicListSortUTF8(&l); 12715 ck_assert_ptr_eq(r, l); 12716 ck_assert_ptr_eq(l, NULL); 12717 // NULL var 12718 r = iicListSortUTF8(NULL); 12719 ck_assert_ptr_eq(r, null); 12720 12721 12722 } 12723 12724 12725 void icListEqUTF8T(CuTest *tc UNUSED) { 12726 12727 char **l = NULL; 12728 char **l2; 12729 char **r = null; 12730 12731 // identical lists 12732 r = listPushS(&l, "1"); 12733 ck_assert_ptr_eq(r, l); 12734 r = listPushS(&l, "22"); 12735 ck_assert_ptr_eq(r, l); 12736 r = listPushS(&l, "333"); 12737 ck_assert_ptr_eq(r, l); 12738 r = listPushS(&l, "4444"); 12739 ck_assert_ptr_eq(r, l); 12740 l2 = listDupS(l); 12741 ck_assert(icListEqUTF8(l,l2)); 12742 // NULL lists 12743 ck_assert(!icListEqUTF8(NULL,l)); 12744 ck_assert(!icListEqUTF8(l,NULL)); 12745 ck_assert(!icListEqUTF8(NULL,NULL)); 12746 // different lists same number of elements 12747 l[3][0] = 'A'; 12748 ck_assert(!icListEqUTF8(l,l2)); 12749 // different number of elements 12750 char *s = listPopS(&l); 12751 free(s); 12752 ck_assert(!icListEqUTF8(l,l2)); 12753 listFreeS(l); 12754 listFreeS(l2); 12755 12756 12757 } 12758 12759 12760 void icListHasUTF8T(CuTest *tc UNUSED) { 12761 12762 char **l = NULL; 12763 char **r = null; 12764 12765 // string 12766 r = listPushS(&l, "1"); 12767 ck_assert_ptr_eq(r, l); 12768 r = listPushS(&l, "22"); 12769 ck_assert_ptr_eq(r, l); 12770 r = listPushS(&l, "333"); 12771 ck_assert_ptr_eq(r, l); 12772 r = listPushS(&l, "4444"); 12773 ck_assert_ptr_eq(r, l); 12774 ck_assert(icListHasUTF8(l, "1")); 12775 // NULL list 12776 ck_assert(!icListHasUTF8(NULL, "1")); 12777 // NULL string 12778 ck_assert(!icListHasUTF8(l, NULL)); 12779 // non existing element 12780 ck_assert(!icListHasUTF8(l, "wfe")); 12781 // string in list 12782 ck_assert(icListHasUTF8(l, "333")); 12783 listFreeS(l); 12784 12785 12786 } 12787 12788 12789 void icListIndexOfUTF8T(CuTest *tc UNUSED) { 12790 12791 char **l = NULL; 12792 char **r = null; 12793 12794 // string 12795 r = listPushS(&l, "1"); 12796 ck_assert_ptr_eq(r, l); 12797 r = listPushS(&l, "22"); 12798 ck_assert_ptr_eq(r, l); 12799 r = listPushS(&l, "333"); 12800 ck_assert_ptr_eq(r, l); 12801 r = listPushS(&l, "4444"); 12802 ck_assert_ptr_eq(r, l); 12803 ck_assert_uint_eq(icListIndexOfUTF8(l, "1"),0); 12804 // NULL list 12805 ck_assert_uint_eq(icListIndexOfUTF8(NULL, "1"),-1); 12806 // NULL string 12807 ck_assert_uint_eq(icListIndexOfUTF8(l, NULL),-1); 12808 // non existing element 12809 ck_assert_uint_eq(icListIndexOfUTF8(l, "wfe"),-1); 12810 // string in list 12811 ck_assert_uint_eq(icListIndexOfUTF8(l, "333"),2); 12812 listFreeS(l); 12813 12814 12815 } 12816 12817 12818 void icListBinarySearchUTF8T(CuTest *tc UNUSED) { 12819 12820 char **l = NULL; 12821 char **r = null; 12822 12823 // string 12824 r = listPushS(&l, "1"); 12825 ck_assert_ptr_eq(r, l); 12826 r = listPushS(&l, "22"); 12827 ck_assert_ptr_eq(r, l); 12828 r = listPushS(&l, "333"); 12829 ck_assert_ptr_eq(r, l); 12830 r = listPushS(&l, "4444"); 12831 ck_assert_ptr_eq(r, l); 12832 r = listPushS(&l, "5"); 12833 ck_assert_ptr_eq(r, l); 12834 r = listPushS(&l, "6"); 12835 ck_assert_ptr_eq(r, l); 12836 ck_assert_uint_eq(icListBinarySearchUTF8(l, "1"),0); 12837 // NULL list 12838 ck_assert_uint_eq(icListBinarySearchUTF8(NULL, "1"),-1); 12839 // NULL string 12840 ck_assert_uint_eq(icListBinarySearchUTF8(l, NULL),-1); 12841 // non existing element 12842 ck_assert_uint_eq(icListBinarySearchUTF8(l, "wfe"),-1); 12843 // string in list 12844 ck_assert_uint_eq(icListBinarySearchUTF8(l, "333"),2); 12845 listFreeS(l); 12846 12847 12848 } 12849 12850 12851 void icListUniqUTF8T(CuTest *tc UNUSED) { 12852 12853 char **l = NULL; 12854 char **l2; 12855 char **r = null; 12856 12857 // list with unique elements 12858 r = listPushS(&l, "1"); 12859 ck_assert_ptr_eq(r, l); 12860 r = listPushS(&l, "22"); 12861 ck_assert_ptr_eq(r, l); 12862 r = listPushS(&l, "333"); 12863 ck_assert_ptr_eq(r, l); 12864 r = listPushS(&l, "4444"); 12865 ck_assert_ptr_eq(r, l); 12866 l2 = icListUniqUTF8(l); 12867 ck_assert(listEqS(l,l2)); 12868 // list with identical elements 12869 l[2][0] = '2'; 12870 l[2][1] = '2'; 12871 l[2][2] = 0; 12872 listFreeS(l2); 12873 l2 = icListUniqUTF8(l); 12874 ck_assert_uint_eq(listLengthS(l2),3); 12875 ck_assert_str_eq(l2[2], "4444"); 12876 listFreeS(l); 12877 listFreeS(l2); 12878 // list with one element 12879 l = NULL; 12880 r = listPushS(&l, "1"); 12881 ck_assert_ptr_eq(r, l); 12882 l2 = icListUniqUTF8(l); 12883 ck_assert_uint_eq(listLengthS(l2),1); 12884 ck_assert_str_eq(l2[0], "1"); 12885 listFreeS(l); 12886 listFreeS(l2); 12887 // empty list 12888 listEmptyS(l) 12889 l2 = icListUniqUTF8(l); 12890 ck_assert_uint_eq(listLengthS(l2),0); 12891 ck_assert_ptr_eq(l2[0], NULL); 12892 listFreeS(l); 12893 listFreeS(l2); 12894 // NULL list 12895 ck_assert_ptr_eq(icListUniqUTF8(NULL), NULL); 12896 12897 12898 } 12899 12900 12901 void iicListUniqUTF8T(CuTest *tc UNUSED) { 12902 12903 char **l = NULL; 12904 char **l2; 12905 char **r = null; 12906 12907 // list with unique elements 12908 r = listPushS(&l, "1"); 12909 ck_assert_ptr_eq(r, l); 12910 r = listPushS(&l, "22"); 12911 ck_assert_ptr_eq(r, l); 12912 r = listPushS(&l, "333"); 12913 ck_assert_ptr_eq(r, l); 12914 r = listPushS(&l, "4444"); 12915 ck_assert_ptr_eq(r, l); 12916 l2 = listDupS(l); 12917 r = iicListUniqUTF8(&l2); 12918 ck_assert_ptr_eq(r, l2); 12919 ck_assert(listEqS(l,l2)); 12920 // list with identical elements 12921 l[2][0] = '2'; 12922 l[2][1] = '2'; 12923 l[2][2] = 0; 12924 listFreeS(l2); 12925 l2 = listDupS(l); 12926 r = iicListUniqUTF8(&l2); 12927 ck_assert_ptr_eq(r, l2); 12928 ck_assert_uint_eq(listLengthS(l2),3); 12929 ck_assert_str_eq(l2[2], "4444"); 12930 listFreeS(l); 12931 listFreeS(l2); 12932 // list with one element 12933 l = NULL; 12934 r = listPushS(&l, "1"); 12935 ck_assert_ptr_eq(r, l); 12936 l2 = listDupS(l); 12937 r = iicListUniqUTF8(&l2); 12938 ck_assert_ptr_eq(r, l2); 12939 ck_assert_uint_eq(listLengthS(l2),1); 12940 ck_assert_str_eq(l2[0], "1"); 12941 listFreeS(l); 12942 listFreeS(l2); 12943 // empty list 12944 listEmptyS(l) 12945 l2 = listDupS(l); 12946 r = iicListUniqUTF8(&l2); 12947 ck_assert_ptr_eq(r, l2); 12948 ck_assert_uint_eq(listLengthS(l2),0); 12949 ck_assert_ptr_eq(l2[0], NULL); 12950 listFreeS(l); 12951 listFreeS(l2); 12952 // NULL list 12953 l = NULL; 12954 r = iicListUniqUTF8(&l); 12955 ck_assert_ptr_eq(r, l); 12956 ck_assert_ptr_eq(l, NULL); 12957 // NULL var 12958 r = iicListUniqUTF8(NULL); 12959 ck_assert_ptr_eq(r, null); 12960 12961 12962 } 12963 12964 12965 void emptySFT(CuTest *tc UNUSED) { 12966 12967 char *s; 12968 12969 // empty string 12970 s = emptySF(); 12971 ck_assert(isEmptyS(s)); 12972 free(s); 12973 12974 } 12975 12976 12977 void iEmptySFT(CuTest *tc UNUSED) { 12978 12979 char *s; 12980 char *r = null; 12981 12982 // empty string 12983 s = strdup("qwe"); 12984 r = iEmptySF(&s); 12985 ck_assert_ptr_eq(r, s); 12986 ck_assert(isEmptyS(s)); 12987 free(s); 12988 // NULL string 12989 s = NULL; 12990 r = iEmptySF(&s); 12991 ck_assert_ptr_eq(r, s); 12992 ck_assert(isEmptyS(s)); 12993 free(s); 12994 // NULL var 12995 r = iEmptySF(NULL); 12996 ck_assert_ptr_eq(r, null); 12997 12998 } 12999 13000 13001 void isEmptyST(CuTest *tc UNUSED) { 13002 13003 char *s; 13004 13005 // non empty 13006 s = strdup("a"); 13007 ck_assert(!isEmptyS(s)); 13008 free(s); 13009 // empty 13010 emptyS(s) 13011 ck_assert(isEmptyS(s)); 13012 free(s); 13013 // NULL string 13014 ck_assert(isEmptyS(NULL)); 13015 13016 } 13017 13018 13019 void isBlankST(CuTest *tc UNUSED) { 13020 13021 char *s; 13022 13023 // non empty 13024 s = strdup("a"); 13025 ck_assert(!isBlankS(s)); 13026 free(s); 13027 // white spaces 13028 ck_assert(isBlankS(" ")); 13029 // empty 13030 emptyS(s) 13031 ck_assert(isBlankS(s)); 13032 free(s); 13033 // NULL string 13034 ck_assert(isBlankS(NULL)); 13035 13036 } 13037 13038 13039 void intIndexT(CuTest *tc UNUSED) { 13040 13041 ssize_t r; 13042 13043 // positive index 13044 r = intIndex(2,3); 13045 ck_assert_int_eq(r, 2); 13046 // negative index 13047 r = intIndex(-1,3); 13048 ck_assert_int_eq(r, 2); 13049 r = intIndex(-3,3); 13050 ck_assert_int_eq(r, 0); 13051 // outside length 13052 r = intIndex(3,3); 13053 ck_assert_int_eq(r, -1); 13054 r = intIndex(-4,3); 13055 ck_assert_int_eq(r, -1); 13056 // length 0 13057 r = intIndex(-1,0); 13058 ck_assert_int_eq(r, -1); 13059 13060 } 13061 13062 13063 void listEmptySFT(CuTest *tc UNUSED) { 13064 13065 char **l; 13066 13067 // empty list 13068 l = listEmptySF(); 13069 ck_assert(listIsEmptyS(l)); 13070 listFreeS(l); 13071 13072 } 13073 13074 13075 void iListEmptySFT(CuTest *tc UNUSED) { 13076 13077 char **l; 13078 char **r = null; 13079 13080 // empty list 13081 l = listCreateS("lib", "sheepy"); 13082 r = iListEmptySF(&l); 13083 ck_assert_ptr_eq(r, l); 13084 ck_assert(listIsEmptyS(l)); 13085 listFreeS(l); 13086 // NULL list 13087 l = NULL; 13088 r = iListEmptySF(&l); 13089 ck_assert_ptr_eq(r, l); 13090 ck_assert(listIsEmptyS(l)); 13091 listFreeS(l); 13092 // NULL var 13093 r = iListEmptySF(NULL); 13094 ck_assert_ptr_eq(r, null); 13095 13096 } 13097 13098 13099 void listIsEmptyST(CuTest *tc UNUSED) { 13100 13101 char **l; 13102 13103 // non empty list 13104 l = listCreateS("sheepy", "SHEEPY", "sheepy"); 13105 // check ck_assert_ptr_null not available in jessie 13106 ck_assert_ptr_ne(l, NULL); 13107 ck_assert(!listIsEmptyS(l)); 13108 listFreeS(l); 13109 // empty list 13110 listEmptyS(l) 13111 ck_assert(listIsEmptyS(l)); 13112 listFreeS(l); 13113 ck_assert(listIsEmptyS(NULL)); 13114 13115 } 13116 13117 13118 void listIsBlankST(CuTest *tc UNUSED) { 13119 13120 char **l; 13121 13122 // non empty list 13123 l = listCreateS("sheepy", "SHEEPY", "sheepy"); 13124 // check ck_assert_ptr_null not available in jessie 13125 ck_assert_ptr_ne(l, NULL); 13126 ck_assert(!listIsBlankS(l)); 13127 listFreeS(l); 13128 l = listCreateS("", " "); 13129 ck_assert(listIsBlankS(l)); 13130 listFreeS(l); 13131 // empty list 13132 listEmptyS(l) 13133 ck_assert(listIsBlankS(l)); 13134 listFreeS(l); 13135 ck_assert(listIsEmptyS(NULL)); 13136 13137 } 13138 13139 13140 void listLengthST(CuTest *tc UNUSED) { 13141 13142 char **l; 13143 13144 // list length 13145 l = malloc(2 * sizeof(char *)); 13146 l[0] = (char *)1; 13147 l[1] = NULL; 13148 ck_assert_uint_eq(listLengthS(l),1); 13149 free(l); 13150 // empty list 13151 listEmptyS(l) 13152 ck_assert_uint_eq(listLengthS(l),0); 13153 free(l); 13154 // NULL list 13155 ck_assert_uint_eq(listLengthS(NULL),0); 13156 13157 13158 } 13159 13160 13161 void listStrLengthST(CuTest *tc UNUSED) { 13162 13163 char **l = null; 13164 ssize_t r; 13165 char **r2 = null; 13166 13167 r2 = listPushS(&l, "lib"); 13168 ck_assert_ptr_eq(r2, l); 13169 r2 = listPushS(&l, "sheepy"); 13170 ck_assert_ptr_eq(r2, l); 13171 r = listStrLengthS(l); 13172 ck_assert_int_eq(r, 9); 13173 listFreeS(l); 13174 // null list 13175 r = listStrLengthS(null); 13176 ck_assert_int_eq(r, -1); 13177 13178 } 13179 13180 13181 void listIntIndexST(CuTest *tc UNUSED) { 13182 13183 char **l = null; 13184 ssize_t r; 13185 char **r2 = null; 13186 13187 r2 = listPushS(&l, "lib"); 13188 ck_assert_ptr_eq(r2, l); 13189 r2 = listPushS(&l, "sheepy"); 13190 ck_assert_ptr_eq(r2, l); 13191 r2 = listPushS(&l, "sheepy"); 13192 ck_assert_ptr_eq(r2, l); 13193 // positive index 13194 r = listIntIndexS(l, 2); 13195 ck_assert_int_eq(r, 2); 13196 // negative index 13197 r = listIntIndexS(l, -1); 13198 ck_assert_int_eq(r, 2); 13199 r = listIntIndexS(l, -3); 13200 ck_assert_int_eq(r, 0); 13201 // outside length 13202 r = listIntIndexS(l, 3); 13203 ck_assert_int_eq(r, -1); 13204 r = listIntIndexS(l, -4); 13205 ck_assert_int_eq(r, -1); 13206 listFreeS(l); 13207 // length 0 13208 listEmptyS(l); 13209 r = listIntIndexS(l, -1); 13210 ck_assert_int_eq(r, -1); 13211 listFreeS(l); 13212 // null list 13213 ck_assert_int_eq(listIntIndexS(NULL, 1), -1); 13214 13215 } 13216 13217 13218 void listAddrST(CuTest *tc UNUSED) { 13219 13220 char **l = null; 13221 char **r; 13222 13223 r = listPushS(&l, "lib"); 13224 ck_assert_ptr_eq(r, l); 13225 r = listPushS(&l, "sheepy"); 13226 ck_assert_ptr_eq(r, l); 13227 r = listPushS(&l, "sheepy"); 13228 ck_assert_ptr_eq(r, l); 13229 // positive index 13230 r = listAddrS(l, 2); 13231 ck_assert_ptr_eq(r, &l[2]); 13232 // negative index 13233 r = listAddrS(l, -1); 13234 ck_assert_ptr_eq(r, &l[2]); 13235 r = listAddrS(l, -3); 13236 ck_assert_ptr_eq(r, &l[0]); 13237 // outside length 13238 r = listAddrS(l, 3); 13239 ck_assert_ptr_eq(r, null); 13240 r = listAddrS(l, -4); 13241 ck_assert_ptr_eq(r, null); 13242 listFreeS(l); 13243 // length 0 13244 listEmptyS(l); 13245 r = listAddrS(l, -1); 13246 ck_assert_ptr_eq(r, null); 13247 listFreeS(l); 13248 // null list 13249 ck_assert_ptr_eq(listAddrS(NULL, 1), null); 13250 13251 13252 } 13253 13254 13255 void listCreateST(CuTest *tc UNUSED) { 13256 13257 char **l; 13258 13259 // create list 13260 l = listCreateS("sheepy", "SHEEPY", "sheepy"); 13261 // check ck_assert_ptr_null not available in jessie 13262 ck_assert_ptr_ne(l, NULL); 13263 ck_assert_uint_eq(listLengthS(l),3); 13264 ck_assert_str_eq(l[0], "sheepy"); 13265 ck_assert_str_eq(l[1], "SHEEPY"); 13266 ck_assert_str_eq(l[2], "sheepy"); 13267 listFreeS(l); 13268 13269 // NULL first element 13270 ck_assert_ptr_eq(listCreateS(NULL, "sheepy"), NULL); 13271 13272 } 13273 13274 13275 void listFromArrayST(CuTest *tc UNUSED) { 13276 13277 char **l = NULL; 13278 char *array[] = {"1", "22", "333"}; 13279 char *arrayNULL[] = {"1", NULL, "333"}; 13280 13281 // copy array to list 13282 l = listFromArrayS(array, 3); 13283 ck_assert_uint_eq(listLengthS(l),3); 13284 ck_assert_str_eq(l[0], "1"); 13285 ck_assert_str_eq(l[1], "22"); 13286 ck_assert_str_eq(l[2], "333"); 13287 listFreeS(l); 13288 // array with NULL inside 13289 l = listFromArrayS(arrayNULL, 3); 13290 ck_assert_uint_eq(listLengthS(l),2); 13291 ck_assert_str_eq(l[0], "1"); 13292 ck_assert_str_eq(l[1], "333"); 13293 listFreeS(l); 13294 // empty list 13295 l = listFromArrayS(array, 0); 13296 ck_assert(listIsEmptyS(l)); 13297 listFreeS(l); 13298 // NULL pointer to list 13299 ck_assert_ptr_eq(listFromArrayS(NULL, 1), NULL); 13300 13301 } 13302 13303 13304 void listPushST(CuTest *tc UNUSED) { 13305 13306 char **l = NULL; 13307 char **r = null; 13308 13309 // push strings and NULL list 13310 r = listPushS(&l, "sheepy"); 13311 ck_assert_ptr_eq(r, l); 13312 // check ck_assert_ptr_null not available in jessie 13313 ck_assert_ptr_ne(l, NULL); 13314 ck_assert_str_eq(l[0], "sheepy"); 13315 r = listPushS(&l, "SHEEPY"); 13316 ck_assert_ptr_eq(r, l); 13317 ck_assert_str_eq(l[1], "SHEEPY"); 13318 ck_assert_str_eq(l[0], "sheepy"); 13319 // push NULL 13320 r = listPushS(&l, NULL); 13321 ck_assert_ptr_eq(r, null); 13322 ck_assert_ptr_eq(l[2], NULL); 13323 listFreeS(l); 13324 // NULL list and NULL string 13325 l = NULL; 13326 r = listPushS(&l, NULL); 13327 ck_assert_ptr_eq(r, null); 13328 ck_assert_ptr_eq(l, NULL); 13329 // empty list 13330 listEmptyS(l) 13331 r = listPushS(&l, "sheepy"); 13332 ck_assert_ptr_eq(r, l); 13333 ck_assert_str_eq(l[0], "sheepy"); 13334 ck_assert_ptr_eq(l[1], NULL); 13335 listFreeS(l); 13336 // NULL pointer to list 13337 r = listPushS(NULL, NULL); 13338 ck_assert_ptr_eq(r, null); 13339 13340 } 13341 13342 13343 void listPushCharST(CuTest *tc UNUSED) { 13344 13345 char **l = NULL; 13346 char **r = null; 13347 13348 // push strings and NULL list 13349 r = listPushCharS(&l, 's'); 13350 ck_assert_ptr_eq(r, l); 13351 // check ck_assert_ptr_null not available in jessie 13352 ck_assert_ptr_ne(l, NULL); 13353 ck_assert_str_eq(l[0], "s"); 13354 r = listPushCharS(&l, 'S'); 13355 ck_assert_ptr_eq(r, l); 13356 ck_assert_str_eq(l[1], "S"); 13357 ck_assert_str_eq(l[0], "s"); 13358 listFreeS(l); 13359 // empty list 13360 listEmptyS(l) 13361 r = listPushCharS(&l, 's'); 13362 ck_assert_ptr_eq(r, l); 13363 ck_assert_str_eq(l[0], "s"); 13364 ck_assert_ptr_eq(l[1], NULL); 13365 listFreeS(l); 13366 // NULL pointer to list 13367 r = listPushCharS(NULL, 's'); 13368 ck_assert_ptr_eq(r, null); 13369 13370 13371 } 13372 13373 13374 void iListPushST(CuTest *tc UNUSED) { 13375 13376 char **l = NULL; 13377 char *s; 13378 char **r = null; 13379 13380 // push strings and NULL list 13381 s = strdup("sheepy"); 13382 r = iListPushS(&l, s); 13383 ck_assert_ptr_eq(r, l); 13384 // check ck_assert_ptr_null not available in jessie 13385 ck_assert_ptr_ne(l, NULL); 13386 ck_assert_str_eq(l[0], "sheepy"); 13387 s = strdup("SHEEPY"); 13388 r = iListPushS(&l, s); 13389 ck_assert_ptr_eq(r, l); 13390 ck_assert_str_eq(l[0], "sheepy"); 13391 ck_assert_str_eq(l[1], "SHEEPY"); 13392 // push NULL 13393 r = iListPushS(&l, NULL); 13394 ck_assert_ptr_eq(r, null); 13395 ck_assert_ptr_eq(l[2], NULL); 13396 listFreeS(l); 13397 // NULL list and NULL string 13398 l = NULL; 13399 r = iListPushS(&l, NULL); 13400 ck_assert_ptr_eq(r, null); 13401 ck_assert_ptr_eq(l, NULL); 13402 // empty list 13403 listEmptyS(l) 13404 s = strdup("sheepy"); 13405 r = iListPushS(&l, s); 13406 ck_assert_ptr_eq(r, l); 13407 ck_assert_str_eq(l[0], "sheepy"); 13408 ck_assert_ptr_eq(l[1], NULL); 13409 listFreeS(l); 13410 // NULL pointer to list 13411 r = iListPushS(NULL, NULL); 13412 ck_assert_ptr_eq(r, null); 13413 13414 } 13415 13416 13417 void listPopST(CuTest *tc UNUSED) { 13418 13419 char **l = NULL; 13420 char *s; 13421 char **r = null; 13422 13423 // pop string 13424 r = listPushS(&l, "sheepy"); 13425 ck_assert_ptr_eq(r, l); 13426 r = listPushS(&l, "SHEEPY"); 13427 ck_assert_ptr_eq(r, l); 13428 s = listPopS(&l); 13429 ck_assert_str_eq(s, "SHEEPY"); 13430 ck_assert_uint_eq(listLengthS(l),1); 13431 free(s); 13432 // last element 13433 s = listPopS(&l); 13434 ck_assert_str_eq(s, "sheepy"); 13435 free(s); 13436 ck_assert_uint_eq(listLengthS(l),0); 13437 // empty list 13438 ck_assert_ptr_eq(listPopS(&l), NULL); 13439 listFreeS(l); 13440 // NULL list 13441 l = NULL; 13442 ck_assert_ptr_eq(listPopS(&l), NULL); 13443 // NULL pointer to list 13444 ck_assert_ptr_eq(listPopS(NULL), NULL); 13445 13446 } 13447 13448 13449 void listPrependST(CuTest *tc UNUSED) { 13450 13451 char **l = NULL; 13452 char **r = null; 13453 13454 // push strings and NULL list 13455 r = listPrependS(&l, "sheepy"); 13456 ck_assert_ptr_eq(r, l); 13457 // check ck_assert_ptr_null not available in jessie 13458 ck_assert_ptr_ne(l, NULL); 13459 ck_assert_str_eq(l[0], "sheepy"); 13460 r = listPrependS(&l, "SHEEPY"); 13461 ck_assert_ptr_eq(r, l); 13462 ck_assert_str_eq(l[0], "SHEEPY"); 13463 ck_assert_str_eq(l[1], "sheepy"); 13464 // push NULL 13465 r = listPrependS(&l, NULL); 13466 ck_assert_ptr_eq(r, null); 13467 ck_assert_str_eq(l[0], "SHEEPY"); 13468 listFreeS(l); 13469 // NULL list and NULL string` 13470 l = NULL; 13471 r = listPrependS(&l, NULL); 13472 ck_assert_ptr_eq(r, null); 13473 ck_assert_ptr_eq(l, NULL); 13474 // empty list 13475 listEmptyS(l) 13476 r = listPrependS(&l, "sheepy"); 13477 ck_assert_ptr_eq(r, l); 13478 ck_assert_str_eq(l[0], "sheepy"); 13479 ck_assert_ptr_eq(l[1], NULL); 13480 listFreeS(l); 13481 // NULL pointer to list 13482 r = listPrependS(NULL, NULL); 13483 ck_assert_ptr_eq(r, null); 13484 13485 } 13486 13487 13488 void listPrependCharST(CuTest *tc UNUSED) { 13489 13490 char **l = NULL; 13491 char **r = null; 13492 13493 // push strings and NULL list 13494 r = listPrependCharS(&l, 's'); 13495 ck_assert_ptr_eq(r, l); 13496 // check ck_assert_ptr_null not available in jessie 13497 ck_assert_ptr_ne(l, NULL); 13498 ck_assert_str_eq(l[0], "s"); 13499 r = listPrependCharS(&l, 'S'); 13500 ck_assert_ptr_eq(r, l); 13501 ck_assert_str_eq(l[0], "S"); 13502 ck_assert_str_eq(l[1], "s"); 13503 listFreeS(l); 13504 // empty list 13505 listEmptyS(l) 13506 r = listPrependCharS(&l, 's'); 13507 ck_assert_ptr_eq(r, l); 13508 ck_assert_str_eq(l[0], "s"); 13509 ck_assert_ptr_eq(l[1], NULL); 13510 listFreeS(l); 13511 // NULL pointer to list 13512 r = listPrependCharS(NULL, 's'); 13513 ck_assert_ptr_eq(r, null); 13514 13515 13516 } 13517 13518 13519 void iListPrependST(CuTest *tc UNUSED) { 13520 13521 char **l = NULL; 13522 char *s; 13523 char **r = null; 13524 13525 // prepend strings and NULL list 13526 s = strdup("sheepy"); 13527 r = iListPrependS(&l, s); 13528 ck_assert_ptr_eq(r, l); 13529 // check ck_assert_ptr_null not available in jessie 13530 ck_assert_ptr_ne(l, NULL); 13531 ck_assert_str_eq(l[0], "sheepy"); 13532 s = strdup("SHEEPY"); 13533 r = iListPrependS(&l, s); 13534 ck_assert_ptr_eq(r, l); 13535 ck_assert_str_eq(l[0], "SHEEPY"); 13536 ck_assert_str_eq(l[1], "sheepy"); 13537 // prepend NULL 13538 r = iListPrependS(&l, NULL); 13539 ck_assert_ptr_eq(r, null); 13540 ck_assert_str_eq(l[0], "SHEEPY"); 13541 listFreeS(l); 13542 // NULL list and NULL string 13543 l = NULL; 13544 r = iListPrependS(&l, NULL); 13545 ck_assert_ptr_eq(r, null); 13546 ck_assert_ptr_eq(l, NULL); 13547 // empty list 13548 listEmptyS(l) 13549 s = strdup("sheepy"); 13550 r = iListPrependS(&l, s); 13551 ck_assert_ptr_eq(r, l); 13552 ck_assert_str_eq(l[0], "sheepy"); 13553 ck_assert_ptr_eq(l[1], NULL); 13554 listFreeS(l); 13555 // NULL pointer to list 13556 r = iListPrependS(NULL, NULL); 13557 ck_assert_ptr_eq(r, null); 13558 13559 } 13560 13561 13562 void listDequeueST(CuTest *tc UNUSED) { 13563 13564 char **l = NULL; 13565 char *s; 13566 char **r = null; 13567 13568 // dequeue string 13569 r = listPushS(&l, "sheepy"); 13570 ck_assert_ptr_eq(r, l); 13571 r = listPushS(&l, "SHEEPY"); 13572 ck_assert_ptr_eq(r, l); 13573 s = listDequeueS(&l); 13574 ck_assert_str_eq(s, "sheepy"); 13575 ck_assert_uint_eq(listLengthS(l),1); 13576 free(s); 13577 // last element 13578 s = listDequeueS(&l); 13579 ck_assert_str_eq(s, "SHEEPY"); 13580 free(s); 13581 ck_assert_uint_eq(listLengthS(l),0); 13582 // empty list 13583 ck_assert_ptr_eq(listDequeueS(&l), NULL); 13584 listFreeS(l); 13585 // NULL list 13586 l = NULL; 13587 ck_assert_ptr_eq(listDequeueS(&l), NULL); 13588 // NULL pointer to list 13589 ck_assert_ptr_eq(listDequeueS(NULL), NULL); 13590 13591 } 13592 13593 13594 void listFreeST(CuTest *tc UNUSED) { 13595 13596 // not possible to know if a pointer is already freed 13597 char **l = listCreateS("we","sd"); 13598 listFreeS(l); 13599 // empty list 13600 listEmptyS(l); 13601 listFreeS(l); 13602 // NULL list 13603 listFreeS(NULL); 13604 13605 } 13606 13607 13608 void listFreeManyST(CuTest *tc UNUSED) { 13609 13610 // not possible to know if a pointer is already freed 13611 char **l1 = listCreateS("we","sd"); 13612 char **l2 = listEmptySF(); 13613 listFreeManyS(l1, l2); 13614 13615 } 13616 13617 13618 void listPrintST(CuTest *tc UNUSED) { 13619 13620 char **l; 13621 13622 // print text 13623 l = readText("textTest.null"); 13624 // TODO check stdout 13625 //listPrintS(l); 13626 listFreeS(l); 13627 // NULL list 13628 int r = listPrintS(NULL); 13629 ck_assert_int_eq(r, 0); 13630 13631 } 13632 13633 13634 void listForEachT(CuTest *tc UNUSED) { 13635 13636 char **l = NULL; 13637 char **l2 = NULL; 13638 char **r = null; 13639 13640 // for each element in list 13641 r = listPushS(&l, "1sdfdsf"); 13642 ck_assert_ptr_eq(r, l); 13643 r = listPushS(&l, "4444"); 13644 ck_assert_ptr_eq(r, l); 13645 r = listPushS(&l, "3"); 13646 ck_assert_ptr_eq(r, l); 13647 r = listPushS(&l, "22sdf"); 13648 ck_assert_ptr_eq(r, l); 13649 forEachCharP(l, i) { 13650 //printf(*i); 13651 r = listPushS(&l2, *i); 13652 ck_assert_ptr_eq(r, l2); 13653 } 13654 ck_assert_str_eq(l2[0], "1sdfdsf"); 13655 ck_assert_str_eq(l2[3], "22sdf"); 13656 listFreeS(l); 13657 listFreeS(l2); 13658 13659 } 13660 13661 13662 void listEnumerateT(CuTest *tc UNUSED) { 13663 13664 char **l = NULL; 13665 char **l2 = NULL; 13666 char **r = null; 13667 13668 // enumerateCharP elements 13669 r = listPushS(&l, "1sdfdsf"); 13670 ck_assert_ptr_eq(r, l); 13671 r = listPushS(&l, "4444"); 13672 ck_assert_ptr_eq(r, l); 13673 r = listPushS(&l, "3"); 13674 ck_assert_ptr_eq(r, l); 13675 r = listPushS(&l, "22sdf"); 13676 ck_assert_ptr_eq(r, l); 13677 enumerateCharP(l, i, j) { 13678 r = listPushS(&l2, *i); 13679 ck_assert_ptr_eq(r, l2); 13680 } 13681 ck_assert_uint_eq(j, 4); 13682 ck_assert_str_eq(l2[0], "1sdfdsf"); 13683 ck_assert_str_eq(l2[3], "22sdf"); 13684 listFreeS(l); 13685 listFreeS(l2); 13686 13687 } 13688 13689 13690 void listSortST(CuTest *tc UNUSED) { 13691 13692 char **l = NULL; 13693 char **l2; 13694 char **r = null; 13695 13696 // list 13697 r = listPushS(&l, "1sdfdsf"); 13698 ck_assert_ptr_eq(r, l); 13699 r = listPushS(&l, "4444"); 13700 ck_assert_ptr_eq(r, l); 13701 r = listPushS(&l, "3"); 13702 ck_assert_ptr_eq(r, l); 13703 r = listPushS(&l, "22sdf"); 13704 ck_assert_ptr_eq(r, l); 13705 l2 = listSortS(l); 13706 ck_assert_str_eq(l2[0], "1sdfdsf"); 13707 ck_assert_str_eq(l2[3], "4444"); 13708 listFreeS(l); 13709 listFreeS(l2); 13710 // one element list 13711 l = NULL; 13712 r = listPushS(&l, "1sdfdsf"); 13713 ck_assert_ptr_eq(r, l); 13714 l2 = listSortS(l); 13715 ck_assert_uint_eq(listLengthS(l2),1); 13716 ck_assert_str_eq(l2[0], "1sdfdsf"); 13717 listFreeS(l); 13718 listFreeS(l2); 13719 // empty list 13720 listEmptyS(l2) 13721 l = listSortS(l2); 13722 ck_assert_uint_eq(listLengthS(l),0); 13723 ck_assert_ptr_eq(l[0], NULL); 13724 listFreeS(l); 13725 listFreeS(l2); 13726 // NULL list 13727 ck_assert_ptr_eq(listSortS(NULL), NULL); 13728 13729 } 13730 13731 13732 void iListSortST(CuTest *tc UNUSED) { 13733 13734 char **l = NULL; 13735 char **r = null; 13736 13737 // list 13738 r = listPushS(&l, "1sdfdsf"); 13739 ck_assert_ptr_eq(r, l); 13740 r = listPushS(&l, "4444"); 13741 ck_assert_ptr_eq(r, l); 13742 r = listPushS(&l, "3"); 13743 ck_assert_ptr_eq(r, l); 13744 r = listPushS(&l, "22sdf"); 13745 ck_assert_ptr_eq(r, l); 13746 r = iListSortS(&l); 13747 ck_assert_ptr_eq(r, l); 13748 ck_assert_str_eq(l[0], "1sdfdsf"); 13749 ck_assert_str_eq(l[3], "4444"); 13750 listFreeS(l); 13751 // one element list 13752 l = NULL; 13753 r = listPushS(&l, "1sdfdsf"); 13754 ck_assert_ptr_eq(r, l); 13755 r = iListSortS(&l); 13756 ck_assert_ptr_eq(r, l); 13757 ck_assert_uint_eq(listLengthS(l),1); 13758 ck_assert_str_eq(l[0], "1sdfdsf"); 13759 listFreeS(l); 13760 // empty list 13761 listEmptyS(l) 13762 r = iListSortS(&l); 13763 ck_assert_ptr_eq(r, null); 13764 ck_assert_uint_eq(listLengthS(l),0); 13765 ck_assert_ptr_eq(l[0], NULL); 13766 listFreeS(l); 13767 // NULL list 13768 l = NULL; 13769 r = iListSortS(&l); 13770 ck_assert_ptr_eq(r, null); 13771 ck_assert_ptr_eq(l, NULL); 13772 // NULL var 13773 r = iListSortS(NULL); 13774 ck_assert_ptr_eq(r, null); 13775 13776 } 13777 13778 /** 13779 * list Sort String Compare function 13780 * 13781 * in: 13782 * a 13783 * b 13784 * out: 13785 * test result 13786 */ 13787 local int listSortSCmp(const void * a, const void * b) { 13788 13789 // sanity checks 13790 if (!a && !b) { 13791 return(0); 13792 } 13793 if (!a && b) { 13794 return(-1); 13795 } 13796 if (a && !b) { 13797 return(1); 13798 } 13799 return(strcmp(*(char **)a,*(char **)b)); 13800 } 13801 13802 void listSortFST(CuTest *tc UNUSED) { 13803 13804 char **l = NULL; 13805 char **l2; 13806 char **r = null; 13807 13808 // list 13809 r = listPushS(&l, "1sdfdsf"); 13810 ck_assert_ptr_eq(r, l); 13811 r = listPushS(&l, "4444"); 13812 ck_assert_ptr_eq(r, l); 13813 r = listPushS(&l, "3"); 13814 ck_assert_ptr_eq(r, l); 13815 r = listPushS(&l, "22sdf"); 13816 ck_assert_ptr_eq(r, l); 13817 l2 = listSortFS(l, listSortSCmp); 13818 ck_assert_str_eq(l2[0], "1sdfdsf"); 13819 ck_assert_str_eq(l2[3], "4444"); 13820 listFreeS(l); 13821 listFreeS(l2); 13822 // one element list 13823 l = NULL; 13824 r = listPushS(&l, "1sdfdsf"); 13825 ck_assert_ptr_eq(r, l); 13826 l2 = listSortFS(l, listSortSCmp); 13827 ck_assert_uint_eq(listLengthS(l2),1); 13828 ck_assert_str_eq(l2[0], "1sdfdsf"); 13829 listFreeS(l); 13830 listFreeS(l2); 13831 // empty list 13832 listEmptyS(l2) 13833 l = listSortFS(l2, listSortSCmp); 13834 ck_assert_uint_eq(listLengthS(l),0); 13835 ck_assert_ptr_eq(l[0], NULL); 13836 listFreeS(l); 13837 // NULL compare function 13838 ck_assert_ptr_eq(listSortFS(l2, NULL), NULL); 13839 listFreeS(l2); 13840 // NULL list 13841 ck_assert_ptr_eq(listSortFS(NULL, listSortSCmp), NULL); 13842 13843 13844 } 13845 13846 13847 void iListSortFST(CuTest *tc UNUSED) { 13848 13849 char **l = NULL; 13850 char **r = null; 13851 13852 // list 13853 r = listPushS(&l, "1sdfdsf"); 13854 ck_assert_ptr_eq(r, l); 13855 r = listPushS(&l, "4444"); 13856 ck_assert_ptr_eq(r, l); 13857 r = listPushS(&l, "3"); 13858 ck_assert_ptr_eq(r, l); 13859 r = listPushS(&l, "22sdf"); 13860 ck_assert_ptr_eq(r, l); 13861 r = iListSortFS(&l, listSortSCmp); 13862 ck_assert_ptr_eq(r, l); 13863 ck_assert_str_eq(l[0], "1sdfdsf"); 13864 ck_assert_str_eq(l[3], "4444"); 13865 listFreeS(l); 13866 // one element list 13867 l = NULL; 13868 r = listPushS(&l, "1sdfdsf"); 13869 ck_assert_ptr_eq(r, l); 13870 r = iListSortFS(&l, listSortSCmp); 13871 ck_assert_ptr_eq(r, l); 13872 ck_assert_uint_eq(listLengthS(l),1); 13873 ck_assert_str_eq(l[0], "1sdfdsf"); 13874 listFreeS(l); 13875 // empty list 13876 listEmptyS(l) 13877 r = iListSortFS(&l, listSortSCmp); 13878 ck_assert_ptr_eq(r, null); 13879 ck_assert_uint_eq(listLengthS(l),0); 13880 ck_assert_ptr_eq(l[0], NULL); 13881 // NULL compare function 13882 r = iListSortFS(&l, null); 13883 ck_assert_ptr_eq(r, null); 13884 listFreeS(l); 13885 // NULL list 13886 l = NULL; 13887 r = iListSortFS(&l, listSortSCmp); 13888 ck_assert_ptr_eq(r, null); 13889 ck_assert_ptr_eq(l, NULL); 13890 // NULL var 13891 r = iListSortFS(NULL, listSortSCmp); 13892 ck_assert_ptr_eq(r, null); 13893 13894 13895 } 13896 13897 13898 void icListSortST(CuTest *tc UNUSED) { 13899 13900 char **l = NULL; 13901 char **l2; 13902 char **r = null; 13903 13904 // list 13905 r = listPushS(&l, "A1sdfdsf"); 13906 ck_assert_ptr_eq(r, l); 13907 r = listPushS(&l, "d4444"); 13908 ck_assert_ptr_eq(r, l); 13909 r = listPushS(&l, "c3"); 13910 ck_assert_ptr_eq(r, l); 13911 r = listPushS(&l, "B22sdf"); 13912 ck_assert_ptr_eq(r, l); 13913 l2 = icListSortS(l); 13914 ck_assert_str_eq(l2[0], "A1sdfdsf"); 13915 ck_assert_str_eq(l2[3], "d4444"); 13916 listFreeS(l); 13917 listFreeS(l2); 13918 // one element list 13919 l = NULL; 13920 r = listPushS(&l, "1sdfdsf"); 13921 ck_assert_ptr_eq(r, l); 13922 l2 = icListSortS(l); 13923 ck_assert_uint_eq(listLengthS(l2),1); 13924 ck_assert_str_eq(l2[0], "1sdfdsf"); 13925 listFreeS(l); 13926 listFreeS(l2); 13927 // empty list 13928 listEmptyS(l2) 13929 l = icListSortS(l2); 13930 ck_assert_uint_eq(listLengthS(l),0); 13931 ck_assert_ptr_eq(l[0], NULL); 13932 listFreeS(l); 13933 listFreeS(l2); 13934 // NULL list 13935 ck_assert_ptr_eq(icListSortS(NULL), NULL); 13936 13937 13938 } 13939 13940 13941 void iicListSortST(CuTest *tc UNUSED) { 13942 13943 char **l = NULL; 13944 char **r = null; 13945 13946 // list 13947 r = listPushS(&l, "a1sdfdsf"); 13948 ck_assert_ptr_eq(r, l); 13949 r = listPushS(&l, "D4444"); 13950 ck_assert_ptr_eq(r, l); 13951 r = listPushS(&l, "B3"); 13952 ck_assert_ptr_eq(r, l); 13953 r = listPushS(&l, "c22sdf"); 13954 ck_assert_ptr_eq(r, l); 13955 r = iicListSortS(&l); 13956 ck_assert_ptr_eq(r, l); 13957 ck_assert_str_eq(l[0], "a1sdfdsf"); 13958 ck_assert_str_eq(l[3], "D4444"); 13959 listFreeS(l); 13960 // one element list 13961 l = NULL; 13962 r = listPushS(&l, "1sdfdsf"); 13963 ck_assert_ptr_eq(r, l); 13964 r = iicListSortS(&l); 13965 ck_assert_ptr_eq(r, l); 13966 ck_assert_uint_eq(listLengthS(l),1); 13967 ck_assert_str_eq(l[0], "1sdfdsf"); 13968 listFreeS(l); 13969 // empty list 13970 listEmptyS(l) 13971 r = iicListSortS(&l); 13972 ck_assert_ptr_eq(r, null); 13973 ck_assert_uint_eq(listLengthS(l),0); 13974 ck_assert_ptr_eq(l[0], NULL); 13975 listFreeS(l); 13976 // NULL list 13977 l = NULL; 13978 r = iicListSortS(&l); 13979 ck_assert_ptr_eq(r, null); 13980 ck_assert_ptr_eq(l, NULL); 13981 // NULL var 13982 r = iicListSortS(NULL); 13983 ck_assert_ptr_eq(r, null); 13984 13985 13986 } 13987 13988 13989 void readTextT(CuTest *tc UNUSED) { 13990 13991 char **l; 13992 13993 // text 13994 l = readText("textTest.null"); 13995 ck_assert_uint_eq(listLengthS(l),2); 13996 ck_assert_str_eq(l[0], "LINE 1"); 13997 ck_assert_str_eq(l[1], "ANOTHER line"); 13998 listFreeS(l); 13999 // empty text 14000 l = readText("chmodTest.null"); 14001 ck_assert_uint_eq(listLengthS(l),0); 14002 ck_assert_ptr_eq(l[0], NULL); 14003 listFreeS(l); 14004 // NULL path 14005 ck_assert_ptr_eq(readText(NULL), NULL); 14006 // non existing path 14007 if (fileExists("nonExistingFile")) { 14008 int R = rmAll("nonExistingFile"); 14009 ck_assert_int_ne(R, 0); 14010 } 14011 ck_assert_ptr_eq(readText("nonExistingFile"), NULL); 14012 14013 } 14014 14015 14016 void readStreamT(CuTest *tc UNUSED) { 14017 14018 char **l; 14019 FILE *fp; 14020 14021 // stream 14022 fp = fopen("textTest.null", "r"); 14023 l = readStream(fp); 14024 fclose(fp); 14025 ck_assert_uint_eq(listLengthS(l),2); 14026 ck_assert_str_eq(l[0], "LINE 1"); 14027 ck_assert_str_eq(l[1], "ANOTHER line"); 14028 listFreeS(l); 14029 // empty stream 14030 fp = fopen("chmodTest.null", "r"); 14031 l = readStream(fp); 14032 fclose(fp); 14033 ck_assert_uint_eq(listLengthS(l),0); 14034 ck_assert_ptr_eq(l[0], NULL); 14035 listFreeS(l); 14036 // NULL stream 14037 ck_assert_ptr_eq(readStream(NULL), NULL); 14038 14039 } 14040 14041 14042 void writeTextT(CuTest *tc UNUSED) { 14043 14044 char **l; 14045 bool r; 14046 14047 // write textOutTest.null 14048 l = readText("textTest.null"); 14049 r = writeText("textOutTest.null", l); 14050 ck_assert(r); 14051 listFreeS(l); 14052 14053 // check textOutTest.null 14054 l = readText("textOutTest.null"); 14055 ck_assert_uint_eq(listLengthS(l),2); 14056 ck_assert_str_eq(l[0], "LINE 1"); 14057 ck_assert_str_eq(l[1], "ANOTHER line"); 14058 // non existing file 14059 // make sure the file doesnt exist 14060 if (fileExists("nonExistingFile")) { 14061 int R = rmAll("nonExistingFile"); 14062 ck_assert_int_ne(R, 0); 14063 } 14064 ck_assert(writeText("nonExistingFile",l)); 14065 if (fileExists("nonExistingFile")) { 14066 int R = rmAll("nonExistingFile"); 14067 ck_assert_int_ne(R, 0); 14068 } 14069 // NULL path 14070 ck_assert(!writeText(NULL,l)); 14071 listFreeS(l); 14072 // NULL list 14073 ck_assert(!writeText("a",NULL)); 14074 14075 } 14076 14077 14078 void writeStreamT(CuTest *tc UNUSED) { 14079 14080 char **l; 14081 FILE *fp; 14082 bool r; 14083 14084 // write textOutTest.null 14085 fp = fopen("textTest.null", "r"); 14086 l = readStream(fp); 14087 fclose(fp); 14088 fp = fopen("textOutTest.null", "w"); 14089 r = writeStream(fp, l); 14090 ck_assert(r); 14091 // NULL list 14092 ck_assert(!writeStream(fp,NULL)); 14093 fclose(fp); 14094 listFreeS(l); 14095 14096 // check textOutTest.null 14097 fp = fopen("textOutTest.null", "r"); 14098 l = readStream(fp); 14099 fclose(fp); 14100 ck_assert_uint_eq(listLengthS(l),2); 14101 ck_assert_str_eq(l[0], "LINE 1"); 14102 ck_assert_str_eq(l[1], "ANOTHER line"); 14103 // NULL stream 14104 ck_assert(!writeStream(NULL,l)); 14105 listFreeS(l); 14106 14107 } 14108 14109 14110 void appendTextT(CuTest *tc UNUSED) { 14111 14112 char **l; 14113 bool r; 14114 14115 // append to textOutTest.null 14116 l = readText("textTest.null"); 14117 r = writeText("textOutTest.null", l); 14118 ck_assert(r); 14119 char **c = listCreateS("A","B"); 14120 r = appendText("textOutTest.null", c); 14121 listFreeManyS(l,c); 14122 14123 // check textOutTest.null 14124 l = readText("textOutTest.null"); 14125 ck_assert_uint_eq(listLengthS(l),4); 14126 ck_assert_str_eq(l[0], "LINE 1"); 14127 ck_assert_str_eq(l[1], "ANOTHER line"); 14128 ck_assert_str_eq(l[2], "A"); 14129 ck_assert_str_eq(l[3], "B"); 14130 // non existing file 14131 // make sure the file doesnt exist 14132 if (fileExists("nonExistingFile")) { 14133 int R = rmAll("nonExistingFile"); 14134 ck_assert_int_ne(R, 0); 14135 } 14136 ck_assert(appendText("nonExistingFile",l)); 14137 if (fileExists("nonExistingFile")) { 14138 int R = rmAll("nonExistingFile"); 14139 ck_assert_int_ne(R, 0); 14140 } 14141 // NULL path 14142 ck_assert(!appendText(NULL,l)); 14143 listFreeS(l); 14144 // NULL list 14145 ck_assert(!appendText("a",NULL)); 14146 14147 } 14148 14149 14150 void listGetST(CuTest *tc UNUSED) { 14151 14152 char **l = NULL; 14153 char **r = null; 14154 14155 // get string 14156 r = listPushS(&l, "1"); 14157 ck_assert_ptr_eq(r, l); 14158 r = listPushS(&l, "22"); 14159 ck_assert_ptr_eq(r, l); 14160 r = listPushS(&l, "333"); 14161 ck_assert_ptr_eq(r, l); 14162 r = listPushS(&l, "4444"); 14163 ck_assert_ptr_eq(r, l); 14164 char *s = listGetS(l, 0); 14165 ck_assert_str_eq(s, "1"); 14166 free(s); 14167 // negative index 14168 s = listGetS(l, -1); 14169 ck_assert_str_eq(s, "4444"); 14170 free(s); 14171 // outside list 14172 ck_assert_ptr_eq(listGetS(l, 10), NULL); 14173 ck_assert_ptr_eq(listGetS(l, -10), NULL); 14174 listFreeS(l); 14175 // negative index in a one element list 14176 l = NULL; 14177 r = listPushS(&l, "ASD"); 14178 ck_assert_ptr_eq(r, l); 14179 r = listPushS(&l, NULL); 14180 ck_assert_ptr_eq(r, null); 14181 s = listGetS(l,-1); 14182 ck_assert_ptr_ne(s, NULL); 14183 free(s); 14184 listFreeS(l); 14185 // empty list 14186 listEmptyS(l) 14187 ck_assert_ptr_eq(listGetS(l,0),NULL); 14188 free(l); 14189 // NULL list 14190 ck_assert_ptr_eq(listGetS(NULL, 0), NULL); 14191 14192 } 14193 14194 14195 void iListGetST(CuTest *tc UNUSED) { 14196 14197 char **l = NULL; 14198 char **r = null; 14199 14200 // get string 14201 r = listPushS(&l, "1"); 14202 ck_assert_ptr_eq(r, l); 14203 r = listPushS(&l, "22"); 14204 ck_assert_ptr_eq(r, l); 14205 r = listPushS(&l, "333"); 14206 ck_assert_ptr_eq(r, l); 14207 r = listPushS(&l, "4444"); 14208 ck_assert_ptr_eq(r, l); 14209 ck_assert_str_eq(iListGetS(l, 0), "1"); 14210 // negative index 14211 ck_assert_str_eq(iListGetS(l, -1), "4444"); 14212 // outside list 14213 ck_assert_ptr_eq(iListGetS(l, 10), NULL); 14214 ck_assert_ptr_eq(iListGetS(l, -10), NULL); 14215 listFreeS(l); 14216 // negative index in a one element list 14217 l = NULL; 14218 r = listPushS(&l, "ASD"); 14219 ck_assert_ptr_eq(r, l); 14220 r = listPushS(&l, NULL); 14221 ck_assert_ptr_eq(r, null); 14222 ck_assert_ptr_ne(iListGetS(l,-1), NULL); 14223 listFreeS(l); 14224 // empty list 14225 listEmptyS(l) 14226 ck_assert_ptr_eq(iListGetS(l,0),NULL); 14227 free(l); 14228 // NULL list 14229 ck_assert_ptr_eq(iListGetS(NULL, 0), NULL); 14230 14231 } 14232 14233 14234 void listSetST(CuTest *tc UNUSED) { 14235 14236 char **l = NULL; 14237 char **r = null; 14238 14239 // get string 14240 r = listPushS(&l, "@@"); 14241 ck_assert_ptr_eq(r, l); 14242 r = listPushS(&l, "22"); 14243 ck_assert_ptr_eq(r, l); 14244 r = listPushS(&l, "|"); 14245 ck_assert_ptr_eq(r, l); 14246 r = listPushS(&l, "4444"); 14247 ck_assert_ptr_eq(r, l); 14248 r = listSetS(l, 0, "1"); 14249 ck_assert_ptr_eq(r, l); 14250 char *s = listGetS(l, 0); 14251 ck_assert_str_eq(s, "1"); 14252 free(s); 14253 // negative index 14254 r = listSetS(l, -2, "333"); 14255 ck_assert_ptr_eq(r, l); 14256 s = listGetS(l, -2); 14257 ck_assert_str_eq(s, "333"); 14258 free(s); 14259 // outside list 14260 // list is unchanged 14261 r = listSetS(l, 10, "QWE"); 14262 ck_assert_ptr_eq(r, null); 14263 r = listSetS(l, -10, "QWE"); 14264 ck_assert_ptr_eq(r, null); 14265 // NULL s string 14266 r = listSetS(l, -2, NULL); 14267 ck_assert_ptr_eq(r, null); 14268 ck_assert_str_eq(l[0], "1"); 14269 ck_assert_str_eq(l[1], "22"); 14270 ck_assert_str_eq(l[2], "333"); 14271 ck_assert_str_eq(l[3], "4444"); 14272 listFreeS(l); 14273 // negative index in a one element list 14274 l = NULL; 14275 r = listPushS(&l, "ASD"); 14276 ck_assert_ptr_eq(r, l); 14277 r = listPushS(&l, NULL); 14278 ck_assert_ptr_eq(r, null); 14279 r = listSetS(l, -1, "QWE"); 14280 ck_assert_ptr_eq(r, l); 14281 s = listGetS(l,-1); 14282 ck_assert_str_eq(s, "QWE"); 14283 free(s); 14284 listFreeS(l); 14285 // empty list - should not crash 14286 listEmptyS(l) 14287 r = listSetS(l, 0, "QWE"); 14288 ck_assert_ptr_eq(r, null); 14289 ck_assert_ptr_eq(listGetS(l,0),NULL); 14290 free(l); 14291 // NULL list 14292 r = listSetS(NULL, 0, "QWE"); 14293 ck_assert_ptr_eq(r, null); 14294 ck_assert_ptr_eq(listGetS(NULL, 0), NULL); 14295 14296 } 14297 14298 14299 void listSetCharST(CuTest *tc UNUSED) { 14300 14301 char **l = NULL; 14302 char **r = null; 14303 14304 // get string 14305 r = listPushS(&l, "@@"); 14306 ck_assert_ptr_eq(r, l); 14307 r = listPushS(&l, "22"); 14308 ck_assert_ptr_eq(r, l); 14309 r = listPushS(&l, "|"); 14310 ck_assert_ptr_eq(r, l); 14311 r = listPushS(&l, "4444"); 14312 ck_assert_ptr_eq(r, l); 14313 r = listSetCharS(l, 0, '1'); 14314 ck_assert_ptr_eq(r, l); 14315 char *s = listGetS(l, 0); 14316 ck_assert_str_eq(s, "1"); 14317 free(s); 14318 // negative index 14319 r = listSetCharS(l, -2, '3'); 14320 ck_assert_ptr_eq(r, l); 14321 s = listGetS(l, -2); 14322 ck_assert_str_eq(s, "3"); 14323 free(s); 14324 // outside list 14325 // list is unchanged 14326 r = listSetCharS(l, 10, 'Q'); 14327 ck_assert_ptr_eq(r, null); 14328 r = listSetCharS(l, -10, 'Q'); 14329 ck_assert_ptr_eq(r, null); 14330 ck_assert_str_eq(l[0], "1"); 14331 ck_assert_str_eq(l[1], "22"); 14332 ck_assert_str_eq(l[2], "3"); 14333 ck_assert_str_eq(l[3], "4444"); 14334 listFreeS(l); 14335 // negative index in a one element list 14336 l = NULL; 14337 r = listPushS(&l, "ASD"); 14338 ck_assert_ptr_eq(r, l); 14339 r = listPushS(&l, NULL); 14340 ck_assert_ptr_eq(r, null); 14341 r = listSetCharS(l, -1, 'Q'); 14342 ck_assert_ptr_eq(r, l); 14343 s = listGetS(l,-1); 14344 ck_assert_str_eq(s, "Q"); 14345 free(s); 14346 listFreeS(l); 14347 // empty list - should not crash 14348 listEmptyS(l) 14349 r = listSetCharS(l, 0, 'Q'); 14350 ck_assert_ptr_eq(r, null); 14351 ck_assert_ptr_eq(listGetS(l,0),NULL); 14352 free(l); 14353 // NULL list 14354 r = listSetCharS(NULL, 0, 'Q'); 14355 ck_assert_ptr_eq(r, null); 14356 ck_assert_ptr_eq(listGetS(NULL, 0), NULL); 14357 14358 14359 } 14360 14361 14362 void iListSetST(CuTest *tc UNUSED) { 14363 14364 char **l = NULL; 14365 char *s; 14366 char **r = null; 14367 14368 // set string 14369 r = listPushS(&l, "@@"); 14370 ck_assert_ptr_eq(r, l); 14371 r = listPushS(&l, "22"); 14372 ck_assert_ptr_eq(r, l); 14373 r = listPushS(&l, "|"); 14374 ck_assert_ptr_eq(r, l); 14375 r = listPushS(&l, "4444"); 14376 ck_assert_ptr_eq(r, l); 14377 s = strdup("1"); 14378 r = iListSetS(l, 0, s); 14379 ck_assert_ptr_eq(r, l); 14380 ck_assert_str_eq(iListGetS(l, 0), "1"); 14381 // negative index 14382 s = strdup("333"); 14383 r = iListSetS(l, -2, s); 14384 ck_assert_ptr_eq(r, l); 14385 ck_assert_str_eq(iListGetS(l, -2), "333"); 14386 // outside list 14387 // list is unchanged 14388 s = strdup("QWE"); 14389 r = iListSetS(l, 10, s); 14390 ck_assert_ptr_eq(r, null); 14391 r = iListSetS(l, -10, s); 14392 ck_assert_ptr_eq(r, null); 14393 free(s); 14394 // NULL s string 14395 s = NULL; 14396 r = iListSetS(l, -2, s); 14397 ck_assert_ptr_eq(r, null); 14398 // NULL s var 14399 r = iListSetS(l, -2, NULL); 14400 ck_assert_ptr_eq(r, null); 14401 ck_assert_str_eq(l[0], "1"); 14402 ck_assert_str_eq(l[1], "22"); 14403 ck_assert_str_eq(l[2], "333"); 14404 ck_assert_str_eq(l[3], "4444"); 14405 listFreeS(l); 14406 // negative index in a one element list 14407 l = NULL; 14408 r = listPushS(&l, "ASD"); 14409 ck_assert_ptr_eq(r, l); 14410 r = listPushS(&l, NULL); 14411 ck_assert_ptr_eq(r, null); 14412 s = strdup("QWE"); 14413 r = iListSetS(l, -1, s); 14414 ck_assert_ptr_eq(r, l); 14415 ck_assert_str_eq(iListGetS(l,-1), "QWE"); 14416 listFreeS(l); 14417 // empty list - should not crash 14418 listEmptyS(l) 14419 s = strdup("QWE"); 14420 r = iListSetS(l, 0, s); 14421 ck_assert_ptr_eq(r, null); 14422 ck_assert_ptr_eq(listGetS(l,0),NULL); 14423 free(s); 14424 free(l); 14425 // NULL list 14426 s = strdup("QWE"); 14427 r = iListSetS(NULL, 0, s); 14428 ck_assert_ptr_eq(r, null); 14429 ck_assert_ptr_eq(listGetS(NULL, 0), NULL); 14430 free(s); 14431 14432 } 14433 14434 14435 void listSwapST(CuTest *tc UNUSED) { 14436 14437 char **l = null; 14438 char **r; 14439 14440 r = listPushS(&l, "lib"); 14441 ck_assert_ptr_eq(r, l); 14442 r = listPushS(&l, "sheepy"); 14443 ck_assert_ptr_eq(r, l); 14444 r = listPushS(&l, "spm"); 14445 ck_assert_ptr_eq(r, l); 14446 // positive index 14447 r = listSwapS(l, 0, 2); 14448 ck_assert_str_eq(r[0], "spm"); 14449 ck_assert_str_eq(r[1], "sheepy"); 14450 ck_assert_str_eq(r[2], "lib"); 14451 listFreeS(r); 14452 // negative index 14453 r = listSwapS(l, -1, 1); 14454 ck_assert_str_eq(r[0], "lib"); 14455 ck_assert_str_eq(r[1], "spm"); 14456 ck_assert_str_eq(r[2], "sheepy"); 14457 listFreeS(r); 14458 r = listSwapS(l, -3, 1); 14459 ck_assert_str_eq(r[0], "sheepy"); 14460 ck_assert_str_eq(r[1], "lib"); 14461 ck_assert_str_eq(r[2], "spm"); 14462 listFreeS(r); 14463 // swap equal indexes 14464 r = listSwapS(l, -3, -3); 14465 ck_assert_str_eq(r[0], "lib"); 14466 ck_assert_str_eq(r[1], "sheepy"); 14467 ck_assert_str_eq(r[2], "spm"); 14468 listFreeS(r); 14469 r = listSwapS(&l[2], 0, -1); 14470 ck_assert_str_eq(r[0], "spm"); 14471 listFreeS(r); 14472 // 1 element list 14473 // outside length 14474 r = listSwapS(l, 0, 3); 14475 ck_assert_ptr_eq(r, null); 14476 r = listSwapS(l, 0, -4); 14477 ck_assert_ptr_eq(r, null); 14478 r = listSwapS(l, 3, 0); 14479 ck_assert_ptr_eq(r, null); 14480 r = listSwapS(l, -4, 0); 14481 ck_assert_ptr_eq(r, null); 14482 listFreeS(l); 14483 // length 0 14484 listEmptyS(l); 14485 r = listSwapS(l, -1, 0); 14486 ck_assert_ptr_eq(r, null); 14487 listFreeS(l); 14488 // null list 14489 ck_assert_ptr_eq(listSwapS(NULL, 1, 1), null); 14490 14491 14492 } 14493 14494 14495 void iListSwapST(CuTest *tc UNUSED) { 14496 14497 char **l = null; 14498 char **r; 14499 14500 r = listPushS(&l, "lib"); 14501 ck_assert_ptr_eq(r, l); 14502 r = listPushS(&l, "sheepy"); 14503 ck_assert_ptr_eq(r, l); 14504 r = listPushS(&l, "spm"); 14505 ck_assert_ptr_eq(r, l); 14506 // positive index 14507 r = iListSwapS(l, 0, 2); 14508 ck_assert_str_eq(r[0], "spm"); 14509 ck_assert_str_eq(r[1], "sheepy"); 14510 ck_assert_str_eq(r[2], "lib"); 14511 // negative index 14512 r = iListSwapS(l, -1, 1); 14513 ck_assert_str_eq(r[0], "spm"); 14514 ck_assert_str_eq(r[1], "lib"); 14515 ck_assert_str_eq(r[2], "sheepy"); 14516 r = iListSwapS(l, -3, 1); 14517 ck_assert_str_eq(r[0], "lib"); 14518 ck_assert_str_eq(r[1], "spm"); 14519 ck_assert_str_eq(r[2], "sheepy"); 14520 // swap equal indexes 14521 r = iListSwapS(l, -3, -3); 14522 ck_assert_str_eq(r[0], "lib"); 14523 ck_assert_str_eq(r[1], "spm"); 14524 ck_assert_str_eq(r[2], "sheepy"); 14525 r = iListSwapS(&l[2], 0, -1); 14526 ck_assert_str_eq(r[0], "sheepy"); 14527 // 1 element list 14528 // outside length 14529 r = iListSwapS(l, 0, 3); 14530 ck_assert_ptr_eq(r, null); 14531 r = iListSwapS(l, 0, -4); 14532 ck_assert_ptr_eq(r, null); 14533 r = iListSwapS(l, 3, 0); 14534 ck_assert_ptr_eq(r, null); 14535 r = iListSwapS(l, -4, 0); 14536 ck_assert_ptr_eq(r, null); 14537 listFreeS(l); 14538 // length 0 14539 listEmptyS(l); 14540 r = iListSwapS(l, -1, 0); 14541 ck_assert_ptr_eq(r, null); 14542 listFreeS(l); 14543 // null list 14544 ck_assert_ptr_eq(iListSwapS(NULL, 1, 1), null); 14545 14546 14547 } 14548 14549 14550 void splitT(CuTest *tc UNUSED) { 14551 14552 char **l; 14553 14554 // string 14555 l = split("one/two", "/"); 14556 ck_assert_uint_eq(listLengthS(l),2); 14557 ck_assert_str_eq(l[0], "one"); 14558 ck_assert_str_eq(l[1], "two"); 14559 listFreeS(l); 14560 // delimiter on the edge 14561 l = split("/one", "/"); 14562 ck_assert_uint_eq(listLengthS(l),2); 14563 ck_assert_str_eq(l[0], ""); 14564 ck_assert_str_eq(l[1], "one"); 14565 listFreeS(l); 14566 l = split("one/", "/"); 14567 ck_assert_uint_eq(listLengthS(l),2); 14568 ck_assert_str_eq(l[0], "one"); 14569 ck_assert_str_eq(l[1], ""); 14570 listFreeS(l); 14571 // delimiter not found 14572 l = split("one/two", "||"); 14573 ck_assert_uint_eq(listLengthS(l),1); 14574 ck_assert_str_eq(l[0], "one/two"); 14575 listFreeS(l); 14576 // split with several delimiters after each other 14577 l = split("one/two three ", " "); 14578 ck_assert_uint_eq(listLengthS(l),4); 14579 ck_assert_str_eq(l[0], "one/two"); 14580 ck_assert_str_eq(l[1], ""); 14581 ck_assert_str_eq(l[2], "three"); 14582 ck_assert_str_eq(l[3], ""); 14583 listFreeS(l); 14584 // multiple character delimiter 14585 l = split("AAe three extract", "e "); 14586 ck_assert_uint_eq(listLengthS(l),3); 14587 ck_assert_str_eq(l[0], "AA"); 14588 ck_assert_str_eq(l[1], "thre"); 14589 ck_assert_str_eq(l[2], "extract"); 14590 listFreeS(l); 14591 // empty delimiter 14592 l = split("AAd", ""); 14593 ck_assert_uint_eq(listLengthS(l),1); 14594 ck_assert_str_eq(l[0], "AAd"); 14595 listFreeS(l); 14596 // empty string 14597 l = split("", "$"); 14598 ck_assert_uint_eq(listLengthS(l),1); 14599 ck_assert_str_eq(l[0], ""); 14600 listFreeS(l); 14601 // NULL list 14602 ck_assert_ptr_eq(split(NULL, ";"), NULL); 14603 // NULL delimiter 14604 ck_assert_ptr_eq(split("test", NULL), NULL); 14605 14606 } 14607 14608 14609 void splitCharT(CuTest *tc UNUSED) { 14610 14611 char **l; 14612 14613 // string 14614 l = splitChar("one/two", '/'); 14615 ck_assert_uint_eq(listLengthS(l),2); 14616 ck_assert_str_eq(l[0], "one"); 14617 ck_assert_str_eq(l[1], "two"); 14618 listFreeS(l); 14619 // delimiter on the edge 14620 l = splitChar("/one", '/'); 14621 ck_assert_uint_eq(listLengthS(l),2); 14622 ck_assert_str_eq(l[0], ""); 14623 ck_assert_str_eq(l[1], "one"); 14624 listFreeS(l); 14625 l = splitChar("one/", '/'); 14626 ck_assert_uint_eq(listLengthS(l),2); 14627 ck_assert_str_eq(l[0], "one"); 14628 ck_assert_str_eq(l[1], ""); 14629 listFreeS(l); 14630 // delimiter not found 14631 l = splitChar("one/two", '|'); 14632 ck_assert_uint_eq(listLengthS(l),1); 14633 ck_assert_str_eq(l[0], "one/two"); 14634 listFreeS(l); 14635 // split with several delimiters after each other 14636 l = splitChar("one/two three ", ' '); 14637 ck_assert_uint_eq(listLengthS(l),4); 14638 ck_assert_str_eq(l[0], "one/two"); 14639 ck_assert_str_eq(l[1], ""); 14640 ck_assert_str_eq(l[2], "three"); 14641 ck_assert_str_eq(l[3], ""); 14642 listFreeS(l); 14643 // empty string 14644 l = splitChar("", '$'); 14645 ck_assert_uint_eq(listLengthS(l),1); 14646 ck_assert_str_eq(l[0], ""); 14647 listFreeS(l); 14648 // NULL list 14649 ck_assert_ptr_eq(splitChar(NULL, ';'), NULL); 14650 14651 14652 } 14653 14654 14655 void icSplitT(CuTest *tc UNUSED) { 14656 14657 char **l; 14658 14659 // string 14660 l = icSplit("one/two", "/"); 14661 ck_assert_uint_eq(listLengthS(l),2); 14662 ck_assert_str_eq(l[0], "one"); 14663 ck_assert_str_eq(l[1], "two"); 14664 listFreeS(l); 14665 // delimiter on the edge 14666 l = icSplit("/one", "/"); 14667 ck_assert_uint_eq(listLengthS(l),2); 14668 ck_assert_str_eq(l[0], ""); 14669 ck_assert_str_eq(l[1], "one"); 14670 listFreeS(l); 14671 l = icSplit("one/", "/"); 14672 ck_assert_uint_eq(listLengthS(l),2); 14673 ck_assert_str_eq(l[0], "one"); 14674 ck_assert_str_eq(l[1], ""); 14675 listFreeS(l); 14676 // delimiter not found 14677 l = icSplit("one/two", "||"); 14678 ck_assert_uint_eq(listLengthS(l),1); 14679 ck_assert_str_eq(l[0], "one/two"); 14680 listFreeS(l); 14681 // split with several delimiters after each other 14682 l = icSplit("one/two three ", " "); 14683 ck_assert_uint_eq(listLengthS(l),4); 14684 ck_assert_str_eq(l[0], "one/two"); 14685 ck_assert_str_eq(l[1], ""); 14686 ck_assert_str_eq(l[2], "three"); 14687 ck_assert_str_eq(l[3], ""); 14688 listFreeS(l); 14689 // multiple character delimiter 14690 l = icSplit("AAe three extract", "e "); 14691 ck_assert_uint_eq(listLengthS(l),3); 14692 ck_assert_str_eq(l[0], "AA"); 14693 ck_assert_str_eq(l[1], "thre"); 14694 ck_assert_str_eq(l[2], "extract"); 14695 listFreeS(l); 14696 // empty delimiter 14697 l = icSplit("AAd", ""); 14698 ck_assert_uint_eq(listLengthS(l),1); 14699 ck_assert_str_eq(l[0], "AAd"); 14700 listFreeS(l); 14701 // empty string 14702 l = icSplit("", "$"); 14703 ck_assert_uint_eq(listLengthS(l),1); 14704 ck_assert_str_eq(l[0], ""); 14705 listFreeS(l); 14706 // NULL list 14707 ck_assert_ptr_eq(icSplit(NULL, ";"), NULL); 14708 // NULL delimiter 14709 ck_assert_ptr_eq(icSplit("test", NULL), NULL); 14710 14711 14712 } 14713 14714 14715 void icSplitCharT(CuTest *tc UNUSED) { 14716 14717 char **l; 14718 14719 // string 14720 l = icSplitChar("one/two", '/'); 14721 ck_assert_uint_eq(listLengthS(l),2); 14722 ck_assert_str_eq(l[0], "one"); 14723 ck_assert_str_eq(l[1], "two"); 14724 listFreeS(l); 14725 // delimiter on the edge 14726 l = icSplitChar("/one", '/'); 14727 ck_assert_uint_eq(listLengthS(l),2); 14728 ck_assert_str_eq(l[0], ""); 14729 ck_assert_str_eq(l[1], "one"); 14730 listFreeS(l); 14731 l = icSplitChar("one/", '/'); 14732 ck_assert_uint_eq(listLengthS(l),2); 14733 ck_assert_str_eq(l[0], "one"); 14734 ck_assert_str_eq(l[1], ""); 14735 listFreeS(l); 14736 // delimiter not found 14737 l = icSplitChar("one/two", '|'); 14738 ck_assert_uint_eq(listLengthS(l),1); 14739 ck_assert_str_eq(l[0], "one/two"); 14740 listFreeS(l); 14741 // split with several delimiters after each other 14742 l = icSplitChar("one/two three ", ' '); 14743 ck_assert_uint_eq(listLengthS(l),4); 14744 ck_assert_str_eq(l[0], "one/two"); 14745 ck_assert_str_eq(l[1], ""); 14746 ck_assert_str_eq(l[2], "three"); 14747 ck_assert_str_eq(l[3], ""); 14748 listFreeS(l); 14749 // empty string 14750 l = icSplitChar("", '$'); 14751 ck_assert_uint_eq(listLengthS(l),1); 14752 ck_assert_str_eq(l[0], ""); 14753 listFreeS(l); 14754 // NULL list 14755 ck_assert_ptr_eq(icSplitChar(NULL, ';'), NULL); 14756 14757 14758 } 14759 14760 14761 void joinLengthT(CuTest *tc UNUSED) { 14762 14763 ssize_t r; 14764 char **l = listCreateS("","lib","sheepy"); 14765 char *s; 14766 14767 r = joinLength(l, "/"); 14768 s = join(l, "/"); 14769 ck_assert_int_eq(r, strlen(s)); 14770 free(s); 14771 listFreeS(l); 14772 // empty list 14773 listEmptyS(l) 14774 r = joinLength(l, "/"); 14775 ck_assert_int_eq(r, 0); 14776 listFreeS(l); 14777 // NULL delimiter 14778 ck_assert_int_eq(joinLength(l, NULL), -1); 14779 // NULL list 14780 ck_assert_int_eq(joinLength(NULL, ";"), -1); 14781 14782 } 14783 14784 14785 void joinT(CuTest *tc UNUSED) { 14786 14787 char **l; 14788 char *s; 14789 char **r = null; 14790 14791 // list 14792 l = split("one/two", "/"); 14793 s = join(l, "/"); 14794 ck_assert_str_eq(s, "one/two"); 14795 // NULL delimiter 14796 ck_assert_ptr_eq(join(l, NULL), NULL); 14797 listFreeS(l); 14798 free(s); 14799 // empty list 14800 listEmptyS(l) 14801 s = join(l, "/"); 14802 ck_assert(isEmptyS(s)); 14803 listFreeS(l); 14804 free(s); 14805 // NULL list 14806 ck_assert_ptr_eq(join(NULL, ";"), NULL); 14807 // list with NULL first element 14808 l = NULL; 14809 r = listPushS(&l, NULL); 14810 ck_assert_ptr_eq(r, l); 14811 ck_assert_ptr_eq(join(l, "/"), NULL); 14812 listFreeS(l); 14813 14814 } 14815 14816 14817 void joinCharT(CuTest *tc UNUSED) { 14818 14819 char **l; 14820 char *s; 14821 14822 // list 14823 l = split("one/two", "/"); 14824 s = joinChar(l, '/'); 14825 ck_assert_str_eq(s, "one/two"); 14826 listFreeS(l); 14827 free(s); 14828 // empty list 14829 listEmptyS(l) 14830 s = joinChar(l, '/'); 14831 ck_assert(isEmptyS(s)); 14832 listFreeS(l); 14833 free(s); 14834 // NULL list 14835 ck_assert_ptr_eq(joinChar(NULL, ';'), NULL); 14836 14837 14838 } 14839 14840 14841 void bJoinT(CuTest *tc UNUSED) { 14842 14843 char **l; 14844 char s[100]; 14845 char **r = null; 14846 char *r2 = null; 14847 14848 // list 14849 l = split("one/two", "/"); 14850 r2 = bJoin(s, l, "/"); 14851 ck_assert_ptr_eq(r2, s); 14852 ck_assert_str_eq(s, "one/two"); 14853 // NULL delimiter 14854 r2 = bJoin(s, l, NULL); 14855 ck_assert_ptr_eq(r2, null); 14856 listFreeS(l); 14857 // empty list 14858 listEmptyS(l) 14859 r2 = bJoin(s, l, "/"); 14860 ck_assert_ptr_eq(r2, null); 14861 ck_assert_str_eq(s, "one/two"); 14862 listFreeS(l); 14863 // NULL list 14864 r2 = bJoin(s, NULL, ";"); 14865 ck_assert_ptr_eq(r2, null); 14866 // list with NULL first element 14867 l = NULL; 14868 r = listPushS(&l, NULL); 14869 ck_assert_ptr_eq(r, l); 14870 r2 = bJoin(s, l, "/"); 14871 ck_assert_ptr_eq(r2, null); 14872 listFreeS(l); 14873 14874 } 14875 14876 14877 void bJoinCharT(CuTest *tc UNUSED) { 14878 14879 char **l; 14880 char s[100]; 14881 char *r = null; 14882 14883 // list 14884 l = split("one/two", "/"); 14885 r = bJoinChar(s, l, '/'); 14886 ck_assert_ptr_eq(r, s); 14887 ck_assert_str_eq(s, "one/two"); 14888 listFreeS(l); 14889 // empty list 14890 listEmptyS(l) 14891 r = bJoinChar(s, l, '/'); 14892 ck_assert_ptr_eq(r, null); 14893 ck_assert_str_eq(s, "one/two"); 14894 listFreeS(l); 14895 // NULL list 14896 r = bJoinChar(s, NULL, ';'); 14897 ck_assert_ptr_eq(r, null); 14898 14899 14900 } 14901 14902 14903 void bLJoinT(CuTest *tc UNUSED) { 14904 14905 char **l; 14906 char s[100]; 14907 char **r = null; 14908 char *r2 = null; 14909 14910 // list 14911 l = split("one/two", "/"); 14912 r2 = bLJoin(s, sizeof s, l, "/"); 14913 ck_assert_ptr_eq(r2, s); 14914 ck_assert_str_eq(s, "one/two"); 14915 // shorter buffer 14916 r2 = bLJoin(s, 5, l, "/"); 14917 ck_assert_ptr_eq(r2, s); 14918 ck_assert_str_eq(s, "one/"); 14919 // size 0 - no change 14920 r2 = bLJoin(s, 0, l, "/"); 14921 ck_assert_ptr_eq(r2, s); 14922 ck_assert_str_eq(s, "one/"); 14923 // NULL delimiter 14924 r2 = bLJoin(s, sizeof s, l, NULL); 14925 ck_assert_ptr_eq(r2, null); 14926 listFreeS(l); 14927 // empty list 14928 listEmptyS(l) 14929 r2 = bLJoin(s, sizeof s, l, "/"); 14930 ck_assert_ptr_eq(r2, null); 14931 ck_assert_str_eq(s, "one/"); 14932 listFreeS(l); 14933 // NULL list 14934 r2 = bLJoin(s, sizeof s, NULL, ";"); 14935 ck_assert_ptr_eq(r2, null); 14936 // list with NULL first element 14937 l = NULL; 14938 r = listPushS(&l, NULL); 14939 ck_assert_ptr_eq(r, l); 14940 r2 = bLJoin(s, sizeof s, l, "/"); 14941 ck_assert_ptr_eq(r2, null); 14942 listFreeS(l); 14943 14944 } 14945 14946 14947 void bLJoinCharT(CuTest *tc UNUSED) { 14948 14949 char **l; 14950 char s[100]; 14951 char *r = null; 14952 14953 // list 14954 l = split("one/two", "/"); 14955 r = bLJoinChar(s, sizeof s, l, '/'); 14956 ck_assert_ptr_eq(r, s); 14957 ck_assert_str_eq(s, "one/two"); 14958 // shorter buffer 14959 r = bLJoinChar(s, 5, l, '/'); 14960 ck_assert_ptr_eq(r, s); 14961 ck_assert_str_eq(s, "one/"); 14962 // size 0 - no change 14963 r = bLJoinChar(s, 0, l, '/'); 14964 ck_assert_ptr_eq(r, s); 14965 ck_assert_str_eq(s, "one/"); 14966 listFreeS(l); 14967 // empty list 14968 listEmptyS(l) 14969 r = bLJoinChar(s, sizeof s, l, '/'); 14970 ck_assert_ptr_eq(r, null); 14971 ck_assert_str_eq(s, "one/"); 14972 listFreeS(l); 14973 // NULL list 14974 r = bLJoinChar(s, sizeof s, NULL, ';'); 14975 ck_assert_ptr_eq(r, null); 14976 14977 14978 } 14979 14980 14981 void extractST(CuTest *tc UNUSED) { 14982 14983 char **l; 14984 14985 // string 14986 l = extractS("one/two|", "/", "|"); 14987 ck_assert_uint_eq(listLengthS(l),1); 14988 ck_assert_str_eq(l[0], "two"); 14989 listFreeS(l); 14990 // delimiter not found 14991 l = extractS("one/two", "||", "/"); 14992 ck_assert_ptr_eq(l, NULL); 14993 // extractS with several delimiters after each other 14994 l = extractS("one/ two /three ", "/", " "); 14995 ck_assert_uint_eq(listLengthS(l),2); 14996 ck_assert_str_eq(l[0], ""); 14997 ck_assert_str_eq(l[1], "three"); 14998 listFreeS(l); 14999 // multiple character delimiter 15000 l = extractS("AAe thre|e extract", "e ", "|"); 15001 ck_assert_uint_eq(listLengthS(l),1); 15002 ck_assert_str_eq(l[0], "thre"); 15003 listFreeS(l); 15004 // empty delimiter 15005 l = extractS("AAd", "", "Ad"); 15006 ck_assert_ptr_eq(l, NULL); 15007 l = extractS("AAd", "A", ""); 15008 ck_assert_ptr_eq(l, NULL); 15009 // empty string 15010 l = extractS("", "$", "#"); 15011 ck_assert_ptr_eq(l, NULL); 15012 // delim1 = delim2 15013 l = extractS("", "$", "$"); 15014 ck_assert_ptr_eq(l, NULL); 15015 // NULL string 15016 ck_assert_ptr_eq(extractS(NULL, ";", ","), NULL); 15017 // NULL delimiter 15018 ck_assert_ptr_eq(extractS("test", NULL, ","), NULL); 15019 ck_assert_ptr_eq(extractS("test", ",", NULL), NULL); 15020 15021 } 15022 15023 15024 void extractCharSST(CuTest *tc UNUSED) { 15025 15026 char **l; 15027 15028 // string 15029 l = extractCharSS("one/two|", '/', "|"); 15030 ck_assert_uint_eq(listLengthS(l),1); 15031 ck_assert_str_eq(l[0], "two"); 15032 listFreeS(l); 15033 // delimiter not found 15034 l = extractCharSS("one/two", '|', "/"); 15035 ck_assert_ptr_eq(l, NULL); 15036 // extractCharSS with several delimiters after each other 15037 l = extractCharSS("one/ two /three ", '/', " "); 15038 ck_assert_uint_eq(listLengthS(l),2); 15039 ck_assert_str_eq(l[0], ""); 15040 ck_assert_str_eq(l[1], "three"); 15041 listFreeS(l); 15042 // empty string 15043 l = extractCharSS("", '$', "#"); 15044 ck_assert_ptr_eq(l, NULL); 15045 // delim1 = delim2 15046 l = extractCharSS("", '$', "$"); 15047 ck_assert_ptr_eq(l, NULL); 15048 // NULL string 15049 ck_assert_ptr_eq(extractCharSS(NULL, ';', ","), NULL); 15050 // NULL delimiter 15051 ck_assert_ptr_eq(extractCharSS("test", ',', NULL), NULL); 15052 15053 15054 } 15055 15056 15057 void extractSCharST(CuTest *tc UNUSED) { 15058 15059 char **l; 15060 15061 // string 15062 l = extractSCharS("one/two|", "/", '|'); 15063 ck_assert_uint_eq(listLengthS(l),1); 15064 ck_assert_str_eq(l[0], "two"); 15065 listFreeS(l); 15066 // delimiter not found 15067 l = extractSCharS("one/two", "||", '/'); 15068 ck_assert_ptr_eq(l, NULL); 15069 // extractSCharS with several delimiters after each other 15070 l = extractSCharS("one/ two /three ", "/", ' '); 15071 ck_assert_uint_eq(listLengthS(l),2); 15072 ck_assert_str_eq(l[0], ""); 15073 ck_assert_str_eq(l[1], "three"); 15074 listFreeS(l); 15075 // multiple character delimiter 15076 l = extractSCharS("AAe thre|e extract", "e ", '|'); 15077 ck_assert_uint_eq(listLengthS(l),1); 15078 ck_assert_str_eq(l[0], "thre"); 15079 listFreeS(l); 15080 // empty delimiter 15081 l = extractSCharS("AAd", "", 'A'); 15082 ck_assert_ptr_eq(l, NULL); 15083 // empty string 15084 l = extractSCharS("", "$", '#'); 15085 ck_assert_ptr_eq(l, NULL); 15086 // delim1 = delim2 15087 l = extractSCharS("", "$", '$'); 15088 ck_assert_ptr_eq(l, NULL); 15089 // NULL string 15090 ck_assert_ptr_eq(extractSCharS(NULL, ";", ','), NULL); 15091 // NULL delimiter 15092 ck_assert_ptr_eq(extractSCharS("test", NULL, ','), NULL); 15093 15094 15095 } 15096 15097 15098 void extractCharCharST(CuTest *tc UNUSED) { 15099 15100 char **l; 15101 15102 // string 15103 l = extractCharCharS("one/two|", '/', '|'); 15104 ck_assert_uint_eq(listLengthS(l),1); 15105 ck_assert_str_eq(l[0], "two"); 15106 listFreeS(l); 15107 // delimiter not found 15108 l = extractCharCharS("one/two", '|', '/'); 15109 ck_assert_ptr_eq(l, NULL); 15110 // extractCharCharS with several delimiters after each other 15111 l = extractCharCharS("one/ two /three ", '/', ' '); 15112 ck_assert_uint_eq(listLengthS(l),2); 15113 ck_assert_str_eq(l[0], ""); 15114 ck_assert_str_eq(l[1], "three"); 15115 listFreeS(l); 15116 // empty string 15117 l = extractCharCharS("", '$', '#'); 15118 ck_assert_ptr_eq(l, NULL); 15119 // delim1 = delim2 15120 l = extractCharCharS("", '$', '$'); 15121 ck_assert_ptr_eq(l, NULL); 15122 // NULL string 15123 ck_assert_ptr_eq(extractCharCharS(NULL, ';', ','), NULL); 15124 15125 15126 } 15127 15128 15129 void icExtractST(CuTest *tc UNUSED) { 15130 15131 char **l; 15132 15133 // string 15134 l = icExtractS("one/two|", "/", "|"); 15135 ck_assert_uint_eq(listLengthS(l),1); 15136 ck_assert_str_eq(l[0], "two"); 15137 listFreeS(l); 15138 // delimiter not found 15139 l = icExtractS("one/two", "||", "/"); 15140 ck_assert_ptr_eq(l, NULL); 15141 // icExtractS with several delimiters after each other 15142 l = icExtractS("one/ two /three ", "/", " "); 15143 ck_assert_uint_eq(listLengthS(l),2); 15144 ck_assert_str_eq(l[0], ""); 15145 ck_assert_str_eq(l[1], "three"); 15146 listFreeS(l); 15147 // multiple character delimiter 15148 l = icExtractS("AAe thre|e extract", "E ", "|"); 15149 ck_assert_uint_eq(listLengthS(l),1); 15150 ck_assert_str_eq(l[0], "thre"); 15151 listFreeS(l); 15152 // empty delimiter 15153 l = icExtractS("AAd", "", "Ad"); 15154 ck_assert_ptr_eq(l, NULL); 15155 l = icExtractS("AAd", "A", ""); 15156 ck_assert_ptr_eq(l, NULL); 15157 // empty string 15158 l = icExtractS("", "$", "#"); 15159 ck_assert_ptr_eq(l, NULL); 15160 // delim1 = delim2 15161 l = icExtractS("", "$", "$"); 15162 ck_assert_ptr_eq(l, NULL); 15163 // NULL string 15164 ck_assert_ptr_eq(icExtractS(NULL, ";", ","), NULL); 15165 // NULL delimiter 15166 ck_assert_ptr_eq(icExtractS("test", NULL, ","), NULL); 15167 ck_assert_ptr_eq(icExtractS("test", ",", NULL), NULL); 15168 15169 15170 } 15171 15172 15173 void icExtractCharSST(CuTest *tc UNUSED) { 15174 15175 char **l; 15176 15177 // string 15178 l = icExtractCharSS("one/two|", '/', "|"); 15179 ck_assert_uint_eq(listLengthS(l),1); 15180 ck_assert_str_eq(l[0], "two"); 15181 listFreeS(l); 15182 // delimiter not found 15183 l = icExtractCharSS("one/two", '|', "/"); 15184 ck_assert_ptr_eq(l, NULL); 15185 // icExtractCharSS with several delimiters after each other 15186 l = icExtractCharSS("one/ two /three ", '/', " "); 15187 ck_assert_uint_eq(listLengthS(l),2); 15188 ck_assert_str_eq(l[0], ""); 15189 ck_assert_str_eq(l[1], "three"); 15190 listFreeS(l); 15191 // empty string 15192 l = icExtractCharSS("", '$', "#"); 15193 ck_assert_ptr_eq(l, NULL); 15194 // delim1 = delim2 15195 l = icExtractCharSS("", '$', "$"); 15196 ck_assert_ptr_eq(l, NULL); 15197 // NULL string 15198 ck_assert_ptr_eq(icExtractCharSS(NULL, ';', ","), NULL); 15199 // NULL delimiter 15200 ck_assert_ptr_eq(icExtractCharSS("test", ',', NULL), NULL); 15201 15202 15203 } 15204 15205 15206 void icExtractSCharST(CuTest *tc UNUSED) { 15207 15208 char **l; 15209 15210 // string 15211 l = icExtractSCharS("one/two|", "/", '|'); 15212 ck_assert_uint_eq(listLengthS(l),1); 15213 ck_assert_str_eq(l[0], "two"); 15214 listFreeS(l); 15215 // delimiter not found 15216 l = icExtractSCharS("one/two", "||", '/'); 15217 ck_assert_ptr_eq(l, NULL); 15218 // icExtractSCharS with several delimiters after each other 15219 l = icExtractSCharS("one/ two /three ", "/", ' '); 15220 ck_assert_uint_eq(listLengthS(l),2); 15221 ck_assert_str_eq(l[0], ""); 15222 ck_assert_str_eq(l[1], "three"); 15223 listFreeS(l); 15224 // multiple character delimiter 15225 l = icExtractSCharS("AAe thre|e extract", "E ", '|'); 15226 ck_assert_uint_eq(listLengthS(l),1); 15227 ck_assert_str_eq(l[0], "thre"); 15228 listFreeS(l); 15229 // empty delimiter 15230 l = icExtractSCharS("AAd", "", 'A'); 15231 ck_assert_ptr_eq(l, NULL); 15232 // empty string 15233 l = icExtractSCharS("", "$", '#'); 15234 ck_assert_ptr_eq(l, NULL); 15235 // delim1 = delim2 15236 l = icExtractSCharS("", "$", '$'); 15237 ck_assert_ptr_eq(l, NULL); 15238 // NULL string 15239 ck_assert_ptr_eq(icExtractSCharS(NULL, ";", ','), NULL); 15240 // NULL delimiter 15241 ck_assert_ptr_eq(icExtractSCharS("test", NULL, ','), NULL); 15242 15243 15244 } 15245 15246 15247 void icExtractCharCharST(CuTest *tc UNUSED) { 15248 15249 char **l; 15250 15251 // string 15252 l = icExtractCharCharS("one/two|", '/', '|'); 15253 ck_assert_uint_eq(listLengthS(l),1); 15254 ck_assert_str_eq(l[0], "two"); 15255 listFreeS(l); 15256 // delimiter not found 15257 l = icExtractCharCharS("one/two", '|', '/'); 15258 ck_assert_ptr_eq(l, NULL); 15259 // icExtractCharCharS with several delimiters after each other 15260 l = icExtractCharCharS("one/ two /three ", '/', ' '); 15261 ck_assert_uint_eq(listLengthS(l),2); 15262 ck_assert_str_eq(l[0], ""); 15263 ck_assert_str_eq(l[1], "three"); 15264 listFreeS(l); 15265 // empty string 15266 l = icExtractCharCharS("", '$', '#'); 15267 ck_assert_ptr_eq(l, NULL); 15268 // delim1 = delim2 15269 l = icExtractCharCharS("", '$', '$'); 15270 ck_assert_ptr_eq(l, NULL); 15271 // NULL string 15272 ck_assert_ptr_eq(icExtractCharCharS(NULL, ';', ','), NULL); 15273 15274 15275 } 15276 15277 15278 void listDupST(CuTest *tc UNUSED) { 15279 15280 char **l = NULL; 15281 char **l2; 15282 char **r = null; 15283 15284 // list 15285 r = listPushS(&l, "1"); 15286 ck_assert_ptr_eq(r, l); 15287 r = listPushS(&l, "22"); 15288 ck_assert_ptr_eq(r, l); 15289 r = listPushS(&l, "333"); 15290 ck_assert_ptr_eq(r, l); 15291 r = listPushS(&l, "4444"); 15292 ck_assert_ptr_eq(r, l); 15293 l2 = listDupS(l); 15294 ck_assert_uint_eq(listLengthS(l2),4); 15295 ck_assert_str_eq(l2[0], "1"); 15296 ck_assert_str_eq(l2[3], "4444"); 15297 listFreeS(l); 15298 listFreeS(l2); 15299 // empty list 15300 listEmptyS(l) 15301 l2 = listDupS(l); 15302 ck_assert(listIsEmptyS(l2)); 15303 listFreeS(l); 15304 listFreeS(l2); 15305 // NULL list 15306 ck_assert_ptr_eq(listDupS(NULL), NULL); 15307 15308 } 15309 15310 15311 void iListDupST(CuTest *tc UNUSED) { 15312 15313 char **l = NULL; 15314 char **l2; 15315 char **r = null; 15316 15317 // list 15318 r = listPushS(&l, "1"); 15319 ck_assert_ptr_eq(r, l); 15320 r = listPushS(&l, "22"); 15321 ck_assert_ptr_eq(r, l); 15322 r = listPushS(&l, "333"); 15323 ck_assert_ptr_eq(r, l); 15324 r = listPushS(&l, "4444"); 15325 ck_assert_ptr_eq(r, l); 15326 l2 = iListDupS(l); 15327 ck_assert_uint_eq(listLengthS(l2),4); 15328 ck_assert_str_eq(l2[0], "1"); 15329 ck_assert_str_eq(l2[3], "4444"); 15330 free(l); 15331 listFreeS(l2); 15332 // empty list 15333 listEmptyS(l); 15334 l2 = iListDupS(l); 15335 ck_assert(listIsEmptyS(l2)); 15336 free(l); 15337 listFreeS(l2); 15338 // NULL list 15339 ck_assert_ptr_eq(iListDupS(NULL), NULL); 15340 15341 } 15342 15343 15344 void listReverseST(CuTest *tc UNUSED) { 15345 15346 char **l = NULL; 15347 char **l2; 15348 char **r = null; 15349 15350 // list 15351 r = listPushS(&l, "1"); 15352 ck_assert_ptr_eq(r, l); 15353 r = listPushS(&l, "22"); 15354 ck_assert_ptr_eq(r, l); 15355 r = listPushS(&l, "333"); 15356 ck_assert_ptr_eq(r, l); 15357 r = listPushS(&l, "4444"); 15358 ck_assert_ptr_eq(r, l); 15359 l2 = listReverseS(l); 15360 ck_assert_uint_eq(listLengthS(l2),4); 15361 ck_assert_str_eq(l2[0], "4444"); 15362 ck_assert_str_eq(l2[3], "1"); 15363 listFreeS(l); 15364 listFreeS(l2); 15365 // empty list 15366 listEmptyS(l) 15367 l2 = listReverseS(l); 15368 ck_assert(listIsEmptyS(l2)); 15369 listFreeS(l); 15370 listFreeS(l2); 15371 // NULL list 15372 ck_assert_ptr_eq(listReverseS(NULL), NULL); 15373 15374 } 15375 15376 15377 void iListReverseST(CuTest *tc UNUSED) { 15378 15379 char **l = NULL; 15380 char **r = null; 15381 15382 // list 15383 r = listPushS(&l, "1"); 15384 ck_assert_ptr_eq(r, l); 15385 r = listPushS(&l, "22"); 15386 ck_assert_ptr_eq(r, l); 15387 r = listPushS(&l, "333"); 15388 ck_assert_ptr_eq(r, l); 15389 r = listPushS(&l, "4444"); 15390 ck_assert_ptr_eq(r, l); 15391 r = iListReverseS(&l); 15392 ck_assert_ptr_eq(r, l); 15393 ck_assert_uint_eq(listLengthS(l),4); 15394 ck_assert_str_eq(l[0], "4444"); 15395 ck_assert_str_eq(l[3], "1"); 15396 listFreeS(l); 15397 // empty list 15398 listEmptyS(l) 15399 r = iListReverseS(&l); 15400 ck_assert_ptr_eq(r, l); 15401 ck_assert(listIsEmptyS(l)); 15402 listFreeS(l); 15403 // NULL list 15404 l = NULL; 15405 r = iListReverseS(&l); 15406 ck_assert_ptr_eq(r, l); 15407 ck_assert_ptr_eq(l, NULL); 15408 // NULL var 15409 r = iListReverseS(NULL); 15410 ck_assert_ptr_eq(r, null); 15411 15412 } 15413 15414 15415 void listCatST(CuTest *tc UNUSED) { 15416 15417 char **l; 15418 char **l2; 15419 char **r; 15420 15421 // cat lists 15422 l = listCreateS("#@#","1"); 15423 l2 = listCreateS("lib","sheepy"); 15424 r = listCatS(l,l2); 15425 ck_assert_str_eq(r[0], "#@#"); 15426 ck_assert_str_eq(r[1], "1"); 15427 ck_assert_str_eq(r[2], "lib"); 15428 ck_assert_str_eq(r[3], "sheepy"); 15429 listFreeManyS(l,l2,r); 15430 // empty list 15431 listEmptyS(l); 15432 r = listCatS(l); 15433 ck_assert(listIsEmptyS(r)); 15434 listFreeManyS(r,l); 15435 // cat empty list with list 15436 listEmptyS(l); 15437 l2 = listCreateS("lib","sheepy"); 15438 r = listCatS(l, l2); 15439 ck_assert_str_eq(r[0], "lib"); 15440 ck_assert_str_eq(r[1], "sheepy"); 15441 listFreeManyS(l,l2,r); 15442 15443 } 15444 15445 15446 void listAppendST(CuTest *tc UNUSED) { 15447 15448 char **l = NULL; 15449 char **l2 = NULL; 15450 char **r = null; 15451 15452 // lists 15453 r = listPushS(&l, "1"); 15454 ck_assert_ptr_eq(r, l); 15455 r = listPushS(&l, "22"); 15456 ck_assert_ptr_eq(r, l); 15457 r = listPushS(&l, "333"); 15458 ck_assert_ptr_eq(r, l); 15459 r = listPushS(&l, "4444"); 15460 ck_assert_ptr_eq(r, l); 15461 r = listPushS(&l2, "A"); 15462 ck_assert_ptr_eq(r, l2); 15463 r = listPushS(&l2, "BB"); 15464 ck_assert_ptr_eq(r, l2); 15465 r = listPushS(&l2, "CCC"); 15466 ck_assert_ptr_eq(r, l2); 15467 r = listPushS(&l2, "DDDD"); 15468 ck_assert_ptr_eq(r, l2); 15469 r = listAppendS(&l2,l); 15470 ck_assert_ptr_eq(r, l2); 15471 ck_assert_uint_eq(listLengthS(l2),8); 15472 ck_assert_str_eq(l2[0], "A"); 15473 ck_assert_str_eq(l2[3], "DDDD"); 15474 ck_assert_str_eq(l2[4],"1"); 15475 ck_assert_str_eq(l2[7],"4444"); 15476 listFreeS(l); 15477 l = NULL; 15478 r = listPushS(&l, "1"); 15479 ck_assert_ptr_eq(r, l); 15480 r = listPushS(&l, "22"); 15481 ck_assert_ptr_eq(r, l); 15482 r = listPushS(&l, "333"); 15483 ck_assert_ptr_eq(r, l); 15484 r = listPushS(&l, "4444"); 15485 ck_assert_ptr_eq(r, l); 15486 r = listAppendS(&l,l); 15487 ck_assert_ptr_eq(r, l); 15488 ck_assert_uint_eq(listLengthS(l),8); 15489 ck_assert_str_eq(l[0], "1"); 15490 ck_assert_str_eq(l[3], "4444"); 15491 ck_assert_str_eq(l[4],"1"); 15492 ck_assert_str_eq(l[7],"4444"); 15493 listFreeS(l); 15494 // empty list + list 15495 listEmptyS(l) 15496 r = listAppendS(&l, l2); 15497 ck_assert_ptr_eq(r, l); 15498 ck_assert(listEqS(l,l2)); 15499 listFreeS(l); 15500 // list + empty list 15501 listEmptyS(l) 15502 r = listAppendS(&l2, l); 15503 ck_assert_ptr_eq(r, l2); 15504 ck_assert_uint_eq(listLengthS(l2),8); 15505 ck_assert_str_eq(l2[0], "A"); 15506 ck_assert_str_eq(l2[3], "DDDD"); 15507 ck_assert_str_eq(l2[4],"1"); 15508 ck_assert_str_eq(l2[7],"4444"); 15509 listFreeS(l); 15510 // empty list + empty list 15511 listEmptyS(l) 15512 r = listAppendS(&l, l); 15513 ck_assert_ptr_eq(r, l); 15514 ck_assert(listIsEmptyS(l)); 15515 listFreeS(l); 15516 // NULL list + list = duplicate 15517 l = NULL; 15518 r = listAppendS(&l,l2); 15519 ck_assert_ptr_eq(r, l); 15520 ck_assert(listEqS(l,l2)); 15521 listFreeS(l); 15522 // list + NULL list 15523 r = listAppendS(&l2, NULL); 15524 ck_assert_ptr_eq(r, l2); 15525 ck_assert_uint_eq(listLengthS(l2),8); 15526 ck_assert_str_eq(l2[0], "A"); 15527 ck_assert_str_eq(l2[3], "DDDD"); 15528 ck_assert_str_eq(l2[4],"1"); 15529 ck_assert_str_eq(l2[7],"4444"); 15530 listFreeS(l2); 15531 // NULL list pointer 15532 r = listAppendS(NULL,l2); 15533 ck_assert_ptr_eq(r, null); 15534 // should not crash 15535 15536 } 15537 15538 15539 void iListAppendST(CuTest *tc UNUSED) { 15540 15541 char **l = NULL; 15542 char **l2 = NULL; 15543 char **r = null; 15544 15545 // lists 15546 r = listPushS(&l, "1"); 15547 ck_assert_ptr_eq(r, l); 15548 r = listPushS(&l, "22"); 15549 ck_assert_ptr_eq(r, l); 15550 r = listPushS(&l, "333"); 15551 ck_assert_ptr_eq(r, l); 15552 r = listPushS(&l, "4444"); 15553 ck_assert_ptr_eq(r, l); 15554 r = listPushS(&l2, "A"); 15555 ck_assert_ptr_eq(r, l2); 15556 r = listPushS(&l2, "BB"); 15557 ck_assert_ptr_eq(r, l2); 15558 r = listPushS(&l2, "CCC"); 15559 ck_assert_ptr_eq(r, l2); 15560 r = listPushS(&l2, "DDDD"); 15561 ck_assert_ptr_eq(r, l2); 15562 r = iListAppendS(&l2,l); 15563 ck_assert_ptr_eq(r, l2); 15564 ck_assert_uint_eq(listLengthS(l2),8); 15565 ck_assert_str_eq(l2[0], "A"); 15566 ck_assert_str_eq(l2[3], "DDDD"); 15567 ck_assert_str_eq(l2[4],"1"); 15568 ck_assert_str_eq(l2[7],"4444"); 15569 free(l); 15570 l = NULL; 15571 r = listPushS(&l, "1"); 15572 ck_assert_ptr_eq(r, l); 15573 r = listPushS(&l, "22"); 15574 ck_assert_ptr_eq(r, l); 15575 r = listPushS(&l, "333"); 15576 ck_assert_ptr_eq(r, l); 15577 r = listPushS(&l, "4444"); 15578 ck_assert_ptr_eq(r, l); 15579 r = iListAppendS(&l,l); 15580 ck_assert_ptr_eq(r, null); 15581 ck_assert_uint_eq(listLengthS(l),4); 15582 ck_assert_str_eq(l[0], "1"); 15583 ck_assert_str_eq(l[3], "4444"); 15584 listFreeS(l); 15585 // empty list + list 15586 listEmptyS(l) 15587 r = iListAppendS(&l, l2); 15588 ck_assert_ptr_eq(r, l); 15589 ck_assert(listEqS(l,l2)); 15590 free(l2); 15591 listFreeS(l); 15592 // list + empty list 15593 l2 = NULL; 15594 r = listPushS(&l2, "A"); 15595 ck_assert_ptr_eq(r, l2); 15596 r = listPushS(&l2, "BB"); 15597 ck_assert_ptr_eq(r, l2); 15598 r = listPushS(&l2, "CCC"); 15599 ck_assert_ptr_eq(r, l2); 15600 r = listPushS(&l2, "DDDD"); 15601 ck_assert_ptr_eq(r, l2); 15602 r = listPushS(&l2, "1"); 15603 ck_assert_ptr_eq(r, l2); 15604 r = listPushS(&l2, "22"); 15605 ck_assert_ptr_eq(r, l2); 15606 r = listPushS(&l2, "333"); 15607 ck_assert_ptr_eq(r, l2); 15608 r = listPushS(&l2, "4444"); 15609 ck_assert_ptr_eq(r, l2); 15610 listEmptyS(l) 15611 r = iListAppendS(&l2, l); 15612 ck_assert_ptr_eq(r, l2); 15613 ck_assert_uint_eq(listLengthS(l2),8); 15614 ck_assert_str_eq(l2[0], "A"); 15615 ck_assert_str_eq(l2[3], "DDDD"); 15616 ck_assert_str_eq(l2[4],"1"); 15617 ck_assert_str_eq(l2[7],"4444"); 15618 free(l); 15619 listFreeS(l2); 15620 // empty list + empty list 15621 listEmptyS(l); 15622 listEmptyS(l2); 15623 r = iListAppendS(&l, l2); 15624 ck_assert_ptr_eq(r, l); 15625 ck_assert(listIsEmptyS(l)); 15626 listFreeS(l); 15627 listFreeS(l2); 15628 // NULL list + list = duplicate 15629 l = NULL; 15630 l2 = NULL; 15631 r = listPushS(&l2, "A"); 15632 ck_assert_ptr_eq(r, l2); 15633 r = listPushS(&l2, "BB"); 15634 ck_assert_ptr_eq(r, l2); 15635 r = listPushS(&l2, "CCC"); 15636 ck_assert_ptr_eq(r, l2); 15637 r = listPushS(&l2, "DDDD"); 15638 ck_assert_ptr_eq(r, l2); 15639 r = iListAppendS(&l,l2); 15640 ck_assert_ptr_eq(r, l); 15641 ck_assert(listEqS(l,l2)); 15642 free(l); 15643 // list + NULL list 15644 r = iListAppendS(&l2, NULL); 15645 ck_assert_ptr_eq(r, l2); 15646 ck_assert_uint_eq(listLengthS(l2),4); 15647 ck_assert_str_eq(l2[0], "A"); 15648 ck_assert_str_eq(l2[3], "DDDD"); 15649 listFreeS(l2); 15650 // NULL list pointer 15651 r = iListAppendS(NULL,l2); 15652 ck_assert_ptr_eq(r, null); 15653 // should not crash 15654 15655 } 15656 15657 15658 void iListAppendNSmashST(CuTest *tc UNUSED) { 15659 15660 char **l = NULL; 15661 char **l2 = NULL; 15662 char **r = null; 15663 15664 // lists 15665 r = listPushS(&l, "1"); 15666 ck_assert_ptr_eq(r, l); 15667 r = listPushS(&l, "22"); 15668 ck_assert_ptr_eq(r, l); 15669 r = listPushS(&l, "333"); 15670 ck_assert_ptr_eq(r, l); 15671 r = listPushS(&l, "4444"); 15672 ck_assert_ptr_eq(r, l); 15673 r = listPushS(&l2, "A"); 15674 ck_assert_ptr_eq(r, l2); 15675 r = listPushS(&l2, "BB"); 15676 ck_assert_ptr_eq(r, l2); 15677 r = listPushS(&l2, "CCC"); 15678 ck_assert_ptr_eq(r, l2); 15679 r = listPushS(&l2, "DDDD"); 15680 ck_assert_ptr_eq(r, l2); 15681 r = iListAppendNSmashS(&l2,l); 15682 ck_assert_ptr_eq(r, l2); 15683 ck_assert_uint_eq(listLengthS(l2),8); 15684 ck_assert_str_eq(l2[0], "A"); 15685 ck_assert_str_eq(l2[3], "DDDD"); 15686 ck_assert_str_eq(l2[4],"1"); 15687 ck_assert_str_eq(l2[7],"4444"); 15688 l = NULL; 15689 r = listPushS(&l, "1"); 15690 ck_assert_ptr_eq(r, l); 15691 r = listPushS(&l, "22"); 15692 ck_assert_ptr_eq(r, l); 15693 r = listPushS(&l, "333"); 15694 ck_assert_ptr_eq(r, l); 15695 r = listPushS(&l, "4444"); 15696 ck_assert_ptr_eq(r, l); 15697 r = iListAppendNSmashS(&l,l); 15698 ck_assert_ptr_eq(r, null); 15699 ck_assert_uint_eq(listLengthS(l),4); 15700 ck_assert_str_eq(l[0], "1"); 15701 ck_assert_str_eq(l[3], "4444"); 15702 listFreeS(l); 15703 // empty list + list 15704 listEmptyS(l) 15705 r = iListAppendNSmashS(&l, l2); 15706 ck_assert_ptr_eq(r, l); 15707 ck_assert_str_eq(l[0], "A"); 15708 ck_assert_str_eq(l[3], "DDDD"); 15709 ck_assert_str_eq(l[4],"1"); 15710 ck_assert_str_eq(l[7],"4444"); 15711 listFreeS(l); 15712 // list + empty list 15713 l2 = NULL; 15714 r = listPushS(&l2, "A"); 15715 ck_assert_ptr_eq(r, l2); 15716 r = listPushS(&l2, "BB"); 15717 ck_assert_ptr_eq(r, l2); 15718 r = listPushS(&l2, "CCC"); 15719 ck_assert_ptr_eq(r, l2); 15720 r = listPushS(&l2, "DDDD"); 15721 ck_assert_ptr_eq(r, l2); 15722 r = listPushS(&l2, "1"); 15723 ck_assert_ptr_eq(r, l2); 15724 r = listPushS(&l2, "22"); 15725 ck_assert_ptr_eq(r, l2); 15726 r = listPushS(&l2, "333"); 15727 ck_assert_ptr_eq(r, l2); 15728 r = listPushS(&l2, "4444"); 15729 ck_assert_ptr_eq(r, l2); 15730 listEmptyS(l) 15731 r = iListAppendNSmashS(&l2, l); 15732 ck_assert_ptr_eq(r, l2); 15733 ck_assert_uint_eq(listLengthS(l2),8); 15734 ck_assert_str_eq(l2[0], "A"); 15735 ck_assert_str_eq(l2[3], "DDDD"); 15736 ck_assert_str_eq(l2[4],"1"); 15737 ck_assert_str_eq(l2[7],"4444"); 15738 listFreeS(l2); 15739 // empty list + empty list 15740 listEmptyS(l); 15741 listEmptyS(l2); 15742 r = iListAppendNSmashS(&l, l2); 15743 ck_assert_ptr_eq(r, l); 15744 ck_assert(listIsEmptyS(l)); 15745 listFreeS(l); 15746 // NULL list + list = duplicate 15747 l = NULL; 15748 l2 = NULL; 15749 r = listPushS(&l2, "A"); 15750 ck_assert_ptr_eq(r, l2); 15751 r = listPushS(&l2, "BB"); 15752 ck_assert_ptr_eq(r, l2); 15753 r = listPushS(&l2, "CCC"); 15754 ck_assert_ptr_eq(r, l2); 15755 r = listPushS(&l2, "DDDD"); 15756 ck_assert_ptr_eq(r, l2); 15757 r = iListAppendNSmashS(&l,l2); 15758 ck_assert_ptr_eq(r, l); 15759 ck_assert_str_eq(l[0], "A"); 15760 ck_assert_str_eq(l[1], "BB"); 15761 ck_assert_str_eq(l[2], "CCC"); 15762 ck_assert_str_eq(l[3], "DDDD"); 15763 // list + NULL list 15764 r = iListAppendNSmashS(&l, NULL); 15765 ck_assert_ptr_eq(r, l); 15766 ck_assert_uint_eq(listLengthS(l),4); 15767 ck_assert_str_eq(l[0], "A"); 15768 ck_assert_str_eq(l[3], "DDDD"); 15769 listFreeS(l); 15770 // NULL list pointer 15771 r = iListAppendNSmashS(NULL,l); 15772 ck_assert_ptr_eq(r, null); 15773 // should not crash 15774 15775 } 15776 15777 15778 void listShiftST(CuTest *tc UNUSED) { 15779 15780 char **l = NULL; 15781 char **l2 = NULL; 15782 char **r = null; 15783 15784 // lists 15785 r = listPushS(&l, "1"); 15786 ck_assert_ptr_eq(r, l); 15787 r = listPushS(&l, "22"); 15788 ck_assert_ptr_eq(r, l); 15789 r = listPushS(&l, "333"); 15790 ck_assert_ptr_eq(r, l); 15791 r = listPushS(&l, "4444"); 15792 ck_assert_ptr_eq(r, l); 15793 r = listPushS(&l2, "A"); 15794 ck_assert_ptr_eq(r, l2); 15795 r = listPushS(&l2, "BB"); 15796 ck_assert_ptr_eq(r, l2); 15797 r = listPushS(&l2, "CCC"); 15798 ck_assert_ptr_eq(r, l2); 15799 r = listPushS(&l2, "DDDD"); 15800 ck_assert_ptr_eq(r, l2); 15801 r = listShiftS(&l2,l); 15802 ck_assert_ptr_eq(r, l2); 15803 ck_assert_uint_eq(listLengthS(l2),8); 15804 ck_assert_str_eq(l2[4], "A"); 15805 ck_assert_str_eq(l2[7], "DDDD"); 15806 ck_assert_str_eq(l2[0],"1"); 15807 ck_assert_str_eq(l2[3],"4444"); 15808 listFreeS(l); 15809 l = NULL; 15810 r = listPushS(&l, "1"); 15811 ck_assert_ptr_eq(r, l); 15812 r = listPushS(&l, "22"); 15813 ck_assert_ptr_eq(r, l); 15814 r = listPushS(&l, "333"); 15815 ck_assert_ptr_eq(r, l); 15816 r = listPushS(&l, "4444"); 15817 ck_assert_ptr_eq(r, l); 15818 r = listShiftS(&l,l); 15819 ck_assert_ptr_eq(r, l); 15820 ck_assert_uint_eq(listLengthS(l),8); 15821 ck_assert_str_eq(l[0], "1"); 15822 ck_assert_str_eq(l[3], "4444"); 15823 ck_assert_str_eq(l[4],"1"); 15824 ck_assert_str_eq(l[7],"4444"); 15825 listFreeS(l); 15826 // empty list + list 15827 listEmptyS(l) 15828 r = listShiftS(&l, l2); 15829 ck_assert_ptr_eq(r, l); 15830 ck_assert(listEqS(l,l2)); 15831 listFreeS(l); 15832 // list + empty list 15833 listEmptyS(l) 15834 r = listShiftS(&l2, l); 15835 ck_assert_ptr_eq(r, l2); 15836 ck_assert_uint_eq(listLengthS(l2),8); 15837 ck_assert_str_eq(l2[4], "A"); 15838 ck_assert_str_eq(l2[7], "DDDD"); 15839 ck_assert_str_eq(l2[0],"1"); 15840 ck_assert_str_eq(l2[3],"4444"); 15841 listFreeS(l); 15842 // empty list + empty list 15843 listEmptyS(l) 15844 r = listShiftS(&l, l); 15845 ck_assert_ptr_eq(r, l); 15846 ck_assert(listIsEmptyS(l)); 15847 listFreeS(l); 15848 // NULL list + list = duplicate 15849 l = NULL; 15850 r = listShiftS(&l,l2); 15851 ck_assert_ptr_eq(r, l); 15852 ck_assert(listEqS(l,l2)); 15853 listFreeS(l); 15854 // list + NULL list 15855 r = listShiftS(&l2, NULL); 15856 ck_assert_ptr_eq(r, l2); 15857 ck_assert_uint_eq(listLengthS(l2),8); 15858 ck_assert_str_eq(l2[4], "A"); 15859 ck_assert_str_eq(l2[7], "DDDD"); 15860 ck_assert_str_eq(l2[0],"1"); 15861 ck_assert_str_eq(l2[3],"4444"); 15862 listFreeS(l2); 15863 // NULL list pointer 15864 r = listShiftS(NULL,l2); 15865 ck_assert_ptr_eq(r, null); 15866 // should not crash 15867 15868 15869 } 15870 15871 15872 void iListShiftST(CuTest *tc UNUSED) { 15873 15874 char **l = NULL; 15875 char **l2 = NULL; 15876 char **r = null; 15877 15878 // lists 15879 r = listPushS(&l, "1"); 15880 ck_assert_ptr_eq(r, l); 15881 r = listPushS(&l, "22"); 15882 ck_assert_ptr_eq(r, l); 15883 r = listPushS(&l, "333"); 15884 ck_assert_ptr_eq(r, l); 15885 r = listPushS(&l, "4444"); 15886 ck_assert_ptr_eq(r, l); 15887 r = listPushS(&l2, "A"); 15888 ck_assert_ptr_eq(r, l2); 15889 r = listPushS(&l2, "BB"); 15890 ck_assert_ptr_eq(r, l2); 15891 r = listPushS(&l2, "CCC"); 15892 ck_assert_ptr_eq(r, l2); 15893 r = listPushS(&l2, "DDDD"); 15894 ck_assert_ptr_eq(r, l2); 15895 r = iListShiftS(&l2,l); 15896 ck_assert_ptr_eq(r, l2); 15897 ck_assert_uint_eq(listLengthS(l2),8); 15898 ck_assert_str_eq(l2[4], "A"); 15899 ck_assert_str_eq(l2[7], "DDDD"); 15900 ck_assert_str_eq(l2[0],"1"); 15901 ck_assert_str_eq(l2[3],"4444"); 15902 free(l); 15903 l = NULL; 15904 r = listPushS(&l, "1"); 15905 ck_assert_ptr_eq(r, l); 15906 r = listPushS(&l, "22"); 15907 ck_assert_ptr_eq(r, l); 15908 r = listPushS(&l, "333"); 15909 ck_assert_ptr_eq(r, l); 15910 r = listPushS(&l, "4444"); 15911 ck_assert_ptr_eq(r, l); 15912 r = iListShiftS(&l,l); 15913 ck_assert_ptr_eq(r, null); 15914 ck_assert_uint_eq(listLengthS(l),4); 15915 ck_assert_str_eq(l[0], "1"); 15916 ck_assert_str_eq(l[3], "4444"); 15917 listFreeS(l); 15918 // empty list + list 15919 listEmptyS(l) 15920 r = iListShiftS(&l, l2); 15921 ck_assert_ptr_eq(r, l); 15922 ck_assert(listEqS(l,l2)); 15923 free(l2); 15924 listFreeS(l); 15925 // list + empty list 15926 l2 = NULL; 15927 r = listPushS(&l2, "A"); 15928 ck_assert_ptr_eq(r, l2); 15929 r = listPushS(&l2, "BB"); 15930 ck_assert_ptr_eq(r, l2); 15931 r = listPushS(&l2, "CCC"); 15932 ck_assert_ptr_eq(r, l2); 15933 r = listPushS(&l2, "DDDD"); 15934 ck_assert_ptr_eq(r, l2); 15935 r = listPushS(&l2, "1"); 15936 ck_assert_ptr_eq(r, l2); 15937 r = listPushS(&l2, "22"); 15938 ck_assert_ptr_eq(r, l2); 15939 r = listPushS(&l2, "333"); 15940 ck_assert_ptr_eq(r, l2); 15941 r = listPushS(&l2, "4444"); 15942 ck_assert_ptr_eq(r, l2); 15943 listEmptyS(l) 15944 r = iListShiftS(&l2, l); 15945 ck_assert_ptr_eq(r, l2); 15946 ck_assert_uint_eq(listLengthS(l2),8); 15947 ck_assert_str_eq(l2[0], "A"); 15948 ck_assert_str_eq(l2[3], "DDDD"); 15949 ck_assert_str_eq(l2[4],"1"); 15950 ck_assert_str_eq(l2[7],"4444"); 15951 free(l); 15952 listFreeS(l2); 15953 // empty list + empty list 15954 listEmptyS(l); 15955 listEmptyS(l2); 15956 r = iListShiftS(&l, l2); 15957 ck_assert_ptr_eq(r, l); 15958 ck_assert(listIsEmptyS(l)); 15959 listFreeS(l); 15960 listFreeS(l2); 15961 // NULL list + list = duplicate 15962 l = NULL; 15963 l2 = NULL; 15964 r = listPushS(&l2, "A"); 15965 ck_assert_ptr_eq(r, l2); 15966 r = listPushS(&l2, "BB"); 15967 ck_assert_ptr_eq(r, l2); 15968 r = listPushS(&l2, "CCC"); 15969 ck_assert_ptr_eq(r, l2); 15970 r = listPushS(&l2, "DDDD"); 15971 ck_assert_ptr_eq(r, l2); 15972 r = iListShiftS(&l,l2); 15973 ck_assert_ptr_eq(r, l); 15974 ck_assert(listEqS(l,l2)); 15975 free(l); 15976 // list + NULL list 15977 r = iListShiftS(&l2, NULL); 15978 ck_assert_ptr_eq(r, null); 15979 ck_assert_uint_eq(listLengthS(l2),4); 15980 ck_assert_str_eq(l2[0], "A"); 15981 ck_assert_str_eq(l2[3], "DDDD"); 15982 listFreeS(l2); 15983 // NULL list pointer 15984 r = iListShiftS(NULL,l2); 15985 ck_assert_ptr_eq(r, null); 15986 // should not crash 15987 15988 15989 } 15990 15991 15992 void iListShiftNSmashST(CuTest *tc UNUSED) { 15993 15994 char **l = NULL; 15995 char **l2 = NULL; 15996 char **r = null; 15997 15998 // lists 15999 r = listPushS(&l, "1"); 16000 ck_assert_ptr_eq(r, l); 16001 r = listPushS(&l, "22"); 16002 ck_assert_ptr_eq(r, l); 16003 r = listPushS(&l, "333"); 16004 ck_assert_ptr_eq(r, l); 16005 r = listPushS(&l, "4444"); 16006 ck_assert_ptr_eq(r, l); 16007 r = listPushS(&l2, "A"); 16008 ck_assert_ptr_eq(r, l2); 16009 r = listPushS(&l2, "BB"); 16010 ck_assert_ptr_eq(r, l2); 16011 r = listPushS(&l2, "CCC"); 16012 ck_assert_ptr_eq(r, l2); 16013 r = listPushS(&l2, "DDDD"); 16014 ck_assert_ptr_eq(r, l2); 16015 r = iListShiftNSmashS(&l2,l); 16016 ck_assert_ptr_eq(r, l2); 16017 ck_assert_uint_eq(listLengthS(l2),8); 16018 ck_assert_str_eq(l2[4], "A"); 16019 ck_assert_str_eq(l2[7], "DDDD"); 16020 ck_assert_str_eq(l2[0],"1"); 16021 ck_assert_str_eq(l2[3],"4444"); 16022 l = NULL; 16023 r = listPushS(&l, "1"); 16024 ck_assert_ptr_eq(r, l); 16025 r = listPushS(&l, "22"); 16026 ck_assert_ptr_eq(r, l); 16027 r = listPushS(&l, "333"); 16028 ck_assert_ptr_eq(r, l); 16029 r = listPushS(&l, "4444"); 16030 ck_assert_ptr_eq(r, l); 16031 r = iListShiftNSmashS(&l,l); 16032 ck_assert_ptr_eq(r, null); 16033 ck_assert_uint_eq(listLengthS(l),4); 16034 ck_assert_str_eq(l[0], "1"); 16035 ck_assert_str_eq(l[3], "4444"); 16036 listFreeS(l); 16037 // empty list + list 16038 listEmptyS(l) 16039 r = iListShiftNSmashS(&l, l2); 16040 ck_assert_ptr_eq(r, l); 16041 ck_assert_str_eq(l[4], "A"); 16042 ck_assert_str_eq(l[7], "DDDD"); 16043 ck_assert_str_eq(l[0],"1"); 16044 ck_assert_str_eq(l[3],"4444"); 16045 listFreeS(l); 16046 // list + empty list 16047 l2 = NULL; 16048 r = listPushS(&l2, "A"); 16049 ck_assert_ptr_eq(r, l2); 16050 r = listPushS(&l2, "BB"); 16051 ck_assert_ptr_eq(r, l2); 16052 r = listPushS(&l2, "CCC"); 16053 ck_assert_ptr_eq(r, l2); 16054 r = listPushS(&l2, "DDDD"); 16055 ck_assert_ptr_eq(r, l2); 16056 r = listPushS(&l2, "1"); 16057 ck_assert_ptr_eq(r, l2); 16058 r = listPushS(&l2, "22"); 16059 ck_assert_ptr_eq(r, l2); 16060 r = listPushS(&l2, "333"); 16061 ck_assert_ptr_eq(r, l2); 16062 r = listPushS(&l2, "4444"); 16063 ck_assert_ptr_eq(r, l2); 16064 listEmptyS(l) 16065 r = iListShiftNSmashS(&l2, l); 16066 ck_assert_ptr_eq(r, l2); 16067 ck_assert_uint_eq(listLengthS(l2),8); 16068 ck_assert_str_eq(l2[0], "A"); 16069 ck_assert_str_eq(l2[3], "DDDD"); 16070 ck_assert_str_eq(l2[4],"1"); 16071 ck_assert_str_eq(l2[7],"4444"); 16072 listFreeS(l2); 16073 // empty list + empty list 16074 listEmptyS(l); 16075 listEmptyS(l2); 16076 r = iListShiftNSmashS(&l, l2); 16077 ck_assert_ptr_eq(r, l); 16078 ck_assert(listIsEmptyS(l)); 16079 listFreeS(l); 16080 // NULL list + list = duplicate 16081 l = NULL; 16082 l2 = NULL; 16083 r = listPushS(&l2, "A"); 16084 ck_assert_ptr_eq(r, l2); 16085 r = listPushS(&l2, "BB"); 16086 ck_assert_ptr_eq(r, l2); 16087 r = listPushS(&l2, "CCC"); 16088 ck_assert_ptr_eq(r, l2); 16089 r = listPushS(&l2, "DDDD"); 16090 ck_assert_ptr_eq(r, l2); 16091 r = iListShiftNSmashS(&l,l2); 16092 ck_assert_ptr_eq(r, l); 16093 ck_assert_str_eq(l[0], "A"); 16094 ck_assert_str_eq(l[1], "BB"); 16095 ck_assert_str_eq(l[2], "CCC"); 16096 ck_assert_str_eq(l[3], "DDDD"); 16097 // list + NULL list 16098 r = iListShiftNSmashS(&l, NULL); 16099 ck_assert_ptr_eq(r, null); 16100 ck_assert_uint_eq(listLengthS(l),4); 16101 ck_assert_str_eq(l[0], "A"); 16102 ck_assert_str_eq(l[3], "DDDD"); 16103 listFreeS(l); 16104 // NULL list pointer 16105 r = iListShiftNSmashS(NULL,l); 16106 ck_assert_ptr_eq(r, null); 16107 // should not crash 16108 16109 16110 } 16111 16112 16113 void listAddST(CuTest *tc UNUSED) { 16114 16115 char **l = NULL; 16116 char **l2 = NULL; 16117 char **l3; 16118 char **r = null; 16119 16120 // lists 16121 r = listPushS(&l, "1"); 16122 ck_assert_ptr_eq(r, l); 16123 r = listPushS(&l, "22"); 16124 ck_assert_ptr_eq(r, l); 16125 r = listPushS(&l, "333"); 16126 ck_assert_ptr_eq(r, l); 16127 r = listPushS(&l, "4444"); 16128 ck_assert_ptr_eq(r, l); 16129 r = listPushS(&l2, "A"); 16130 ck_assert_ptr_eq(r, l2); 16131 r = listPushS(&l2, "BB"); 16132 ck_assert_ptr_eq(r, l2); 16133 r = listPushS(&l2, "CCC"); 16134 ck_assert_ptr_eq(r, l2); 16135 r = listPushS(&l2, "DDDD"); 16136 ck_assert_ptr_eq(r, l2); 16137 l3 = listAddS(l2,l); 16138 ck_assert_uint_eq(listLengthS(l3),8); 16139 ck_assert_str_eq(l3[0], "A"); 16140 ck_assert_str_eq(l3[3], "DDDD"); 16141 ck_assert_str_eq(l3[4],"1"); 16142 ck_assert_str_eq(l3[7],"4444"); 16143 listFreeS(l3); 16144 listFreeS(l); 16145 // empty list + list 16146 listEmptyS(l) 16147 l3 = listAddS(l, l2); 16148 ck_assert(listEqS(l3,l2)); 16149 listFreeS(l3); 16150 listFreeS(l); 16151 // list + empty list 16152 listEmptyS(l) 16153 l3 = listAddS(l2, l); 16154 ck_assert(listEqS(l3,l2)); 16155 listFreeS(l3); 16156 listFreeS(l); 16157 // empty list + empty list 16158 listEmptyS(l) 16159 l3 = listAddS(l, l); 16160 ck_assert(listIsEmptyS(l3)); 16161 listFreeS(l3); 16162 listFreeS(l); 16163 // NULL list + list 16164 l3 = listAddS(NULL,l2); 16165 ck_assert(listEqS(l3,l2)); 16166 listFreeS(l3); 16167 // list + NULL list 16168 l3 = listAddS(l2, NULL); 16169 ck_assert(listEqS(l3,l2)); 16170 listFreeS(l3); 16171 listFreeS(l2); 16172 // NULL list + NULL list 16173 ck_assert_ptr_eq(listAddS(NULL,NULL), NULL); 16174 16175 } 16176 16177 16178 void listSliceST(CuTest *tc UNUSED) { 16179 16180 char **l = NULL; 16181 char **l2; 16182 char **r = null; 16183 16184 // list negative index 16185 r = listPushS(&l, "1"); 16186 ck_assert_ptr_eq(r, l); 16187 r = listPushS(&l, "22"); 16188 ck_assert_ptr_eq(r, l); 16189 r = listPushS(&l, "333"); 16190 ck_assert_ptr_eq(r, l); 16191 r = listPushS(&l, "4444"); 16192 ck_assert_ptr_eq(r, l); 16193 l2 = listSliceS(l, 1,-1); 16194 ck_assert_uint_eq(listLengthS(l2),2); 16195 ck_assert_str_eq(l2[0], "22"); 16196 ck_assert_str_eq(l2[1], "333"); 16197 listFreeS(l2); 16198 // start outside 16199 ck_assert_ptr_eq(listSliceS(l, 20,-4), NULL); 16200 // end outside 16201 l2 = listSliceS(l, 2,40); 16202 ck_assert_uint_eq(listLengthS(l2),2); 16203 ck_assert_str_eq(l2[0], "333"); 16204 ck_assert_str_eq(l2[1], "4444"); 16205 listFreeS(l2); 16206 // end negative and outside 16207 ck_assert_ptr_eq(listSliceS(l, 2,-40), NULL); 16208 // end before start 16209 ck_assert_ptr_eq(listSliceS(l, 3,2), NULL); 16210 listFreeS(l); 16211 // negative start last element 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,0); 16218 ck_assert_uint_eq(listLengthS(l2),1); 16219 ck_assert_str_eq(l2[0], "22"); 16220 listFreeS(l); 16221 listFreeS(l2); 16222 // start = end 16223 l = NULL; 16224 r = listPushS(&l, "1"); 16225 ck_assert_ptr_eq(r, l); 16226 r = listPushS(&l, "22"); 16227 ck_assert_ptr_eq(r, l); 16228 l2 = listSliceS(l, 1,1); 16229 ck_assert_uint_eq(listLengthS(l2),0); 16230 ck_assert_ptr_eq(l2[0], NULL); 16231 listFreeS(l); 16232 listFreeS(l2); 16233 // empty list 16234 listEmptyS(l) 16235 ck_assert_ptr_eq(listSliceS(l, 0,0), NULL); 16236 ck_assert_ptr_eq(listSliceS(l, -1,0), NULL); 16237 listFreeS(l); 16238 // NULL list 16239 ck_assert_ptr_eq(listSliceS(NULL, 2,-4), NULL); 16240 16241 16242 } 16243 16244 16245 void iListCopyST(CuTest *tc UNUSED) { 16246 16247 char **l = NULL; 16248 char **l2; 16249 char **r = null; 16250 16251 // list negative index 16252 r = listPushS(&l, "1"); 16253 ck_assert_ptr_eq(r, l); 16254 r = listPushS(&l, "22"); 16255 ck_assert_ptr_eq(r, l); 16256 r = listPushS(&l, "333"); 16257 ck_assert_ptr_eq(r, l); 16258 r = listPushS(&l, "4444"); 16259 ck_assert_ptr_eq(r, l); 16260 l2 = iListCopyS(l, 1,-1); 16261 ck_assert_uint_eq(listLengthS(l2),2); 16262 ck_assert_str_eq(l2[0], "22"); 16263 ck_assert_str_eq(l2[1], "333"); 16264 free(l2); 16265 listFreeS(l); 16266 // start outside 16267 l = NULL; 16268 r = listPushS(&l, "1"); 16269 ck_assert_ptr_eq(r, l); 16270 r = listPushS(&l, "22"); 16271 ck_assert_ptr_eq(r, l); 16272 r = listPushS(&l, "333"); 16273 ck_assert_ptr_eq(r, l); 16274 r = listPushS(&l, "4444"); 16275 ck_assert_ptr_eq(r, l); 16276 ck_assert_ptr_eq(iListCopyS(l, 20,-4), NULL); 16277 // end outside 16278 l2 = iListCopyS(l, 2,40); 16279 ck_assert_uint_eq(listLengthS(l2),2); 16280 ck_assert_str_eq(l2[0], "333"); 16281 ck_assert_str_eq(l2[1], "4444"); 16282 free(l2); 16283 listFreeS(l); 16284 // end negative and outside 16285 l = NULL; 16286 r = listPushS(&l, "1"); 16287 ck_assert_ptr_eq(r, l); 16288 r = listPushS(&l, "22"); 16289 ck_assert_ptr_eq(r, l); 16290 r = listPushS(&l, "333"); 16291 ck_assert_ptr_eq(r, l); 16292 r = listPushS(&l, "4444"); 16293 ck_assert_ptr_eq(r, l); 16294 ck_assert_ptr_eq(iListCopyS(l, 2,-40), NULL); 16295 // end before start 16296 ck_assert_ptr_eq(iListCopyS(l, 3,2), NULL); 16297 listFreeS(l); 16298 // negative start last element 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,0); 16305 ck_assert_uint_eq(listLengthS(l2),1); 16306 ck_assert_str_eq(l2[0], "22"); 16307 free(l2); 16308 listFreeS(l); 16309 // start = end 16310 l = NULL; 16311 r = listPushS(&l, "1"); 16312 ck_assert_ptr_eq(r, l); 16313 r = listPushS(&l, "22"); 16314 ck_assert_ptr_eq(r, l); 16315 l2 = iListCopyS(l, 1,1); 16316 ck_assert_uint_eq(listLengthS(l2),0); 16317 ck_assert_ptr_eq(l2[0], NULL); 16318 free(l2); 16319 listFreeS(l); 16320 // empty list 16321 listEmptyS(l) 16322 ck_assert_ptr_eq(iListCopyS(l, 0,0), NULL); 16323 ck_assert_ptr_eq(iListCopyS(l, -1,0), NULL); 16324 listFreeS(l); 16325 // NULL list 16326 ck_assert_ptr_eq(iListCopyS(NULL, 2,-4), NULL); 16327 16328 16329 } 16330 16331 16332 void iListSliceST(CuTest *tc UNUSED) { 16333 16334 char **l = NULL; 16335 char **r = null; 16336 16337 // list negative index 16338 r = listPushS(&l, "1"); 16339 ck_assert_ptr_eq(r, l); 16340 r = listPushS(&l, "22"); 16341 ck_assert_ptr_eq(r, l); 16342 r = listPushS(&l, "333"); 16343 ck_assert_ptr_eq(r, l); 16344 r = listPushS(&l, "4444"); 16345 ck_assert_ptr_eq(r, l); 16346 r = iListSliceS(&l, 1,-1); 16347 ck_assert_ptr_eq(r, l); 16348 ck_assert_uint_eq(listLengthS(l),2); 16349 ck_assert_str_eq(l[0], "22"); 16350 ck_assert_str_eq(l[1], "333"); 16351 // start outside 16352 r = listPushS(&l, "1"); 16353 ck_assert_ptr_eq(r, l); 16354 r = listPushS(&l, "22"); 16355 ck_assert_ptr_eq(r, l); 16356 r = iListSliceS(&l, 20,-4); 16357 ck_assert_ptr_eq(r, null); 16358 ck_assert_uint_eq(listLengthS(l),0); 16359 // end outside 16360 r = iListSliceS(&l, 2,40); 16361 ck_assert_ptr_eq(r, null); 16362 ck_assert_uint_eq(listLengthS(l),0); 16363 // end negative and outside 16364 r = iListSliceS(&l, 2,-40); 16365 ck_assert_ptr_eq(r, null); 16366 ck_assert_uint_eq(listLengthS(l),0); 16367 // end before start 16368 r = listPushS(&l, "333"); 16369 ck_assert_ptr_eq(r, l); 16370 r = listPushS(&l, "4444"); 16371 ck_assert_ptr_eq(r, l); 16372 r = listPushS(&l, "55555"); 16373 ck_assert_ptr_eq(r, l); 16374 r = iListSliceS(&l, 3,2); 16375 ck_assert_ptr_eq(r, null); 16376 ck_assert_uint_eq(listLengthS(l),0); 16377 listFreeS(l); 16378 // negative start last element 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,0); 16385 ck_assert_ptr_eq(r, l); 16386 ck_assert_uint_eq(listLengthS(l),1); 16387 ck_assert_str_eq(l[0], "22"); 16388 listFreeS(l); 16389 // start = end 16390 l = NULL; 16391 r = listPushS(&l, "1"); 16392 ck_assert_ptr_eq(r, l); 16393 r = listPushS(&l, "22"); 16394 ck_assert_ptr_eq(r, l); 16395 r = iListSliceS(&l, 1,1); 16396 ck_assert_ptr_eq(r, l); 16397 ck_assert_uint_eq(listLengthS(l),0); 16398 ck_assert_ptr_eq(l[0], NULL); 16399 listFreeS(l); 16400 // empty list 16401 listEmptyS(l) 16402 r = iListSliceS(&l, 0,0); 16403 ck_assert_ptr_eq(r, null); 16404 ck_assert(listIsEmptyS(l)); 16405 r = iListSliceS(&l, -1,0); 16406 ck_assert_ptr_eq(r, null); 16407 ck_assert(listIsEmptyS(l)); 16408 listFreeS(l); 16409 // NULL list 16410 l = NULL; 16411 r = iListSliceS(&l, 2,-4); 16412 ck_assert_ptr_eq(r, null); 16413 // NULL var 16414 r = iListSliceS(NULL, 2,-4); 16415 ck_assert_ptr_eq(r, null); 16416 16417 16418 } 16419 16420 16421 void listCropST(CuTest *tc UNUSED) { 16422 16423 char **l = NULL; 16424 char **l2; 16425 char **r = null; 16426 16427 // list negative index 16428 r = listPushS(&l, "1"); 16429 ck_assert_ptr_eq(r, l); 16430 r = listPushS(&l, "22"); 16431 ck_assert_ptr_eq(r, l); 16432 r = listPushS(&l, "333"); 16433 ck_assert_ptr_eq(r, l); 16434 r = listPushS(&l, "4444"); 16435 ck_assert_ptr_eq(r, l); 16436 l2 = listCropS(l, 1,-1); 16437 ck_assert_uint_eq(listLengthS(l2),2); 16438 ck_assert_str_eq(l2[0], "22"); 16439 ck_assert_str_eq(l2[1], "333"); 16440 ck_assert_str_eq(l[0], "1"); 16441 ck_assert_str_eq(l[1], "4444"); 16442 ck_assert_ptr_eq(l[2], null); 16443 listFreeS(l2); 16444 // start outside 16445 ck_assert_ptr_eq(listCropS(l, 20,-4), NULL); 16446 // end outside 16447 l2 = listCropS(l, 0,40); 16448 ck_assert_uint_eq(listLengthS(l2),2); 16449 ck_assert_str_eq(l2[0], "1"); 16450 ck_assert_str_eq(l2[1], "4444"); 16451 ck_assert_ptr_eq(l[0], null); 16452 listFreeS(l2); 16453 listFreeS(l); 16454 // end negative and outside 16455 l = NULL; 16456 r = listPushS(&l, "1"); 16457 ck_assert_ptr_eq(r, l); 16458 r = listPushS(&l, "22"); 16459 ck_assert_ptr_eq(r, l); 16460 r = listPushS(&l, "333"); 16461 ck_assert_ptr_eq(r, l); 16462 r = listPushS(&l, "4444"); 16463 ck_assert_ptr_eq(r, l); 16464 ck_assert_ptr_eq(listCropS(l, 2,-40), NULL); 16465 ck_assert_str_eq(l[0], "1"); 16466 ck_assert_str_eq(l[1], "22"); 16467 ck_assert_str_eq(l[2], "333"); 16468 ck_assert_str_eq(l[3], "4444"); 16469 // end before start 16470 ck_assert_ptr_eq(listCropS(l, 3,2), NULL); 16471 ck_assert_str_eq(l[0], "1"); 16472 ck_assert_str_eq(l[1], "22"); 16473 ck_assert_str_eq(l[2], "333"); 16474 ck_assert_str_eq(l[3], "4444"); 16475 listFreeS(l); 16476 // negative start last element 16477 l = NULL; 16478 r = listPushS(&l, "1"); 16479 ck_assert_ptr_eq(r, l); 16480 r = listPushS(&l, "22"); 16481 ck_assert_ptr_eq(r, l); 16482 l2 = listCropS(l, -1,0); 16483 ck_assert_uint_eq(listLengthS(l2),1); 16484 ck_assert_str_eq(l2[0], "22"); 16485 ck_assert_str_eq(l[0], "1"); 16486 ck_assert_ptr_eq(l[1], null); 16487 listFreeS(l); 16488 listFreeS(l2); 16489 // start = end 16490 l = NULL; 16491 r = listPushS(&l, "1"); 16492 ck_assert_ptr_eq(r, l); 16493 r = listPushS(&l, "22"); 16494 ck_assert_ptr_eq(r, l); 16495 l2 = listCropS(l, 1,1); 16496 ck_assert_uint_eq(listLengthS(l2),0); 16497 ck_assert_ptr_eq(l2[0], NULL); 16498 ck_assert_str_eq(l[0], "1"); 16499 ck_assert_str_eq(l[1], "22"); 16500 ck_assert_ptr_eq(l[2], null); 16501 listFreeS(l); 16502 listFreeS(l2); 16503 // empty list 16504 listEmptyS(l) 16505 ck_assert_ptr_eq(listCropS(l, 0,0), NULL); 16506 ck_assert_ptr_eq(listCropS(l, -1,0), NULL); 16507 listFreeS(l); 16508 // NULL list 16509 ck_assert_ptr_eq(listCropS(NULL, 2,-4), NULL); 16510 16511 16512 } 16513 16514 16515 void iListCropST(CuTest *tc UNUSED) { 16516 16517 char **l = NULL; 16518 char **l2; 16519 char **r = null; 16520 16521 // list negative index 16522 r = listPushS(&l, "1"); 16523 ck_assert_ptr_eq(r, l); 16524 r = listPushS(&l, "22"); 16525 ck_assert_ptr_eq(r, l); 16526 r = listPushS(&l, "333"); 16527 ck_assert_ptr_eq(r, l); 16528 r = listPushS(&l, "4444"); 16529 ck_assert_ptr_eq(r, l); 16530 l2 = iListCropS(&l, 1,-1); 16531 ck_assert_uint_eq(listLengthS(l2),2); 16532 ck_assert_str_eq(l2[0], "22"); 16533 ck_assert_str_eq(l2[1], "333"); 16534 ck_assert_str_eq(l[0], "1"); 16535 ck_assert_str_eq(l[1], "4444"); 16536 ck_assert_ptr_eq(l[2], null); 16537 listFreeS(l2); 16538 // start outside 16539 ck_assert_ptr_eq(iListCropS(&l, 20,-4), NULL); 16540 // end outside 16541 l2 = iListCropS(&l, 0,40); 16542 ck_assert_uint_eq(listLengthS(l2),2); 16543 ck_assert_str_eq(l2[0], "1"); 16544 ck_assert_str_eq(l2[1], "4444"); 16545 ck_assert_ptr_eq(l[0], null); 16546 listFreeS(l2); 16547 listFreeS(l); 16548 // end negative and outside 16549 l = NULL; 16550 r = listPushS(&l, "1"); 16551 ck_assert_ptr_eq(r, l); 16552 r = listPushS(&l, "22"); 16553 ck_assert_ptr_eq(r, l); 16554 r = listPushS(&l, "333"); 16555 ck_assert_ptr_eq(r, l); 16556 r = listPushS(&l, "4444"); 16557 ck_assert_ptr_eq(r, l); 16558 ck_assert_ptr_eq(iListCropS(&l, 2,-40), NULL); 16559 ck_assert_str_eq(l[0], "1"); 16560 ck_assert_str_eq(l[1], "22"); 16561 ck_assert_str_eq(l[2], "333"); 16562 ck_assert_str_eq(l[3], "4444"); 16563 // end before start 16564 ck_assert_ptr_eq(iListCropS(&l, 3,2), NULL); 16565 ck_assert_str_eq(l[0], "1"); 16566 ck_assert_str_eq(l[1], "22"); 16567 ck_assert_str_eq(l[2], "333"); 16568 ck_assert_str_eq(l[3], "4444"); 16569 listFreeS(l); 16570 // negative start last element 16571 l = NULL; 16572 r = listPushS(&l, "1"); 16573 ck_assert_ptr_eq(r, l); 16574 r = listPushS(&l, "22"); 16575 ck_assert_ptr_eq(r, l); 16576 l2 = iListCropS(&l, -1,0); 16577 ck_assert_uint_eq(listLengthS(l2),1); 16578 ck_assert_str_eq(l2[0], "22"); 16579 ck_assert_str_eq(l[0], "1"); 16580 ck_assert_ptr_eq(l[1], null); 16581 listFreeS(l); 16582 listFreeS(l2); 16583 // start = end 16584 l = NULL; 16585 r = listPushS(&l, "1"); 16586 ck_assert_ptr_eq(r, l); 16587 r = listPushS(&l, "22"); 16588 ck_assert_ptr_eq(r, l); 16589 l2 = iListCropS(&l, 1,1); 16590 ck_assert_uint_eq(listLengthS(l2),0); 16591 ck_assert_ptr_eq(l2[0], NULL); 16592 ck_assert_str_eq(l[0], "1"); 16593 ck_assert_str_eq(l[1], "22"); 16594 ck_assert_ptr_eq(l[2], null); 16595 listFreeS(l); 16596 listFreeS(l2); 16597 // empty list 16598 listEmptyS(l) 16599 ck_assert_ptr_eq(iListCropS(&l, 0,0), NULL); 16600 ck_assert_ptr_eq(iListCropS(&l, -1,0), NULL); 16601 listFreeS(l); 16602 // NULL list 16603 l = null; 16604 ck_assert_ptr_eq(iListCropS(&l, 2,-4), NULL); 16605 ck_assert_ptr_eq(iListCropS(NULL, 2,-4), NULL); 16606 16607 16608 } 16609 16610 16611 void listCropElemST(CuTest *tc UNUSED) { 16612 16613 char **l = NULL; 16614 char *r; 16615 char **r2 = null; 16616 16617 // positive index 16618 r2 = listPushS(&l, "1"); 16619 ck_assert_ptr_eq(r2, l); 16620 r2 = listPushS(&l, "22"); 16621 ck_assert_ptr_eq(r2, l); 16622 r2 = listPushS(&l, "333"); 16623 ck_assert_ptr_eq(r2, l); 16624 r2 = listPushS(&l, "4444"); 16625 ck_assert_ptr_eq(r2, l); 16626 r = listCropElemS(l, 1); 16627 ck_assert_str_eq(r, "22"); 16628 ck_assert_str_eq(l[0], "1"); 16629 ck_assert_str_eq(l[1], "333"); 16630 ck_assert_str_eq(l[2], "4444"); 16631 ck_assert_ptr_eq(l[3], null); 16632 free(r); 16633 // list negative index 16634 r = listCropElemS(l, -1); 16635 ck_assert_str_eq(r, "4444"); 16636 ck_assert_str_eq(l[0], "1"); 16637 ck_assert_str_eq(l[1], "333"); 16638 ck_assert_ptr_eq(l[2], null); 16639 free(r); 16640 // index outside 16641 ck_assert_ptr_eq(listCropElemS(l, 20), NULL); 16642 ck_assert_ptr_eq(listCropElemS(l, -4), NULL); 16643 listFreeS(l); 16644 // empty list 16645 listEmptyS(l) 16646 ck_assert_ptr_eq(listCropElemS(l, 0), NULL); 16647 ck_assert_ptr_eq(listCropElemS(l, -1), NULL); 16648 listFreeS(l); 16649 // NULL list 16650 ck_assert_ptr_eq(listCropElemS(NULL, 2), NULL); 16651 16652 16653 } 16654 16655 16656 void iListCropElemST(CuTest *tc UNUSED) { 16657 16658 char **l = NULL; 16659 char *r; 16660 char **r2 = null; 16661 16662 // positive index 16663 r2 = listPushS(&l, "1"); 16664 ck_assert_ptr_eq(r2, l); 16665 r2 = listPushS(&l, "22"); 16666 ck_assert_ptr_eq(r2, l); 16667 r2 = listPushS(&l, "333"); 16668 ck_assert_ptr_eq(r2, l); 16669 r2 = listPushS(&l, "4444"); 16670 ck_assert_ptr_eq(r2, l); 16671 r = iListCropElemS(&l, 1); 16672 ck_assert_str_eq(r, "22"); 16673 ck_assert_str_eq(l[0], "1"); 16674 ck_assert_str_eq(l[1], "333"); 16675 ck_assert_str_eq(l[2], "4444"); 16676 ck_assert_ptr_eq(l[3], null); 16677 free(r); 16678 // list negative index 16679 r = iListCropElemS(&l, -1); 16680 ck_assert_str_eq(r, "4444"); 16681 ck_assert_str_eq(l[0], "1"); 16682 ck_assert_str_eq(l[1], "333"); 16683 ck_assert_ptr_eq(l[2], null); 16684 free(r); 16685 // index outside 16686 ck_assert_ptr_eq(iListCropElemS(&l, 20), NULL); 16687 ck_assert_ptr_eq(iListCropElemS(&l, -4), NULL); 16688 listFreeS(l); 16689 // empty list 16690 listEmptyS(l) 16691 ck_assert_ptr_eq(iListCropElemS(&l, 0), NULL); 16692 ck_assert_ptr_eq(iListCropElemS(&l, -1), NULL); 16693 listFreeS(l); 16694 // NULL list 16695 l = null; 16696 ck_assert_ptr_eq(iListCropElemS(&l, 2), NULL); 16697 ck_assert_ptr_eq(iListCropElemS(NULL, 2), NULL); 16698 16699 16700 } 16701 16702 16703 void listInsertST(CuTest *tc UNUSED) { 16704 16705 char **l; 16706 char **l2; 16707 char **r; 16708 16709 // insert 16710 l = listCreateS("1","22"); 16711 l2 = listCreateS("lib"); 16712 r = listInsertS(l, 0, l2); 16713 ck_assert_uint_eq(listLengthS(r),3); 16714 ck_assert_str_eq(r[0], "lib"); 16715 ck_assert_str_eq(r[1], "1"); 16716 ck_assert_str_eq(r[2], "22"); 16717 listFreeS(r); 16718 // negative index 16719 r = listInsertS(l, -1, l2); 16720 ck_assert_uint_eq(listLengthS(r),3); 16721 ck_assert_str_eq(r[0], "1"); 16722 ck_assert_str_eq(r[1], "22"); 16723 ck_assert_str_eq(r[2], "lib"); 16724 listFreeS(r); 16725 // edge 16726 r = listInsertS(l, 2, l2); 16727 ck_assert_uint_eq(listLengthS(r),3); 16728 ck_assert_str_eq(r[0], "1"); 16729 ck_assert_str_eq(r[1], "22"); 16730 ck_assert_str_eq(r[2], "lib"); 16731 listFreeS(r); 16732 // outside list 16733 r = listInsertS(l, 4, l2); 16734 ck_assert_ptr_eq(r, NULL); 16735 r = listInsertS(l, -4, l2); 16736 ck_assert_ptr_eq(r, NULL); 16737 listFreeS(l); 16738 // negative index in a one element list 16739 l = listCreateS("1"); 16740 r = listInsertS(l, -1, l2); 16741 ck_assert_str_eq(r[0], "1"); 16742 ck_assert_str_eq(r[1], "lib"); 16743 listFreeManyS(l,r); 16744 // empty list 16745 listEmptyS(l); 16746 r = listInsertS(l, 0, l2); 16747 ck_assert_str_eq(r[0], "lib"); 16748 listFreeManyS(r,l); 16749 listEmptyS(l); 16750 r = listInsertS(l, -1, l2); 16751 ck_assert_str_eq(r[0], "lib"); 16752 listFreeManyS(r,l, l2); 16753 // empty insert list 16754 l = listCreateS("1"); 16755 listEmptyS(l2); 16756 r = listInsertS(l, 0, l2); 16757 ck_assert_str_eq(r[0], "1"); 16758 listFreeManyS(r,l2); 16759 // NULL insert string 16760 r = listInsertS(l, 0, NULL); 16761 ck_assert_str_eq(r[0], "1"); 16762 listFreeManyS(r,l); 16763 // NULL list 16764 r = listInsertS(NULL, 0, NULL); 16765 ck_assert_ptr_eq(r, NULL); 16766 16767 16768 } 16769 16770 16771 void iListInsertST(CuTest *tc UNUSED) { 16772 16773 char **l; 16774 char **l2; 16775 char **r = null; 16776 16777 // insert 16778 l = listCreateS("1","22"); 16779 l2 = listCreateS("lib"); 16780 r = iListInsertS(&l, 0, l2); 16781 ck_assert_ptr_eq(r, l); 16782 ck_assert_uint_eq(listLengthS(l),3); 16783 ck_assert_str_eq(l[0], "lib"); 16784 ck_assert_str_eq(l[1], "1"); 16785 ck_assert_str_eq(l[2], "22"); 16786 free(l2); 16787 listFreeS(l); 16788 // negative index 16789 l = listCreateS("1","22"); 16790 l2 = listCreateS("lib"); 16791 r = iListInsertS(&l, -1, 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 // edge 16800 l = listCreateS("1","22"); 16801 l2 = listCreateS("lib"); 16802 r = iListInsertS(&l, 2, l2); 16803 ck_assert_ptr_eq(r, l); 16804 ck_assert_uint_eq(listLengthS(l),3); 16805 ck_assert_str_eq(l[0], "1"); 16806 ck_assert_str_eq(l[1], "22"); 16807 ck_assert_str_eq(l[2], "lib"); 16808 free(l2); 16809 listFreeS(l); 16810 // outside list 16811 l = listCreateS("1","22"); 16812 l2 = listCreateS("lib"); 16813 r = iListInsertS(&l, 4, l2); 16814 ck_assert_ptr_eq(r, null); 16815 ck_assert_uint_eq(listLengthS(l),2); 16816 ck_assert_str_eq(l[0], "1"); 16817 ck_assert_str_eq(l[1], "22"); 16818 r = iListInsertS(&l, -4, l2); 16819 ck_assert_ptr_eq(r, null); 16820 ck_assert_uint_eq(listLengthS(l),2); 16821 ck_assert_str_eq(l[0], "1"); 16822 ck_assert_str_eq(l[1], "22"); 16823 listFreeS(l); 16824 // negative index in a one element list 16825 l = listCreateS("1"); 16826 r = iListInsertS(&l, -1, l2); 16827 ck_assert_ptr_eq(r, l); 16828 ck_assert_str_eq(l[0], "1"); 16829 ck_assert_str_eq(l[1], "lib"); 16830 free(l2); 16831 listFreeS(l); 16832 // empty list 16833 listEmptyS(l); 16834 l2 = listCreateS("lib"); 16835 r = iListInsertS(&l, 0, l2); 16836 ck_assert_ptr_eq(r, l); 16837 ck_assert_str_eq(l[0], "lib"); 16838 free(l2); 16839 listFreeS(l); 16840 listEmptyS(l); 16841 l2 = listCreateS("lib"); 16842 r = iListInsertS(&l, -1, l2); 16843 ck_assert_ptr_eq(r, l); 16844 ck_assert_str_eq(l[0], "lib"); 16845 free(l2); 16846 listFreeS(l); 16847 // empty insert list 16848 l = listCreateS("1"); 16849 listEmptyS(l2); 16850 r = iListInsertS(&l, 0, l2); 16851 ck_assert_ptr_eq(r, l); 16852 ck_assert_str_eq(l[0], "1"); 16853 listFreeS(l2); 16854 // NULL insert string 16855 r = iListInsertS(&l, 0, NULL); 16856 ck_assert_ptr_eq(r, null); 16857 ck_assert_str_eq(l[0], "1"); 16858 listFreeS(l); 16859 // NULL list and list to insert at index 0 16860 l = NULL; 16861 l2 = listCreateS("lib"); 16862 r = iListInsertS(&l, 0, l2); 16863 ck_assert_ptr_eq(r, l); 16864 ck_assert_str_eq(l[0], "lib"); 16865 free(l2); 16866 listFreeS(l); 16867 // NULL list and list to insert at non 0 index 16868 l = NULL; 16869 l2 = listCreateS("lib"); 16870 r = iListInsertS(&l, -1, l2); 16871 ck_assert_ptr_eq(r, null); 16872 ck_assert_ptr_eq(l, NULL); 16873 listFreeS(l2); 16874 // NULL list 16875 l = NULL; 16876 r = iListInsertS(&l, 0, NULL); 16877 ck_assert_ptr_eq(r, null); 16878 ck_assert_ptr_eq(l, NULL); 16879 // NULL var 16880 r = iListInsertS(NULL, 0, NULL); 16881 ck_assert_ptr_eq(r, null); 16882 16883 16884 } 16885 16886 16887 void iListInsertNFreeST(CuTest *tc UNUSED) { 16888 16889 char **l, **r; 16890 char **l2; 16891 16892 // insert 16893 l = listCreateS("1","22"); 16894 l2 = listCreateS("lib"); 16895 r = iListInsertNFreeS(&l, 0, l2); 16896 ck_assert_ptr_eq(r, l); 16897 ck_assert_uint_eq(listLengthS(l),3); 16898 ck_assert_str_eq(l[0], "lib"); 16899 ck_assert_str_eq(l[1], "1"); 16900 ck_assert_str_eq(l[2], "22"); 16901 listFreeS(l); 16902 // negative index 16903 l = listCreateS("1","22"); 16904 l2 = listCreateS("lib"); 16905 r = iListInsertNFreeS(&l, -1, l2); 16906 ck_assert_ptr_eq(r, l); 16907 ck_assert_uint_eq(listLengthS(l),3); 16908 ck_assert_str_eq(l[0], "1"); 16909 ck_assert_str_eq(l[1], "22"); 16910 ck_assert_str_eq(l[2], "lib"); 16911 listFreeS(l); 16912 // edge 16913 l = listCreateS("1","22"); 16914 l2 = listCreateS("lib"); 16915 r = iListInsertNFreeS(&l, 2, l2); 16916 ck_assert_ptr_eq(r, l); 16917 ck_assert_uint_eq(listLengthS(l),3); 16918 ck_assert_str_eq(l[0], "1"); 16919 ck_assert_str_eq(l[1], "22"); 16920 ck_assert_str_eq(l[2], "lib"); 16921 listFreeS(l); 16922 // outside list 16923 l = listCreateS("1","22"); 16924 l2 = listCreateS("lib"); 16925 r = iListInsertNFreeS(&l, 4, l2); 16926 ck_assert_ptr_eq(r, NULL); 16927 // free L2 since it is not freed because iListInsertNFreeS failed 16928 listFreeS(l2); 16929 ck_assert_uint_eq(listLengthS(l),2); 16930 ck_assert_str_eq(l[0], "1"); 16931 ck_assert_str_eq(l[1], "22"); 16932 l2 = listCreateS("lib"); 16933 r = iListInsertNFreeS(&l, -4, l2); 16934 ck_assert_ptr_eq(r, NULL); 16935 // free L2 since it is not freed because iListInsertNFreeS failed 16936 listFreeS(l2); 16937 ck_assert_uint_eq(listLengthS(l),2); 16938 ck_assert_str_eq(l[0], "1"); 16939 ck_assert_str_eq(l[1], "22"); 16940 listFreeS(l); 16941 // negative index in a one element list 16942 l = listCreateS("1"); 16943 l2 = listCreateS("lib"); 16944 r = iListInsertNFreeS(&l, -1, l2); 16945 ck_assert_ptr_eq(r, l); 16946 ck_assert_str_eq(l[0], "1"); 16947 ck_assert_str_eq(l[1], "lib"); 16948 listFreeS(l); 16949 // empty list 16950 listEmptyS(l); 16951 l2 = listCreateS("lib"); 16952 r = iListInsertNFreeS(&l, 0, l2); 16953 ck_assert_ptr_eq(r, l); 16954 ck_assert_str_eq(l[0], "lib"); 16955 listFreeS(l); 16956 listEmptyS(l); 16957 l2 = listCreateS("lib"); 16958 r = iListInsertNFreeS(&l, -1, l2); 16959 ck_assert_ptr_eq(r, l); 16960 ck_assert_str_eq(l[0], "lib"); 16961 listFreeS(l); 16962 // empty insert list 16963 l = listCreateS("1"); 16964 listEmptyS(l2); 16965 r = iListInsertNFreeS(&l, 0, l2); 16966 ck_assert_ptr_eq(r, l); 16967 ck_assert_str_eq(l[0], "1"); 16968 // NULL insert string 16969 r = iListInsertNFreeS(&l, 0, NULL); 16970 ck_assert_ptr_eq(r, null); 16971 ck_assert_str_eq(l[0], "1"); 16972 listFreeS(l); 16973 // NULL list 16974 l = NULL; 16975 l2 = listCreateS("lib"); 16976 r = iListInsertNFreeS(&l, 0, l2); 16977 ck_assert_ptr_eq(r, l); 16978 ck_assert_str_eq(l[0], "lib"); 16979 listFreeS(l); 16980 // NULL var 16981 l2 = listCreateS("lib"); 16982 l = iListInsertNFreeS(NULL, 0, l2); 16983 ck_assert_ptr_eq(l, NULL); 16984 // free L2 since it is not freed because iListInsertNFreeS failed 16985 listFreeS(l2); 16986 16987 } 16988 16989 16990 void listInjectST(CuTest *tc UNUSED) { 16991 16992 char **l; 16993 char **r; 16994 16995 // insert 16996 l = listCreateS("1","22"); 16997 r = listInjectS(l, 0, "lib"); 16998 ck_assert_uint_eq(listLengthS(r),3); 16999 ck_assert_str_eq(r[0], "lib"); 17000 ck_assert_str_eq(r[1], "1"); 17001 ck_assert_str_eq(r[2], "22"); 17002 listFreeS(r); 17003 // negative index 17004 r = listInjectS(l, -1, "lib"); 17005 ck_assert_uint_eq(listLengthS(r),3); 17006 ck_assert_str_eq(r[0], "1"); 17007 ck_assert_str_eq(r[1], "22"); 17008 ck_assert_str_eq(r[2], "lib"); 17009 listFreeS(r); 17010 // edge 17011 r = listInjectS(l, 2, "lib"); 17012 ck_assert_uint_eq(listLengthS(r),3); 17013 ck_assert_str_eq(r[0], "1"); 17014 ck_assert_str_eq(r[1], "22"); 17015 ck_assert_str_eq(r[2], "lib"); 17016 listFreeS(r); 17017 // outside list 17018 r = listInjectS(l, 4, "lib"); 17019 ck_assert_ptr_eq(r, NULL); 17020 r = listInjectS(l, -4, "lib"); 17021 ck_assert_ptr_eq(r, NULL); 17022 listFreeS(l); 17023 // negative index in a one element list 17024 l = listCreateS("1"); 17025 r = listInjectS(l, -1, "lib"); 17026 ck_assert_str_eq(r[0], "1"); 17027 ck_assert_str_eq(r[1], "lib"); 17028 listFreeManyS(l,r); 17029 // empty list 17030 listEmptyS(l); 17031 r = listInjectS(l, 0, "lib"); 17032 ck_assert_str_eq(r[0], "lib"); 17033 listFreeManyS(r,l); 17034 listEmptyS(l); 17035 r = listInjectS(l, -1, "lib"); 17036 ck_assert_str_eq(r[0], "lib"); 17037 listFreeManyS(r,l); 17038 // NULL insert string 17039 l = listCreateS("1"); 17040 r = listInjectS(l, 0, NULL); 17041 ck_assert_ptr_eq(r, NULL); 17042 listFreeManyS(l,r); 17043 // NULL list 17044 r = listInjectS(NULL, 0, NULL); 17045 ck_assert_ptr_eq(r, NULL); 17046 17047 17048 } 17049 17050 17051 void listInjectCharST(CuTest *tc UNUSED) { 17052 17053 char **l; 17054 char **r; 17055 17056 // insert 17057 l = listCreateS("1","22"); 17058 r = listInjectCharS(l, 0, 'l'); 17059 ck_assert_uint_eq(listLengthS(r),3); 17060 ck_assert_str_eq(r[0], "l"); 17061 ck_assert_str_eq(r[1], "1"); 17062 ck_assert_str_eq(r[2], "22"); 17063 listFreeS(r); 17064 // negative index 17065 r = listInjectCharS(l, -1, 'l'); 17066 ck_assert_uint_eq(listLengthS(r),3); 17067 ck_assert_str_eq(r[0], "1"); 17068 ck_assert_str_eq(r[1], "22"); 17069 ck_assert_str_eq(r[2], "l"); 17070 listFreeS(r); 17071 // edge 17072 r = listInjectCharS(l, 2, 'l'); 17073 ck_assert_uint_eq(listLengthS(r),3); 17074 ck_assert_str_eq(r[0], "1"); 17075 ck_assert_str_eq(r[1], "22"); 17076 ck_assert_str_eq(r[2], "l"); 17077 listFreeS(r); 17078 // outside list 17079 r = listInjectCharS(l, 4, 'l'); 17080 ck_assert_ptr_eq(r, NULL); 17081 r = listInjectCharS(l, -4, 'l'); 17082 ck_assert_ptr_eq(r, NULL); 17083 listFreeS(l); 17084 // negative index in a one element list 17085 l = listCreateS("1"); 17086 r = listInjectCharS(l, -1, 'l'); 17087 ck_assert_str_eq(r[0], "1"); 17088 ck_assert_str_eq(r[1], "l"); 17089 listFreeManyS(l,r); 17090 // empty list 17091 listEmptyS(l); 17092 r = listInjectCharS(l, 0, 'l'); 17093 ck_assert_str_eq(r[0], "l"); 17094 listFreeManyS(r,l); 17095 listEmptyS(l); 17096 r = listInjectCharS(l, -1, 'l'); 17097 ck_assert_str_eq(r[0], "l"); 17098 listFreeManyS(r,l); 17099 // NULL list 17100 r = listInjectCharS(NULL, 0, 'l'); 17101 ck_assert_str_eq(r[0], "l"); 17102 ck_assert_ptr_eq(r[1], NULL); 17103 listFreeS(r); 17104 17105 17106 } 17107 17108 17109 void iListInjectST(CuTest *tc UNUSED) { 17110 17111 char **l; 17112 char **r = null; 17113 17114 // insert 17115 l = listCreateS("1","22"); 17116 r = iListInjectS(&l, 0, strdup("lib")); 17117 ck_assert_ptr_eq(r, l); 17118 ck_assert_uint_eq(listLengthS(l),3); 17119 ck_assert_str_eq(l[0], "lib"); 17120 ck_assert_str_eq(l[1], "1"); 17121 ck_assert_str_eq(l[2], "22"); 17122 listFreeS(l); 17123 // negative index 17124 l = listCreateS("1","22"); 17125 r = iListInjectS(&l, -1, strdup("lib")); 17126 ck_assert_ptr_eq(r, l); 17127 ck_assert_uint_eq(listLengthS(l),3); 17128 ck_assert_str_eq(l[0], "1"); 17129 ck_assert_str_eq(l[1], "22"); 17130 ck_assert_str_eq(l[2], "lib"); 17131 listFreeS(l); 17132 // edge 17133 l = listCreateS("1","22"); 17134 r = iListInjectS(&l, 2, strdup("lib")); 17135 ck_assert_ptr_eq(r, l); 17136 ck_assert_uint_eq(listLengthS(l),3); 17137 ck_assert_str_eq(l[0], "1"); 17138 ck_assert_str_eq(l[1], "22"); 17139 ck_assert_str_eq(l[2], "lib"); 17140 listFreeS(l); 17141 // outside list 17142 l = listCreateS("1","22"); 17143 r = iListInjectS(&l, 4, "lib"); 17144 ck_assert_ptr_eq(r, null); 17145 ck_assert_uint_eq(listLengthS(l),2); 17146 ck_assert_str_eq(l[0], "1"); 17147 ck_assert_str_eq(l[1], "22"); 17148 r = iListInjectS(&l, -4, "lib"); 17149 ck_assert_ptr_eq(r, null); 17150 ck_assert_uint_eq(listLengthS(l),2); 17151 ck_assert_str_eq(l[0], "1"); 17152 ck_assert_str_eq(l[1], "22"); 17153 listFreeS(l); 17154 // negative index in a one element list 17155 l = listCreateS("1"); 17156 r = iListInjectS(&l, -1, strdup("lib")); 17157 ck_assert_ptr_eq(r, l); 17158 ck_assert_str_eq(l[0], "1"); 17159 ck_assert_str_eq(l[1], "lib"); 17160 listFreeS(l); 17161 // empty list 17162 listEmptyS(l); 17163 r = iListInjectS(&l, 0, strdup("lib")); 17164 ck_assert_ptr_eq(r, l); 17165 ck_assert_str_eq(l[0], "lib"); 17166 listFreeS(l); 17167 listEmptyS(l); 17168 r = iListInjectS(&l, -1, strdup("lib")); 17169 ck_assert_ptr_eq(r, l); 17170 ck_assert_str_eq(l[0], "lib"); 17171 listFreeS(l); 17172 // NULL insert string 17173 l = listCreateS("1"); 17174 r = iListInjectS(&l, 0, NULL); 17175 ck_assert_ptr_eq(r, null); 17176 ck_assert_str_eq(l[0], "1"); 17177 listFreeS(l); 17178 // NULL list and non zero index 17179 l = NULL; 17180 r = iListInjectS(&l, 1, ""); 17181 ck_assert_ptr_eq(r, null); 17182 ck_assert_ptr_eq(l, NULL); 17183 // NULL list and zero index 17184 l = NULL; 17185 r = iListInjectS(&l, 0, "aa"); 17186 ck_assert_ptr_eq(r, l); 17187 ck_assert_str_eq(l[0], "aa"); 17188 free(l); 17189 // NULL var 17190 r = iListInjectS(NULL, 0, ""); 17191 ck_assert_ptr_eq(r, null); 17192 17193 17194 } 17195 17196 17197 void iListInjectCharST(CuTest *tc UNUSED) { 17198 17199 char **l; 17200 char **r = null; 17201 17202 // insert 17203 l = listCreateS("1","22"); 17204 r = iListInjectCharS(&l, 1, 'a'); 17205 ck_assert_ptr_eq(r, l); 17206 ck_assert_uint_eq(listLengthS(l),3); 17207 ck_assert_str_eq(l[0], "1"); 17208 ck_assert_str_eq(l[1], "a"); 17209 ck_assert_str_eq(l[2], "22"); 17210 listFreeS(l); 17211 // NULL list and zero index 17212 l = NULL; 17213 r = iListInjectCharS(&l, 0, 'a'); 17214 ck_assert_ptr_eq(r, l); 17215 ck_assert_str_eq(l[0], "a"); 17216 listFreeS(l); 17217 // NULL list and non zero index 17218 l = NULL; 17219 r = iListInjectCharS(&l, 1, 'a'); 17220 ck_assert_ptr_eq(r, l); 17221 ck_assert_ptr_eq(l, NULL); 17222 // NULL var 17223 r = iListInjectCharS(NULL, 1, 'a'); 17224 ck_assert_ptr_eq(r, null); 17225 17226 } 17227 17228 17229 void listDelST(CuTest *tc UNUSED) { 17230 17231 char **l = NULL; 17232 char **l2; 17233 char **r = null; 17234 17235 // list negative index 17236 r = listPushS(&l, "1"); 17237 ck_assert_ptr_eq(r, l); 17238 r = listPushS(&l, "22"); 17239 ck_assert_ptr_eq(r, l); 17240 r = listPushS(&l, "333"); 17241 ck_assert_ptr_eq(r, l); 17242 r = listPushS(&l, "4444"); 17243 ck_assert_ptr_eq(r, l); 17244 l2 = listDelS(l, 1,-1); 17245 ck_assert_uint_eq(listLengthS(l2),2); 17246 ck_assert_str_eq(l2[0], "1"); 17247 ck_assert_str_eq(l2[1], "4444"); 17248 listFreeS(l2); 17249 // start outside 17250 ck_assert_ptr_eq(listDelS(l, 20,-4), NULL); 17251 // end outside 17252 l2 = listDelS(l, 2,40); 17253 ck_assert_uint_eq(listLengthS(l2),2); 17254 ck_assert_str_eq(l2[0], "1"); 17255 ck_assert_str_eq(l2[1], "22"); 17256 listFreeS(l2); 17257 // end negative and outside 17258 ck_assert_ptr_eq(listDelS(l, 2,-40), NULL); 17259 // end before start 17260 ck_assert_ptr_eq(listDelS(l, 3,2), NULL); 17261 listFreeS(l); 17262 // negative start last element 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, -1,0); 17269 ck_assert_uint_eq(listLengthS(l2),1); 17270 ck_assert_str_eq(l2[0], "1"); 17271 listFreeS(l); 17272 listFreeS(l2); 17273 // start negative and outside (delete complete list because end is 0 (=len)) 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, -3,0); 17280 ck_assert_uint_eq(listLengthS(l2),0); 17281 ck_assert_ptr_eq(l2[0], NULL); 17282 listFreeS(l); 17283 listFreeS(l2); 17284 // start = end 17285 l = NULL; 17286 r = listPushS(&l, "1"); 17287 ck_assert_ptr_eq(r, l); 17288 r = listPushS(&l, "22"); 17289 ck_assert_ptr_eq(r, l); 17290 l2 = listDelS(l, 1,1); 17291 ck_assert_uint_eq(listLengthS(l2),2); 17292 ck_assert_str_eq(l2[0], "1"); 17293 ck_assert_str_eq(l2[1], "22"); 17294 listFreeS(l); 17295 listFreeS(l2); 17296 // empty list 17297 listEmptyS(l) 17298 ck_assert_ptr_eq(listDelS(l, 0,0), NULL); 17299 ck_assert_ptr_eq(listDelS(l, -1,0), NULL); 17300 listFreeS(l); 17301 // NULL list 17302 ck_assert_ptr_eq(listDelS(NULL, 2,-4), NULL); 17303 17304 17305 } 17306 17307 17308 void iListDelST(CuTest *tc UNUSED) { 17309 17310 char **l = NULL; 17311 char **r = null; 17312 17313 // list negative index 17314 r = listPushS(&l, "1"); 17315 ck_assert_ptr_eq(r, l); 17316 r = listPushS(&l, "22"); 17317 ck_assert_ptr_eq(r, l); 17318 r = listPushS(&l, "333"); 17319 ck_assert_ptr_eq(r, l); 17320 r = listPushS(&l, "4444"); 17321 ck_assert_ptr_eq(r, l); 17322 r = iListDelS(&l, 1,-1); 17323 ck_assert_ptr_eq(r, l); 17324 ck_assert_uint_eq(listLengthS(l),2); 17325 ck_assert_str_eq(l[0], "1"); 17326 ck_assert_str_eq(l[1], "4444"); 17327 r = iListEmptySF(&l); 17328 ck_assert_ptr_eq(r, l); 17329 // start outside 17330 r = listPushS(&l, "1"); 17331 ck_assert_ptr_eq(r, l); 17332 r = listPushS(&l, "22"); 17333 ck_assert_ptr_eq(r, l); 17334 r = listPushS(&l, "333"); 17335 ck_assert_ptr_eq(r, l); 17336 r = listPushS(&l, "4444"); 17337 ck_assert_ptr_eq(r, l); 17338 r = iListDelS(&l, 20,-4); 17339 ck_assert_ptr_eq(r, null); 17340 ck_assert_uint_eq(listLengthS(l),4); 17341 ck_assert_str_eq(l[0], "1"); 17342 ck_assert_str_eq(l[3], "4444"); 17343 // end outside 17344 r = iListDelS(&l, 2,40); 17345 ck_assert_ptr_eq(r, l); 17346 ck_assert_uint_eq(listLengthS(l),2); 17347 ck_assert_str_eq(l[0], "1"); 17348 ck_assert_str_eq(l[1], "22"); 17349 r = iListEmptySF(&l); 17350 ck_assert_ptr_eq(r, l); 17351 // end negative and outside 17352 r = listPushS(&l, "1"); 17353 ck_assert_ptr_eq(r, l); 17354 r = listPushS(&l, "22"); 17355 ck_assert_ptr_eq(r, l); 17356 r = listPushS(&l, "333"); 17357 ck_assert_ptr_eq(r, l); 17358 r = listPushS(&l, "4444"); 17359 ck_assert_ptr_eq(r, l); 17360 r = iListDelS(&l, 2,-40); 17361 ck_assert_ptr_eq(r, null); 17362 ck_assert_uint_eq(listLengthS(l),4); 17363 ck_assert_str_eq(l[0], "1"); 17364 ck_assert_str_eq(l[3], "4444"); 17365 // end before start 17366 r = iListDelS(&l, 3,2); 17367 ck_assert_ptr_eq(r, null); 17368 ck_assert_uint_eq(listLengthS(l),4); 17369 ck_assert_str_eq(l[0], "1"); 17370 ck_assert_str_eq(l[3], "4444"); 17371 r = iListEmptySF(&l); 17372 ck_assert_ptr_eq(r, l); 17373 // negative start last element 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, -1,0); 17379 ck_assert_ptr_eq(r, l); 17380 ck_assert_uint_eq(listLengthS(l),1); 17381 ck_assert_str_eq(l[0], "1"); 17382 r = iListEmptySF(&l); 17383 ck_assert_ptr_eq(r, l); 17384 // start negative and outside (delete complete list because end is 0 (=len)) 17385 r = listPushS(&l, "1"); 17386 ck_assert_ptr_eq(r, l); 17387 r = listPushS(&l, "22"); 17388 ck_assert_ptr_eq(r, l); 17389 r = iListDelS(&l, -3,0); 17390 ck_assert_ptr_eq(r, l); 17391 ck_assert_uint_eq(listLengthS(l),0); 17392 ck_assert_ptr_eq(l[0], NULL); 17393 // start = end 17394 // (l is empty from previous test) 17395 r = listPushS(&l, "1"); 17396 ck_assert_ptr_eq(r, l); 17397 r = listPushS(&l, "22"); 17398 ck_assert_ptr_eq(r, l); 17399 r = iListDelS(&l, 1,1); 17400 ck_assert_ptr_eq(r, l); 17401 ck_assert_uint_eq(listLengthS(l),2); 17402 ck_assert_str_eq(l[0], "1"); 17403 ck_assert_str_eq(l[1], "22"); 17404 listFreeS(l); 17405 // empty list 17406 listEmptyS(l); 17407 r = iListDelS(&l, 0,0); 17408 ck_assert_ptr_eq(r, null); 17409 ck_assert(listIsEmptyS(l)); 17410 r = iListDelS(&l, -1,0); 17411 ck_assert_ptr_eq(r, null); 17412 ck_assert(listIsEmptyS(l)); 17413 listFreeS(l); 17414 // NULL list 17415 l = NULL; 17416 r = iListDelS(&l, 2,-4); 17417 ck_assert_ptr_eq(r, null); 17418 ck_assert_ptr_eq(l, NULL); 17419 // NULL var 17420 r = iListDelS(NULL, 2,-4); 17421 ck_assert_ptr_eq(r, null); 17422 17423 17424 } 17425 17426 17427 void iListRemoveST(CuTest *tc UNUSED) { 17428 17429 char **l = NULL; 17430 char **r = null; 17431 17432 // list negative index 17433 r = listPushS(&l, "1"); 17434 ck_assert_ptr_eq(r, l); 17435 r = iListPushS(&l, "22"); 17436 ck_assert_ptr_eq(r, l); 17437 r = iListPushS(&l, "333"); 17438 ck_assert_ptr_eq(r, l); 17439 r = listPushS(&l, "4444"); 17440 ck_assert_ptr_eq(r, l); 17441 iListRemoveS(&l, 1,-1); 17442 ck_assert_uint_eq(listLengthS(l),2); 17443 ck_assert_str_eq(l[0], "1"); 17444 ck_assert_str_eq(l[1], "4444"); 17445 r = iListEmptySF(&l); 17446 ck_assert_ptr_eq(r, l); 17447 // start outside 17448 r = listPushS(&l, "1"); 17449 ck_assert_ptr_eq(r, l); 17450 r = listPushS(&l, "22"); 17451 ck_assert_ptr_eq(r, l); 17452 r = iListPushS(&l, "333"); 17453 ck_assert_ptr_eq(r, l); 17454 r = iListPushS(&l, "4444"); 17455 ck_assert_ptr_eq(r, l); 17456 iListRemoveS(&l, 20,-4); 17457 ck_assert_uint_eq(listLengthS(l),4); 17458 ck_assert_str_eq(l[0], "1"); 17459 ck_assert_str_eq(l[3], "4444"); 17460 // end outside 17461 iListRemoveS(&l, 2,40); 17462 ck_assert_uint_eq(listLengthS(l),2); 17463 ck_assert_str_eq(l[0], "1"); 17464 ck_assert_str_eq(l[1], "22"); 17465 r = iListEmptySF(&l); 17466 ck_assert_ptr_eq(r, l); 17467 // end negative and outside 17468 r = listPushS(&l, "1"); 17469 ck_assert_ptr_eq(r, l); 17470 r = listPushS(&l, "22"); 17471 ck_assert_ptr_eq(r, l); 17472 r = listPushS(&l, "333"); 17473 ck_assert_ptr_eq(r, l); 17474 r = listPushS(&l, "4444"); 17475 ck_assert_ptr_eq(r, l); 17476 iListRemoveS(&l, 2,-40); 17477 ck_assert_uint_eq(listLengthS(l),4); 17478 ck_assert_str_eq(l[0], "1"); 17479 ck_assert_str_eq(l[3], "4444"); 17480 // end before start 17481 iListRemoveS(&l, 3,2); 17482 ck_assert_uint_eq(listLengthS(l),4); 17483 ck_assert_str_eq(l[0], "1"); 17484 ck_assert_str_eq(l[3], "4444"); 17485 r = iListEmptySF(&l); 17486 ck_assert_ptr_eq(r, l); 17487 // negative start last element 17488 r = listPushS(&l, "1"); 17489 ck_assert_ptr_eq(r, l); 17490 r = iListPushS(&l, "22"); 17491 ck_assert_ptr_eq(r, l); 17492 iListRemoveS(&l, -1,0); 17493 ck_assert_uint_eq(listLengthS(l),1); 17494 ck_assert_str_eq(l[0], "1"); 17495 r = iListEmptySF(&l); 17496 ck_assert_ptr_eq(r, l); 17497 // start negative and outside (delete complete list because end is 0 (=len)) 17498 r = iListPushS(&l, "1"); 17499 ck_assert_ptr_eq(r, l); 17500 r = iListPushS(&l, "22"); 17501 ck_assert_ptr_eq(r, l); 17502 iListRemoveS(&l, -3,0); 17503 ck_assert_uint_eq(listLengthS(l),0); 17504 ck_assert_ptr_eq(l[0], NULL); 17505 // start = end 17506 // (l is empty from previous test) 17507 r = listPushS(&l, "1"); 17508 ck_assert_ptr_eq(r, l); 17509 r = listPushS(&l, "22"); 17510 ck_assert_ptr_eq(r, l); 17511 iListRemoveS(&l, 1,1); 17512 ck_assert_uint_eq(listLengthS(l),2); 17513 ck_assert_str_eq(l[0], "1"); 17514 ck_assert_str_eq(l[1], "22"); 17515 listFreeS(l); 17516 // empty list 17517 listEmptyS(l); 17518 iListRemoveS(&l, 0,0); 17519 ck_assert(listIsEmptyS(l)); 17520 iListRemoveS(&l, -1,0); 17521 ck_assert(listIsEmptyS(l)); 17522 listFreeS(l); 17523 // NULL list 17524 l = NULL; 17525 iListRemoveS(&l, 2,-4); 17526 ck_assert_ptr_eq(l, NULL); 17527 // NULL var 17528 ck_assert_ptr_eq(iListRemoveS(NULL, 2,-4), NULL); 17529 17530 17531 } 17532 17533 17534 void listDelElemST(CuTest *tc UNUSED) { 17535 17536 char **l = NULL; 17537 char **l2; 17538 char **r = null; 17539 17540 // positive index 17541 r = listPushS(&l, "1"); 17542 ck_assert_ptr_eq(r, l); 17543 r = listPushS(&l, "22"); 17544 ck_assert_ptr_eq(r, l); 17545 r = listPushS(&l, "333"); 17546 ck_assert_ptr_eq(r, l); 17547 r = listPushS(&l, "4444"); 17548 ck_assert_ptr_eq(r, l); 17549 l2 = listDelElemS(l, 1); 17550 ck_assert_str_eq(l2[0], "1"); 17551 ck_assert_str_eq(l2[1], "333"); 17552 ck_assert_str_eq(l2[2], "4444"); 17553 ck_assert_ptr_eq(l2[3], null); 17554 listFreeS(l2); 17555 // list negative index 17556 l2 = listDelElemS(l, -1); 17557 ck_assert_str_eq(l2[0], "1"); 17558 ck_assert_str_eq(l2[1], "22"); 17559 ck_assert_str_eq(l2[2], "333"); 17560 ck_assert_ptr_eq(l2[3], null); 17561 listFreeS(l2); 17562 // index outside 17563 ck_assert_ptr_eq(listDelElemS(l, 20), NULL); 17564 ck_assert_ptr_eq(listDelElemS(l, -5), NULL); 17565 listFreeS(l); 17566 // empty list 17567 listEmptyS(l) 17568 ck_assert_ptr_eq(listDelElemS(l, 0), NULL); 17569 ck_assert_ptr_eq(listDelElemS(l, -1), NULL); 17570 listFreeS(l); 17571 // NULL list 17572 ck_assert_ptr_eq(listDelElemS(NULL, 2), NULL); 17573 17574 17575 } 17576 17577 17578 void iListDelElemST(CuTest *tc UNUSED) { 17579 17580 char **l = NULL; 17581 char **r; 17582 17583 // positive index 17584 r = listPushS(&l, "1"); 17585 ck_assert_ptr_eq(r, l); 17586 r = listPushS(&l, "22"); 17587 ck_assert_ptr_eq(r, l); 17588 r = listPushS(&l, "333"); 17589 ck_assert_ptr_eq(r, l); 17590 r = listPushS(&l, "4444"); 17591 ck_assert_ptr_eq(r, l); 17592 r = iListDelElemS(&l, 1); 17593 ck_assert_ptr_ne(r, null); 17594 ck_assert_str_eq(l[0], "1"); 17595 ck_assert_str_eq(l[1], "333"); 17596 ck_assert_str_eq(l[2], "4444"); 17597 ck_assert_ptr_eq(l[3], null); 17598 // list negative index 17599 r = iListDelElemS(&l, -1); 17600 ck_assert_ptr_ne(r, null); 17601 ck_assert_str_eq(l[0], "1"); 17602 ck_assert_str_eq(l[1], "333"); 17603 ck_assert_ptr_eq(l[2], null); 17604 // index outside 17605 ck_assert_ptr_eq(iListDelElemS(&l, 20), NULL); 17606 ck_assert_ptr_eq(iListDelElemS(&l, -4), NULL); 17607 listFreeS(l); 17608 // empty list 17609 listEmptyS(l) 17610 ck_assert_ptr_eq(iListDelElemS(&l, 0), NULL); 17611 ck_assert_ptr_eq(iListDelElemS(&l, -1), NULL); 17612 listFreeS(l); 17613 // NULL list 17614 l = null; 17615 ck_assert_ptr_eq(iListDelElemS(&l, 2), NULL); 17616 ck_assert_ptr_eq(iListDelElemS(NULL, 2), NULL); 17617 17618 17619 } 17620 17621 17622 void iListRemoveElemST(CuTest *tc UNUSED) { 17623 17624 char **l = NULL; 17625 char **r; 17626 17627 // positive index 17628 r = listPushS(&l, "1"); 17629 ck_assert_ptr_eq(r, l); 17630 r = iListPushS(&l, "22"); 17631 ck_assert_ptr_eq(r, l); 17632 r = listPushS(&l, "333"); 17633 ck_assert_ptr_eq(r, l); 17634 r = iListPushS(&l, "4444"); 17635 ck_assert_ptr_eq(r, l); 17636 r = iListRemoveElemS(&l, 1); 17637 ck_assert_ptr_ne(r, null); 17638 ck_assert_str_eq(l[0], "1"); 17639 ck_assert_str_eq(l[1], "333"); 17640 ck_assert_str_eq(l[2], "4444"); 17641 ck_assert_ptr_eq(l[3], null); 17642 // list negative index 17643 r = iListRemoveElemS(&l, -1); 17644 ck_assert_ptr_ne(r, null); 17645 ck_assert_str_eq(l[0], "1"); 17646 ck_assert_str_eq(l[1], "333"); 17647 ck_assert_ptr_eq(l[2], null); 17648 // index outside 17649 ck_assert_ptr_eq(iListRemoveElemS(&l, 20), NULL); 17650 ck_assert_ptr_eq(iListRemoveElemS(&l, -4), NULL); 17651 listFreeS(l); 17652 // empty list 17653 listEmptyS(l) 17654 ck_assert_ptr_eq(iListRemoveElemS(&l, 0), NULL); 17655 ck_assert_ptr_eq(iListRemoveElemS(&l, -1), NULL); 17656 listFreeS(l); 17657 // NULL list 17658 l = null; 17659 ck_assert_ptr_eq(iListRemoveElemS(&l, 2), NULL); 17660 ck_assert_ptr_eq(iListRemoveElemS(NULL, 2), NULL); 17661 17662 17663 } 17664 17665 17666 void execOutT(CuTest *tc UNUSED) { 17667 17668 char **l; 17669 17670 // command 17671 l = execOut("ls chmodTest.null"); 17672 ck_assert_uint_eq(listLengthS(l),1); 17673 ck_assert_str_eq(l[0], "chmodTest.null"); 17674 listFreeS(l); 17675 17676 // invalid command 17677 l = execOut("randomCommand"); 17678 ck_assert_uint_eq(listLengthS(l),0); 17679 ck_assert_ptr_eq(l[0], NULL); 17680 listFreeS(l); 17681 // NULL command 17682 ck_assert_ptr_eq(execOut(NULL), NULL); 17683 17684 } 17685 17686 17687 void systemOutfT(CuTest *tc UNUSED) { 17688 17689 char **l; 17690 17691 // command 17692 l = systemOutf("ls %s", "chmodTest.null"); 17693 ck_assert_uint_eq(listLengthS(l),1); 17694 ck_assert_str_eq(l[0], "chmodTest.null"); 17695 listFreeS(l); 17696 17697 // invalid command 17698 l = systemOutf("randomCommand"); 17699 ck_assert_uint_eq(listLengthS(l),0); 17700 ck_assert_ptr_eq(l[0], NULL); 17701 listFreeS(l); 17702 // NULL command 17703 ck_assert_ptr_eq(systemOutf(NULL), NULL); 17704 17705 17706 } 17707 17708 17709 void systemfT(CuTest *tc UNUSED) { 17710 17711 int r; 17712 17713 // command 17714 r = systemf("ls %s", "chmodTest.null"); 17715 ck_assert_int_eq(r,0); 17716 17717 // invalid command 17718 r = systemf("randomCommand"); 17719 ck_assert_int_ne(r,0); 17720 17721 // NULL command 17722 ck_assert_int_eq(systemf(NULL), -1); 17723 17724 17725 } 17726 17727 17728 void commandFT(CuTest *tc UNUSED) { 17729 17730 int r; 17731 17732 // command 17733 r = command("ls chmodTest.null"); 17734 ck_assert_int_eq(r,0); 17735 17736 // invalid command 17737 r = command("randomCommand"); 17738 ck_assert_int_ne(r,0); 17739 // NULL command 17740 ck_assert_int_eq(command(NULL), -1); 17741 17742 17743 } 17744 17745 17746 void commandfFT(CuTest *tc UNUSED) { 17747 17748 int r; 17749 17750 // command 17751 r = commandf("ls %s", "chmodTest.null"); 17752 ck_assert_int_eq(r,0); 17753 17754 // invalid command 17755 r = commandf("randomCommand"); 17756 ck_assert_int_ne(r,0); 17757 17758 // NULL command 17759 ck_assert_int_eq(commandf(NULL), -1); 17760 17761 17762 } 17763 17764 17765 void commandNFreeFT(CuTest *tc UNUSED) { 17766 17767 int r; 17768 17769 // command 17770 r = commandNFree(strdup("ls chmodTest.null")); 17771 ck_assert_int_eq(r,0); 17772 17773 // invalid command 17774 r = commandNFree(strdup("randomCommand")); 17775 ck_assert_int_ne(r,0); 17776 // NULL command 17777 ck_assert_int_eq(commandNFree(NULL), -1); 17778 17779 17780 } 17781 17782 17783 void listEqST(CuTest *tc UNUSED) { 17784 17785 char **l = NULL; 17786 char **l2; 17787 char **r = null; 17788 17789 // identical lists 17790 r = listPushS(&l, "1"); 17791 ck_assert_ptr_eq(r, l); 17792 r = listPushS(&l, "22"); 17793 ck_assert_ptr_eq(r, l); 17794 r = listPushS(&l, "333"); 17795 ck_assert_ptr_eq(r, l); 17796 r = listPushS(&l, "4444"); 17797 ck_assert_ptr_eq(r, l); 17798 l2 = listDupS(l); 17799 ck_assert(listEqS(l,l2)); 17800 // NULL lists 17801 ck_assert(!listEqS(NULL,l)); 17802 ck_assert(!listEqS(l,NULL)); 17803 ck_assert(!listEqS(NULL,NULL)); 17804 // different lists same number of elements 17805 l[3][0] = 'A'; 17806 ck_assert(!listEqS(l,l2)); 17807 // different number of elements 17808 char *s = listPopS(&l); 17809 free(s); 17810 ck_assert(!listEqS(l,l2)); 17811 listFreeS(l); 17812 listFreeS(l2); 17813 17814 } 17815 17816 17817 void listHasST(CuTest *tc UNUSED) { 17818 17819 char **l = NULL; 17820 char **r = null; 17821 17822 // string 17823 r = listPushS(&l, "1"); 17824 ck_assert_ptr_eq(r, l); 17825 r = listPushS(&l, "22"); 17826 ck_assert_ptr_eq(r, l); 17827 r = listPushS(&l, "333"); 17828 ck_assert_ptr_eq(r, l); 17829 r = listPushS(&l, "4444"); 17830 ck_assert_ptr_eq(r, l); 17831 ck_assert(listHasS(l, "1")); 17832 // NULL list 17833 ck_assert(!listHasS(NULL, "1")); 17834 // NULL string 17835 ck_assert(!listHasS(l, NULL)); 17836 // non existing element 17837 ck_assert(!listHasS(l, "wfe")); 17838 // string in list 17839 ck_assert(listHasS(l, "333")); 17840 listFreeS(l); 17841 17842 } 17843 17844 17845 void listHasCharST(CuTest *tc UNUSED) { 17846 17847 char **l = NULL; 17848 char **r = null; 17849 17850 // string 17851 r = listPushS(&l, "1"); 17852 ck_assert_ptr_eq(r, l); 17853 r = listPushS(&l, "22"); 17854 ck_assert_ptr_eq(r, l); 17855 r = listPushS(&l, "333"); 17856 ck_assert_ptr_eq(r, l); 17857 r = listPushS(&l, "4444"); 17858 ck_assert_ptr_eq(r, l); 17859 ck_assert(listHasCharS(l, '1')); 17860 // NULL list 17861 ck_assert(!listHasCharS(NULL, '1')); 17862 // non existing element 17863 ck_assert(!listHasCharS(l, 'w')); 17864 listFreeS(l); 17865 17866 17867 } 17868 17869 17870 void listIndexOfST(CuTest *tc UNUSED) { 17871 17872 char **l = NULL; 17873 char **r = null; 17874 17875 // string 17876 r = listPushS(&l, "1"); 17877 ck_assert_ptr_eq(r, l); 17878 r = listPushS(&l, "22"); 17879 ck_assert_ptr_eq(r, l); 17880 r = listPushS(&l, "333"); 17881 ck_assert_ptr_eq(r, l); 17882 r = listPushS(&l, "4444"); 17883 ck_assert_ptr_eq(r, l); 17884 ck_assert_uint_eq(listIndexOfS(l, "1"),0); 17885 // NULL list 17886 ck_assert_uint_eq(listIndexOfS(NULL, "1"),-1); 17887 // NULL string 17888 ck_assert_uint_eq(listIndexOfS(l, NULL),-1); 17889 // non existing element 17890 ck_assert_uint_eq(listIndexOfS(l, "wfe"),-1); 17891 // string in list 17892 ck_assert_uint_eq(listIndexOfS(l, "333"),2); 17893 listFreeS(l); 17894 17895 } 17896 17897 17898 void listIndexOfCharST(CuTest *tc UNUSED) { 17899 17900 char **l = NULL; 17901 char **r = null; 17902 17903 // string 17904 r = listPushS(&l, "1"); 17905 ck_assert_ptr_eq(r, l); 17906 r = listPushS(&l, "22"); 17907 ck_assert_ptr_eq(r, l); 17908 r = listPushS(&l, "333"); 17909 ck_assert_ptr_eq(r, l); 17910 r = listPushS(&l, "4444"); 17911 ck_assert_ptr_eq(r, l); 17912 ck_assert_uint_eq(listIndexOfCharS(l, '1'),0); 17913 // NULL list 17914 ck_assert_uint_eq(listIndexOfCharS(NULL, '1'),-1); 17915 // non existing element 17916 ck_assert_uint_eq(listIndexOfCharS(l, 'w'),-1); 17917 listFreeS(l); 17918 17919 17920 } 17921 17922 17923 void listBinarySearchST(CuTest *tc UNUSED) { 17924 17925 char **l = NULL; 17926 char **r = null; 17927 17928 // string 17929 r = listPushS(&l, "1"); 17930 ck_assert_ptr_eq(r, l); 17931 r = listPushS(&l, "22"); 17932 ck_assert_ptr_eq(r, l); 17933 r = listPushS(&l, "333"); 17934 ck_assert_ptr_eq(r, l); 17935 r = listPushS(&l, "4444"); 17936 ck_assert_ptr_eq(r, l); 17937 r = listPushS(&l, "5"); 17938 ck_assert_ptr_eq(r, l); 17939 r = listPushS(&l, "6"); 17940 ck_assert_ptr_eq(r, l); 17941 ck_assert_uint_eq(listBinarySearchS(l, "1"),0); 17942 // NULL list 17943 ck_assert_uint_eq(listBinarySearchS(NULL, "1"),-1); 17944 // NULL string 17945 ck_assert_uint_eq(listBinarySearchS(l, NULL),-1); 17946 // non existing element 17947 ck_assert_uint_eq(listBinarySearchS(l, "wfe"),-1); 17948 // string in list 17949 ck_assert_uint_eq(listBinarySearchS(l, "333"),2); 17950 listFreeS(l); 17951 17952 } 17953 17954 17955 void listBinarySearchCharST(CuTest *tc UNUSED) { 17956 17957 char **l = NULL; 17958 char **r = null; 17959 17960 // string 17961 r = listPushS(&l, "1"); 17962 ck_assert_ptr_eq(r, l); 17963 r = listPushS(&l, "22"); 17964 ck_assert_ptr_eq(r, l); 17965 r = listPushS(&l, "333"); 17966 ck_assert_ptr_eq(r, l); 17967 r = listPushS(&l, "4444"); 17968 ck_assert_ptr_eq(r, l); 17969 r = listPushS(&l, "5"); 17970 ck_assert_ptr_eq(r, l); 17971 r = listPushS(&l, "6"); 17972 ck_assert_ptr_eq(r, l); 17973 ck_assert_uint_eq(listBinarySearchCharS(l, '1'),0); 17974 // NULL list 17975 ck_assert_uint_eq(listBinarySearchCharS(NULL, '1'),-1); 17976 // non existing element 17977 ck_assert_uint_eq(listBinarySearchCharS(l, 'w'),-1); 17978 // string in list 17979 ck_assert_uint_eq(listBinarySearchCharS(l, '5'),4); 17980 listFreeS(l); 17981 17982 17983 } 17984 17985 17986 void listUniqST(CuTest *tc UNUSED) { 17987 17988 char **l = NULL; 17989 char **l2; 17990 char **r = null; 17991 17992 // list with unique elements 17993 r = listPushS(&l, "1"); 17994 ck_assert_ptr_eq(r, l); 17995 r = listPushS(&l, "22"); 17996 ck_assert_ptr_eq(r, l); 17997 r = listPushS(&l, "333"); 17998 ck_assert_ptr_eq(r, l); 17999 r = listPushS(&l, "4444"); 18000 ck_assert_ptr_eq(r, l); 18001 l2 = listUniqS(l); 18002 ck_assert(listEqS(l,l2)); 18003 // list with identical elements 18004 l[2][0] = '2'; 18005 l[2][1] = '2'; 18006 l[2][2] = 0; 18007 listFreeS(l2); 18008 l2 = listUniqS(l); 18009 ck_assert_uint_eq(listLengthS(l2),3); 18010 ck_assert_str_eq(l2[2], "4444"); 18011 listFreeS(l); 18012 listFreeS(l2); 18013 // list with one element 18014 l = NULL; 18015 r = listPushS(&l, "1"); 18016 ck_assert_ptr_eq(r, l); 18017 l2 = listUniqS(l); 18018 ck_assert_uint_eq(listLengthS(l2),1); 18019 ck_assert_str_eq(l2[0], "1"); 18020 listFreeS(l); 18021 listFreeS(l2); 18022 // empty list 18023 listEmptyS(l) 18024 l2 = listUniqS(l); 18025 ck_assert_uint_eq(listLengthS(l2),0); 18026 ck_assert_ptr_eq(l2[0], NULL); 18027 listFreeS(l); 18028 listFreeS(l2); 18029 // NULL list 18030 ck_assert_ptr_eq(listUniqS(NULL), NULL); 18031 18032 } 18033 18034 18035 void iListUniqST(CuTest *tc UNUSED) { 18036 18037 char **l = NULL; 18038 char **l2; 18039 char **r = null; 18040 18041 // list with unique elements 18042 r = listPushS(&l, "1"); 18043 ck_assert_ptr_eq(r, l); 18044 r = listPushS(&l, "22"); 18045 ck_assert_ptr_eq(r, l); 18046 r = listPushS(&l, "333"); 18047 ck_assert_ptr_eq(r, l); 18048 r = listPushS(&l, "4444"); 18049 ck_assert_ptr_eq(r, l); 18050 l2 = listDupS(l); 18051 r = iListUniqS(&l2); 18052 ck_assert_ptr_eq(r, l2); 18053 ck_assert(listEqS(l,l2)); 18054 // list with identical elements 18055 l[2][0] = '2'; 18056 l[2][1] = '2'; 18057 l[2][2] = 0; 18058 listFreeS(l2); 18059 l2 = listDupS(l); 18060 r = iListUniqS(&l2); 18061 ck_assert_ptr_eq(r, l2); 18062 ck_assert_uint_eq(listLengthS(l2),3); 18063 ck_assert_str_eq(l2[2], "4444"); 18064 listFreeS(l); 18065 listFreeS(l2); 18066 // list with one element 18067 l = NULL; 18068 r = listPushS(&l, "1"); 18069 ck_assert_ptr_eq(r, l); 18070 l2 = listDupS(l); 18071 r = iListUniqS(&l2); 18072 ck_assert_ptr_eq(r, l2); 18073 ck_assert_uint_eq(listLengthS(l2),1); 18074 ck_assert_str_eq(l2[0], "1"); 18075 listFreeS(l); 18076 listFreeS(l2); 18077 // empty list 18078 listEmptyS(l) 18079 l2 = listDupS(l); 18080 r = iListUniqS(&l2); 18081 ck_assert_ptr_eq(r, l2); 18082 ck_assert_uint_eq(listLengthS(l2),0); 18083 ck_assert_ptr_eq(l2[0], NULL); 18084 listFreeS(l); 18085 listFreeS(l2); 18086 // NULL list 18087 l = NULL; 18088 r = iListUniqS(&l); 18089 ck_assert_ptr_eq(r, l); 18090 ck_assert_ptr_eq(l, NULL); 18091 // NULL var 18092 r = iListUniqS(NULL); 18093 ck_assert_ptr_eq(r, null); 18094 18095 } 18096 18097 18098 void icListEqST(CuTest *tc UNUSED) { 18099 18100 char **l = NULL; 18101 char **l2; 18102 char **r2 = null; 18103 char *r = null; 18104 18105 // identical lists 18106 r2 = listPushS(&l, "1"); 18107 ck_assert_ptr_eq(r2, l); 18108 r2 = listPushS(&l, "bb"); 18109 ck_assert_ptr_eq(r2, l); 18110 r2 = listPushS(&l, "333"); 18111 ck_assert_ptr_eq(r2, l); 18112 r2 = listPushS(&l, "4444"); 18113 ck_assert_ptr_eq(r2, l); 18114 l2 = listDupS(l); 18115 r = iUpperS(&l2[1]); 18116 ck_assert_ptr_eq(r, l2[1]); 18117 ck_assert(icListEqS(l,l2)); 18118 // NULL lists 18119 ck_assert(!icListEqS(NULL,l)); 18120 ck_assert(!icListEqS(l,NULL)); 18121 ck_assert(!icListEqS(NULL,NULL)); 18122 // different lists same number of elements 18123 l[3][0] = 'A'; 18124 ck_assert(!icListEqS(l,l2)); 18125 // different number of elements 18126 char *s = listPopS(&l); 18127 free(s); 18128 ck_assert(!icListEqS(l,l2)); 18129 listFreeS(l); 18130 listFreeS(l2); 18131 18132 18133 } 18134 18135 18136 void icListHasST(CuTest *tc UNUSED) { 18137 18138 char **l = NULL; 18139 char **r = null; 18140 18141 // string 18142 r = listPushS(&l, "a"); 18143 ck_assert_ptr_eq(r, l); 18144 r = listPushS(&l, "22"); 18145 ck_assert_ptr_eq(r, l); 18146 r = listPushS(&l, "333"); 18147 ck_assert_ptr_eq(r, l); 18148 r = listPushS(&l, "4444"); 18149 ck_assert_ptr_eq(r, l); 18150 ck_assert(icListHasS(l, "A")); 18151 // NULL list 18152 ck_assert(!icListHasS(NULL, "1")); 18153 // NULL string 18154 ck_assert(!icListHasS(l, NULL)); 18155 // non existing element 18156 ck_assert(!icListHasS(l, "wfe")); 18157 // string in list 18158 ck_assert(icListHasS(l, "333")); 18159 listFreeS(l); 18160 18161 18162 } 18163 18164 18165 void icListHasCharST(CuTest *tc UNUSED) { 18166 18167 char **l = NULL; 18168 char **r = null; 18169 18170 // string 18171 r = listPushS(&l, "A"); 18172 ck_assert_ptr_eq(r, l); 18173 r = listPushS(&l, "22"); 18174 ck_assert_ptr_eq(r, l); 18175 r = listPushS(&l, "333"); 18176 ck_assert_ptr_eq(r, l); 18177 r = listPushS(&l, "4444"); 18178 ck_assert_ptr_eq(r, l); 18179 ck_assert(icListHasCharS(l, 'a')); 18180 // NULL list 18181 ck_assert(!icListHasCharS(NULL, '1')); 18182 // non existing element 18183 ck_assert(!icListHasCharS(l, 'w')); 18184 listFreeS(l); 18185 18186 18187 } 18188 18189 18190 void icListIndexOfST(CuTest *tc UNUSED) { 18191 18192 char **l = NULL; 18193 char **r = null; 18194 18195 // string 18196 r = listPushS(&l, "a"); 18197 ck_assert_ptr_eq(r, l); 18198 r = listPushS(&l, "22"); 18199 ck_assert_ptr_eq(r, l); 18200 r = listPushS(&l, "333"); 18201 ck_assert_ptr_eq(r, l); 18202 r = listPushS(&l, "4444"); 18203 ck_assert_ptr_eq(r, l); 18204 ck_assert_uint_eq(icListIndexOfS(l, "A"),0); 18205 // NULL list 18206 ck_assert_uint_eq(icListIndexOfS(NULL, "1"),-1); 18207 // NULL string 18208 ck_assert_uint_eq(icListIndexOfS(l, NULL),-1); 18209 // non existing element 18210 ck_assert_uint_eq(icListIndexOfS(l, "wfe"),-1); 18211 // string in list 18212 ck_assert_uint_eq(icListIndexOfS(l, "333"),2); 18213 listFreeS(l); 18214 18215 18216 } 18217 18218 18219 void icListIndexOfCharST(CuTest *tc UNUSED) { 18220 18221 char **l = NULL; 18222 char **r = null; 18223 18224 // string 18225 r = listPushS(&l, "A"); 18226 ck_assert_ptr_eq(r, l); 18227 r = listPushS(&l, "22"); 18228 ck_assert_ptr_eq(r, l); 18229 r = listPushS(&l, "333"); 18230 ck_assert_ptr_eq(r, l); 18231 r = listPushS(&l, "4444"); 18232 ck_assert_ptr_eq(r, l); 18233 ck_assert_uint_eq(icListIndexOfCharS(l, 'a'),0); 18234 // NULL list 18235 ck_assert_uint_eq(icListIndexOfCharS(NULL, '1'),-1); 18236 // non existing element 18237 ck_assert_uint_eq(icListIndexOfCharS(l, 'w'),-1); 18238 listFreeS(l); 18239 18240 18241 } 18242 18243 18244 void icListBinarySearchST(CuTest *tc UNUSED) { 18245 18246 char **l = NULL; 18247 char **r = null; 18248 18249 // string 18250 r = listPushS(&l, "a"); 18251 ck_assert_ptr_eq(r, l); 18252 r = listPushS(&l, "22"); 18253 ck_assert_ptr_eq(r, l); 18254 r = listPushS(&l, "333"); 18255 ck_assert_ptr_eq(r, l); 18256 r = listPushS(&l, "4444"); 18257 ck_assert_ptr_eq(r, l); 18258 r = listPushS(&l, "ccc"); 18259 ck_assert_ptr_eq(r, l); 18260 r = listPushS(&l, "6"); 18261 ck_assert_ptr_eq(r, l); 18262 r = iListSortS(&l); 18263 ck_assert_ptr_eq(r, l); 18264 ck_assert_uint_eq(icListBinarySearchS(l, "A"),4); 18265 // NULL list 18266 ck_assert_uint_eq(icListBinarySearchS(NULL, "1"),-1); 18267 // NULL string 18268 ck_assert_uint_eq(icListBinarySearchS(l, NULL),-1); 18269 // non existing element 18270 ck_assert_uint_eq(icListBinarySearchS(l, "wfe"),-1); 18271 // string in list 18272 ck_assert_uint_eq(icListBinarySearchS(l, "Ccc"),5); 18273 listFreeS(l); 18274 18275 18276 } 18277 18278 18279 void icListBinarySearchCharST(CuTest *tc UNUSED) { 18280 18281 char **l = NULL; 18282 char **r = null; 18283 18284 // string 18285 r = listPushS(&l, "A"); 18286 ck_assert_ptr_eq(r, l); 18287 r = listPushS(&l, "22"); 18288 ck_assert_ptr_eq(r, l); 18289 r = listPushS(&l, "333"); 18290 ck_assert_ptr_eq(r, l); 18291 r = listPushS(&l, "4444"); 18292 ck_assert_ptr_eq(r, l); 18293 r = listPushS(&l, "C"); 18294 ck_assert_ptr_eq(r, l); 18295 r = listPushS(&l, "6"); 18296 ck_assert_ptr_eq(r, l); 18297 r = iListSortS(&l); 18298 ck_assert_ptr_eq(r, l); 18299 ck_assert_uint_eq(icListBinarySearchCharS(l, 'a'),4); 18300 // NULL list 18301 ck_assert_uint_eq(icListBinarySearchCharS(NULL, '1'),-1); 18302 // non existing element 18303 ck_assert_uint_eq(icListBinarySearchCharS(l, 'w'),-1); 18304 // string in list 18305 ck_assert_uint_eq(icListBinarySearchCharS(l, 'c'),5); 18306 listFreeS(l); 18307 18308 18309 } 18310 18311 18312 void icListUniqST(CuTest *tc UNUSED) { 18313 18314 char **l = NULL; 18315 char **l2; 18316 char **r = null; 18317 18318 // list with unique elements 18319 r = listPushS(&l, "1"); 18320 ck_assert_ptr_eq(r, l); 18321 r = listPushS(&l, "bb"); 18322 ck_assert_ptr_eq(r, l); 18323 r = listPushS(&l, "333"); 18324 ck_assert_ptr_eq(r, l); 18325 r = listPushS(&l, "4444"); 18326 ck_assert_ptr_eq(r, l); 18327 l2 = icListUniqS(l); 18328 ck_assert(listEqS(l,l2)); 18329 // list with identical elements 18330 l[2][0] = 'B'; 18331 l[2][1] = 'B'; 18332 l[2][2] = 0; 18333 listFreeS(l2); 18334 l2 = icListUniqS(l); 18335 ck_assert_uint_eq(listLengthS(l2),3); 18336 ck_assert_str_eq(l2[2], "4444"); 18337 listFreeS(l); 18338 listFreeS(l2); 18339 // list with one element 18340 l = NULL; 18341 r = listPushS(&l, "1"); 18342 ck_assert_ptr_eq(r, l); 18343 l2 = icListUniqS(l); 18344 ck_assert_uint_eq(listLengthS(l2),1); 18345 ck_assert_str_eq(l2[0], "1"); 18346 listFreeS(l); 18347 listFreeS(l2); 18348 // empty list 18349 listEmptyS(l) 18350 l2 = icListUniqS(l); 18351 ck_assert_uint_eq(listLengthS(l2),0); 18352 ck_assert_ptr_eq(l2[0], NULL); 18353 listFreeS(l); 18354 listFreeS(l2); 18355 // NULL list 18356 ck_assert_ptr_eq(icListUniqS(NULL), NULL); 18357 18358 18359 } 18360 18361 18362 void iicListUniqST(CuTest *tc UNUSED) { 18363 18364 char **l = NULL; 18365 char **l2; 18366 char **r = null; 18367 18368 // list with unique elements 18369 r = listPushS(&l, "1"); 18370 ck_assert_ptr_eq(r, l); 18371 r = listPushS(&l, "BB"); 18372 ck_assert_ptr_eq(r, l); 18373 r = listPushS(&l, "333"); 18374 ck_assert_ptr_eq(r, l); 18375 r = listPushS(&l, "4444"); 18376 ck_assert_ptr_eq(r, l); 18377 l2 = listDupS(l); 18378 r = iicListUniqS(&l2); 18379 ck_assert_ptr_eq(r, l2); 18380 ck_assert(listEqS(l,l2)); 18381 // list with identical elements 18382 l[2][0] = 'b'; 18383 l[2][1] = 'b'; 18384 l[2][2] = 0; 18385 listFreeS(l2); 18386 l2 = listDupS(l); 18387 r = iicListUniqS(&l2); 18388 ck_assert_ptr_eq(r, l2); 18389 ck_assert_uint_eq(listLengthS(l2),3); 18390 ck_assert_str_eq(l2[2], "4444"); 18391 listFreeS(l); 18392 listFreeS(l2); 18393 // list with one element 18394 l = NULL; 18395 r = listPushS(&l, "1"); 18396 ck_assert_ptr_eq(r, l); 18397 l2 = listDupS(l); 18398 r = iicListUniqS(&l2); 18399 ck_assert_ptr_eq(r, l2); 18400 ck_assert_uint_eq(listLengthS(l2),1); 18401 ck_assert_str_eq(l2[0], "1"); 18402 listFreeS(l); 18403 listFreeS(l2); 18404 // empty list 18405 listEmptyS(l) 18406 l2 = listDupS(l); 18407 r = iicListUniqS(&l2); 18408 ck_assert_ptr_eq(r, l2); 18409 ck_assert_uint_eq(listLengthS(l2),0); 18410 ck_assert_ptr_eq(l2[0], NULL); 18411 listFreeS(l); 18412 listFreeS(l2); 18413 // NULL list 18414 l = NULL; 18415 r = iicListUniqS(&l); 18416 ck_assert_ptr_eq(r, l); 18417 ck_assert_ptr_eq(l, NULL); 18418 // NULL var 18419 r = iicListUniqS(NULL); 18420 ck_assert_ptr_eq(r, null); 18421 18422 18423 } 18424 18425 18426 void listCompactST(CuTest *tc UNUSED) { 18427 18428 char **l = NULL; 18429 char **l2; 18430 char **r = null; 18431 18432 // list with empty elements 18433 r = listPushS(&l, "1"); 18434 ck_assert_ptr_eq(r, l); 18435 r = listPushS(&l, ""); 18436 ck_assert_ptr_eq(r, l); 18437 r = listPushS(&l, ""); 18438 ck_assert_ptr_eq(r, l); 18439 r = listPushS(&l, "4444"); 18440 ck_assert_ptr_eq(r, l); 18441 l2 = listCompactS(l); 18442 ck_assert_uint_eq(listLengthS(l2),2); 18443 ck_assert_str_eq(l2[1], "4444"); 18444 listFreeS(l); 18445 listFreeS(l2); 18446 // empty list 18447 listEmptyS(l) 18448 l2 = listCompactS(l); 18449 ck_assert_uint_eq(listLengthS(l2),0); 18450 ck_assert_ptr_eq(l2[0], NULL); 18451 listFreeS(l); 18452 listFreeS(l2); 18453 // NULL list 18454 ck_assert_ptr_eq(listCompactS(NULL), NULL); 18455 18456 } 18457 18458 18459 void iListCompactST(CuTest *tc UNUSED) { 18460 18461 char **l = NULL; 18462 char **l2; 18463 char **r = null; 18464 18465 // list with empty elements 18466 r = listPushS(&l, "1"); 18467 ck_assert_ptr_eq(r, l); 18468 r = listPushS(&l, ""); 18469 ck_assert_ptr_eq(r, l); 18470 r = listPushS(&l, ""); 18471 ck_assert_ptr_eq(r, l); 18472 r = listPushS(&l, "4444"); 18473 ck_assert_ptr_eq(r, l); 18474 l2 = listDupS(l); 18475 r = iListCompactS(&l2); 18476 ck_assert_ptr_eq(r, l2); 18477 ck_assert_uint_eq(listLengthS(l2),2); 18478 ck_assert_str_eq(l2[1], "4444"); 18479 listFreeS(l); 18480 listFreeS(l2); 18481 // list with an empty string 18482 l = NULL; 18483 r = listPushS(&l, ""); 18484 ck_assert_ptr_eq(r, l); 18485 r = iListCompactS(&l); 18486 ck_assert_ptr_eq(r, l); 18487 ck_assert_uint_eq(listLengthS(l),0); 18488 ck_assert_ptr_eq(l[0], NULL); 18489 listFreeS(l); 18490 // empty list 18491 listEmptyS(l) 18492 l2 = listDupS(l); 18493 r = iListCompactS(&l2); 18494 ck_assert_ptr_eq(r, l2); 18495 ck_assert_uint_eq(listLengthS(l2),0); 18496 ck_assert_ptr_eq(l2[0], NULL); 18497 listFreeS(l); 18498 listFreeS(l2); 18499 // NULL list 18500 l = NULL; 18501 r = iListCompactS(&l); 18502 ck_assert_ptr_eq(r, null); 18503 ck_assert_ptr_eq(l, NULL); 18504 // NULL var 18505 r = iListCompactS(NULL); 18506 ck_assert_ptr_eq(r, null); 18507 18508 } 18509 18510 18511 void btraceEnableT(CuTest *tc UNUSED) { 18512 18513 btraceEnable(); 18514 ck_assert(btraceConfig()); 18515 btraceDisable(); 18516 ck_assert(!btraceConfig()); 18517 18518 18519 } 18520 18521 18522 void btraceT(CuTest *tc UNUSED) { 18523 18524 char **r; 18525 18526 r = btrace(); 18527 ck_assert_ptr_ne(r, null); 18528 listFreeS(r); 18529 18530 18531 } 18532 18533 18534 void listEmptyFT(CuTest *tc UNUSED) { 18535 18536 void **l = NULL; 18537 18538 // empty list 18539 l = listEmptyF(); 18540 ck_assert(listIsEmpty(l)); 18541 free(l); 18542 18543 } 18544 18545 18546 void iListEmptyFT(CuTest *tc UNUSED) { 18547 18548 void **l = NULL; 18549 char *s1 = "lib"; 18550 char *s2 = "sheepy"; 18551 void **r = null; 18552 18553 // empty list 18554 r = listPush(&l, s1); 18555 ck_assert_ptr_eq(r, l); 18556 r = listPush(&l, s2); 18557 ck_assert_ptr_eq(r, l); 18558 r = iListEmptyF(&l); 18559 ck_assert_ptr_eq(r, l); 18560 ck_assert(listIsEmpty(l)); 18561 free(l); 18562 // NULL list 18563 l = NULL; 18564 r = iListEmptyF(&l); 18565 ck_assert_ptr_eq(r, l); 18566 ck_assert(listIsEmpty(l)); 18567 free(l); 18568 // NULL var 18569 r = iListEmptyF(NULL); 18570 ck_assert_ptr_eq(r, null); 18571 18572 } 18573 18574 18575 void listIsEmptyT(CuTest *tc UNUSED) { 18576 18577 void **l = NULL; 18578 char *s1 = "lib"; 18579 char *s2 = "sheepy"; 18580 void **r = null; 18581 18582 // non empty list 18583 r = listPush(&l, s1); 18584 ck_assert_ptr_eq(r, l); 18585 r = listPush(&l, s2); 18586 ck_assert_ptr_eq(r, l); 18587 // check ck_assert_ptr_null not available in jessie 18588 ck_assert_ptr_ne(l, NULL); 18589 ck_assert(!listIsEmpty(l)); 18590 free(l); 18591 // empty list 18592 listEmpty(l); 18593 ck_assert(listIsEmpty(l)); 18594 free(l); 18595 ck_assert(listIsEmpty(NULL)); 18596 18597 } 18598 18599 18600 void listCreateT(CuTest *tc UNUSED) { 18601 18602 void **l; 18603 char *s1 = "sheepy"; 18604 char *s2 = "SHEEPY"; 18605 18606 // create list 18607 l = listCreate((void *)s1, (void *)s2, (void *)s1); 18608 // check ck_assert_ptr_null not available in jessie 18609 ck_assert_ptr_ne(l, NULL); 18610 ck_assert_uint_eq(listLength(l),3); 18611 ck_assert_str_eq(l[0], "sheepy"); 18612 ck_assert_str_eq(l[1], "SHEEPY"); 18613 ck_assert_str_eq(l[2], "sheepy"); 18614 free(l); 18615 18616 // NULL first element 18617 ck_assert_ptr_eq(listCreate(NULL, "sheepy"), NULL); 18618 18619 } 18620 18621 18622 void listFromArrayT(CuTest *tc UNUSED) { 18623 18624 void **l = NULL; 18625 char *array[] = {"1", "22", "333"}; 18626 char *arrayNULL[] = {"1", NULL, "333"}; 18627 18628 // copy array to list 18629 l = listFromArray((void *)array, 3); 18630 ck_assert_uint_eq(listLength(l),3); 18631 ck_assert_str_eq(l[0], "1"); 18632 ck_assert_str_eq(l[1], "22"); 18633 ck_assert_str_eq(l[2], "333"); 18634 free(l); 18635 // array with NULL inside 18636 l = listFromArray((void *)arrayNULL, 3); 18637 ck_assert_uint_eq(listLength(l),2); 18638 ck_assert_str_eq(l[0], "1"); 18639 ck_assert_str_eq(l[1], "333"); 18640 free(l); 18641 // empty list 18642 l = listFromArray((void *)array, 0); 18643 ck_assert(listIsEmpty(l)); 18644 free(l); 18645 // NULL pointer to list 18646 ck_assert_ptr_eq(listFromArray(NULL, 1), NULL); 18647 18648 } 18649 18650 18651 void listPushT(CuTest *tc UNUSED) { 18652 18653 void **l = NULL; 18654 char *s = "sheepy"; 18655 char *s2 = "SHEEPY"; 18656 void **r = null; 18657 18658 // push strings and NULL list 18659 r = listPush(&l, (void *)s); 18660 ck_assert_ptr_eq(r, l); 18661 // check ck_assert_ptr_null not available in jessie 18662 ck_assert_ptr_ne(l, NULL); 18663 ck_assert_str_eq(l[0], "sheepy"); 18664 r = listPush(&l, (void *)s2); 18665 ck_assert_ptr_eq(r, l); 18666 ck_assert_str_eq(l[1], "SHEEPY"); 18667 ck_assert_str_eq(l[0], "sheepy"); 18668 // push NULL 18669 r = listPush(&l, NULL); 18670 ck_assert_ptr_eq(r, null); 18671 ck_assert_ptr_eq(l[2], NULL); 18672 free(l); 18673 // NULL list and NULL string 18674 l = NULL; 18675 r = listPush(&l, NULL); 18676 ck_assert_ptr_eq(r, null); 18677 ck_assert_ptr_eq(l, NULL); 18678 // empty list 18679 listEmpty(l); 18680 r = listPush(&l, (void *)s); 18681 ck_assert_ptr_eq(r, l); 18682 ck_assert_str_eq(l[0], "sheepy"); 18683 ck_assert_ptr_eq(l[1], NULL); 18684 free(l); 18685 // NULL pointer to list 18686 r = listPush(NULL, NULL); 18687 ck_assert_ptr_eq(r, null); 18688 18689 } 18690 18691 18692 void listPopT(CuTest *tc UNUSED) { 18693 18694 void **l = NULL; 18695 char *s1 = "sheepy"; 18696 char *s2 = "SHEEPY"; 18697 char *s; 18698 void **r = null; 18699 18700 // pop string 18701 r = listPush(&l, (void *)s1); 18702 ck_assert_ptr_eq(r, l); 18703 r = listPush(&l, (void *)s2); 18704 ck_assert_ptr_eq(r, l); 18705 s = (char *)listPop(&l); 18706 ck_assert_str_eq(s, "SHEEPY"); 18707 ck_assert_uint_eq(listLength(l),1); 18708 // last element 18709 s = (char *)listPop(&l); 18710 ck_assert_str_eq(s, "sheepy"); 18711 ck_assert_uint_eq(listLength(l),0); 18712 // empty list 18713 ck_assert_ptr_eq(listPop(&l), NULL); 18714 free(l); 18715 // NULL list 18716 l = NULL; 18717 ck_assert_ptr_eq(listPop(&l), NULL); 18718 // NULL pointer to list 18719 ck_assert_ptr_eq(listPop(NULL), NULL); 18720 18721 } 18722 18723 18724 void listPrependT(CuTest *tc UNUSED) { 18725 18726 void **l = NULL; 18727 char *s1 = "sheepy"; 18728 char *s2 = "SHEEPY"; 18729 void **r = null; 18730 18731 // push strings and NULL list 18732 r = listPrepend(&l, (void *)s1); 18733 ck_assert_ptr_eq(r, l); 18734 // check ck_assert_ptr_null not available in jessie 18735 ck_assert_ptr_ne(l, NULL); 18736 ck_assert_str_eq(l[0], "sheepy"); 18737 r = listPrepend(&l, (void *)s2); 18738 ck_assert_ptr_eq(r, l); 18739 ck_assert_str_eq(l[0], "SHEEPY"); 18740 ck_assert_str_eq(l[1], "sheepy"); 18741 // push NULL 18742 r = listPrepend(&l, NULL); 18743 ck_assert_ptr_eq(r, null); 18744 ck_assert_str_eq(l[0], "SHEEPY"); 18745 free(l); 18746 // NULL list and NULL string` 18747 l = NULL; 18748 r = listPrepend(&l, NULL); 18749 ck_assert_ptr_eq(r, null); 18750 ck_assert_ptr_eq(l, NULL); 18751 // empty list 18752 listEmpty(l) 18753 r = listPrepend(&l, (void *)s1); 18754 ck_assert_ptr_eq(r, l); 18755 ck_assert_str_eq(l[0], "sheepy"); 18756 ck_assert_ptr_eq(l[1], NULL); 18757 free(l); 18758 // NULL pointer to list 18759 r = listPrepend(NULL, NULL); 18760 ck_assert_ptr_eq(r, null); 18761 18762 } 18763 18764 18765 void listDequeueT(CuTest *tc UNUSED) { 18766 18767 void **l = NULL; 18768 char *s1 = "sheepy"; 18769 char *s2 = "SHEEPY"; 18770 char *s; 18771 void **r = null; 18772 18773 // pop string 18774 r = listPush(&l, (void *)s1); 18775 ck_assert_ptr_eq(r, l); 18776 r = listPush(&l, (void *)s2); 18777 ck_assert_ptr_eq(r, l); 18778 s = listDequeue(&l); 18779 ck_assert_str_eq(s, "sheepy"); 18780 ck_assert_uint_eq(listLength(l),1); 18781 // last element 18782 s = listDequeue(&l); 18783 ck_assert_str_eq(s, "SHEEPY"); 18784 ck_assert_uint_eq(listLength(l),0); 18785 // empty list 18786 ck_assert_ptr_eq(listDequeue(&l), NULL); 18787 free(l); 18788 // NULL list 18789 l = NULL; 18790 ck_assert_ptr_eq(listDequeue(&l), NULL); 18791 // NULL pointer to list 18792 ck_assert_ptr_eq(listDequeue(NULL), NULL); 18793 18794 } 18795 18796 18797 void listFreeT(CuTest *tc UNUSED) { 18798 18799 void **l = NULL; 18800 char *s1 = strdup("sheepy"); 18801 char *s2 = strdup("SHEEPY"); 18802 void **r = null; 18803 18804 // not possible to know if a pointer is already freed 18805 r = listPush(&l, (void *)s1); 18806 ck_assert_ptr_eq(r, l); 18807 r = listPush(&l, (void *)s2); 18808 ck_assert_ptr_eq(r, l); 18809 listFree(l); 18810 // empty list 18811 listEmpty(l); 18812 listFree(l); 18813 // NULL list 18814 listFree(NULL); 18815 18816 } 18817 18818 18819 void listFreeManyT(CuTest *tc UNUSED) { 18820 18821 void **l1 = NULL; 18822 char *s1 = strdup("sheepy"); 18823 char *s2 = strdup("SHEEPY"); 18824 void **r = null; 18825 18826 // not possible to know if a pointer is already freed 18827 r = listPush(&l1, (void *)s1); 18828 ck_assert_ptr_eq(r, l1); 18829 r = listPush(&l1, (void *)s2); 18830 ck_assert_ptr_eq(r, l1); 18831 void **l2 = listEmptyF(); 18832 listFreeMany(l1, l2); 18833 18834 } 18835 18836 18837 void listLengthT(CuTest *tc UNUSED) { 18838 18839 void **l; 18840 18841 // list length 18842 l = malloc(2 * sizeof(char *)); 18843 l[0] = (void *)1; 18844 l[1] = NULL; 18845 ck_assert_uint_eq(listLength(l),1); 18846 free(l); 18847 // empty list 18848 listEmpty(l) 18849 ck_assert_uint_eq(listLength(l),0); 18850 free(l); 18851 // NULL list 18852 ck_assert_uint_eq(listLength(NULL),0); 18853 18854 18855 } 18856 18857 18858 void listGetT(CuTest *tc UNUSED) { 18859 18860 void **l = NULL; 18861 char *s1 = "1"; 18862 char *s2 = "22"; 18863 char *s3 = "333"; 18864 char *s4 = "4444"; 18865 void **r = null; 18866 18867 // get string 18868 r = listPush(&l, (void*)s1); 18869 ck_assert_ptr_eq(r, l); 18870 r = listPush(&l, (void*)s2); 18871 ck_assert_ptr_eq(r, l); 18872 r = listPush(&l, (void*)s3); 18873 ck_assert_ptr_eq(r, l); 18874 r = listPush(&l, (void*)s4); 18875 ck_assert_ptr_eq(r, l); 18876 ck_assert_str_eq(listGet(l, 0), "1"); 18877 // negative index 18878 ck_assert_str_eq(listGet(l, -1), "4444"); 18879 // outside list 18880 ck_assert_ptr_eq(listGet(l, 10), NULL); 18881 ck_assert_ptr_eq(listGet(l, -10), NULL); 18882 free(l); 18883 // negative index in a one element list 18884 l = NULL; 18885 r = listPush(&l, (void*)s1); 18886 ck_assert_ptr_eq(r, l); 18887 r = listPush(&l, NULL); 18888 ck_assert_ptr_eq(r, null); 18889 ck_assert_ptr_ne(listGet(l,-1), NULL); 18890 free(l); 18891 // empty list 18892 listEmpty(l) 18893 ck_assert_ptr_eq(listGet(l,0),NULL); 18894 free(l); 18895 // NULL list 18896 ck_assert_ptr_eq(listGet(NULL, 0), NULL); 18897 18898 } 18899 18900 18901 void listSetT(CuTest *tc UNUSED) { 18902 18903 void **l = NULL; 18904 char *s1 = "1"; 18905 char *s2 = "22"; 18906 char *s3 = "333"; 18907 char *s4 = "4444"; 18908 char *sA = "@@"; 18909 char *sB = "|"; 18910 void **r = null; 18911 18912 // get string 18913 r = listPush(&l, (void*)sA); 18914 ck_assert_ptr_eq(r, l); 18915 r = listPush(&l, (void*)s2); 18916 ck_assert_ptr_eq(r, l); 18917 r = listPush(&l, (void*)sB); 18918 ck_assert_ptr_eq(r, l); 18919 r = listPush(&l, (void*)s4); 18920 ck_assert_ptr_eq(r, l); 18921 r = listSet(l, 0, (void*)s1); 18922 ck_assert_ptr_eq(r, l); 18923 ck_assert_str_eq(listGet(l, 0), "1"); 18924 // negative index 18925 r = listSet(l, -2, (void*)s3); 18926 ck_assert_ptr_eq(r, l); 18927 ck_assert_str_eq(listGet(l, -2), "333"); 18928 // outside list 18929 // list is unchanged 18930 r = listSet(l, 10, (void*)s1); 18931 ck_assert_ptr_eq(r, null); 18932 r = listSet(l, -10, (void*)s1); 18933 ck_assert_ptr_eq(r, null); 18934 // NULL s var 18935 r = listSet(l, -2, NULL); 18936 ck_assert_ptr_eq(r, l); 18937 ck_assert_str_eq(l[0], "1"); 18938 ck_assert_str_eq(l[1], "22"); 18939 ck_assert_str_eq(l[2], "333"); 18940 ck_assert_str_eq(l[3], "4444"); 18941 free(l); 18942 // negative index in a one element list 18943 l = NULL; 18944 r = listPush(&l, (void*)s1); 18945 ck_assert_ptr_eq(r, l); 18946 r = listPush(&l, NULL); 18947 ck_assert_ptr_eq(r, null); 18948 r = listSet(l, -1, (void*)s1); 18949 ck_assert_ptr_eq(r, l); 18950 ck_assert_str_eq(listGet(l,-1), "1"); 18951 free(l); 18952 // empty list - should not crash 18953 listEmpty(l); 18954 r = listSet(l, 0, (void*)s1); 18955 ck_assert_ptr_eq(r, null); 18956 ck_assert_ptr_eq(listGet(l,0),NULL); 18957 free(l); 18958 // NULL list 18959 r = listSet(NULL, 0, (void*)s1); 18960 ck_assert_ptr_eq(r, null); 18961 ck_assert_ptr_eq(listGet(NULL, 0), NULL); 18962 18963 } 18964 18965 18966 void listDupT(CuTest *tc UNUSED) { 18967 18968 void **l = NULL; 18969 void **l2; 18970 char *s1 = "1"; 18971 char *s2 = "22"; 18972 char *s3 = "333"; 18973 char *s4 = "4444"; 18974 void **r = null; 18975 18976 // list 18977 r = listPush(&l, (void*)s1); 18978 ck_assert_ptr_eq(r, l); 18979 r = listPush(&l, (void*)s2); 18980 ck_assert_ptr_eq(r, l); 18981 r = listPush(&l, (void*)s3); 18982 ck_assert_ptr_eq(r, l); 18983 r = listPush(&l, (void*)s4); 18984 ck_assert_ptr_eq(r, l); 18985 l2 = listDup(l); 18986 ck_assert_uint_eq(listLength(l2),4); 18987 ck_assert_str_eq(l2[0], "1"); 18988 ck_assert_str_eq(l2[3], "4444"); 18989 free(l); 18990 free(l2); 18991 // empty list 18992 listEmpty(l); 18993 l2 = listDup(l); 18994 ck_assert(listIsEmpty(l2)); 18995 free(l); 18996 free(l2); 18997 // NULL list 18998 ck_assert_ptr_eq(listDup(NULL), NULL); 18999 19000 } 19001 19002 19003 void listReverseT(CuTest *tc UNUSED) { 19004 19005 void **l = NULL; 19006 void **l2; 19007 char *s1 = "1"; 19008 char *s2 = "22"; 19009 char *s3 = "333"; 19010 char *s4 = "4444"; 19011 void **r = null; 19012 19013 // list 19014 r = listPush(&l, (void*)s1); 19015 ck_assert_ptr_eq(r, l); 19016 r = listPush(&l, (void*)s2); 19017 ck_assert_ptr_eq(r, l); 19018 r = listPush(&l, (void*)s3); 19019 ck_assert_ptr_eq(r, l); 19020 r = listPush(&l, (void*)s4); 19021 ck_assert_ptr_eq(r, l); 19022 l2 = listReverse(l); 19023 ck_assert_uint_eq(listLength(l2),4); 19024 ck_assert_str_eq(l2[0], "4444"); 19025 ck_assert_str_eq(l2[3], "1"); 19026 free(l); 19027 free(l2); 19028 // empty list 19029 listEmpty(l); 19030 l2 = listReverse(l); 19031 ck_assert(listIsEmpty(l2)); 19032 free(l); 19033 free(l2); 19034 // NULL list 19035 ck_assert_ptr_eq(listReverse(NULL), NULL); 19036 19037 } 19038 19039 19040 void iListReverseT(CuTest *tc UNUSED) { 19041 19042 void **l = NULL; 19043 char *s1 = "1"; 19044 char *s2 = "22"; 19045 char *s3 = "333"; 19046 char *s4 = "4444"; 19047 void **r = null; 19048 19049 // list 19050 r = listPush(&l, (void*)s1); 19051 ck_assert_ptr_eq(r, l); 19052 r = listPush(&l, (void*)s2); 19053 ck_assert_ptr_eq(r, l); 19054 r = listPush(&l, (void*)s3); 19055 ck_assert_ptr_eq(r, l); 19056 r = listPush(&l, (void*)s4); 19057 ck_assert_ptr_eq(r, l); 19058 r = iListReverse(&l); 19059 ck_assert_ptr_eq(r, l); 19060 ck_assert_uint_eq(listLength(l),4); 19061 ck_assert_str_eq(l[0], "4444"); 19062 ck_assert_str_eq(l[3], "1"); 19063 free(l); 19064 /* // empty list */ 19065 listEmpty(l); 19066 r = iListReverse(&l); 19067 ck_assert_ptr_eq(r, l); 19068 ck_assert(listIsEmpty(l)); 19069 free(l); 19070 // NULL list 19071 l = NULL; 19072 r = iListReverse(&l); 19073 ck_assert_ptr_eq(r, l); 19074 ck_assert_ptr_eq(l, NULL); 19075 // NULL var 19076 r = iListReverse(NULL); 19077 ck_assert_ptr_eq(r, null); 19078 19079 } 19080 19081 19082 void listCatT(CuTest *tc UNUSED) { 19083 19084 void **l = NULL; 19085 void **l2 = NULL; 19086 void **r; 19087 char *s1 = "1"; 19088 char *s2 = "#@#"; 19089 char *s3 = "lib"; 19090 char *s4 = "sheepy"; 19091 19092 // cat lists 19093 r = listPush(&l, (void*)s2); 19094 ck_assert_ptr_eq(r, l); 19095 r = listPush(&l, (void*)s1); 19096 ck_assert_ptr_eq(r, l); 19097 r = listPush(&l2, (void*)s3); 19098 ck_assert_ptr_eq(r, l2); 19099 r = listPush(&l2, (void*)s4); 19100 ck_assert_ptr_eq(r, l2); 19101 r = listCat(l,l2); 19102 ck_assert_str_eq(r[0], "#@#"); 19103 ck_assert_str_eq(r[1], "1"); 19104 ck_assert_str_eq(r[2], "lib"); 19105 ck_assert_str_eq(r[3], "sheepy"); 19106 freeManyS(l,l2,r); 19107 // empty list 19108 listEmpty(l); 19109 r = listCat(l); 19110 ck_assert(listIsEmpty(r)); 19111 freeManyS(r,l); 19112 // cat empty list with list 19113 listEmpty(l); 19114 l2 = NULL; 19115 r = listPush(&l2, (void*)s3); 19116 ck_assert_ptr_eq(r, l2); 19117 r = listPush(&l2, (void*)s4); 19118 ck_assert_ptr_eq(r, l2); 19119 r = listCat(l, l2); 19120 ck_assert_str_eq(r[0], "lib"); 19121 ck_assert_str_eq(r[1], "sheepy"); 19122 freeManyS(l,l2,r); 19123 19124 } 19125 19126 19127 void listAppendT(CuTest *tc UNUSED) { 19128 19129 void **l = NULL; 19130 void **l2 = NULL; 19131 char *s1 = "1"; 19132 char *s2 = "22"; 19133 char *s3 = "333"; 19134 char *s4 = "4444"; 19135 char *sA = "A"; 19136 char *sB = "BB"; 19137 char *sC = "CCC"; 19138 char *sD = "DDDD"; 19139 void **r = null; 19140 19141 // lists 19142 r = listPush(&l, (void*)s1); 19143 ck_assert_ptr_eq(r, l); 19144 r = listPush(&l, (void*)s2); 19145 ck_assert_ptr_eq(r, l); 19146 r = listPush(&l, (void*)s3); 19147 ck_assert_ptr_eq(r, l); 19148 r = listPush(&l, (void*)s4); 19149 ck_assert_ptr_eq(r, l); 19150 r = listPush(&l2, (void*)sA); 19151 ck_assert_ptr_eq(r, l2); 19152 r = listPush(&l2, (void*)sB); 19153 ck_assert_ptr_eq(r, l2); 19154 r = listPush(&l2, (void*)sC); 19155 ck_assert_ptr_eq(r, l2); 19156 r = listPush(&l2, (void*)sD); 19157 ck_assert_ptr_eq(r, l2); 19158 r = listAppend(&l2,l); 19159 ck_assert_ptr_eq(r, l2); 19160 ck_assert_uint_eq(listLength(l2),8); 19161 ck_assert_str_eq(l2[0], "A"); 19162 ck_assert_str_eq(l2[3], "DDDD"); 19163 ck_assert_str_eq(l2[4],"1"); 19164 ck_assert_str_eq(l2[7],"4444"); 19165 free(l); 19166 // append list to itself - no change 19167 l = NULL; 19168 r = listPush(&l, (void*)s1); 19169 ck_assert_ptr_eq(r, l); 19170 r = listPush(&l, (void*)s2); 19171 ck_assert_ptr_eq(r, l); 19172 r = listPush(&l, (void*)s3); 19173 ck_assert_ptr_eq(r, l); 19174 r = listPush(&l, (void*)s4); 19175 ck_assert_ptr_eq(r, l); 19176 r = listAppend(&l,l); 19177 ck_assert_ptr_eq(r, null); 19178 ck_assert_uint_eq(listLength(l),4); 19179 ck_assert_str_eq(l[0], "1"); 19180 ck_assert_str_eq(l[3], "4444"); 19181 free(l); 19182 // empty list + list 19183 listEmpty(l); 19184 r = listAppend(&l, l2); 19185 ck_assert_ptr_eq(r, l); 19186 //ck_assert(listEqS(l,l2)); 19187 ck_assert_uint_eq(listLength(l),listLength(l2)); 19188 ck_assert_str_eq(l2[0], l[0]); 19189 ck_assert_str_eq(l2[3], l[3]); 19190 ck_assert_str_eq(l2[4], l[4]); 19191 ck_assert_str_eq(l2[7], l[7]); 19192 free(l); 19193 // list + empty list 19194 listEmptyS(l); 19195 r = listAppend(&l2, l); 19196 ck_assert_ptr_eq(r, l2); 19197 ck_assert_uint_eq(listLength(l2),8); 19198 ck_assert_str_eq(l2[0], "A"); 19199 ck_assert_str_eq(l2[3], "DDDD"); 19200 ck_assert_str_eq(l2[4],"1"); 19201 ck_assert_str_eq(l2[7],"4444"); 19202 free(l); 19203 free(l2); 19204 // empty list + empty list 19205 listEmpty(l); 19206 listEmpty(l2); 19207 r = listAppend(&l, l2); 19208 ck_assert_ptr_eq(r, l); 19209 ck_assert(listIsEmpty(l)); 19210 free(l); 19211 free(l2); 19212 // NULL list + list = duplicate 19213 l = NULL; 19214 l2 = NULL; 19215 r = listPush(&l2, (void*)sA); 19216 ck_assert_ptr_eq(r, l2); 19217 r = listPush(&l2, (void*)sB); 19218 ck_assert_ptr_eq(r, l2); 19219 r = listPush(&l2, (void*)sC); 19220 ck_assert_ptr_eq(r, l2); 19221 r = listPush(&l2, (void*)sD); 19222 ck_assert_ptr_eq(r, l2); 19223 r = listAppend(&l,l2); 19224 ck_assert_ptr_eq(r, l); 19225 //ck_assert(listEqS(l,l2)); 19226 ck_assert_uint_eq(listLength(l),listLength(l2)); 19227 ck_assert_str_eq(l2[0], l[0]); 19228 ck_assert_str_eq(l2[3], l[3]); 19229 free(l); 19230 // list + NULL list 19231 r = listAppend(&l2, NULL); 19232 ck_assert_ptr_eq(r, l2); 19233 ck_assert_uint_eq(listLength(l2),4); 19234 ck_assert_str_eq(l2[0], "A"); 19235 ck_assert_str_eq(l2[3], "DDDD"); 19236 free(l2); 19237 // NULL list pointer 19238 r = listAppend(NULL,l2); 19239 ck_assert_ptr_eq(r, null); 19240 // should not crash 19241 19242 } 19243 19244 19245 void listAddT(CuTest *tc UNUSED) { 19246 19247 void **l = NULL; 19248 void **l2 = NULL; 19249 void **l3; 19250 char *s1 = "1"; 19251 char *s2 = "22"; 19252 char *s3 = "333"; 19253 char *s4 = "4444"; 19254 char *sA = "A"; 19255 char *sB = "BB"; 19256 char *sC = "CCC"; 19257 char *sD = "DDDD"; 19258 void **r = null; 19259 19260 // lists 19261 r = listPush(&l, (void*)s1); 19262 ck_assert_ptr_eq(r, l); 19263 r = listPush(&l, (void*)s2); 19264 ck_assert_ptr_eq(r, l); 19265 r = listPush(&l, (void*)s3); 19266 ck_assert_ptr_eq(r, l); 19267 r = listPush(&l, (void*)s4); 19268 ck_assert_ptr_eq(r, l); 19269 r = listPush(&l2, (void*)sA); 19270 ck_assert_ptr_eq(r, l2); 19271 r = listPush(&l2, (void*)sB); 19272 ck_assert_ptr_eq(r, l2); 19273 r = listPush(&l2, (void*)sC); 19274 ck_assert_ptr_eq(r, l2); 19275 r = listPush(&l2, (void*)sD); 19276 ck_assert_ptr_eq(r, l2); 19277 l3 = listAdd(l2,l); 19278 ck_assert_uint_eq(listLength(l3),8); 19279 ck_assert_str_eq(l3[0], "A"); 19280 ck_assert_str_eq(l3[3], "DDDD"); 19281 ck_assert_str_eq(l3[4],"1"); 19282 ck_assert_str_eq(l3[7],"4444"); 19283 free(l3); 19284 free(l); 19285 // empty list + list 19286 listEmpty(l); 19287 l3 = listAdd(l, l2); 19288 //ck_assert(listEqS(l3,l2)); 19289 ck_assert_uint_eq(listLength(l3),listLength(l2)); 19290 ck_assert_str_eq(l3[0], l2[0]); 19291 ck_assert_str_eq(l3[3], l2[3]); 19292 free(l3); 19293 free(l); 19294 // list + empty list 19295 listEmpty(l) 19296 l3 = listAdd(l2, l); 19297 //ck_assert(listEqS(l3,l2)); 19298 ck_assert_uint_eq(listLength(l3),listLength(l2)); 19299 ck_assert_str_eq(l3[0], l2[0]); 19300 ck_assert_str_eq(l3[3], l2[3]); 19301 free(l3); 19302 free(l); 19303 // empty list + empty list 19304 listEmpty(l); 19305 l3 = listAdd(l, l); 19306 ck_assert(listIsEmpty(l3)); 19307 free(l3); 19308 free(l); 19309 // NULL list + list 19310 l3 = listAdd(NULL,l2); 19311 //ck_assert(listEq(l3,l2)); 19312 ck_assert_uint_eq(listLength(l3),listLength(l2)); 19313 ck_assert_str_eq(l3[0], l2[0]); 19314 ck_assert_str_eq(l3[3], l2[3]); 19315 free(l3); 19316 // list + NULL list 19317 l3 = listAdd(l2, NULL); 19318 //ck_assert(listEqS(l3,l2)); 19319 ck_assert_uint_eq(listLength(l3),listLength(l2)); 19320 ck_assert_str_eq(l3[0], l2[0]); 19321 ck_assert_str_eq(l3[3], l2[3]); 19322 free(l3); 19323 free(l2); 19324 // NULL list + NULL list 19325 ck_assert_ptr_eq(listAdd(NULL,NULL), NULL); 19326 19327 } 19328 19329 19330 void listSliceT(CuTest *tc UNUSED) { 19331 19332 void **l = NULL; 19333 void **l2; 19334 char *s1 = "1"; 19335 char *s2 = "22"; 19336 char *s3 = "333"; 19337 char *s4 = "4444"; 19338 void **r = null; 19339 19340 // list negative index 19341 r = listPush(&l, (void*)s1); 19342 ck_assert_ptr_eq(r, l); 19343 r = listPush(&l, (void*)s2); 19344 ck_assert_ptr_eq(r, l); 19345 r = listPush(&l, (void*)s3); 19346 ck_assert_ptr_eq(r, l); 19347 r = listPush(&l, (void*)s4); 19348 ck_assert_ptr_eq(r, l); 19349 l2 = listSlice(l, 1,-1); 19350 ck_assert_uint_eq(listLength(l2),2); 19351 ck_assert_str_eq(l2[0], "22"); 19352 ck_assert_str_eq(l2[1], "333"); 19353 free(l); 19354 free(l2); 19355 // start outside 19356 l = NULL; 19357 r = listPush(&l, (void*)s1); 19358 ck_assert_ptr_eq(r, l); 19359 r = listPush(&l, (void*)s2); 19360 ck_assert_ptr_eq(r, l); 19361 r = listPush(&l, (void*)s3); 19362 ck_assert_ptr_eq(r, l); 19363 r = listPush(&l, (void*)s4); 19364 ck_assert_ptr_eq(r, l); 19365 ck_assert_ptr_eq(listSlice(l, 20,-4), NULL); 19366 // end outside 19367 l2 = listSlice(l, 2,40); 19368 ck_assert_uint_eq(listLength(l2),2); 19369 ck_assert_str_eq(l2[0], "333"); 19370 ck_assert_str_eq(l2[1], "4444"); 19371 free(l); 19372 free(l2); 19373 // end negative and outside 19374 l = NULL; 19375 r = listPush(&l, (void*)s1); 19376 ck_assert_ptr_eq(r, l); 19377 r = listPush(&l, (void*)s2); 19378 ck_assert_ptr_eq(r, l); 19379 r = listPush(&l, (void*)s3); 19380 ck_assert_ptr_eq(r, l); 19381 r = listPush(&l, (void*)s4); 19382 ck_assert_ptr_eq(r, l); 19383 ck_assert_ptr_eq(listSlice(l, 2,-40), NULL); 19384 // end before start 19385 ck_assert_ptr_eq(listSlice(l, 3,2), NULL); 19386 free(l); 19387 // negative start last element 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,0); 19394 ck_assert_uint_eq(listLength(l2),1); 19395 ck_assert_str_eq(l2[0], "22"); 19396 free(l); 19397 free(l2); 19398 // start = end 19399 l = NULL; 19400 r = listPush(&l, (void*)s1); 19401 ck_assert_ptr_eq(r, l); 19402 r = listPush(&l, (void*)s2); 19403 ck_assert_ptr_eq(r, l); 19404 l2 = listSlice(l, 1,1); 19405 ck_assert_uint_eq(listLength(l2),0); 19406 ck_assert_ptr_eq(l2[0], NULL); 19407 free(l); 19408 free(l2); 19409 // empty list 19410 listEmpty(l) 19411 ck_assert_ptr_eq(listSlice(l, 0,0), NULL); 19412 ck_assert_ptr_eq(listSlice(l, -1,0), NULL); 19413 free(l); 19414 // NULL list 19415 ck_assert_ptr_eq(listSlice(NULL, 2,-4), NULL); 19416 19417 19418 } 19419 19420 19421 void iListSliceT(CuTest *tc UNUSED) { 19422 19423 void **l = NULL; 19424 char *s1 = "1"; 19425 char *s2 = "22"; 19426 char *s3 = "333"; 19427 char *s4 = "4444"; 19428 void **r = null; 19429 19430 // list negative index 19431 r = listPush(&l, (void*)s1); 19432 ck_assert_ptr_eq(r, l); 19433 r = listPush(&l, (void*)s2); 19434 ck_assert_ptr_eq(r, l); 19435 r = listPush(&l, (void*)s3); 19436 ck_assert_ptr_eq(r, l); 19437 r = listPush(&l, (void*)s4); 19438 ck_assert_ptr_eq(r, l); 19439 r = iListSlice(&l, 1,-1); 19440 ck_assert_ptr_eq(r, l); 19441 ck_assert_uint_eq(listLength(l),2); 19442 ck_assert_str_eq(l[0], "22"); 19443 ck_assert_str_eq(l[1], "333"); 19444 // start outside 19445 r = listPush(&l, (void*)s1); 19446 ck_assert_ptr_eq(r, l); 19447 r = listPush(&l, (void*)s2); 19448 ck_assert_ptr_eq(r, l); 19449 r = iListSlice(&l, 20,-4); 19450 ck_assert_ptr_eq(r, null); 19451 ck_assert_uint_eq(listLength(l),0); 19452 // end outside 19453 r = iListSlice(&l, 2,40); 19454 ck_assert_ptr_eq(r, null); 19455 ck_assert_uint_eq(listLength(l),0); 19456 // end negative and outside 19457 r = iListSlice(&l, 2,-40); 19458 ck_assert_ptr_eq(r, null); 19459 ck_assert_uint_eq(listLength(l),0); 19460 // end before start 19461 r = listPush(&l, (void*)s3); 19462 ck_assert_ptr_eq(r, l); 19463 r = listPush(&l, (void*)s4); 19464 ck_assert_ptr_eq(r, l); 19465 r = iListSlice(&l, 3,2); 19466 ck_assert_ptr_eq(r, null); 19467 ck_assert_uint_eq(listLength(l),0); 19468 free(l); 19469 // negative start last element 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,0); 19476 ck_assert_ptr_eq(r, l); 19477 ck_assert_uint_eq(listLength(l),1); 19478 ck_assert_str_eq(l[0], "22"); 19479 free(l); 19480 // start = end 19481 l = NULL; 19482 r = listPush(&l, (void*)s1); 19483 ck_assert_ptr_eq(r, l); 19484 r = listPush(&l, (void*)s2); 19485 ck_assert_ptr_eq(r, l); 19486 r = iListSlice(&l, 1,1); 19487 ck_assert_ptr_eq(r, l); 19488 ck_assert_uint_eq(listLength(l),0); 19489 ck_assert_ptr_eq(l[0], NULL); 19490 free(l); 19491 // empty list 19492 listEmpty(l) 19493 r = iListSlice(&l, 0,0); 19494 ck_assert_ptr_eq(r, null); 19495 ck_assert(listIsEmpty(l)); 19496 r = iListSlice(&l, -1,0); 19497 ck_assert_ptr_eq(r, null); 19498 ck_assert(listIsEmpty(l)); 19499 free(l); 19500 // NULL list 19501 l = NULL; 19502 r = iListSlice(&l, 2,-4); 19503 ck_assert_ptr_eq(r, null); 19504 // NULL var 19505 r = iListSlice(NULL, 2,-4); 19506 ck_assert_ptr_eq(r, null); 19507 19508 19509 } 19510 19511 19512 void listInsertT(CuTest *tc UNUSED) { 19513 19514 void **l; 19515 void **l2; 19516 void **r; 19517 char *s1 = "1"; 19518 char *s2 = "22"; 19519 char *s3 = "lib"; 19520 19521 // insert 19522 l = listCreate((void*)s1, (void*)s2); 19523 l2 = listCreate((void*)s3); 19524 r = listInsert(l, 0, l2); 19525 ck_assert_uint_eq(listLength(r),3); 19526 ck_assert_str_eq(r[0], "lib"); 19527 ck_assert_str_eq(r[1], "1"); 19528 ck_assert_str_eq(r[2], "22"); 19529 free(r); 19530 // negative index 19531 r = listInsert(l, -1, l2); 19532 ck_assert_uint_eq(listLength(r),3); 19533 ck_assert_str_eq(r[0], "1"); 19534 ck_assert_str_eq(r[1], "22"); 19535 ck_assert_str_eq(r[2], "lib"); 19536 free(r); 19537 // edge 19538 r = listInsert(l, 2, l2); 19539 ck_assert_uint_eq(listLength(r),3); 19540 ck_assert_str_eq(r[0], "1"); 19541 ck_assert_str_eq(r[1], "22"); 19542 ck_assert_str_eq(r[2], "lib"); 19543 free(r); 19544 // outside list 19545 r = listInsert(l, 4, l2); 19546 ck_assert_ptr_eq(r, NULL); 19547 r = listInsert(l, -4, l2); 19548 ck_assert_ptr_eq(r, NULL); 19549 free(l); 19550 // negative index in a one element list 19551 l = listCreate((void*)s1); 19552 r = listInsert(l, -1, l2); 19553 ck_assert_str_eq(r[0], "1"); 19554 ck_assert_str_eq(r[1], "lib"); 19555 freeManyS(l,r); 19556 // empty list 19557 listEmpty(l); 19558 r = listInsert(l, 0, l2); 19559 ck_assert_str_eq(r[0], "lib"); 19560 freeManyS(r,l, l2); 19561 // empty insert list 19562 l = listCreate((void*)s1); 19563 listEmpty(l2); 19564 r = listInsert(l, 0, l2); 19565 ck_assert_str_eq(r[0], "1"); 19566 freeManyS(r,l2); 19567 // NULL insert string 19568 r = listInsert(l, 0, NULL); 19569 ck_assert_ptr_eq(r, NULL); 19570 free(l); 19571 // NULL list 19572 r = listInsert(NULL, 0, NULL); 19573 ck_assert_ptr_eq(r, NULL); 19574 19575 19576 } 19577 19578 19579 void iListInsertT(CuTest *tc UNUSED) { 19580 19581 void **l; 19582 void **l2; 19583 char *s1 = "1"; 19584 char *s2 = "22"; 19585 char *s3 = "lib"; 19586 void **r = null; 19587 19588 // insert 19589 l = listCreate((void*)s1, (void*)s2); 19590 l2 = listCreate((void*)s3); 19591 r = iListInsert(&l, 0, l2); 19592 ck_assert_ptr_eq(r, l); 19593 ck_assert_uint_eq(listLength(l),3); 19594 ck_assert_str_eq(l[0], "lib"); 19595 ck_assert_str_eq(l[1], "1"); 19596 ck_assert_str_eq(l[2], "22"); 19597 free(l2); 19598 free(l); 19599 // negative index 19600 l = listCreate((void*)s1, (void*)s2); 19601 l2 = listCreate((void*)s3); 19602 r = iListInsert(&l, -1, 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 // edge 19611 l = listCreate((void*)s1, (void*)s2); 19612 l2 = listCreate((void*)s3); 19613 r = iListInsert(&l, 2, l2); 19614 ck_assert_ptr_eq(r, l); 19615 ck_assert_uint_eq(listLength(l),3); 19616 ck_assert_str_eq(l[0], "1"); 19617 ck_assert_str_eq(l[1], "22"); 19618 ck_assert_str_eq(l[2], "lib"); 19619 free(l2); 19620 free(l); 19621 // outside list 19622 l = listCreate((void*)s1, (void*)s2); 19623 l2 = listCreate((void*)s3); 19624 r = iListInsert(&l, 4, l2); 19625 ck_assert_ptr_eq(r, null); 19626 ck_assert_uint_eq(listLength(l),2); 19627 ck_assert_str_eq(l[0], "1"); 19628 ck_assert_str_eq(l[1], "22"); 19629 r = iListInsert(&l, -4, l2); 19630 ck_assert_ptr_eq(r, null); 19631 ck_assert_uint_eq(listLength(l),2); 19632 ck_assert_str_eq(l[0], "1"); 19633 ck_assert_str_eq(l[1], "22"); 19634 free(l); 19635 // negative index in a one element list 19636 l = listCreate((void*)s1); 19637 r = iListInsert(&l, -1, l2); 19638 ck_assert_ptr_eq(r, l); 19639 ck_assert_str_eq(l[0], "1"); 19640 ck_assert_str_eq(l[1], "lib"); 19641 free(l2); 19642 free(l); 19643 // empty list 19644 listEmpty(l); 19645 l2 = listCreate((void*)s3); 19646 r = iListInsert(&l, 0, l2); 19647 ck_assert_ptr_eq(r, l); 19648 ck_assert_str_eq(l[0], "lib"); 19649 free(l2); 19650 free(l); 19651 // empty insert list 19652 l = listCreate((void*)s1); 19653 listEmpty(l2); 19654 r = iListInsert(&l, 0, l2); 19655 ck_assert_ptr_eq(r, l); 19656 ck_assert_str_eq(l[0], "1"); 19657 free(l2); 19658 // NULL insert string 19659 r = iListInsert(&l, 0, NULL); 19660 ck_assert_ptr_eq(r, null); 19661 ck_assert_str_eq(l[0], "1"); 19662 free(l); 19663 // NULL list 19664 l = NULL; 19665 r = iListInsert(&l, 0, NULL); 19666 ck_assert_ptr_eq(r, null); 19667 ck_assert_ptr_eq(l, NULL); 19668 // NULL var 19669 r = iListInsert(NULL, 0, NULL); 19670 ck_assert_ptr_eq(r, NULL); 19671 19672 19673 } 19674 19675 19676 void listDelT(CuTest *tc UNUSED) { 19677 19678 void **l = NULL; 19679 void **l2; 19680 char *s1 = "1"; 19681 char *s2 = "22"; 19682 char *s3 = "333"; 19683 char *s4 = "4444"; 19684 void **r = null; 19685 19686 // list negative index 19687 r = listPush(&l, (void*)s1); 19688 ck_assert_ptr_eq(r, l); 19689 r = listPush(&l, (void*)s2); 19690 ck_assert_ptr_eq(r, l); 19691 r = listPush(&l, (void*)s3); 19692 ck_assert_ptr_eq(r, l); 19693 r = listPush(&l, (void*)s4); 19694 ck_assert_ptr_eq(r, l); 19695 l2 = listDel(l, 1,-1); 19696 ck_assert_uint_eq(listLength(l2),2); 19697 ck_assert_str_eq(l2[0], "1"); 19698 ck_assert_str_eq(l2[1], "4444"); 19699 free(l2); 19700 // start outside 19701 ck_assert_ptr_eq(listDel(l, 20,-4), NULL); 19702 // end outside 19703 l2 = listDel(l, 2,40); 19704 ck_assert_uint_eq(listLength(l2),2); 19705 ck_assert_str_eq(l2[0], "1"); 19706 ck_assert_str_eq(l2[1], "22"); 19707 free(l2); 19708 // end negative and outside 19709 ck_assert_ptr_eq(listDel(l, 2,-40), NULL); 19710 // end before start 19711 ck_assert_ptr_eq(listDel(l, 3,2), NULL); 19712 free(l); 19713 // negative start last element 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, -1,0); 19720 ck_assert_uint_eq(listLength(l2),1); 19721 ck_assert_str_eq(l2[0], "1"); 19722 free(l); 19723 free(l2); 19724 // start negative and outside (delete complete list because end is 0 (=len)) 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, -3,0); 19731 ck_assert_uint_eq(listLength(l2),0); 19732 ck_assert_ptr_eq(l2[0], NULL); 19733 free(l); 19734 free(l2); 19735 // start = end 19736 l = NULL; 19737 r = listPush(&l, (void*)s1); 19738 ck_assert_ptr_eq(r, l); 19739 r = listPush(&l, (void*)s2); 19740 ck_assert_ptr_eq(r, l); 19741 l2 = listDel(l, 1,1); 19742 ck_assert_uint_eq(listLength(l2),2); 19743 ck_assert_str_eq(l2[0], "1"); 19744 ck_assert_str_eq(l2[1], "22"); 19745 free(l); 19746 free(l2); 19747 // empty list 19748 listEmpty(l) 19749 ck_assert_ptr_eq(listDel(l, 0,0), NULL); 19750 ck_assert_ptr_eq(listDel(l, -1,0), NULL); 19751 free(l); 19752 // NULL list 19753 ck_assert_ptr_eq(listDel(NULL, 2,-4), NULL); 19754 19755 19756 } 19757 19758 19759 void iListDelT(CuTest *tc UNUSED) { 19760 19761 void **l = NULL; 19762 char *s1 = "1"; 19763 char *s2 = "22"; 19764 char *s3 = "333"; 19765 char *s4 = "4444"; 19766 void **r = null; 19767 19768 // list negative index 19769 r = listPush(&l, (void*)s1); 19770 ck_assert_ptr_eq(r, l); 19771 r = listPush(&l, (void*)s2); 19772 ck_assert_ptr_eq(r, l); 19773 r = listPush(&l, (void*)s3); 19774 ck_assert_ptr_eq(r, l); 19775 r = listPush(&l, (void*)s4); 19776 ck_assert_ptr_eq(r, l); 19777 r = iListDel(&l, 1,-1); 19778 ck_assert_ptr_eq(r, l); 19779 ck_assert_uint_eq(listLength(l),2); 19780 ck_assert_str_eq(l[0], "1"); 19781 ck_assert_str_eq(l[1], "4444"); 19782 r = iListEmptyF(&l); 19783 ck_assert_ptr_eq(r, l); 19784 // start outside 19785 r = listPush(&l, (void*)s1); 19786 ck_assert_ptr_eq(r, l); 19787 r = listPush(&l, (void*)s2); 19788 ck_assert_ptr_eq(r, l); 19789 r = listPush(&l, (void*)s3); 19790 ck_assert_ptr_eq(r, l); 19791 r = listPush(&l, (void*)s4); 19792 ck_assert_ptr_eq(r, l); 19793 r = iListDel(&l, 20,-4); 19794 ck_assert_ptr_eq(r, null); 19795 ck_assert_uint_eq(listLength(l),4); 19796 ck_assert_str_eq(l[0], "1"); 19797 ck_assert_str_eq(l[3], "4444"); 19798 // end outside 19799 r = iListDel(&l, 2,40); 19800 ck_assert_ptr_eq(r, l); 19801 ck_assert_uint_eq(listLength(l),2); 19802 ck_assert_str_eq(l[0], "1"); 19803 ck_assert_str_eq(l[1], "22"); 19804 r = iListEmptyF(&l); 19805 ck_assert_ptr_eq(r, l); 19806 // end negative and outside 19807 r = listPush(&l, (void*)s1); 19808 ck_assert_ptr_eq(r, l); 19809 r = listPush(&l, (void*)s2); 19810 ck_assert_ptr_eq(r, l); 19811 r = listPush(&l, (void*)s3); 19812 ck_assert_ptr_eq(r, l); 19813 r = listPush(&l, (void*)s4); 19814 ck_assert_ptr_eq(r, l); 19815 r = iListDel(&l, 2,-40); 19816 ck_assert_ptr_eq(r, null); 19817 ck_assert_uint_eq(listLength(l),4); 19818 ck_assert_str_eq(l[0], "1"); 19819 ck_assert_str_eq(l[3], "4444"); 19820 // end before start 19821 r = iListDel(&l, 3,2); 19822 ck_assert_ptr_eq(r, null); 19823 ck_assert_uint_eq(listLength(l),4); 19824 ck_assert_str_eq(l[0], "1"); 19825 ck_assert_str_eq(l[3], "4444"); 19826 r = iListEmptyF(&l); 19827 ck_assert_ptr_eq(r, l); 19828 // negative start last element 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, -1,0); 19834 ck_assert_ptr_eq(r, l); 19835 ck_assert_uint_eq(listLength(l),1); 19836 ck_assert_str_eq(l[0], "1"); 19837 r = iListEmptyF(&l); 19838 ck_assert_ptr_eq(r, l); 19839 // start negative and outside (delete complete list because end is 0 (=len)) 19840 r = listPush(&l, (void*)s1); 19841 ck_assert_ptr_eq(r, l); 19842 r = listPush(&l, (void*)s2); 19843 ck_assert_ptr_eq(r, l); 19844 r = iListDel(&l, -3,0); 19845 ck_assert_ptr_eq(r, l); 19846 ck_assert_uint_eq(listLength(l),0); 19847 ck_assert_ptr_eq(l[0], NULL); 19848 // start = end 19849 // (l is empty from previous test) 19850 r = listPush(&l, (void*)s1); 19851 ck_assert_ptr_eq(r, l); 19852 r = listPush(&l, (void*)s2); 19853 ck_assert_ptr_eq(r, l); 19854 r = iListDel(&l, 1,1); 19855 ck_assert_ptr_eq(r, l); 19856 ck_assert_uint_eq(listLength(l),2); 19857 ck_assert_str_eq(l[0], "1"); 19858 ck_assert_str_eq(l[1], "22"); 19859 free(l); 19860 // empty list 19861 listEmpty(l); 19862 r = iListDel(&l, 0,0); 19863 ck_assert_ptr_eq(r, null); 19864 ck_assert(listIsEmpty(l)); 19865 r = iListDel(&l, -1,0); 19866 ck_assert_ptr_eq(r, null); 19867 ck_assert(listIsEmpty(l)); 19868 free(l); 19869 // NULL list 19870 l = NULL; 19871 r = iListDel(&l, 2,-4); 19872 ck_assert_ptr_eq(r, null); 19873 ck_assert_ptr_eq(l, NULL); 19874 // NULL var 19875 r = iListDel(NULL, 2,-4); 19876 ck_assert_ptr_eq(r, null); 19877 19878 19879 } 19880 19881 ringMake(ringTestT, int, 4); 19882 19883 void ringInitT(CuTest *tc UNUSED) { 19884 19885 ringTestT rg; 19886 19887 ck_assert_int_eq(ringInit(&rg, 4), 1); 19888 19889 // NULL 19890 ck_assert_int_eq(ringInit(NULL, 4), 0); 19891 19892 19893 } 19894 19895 19896 void ringEmptyT(CuTest *tc UNUSED) { 19897 19898 ringTestT rg; 19899 ringInit(&rg, 4); 19900 19901 // empty 19902 ringPush(&rg); 19903 ck_assert_int_eq(ringEmpty(&rg), 1); 19904 ck_assert_int_eq(ringIsEmpty(&rg), 1); 19905 19906 // already empty 19907 ck_assert_int_eq(ringEmpty(&rg), 1); 19908 19909 // null ring 19910 ck_assert_int_eq(ringEmpty(null), 0); 19911 19912 } 19913 19914 19915 void ringIsEmptyT(CuTest *tc UNUSED) { 19916 19917 ringTestT rg; 19918 ringInit(&rg, 4); 19919 19920 // empty 19921 ck_assert_int_eq(ringIsEmpty(&rg), 1); 19922 19923 // not empty 19924 ringPush(&rg); 19925 ck_assert_int_eq(ringIsEmpty(&rg), 0); 19926 19927 // NULL 19928 ck_assert_int_eq(ringIsEmpty(NULL), -1); 19929 19930 19931 } 19932 19933 19934 void ringIsFullT(CuTest *tc UNUSED) { 19935 19936 ringTestT rg; 19937 ringInit(&rg, 4); 19938 19939 // full 19940 ringPush(&rg); 19941 rg.last = 2; 19942 rg.head = 3; 19943 ck_assert_int_eq(ringIsFull(&rg), 1); 19944 19945 // not full 19946 rg.last = 1; 19947 ck_assert_int_eq(ringIsFull(&rg), 0); 19948 19949 // NULL 19950 ck_assert_int_eq(ringIsFull(NULL), -1); 19951 19952 } 19953 19954 19955 void ringCountT(CuTest *tc UNUSED) { 19956 19957 ringTestT rg; 19958 ringInit(&rg, 4); 19959 19960 // empty 19961 ck_assert_int_eq(ringCount(&rg), 0); 19962 // last < head 19963 ringPush(&rg); 19964 rg.last = 2; 19965 rg.head = 3; 19966 ck_assert_int_eq(ringCount(&rg), 4); 19967 // cound > head 19968 rg.head = 0; 19969 rg.last = 2; 19970 ck_assert_int_eq(ringCount(&rg), 3); 19971 // NULL 19972 ck_assert_int_eq(ringCount(NULL), -1); 19973 19974 } 19975 19976 19977 void ringPushT(CuTest *tc UNUSED) { 19978 19979 ringTestT rg; 19980 ringInit(&rg, 4); 19981 19982 // push 19983 ck_assert_int_eq(ringPush(&rg), 0); 19984 ck_assert_int_eq(ringPush(&rg), 1); 19985 ck_assert_int_eq(ringPush(&rg), 2); 19986 ck_assert_int_eq(ringPush(&rg), 3); 19987 // full 19988 ck_assert_int_eq(ringPush(&rg), -1); 19989 ck_assert_int_eq(ringPush(&rg), -1); 19990 // NULL 19991 ck_assert_int_eq(ringPush(NULL), -2); 19992 19993 19994 } 19995 19996 19997 void ringPopT(CuTest *tc UNUSED) { 19998 19999 ringTestT rg; 20000 ringInit(&rg, 4); 20001 20002 // empty ring 20003 ck_assert_int_eq(ringPop(&rg), 0); 20004 // pop 20005 ringPush(&rg); 20006 ringPush(&rg); 20007 ck_assert_int_eq(ringPop(&rg), 1); 20008 // pop last 20009 ck_assert_int_eq(ringPop(&rg), 1); 20010 // pop when head > last 20011 rg.isEmpty = false; 20012 rg.head = 3; 20013 ck_assert_int_eq(ringPop(&rg), 1); 20014 // NULL 20015 ck_assert_int_eq(ringPop(NULL), -1); 20016 20017 } 20018 20019 20020 void ringPrependT(CuTest *tc UNUSED) { 20021 20022 ringTestT rg; 20023 ringInit(&rg, 4); 20024 20025 // push 20026 ck_assert_int_eq(ringPrepend(&rg), 0); 20027 ck_assert_int_eq(ringPrepend(&rg), 3); 20028 ck_assert_int_eq(ringPrepend(&rg), 2); 20029 ck_assert_int_eq(ringPrepend(&rg), 1); 20030 // full 20031 ck_assert_int_eq(ringPrepend(&rg), -1); 20032 ck_assert_int_eq(ringPrepend(&rg), -1); 20033 // NULL 20034 ck_assert_int_eq(ringPrepend(NULL), -2); 20035 20036 } 20037 20038 20039 void ringDequeueT(CuTest *tc UNUSED) { 20040 20041 ringTestT rg; 20042 ringInit(&rg, 4); 20043 20044 // empty ring 20045 ck_assert_int_eq(ringDequeue(&rg), 0); 20046 // pop 20047 ringPush(&rg); 20048 ringPush(&rg); 20049 ck_assert_int_eq(ringDequeue(&rg), 1); 20050 // pop last 20051 ck_assert_int_eq(ringDequeue(&rg), 1); 20052 // pop when head > last 20053 rg.isEmpty = false; 20054 rg.head = 3; 20055 ck_assert_int_eq(ringDequeue(&rg), 1); 20056 // NULL 20057 ck_assert_int_eq(ringDequeue(NULL), -1); 20058 20059 } 20060 20061 #define chanMax 30 20062 ringMake(chanT, int, chanMax); 20063 20064 // context for fibers of type fiberA 20065 typedef struct {int slot; int a; chanT *c;} AArgs; 20066 20067 // declaration of fibers type fiberA 20068 void fiberATest(int thisSlot UNUSED) { 20069 return; 20070 } 20071 20072 void fiberAddT(CuTest *tc UNUSED) { 20073 20074 staticArrayInit(fibers.L); 20075 staticArrayInit(fibers.startL); 20076 20077 AArgs Aa; 20078 chanT c; 20079 20080 ringInit(&c, chanMax); 20081 20082 Aa.c = &c; 20083 20084 ck_assert(fiberAdd(&Aa, 1, fiberATest)); 20085 20086 } 20087 20088 20089 void fiberPrependT(CuTest *tc UNUSED) { 20090 20091 staticArrayInit(fibers.L); 20092 staticArrayInit(fibers.startL); 20093 20094 AArgs Aa; 20095 chanT c; 20096 20097 ringInit(&c, chanMax); 20098 20099 Aa.c = &c; 20100 20101 ck_assert(fiberPrepend(&Aa, 1, fiberATest)); 20102 20103 } 20104 20105 20106 void schedulerT(CuTest *tc UNUSED) { 20107 20108 staticArrayInit(fibers.L); 20109 staticArrayInit(fibers.startL); 20110 20111 scheduler(); 20112 20113 AArgs Aa; 20114 chanT c; 20115 20116 ringInit(&c, chanMax); 20117 20118 Aa.c = &c; 20119 20120 fiberAdd(&Aa, 1, fiberATest); 20121 20122 scheduler(); 20123 20124 // TODO test 100% 20125 20126 } 20127 20128 20129 void getMonotonicTimeT(CuTest *tc UNUSED) { 20130 20131 uint64_t r = getMonotonicTime(); 20132 ck_assert_uint_ne(r, 0); 20133 20134 } 20135 20136 20137 void nanoSleepT(CuTest *tc UNUSED) { 20138 20139 int r; 20140 20141 nanoSleep(100); 20142 nanoSleepE(100, puts(BLD RED "nanosleep error" RST)); 20143 r = nanoSleepF(100); 20144 ck_assert_int_eq(r, 1); 20145 20146 } 20147 20148 20149 20150 20151 int main(int n UNUSED, char**v UNUSED) { 20152 // disable btrace to make the test run faster 20153 btraceDisable(); 20154 CuString *output = CuStringNew(); 20155 CuSuite *suite = CuSuiteNew(); 20156 20157 SUITE_ADD_TEST(suite, cleanUpCharFreeT); 20158 SUITE_ADD_TEST(suite, cleanUpListFreeT); 20159 SUITE_ADD_TEST(suite, cleanUpFileFreeT); 20160 SUITE_ADD_TEST(suite, cleanUpCharFreeNullT); 20161 SUITE_ADD_TEST(suite, cleanUpListFreeNullT); 20162 SUITE_ADD_TEST(suite, cleanUpFileFreeNullT); 20163 SUITE_ADD_TEST(suite, shStopwatchT); 20164 SUITE_ADD_TEST(suite, setLogSymbolsT); 20165 SUITE_ADD_TEST(suite, setMaxLogLevelT); 20166 SUITE_ADD_TEST(suite, setLogShortPathT); 20167 SUITE_ADD_TEST(suite, setLogStdoutT); 20168 SUITE_ADD_TEST(suite, openProgLogFileT); 20169 SUITE_ADD_TEST(suite, setLogFileT); 20170 SUITE_ADD_TEST(suite, closeLogFilesT); 20171 SUITE_ADD_TEST(suite, getLogModeT); 20172 SUITE_ADD_TEST(suite, setLogModeT); 20173 SUITE_ADD_TEST(suite, _pLogT); 20174 SUITE_ADD_TEST(suite, setProgNameT); 20175 SUITE_ADD_TEST(suite, initLibsheepyFT); 20176 SUITE_ADD_TEST(suite, setStackLimitT); 20177 SUITE_ADD_TEST(suite, getProgPathT); 20178 SUITE_ADD_TEST(suite, getRealProgPathT); 20179 SUITE_ADD_TEST(suite, systemNFreeFT); 20180 SUITE_ADD_TEST(suite, getModificationTimeT); 20181 SUITE_ADD_TEST(suite, setModificationTimeT); 20182 SUITE_ADD_TEST(suite, isReadableT); 20183 SUITE_ADD_TEST(suite, isWritableT); 20184 SUITE_ADD_TEST(suite, isExecutableT); 20185 SUITE_ADD_TEST(suite, equalModificationTimesT); 20186 SUITE_ADD_TEST(suite, getCurrentUnixTimeT); 20187 SUITE_ADD_TEST(suite, strToUnixTimeT); 20188 SUITE_ADD_TEST(suite, timeToST); 20189 SUITE_ADD_TEST(suite, timeToYMDST); 20190 SUITE_ADD_TEST(suite, getCurrentDateT); 20191 SUITE_ADD_TEST(suite, getCurrentDateYMDT); 20192 SUITE_ADD_TEST(suite, shDirnameT); 20193 SUITE_ADD_TEST(suite, bDirnameT); 20194 SUITE_ADD_TEST(suite, bLDirnameT); 20195 SUITE_ADD_TEST(suite, expandHomeT); 20196 SUITE_ADD_TEST(suite, iExpandHomeT); 20197 SUITE_ADD_TEST(suite, bExpandHomeT); 20198 SUITE_ADD_TEST(suite, bLExpandHomeT); 20199 SUITE_ADD_TEST(suite, normalizePathT); 20200 SUITE_ADD_TEST(suite, iNormalizePathT); 20201 SUITE_ADD_TEST(suite, bNormalizePathT); 20202 SUITE_ADD_TEST(suite, bLNormalizePathT); 20203 SUITE_ADD_TEST(suite, relPathT); 20204 SUITE_ADD_TEST(suite, iRelPathT); 20205 SUITE_ADD_TEST(suite, bRelPathT); 20206 SUITE_ADD_TEST(suite, bLRelPathT); 20207 SUITE_ADD_TEST(suite, getHomePathT); 20208 SUITE_ADD_TEST(suite, getCwdT); 20209 SUITE_ADD_TEST(suite, chDirT); 20210 SUITE_ADD_TEST(suite, isDirT); 20211 SUITE_ADD_TEST(suite, shReadlinkT); 20212 SUITE_ADD_TEST(suite, endlinkT); 20213 SUITE_ADD_TEST(suite, isLinkT); 20214 SUITE_ADD_TEST(suite, fileExistsT); 20215 SUITE_ADD_TEST(suite, fileChmodT); 20216 SUITE_ADD_TEST(suite, fileSizeT); 20217 SUITE_ADD_TEST(suite, fileSizeFPT); 20218 SUITE_ADD_TEST(suite, readFileToST); 20219 SUITE_ADD_TEST(suite, readStreamToST); 20220 SUITE_ADD_TEST(suite, bReadFileToST); 20221 SUITE_ADD_TEST(suite, bReadStreamToST); 20222 SUITE_ADD_TEST(suite, bLReadFileToST); 20223 SUITE_ADD_TEST(suite, bLReadStreamToST); 20224 SUITE_ADD_TEST(suite, readFileT); 20225 SUITE_ADD_TEST(suite, bReadFileT); 20226 SUITE_ADD_TEST(suite, bLReadFileT); 20227 SUITE_ADD_TEST(suite, writeFileST); 20228 SUITE_ADD_TEST(suite, writeFileT); 20229 SUITE_ADD_TEST(suite, writeStreamST); 20230 SUITE_ADD_TEST(suite, writeLStreamT); 20231 SUITE_ADD_TEST(suite, appendFileST); 20232 SUITE_ADD_TEST(suite, appendFileT); 20233 SUITE_ADD_TEST(suite, walkDirT); 20234 SUITE_ADD_TEST(suite, walkDirDirT); 20235 SUITE_ADD_TEST(suite, readDirT); 20236 SUITE_ADD_TEST(suite, readDirDirT); 20237 SUITE_ADD_TEST(suite, walkDirAllT); 20238 SUITE_ADD_TEST(suite, readDirAllT); 20239 SUITE_ADD_TEST(suite, mkdirParentsT); 20240 SUITE_ADD_TEST(suite, rmAllT); 20241 SUITE_ADD_TEST(suite, copyT); 20242 SUITE_ADD_TEST(suite, shRenameT); 20243 SUITE_ADD_TEST(suite, shMoveT); 20244 SUITE_ADD_TEST(suite, setSoftwareRandomT); 20245 SUITE_ADD_TEST(suite, setHardwareRandomT); 20246 SUITE_ADD_TEST(suite, randomOpenCloseT); 20247 SUITE_ADD_TEST(suite, randomWordT); 20248 SUITE_ADD_TEST(suite, randomWordFromHWT); 20249 SUITE_ADD_TEST(suite, randomChoiceT); 20250 SUITE_ADD_TEST(suite, randomST); 20251 SUITE_ADD_TEST(suite, bRandomST); 20252 SUITE_ADD_TEST(suite, randomAlphaNumST); 20253 SUITE_ADD_TEST(suite, bRandomAlphaNumST); 20254 SUITE_ADD_TEST(suite, readST); 20255 SUITE_ADD_TEST(suite, bLReadST); 20256 SUITE_ADD_TEST(suite, readPasswordST); 20257 SUITE_ADD_TEST(suite, zeroST); 20258 SUITE_ADD_TEST(suite, zeroBufT); 20259 SUITE_ADD_TEST(suite, memdupT); 20260 SUITE_ADD_TEST(suite, readEnterT); 20261 SUITE_ADD_TEST(suite, readLineT); 20262 SUITE_ADD_TEST(suite, dupST); 20263 SUITE_ADD_TEST(suite, shPrintfST); 20264 SUITE_ADD_TEST(suite, shEprintfT); 20265 SUITE_ADD_TEST(suite, freeManyST); 20266 SUITE_ADD_TEST(suite, logNFreeT); 20267 SUITE_ADD_TEST(suite, loghexT); 20268 SUITE_ADD_TEST(suite, toHexST); 20269 SUITE_ADD_TEST(suite, toHexSepST); 20270 SUITE_ADD_TEST(suite, toHexHeadSepST); 20271 SUITE_ADD_TEST(suite, strCpyT); 20272 SUITE_ADD_TEST(suite, strNCpyT); 20273 SUITE_ADD_TEST(suite, strLCpyT); 20274 SUITE_ADD_TEST(suite, strCatT); 20275 SUITE_ADD_TEST(suite, strNCatT); 20276 SUITE_ADD_TEST(suite, strLCatT); 20277 SUITE_ADD_TEST(suite, strLNCatT); 20278 SUITE_ADD_TEST(suite, catST); 20279 SUITE_ADD_TEST(suite, iCatST); 20280 SUITE_ADD_TEST(suite, bLCatST); 20281 SUITE_ADD_TEST(suite, formatST); 20282 SUITE_ADD_TEST(suite, appendST); 20283 SUITE_ADD_TEST(suite, appendCharST); 20284 SUITE_ADD_TEST(suite, appendSCharT); 20285 SUITE_ADD_TEST(suite, iAppendST); 20286 SUITE_ADD_TEST(suite, iAppendCharST); 20287 SUITE_ADD_TEST(suite, iAppendNFreeST); 20288 SUITE_ADD_TEST(suite, iAppendManyST); 20289 SUITE_ADD_TEST(suite, bAppendManyST); 20290 SUITE_ADD_TEST(suite, bLAppendManyST); 20291 SUITE_ADD_TEST(suite, prependST); 20292 SUITE_ADD_TEST(suite, prependCharST); 20293 SUITE_ADD_TEST(suite, prependSCharT); 20294 SUITE_ADD_TEST(suite, iPrependST); 20295 SUITE_ADD_TEST(suite, iPrependCharST); 20296 SUITE_ADD_TEST(suite, iPrependNFreeST); 20297 SUITE_ADD_TEST(suite, bPrependST); 20298 SUITE_ADD_TEST(suite, bLPrependST); 20299 SUITE_ADD_TEST(suite, replaceST); 20300 SUITE_ADD_TEST(suite, replaceCharSST); 20301 SUITE_ADD_TEST(suite, replaceSCharST); 20302 SUITE_ADD_TEST(suite, replaceCharCharST); 20303 SUITE_ADD_TEST(suite, iReplaceST); 20304 SUITE_ADD_TEST(suite, iReplaceCharSST); 20305 SUITE_ADD_TEST(suite, iReplaceSCharST); 20306 SUITE_ADD_TEST(suite, iReplaceCharCharST); 20307 SUITE_ADD_TEST(suite, bReplaceST); 20308 SUITE_ADD_TEST(suite, bLReplaceST); 20309 SUITE_ADD_TEST(suite, icReplaceST); 20310 SUITE_ADD_TEST(suite, iicReplaceST); 20311 SUITE_ADD_TEST(suite, bicReplaceST); 20312 SUITE_ADD_TEST(suite, bLicReplaceST); 20313 SUITE_ADD_TEST(suite, replaceManyST); 20314 SUITE_ADD_TEST(suite, iReplaceManyST); 20315 SUITE_ADD_TEST(suite, bReplaceManyST); 20316 SUITE_ADD_TEST(suite, bLReplaceManyST); 20317 SUITE_ADD_TEST(suite, icReplaceManyST); 20318 SUITE_ADD_TEST(suite, iicReplaceManyST); 20319 SUITE_ADD_TEST(suite, bicReplaceManyST); 20320 SUITE_ADD_TEST(suite, bLicReplaceManyST); 20321 SUITE_ADD_TEST(suite, eqST); 20322 SUITE_ADD_TEST(suite, eqCharST); 20323 SUITE_ADD_TEST(suite, eqSCharT); 20324 SUITE_ADD_TEST(suite, eqIST); 20325 SUITE_ADD_TEST(suite, eqICharST); 20326 SUITE_ADD_TEST(suite, startsWithST); 20327 SUITE_ADD_TEST(suite, startsWithCharST); 20328 SUITE_ADD_TEST(suite, endsWithST); 20329 SUITE_ADD_TEST(suite, endsWithCharST); 20330 SUITE_ADD_TEST(suite, countST); 20331 SUITE_ADD_TEST(suite, countCharST); 20332 SUITE_ADD_TEST(suite, icEqST); 20333 SUITE_ADD_TEST(suite, icEqCharST); 20334 SUITE_ADD_TEST(suite, icEqSCharT); 20335 SUITE_ADD_TEST(suite, icEqIST); 20336 SUITE_ADD_TEST(suite, icEqICharST); 20337 SUITE_ADD_TEST(suite, icStartsWithST); 20338 SUITE_ADD_TEST(suite, icStartsWithCharST); 20339 SUITE_ADD_TEST(suite, icEndsWithST); 20340 SUITE_ADD_TEST(suite, icEndsWithCharST); 20341 SUITE_ADD_TEST(suite, icCountST); 20342 SUITE_ADD_TEST(suite, icCountCharST); 20343 SUITE_ADD_TEST(suite, hasCtrlCharT); 20344 SUITE_ADD_TEST(suite, stripCtrlST); 20345 SUITE_ADD_TEST(suite, iStripCtrlST); 20346 SUITE_ADD_TEST(suite, bStripCtrlST); 20347 SUITE_ADD_TEST(suite, quoteST); 20348 SUITE_ADD_TEST(suite, bQuoteST); 20349 SUITE_ADD_TEST(suite, bLQuoteST); 20350 SUITE_ADD_TEST(suite, quoteLenST); 20351 SUITE_ADD_TEST(suite, escapeST); 20352 SUITE_ADD_TEST(suite, bEscapeST); 20353 SUITE_ADD_TEST(suite, bLEscapeST); 20354 SUITE_ADD_TEST(suite, escapeLenST); 20355 SUITE_ADD_TEST(suite, nibbleToHexT); 20356 SUITE_ADD_TEST(suite, cEscapeST); 20357 SUITE_ADD_TEST(suite, bCEscapeST); 20358 SUITE_ADD_TEST(suite, bLCEscapeST); 20359 SUITE_ADD_TEST(suite, cEscapeLenST); 20360 SUITE_ADD_TEST(suite, isNumberT); 20361 SUITE_ADD_TEST(suite, isIntT); 20362 SUITE_ADD_TEST(suite, parseIntT); 20363 SUITE_ADD_TEST(suite, parseIntCharT); 20364 SUITE_ADD_TEST(suite, parseI64T); 20365 SUITE_ADD_TEST(suite, parseI64CharT); 20366 SUITE_ADD_TEST(suite, parseDoubleT); 20367 SUITE_ADD_TEST(suite, parseDoubleCharT); 20368 SUITE_ADD_TEST(suite, parseHexT); 20369 SUITE_ADD_TEST(suite, intToST); 20370 SUITE_ADD_TEST(suite, bIntToST); 20371 SUITE_ADD_TEST(suite, doubleToST); 20372 SUITE_ADD_TEST(suite, bDoubleToST); 20373 SUITE_ADD_TEST(suite, lenST); 20374 SUITE_ADD_TEST(suite, sizeST); 20375 SUITE_ADD_TEST(suite, upperST); 20376 SUITE_ADD_TEST(suite, iUpperST); 20377 SUITE_ADD_TEST(suite, bUpperST); 20378 SUITE_ADD_TEST(suite, lowerST); 20379 SUITE_ADD_TEST(suite, iLowerST); 20380 SUITE_ADD_TEST(suite, bLowerST); 20381 SUITE_ADD_TEST(suite, trimST); 20382 SUITE_ADD_TEST(suite, iTrimST); 20383 SUITE_ADD_TEST(suite, bTrimST); 20384 SUITE_ADD_TEST(suite, lTrimST); 20385 SUITE_ADD_TEST(suite, iLTrimST); 20386 SUITE_ADD_TEST(suite, bLTrimST); 20387 SUITE_ADD_TEST(suite, rTrimST); 20388 SUITE_ADD_TEST(suite, iRTrimST); 20389 SUITE_ADD_TEST(suite, bRTrimST); 20390 SUITE_ADD_TEST(suite, uniqST); 20391 SUITE_ADD_TEST(suite, iUniqST); 20392 SUITE_ADD_TEST(suite, bUniqST); 20393 SUITE_ADD_TEST(suite, icUniqST); 20394 SUITE_ADD_TEST(suite, iicUniqST); 20395 SUITE_ADD_TEST(suite, bicUniqST); 20396 SUITE_ADD_TEST(suite, repeatST); 20397 SUITE_ADD_TEST(suite, iRepeatST); 20398 SUITE_ADD_TEST(suite, bRepeatST); 20399 SUITE_ADD_TEST(suite, bLRepeatST); 20400 SUITE_ADD_TEST(suite, repeatCharST); 20401 SUITE_ADD_TEST(suite, bRepeatCharST); 20402 SUITE_ADD_TEST(suite, bLRepeatCharST); 20403 SUITE_ADD_TEST(suite, repeatLenST); 20404 SUITE_ADD_TEST(suite, ellipsisStartST); 20405 SUITE_ADD_TEST(suite, iEllipsisStartST); 20406 SUITE_ADD_TEST(suite, bEllipsisStartST); 20407 SUITE_ADD_TEST(suite, bLEllipsisStartST); 20408 SUITE_ADD_TEST(suite, ellipsisStartCharST); 20409 SUITE_ADD_TEST(suite, iEllipsisStartCharST); 20410 SUITE_ADD_TEST(suite, bEllipsisStartCharST); 20411 SUITE_ADD_TEST(suite, bLEllipsisStartCharST); 20412 SUITE_ADD_TEST(suite, ellipsisLenST); 20413 SUITE_ADD_TEST(suite, ellipsisEndST); 20414 SUITE_ADD_TEST(suite, iEllipsisEndST); 20415 SUITE_ADD_TEST(suite, bEllipsisEndST); 20416 SUITE_ADD_TEST(suite, bLEllipsisEndST); 20417 SUITE_ADD_TEST(suite, ellipsisEndCharST); 20418 SUITE_ADD_TEST(suite, iEllipsisEndCharST); 20419 SUITE_ADD_TEST(suite, bEllipsisEndCharST); 20420 SUITE_ADD_TEST(suite, bLEllipsisEndCharST); 20421 SUITE_ADD_TEST(suite, padStartST); 20422 SUITE_ADD_TEST(suite, iPadStartST); 20423 SUITE_ADD_TEST(suite, bPadStartST); 20424 SUITE_ADD_TEST(suite, bLPadStartST); 20425 SUITE_ADD_TEST(suite, padStartCharST); 20426 SUITE_ADD_TEST(suite, iPadStartCharST); 20427 SUITE_ADD_TEST(suite, bPadStartCharST); 20428 SUITE_ADD_TEST(suite, bLPadStartCharST); 20429 SUITE_ADD_TEST(suite, padStartLenST); 20430 SUITE_ADD_TEST(suite, padEndST); 20431 SUITE_ADD_TEST(suite, iPadEndST); 20432 SUITE_ADD_TEST(suite, bPadEndST); 20433 SUITE_ADD_TEST(suite, bLPadEndST); 20434 SUITE_ADD_TEST(suite, padEndCharST); 20435 SUITE_ADD_TEST(suite, iPadEndCharST); 20436 SUITE_ADD_TEST(suite, bPadEndCharST); 20437 SUITE_ADD_TEST(suite, bLPadEndCharST); 20438 SUITE_ADD_TEST(suite, padEndLenST); 20439 SUITE_ADD_TEST(suite, getST); 20440 SUITE_ADD_TEST(suite, setST); 20441 SUITE_ADD_TEST(suite, swapST); 20442 SUITE_ADD_TEST(suite, iSwapST); 20443 SUITE_ADD_TEST(suite, bSwapST); 20444 SUITE_ADD_TEST(suite, bLSwapST); 20445 SUITE_ADD_TEST(suite, sliceST); 20446 SUITE_ADD_TEST(suite, iSliceST); 20447 SUITE_ADD_TEST(suite, bSliceST); 20448 SUITE_ADD_TEST(suite, bLSliceST); 20449 SUITE_ADD_TEST(suite, cropST); 20450 SUITE_ADD_TEST(suite, iCropST); 20451 SUITE_ADD_TEST(suite, cropElemST); 20452 SUITE_ADD_TEST(suite, iCropElemST); 20453 SUITE_ADD_TEST(suite, insertST); 20454 SUITE_ADD_TEST(suite, insertNFreeST); 20455 SUITE_ADD_TEST(suite, iInsertST); 20456 SUITE_ADD_TEST(suite, iInsertNFreeST); 20457 SUITE_ADD_TEST(suite, bInsertST); 20458 SUITE_ADD_TEST(suite, bLInsertST); 20459 SUITE_ADD_TEST(suite, injectST); 20460 SUITE_ADD_TEST(suite, iInjectST); 20461 SUITE_ADD_TEST(suite, bInjectST); 20462 SUITE_ADD_TEST(suite, bLInjectST); 20463 SUITE_ADD_TEST(suite, delST); 20464 SUITE_ADD_TEST(suite, iDelST); 20465 SUITE_ADD_TEST(suite, bDelST); 20466 SUITE_ADD_TEST(suite, bLDelST); 20467 SUITE_ADD_TEST(suite, delElemST); 20468 SUITE_ADD_TEST(suite, iDelElemST); 20469 SUITE_ADD_TEST(suite, bDelElemST); 20470 SUITE_ADD_TEST(suite, bLDelElemST); 20471 SUITE_ADD_TEST(suite, findST); 20472 SUITE_ADD_TEST(suite, findCharST); 20473 SUITE_ADD_TEST(suite, indexOfST); 20474 SUITE_ADD_TEST(suite, indexOfCharST); 20475 SUITE_ADD_TEST(suite, hasST); 20476 SUITE_ADD_TEST(suite, hasCharST); 20477 SUITE_ADD_TEST(suite, icFindST); 20478 SUITE_ADD_TEST(suite, icFindCharST); 20479 SUITE_ADD_TEST(suite, icIndexOfST); 20480 SUITE_ADD_TEST(suite, icIndexOfCharST); 20481 SUITE_ADD_TEST(suite, icHasST); 20482 SUITE_ADD_TEST(suite, icHasCharST); 20483 SUITE_ADD_TEST(suite, tokST); 20484 SUITE_ADD_TEST(suite, icTokST); 20485 SUITE_ADD_TEST(suite, lenUTF8T); 20486 SUITE_ADD_TEST(suite, bLLenUTF8T); 20487 SUITE_ADD_TEST(suite, isUTF8T); 20488 SUITE_ADD_TEST(suite, bLIsUTF8T); 20489 SUITE_ADD_TEST(suite, isCodeUTF8T); 20490 SUITE_ADD_TEST(suite, nextUTF8T); 20491 SUITE_ADD_TEST(suite, bLNextUTF8T); 20492 SUITE_ADD_TEST(suite, findNextUTF8T); 20493 SUITE_ADD_TEST(suite, prevUTF8T); 20494 SUITE_ADD_TEST(suite, bPrevUTF8T); 20495 SUITE_ADD_TEST(suite, idx2PtrUTF8T); 20496 SUITE_ADD_TEST(suite, bLIdx2PtrUTF8T); 20497 SUITE_ADD_TEST(suite, ptr2IdxUTF8T); 20498 SUITE_ADD_TEST(suite, bPtr2IdxUTF8T); 20499 SUITE_ADD_TEST(suite, bLPtr2IdxUTF8T); 20500 SUITE_ADD_TEST(suite, bLPtr2NegIdxUTF8T); 20501 SUITE_ADD_TEST(suite, makeValidUTF8T); 20502 SUITE_ADD_TEST(suite, bMakeValidUTF8T); 20503 SUITE_ADD_TEST(suite, nMakeValidUTF8T); 20504 SUITE_ADD_TEST(suite, bNMakeValidUTF8T); 20505 SUITE_ADD_TEST(suite, bLMakeValidUTF8T); 20506 SUITE_ADD_TEST(suite, bLNMakeValidUTF8T); 20507 SUITE_ADD_TEST(suite, strNCpyUTF8T); 20508 SUITE_ADD_TEST(suite, strLCpyUTF8T); 20509 SUITE_ADD_TEST(suite, strNCatUTF8T); 20510 SUITE_ADD_TEST(suite, strLCatUTF8T); 20511 SUITE_ADD_TEST(suite, strLNCatUTF8T); 20512 SUITE_ADD_TEST(suite, eqIUTF8T); 20513 SUITE_ADD_TEST(suite, eqICharUTF8T); 20514 SUITE_ADD_TEST(suite, icEqUTF8T); 20515 SUITE_ADD_TEST(suite, icEqCharUTF8T); 20516 SUITE_ADD_TEST(suite, icEqUTF8CharT); 20517 SUITE_ADD_TEST(suite, icStartsWithUTF8T); 20518 SUITE_ADD_TEST(suite, icEndsWithUTF8T); 20519 SUITE_ADD_TEST(suite, icCountUTF8T); 20520 SUITE_ADD_TEST(suite, code2RuneUTF8T); 20521 SUITE_ADD_TEST(suite, code2RuneLUTF8T); 20522 SUITE_ADD_TEST(suite, bRune2CodeUTF8T); 20523 SUITE_ADD_TEST(suite, runeLenUTF8T); 20524 SUITE_ADD_TEST(suite, toupperUTF8T); 20525 SUITE_ADD_TEST(suite, upperUTF8T); 20526 SUITE_ADD_TEST(suite, iUpperUTF8T); 20527 SUITE_ADD_TEST(suite, tolowerUTF8T); 20528 SUITE_ADD_TEST(suite, lowerUTF8T); 20529 SUITE_ADD_TEST(suite, iLowerUTF8T); 20530 SUITE_ADD_TEST(suite, uniqUTF8T); 20531 SUITE_ADD_TEST(suite, iUniqUTF8T); 20532 SUITE_ADD_TEST(suite, bUniqUTF8T); 20533 SUITE_ADD_TEST(suite, getUTF8T); 20534 SUITE_ADD_TEST(suite, setUTF8T); 20535 SUITE_ADD_TEST(suite, sliceUTF8T); 20536 SUITE_ADD_TEST(suite, iSliceUTF8T); 20537 SUITE_ADD_TEST(suite, bSliceUTF8T); 20538 SUITE_ADD_TEST(suite, bLSliceUTF8T); 20539 SUITE_ADD_TEST(suite, insertUTF8T); 20540 SUITE_ADD_TEST(suite, insertNFreeUTF8T); 20541 SUITE_ADD_TEST(suite, iInsertUTF8T); 20542 SUITE_ADD_TEST(suite, iInsertNFreeUTF8T); 20543 SUITE_ADD_TEST(suite, bInsertUTF8T); 20544 SUITE_ADD_TEST(suite, bLInsertUTF8T); 20545 SUITE_ADD_TEST(suite, delUTF8T); 20546 SUITE_ADD_TEST(suite, iDelUTF8T); 20547 SUITE_ADD_TEST(suite, bDelUTF8T); 20548 SUITE_ADD_TEST(suite, bLDelUTF8T); 20549 SUITE_ADD_TEST(suite, indexOfUTF8T); 20550 SUITE_ADD_TEST(suite, icHasUTF8T); 20551 SUITE_ADD_TEST(suite, icListSortUTF8T); 20552 SUITE_ADD_TEST(suite, iicListSortUTF8T); 20553 SUITE_ADD_TEST(suite, icListEqUTF8T); 20554 SUITE_ADD_TEST(suite, icListHasUTF8T); 20555 SUITE_ADD_TEST(suite, icListIndexOfUTF8T); 20556 SUITE_ADD_TEST(suite, icListBinarySearchUTF8T); 20557 SUITE_ADD_TEST(suite, icListUniqUTF8T); 20558 SUITE_ADD_TEST(suite, iicListUniqUTF8T); 20559 SUITE_ADD_TEST(suite, emptySFT); 20560 SUITE_ADD_TEST(suite, iEmptySFT); 20561 SUITE_ADD_TEST(suite, isEmptyST); 20562 SUITE_ADD_TEST(suite, isBlankST); 20563 SUITE_ADD_TEST(suite, intIndexT); 20564 SUITE_ADD_TEST(suite, listEmptySFT); 20565 SUITE_ADD_TEST(suite, iListEmptySFT); 20566 SUITE_ADD_TEST(suite, listIsEmptyST); 20567 SUITE_ADD_TEST(suite, listIsBlankST); 20568 SUITE_ADD_TEST(suite, listLengthST); 20569 SUITE_ADD_TEST(suite, listStrLengthST); 20570 SUITE_ADD_TEST(suite, listIntIndexST); 20571 SUITE_ADD_TEST(suite, listAddrST); 20572 SUITE_ADD_TEST(suite, listCreateST); 20573 SUITE_ADD_TEST(suite, listFromArrayST); 20574 SUITE_ADD_TEST(suite, listPushST); 20575 SUITE_ADD_TEST(suite, listPushCharST); 20576 SUITE_ADD_TEST(suite, iListPushST); 20577 SUITE_ADD_TEST(suite, listPopST); 20578 SUITE_ADD_TEST(suite, listPrependST); 20579 SUITE_ADD_TEST(suite, listPrependCharST); 20580 SUITE_ADD_TEST(suite, iListPrependST); 20581 SUITE_ADD_TEST(suite, listDequeueST); 20582 SUITE_ADD_TEST(suite, listFreeST); 20583 SUITE_ADD_TEST(suite, listFreeManyST); 20584 SUITE_ADD_TEST(suite, listPrintST); 20585 SUITE_ADD_TEST(suite, listForEachT); 20586 SUITE_ADD_TEST(suite, listEnumerateT); 20587 SUITE_ADD_TEST(suite, listSortST); 20588 SUITE_ADD_TEST(suite, iListSortST); 20589 SUITE_ADD_TEST(suite, listSortFST); 20590 SUITE_ADD_TEST(suite, iListSortFST); 20591 SUITE_ADD_TEST(suite, icListSortST); 20592 SUITE_ADD_TEST(suite, iicListSortST); 20593 SUITE_ADD_TEST(suite, readTextT); 20594 SUITE_ADD_TEST(suite, readStreamT); 20595 SUITE_ADD_TEST(suite, writeTextT); 20596 SUITE_ADD_TEST(suite, writeStreamT); 20597 SUITE_ADD_TEST(suite, appendTextT); 20598 SUITE_ADD_TEST(suite, listGetST); 20599 SUITE_ADD_TEST(suite, iListGetST); 20600 SUITE_ADD_TEST(suite, listSetST); 20601 SUITE_ADD_TEST(suite, listSetCharST); 20602 SUITE_ADD_TEST(suite, iListSetST); 20603 SUITE_ADD_TEST(suite, listSwapST); 20604 SUITE_ADD_TEST(suite, iListSwapST); 20605 SUITE_ADD_TEST(suite, splitT); 20606 SUITE_ADD_TEST(suite, splitCharT); 20607 SUITE_ADD_TEST(suite, icSplitT); 20608 SUITE_ADD_TEST(suite, icSplitCharT); 20609 SUITE_ADD_TEST(suite, joinLengthT); 20610 SUITE_ADD_TEST(suite, joinT); 20611 SUITE_ADD_TEST(suite, joinCharT); 20612 SUITE_ADD_TEST(suite, bJoinT); 20613 SUITE_ADD_TEST(suite, bJoinCharT); 20614 SUITE_ADD_TEST(suite, bLJoinT); 20615 SUITE_ADD_TEST(suite, bLJoinCharT); 20616 SUITE_ADD_TEST(suite, extractST); 20617 SUITE_ADD_TEST(suite, extractCharSST); 20618 SUITE_ADD_TEST(suite, extractSCharST); 20619 SUITE_ADD_TEST(suite, extractCharCharST); 20620 SUITE_ADD_TEST(suite, icExtractST); 20621 SUITE_ADD_TEST(suite, icExtractCharSST); 20622 SUITE_ADD_TEST(suite, icExtractSCharST); 20623 SUITE_ADD_TEST(suite, icExtractCharCharST); 20624 SUITE_ADD_TEST(suite, listDupST); 20625 SUITE_ADD_TEST(suite, iListDupST); 20626 SUITE_ADD_TEST(suite, listReverseST); 20627 SUITE_ADD_TEST(suite, iListReverseST); 20628 SUITE_ADD_TEST(suite, listCatST); 20629 SUITE_ADD_TEST(suite, listAppendST); 20630 SUITE_ADD_TEST(suite, iListAppendST); 20631 SUITE_ADD_TEST(suite, iListAppendNSmashST); 20632 SUITE_ADD_TEST(suite, listShiftST); 20633 SUITE_ADD_TEST(suite, iListShiftST); 20634 SUITE_ADD_TEST(suite, iListShiftNSmashST); 20635 SUITE_ADD_TEST(suite, listAddST); 20636 SUITE_ADD_TEST(suite, listSliceST); 20637 SUITE_ADD_TEST(suite, iListCopyST); 20638 SUITE_ADD_TEST(suite, iListSliceST); 20639 SUITE_ADD_TEST(suite, listCropST); 20640 SUITE_ADD_TEST(suite, iListCropST); 20641 SUITE_ADD_TEST(suite, listCropElemST); 20642 SUITE_ADD_TEST(suite, iListCropElemST); 20643 SUITE_ADD_TEST(suite, listInsertST); 20644 SUITE_ADD_TEST(suite, iListInsertST); 20645 SUITE_ADD_TEST(suite, iListInsertNFreeST); 20646 SUITE_ADD_TEST(suite, listInjectST); 20647 SUITE_ADD_TEST(suite, listInjectCharST); 20648 SUITE_ADD_TEST(suite, iListInjectST); 20649 SUITE_ADD_TEST(suite, iListInjectCharST); 20650 SUITE_ADD_TEST(suite, listDelST); 20651 SUITE_ADD_TEST(suite, iListDelST); 20652 SUITE_ADD_TEST(suite, iListRemoveST); 20653 SUITE_ADD_TEST(suite, listDelElemST); 20654 SUITE_ADD_TEST(suite, iListDelElemST); 20655 SUITE_ADD_TEST(suite, iListRemoveElemST); 20656 SUITE_ADD_TEST(suite, execOutT); 20657 SUITE_ADD_TEST(suite, systemOutfT); 20658 SUITE_ADD_TEST(suite, systemfT); 20659 SUITE_ADD_TEST(suite, commandFT); 20660 SUITE_ADD_TEST(suite, commandfFT); 20661 SUITE_ADD_TEST(suite, commandNFreeFT); 20662 SUITE_ADD_TEST(suite, listEqST); 20663 SUITE_ADD_TEST(suite, listHasST); 20664 SUITE_ADD_TEST(suite, listHasCharST); 20665 SUITE_ADD_TEST(suite, listIndexOfST); 20666 SUITE_ADD_TEST(suite, listIndexOfCharST); 20667 SUITE_ADD_TEST(suite, listBinarySearchST); 20668 SUITE_ADD_TEST(suite, listBinarySearchCharST); 20669 SUITE_ADD_TEST(suite, listUniqST); 20670 SUITE_ADD_TEST(suite, iListUniqST); 20671 SUITE_ADD_TEST(suite, icListEqST); 20672 SUITE_ADD_TEST(suite, icListHasST); 20673 SUITE_ADD_TEST(suite, icListHasCharST); 20674 SUITE_ADD_TEST(suite, icListIndexOfST); 20675 SUITE_ADD_TEST(suite, icListIndexOfCharST); 20676 SUITE_ADD_TEST(suite, icListBinarySearchST); 20677 SUITE_ADD_TEST(suite, icListBinarySearchCharST); 20678 SUITE_ADD_TEST(suite, icListUniqST); 20679 SUITE_ADD_TEST(suite, iicListUniqST); 20680 SUITE_ADD_TEST(suite, listCompactST); 20681 SUITE_ADD_TEST(suite, iListCompactST); 20682 SUITE_ADD_TEST(suite, btraceEnableT); 20683 SUITE_ADD_TEST(suite, btraceT); 20684 SUITE_ADD_TEST(suite, listEmptyFT); 20685 SUITE_ADD_TEST(suite, iListEmptyFT); 20686 SUITE_ADD_TEST(suite, listIsEmptyT); 20687 SUITE_ADD_TEST(suite, listCreateT); 20688 SUITE_ADD_TEST(suite, listFromArrayT); 20689 SUITE_ADD_TEST(suite, listPushT); 20690 SUITE_ADD_TEST(suite, listPopT); 20691 SUITE_ADD_TEST(suite, listPrependT); 20692 SUITE_ADD_TEST(suite, listDequeueT); 20693 SUITE_ADD_TEST(suite, listFreeT); 20694 SUITE_ADD_TEST(suite, listFreeManyT); 20695 SUITE_ADD_TEST(suite, listLengthT); 20696 SUITE_ADD_TEST(suite, listGetT); 20697 SUITE_ADD_TEST(suite, listSetT); 20698 SUITE_ADD_TEST(suite, listDupT); 20699 SUITE_ADD_TEST(suite, listReverseT); 20700 SUITE_ADD_TEST(suite, iListReverseT); 20701 SUITE_ADD_TEST(suite, listCatT); 20702 SUITE_ADD_TEST(suite, listAppendT); 20703 SUITE_ADD_TEST(suite, listAddT); 20704 SUITE_ADD_TEST(suite, listSliceT); 20705 SUITE_ADD_TEST(suite, iListSliceT); 20706 SUITE_ADD_TEST(suite, listInsertT); 20707 SUITE_ADD_TEST(suite, iListInsertT); 20708 SUITE_ADD_TEST(suite, listDelT); 20709 SUITE_ADD_TEST(suite, iListDelT); 20710 SUITE_ADD_TEST(suite, ringInitT); 20711 SUITE_ADD_TEST(suite, ringEmptyT); 20712 SUITE_ADD_TEST(suite, ringIsEmptyT); 20713 SUITE_ADD_TEST(suite, ringIsFullT); 20714 SUITE_ADD_TEST(suite, ringCountT); 20715 SUITE_ADD_TEST(suite, ringPushT); 20716 SUITE_ADD_TEST(suite, ringPopT); 20717 SUITE_ADD_TEST(suite, ringPrependT); 20718 SUITE_ADD_TEST(suite, ringDequeueT); 20719 SUITE_ADD_TEST(suite, fiberAddT); 20720 SUITE_ADD_TEST(suite, fiberPrependT); 20721 SUITE_ADD_TEST(suite, schedulerT); 20722 SUITE_ADD_TEST(suite, getMonotonicTimeT); 20723 SUITE_ADD_TEST(suite, nanoSleepT); 20724 20725 20726 CuSuiteRun(suite); 20727 CuSuiteDetails(suite, output); 20728 printf ("%s\n", output->buffer); 20729 return suite->failCount; 20730 }