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