libsheepyCSmallBoolTest.c (43043B)
1 #include <stdlib.h> 2 #include <stdio.h> 3 #include <check.h> 4 5 //START MEM TEST ANCHOR 6 7 #include "../libsheepy.h" 8 #include "../libsheepyObject.h" 9 10 #ifdef __GNUC__ 11 #define UNUSED __attribute__ ((unused)) 12 #else 13 #define UNUSED 14 #endif 15 16 // TODO redirect stderr 17 18 19 START_TEST(initiateSmallBoolT) 20 21 smallBoolt self; 22 23 initiateSmallBool(&self); 24 ck_assert_str_eq(self.type, "smallBool"); 25 ck_assert_ptr_eq(self.value, null); 26 27 END_TEST 28 29 30 START_TEST(initiateAllocateSmallBoolT) 31 32 smallBoolt *self = NULL; 33 34 initiateAllocateSmallBool(&self); 35 ck_assert_str_eq(self->type, "smallBool"); 36 ck_assert_ptr_eq(self->value, null); 37 terminateO(self); 38 39 END_TEST 40 41 42 START_TEST(allocSmallBoolT) 43 44 smallBoolt* r; 45 46 r = allocSmallBool(true); 47 ck_assert_str_eq(r->type, "smallBool"); 48 ck_assert_ptr_ne(r->value, null); 49 char *s = toStringO(r); 50 ck_assert_str_eq(s, "true"); 51 free(s); 52 terminateO(r); 53 54 END_TEST 55 56 57 START_TEST(freeSmallBoolT) 58 59 smallBoolt *self = allocSmallBool(true); 60 61 freeO(self); 62 finishO(self); 63 64 END_TEST 65 66 67 START_TEST(terminateSmallBoolT) 68 69 smallBoolt *self = allocSmallBool(true); 70 terminateO(self); 71 ck_assert_ptr_eq(self, null); 72 73 END_TEST 74 75 76 START_TEST(toStringSmallBoolT) 77 78 smallBoolt *self = allocSmallBool(true); 79 80 char *s = toStringO(self); 81 ck_assert_str_eq(s, "true"); 82 free(s); 83 // empty smallBool 84 freeO(self); 85 s = toStringO(self); 86 ck_assert_ptr_eq(s, null); 87 terminateO(self); 88 89 END_TEST 90 91 92 START_TEST(duplicateSmallBoolT) 93 94 smallBoolt* r; 95 smallBoolt *self = allocSmallBool(true); 96 97 r = duplicateO(self); 98 char *s = toStringO(r); 99 terminateO(r); 100 ck_assert_str_eq(s, "true"); 101 free(s); 102 terminateO(self); 103 104 END_TEST 105 106 107 START_TEST(smashSmallBoolT) 108 109 smallBoolt *self = allocSmallBool(true); 110 sBoolt *v = self->value; 111 112 smashO(self); 113 ck_assert_ptr_eq(self, null); 114 free(v); 115 116 END_TEST 117 118 119 START_TEST(finishSmallBoolT) 120 121 smallBoolt *self = allocSmallBool(true); 122 123 freeO(self); 124 finishO(self); 125 ck_assert_ptr_eq(self, null); 126 127 END_TEST 128 129 130 START_TEST(getSmallBoolT) 131 132 bool r; 133 smallBoolt *self = allocSmallBool(true); 134 135 r = getValO(self); 136 ck_assert(r); 137 // empty smallBool 138 freeO(self); 139 r = getValO(self); 140 ck_assert(!r); 141 terminateO(self); 142 143 END_TEST 144 145 146 START_TEST(setSmallBoolT) 147 148 smallBoolt* r; 149 smallBoolt *self = allocSmallBool(false); 150 151 r = setValO(self, true); 152 ck_assert_ptr_ne(r, null); 153 char *s = toStringO(r); 154 ck_assert_str_eq(s, "true"); 155 free(s); 156 // empty smallBool 157 freeO(self); 158 r = setValO(self, true); 159 ck_assert_ptr_ne(r, null); 160 s = toStringO(r); 161 ck_assert_str_eq(s, "true"); 162 free(s); 163 terminateO(self); 164 165 END_TEST 166 167 168 START_TEST(setDoubleSmallBoolT) 169 170 smallBoolt* r; 171 smallBoolt* self = allocSmallBool(false); 172 173 r = self->f->setDouble(self, 10); 174 ck_assert_ptr_ne(r, null); 175 char *s = toStringO(r); 176 ck_assert_str_eq(s, "true"); 177 free(s); 178 // empty smallBool 179 freeO(self); 180 r = self->f->setDouble(self, 1); 181 ck_assert_ptr_ne(r, null); 182 s = toStringO(r); 183 ck_assert_str_eq(s, "true"); 184 free(s); 185 terminateO(self); 186 187 END_TEST 188 189 190 START_TEST(setInt64SmallBoolT) 191 192 smallBoolt* r; 193 smallBoolt* self = allocSmallBool(true); 194 195 r = setInt64O(self, 0); 196 ck_assert_ptr_ne(r, null); 197 char *s = toStringO(r); 198 ck_assert_str_eq(s, "false"); 199 free(s); 200 // empty smallBool 201 freeO(self); 202 r = setInt64O(self, 1); 203 ck_assert_ptr_ne(r, null); 204 s = toStringO(r); 205 ck_assert_str_eq(s, "true"); 206 free(s); 207 terminateO(self); 208 209 END_TEST 210 211 212 START_TEST(setInt32SmallBoolT) 213 214 smallBoolt* r; 215 smallBoolt* self = allocSmallBool(true); 216 217 r = setInt32O(self, 0); 218 ck_assert_ptr_ne(r, null); 219 char *s = toStringO(r); 220 ck_assert_str_eq(s, "false"); 221 free(s); 222 // empty smallBool 223 freeO(self); 224 r = setInt32O(self, 1); 225 ck_assert_ptr_ne(r, null); 226 s = toStringO(r); 227 ck_assert_str_eq(s, "true"); 228 free(s); 229 terminateO(self); 230 231 END_TEST 232 233 234 START_TEST(setUint32SmallBoolT) 235 236 smallBoolt* r; 237 smallBoolt* self = allocSmallBool(true); 238 239 r = setUint32O(self, 0); 240 ck_assert_ptr_ne(r, null); 241 char *s = toStringO(r); 242 ck_assert_str_eq(s, "false"); 243 free(s); 244 // empty smallBool 245 freeO(self); 246 r = setUint32O(self, 1); 247 ck_assert_ptr_ne(r, null); 248 s = toStringO(r); 249 ck_assert_str_eq(s, "true"); 250 free(s); 251 terminateO(self); 252 253 END_TEST 254 255 256 START_TEST(setUint64SmallBoolT) 257 258 smallBoolt* r; 259 smallBoolt* self = allocSmallBool(true); 260 261 r = setUint64O(self, 0); 262 ck_assert_ptr_ne(r, null); 263 char *s = toStringO(r); 264 ck_assert_str_eq(s, "false"); 265 free(s); 266 // empty smallBool 267 freeO(self); 268 r = setUint64O(self, 1); 269 ck_assert_ptr_ne(r, null); 270 s = toStringO(r); 271 ck_assert_str_eq(s, "true"); 272 free(s); 273 terminateO(self); 274 275 END_TEST 276 277 278 START_TEST(setSSmallBoolT) 279 280 smallBoolt* r; 281 smallBoolt* self = allocSmallBool(false); 282 283 r = self->f->setS(self, "true"); 284 ck_assert_ptr_ne(r, null); 285 char *s = toStringO(r); 286 ck_assert_str_eq(s, "true"); 287 free(s); 288 // empty smallBool 289 freeO(self); 290 r = self->f->setS(self, "TRUE"); 291 ck_assert_ptr_ne(r, null); 292 s = toStringO(r); 293 ck_assert_str_eq(s, "true"); 294 free(s); 295 // NULL parameter 296 r = self->f->setS(self, null); 297 ck_assert_ptr_eq(r, null); 298 terminateO(self); 299 300 END_TEST 301 302 303 START_TEST(setSmallBoolSmallBoolT) 304 305 smallBoolt* r; 306 smallBoolt* self = allocSmallBool(false); 307 smallBoolt* p2 = allocSmallBool(true); 308 309 r = self->f->setSmallBool(self, p2); 310 ck_assert_ptr_ne(r, null); 311 char *s = toStringO(r); 312 ck_assert_str_eq(s, "true"); 313 free(s); 314 // empty smallBool 315 freeO(self); 316 r = self->f->setSmallBool(self, p2); 317 terminateO(p2); 318 ck_assert_ptr_ne(r, null); 319 s = toStringO(r); 320 ck_assert_str_eq(s, "true"); 321 free(s); 322 // NULL parameter 323 r = self->f->setSmallBool(self, null); 324 ck_assert_ptr_eq(r, null); 325 terminateO(self); 326 327 END_TEST 328 329 330 START_TEST(setSmallDoubleSmallBoolT) 331 332 smallBoolt* r; 333 smallBoolt* self = allocSmallBool(true); 334 smallDoublet* p2 = allocSmallDouble(0); 335 336 r = self->f->setSmallDouble(self, p2); 337 ck_assert_ptr_ne(r, null); 338 char *s = toStringO(r); 339 ck_assert_str_eq(s, "false"); 340 free(s); 341 // empty smallBool 342 freeO(self); 343 r = self->f->setSmallDouble(self, p2); 344 terminateO(p2); 345 ck_assert_ptr_ne(r, null); 346 s = toStringO(r); 347 ck_assert_str_eq(s, "false"); 348 free(s); 349 // NULL parameter 350 r = self->f->setSmallDouble(self, null); 351 ck_assert_ptr_eq(r, null); 352 terminateO(self); 353 354 END_TEST 355 356 357 START_TEST(setSmallIntSmallBoolT) 358 359 smallBoolt* r; 360 smallBoolt* self = allocSmallBool(true); 361 smallIntt* p2 = allocSmallInt(0); 362 363 r = self->f->setSmallInt(self, p2); 364 ck_assert_ptr_ne(r, null); 365 char *s = toStringO(r); 366 ck_assert_str_eq(s, "false"); 367 free(s); 368 // empty smallBool 369 freeO(self); 370 r = self->f->setSmallInt(self, p2); 371 terminateO(p2); 372 ck_assert_ptr_ne(r, null); 373 s = toStringO(r); 374 ck_assert_str_eq(s, "false"); 375 free(s); 376 // NULL parameter 377 r = self->f->setSmallInt(self, null); 378 ck_assert_ptr_eq(r, null); 379 terminateO(self); 380 381 END_TEST 382 383 384 START_TEST(setSmallJsonSmallBoolT) 385 386 smallBoolt* r; 387 smallBoolt* self = allocSmallBool(true); 388 smallJsont* p2 = allocSmallJson(); 389 390 // empty json >> error 391 r = self->f->setSmallJson(self, p2); 392 ck_assert_ptr_eq(r, null); 393 // json bool 394 setTopBoolO(p2, true); 395 r = self->f->setSmallJson(self, p2); 396 terminateO(p2); 397 char *s = toStringO(r); 398 ck_assert_str_eq(s, "true"); 399 free(s); 400 // json double 401 p2 = allocSmallJson(); 402 setTopDoubleO(p2, 2); 403 r = self->f->setSmallJson(self, p2); 404 terminateO(p2); 405 s = toStringO(r); 406 ck_assert_str_eq(s, "true"); 407 free(s); 408 // json int 409 p2 = allocSmallJson(); 410 setTopIntO(p2, 2); 411 r = self->f->setSmallJson(self, p2); 412 terminateO(p2); 413 s = toStringO(r); 414 ck_assert_str_eq(s, "true"); 415 free(s); 416 // json string 417 p2 = allocSmallJson(); 418 setTopSO(p2, "false"); 419 r = self->f->setSmallJson(self, p2); 420 terminateO(p2); 421 s = toStringO(r); 422 ck_assert_str_eq(s, "false"); 423 free(s); 424 // NULL parameter 425 r = self->f->setSmallJson(self, null); 426 ck_assert_ptr_eq(r, null); 427 terminateO(self); 428 429 END_TEST 430 431 432 START_TEST(setSmallStringSmallBoolT) 433 434 smallBoolt* r; 435 smallBoolt* self = allocSmallBool(true); 436 smallStringt* p2 = allocSmallString(""); 437 438 r = self->f->setSmallString(self, p2); 439 ck_assert_ptr_ne(r, null); 440 char *s = toStringO(r); 441 ck_assert_str_eq(s, "false"); 442 free(s); 443 // empty smallBool 444 freeO(self); 445 r = self->f->setSmallString(self, p2); 446 terminateO(p2); 447 ck_assert_ptr_ne(r, null); 448 s = toStringO(r); 449 ck_assert_str_eq(s, "false"); 450 free(s); 451 // NULL parameter 452 r = self->f->setSmallString(self, null); 453 ck_assert_ptr_eq(r, null); 454 terminateO(self); 455 456 END_TEST 457 458 459 START_TEST(getPSmallBoolT) 460 461 bool* r; 462 smallBoolt *self = allocSmallBool(true); 463 464 r = self->f->getP(self); 465 ck_assert_ptr_ne(r, null); 466 ck_assert(*r); 467 // empty smallBool 468 freeO(self); 469 r = self->f->getP(self); 470 ck_assert_ptr_eq(r, null); 471 terminateO(self); 472 473 END_TEST 474 475 476 START_TEST(equalSmallBoolCharT) 477 478 bool r; 479 smallBoolt* self = allocSmallBool(true); 480 481 r = self->f->equalChar(self, "TRUE"); 482 ck_assert(r); 483 r = self->f->equalChar(self, "false"); 484 ck_assert(!r); 485 r = self->f->equalChar(self, "qwe"); 486 ck_assert(!r); 487 // NULL parameter 488 r = self->f->equalChar(self, null); 489 ck_assert(!r); 490 // empty smallBool 491 freeO(self); 492 r = self->f->equalChar(self, ""); 493 ck_assert(!r); 494 terminateO(self); 495 496 END_TEST 497 498 499 START_TEST(equalSmallBoolBaseT) 500 501 bool r; 502 smallBoolt* self = allocSmallBool(true); 503 baset* p2 = (baset*) allocSmallBool(true); 504 smallJsont* p3 = allocSmallJson(); 505 506 setTopBoolO(p3, false); 507 508 r = self->f->equalBase(self, p2); 509 terminateO(p2); 510 ck_assert(r); 511 r = self->f->equalBase(self, (baset*)p3); 512 terminateO(p3); 513 ck_assert(!r); 514 p2 = (baset*) allocSmallString("qwe"); 515 r = self->f->equalBase(self, p2); 516 terminateO(p2); 517 ck_assert(!r); 518 // NULL parameter 519 r = self->f->equalBase(self, null); 520 ck_assert(!r); 521 // empty smallBool 522 freeO(self); 523 r = self->f->equalBase(self, p2); 524 ck_assert(!r); 525 terminateO(self); 526 527 END_TEST 528 529 530 START_TEST(equalSmallBoolBoolT) 531 532 bool r; 533 smallBoolt* self = allocSmallBool(true); 534 535 r = self->f->equalBool(self, true); 536 ck_assert(r); 537 r = self->f->equalBool(self, false); 538 ck_assert(!r); 539 // empty smallBool 540 freeO(self); 541 r = self->f->equalBool(self, true); 542 ck_assert(!r); 543 terminateO(self); 544 545 END_TEST 546 547 548 START_TEST(equalSmallBoolDoubleT) 549 550 bool r; 551 smallBoolt* self = allocSmallBool(true); 552 553 r = self->f->equalDouble(self, 1); 554 ck_assert(r); 555 r = self->f->equalDouble(self, 2); 556 ck_assert(!r); 557 // empty smallBool 558 freeO(self); 559 r = self->f->equalDouble(self, 1); 560 ck_assert(!r); 561 terminateO(self); 562 563 END_TEST 564 565 566 START_TEST(equalSmallBoolInt64T) 567 568 bool r; 569 smallBoolt* self = allocSmallBool(true); 570 571 r = self->f->equalInt64(self, 1); 572 ck_assert(r); 573 r = self->f->equalInt64(self, 0); 574 ck_assert(!r); 575 // empty smallBool 576 freeO(self); 577 r = self->f->equalInt64(self, 2); 578 ck_assert(!r); 579 terminateO(self); 580 581 END_TEST 582 583 584 START_TEST(equalSmallBoolInt32T) 585 586 bool r; 587 smallBoolt* self = allocSmallBool(true); 588 589 r = self->f->equalInt32(self, 1); 590 ck_assert(r); 591 r = self->f->equalInt32(self, 0); 592 ck_assert(!r); 593 // empty smallBool 594 freeO(self); 595 r = self->f->equalInt32(self, 2); 596 ck_assert(!r); 597 terminateO(self); 598 599 END_TEST 600 601 602 START_TEST(equalSmallBoolUint32T) 603 604 bool r; 605 smallBoolt* self = allocSmallBool(true); 606 607 r = self->f->equalUint32(self, 1); 608 ck_assert(r); 609 r = self->f->equalUint32(self, 0); 610 ck_assert(!r); 611 // empty smallBool 612 freeO(self); 613 r = self->f->equalUint32(self, 2); 614 ck_assert(!r); 615 terminateO(self); 616 617 END_TEST 618 619 620 START_TEST(equalSmallBoolUint64T) 621 622 bool r; 623 smallBoolt* self = allocSmallBool(true); 624 625 r = self->f->equalUint64(self, 1); 626 ck_assert(r); 627 r = self->f->equalUint64(self, 0); 628 ck_assert(!r); 629 // empty smallBool 630 freeO(self); 631 r = self->f->equalUint64(self, 2); 632 ck_assert(!r); 633 terminateO(self); 634 635 END_TEST 636 637 638 START_TEST(equalSmallBoolT) 639 640 bool r; 641 smallBoolt* self = allocSmallBool(true); 642 smallBoolt* p2 = allocSmallBool(true); 643 644 r = self->f->equal(self, p2); 645 ck_assert(r); 646 setValO(p2, false); 647 r = self->f->equal(self, p2); 648 ck_assert(!r); 649 // empty p2 650 freeO(p2); 651 r = self->f->equal(self, p2); 652 ck_assert(!r); 653 // NULL parameter 654 r = self->f->equal(self, null); 655 ck_assert(!r); 656 // empty smallBool 657 freeO(self); 658 r = self->f->equal(self, p2); 659 ck_assert(!r); 660 terminateO(p2); 661 terminateO(self); 662 663 END_TEST 664 665 666 START_TEST(equalSmallBoolSmallBytesT) 667 668 bool r; 669 smallBoolt* self = allocSmallBool(true); 670 smallBytest* p2 = allocSmallBytes("true", sizeof("true")); 671 672 r = self->f->equalSmallBytes(self, p2); 673 ck_assert(r); 674 p2->f->set(p2, "false", sizeof("false")); 675 r = self->f->equalSmallBytes(self, p2); 676 ck_assert(!r); 677 p2->f->set(p2, "qwe", sizeof("qwe")); 678 r = self->f->equalSmallBytes(self, p2); 679 ck_assert(!r); 680 // empty p2 681 freeO(p2); 682 r = self->f->equalSmallBytes(self, p2); 683 ck_assert(!r); 684 // NULL parameter 685 r = self->f->equalSmallBytes(self, null); 686 ck_assert(!r); 687 // empty smallBool 688 freeO(self); 689 r = self->f->equalSmallBytes(self, p2); 690 ck_assert(!r); 691 terminateO(p2); 692 terminateO(self); 693 694 END_TEST 695 696 697 START_TEST(equalSmallBoolSmallDoubleT) 698 699 bool r; 700 smallBoolt* self = allocSmallBool(true); 701 smallDoublet* p2 = allocSmallDouble(1); 702 703 r = self->f->equalSmallDouble(self, p2); 704 ck_assert(r); 705 setValO(p2, 1.5); 706 r = self->f->equalSmallDouble(self, p2); 707 ck_assert(!r); 708 // empty p2 709 freeO(p2); 710 r = self->f->equalSmallDouble(self, p2); 711 ck_assert(!r); 712 // NULL parameter 713 r = self->f->equalSmallDouble(self, null); 714 ck_assert(!r); 715 // empty smallBool 716 freeO(self); 717 r = self->f->equalSmallDouble(self, p2); 718 ck_assert(!r); 719 terminateO(p2); 720 terminateO(self); 721 722 END_TEST 723 724 725 START_TEST(equalSmallBoolSmallIntT) 726 727 bool r; 728 smallBoolt* self = allocSmallBool(true); 729 smallIntt* p2 = allocSmallInt(1); 730 731 r = self->f->equalSmallInt(self, p2); 732 ck_assert(r); 733 setValO(p2, 2); 734 r = self->f->equalSmallInt(self, p2); 735 ck_assert(!r); 736 // empty p2 737 freeO(p2); 738 r = self->f->equalSmallInt(self, p2); 739 ck_assert(!r); 740 // NULL parameter 741 r = self->f->equalSmallInt(self, null); 742 ck_assert(!r); 743 // empty smallBool 744 freeO(self); 745 r = self->f->equalSmallInt(self, p2); 746 ck_assert(!r); 747 terminateO(p2); 748 terminateO(self); 749 750 END_TEST 751 752 753 START_TEST(equalSmallBoolSmallJsonT) 754 755 bool r; 756 smallBoolt* self = allocSmallBool(true); 757 smallJsont* p2 = allocSmallJson(); 758 759 r = self->f->equalSmallJson(self, p2); 760 ck_assert(!r); 761 // non json paramenter 762 terminateO(p2); 763 p2 = (smallJsont*) allocSmallBool(true); 764 r = self->f->equalSmallJson(self, p2); 765 terminateO(p2); 766 ck_assert(!r); 767 // NULL parameter 768 r = self->f->equalSmallJson(self, null); 769 ck_assert(!r); 770 terminateO(self); 771 772 END_TEST 773 774 775 START_TEST(equalSmallBoolSmallStringT) 776 777 bool r; 778 smallBoolt* self = allocSmallBool(true); 779 smallStringt* p2 = allocSmallString("true"); 780 781 r = self->f->equalSmallString(self, p2); 782 ck_assert(r); 783 setValO(p2, "false"); 784 r = self->f->equalSmallString(self, p2); 785 ck_assert(!r); 786 setValO(p2, "qwe"); 787 r = self->f->equalSmallString(self, p2); 788 ck_assert(!r); 789 // empty p2 790 freeO(p2); 791 r = self->f->equalSmallString(self, p2); 792 ck_assert(!r); 793 // NULL parameter 794 r = self->f->equalSmallString(self, null); 795 ck_assert(!r); 796 // empty smallBool 797 freeO(self); 798 r = self->f->equalSmallString(self, p2); 799 ck_assert(!r); 800 terminateO(p2); 801 terminateO(self); 802 803 END_TEST 804 805 806 START_TEST(readFileSmallBoolT) 807 808 smallBoolt* r; 809 smallBoolt *self = allocSmallBool(true); 810 const char *filePath = "smallBool.bin"; 811 812 writeFileO(self, filePath); 813 setValO(self, false); 814 r = readFileO(self, filePath); 815 ck_assert_ptr_ne(r, null); 816 char *s = toStringO(r); 817 ck_assert_str_eq(s, "true"); 818 free(s); 819 // empty smallBool 820 freeO(self); 821 r = readFileO(self, filePath); 822 ck_assert_ptr_ne(r, null); 823 s = toStringO(r); 824 ck_assert_str_eq(s, "true"); 825 free(s); 826 rmAll(filePath); 827 // non existing file 828 r = readFileO(self, "nonexistingfile"); 829 ck_assert_ptr_eq(r, null); 830 // non bool file 831 FILE *f = fopen("empty.file", "w"); 832 fclose(f); 833 r = readFileO(self, "empty.file"); 834 rmAll("empty.file"); 835 ck_assert_ptr_eq(r, null); 836 // blank file path 837 r = readFileO(self, " "); 838 ck_assert_ptr_eq(r, null); 839 terminateO(self); 840 841 END_TEST 842 843 844 START_TEST(readFileSmallJsonSmallBoolT) 845 846 smallBoolt* r; 847 smallBoolt *self = allocSmallBool(true); 848 smallJsont *filePath = allocSmallJson(); 849 setTopSO(filePath, "smallBool.bin"); 850 851 writeFileO(self, sjGet(filePath)); 852 setValO(self, false); 853 r = self->f->readFileSmallJson(self, filePath); 854 ck_assert_ptr_ne(r, null); 855 char *s = toStringO(r); 856 ck_assert_str_eq(s, "true"); 857 free(s); 858 // empty smallBool 859 freeO(self); 860 r = self->f->readFileSmallJson(self, filePath); 861 ck_assert_ptr_ne(r, null); 862 s = toStringO(r); 863 ck_assert_str_eq(s, "true"); 864 free(s); 865 rmAll(sjGet(filePath)); 866 // non existing file 867 freeO(filePath); 868 setTopSO(filePath, "nonexistingfile"); 869 r = self->f->readFileSmallJson(self, filePath); 870 ck_assert_ptr_eq(r, null); 871 // non bool file 872 FILE *f = fopen("empty.file", "w"); 873 fclose(f); 874 freeO(filePath); 875 setTopSO(filePath, "empty.file"); 876 r = self->f->readFileSmallJson(self, filePath); 877 rmAll("empty.file"); 878 ck_assert_ptr_eq(r, null); 879 // blank file path 880 freeO(filePath); 881 setTopSO(filePath, " "); 882 r = self->f->readFileSmallJson(self, filePath); 883 ck_assert_ptr_eq(r, null); 884 // non string json 885 freeO(filePath); 886 setTopIntO(filePath, 101); 887 r = self->f->readFileSmallJson(self, filePath); 888 ck_assert_ptr_eq(r, null); 889 terminateO(filePath); 890 // non smallJson object 891 filePath = (smallJsont*)allocSmallBool(true); 892 r = self->f->readFileSmallJson(self, filePath); 893 ck_assert_ptr_eq(r, null); 894 // NULL path 895 r = self->f->readFileSmallJson(self, null); 896 ck_assert_ptr_eq(r, null); 897 terminateO(filePath); 898 terminateO(self); 899 900 END_TEST 901 902 903 START_TEST(readFileSmallStringSmallBoolT) 904 905 smallBoolt* r; 906 smallBoolt *self = allocSmallBool(true); 907 smallStringt *filePath = allocSmallString("smallBool.bin"); 908 909 writeFileO(self, ssGet(filePath)); 910 setValO(self, false); 911 r = self->f->readFileSmallString(self, filePath); 912 ck_assert_ptr_ne(r, null); 913 char *s = toStringO(r); 914 ck_assert_str_eq(s, "true"); 915 free(s); 916 // empty smallBool 917 freeO(self); 918 r = self->f->readFileSmallString(self, filePath); 919 ck_assert_ptr_ne(r, null); 920 s = toStringO(r); 921 ck_assert_str_eq(s, "true"); 922 free(s); 923 rmAll(ssGet(filePath)); 924 // non existing file 925 setValO(filePath, "nonexistingfile"); 926 r = self->f->readFileSmallString(self, filePath); 927 ck_assert_ptr_eq(r, null); 928 // non bool file 929 FILE *f = fopen("empty.file", "w"); 930 fclose(f); 931 setValO(filePath, "empty.file"); 932 r = self->f->readFileSmallString(self, filePath); 933 rmAll("empty.file"); 934 ck_assert_ptr_eq(r, null); 935 // blank file path 936 setValO(filePath, " "); 937 r = self->f->readFileSmallString(self, filePath); 938 ck_assert_ptr_eq(r, null); 939 terminateO(filePath); 940 // non smallString object 941 filePath = (smallStringt*)allocSmallBool(true); 942 r = self->f->readFileSmallString(self, filePath); 943 ck_assert_ptr_eq(r, null); 944 // NULL path 945 r = self->f->readFileSmallString(self, null); 946 ck_assert_ptr_eq(r, null); 947 terminateO(filePath); 948 terminateO(self); 949 950 END_TEST 951 952 953 START_TEST(readStreamSmallBoolT) 954 955 smallBoolt* r; 956 smallBoolt *self = allocSmallBool(true); 957 FILE *fp; 958 const char *filePath = "smallBool.bin"; 959 960 writeFileO(self, filePath); 961 setValO(self, false); 962 fp = fopen("smallBool.bin", "r"); 963 r = readStreamO(self, fp); 964 ck_assert_ptr_ne(r, null); 965 fclose(fp); 966 char *s = toStringO(r); 967 ck_assert_str_eq(s, "true"); 968 free(s); 969 // empty smallBool 970 freeO(self); 971 fp = fopen("smallBool.bin", "r"); 972 r = readStreamO(self, fp); 973 ck_assert_ptr_ne(r, null); 974 fclose(fp); 975 s = toStringO(r); 976 ck_assert_str_eq(s, "true"); 977 free(s); 978 rmAll(filePath); 979 // non existing file 980 r = readStreamO(self, null); 981 ck_assert_ptr_eq(r, null); 982 // non bool file 983 FILE *f = fopen("empty.file", "w"); 984 fclose(f); 985 fp = fopen("empty.file", "r"); 986 r = readStreamO(self, fp); 987 rmAll("empty.file"); 988 ck_assert_ptr_eq(r, null); 989 fclose(fp); 990 terminateO(self); 991 992 END_TEST 993 994 995 START_TEST(writeFileSmallBoolT) 996 997 int r; 998 smallBoolt *self = allocSmallBool(true); 999 const char *filePath = "smallBool.bin"; 1000 1001 r = writeFileO(self, filePath); 1002 ck_assert_int_eq(r, 1); 1003 freeO(self); 1004 smallBoolt *r2 = readFileO(self, filePath); 1005 ck_assert_ptr_ne(r2, null); 1006 char *s = toStringO(r2); 1007 ck_assert_str_eq(s, "true"); 1008 free(s); 1009 // non writable path 1010 r = writeFileO(self, "/nonexisting/readonly"); 1011 ck_assert_int_eq(r, 0); 1012 // blank path 1013 r = writeFileO(self, " "); 1014 ck_assert_int_eq(r, 0); 1015 // null path 1016 r = writeFileO(self, null); 1017 ck_assert_int_eq(r, 0); 1018 // empty smallBool 1019 freeO(self); 1020 r = writeFileO(self, filePath); 1021 ck_assert_int_eq(r, 0); 1022 terminateO(self); 1023 rmAll("smallBool.bin"); 1024 1025 END_TEST 1026 1027 1028 START_TEST(writeFileSmallJsonSmallBoolT) 1029 1030 int r; 1031 smallBoolt *self = allocSmallBool(true); 1032 smallJsont *filePath = allocSmallJson(); 1033 setTopSO(filePath, "smallBool.bin"); 1034 1035 r = self->f->writeFileSmallJson(self, filePath); 1036 ck_assert_int_eq(r, 1); 1037 freeO(self); 1038 smallBoolt *r2 = readFileO(self, sjGet(filePath)); 1039 ck_assert_ptr_ne(r2, null); 1040 char *s = toStringO(r2); 1041 ck_assert_str_eq(s, "true"); 1042 free(s); 1043 // non writable path 1044 freeO(filePath); 1045 setTopSO(filePath, "/nonexistingfile/readonly"); 1046 r = self->f->writeFileSmallJson(self, filePath); 1047 ck_assert_int_eq(r, 0); 1048 // blank path 1049 freeO(filePath); 1050 setTopSO(filePath, " "); 1051 r = self->f->writeFileSmallJson(self, filePath); 1052 ck_assert_int_eq(r, 0); 1053 // null path 1054 r = self->f->writeFileSmallJson(self, null); 1055 ck_assert_int_eq(r, 0); 1056 // empty smallBool 1057 freeO(self); 1058 freeO(filePath); 1059 setTopSO(filePath, "smallBool.bin"); 1060 r = self->f->writeFileSmallJson(self, filePath); 1061 ck_assert_int_eq(r, 0); 1062 // non string json 1063 freeO(filePath); 1064 setTopIntO(filePath, 101); 1065 r = self->f->writeFileSmallJson(self, filePath); 1066 ck_assert_int_eq(r, 0); 1067 terminateO(filePath); 1068 // non smallJson object 1069 filePath = (smallJsont*)allocSmallBool(true); 1070 r = self->f->writeFileSmallJson(self, filePath); 1071 ck_assert_int_eq(r, 0); 1072 terminateO(filePath); 1073 terminateO(self); 1074 rmAll("smallBool.bin"); 1075 1076 END_TEST 1077 1078 1079 START_TEST(writeFileSmallStringSmallBoolT) 1080 1081 int r; 1082 smallBoolt *self = allocSmallBool(true); 1083 smallStringt *filePath = allocSmallString("smallBool.bin"); 1084 1085 r = self->f->writeFileSmallString(self, filePath); 1086 ck_assert_int_eq(r, 1); 1087 freeO(self); 1088 smallBoolt *r2 = readFileO(self, ssGet(filePath)); 1089 ck_assert_ptr_ne(r2, null); 1090 char *s = toStringO(r2); 1091 ck_assert_str_eq(s, "true"); 1092 free(s); 1093 // non writable path 1094 setValO(filePath, "/nonexistingfile/readonly"); 1095 r = self->f->writeFileSmallString(self, filePath); 1096 ck_assert_int_eq(r, 0); 1097 // blank path 1098 setValO(filePath, " "); 1099 r = self->f->writeFileSmallString(self, filePath); 1100 ck_assert_int_eq(r, 0); 1101 // null path 1102 r = self->f->writeFileSmallString(self, null); 1103 ck_assert_int_eq(r, 0); 1104 // empty smallBool 1105 freeO(self); 1106 setValO(filePath, "smallBool.bin"); 1107 r = self->f->writeFileSmallString(self, filePath); 1108 ck_assert_int_eq(r, 0); 1109 terminateO(filePath); 1110 // non smallString object 1111 filePath = (smallStringt*)allocSmallBool(true); 1112 r = self->f->writeFileSmallString(self, filePath); 1113 ck_assert_int_eq(r, 0); 1114 terminateO(filePath); 1115 terminateO(self); 1116 rmAll("smallBool.bin"); 1117 1118 END_TEST 1119 1120 1121 START_TEST(writeStreamSmallBoolT) 1122 1123 int r; 1124 smallBoolt *self = allocSmallBool(true); 1125 FILE *fp; 1126 const char *filePath = "smallBool.bin"; 1127 1128 fp = fopen("smallBool.bin", "w"); 1129 r = writeStreamO(self, fp); 1130 ck_assert_int_eq(r, 1); 1131 fclose(fp); 1132 freeO(self); 1133 smallBoolt *r2 = readFileO(self, filePath); 1134 ck_assert_ptr_ne(r2, null); 1135 char *s = toStringO(r2); 1136 ck_assert_str_eq(s, "true"); 1137 free(s); 1138 // null file 1139 r = writeStreamO(self, null); 1140 ck_assert_int_eq(r, 0); 1141 // empty smallBool 1142 freeO(self); 1143 fp = fopen("smallBool.bin", "w"); 1144 r = writeStreamO(self, fp); 1145 ck_assert_int_eq(r, 0); 1146 fclose(fp); 1147 terminateO(self); 1148 rmAll("smallBool.bin"); 1149 1150 END_TEST 1151 1152 1153 START_TEST(appendFileSmallBoolT) 1154 1155 int r; 1156 smallBoolt *self = allocSmallBool(true); 1157 const char *filePath = "smallBool.bin"; 1158 1159 FILE *f = fopen(filePath, "w"); 1160 fclose(f); 1161 r = appendFileO(self, filePath); 1162 ck_assert_int_eq(r, 1); 1163 freeO(self); 1164 smallBoolt *r2 = readFileO(self, filePath); 1165 ck_assert_ptr_ne(r2, null); 1166 char *s = toStringO(r2); 1167 ck_assert_str_eq(s, "true"); 1168 free(s); 1169 // non existing file 1170 r = appendFileO(self, "/nonexisting/readonly"); 1171 ck_assert_int_eq(r, 0); 1172 // blank path 1173 r = appendFileO(self, " "); 1174 ck_assert_int_eq(r, 0); 1175 // null path 1176 r = appendFileO(self, null); 1177 ck_assert_int_eq(r, 0); 1178 // empty smallBool 1179 freeO(self); 1180 r = appendFileO(self, filePath); 1181 ck_assert_int_eq(r, 0); 1182 terminateO(self); 1183 rmAll("smallBool.bin"); 1184 1185 END_TEST 1186 1187 1188 START_TEST(appendFileSmallStringSmallBoolT) 1189 1190 int r; 1191 smallBoolt *self = allocSmallBool(true); 1192 smallStringt *filePath = allocSmallString("smallBool.bin"); 1193 1194 FILE *f = fopen(ssGet(filePath), "w"); 1195 fclose(f); 1196 r = appendFileSmallStringO(self, filePath); 1197 ck_assert_int_eq(r, 1); 1198 freeO(self); 1199 smallBoolt *r2 = readFileO(self, ssGet(filePath)); 1200 ck_assert_ptr_ne(r2, null); 1201 char *s = toStringO(r2); 1202 ck_assert_str_eq(s, "true"); 1203 free(s); 1204 // non existing file 1205 setValO(filePath, "/nonexisting/readonly"); 1206 r = appendFileSmallStringO(self, filePath); 1207 ck_assert_int_eq(r, 0); 1208 // blank path 1209 setValO(filePath, " "); 1210 r = appendFileSmallStringO(self, filePath); 1211 ck_assert_int_eq(r, 0); 1212 // null path 1213 r = appendFileSmallStringO(self, null); 1214 ck_assert_int_eq(r, 0); 1215 // empty smallBool 1216 freeO(self); 1217 setValO(filePath, "smallBool.bin"); 1218 r = appendFileSmallStringO(self, filePath); 1219 ck_assert_int_eq(r, 0); 1220 terminateO(filePath); 1221 terminateO(self); 1222 rmAll("smallBool.bin"); 1223 1224 END_TEST 1225 1226 1227 START_TEST(duplicateSmallBoolGT) 1228 1229 smallBoolt* r; 1230 smallBoolt *self = allocSmallBool(true); 1231 1232 r = duplicateSmallBoolG(self); 1233 char *s = toStringO(r); 1234 ck_assert_str_eq(s, "true"); 1235 free(s); 1236 terminateO(r); 1237 terminateO(self); 1238 1239 END_TEST 1240 1241 1242 START_TEST(freeSmallBoolGT) 1243 1244 smallBoolt *self = allocSmallBool(true); 1245 1246 freeSmallBoolG(self); 1247 char *s = toStringO(self); 1248 ck_assert_ptr_eq(s, null); 1249 terminateO(self); 1250 1251 END_TEST 1252 1253 1254 START_TEST(getBoolSmallBoolGT) 1255 1256 bool r; 1257 smallBoolt *self = allocSmallBool(true); 1258 1259 r = getBoolSmallBoolG(self, false, 0); 1260 ck_assert(r); 1261 terminateO(self); 1262 1263 END_TEST 1264 1265 1266 START_TEST(getBoolPSmallBoolGT) 1267 1268 bool* r; 1269 smallBoolt *self = allocSmallBool(true); 1270 bool retType = on; 1271 1272 r = getBoolPSmallBoolG(self, &retType, 10); 1273 ck_assert_ptr_ne(r, null); 1274 ck_assert(*r); 1275 terminateO(self); 1276 1277 END_TEST 1278 1279 1280 START_TEST(setSmallBoolGT) 1281 1282 smallBoolt* r; 1283 smallBoolt* self = allocSmallBool(true); 1284 1285 r = setSmallBoolG(self, false); 1286 ck_assert_ptr_ne(r, null); 1287 char *s = toStringO(r); 1288 ck_assert_str_eq(s, "false"); 1289 free(s); 1290 terminateO(self); 1291 1292 END_TEST 1293 1294 1295 START_TEST(setDoubleSmallBoolGT) 1296 1297 smallBoolt* r; 1298 smallBoolt* self = allocSmallBool(true); 1299 1300 r = setDoubleSmallBoolG(self, 0); 1301 ck_assert_ptr_ne(r, null); 1302 char *s = toStringO(r); 1303 ck_assert_str_eq(s, "false"); 1304 free(s); 1305 terminateO(self); 1306 1307 END_TEST 1308 1309 1310 START_TEST(setInt64SmallBoolGT) 1311 1312 smallBoolt* r; 1313 smallBoolt* self = allocSmallBool(true); 1314 1315 r = setInt64SmallBoolG(self, 0); 1316 ck_assert_ptr_ne(r, null); 1317 char *s = toStringO(r); 1318 ck_assert_str_eq(s, "false"); 1319 free(s); 1320 terminateO(self); 1321 1322 END_TEST 1323 1324 1325 START_TEST(setInt32SmallBoolGT) 1326 1327 smallBoolt* r; 1328 smallBoolt* self = allocSmallBool(true); 1329 1330 r = setInt32SmallBoolG(self, 0); 1331 ck_assert_ptr_ne(r, null); 1332 char *s = toStringO(r); 1333 ck_assert_str_eq(s, "false"); 1334 free(s); 1335 terminateO(self); 1336 1337 END_TEST 1338 1339 1340 START_TEST(setUint32SmallBoolGT) 1341 1342 smallBoolt* r; 1343 smallBoolt* self = allocSmallBool(true); 1344 1345 r = setUint32SmallBoolG(self, 0); 1346 ck_assert_ptr_ne(r, null); 1347 char *s = toStringO(r); 1348 ck_assert_str_eq(s, "false"); 1349 free(s); 1350 terminateO(self); 1351 1352 END_TEST 1353 1354 1355 START_TEST(setUint64SmallBoolGT) 1356 1357 smallBoolt* r; 1358 smallBoolt* self = allocSmallBool(true); 1359 1360 r = setUint64SmallBoolG(self, 0); 1361 ck_assert_ptr_ne(r, null); 1362 char *s = toStringO(r); 1363 ck_assert_str_eq(s, "false"); 1364 free(s); 1365 terminateO(self); 1366 1367 END_TEST 1368 1369 1370 START_TEST(setSSmallBoolGT) 1371 1372 smallBoolt* r; 1373 smallBoolt* self = allocSmallBool(true); 1374 1375 r = setSSmallBoolG(self, "false"); 1376 ck_assert_ptr_ne(r, null); 1377 char *s = toStringO(r); 1378 ck_assert_str_eq(s, "false"); 1379 free(s); 1380 terminateO(self); 1381 1382 END_TEST 1383 1384 1385 START_TEST(setSmallBoolSmallBoolGT) 1386 1387 smallBoolt* r; 1388 smallBoolt* self = allocSmallBool(true); 1389 smallBoolt* p2 = allocSmallBool(false); 1390 1391 r = setSmallBoolSmallBoolG(self, p2); 1392 ck_assert_ptr_ne(r, null); 1393 terminateO(p2); 1394 char *s = toStringO(r); 1395 ck_assert_str_eq(s, "false"); 1396 free(s); 1397 terminateO(self); 1398 1399 END_TEST 1400 1401 1402 START_TEST(setSmallDoubleSmallBoolGT) 1403 1404 smallBoolt* r; 1405 smallBoolt* self = allocSmallBool(true); 1406 smallDoublet* p2 = allocSmallDouble(0); 1407 1408 r = setSmallDoubleSmallBoolG(self, p2); 1409 ck_assert_ptr_ne(r, null); 1410 terminateO(p2); 1411 char *s = toStringO(r); 1412 ck_assert_str_eq(s, "false"); 1413 free(s); 1414 terminateO(self); 1415 1416 END_TEST 1417 1418 1419 START_TEST(setSmallIntSmallBoolGT) 1420 1421 smallBoolt* r; 1422 smallBoolt* self = allocSmallBool(true); 1423 smallIntt* p2 = allocSmallInt(0); 1424 1425 r = setSmallIntSmallBoolG(self, p2); 1426 ck_assert_ptr_ne(r, null); 1427 terminateO(p2); 1428 char *s = toStringO(r); 1429 ck_assert_str_eq(s, "false"); 1430 free(s); 1431 terminateO(self); 1432 1433 END_TEST 1434 1435 1436 START_TEST(setSmallJsonSmallBoolGT) 1437 1438 smallBoolt* r; 1439 smallBoolt* self = allocSmallBool(true); 1440 smallJsont* p2 = allocSmallJson(); 1441 1442 setTopBoolO(p2, false); 1443 r = setSmallJsonSmallBoolG(self, p2); 1444 ck_assert_ptr_ne(r, null); 1445 terminateO(p2); 1446 char *s = toStringO(r); 1447 ck_assert_str_eq(s, "false"); 1448 free(s); 1449 terminateO(self); 1450 1451 END_TEST 1452 1453 1454 START_TEST(setSmallStringSmallBoolGT) 1455 1456 smallBoolt* r; 1457 smallBoolt* self = allocSmallBool(true); 1458 smallStringt* p2 = allocSmallString("FALSE"); 1459 1460 r = setSmallStringSmallBoolG(self, p2); 1461 ck_assert_ptr_ne(r, null); 1462 terminateO(p2); 1463 char *s = toStringO(r); 1464 ck_assert_str_eq(s, "false"); 1465 free(s); 1466 terminateO(self); 1467 1468 END_TEST 1469 1470 1471 START_TEST(equalSmallBoolCharGT) 1472 1473 bool r; 1474 smallBoolt* self = allocSmallBool(true); 1475 1476 r = equalSmallBoolCharG(self, "true"); 1477 ck_assert(r); 1478 terminateO(self); 1479 1480 END_TEST 1481 1482 1483 START_TEST(equalSmallBoolBaseGT) 1484 1485 bool r; 1486 smallBoolt* self = allocSmallBool(true); 1487 baset* p2 = (baset*) allocSmallInt(1); 1488 1489 r = equalSmallBoolBaseG(self,p2); 1490 terminateO(p2); 1491 ck_assert(!r); 1492 terminateO(self); 1493 1494 END_TEST 1495 1496 1497 START_TEST(equalSmallBoolBoolGT) 1498 1499 bool r; 1500 smallBoolt* self = allocSmallBool(true); 1501 1502 r = equalSmallBoolBoolG(self, true); 1503 ck_assert(r); 1504 terminateO(self); 1505 1506 END_TEST 1507 1508 1509 START_TEST(equalSmallBoolDoubleGT) 1510 1511 bool r; 1512 smallBoolt* self = allocSmallBool(true); 1513 1514 r = equalSmallBoolDoubleG(self, 2); 1515 ck_assert(!r); 1516 terminateO(self); 1517 1518 END_TEST 1519 1520 1521 START_TEST(equalSmallBoolInt64GT) 1522 1523 bool r; 1524 smallBoolt* self = allocSmallBool(true); 1525 1526 r = equalSmallBoolInt64G(self, 2); 1527 ck_assert(!r); 1528 terminateO(self); 1529 1530 END_TEST 1531 1532 1533 START_TEST(equalSmallBoolInt32GT) 1534 1535 bool r; 1536 smallBoolt* self = allocSmallBool(true); 1537 1538 r = equalSmallBoolInt32G(self, 2); 1539 ck_assert(!r); 1540 terminateO(self); 1541 1542 END_TEST 1543 1544 1545 START_TEST(equalSmallBoolUint32GT) 1546 1547 bool r; 1548 smallBoolt* self = allocSmallBool(true); 1549 1550 r = equalSmallBoolUint32G(self, 2); 1551 ck_assert(!r); 1552 terminateO(self); 1553 1554 END_TEST 1555 1556 1557 START_TEST(equalSmallBoolUint64GT) 1558 1559 bool r; 1560 smallBoolt* self = allocSmallBool(true); 1561 1562 r = equalSmallBoolUint64G(self, 2); 1563 ck_assert(!r); 1564 terminateO(self); 1565 1566 END_TEST 1567 1568 1569 START_TEST(equalSmallBoolFGT) 1570 1571 bool r; 1572 smallBoolt* self = allocSmallBool(true); 1573 smallBoolt* p2 = allocSmallBool(true); 1574 1575 r = equalSmallBoolFG(self, p2); 1576 terminateO(p2); 1577 ck_assert(r); 1578 terminateO(self); 1579 1580 END_TEST 1581 1582 1583 START_TEST(equalSmallBoolSmallBytesGT) 1584 1585 bool r; 1586 smallBoolt* self = allocSmallBool(true); 1587 smallBytest* p2 = allocSmallBytes("true", sizeof("true")); 1588 1589 r = equalSmallBoolSmallBytesG(self, p2); 1590 terminateO(p2); 1591 ck_assert(r); 1592 terminateO(self); 1593 1594 END_TEST 1595 1596 1597 START_TEST(equalSmallBoolSmallDoubleGT) 1598 1599 bool r; 1600 smallBoolt* self = allocSmallBool(true); 1601 smallDoublet* p2 = allocSmallDouble(1); 1602 1603 r = equalSmallBoolSmallDoubleG(self, p2); 1604 terminateO(p2); 1605 ck_assert(r); 1606 terminateO(self); 1607 1608 END_TEST 1609 1610 1611 START_TEST(equalSmallBoolSmallIntGT) 1612 1613 bool r; 1614 smallBoolt* self = allocSmallBool(true); 1615 smallIntt* p2 = allocSmallInt(1); 1616 1617 r = equalSmallBoolSmallIntG(self, p2); 1618 terminateO(p2); 1619 ck_assert(r); 1620 terminateO(self); 1621 1622 END_TEST 1623 1624 1625 START_TEST(equalSmallBoolSmallJsonGT) 1626 1627 bool r; 1628 smallBoolt* self = allocSmallBool(true); 1629 smallJsont* p2 = allocSmallJson(); 1630 1631 setTopSO(p2, "TRUE"); 1632 r = equalSmallBoolSmallJsonG(self, p2); 1633 terminateO(p2); 1634 ck_assert(r); 1635 terminateO(self); 1636 1637 END_TEST 1638 1639 1640 START_TEST(equalSmallBoolSmallStringGT) 1641 1642 bool r; 1643 smallBoolt* self = allocSmallBool(true); 1644 smallStringt* p2 = allocSmallString("true"); 1645 1646 r = equalSmallBoolSmallStringG(self, p2); 1647 terminateO(p2); 1648 ck_assert(r); 1649 terminateO(self); 1650 1651 END_TEST 1652 1653 1654 START_TEST(readFileSmallBoolGT) 1655 1656 smallBoolt* r; 1657 smallBoolt *self = allocSmallBool(true); 1658 const char *filePath = "smallBool.bin"; 1659 1660 writeFileO(self, filePath); 1661 setValO(self, false); 1662 r = readFileSmallBoolG(self, filePath); 1663 ck_assert_ptr_ne(r, null); 1664 char *s = toStringO(r); 1665 ck_assert_str_eq(s, "true"); 1666 free(s); 1667 rmAll(filePath); 1668 terminateO(self); 1669 1670 END_TEST 1671 1672 1673 START_TEST(readFileSmallJsonSmallBoolGT) 1674 1675 smallBoolt* r; 1676 smallBoolt *self = allocSmallBool(true); 1677 smallJsont *filePath = allocSmallJson(); 1678 setTopSO(filePath, "smallBool.bin"); 1679 1680 writeFileO(self, sjGet(filePath)); 1681 setValO(self, false); 1682 r = readFileSmallJsonSmallBoolG(self, filePath); 1683 ck_assert_ptr_ne(r, null); 1684 char *s = toStringO(r); 1685 ck_assert_str_eq(s, "true"); 1686 free(s); 1687 rmAll(sjGet(filePath)); 1688 terminateO(filePath); 1689 terminateO(self); 1690 1691 END_TEST 1692 1693 1694 START_TEST(readFileSmallStringSmallBoolGT) 1695 1696 smallBoolt* r; 1697 smallBoolt *self = allocSmallBool(true); 1698 smallStringt *filePath = allocSmallString("smallBool.bin"); 1699 1700 writeFileO(self, ssGet(filePath)); 1701 setValO(self, false); 1702 r = readFileSmallStringSmallBoolG(self, filePath); 1703 ck_assert_ptr_ne(r, null); 1704 char *s = toStringO(r); 1705 ck_assert_str_eq(s, "true"); 1706 free(s); 1707 rmAll(ssGet(filePath)); 1708 terminateO(filePath); 1709 terminateO(self); 1710 1711 END_TEST 1712 1713 1714 START_TEST(readStreamSmallBoolGT) 1715 1716 smallBoolt* r; 1717 smallBoolt *self = allocSmallBool(true); 1718 FILE *fp; 1719 const char *filePath = "smallBool.bin"; 1720 1721 writeFileO(self, filePath); 1722 setValO(self, false); 1723 fp = fopen(filePath, "r"); 1724 r = readStreamSmallBoolG(self, fp); 1725 ck_assert_ptr_ne(r, null); 1726 fclose(fp); 1727 char *s = toStringO(r); 1728 ck_assert_str_eq(s, "true"); 1729 free(s); 1730 rmAll(filePath); 1731 terminateO(self); 1732 1733 END_TEST 1734 1735 1736 START_TEST(writeFileSmallBoolGT) 1737 1738 int r; 1739 smallBoolt *self = allocSmallBool(true); 1740 const char *filePath = "smallBool.bin"; 1741 1742 r = writeFileSmallBoolG(self, filePath); 1743 ck_assert_int_eq(r, 1); 1744 freeO(self); 1745 smallBoolt *r2 = readFileO(self, filePath); 1746 ck_assert_ptr_ne(r2, null); 1747 char *s = toStringO(r2); 1748 ck_assert_str_eq(s, "true"); 1749 free(s); 1750 rmAll(filePath); 1751 terminateO(self); 1752 1753 END_TEST 1754 1755 1756 START_TEST(writeFileSmallJsonSmallBoolGT) 1757 1758 int r; 1759 smallBoolt *self = allocSmallBool(true); 1760 smallJsont *filePath = allocSmallJson(); 1761 setTopSO(filePath, "smallBool.bin"); 1762 1763 r = writeFileSmallJsonSmallBoolG(self, filePath); 1764 ck_assert_int_eq(r, 1); 1765 freeO(self); 1766 smallBoolt *r2 = readFileO(self, sjGet(filePath)); 1767 ck_assert_ptr_ne(r2, null); 1768 char *s = toStringO(r2); 1769 ck_assert_str_eq(s, "true"); 1770 free(s); 1771 terminateO(filePath); 1772 terminateO(self); 1773 rmAll("smallBool.bin"); 1774 1775 END_TEST 1776 1777 1778 START_TEST(writeFileSmallStringSmallBoolGT) 1779 1780 int r; 1781 smallBoolt *self = allocSmallBool(true); 1782 smallStringt *filePath = allocSmallString("smallBool.bin"); 1783 1784 r = writeFileSmallStringSmallBoolG(self, filePath); 1785 ck_assert_int_eq(r, 1); 1786 freeO(self); 1787 smallBoolt *r2 = readFileO(self, ssGet(filePath)); 1788 ck_assert_ptr_ne(r2, null); 1789 char *s = toStringO(r2); 1790 ck_assert_str_eq(s, "true"); 1791 free(s); 1792 terminateO(filePath); 1793 terminateO(self); 1794 rmAll("smallBool.bin"); 1795 1796 END_TEST 1797 1798 1799 START_TEST(writeStreamSmallBoolGT) 1800 1801 int r; 1802 smallBoolt *self = allocSmallBool(true); 1803 FILE *fp; 1804 const char *filePath = "smallBool.bin"; 1805 1806 fp = fopen(filePath, "w"); 1807 r = writeStreamSmallBoolG(self, fp); 1808 ck_assert_int_eq(r, 1); 1809 fclose(fp); 1810 freeO(self); 1811 smallBoolt *r2 = readFileO(self, filePath); 1812 ck_assert_ptr_ne(r2, null); 1813 char *s = toStringO(r2); 1814 ck_assert_str_eq(s, "true"); 1815 free(s); 1816 terminateO(self); 1817 rmAll(filePath); 1818 1819 END_TEST 1820 1821 1822 START_TEST(appendFileSmallBoolFGT) 1823 1824 int r; 1825 smallBoolt *self = allocSmallBool(true); 1826 const char *filePath = "smallBool.bin"; 1827 1828 FILE *f = fopen(filePath, "w"); 1829 fclose(f); 1830 r = appendFileSmallBoolFG(self, filePath); 1831 ck_assert_int_eq(r, 1); 1832 freeO(self); 1833 smallBoolt *r2 = readFileO(self, filePath); 1834 ck_assert_ptr_ne(r2, null); 1835 char *s = toStringO(r2); 1836 ck_assert_str_eq(s, "true"); 1837 free(s); 1838 terminateO(self); 1839 rmAll("smallBool.bin"); 1840 1841 END_TEST 1842 1843 1844 START_TEST(appendFileSmallStringSmallBoolGT) 1845 1846 int r; 1847 smallBoolt *self = allocSmallBool(true); 1848 smallStringt *filePath = allocSmallString("smallBool.bin"); 1849 1850 FILE *f = fopen(ssGet(filePath), "w"); 1851 fclose(f); 1852 r = appendFileSmallStringSmallBoolG(self, filePath); 1853 ck_assert_int_eq(r, 1); 1854 freeO(self); 1855 smallBoolt *r2 = readFileO(self, ssGet(filePath)); 1856 ck_assert_ptr_ne(r2, null); 1857 char *s = toStringO(r2); 1858 ck_assert_str_eq(s, "true"); 1859 free(s); 1860 terminateO(filePath); 1861 terminateO(self); 1862 rmAll("smallBool.bin"); 1863 1864 END_TEST 1865 1866 1867 1868 1869 1870 Suite * libsheepySuite(void) { 1871 Suite *s; 1872 TCase *tc_core; 1873 1874 s = suite_create("libsheepy"); 1875 1876 /* Core test case */ 1877 tc_core = tcase_create("Object"); 1878 1879 setLogMode(LOG_VERBOSE); 1880 1881 // disable btrace to make the test run faster 1882 btraceDisable(); 1883 1884 tcase_add_test(tc_core, initiateSmallBoolT); 1885 tcase_add_test(tc_core, initiateAllocateSmallBoolT); 1886 tcase_add_test(tc_core, allocSmallBoolT); 1887 tcase_add_test(tc_core, freeSmallBoolT); 1888 tcase_add_test(tc_core, terminateSmallBoolT); 1889 tcase_add_test(tc_core, toStringSmallBoolT); 1890 tcase_add_test(tc_core, duplicateSmallBoolT); 1891 tcase_add_test(tc_core, smashSmallBoolT); 1892 tcase_add_test(tc_core, finishSmallBoolT); 1893 tcase_add_test(tc_core, getSmallBoolT); 1894 tcase_add_test(tc_core, setSmallBoolT); 1895 tcase_add_test(tc_core, setDoubleSmallBoolT); 1896 tcase_add_test(tc_core, setInt64SmallBoolT); 1897 tcase_add_test(tc_core, setInt32SmallBoolT); 1898 tcase_add_test(tc_core, setUint32SmallBoolT); 1899 tcase_add_test(tc_core, setUint64SmallBoolT); 1900 tcase_add_test(tc_core, setSSmallBoolT); 1901 tcase_add_test(tc_core, setSmallBoolSmallBoolT); 1902 tcase_add_test(tc_core, setSmallDoubleSmallBoolT); 1903 tcase_add_test(tc_core, setSmallIntSmallBoolT); 1904 tcase_add_test(tc_core, setSmallJsonSmallBoolT); 1905 tcase_add_test(tc_core, setSmallStringSmallBoolT); 1906 tcase_add_test(tc_core, getPSmallBoolT); 1907 tcase_add_test(tc_core, equalSmallBoolCharT); 1908 tcase_add_test(tc_core, equalSmallBoolBaseT); 1909 tcase_add_test(tc_core, equalSmallBoolBoolT); 1910 tcase_add_test(tc_core, equalSmallBoolDoubleT); 1911 tcase_add_test(tc_core, equalSmallBoolInt64T); 1912 tcase_add_test(tc_core, equalSmallBoolInt32T); 1913 tcase_add_test(tc_core, equalSmallBoolUint32T); 1914 tcase_add_test(tc_core, equalSmallBoolUint64T); 1915 tcase_add_test(tc_core, equalSmallBoolT); 1916 tcase_add_test(tc_core, equalSmallBoolSmallBytesT); 1917 tcase_add_test(tc_core, equalSmallBoolSmallDoubleT); 1918 tcase_add_test(tc_core, equalSmallBoolSmallIntT); 1919 tcase_add_test(tc_core, equalSmallBoolSmallJsonT); 1920 tcase_add_test(tc_core, equalSmallBoolSmallStringT); 1921 tcase_add_test(tc_core, readFileSmallBoolT); 1922 tcase_add_test(tc_core, readFileSmallJsonSmallBoolT); 1923 tcase_add_test(tc_core, readFileSmallStringSmallBoolT); 1924 tcase_add_test(tc_core, readStreamSmallBoolT); 1925 tcase_add_test(tc_core, writeFileSmallBoolT); 1926 tcase_add_test(tc_core, writeFileSmallJsonSmallBoolT); 1927 tcase_add_test(tc_core, writeFileSmallStringSmallBoolT); 1928 tcase_add_test(tc_core, writeStreamSmallBoolT); 1929 tcase_add_test(tc_core, appendFileSmallBoolT); 1930 tcase_add_test(tc_core, appendFileSmallStringSmallBoolT); 1931 tcase_add_test(tc_core, duplicateSmallBoolGT); 1932 tcase_add_test(tc_core, freeSmallBoolGT); 1933 tcase_add_test(tc_core, getBoolSmallBoolGT); 1934 tcase_add_test(tc_core, getBoolPSmallBoolGT); 1935 tcase_add_test(tc_core, setSmallBoolGT); 1936 tcase_add_test(tc_core, setDoubleSmallBoolGT); 1937 tcase_add_test(tc_core, setInt64SmallBoolGT); 1938 tcase_add_test(tc_core, setInt32SmallBoolGT); 1939 tcase_add_test(tc_core, setUint32SmallBoolGT); 1940 tcase_add_test(tc_core, setUint64SmallBoolGT); 1941 tcase_add_test(tc_core, setSSmallBoolGT); 1942 tcase_add_test(tc_core, setSmallBoolSmallBoolGT); 1943 tcase_add_test(tc_core, setSmallDoubleSmallBoolGT); 1944 tcase_add_test(tc_core, setSmallIntSmallBoolGT); 1945 tcase_add_test(tc_core, setSmallJsonSmallBoolGT); 1946 tcase_add_test(tc_core, setSmallStringSmallBoolGT); 1947 tcase_add_test(tc_core, equalSmallBoolCharGT); 1948 tcase_add_test(tc_core, equalSmallBoolBaseGT); 1949 tcase_add_test(tc_core, equalSmallBoolBoolGT); 1950 tcase_add_test(tc_core, equalSmallBoolDoubleGT); 1951 tcase_add_test(tc_core, equalSmallBoolInt64GT); 1952 tcase_add_test(tc_core, equalSmallBoolInt32GT); 1953 tcase_add_test(tc_core, equalSmallBoolUint32GT); 1954 tcase_add_test(tc_core, equalSmallBoolUint64GT); 1955 tcase_add_test(tc_core, equalSmallBoolFGT); 1956 tcase_add_test(tc_core, equalSmallBoolSmallBytesGT); 1957 tcase_add_test(tc_core, equalSmallBoolSmallDoubleGT); 1958 tcase_add_test(tc_core, equalSmallBoolSmallIntGT); 1959 tcase_add_test(tc_core, equalSmallBoolSmallJsonGT); 1960 tcase_add_test(tc_core, equalSmallBoolSmallStringGT); 1961 tcase_add_test(tc_core, readFileSmallBoolGT); 1962 tcase_add_test(tc_core, readFileSmallJsonSmallBoolGT); 1963 tcase_add_test(tc_core, readFileSmallStringSmallBoolGT); 1964 tcase_add_test(tc_core, readStreamSmallBoolGT); 1965 tcase_add_test(tc_core, writeFileSmallBoolGT); 1966 tcase_add_test(tc_core, writeFileSmallJsonSmallBoolGT); 1967 tcase_add_test(tc_core, writeFileSmallStringSmallBoolGT); 1968 tcase_add_test(tc_core, writeStreamSmallBoolGT); 1969 tcase_add_test(tc_core, appendFileSmallBoolFGT); 1970 tcase_add_test(tc_core, appendFileSmallStringSmallBoolGT); 1971 1972 suite_add_tcase(s, tc_core); 1973 1974 return s; 1975 } 1976 1977 int main(int ARGC UNUSED, char** ARGV UNUSED) { 1978 int number_failed; 1979 Suite *s; 1980 SRunner *sr; 1981 1982 s = libsheepySuite(); 1983 sr = srunner_create(s); 1984 1985 srunner_run_all(sr, CK_NORMAL); 1986 number_failed = srunner_ntests_failed(sr); 1987 srunner_free(sr); 1988 1989 exit((number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE); 1990 } 1991 // vim: set expandtab ts=2 sw=2: