libsheepySmallTest.c (43057B)
1 #include <stdlib.h> 2 #include <stdio.h> 3 #include <check.h> 4 5 //START MEM TEST ANCHOR 6 7 #include "libsheepySmall.h" 8 9 START_TEST(isSTypeFT) 10 11 sBoolt *b; 12 b = allocSBool(false); 13 ck_assert(isSTypeF((smallt *)b, BOOL)); 14 free(b); 15 // NULL 16 ck_assert(!isSTypeF(NULL, UNDEFINED)); 17 18 END_TEST 19 20 START_TEST(sSizeT) 21 22 sBoolt *b; 23 b = allocSBool(false); 24 ck_assert_uint_eq(sSizeTiny((smallt *)b), sizeof(sBoolt)); 25 free(b); 26 27 sContainert *c; 28 c = allocSContainer(strdup("sheepy")); 29 ck_assert_uint_eq(sSizeTiny((smallt *)c), sizeof(sContainert)); 30 free(c->data); 31 free(c); 32 33 sDictt *d; 34 d = allocSDict(); 35 ck_assert_uint_eq(sSizeTiny((smallt *)d), sizeof(sDictt)); 36 // with elements 37 b = allocSBool(false); 38 sDictPushTiny(&d, "a", (smallt *) b); 39 ck_assert_uint_eq(sSizeTiny((smallt *)d), sizeof(sDictt) + sizeof(sDictElemt *)*(d->count-1)); 40 sDictFreeTiny(d); 41 42 sDoublet *D; 43 D = allocSDouble(10); 44 ck_assert_uint_eq(sSizeTiny((smallt *)D), sizeof(sDoublet)); 45 free(D); 46 47 sIntt *i; 48 i = allocSInt(10); 49 ck_assert_uint_eq(sSizeTiny((smallt *)i), sizeof(sIntt)); 50 free(i); 51 52 sStringt *s; 53 s = allocSStringTiny(""); 54 ck_assert_uint_eq(sSizeTiny((smallt *)s), sizeof(sStringt)); 55 free(s); 56 // string 57 s = allocSStringTiny("sheepy"); 58 ck_assert_uint_eq(sSizeTiny((smallt *)s), sizeof(sStringt) + strlen("sheepy")); 59 free(s); 60 61 sArrayt *a; 62 a = allocSArray(); 63 ck_assert_uint_eq(sSizeTiny((smallt *)a), sizeof(sArrayt)); 64 b = allocSBool(false); 65 sArrayPushTiny(&a, (smallt *) b); 66 D = allocSDouble(10); 67 sArrayPushTiny(&a, (smallt *) D); 68 s = allocSStringTiny("sheepy"); 69 sArrayPushTiny(&a, (smallt *) s); 70 ck_assert_uint_eq(sSizeTiny((smallt *)a), sizeof(sArrayt) + sizeof(smallt *)*(a->count-1)); 71 sArrayFreeTiny(a); 72 73 sUndefinedt *u; 74 u = allocSUndefined(); 75 ck_assert_uint_eq(sSizeTiny((smallt *)u), sizeof(sUndefinedt)); 76 free(u); 77 78 sBytest *B; 79 B = allocSBytes(); 80 ck_assert_uint_eq(sSizeTiny((smallt *)B), sizeof(sBytest)); 81 sBytesPush(&B, 1); 82 sBytesPush(&B, 2); 83 sBytesPush(&B, 3); 84 ck_assert_uint_eq(sSizeTiny((smallt *)B), sizeof(sBytest) + sizeof(char) * (B->count-1)); 85 free(B); 86 87 // non existing object type - size 0 88 sUndefinedt *NIL; 89 NIL = allocSUndefined(); 90 NIL->type += 100; 91 ck_assert_uint_eq(sSizeTiny((smallt *)NIL), 0); 92 free(NIL); 93 94 END_TEST 95 96 97 98 START_TEST(allocSBoolT) 99 100 sBoolt *o; 101 o = allocSBool(false); 102 ck_assert_uint_eq(o->type, BOOL); 103 ck_assert(!o->value); 104 free(o); 105 106 END_TEST 107 108 109 START_TEST(allocSContainerT) 110 111 sContainert *o; 112 o = allocSContainer(strdup("sheepy")); 113 ck_assert_uint_eq(o->type, CONTAINER); 114 ck_assert_str_eq(o->data, "sheepy"); 115 free(o->data); 116 free(o); 117 118 END_TEST 119 120 121 START_TEST(allocSDictT) 122 123 sDictt *o; 124 o = allocSDict(); 125 ck_assert_uint_eq(o->type, DICT); 126 ck_assert_uint_eq(o->count, 0); 127 free(o); 128 129 END_TEST 130 131 132 START_TEST(allocSDoubleT) 133 134 sDoublet *o; 135 o = allocSDouble(1.5); 136 ck_assert_uint_eq(o->type, DOUBLE); 137 // TODO use ck_assert_float_eq when available 138 ck_assert_uint_eq(o->value*2, 3); 139 free(o); 140 141 END_TEST 142 143 144 START_TEST(allocSIntT) 145 146 sIntt *o; 147 o = allocSInt(1); 148 ck_assert_uint_eq(o->type, INT); 149 ck_assert_uint_eq(o->value, 1); 150 free(o); 151 152 END_TEST 153 154 155 START_TEST(allocSStringT) 156 157 sStringt *o; 158 o = allocSStringTiny("sheepy"); 159 ck_assert_uint_eq(o->type, STRING); 160 ck_assert_uint_ne(o->data, 0); 161 free(o); 162 163 END_TEST 164 165 166 START_TEST(allocSArrayT) 167 168 sArrayt *o; 169 o = allocSArray(); 170 ck_assert_uint_eq(o->type, ARRAY); 171 ck_assert_uint_eq(o->count, 0); 172 free(o); 173 174 END_TEST 175 176 177 START_TEST(allocSUndefinedT) 178 179 sUndefinedt *o; 180 o = allocSUndefined(); 181 ck_assert_uint_eq(o->type, UNDEFINED); 182 free(o); 183 184 END_TEST 185 186 187 START_TEST(allocSBytesT) 188 189 sBytest *o; 190 o = allocSBytes(); 191 ck_assert_uint_eq(o->type, BYTES); 192 ck_assert_uint_eq(o->count, 0); 193 free(o); 194 195 END_TEST 196 197 198 START_TEST(sFreeT) 199 200 // dict 201 sDictt *o = allocSDict(); 202 sFree((smallt *) o); 203 // array 204 sArrayt *a = allocSArray(); 205 sFree((smallt *) a); 206 // other objects 207 sUndefinedt *u = allocSUndefined(); 208 sFree((smallt *) u); 209 // non existing object type - size 0 210 sUndefinedt *NIL; 211 NIL = allocSUndefined(); 212 NIL->type += 100; 213 sFree((smallt *) NIL); 214 // NULL 215 sFree(NULL); 216 217 END_TEST 218 219 220 START_TEST(sDictFreeT) 221 222 sDictt *o = allocSDict(); 223 sDictt *d = allocSDict(); 224 sDictPushTiny(&o, "d" , (smallt *)d); 225 sArrayt *a = allocSArray(); 226 sDictPushTiny(&o, "a" , (smallt *)a); 227 sDictFreeTiny(o); 228 229 END_TEST 230 231 232 START_TEST(sArrayFreeT) 233 234 sArrayt *o = allocSArray(); 235 sDictt *d = allocSDict(); 236 sArrayPushTiny(&o, (smallt *)d); 237 sArrayt *a = allocSArray(); 238 sArrayPushTiny(&o, (smallt *)a); 239 sArrayFreeTiny(o); 240 241 END_TEST 242 243 244 START_TEST(sBoolToStringT) 245 246 sBoolt *o; 247 o = allocSBool(false); 248 char *S = sBoolToStringTiny(o); 249 ck_assert_str_eq(S, "false"); 250 free(S); 251 o->value = true; 252 S = sBoolToStringTiny(o); 253 ck_assert_str_eq(S, "true"); 254 free(S); 255 free(o); 256 257 END_TEST 258 259 260 START_TEST(sContainerToStringT) 261 262 sContainert *o; 263 o = allocSContainer(strdup("sheepy")); 264 char *S = sContainerToStringTiny(o); 265 ck_assert_str_eq(S, "<data container>"); 266 free(S); 267 free(o->data); 268 free(o); 269 270 END_TEST 271 272 273 START_TEST(sDictToStringT) 274 275 sDictt *o; 276 o = allocSDict(); 277 char *S = sDictToStringTiny(o); 278 ck_assert_str_eq(S, "{}"); 279 free(S); 280 // elements 281 sBoolt *b = allocSBool(false); 282 sDictPushTiny(&o, "a", (smallt *) b); 283 sContainert *c = allocSContainer(strdup("sheepy")); 284 sDictPushTiny(&o, "c", (smallt *) c); 285 sStringt *s = allocSStringTiny(""); 286 sDictPushTiny(&o, "s", (smallt *) s); 287 S = sDictToStringTiny(o); 288 ck_assert_str_eq(S, "{\"a\":false,\"c\":\"<data container>\",\"s\":\"\"}"); 289 free(S); 290 free(c->data); 291 sDictFreeTiny(o); 292 293 END_TEST 294 295 296 START_TEST(sDoubleToStringT) 297 298 sDoublet *o; 299 o = allocSDouble(1.5); 300 char *S = sDoubleToStringTiny(o); 301 ck_assert_str_eq(S, "1.500000e+00"); 302 free(S); 303 free(o); 304 305 END_TEST 306 307 308 START_TEST(sIntToStringT) 309 310 sIntt *o; 311 o = allocSInt(1); 312 char *S = sIntToStringTiny(o); 313 ck_assert_str_eq(S, "1"); 314 free(S); 315 free(o); 316 317 END_TEST 318 319 320 START_TEST(sStringToStringT) 321 322 sStringt *o; 323 o = allocSStringTiny("sheepy"); 324 char *S = sStringToStringTiny(o); 325 ck_assert_str_eq(S, "sheepy"); 326 free(S); 327 free(o); 328 329 END_TEST 330 331 332 START_TEST(sArrayToStringT) 333 334 sArrayt *o; 335 o = allocSArray(); 336 char *S = sArrayToStringTiny(o); 337 ck_assert_str_eq(S, "[]"); 338 free(S); 339 // elements 340 sBoolt *b = allocSBool(false); 341 sArrayPushTiny(&o, (smallt *) b); 342 sContainert *c = allocSContainer(strdup("sheepy")); 343 sArrayPushTiny(&o, (smallt *) c); 344 sStringt *s = allocSStringTiny(""); 345 sArrayPushTiny(&o, (smallt *) s); 346 sUndefinedt *u = allocSUndefined(); 347 sArrayPushTiny(&o, (smallt *) u); 348 sArraySetTiny(o, 3, NULL); 349 S = sArrayToStringTiny(o); 350 ck_assert_str_eq(S, "[false,\"<data container>\",\"\"]"); 351 free(S); 352 free(c->data); 353 sArrayFreeTiny(o); 354 // array with 1 NULL element 355 o = allocSArray(); 356 sArrayPushTiny(&o, NULL); 357 S = sArrayToStringTiny(o); 358 ck_assert_str_eq(S, "[]"); 359 free(S); 360 sArrayFreeTiny(o); 361 362 END_TEST 363 364 365 START_TEST(sUndefinedToStringT) 366 367 sUndefinedt *o; 368 o = allocSUndefined(); 369 char *S = sUndefinedToStringTiny(o); 370 ck_assert_str_eq(S, "null"); 371 free(S); 372 free(o); 373 374 END_TEST 375 376 377 START_TEST(sBytesToStringT) 378 379 sBytest *o; 380 o = allocSBytes(); 381 char *S = sBytesToStringTiny(o); 382 ck_assert_str_eq(S, "[]"); 383 free(S); 384 sBytesPush(&o, 1); 385 sBytesPush(&o, 2); 386 sBytesPush(&o, 3); 387 S = sBytesToStringTiny(o); 388 ck_assert_str_eq(S, "[0x01,0x02,0x03]"); 389 free(S); 390 free(o); 391 392 END_TEST 393 394 395 START_TEST(sToStringT) 396 397 sBoolt *b; 398 b = allocSBool(false); 399 char *S = sToString((smallt *)b); 400 ck_assert_str_eq(S, "false"); 401 free(S); 402 free(b); 403 404 sContainert *c; 405 c = allocSContainer(strdup("sheepy")); 406 S = sToString((smallt *)c); 407 ck_assert_str_eq(S, "<data container>"); 408 free(S); 409 free(c->data); 410 free(c); 411 412 sDictt *d; 413 d = allocSDict(); 414 S = sToString((smallt *)d); 415 ck_assert_str_eq(S, "{}"); 416 free(S); 417 sDictFreeTiny(d); 418 419 sDoublet *D; 420 D = allocSDouble(10); 421 S = sToString((smallt *)D); 422 ck_assert_str_eq(S, "1.000000e+01"); 423 free(S); 424 free(D); 425 426 sIntt *i; 427 i = allocSInt(10); 428 S = sToString((smallt *)i); 429 ck_assert_str_eq(S, "10"); 430 free(S); 431 free(i); 432 433 sStringt *s; 434 s = allocSStringTiny(""); 435 S = sToString((smallt *)s); 436 ck_assert_str_eq(S, ""); 437 free(S); 438 free(s); 439 440 sArrayt *a; 441 a = allocSArray(); 442 S = sToString((smallt *)a); 443 ck_assert_str_eq(S, "[]"); 444 free(S); 445 sArrayFreeTiny(a); 446 447 sUndefinedt *u; 448 u = allocSUndefined(); 449 S = sToString((smallt *)u); 450 ck_assert_str_eq(S, "null"); 451 free(S); 452 free(u); 453 454 sBytest *B; 455 B = allocSBytes(); 456 S = sToString((smallt *)B); 457 ck_assert_str_eq(S, "[]"); 458 free(S); 459 free(B); 460 461 // non existing object type - size 0 462 sUndefinedt *NIL; 463 NIL = allocSUndefined(); 464 NIL->type += 100; 465 S = sToString((smallt *)NIL); 466 ck_assert_ptr_eq(S, NULL); 467 free(NIL); 468 469 // NULL 470 S = sToString(NULL); 471 ck_assert_ptr_eq(S, NULL); 472 473 END_TEST 474 475 476 START_TEST(sTypesT) 477 478 sDictt *o; 479 o = allocSDict(); 480 // elements 481 sBoolt *b = allocSBool(false); 482 sDictPushTiny(&o, "a", (smallt *) b); 483 sContainert *c = allocSContainer(strdup("sheepy")); 484 sDictPushTiny(&o, "c", (smallt *) c); 485 sStringt *s = allocSStringTiny(""); 486 sDictPushTiny(&o, "s", (smallt *) s); 487 char *S = sTypesTiny((smallt *)o); 488 ck_assert_str_eq(S, "[\"bool\",\"container\",\"string\"]"); 489 free(S); 490 free(c->data); 491 sDictFreeTiny(o); 492 493 END_TEST 494 495 496 START_TEST(sTypesToBytesT) 497 498 // dict 499 sDictt *o; 500 o = allocSDict(); 501 // elements 502 sBoolt *b = allocSBool(false); 503 sDictPushTiny(&o, "a", (smallt *) b); 504 sContainert *c = allocSContainer(strdup("sheepy")); 505 sDictPushTiny(&o, "c", (smallt *) c); 506 sStringt *s = allocSStringTiny(""); 507 sDictPushTiny(&o, "s", (smallt *) s); 508 sBytest *t = sTypesToBytesTiny((smallt *)o); 509 char *S = sBytesToStringTiny(t); 510 ck_assert_str_eq(S, "[0x02,0x03,0x08]"); 511 free(S); 512 free(t); 513 free(c->data); 514 sDictFreeTiny(o); 515 516 // array 517 sArrayt *a; 518 a = allocSArray(); 519 // elements 520 b = allocSBool(false); 521 sArrayPushTiny(&a, (smallt *) b); 522 c = allocSContainer(strdup("sheepy")); 523 sArrayPushTiny(&a, (smallt *) c); 524 s = allocSStringTiny(""); 525 sArrayPushTiny(&a, (smallt *) s); 526 sUndefinedt *u = allocSUndefined(); 527 sArrayPushTiny(&a, (smallt *) u); 528 sArraySetTiny(a, 3, NULL); 529 t = sTypesToBytesTiny((smallt *)a); 530 S = sBytesToStringTiny(t); 531 ck_assert_str_eq(S, "[0x02,0x03,0x08]"); 532 free(S); 533 free(t); 534 free(c->data); 535 sArrayFreeTiny(a); 536 537 // non existing object type - size 0 538 sUndefinedt *NIL; 539 NIL = allocSUndefined(); 540 NIL->type += 100; 541 t = sTypesToBytesTiny((smallt *)NIL); 542 ck_assert_ptr_eq(t, NULL); 543 free(NIL); 544 545 END_TEST 546 547 548 START_TEST(sDictTypeStringsT) 549 550 sDictt *o; 551 o = allocSDict(); 552 // elements 553 sBoolt *b = allocSBool(false); 554 sDictPushTiny(&o, "a", (smallt *) b); 555 sContainert *c = allocSContainer(strdup("sheepy")); 556 sDictPushTiny(&o, "c", (smallt *) c); 557 sStringt *s = allocSStringTiny(""); 558 sDictPushTiny(&o, "s", (smallt *) s); 559 char **t = (char**)sDictTypeStrings(o); 560 char *S = join(t, ","); 561 ck_assert_str_eq(S, "bool,container,string"); 562 free(S); 563 free(t); 564 free(c->data); 565 sDictFreeTiny(o); 566 567 END_TEST 568 569 570 START_TEST(sDictTypesT) 571 572 sDictt *o; 573 o = allocSDict(); 574 // elements 575 sBoolt *b = allocSBool(false); 576 sDictPushTiny(&o, "a", (smallt *) b); 577 sContainert *c = allocSContainer(strdup("sheepy")); 578 sDictPushTiny(&o, "c", (smallt *) c); 579 sStringt *s = allocSStringTiny(""); 580 sDictPushTiny(&o, "s", (smallt *) s); 581 sBytest *t = sDictTypesTiny(o); 582 char *S = sBytesToStringTiny(t); 583 ck_assert_str_eq(S, "[0x02,0x03,0x08]"); 584 free(S); 585 free(t); 586 free(c->data); 587 sDictFreeTiny(o); 588 589 END_TEST 590 591 592 START_TEST(sArrayTypeStringsT) 593 594 sArrayt *o; 595 o = allocSArray(); 596 // elements 597 sBoolt *b = allocSBool(false); 598 sArrayPushTiny(&o, (smallt *) b); 599 sContainert *c = allocSContainer(strdup("sheepy")); 600 sArrayPushTiny(&o, (smallt *) c); 601 sStringt *s = allocSStringTiny(""); 602 sArrayPushTiny(&o, (smallt *) s); 603 sUndefinedt *u = allocSUndefined(); 604 sArrayPushTiny(&o, (smallt *) u); 605 sArraySetTiny(o, 3, NULL); 606 char **t = (char**)sArrayTypeStrings(o); 607 char *S = join(t, ","); 608 ck_assert_str_eq(S, "bool,container,string"); 609 free(S); 610 free(t); 611 free(c->data); 612 sArrayFreeTiny(o); 613 614 END_TEST 615 616 617 START_TEST(sArrayTypesT) 618 619 sArrayt *o; 620 o = allocSArray(); 621 // elements 622 sBoolt *b = allocSBool(false); 623 sArrayPushTiny(&o, (smallt *) b); 624 sContainert *c = allocSContainer(strdup("sheepy")); 625 sArrayPushTiny(&o, (smallt *) c); 626 sStringt *s = allocSStringTiny(""); 627 sArrayPushTiny(&o, (smallt *) s); 628 sUndefinedt *u = allocSUndefined(); 629 sArrayPushTiny(&o, (smallt *) u); 630 sArraySetTiny(o, 3, NULL); 631 sBytest *t = sArrayTypesTiny(o); 632 char *S = sBytesToStringTiny(t); 633 ck_assert_str_eq(S, "[0x02,0x03,0x08]"); 634 free(S); 635 free(t); 636 free(c->data); 637 sArrayFreeTiny(o); 638 639 END_TEST 640 641 642 START_TEST(sDuplicateT) 643 char *S; 644 645 sBoolt *b, *b2; 646 b = allocSBool(true); 647 b2 = (sBoolt *) sDuplicate((smallt *)b); 648 ck_assert(b2->value); 649 free(b2); 650 free(b); 651 652 sContainert *c, *c2; 653 c = allocSContainer(strdup("sheepy")); 654 c2 = (sContainert *) sDuplicate((smallt *)c); 655 ck_assert_str_eq(c2->data, c->data); 656 free(c2); 657 free(c->data); 658 free(c); 659 660 sDictt *d, *d2; 661 d = allocSDict(); 662 d2 = (sDictt *) sDuplicateTiny((smallt *)d); 663 ck_assert_uint_eq(d2->count, 0); 664 sDictFreeTiny(d2); 665 // with elements 666 b = allocSBool(false); 667 sDictPushTiny(&d, "a", (smallt *) b); 668 d2 = (sDictt *) sDuplicateTiny((smallt *)d); 669 S = sDictToStringTiny(d2); 670 ck_assert_str_eq(S, "{\"a\":false}"); 671 free(S); 672 sDictFreeTiny(d2); 673 sDictFreeTiny(d); 674 675 sDoublet *D, *D2; 676 D = allocSDouble(10); 677 D2 = (sDoublet *) sDuplicate((smallt *)D); 678 ck_assert_uint_eq((uint)D2->value, (uint)D->value); 679 free(D2); 680 free(D); 681 682 sIntt *i, *i2; 683 i = allocSInt(10); 684 i2 = (sIntt *) sDuplicate((smallt *)i); 685 ck_assert_uint_eq(i2->value, i->value); 686 free(i2); 687 free(i); 688 689 sStringt *s, *s2; 690 s = allocSStringTiny(""); 691 s2 = (sStringt *) sDuplicate((smallt *)s); 692 ck_assert_str_eq((char*)s, (char*)s2); 693 free(s2); 694 free(s); 695 // string 696 s = allocSStringTiny("sheepy"); 697 s2 = (sStringt *) sDuplicate((smallt *)s); 698 ck_assert_str_eq((char*)s, (char*)s2); 699 free(s2); 700 free(s); 701 702 sArrayt *a, *a2; 703 a = allocSArray(); 704 a2 = (sArrayt *) sDuplicate((smallt *)a); 705 ck_assert_uint_eq(a2->count, 0); 706 sArrayFreeTiny(a2); 707 b = allocSBool(false); 708 sArrayPushTiny(&a, (smallt *) b); 709 D = allocSDouble(10); 710 sArrayPushTiny(&a, (smallt *) D); 711 s = allocSStringTiny("sheepy"); 712 sArrayPushTiny(&a, (smallt *) s); 713 a2 = (sArrayt *) sDuplicate((smallt *)a); 714 S = sArrayToStringTiny(a2); 715 ck_assert_str_eq(S, "[false,1.000000e+01,\"sheepy\"]"); 716 free(S); 717 sArrayFreeTiny(a2); 718 sArrayFreeTiny(a); 719 720 sUndefinedt *u, *u2 = NULL; 721 u = allocSUndefined(); 722 u2 = (sUndefinedt *) sDuplicate((smallt *)u); 723 ck_assert_uint_eq(u2->type, UNDEFINED); 724 free(u2); 725 free(u); 726 727 sBytest *B, *B2; 728 B = allocSBytes(); 729 B2 = (sBytest *) sDuplicate((smallt *)B); 730 sBytesPush(&B, 1); 731 sBytesPush(&B, 2); 732 sBytesPush(&B, 3); 733 ck_assert_uint_eq(B2->count, 0); 734 free(B2); 735 B2 = (sBytest *) sDuplicate((smallt *)B); 736 S = sToStringTiny((smallt *)B); 737 ck_assert_str_eq(S, "[0x01,0x02,0x03]"); 738 free(S); 739 S = sToStringTiny((smallt *)B2); 740 ck_assert_str_eq(S, "[0x01,0x02,0x03]"); 741 free(S); 742 free(B2); 743 free(B); 744 745 // NULL 746 ck_assert_ptr_eq(sDuplicate(NULL), NULL); 747 748 END_TEST 749 750 751 START_TEST(sDictDuplicateT) 752 753 sDictt *o, *d; 754 o = allocSDict(); 755 // elements 756 sBoolt *b = allocSBool(true); 757 sDictPushTiny(&o, "a", (smallt *) b); 758 sContainert *c = allocSContainer(strdup("sheepy")); 759 sDictPushTiny(&o, "c", (smallt *) c); 760 sStringt *s = allocSStringTiny(""); 761 sDictPushTiny(&o, "s", (smallt *) s); 762 d = sDictDuplicateTiny(o); 763 char *S = sDictToStringTiny(d); 764 ck_assert_str_eq(S, "{\"a\":true,\"c\":\"<data container>\",\"s\":\"\"}"); 765 free(S); 766 free(c->data); 767 sDictFreeTiny(d); 768 sDictFreeTiny(o); 769 770 END_TEST 771 772 773 START_TEST(sArrayDuplicateT) 774 775 sArrayt *a = allocSArray(); 776 sBoolt *b = allocSBool(false); 777 sArrayPushTiny(&a, (smallt *) b); 778 sDoublet *D = allocSDouble(10); 779 sArrayPushTiny(&a, (smallt *) D); 780 sStringt *s = allocSStringTiny("sheepy"); 781 sArrayPushTiny(&a, (smallt *) s); 782 sArrayPushTiny(&a, NULL); 783 sArrayPushTiny(&a, NULL); 784 sArrayt *a2 = sArrayDuplicateTiny(a); 785 char *S = sArrayToStringTiny(a2); 786 ck_assert_str_eq(S, "[false,1.000000e+01,\"sheepy\"]"); 787 free(S); 788 sArrayFreeTiny(a2); 789 sArrayFreeTiny(a); 790 791 END_TEST 792 793 794 START_TEST(sDictGetT) 795 796 sDictt *o; 797 o = allocSDict(); 798 // elements 799 sBoolt *b = allocSBool(false); 800 sDictPushTiny(&o, "a", (smallt *) b); 801 sContainert *c = allocSContainer(strdup("sheepy")); 802 sDictPushTiny(&o, "c", (smallt *) c); 803 sStringt *s = allocSStringTiny(""); 804 sDictPushTiny(&o, "s", (smallt *) s); 805 b = (sBoolt *)sDictGet(o, "a"); 806 ck_assert_uint_eq(b->type, BOOL); 807 // invalid key 808 ck_assert_ptr_eq(sDictGet(o, "X"), NULL); 809 free(c->data); 810 sDictFreeTiny(o); 811 812 END_TEST 813 814 815 START_TEST(sDictGetPT) 816 817 sDictt *o; 818 o = allocSDict(); 819 // elements 820 sBoolt *b = allocSBool(false); 821 sDictPushTiny(&o, "a", (smallt *) b); 822 sContainert *c = allocSContainer(strdup("sheepy")); 823 sDictPushTiny(&o, "c", (smallt *) c); 824 sStringt *s = allocSStringTiny(""); 825 sDictPushTiny(&o, "s", (smallt *) s); 826 sBoolt **bb = (sBoolt **)sDictGetP(o, "a"); 827 ck_assert_uint_eq((*bb)->type, BOOL); 828 // invalid key 829 ck_assert_ptr_eq(sDictGetP(o, "X"), NULL); 830 free(c->data); 831 sDictFreeTiny(o); 832 833 END_TEST 834 835 836 START_TEST(sDictSetPT) 837 838 sDictt *o = NULL; 839 sBoolt *b1, *b2; 840 // elements 841 sBoolt *b = allocSBool(false); 842 b1 = b; 843 sDictSetP(&o, "a", (smallt *) b); 844 b2 = allocSBool(true); 845 sDictSetP(&o, "a2", (smallt *) b2); 846 b = allocSBool(true); 847 sDictSetP(&o, "a", (smallt *) b); 848 b = allocSBool(false); 849 sDictSetP(&o, "a2", (smallt *) b); 850 // b1 and b2 is not freed by sDictSetP 851 ck_assert(!b1->value); 852 ck_assert(b2->value); 853 sFree((smallt *) b1); 854 sFree((smallt *) b2); 855 // set NULL (not changed) 856 sDictSetP(&o, "a", NULL); 857 b = (sBoolt *)sDictGet(o, "a"); 858 ck_assert(b->value); 859 b = (sBoolt *)sDictGet(o, "a2"); 860 ck_assert(!b->value); 861 sDictFreeTiny(o); 862 863 END_TEST 864 865 866 START_TEST(sDictSetT) 867 868 sDictt *o = NULL; 869 // elements 870 sBoolt *b = allocSBool(false); 871 sDictSetTiny(&o, "a", (smallt *) b); 872 b = allocSBool(true); 873 sDictSetTiny(&o, "a2", (smallt *) b); 874 b = allocSBool(true); 875 sDictSetTiny(&o, "a", (smallt *) b); 876 b = allocSBool(false); 877 sDictSetTiny(&o, "a2", (smallt *) b); 878 // set NULL (not changed) 879 sDictSetTiny(&o, "a", NULL); 880 b = (sBoolt *)sDictGet(o, "a"); 881 ck_assert(b->value); 882 b = (sBoolt *)sDictGet(o, "a2"); 883 ck_assert(!b->value); 884 sDictFreeTiny(o); 885 886 END_TEST 887 888 889 START_TEST(sDictPushT) 890 891 sDictt *o = NULL; 892 // elements 893 sBoolt *b = allocSBool(false); 894 sDictPushTiny(&o, "a", (smallt *) b); 895 b = allocSBool(true); 896 sDictPushTiny(&o, "a2", (smallt *) b); 897 b = allocSBool(true); 898 sDictPushTiny(&o, "a3", (smallt *) b); 899 b = allocSBool(true); 900 sDictPushTiny(&o, "a4", (smallt *) b); 901 b = allocSBool(true); 902 sDictPushTiny(&o, "aq", (smallt *) b); 903 b = allocSBool(true); 904 sDictPushTiny(&o, "aw", (smallt *) b); 905 b = allocSBool(true); 906 sDictPushTiny(&o, "ae", (smallt *) b); 907 b = allocSBool(true); 908 sDictPushTiny(&o, "ar", (smallt *) b); 909 b = allocSBool(true); 910 sDictPushTiny(&o, "at", (smallt *) b); 911 b = allocSBool(true); 912 sDictPushTiny(&o, "ay", (smallt *) b); 913 b = allocSBool(true); 914 sDictPushTiny(&o, "au", (smallt *) b); 915 sContainert *c = allocSContainer(strdup("sheepy")); 916 sDictPushTiny(&o, "c", (smallt *) c); 917 sStringt *s = allocSStringTiny(""); 918 sDictPushTiny(&o, "s", (smallt *) s); 919 // set NULL 920 sDictPushTiny(&o, "a", NULL); 921 b = (sBoolt *)sDictGet(o, "a"); 922 ck_assert_uint_eq(b->type, BOOL); 923 b = (sBoolt *)sDictGet(o, "au"); 924 ck_assert(b->value); 925 ck_assert_uint_eq(o->count, 13); 926 // TODO 16 depends on defines SDICT_REALLOC_STEPS and SDICT_MIN_ELEMENTS 927 ck_assert_uint_eq(o->maxCount, 16); 928 free(c->data); 929 sDictFreeTiny(o); 930 931 END_TEST 932 933 934 START_TEST(sDictDelT) 935 936 sDictt *o = NULL; 937 // elements 938 sBoolt *b = allocSBool(false); 939 sDictPushTiny(&o, "a", (smallt *) b); 940 sDictDelTiny(o, "a"); 941 b = (sBoolt *)sDictGet(o, "a"); 942 ck_assert_ptr_eq(b, NULL); 943 sDictFreeTiny(o); 944 945 END_TEST 946 947 948 START_TEST(sStringGetT) 949 950 sStringt *s = allocSStringTiny("qweqwe"); 951 char *S = sStringGetTiny(s); 952 ck_assert_str_eq(S, "qweqwe"); 953 free(s); 954 955 END_TEST 956 957 958 START_TEST(sStringSetT) 959 960 sStringt *s = allocSStringTiny("qweqwe"); 961 sStringSetTiny(&s, "sheepy"); 962 char *S = sStringGetTiny(s); 963 ck_assert_str_eq(S, "sheepy"); 964 free(s); 965 966 END_TEST 967 968 969 START_TEST(sArrayPushT) 970 971 sArrayt *a = allocSArray(); 972 sBoolt *b = allocSBool(false); 973 sArrayPushTiny(&a, (smallt *) b); 974 sDoublet *D = allocSDouble(10); 975 sArrayPushTiny(&a, (smallt *) D); 976 sStringt *s = allocSStringTiny("sheepy"); 977 sArrayPushTiny(&a, (smallt *) s); 978 sArrayPushTiny(&a, NULL); 979 sArrayPushTiny(&a, NULL); 980 ck_assert_uint_eq(a->count, 5); 981 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 982 ck_assert_uint_eq(a->maxCount, 8); 983 sArrayFreeTiny(a); 984 //NULL 985 a = NULL; 986 b = allocSBool(false); 987 sArrayPushTiny(&a, (smallt *) b); 988 sArrayFreeTiny(a); 989 990 END_TEST 991 992 993 START_TEST(sArrayPrependT) 994 995 sArrayt *a = allocSArray(); 996 sBoolt *b = allocSBool(false); 997 sArrayPrependTiny(&a, (smallt *) b); 998 sDoublet *D = allocSDouble(10); 999 sArrayPrependTiny(&a, (smallt *) D); 1000 sStringt *s = allocSStringTiny("sheepy"); 1001 sArrayPrependTiny(&a, (smallt *) s); 1002 sArrayPrependTiny(&a, NULL); 1003 sArrayPrependTiny(&a, NULL); 1004 ck_assert_uint_eq(a->count, 5); 1005 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1006 ck_assert_uint_eq(a->maxCount, 8); 1007 sArrayFreeTiny(a); 1008 //NULL 1009 a = NULL; 1010 b = allocSBool(false); 1011 sArrayPrependTiny(&a, (smallt *) b); 1012 sArrayFreeTiny(a); 1013 1014 END_TEST 1015 1016 1017 START_TEST(sArrayPopT) 1018 1019 char *S; 1020 sArrayt *a = allocSArray(); 1021 sBoolt *b = allocSBool(false); 1022 sArrayPushTiny(&a, (smallt *) b); 1023 sDoublet *D = allocSDouble(10); 1024 sArrayPushTiny(&a, (smallt *) D); 1025 sStringt *s = allocSStringTiny("sheepy"); 1026 sArrayPushTiny(&a, (smallt *) s); 1027 sArrayPushTiny(&a, NULL); 1028 sArrayPushTiny(&a, NULL); 1029 s = (sStringt *) sArrayPopTiny(a); 1030 ck_assert_ptr_eq(s, NULL); 1031 ck_assert_uint_eq(a->count, 4); 1032 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1033 ck_assert_uint_eq(a->maxCount, 8); 1034 s = (sStringt *) sArrayPopTiny(a); 1035 ck_assert_ptr_eq(s, NULL); 1036 ck_assert_uint_eq(a->count, 3); 1037 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1038 ck_assert_uint_eq(a->maxCount, 8); 1039 s = (sStringt *) sArrayPopTiny(a); 1040 S = sStringGetTiny(s); 1041 ck_assert_str_eq(S, "sheepy"); 1042 free(s); 1043 ck_assert_uint_eq(a->count, 2); 1044 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1045 ck_assert_uint_eq(a->maxCount, 8); 1046 D = (sDoublet *) sArrayPopTiny(a); 1047 ck_assert_uint_eq((uint32_t)D->value, 10); 1048 free(D); 1049 ck_assert_uint_eq(a->count, 1); 1050 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1051 ck_assert_uint_eq(a->maxCount, 8); 1052 b = (sBoolt *) sArrayPopTiny(a); 1053 ck_assert(!b->value); 1054 free(b); 1055 ck_assert_uint_eq(a->count, 0); 1056 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1057 ck_assert_uint_eq(a->maxCount, 8); 1058 sArrayFreeTiny(a); 1059 1060 END_TEST 1061 1062 1063 START_TEST(sArrayDequeueT) 1064 1065 char *S; 1066 sArrayt *a = allocSArray(); 1067 sBoolt *b = allocSBool(false); 1068 sArrayPrependTiny(&a, (smallt *) b); 1069 sDoublet *D = allocSDouble(10); 1070 sArrayPrependTiny(&a, (smallt *) D); 1071 sStringt *s = allocSStringTiny("sheepy"); 1072 sArrayPrependTiny(&a, (smallt *) s); 1073 sArrayPrependTiny(&a, NULL); 1074 sArrayPrependTiny(&a, NULL); 1075 s = (sStringt *) sArrayDequeueTiny(a); 1076 ck_assert_ptr_eq(s, NULL); 1077 ck_assert_uint_eq(a->count, 4); 1078 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1079 ck_assert_uint_eq(a->maxCount, 8); 1080 s = (sStringt *) sArrayDequeueTiny(a); 1081 ck_assert_ptr_eq(s, NULL); 1082 ck_assert_uint_eq(a->count, 3); 1083 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1084 ck_assert_uint_eq(a->maxCount, 8); 1085 s = (sStringt *) sArrayDequeueTiny(a); 1086 S = sStringGetTiny(s); 1087 ck_assert_str_eq(S, "sheepy"); 1088 free(s); 1089 ck_assert_uint_eq(a->count, 2); 1090 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1091 ck_assert_uint_eq(a->maxCount, 8); 1092 D = (sDoublet *) sArrayDequeueTiny(a); 1093 ck_assert_uint_eq((uint32_t)D->value, 10); 1094 free(D); 1095 ck_assert_uint_eq(a->count, 1); 1096 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1097 ck_assert_uint_eq(a->maxCount, 8); 1098 b = (sBoolt *) sArrayDequeueTiny(a); 1099 ck_assert(!b->value); 1100 free(b); 1101 ck_assert_uint_eq(a->count, 0); 1102 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1103 ck_assert_uint_eq(a->maxCount, 8); 1104 sArrayFreeTiny(a); 1105 1106 END_TEST 1107 1108 1109 START_TEST(sArrayGetT) 1110 1111 sArrayt *a = allocSArray(); 1112 sBoolt *b = allocSBool(false); 1113 sArrayPushTiny(&a, (smallt *) b); 1114 sDoublet *D = allocSDouble(10); 1115 sArrayPushTiny(&a, (smallt *) D); 1116 sStringt *s = allocSStringTiny("sheepy"); 1117 sArrayPushTiny(&a, (smallt *) s); 1118 sArrayPushTiny(&a, NULL); 1119 sArrayPushTiny(&a, NULL); 1120 b = (sBoolt *) sArrayGetTiny(a, 0); 1121 ck_assert(!b->value); 1122 ck_assert_uint_eq(a->count, 5); 1123 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1124 ck_assert_uint_eq(a->maxCount, 8); 1125 sArrayFreeTiny(a); 1126 1127 END_TEST 1128 1129 1130 START_TEST(sArrayGetPT) 1131 1132 sArrayt *a = allocSArray(); 1133 sBoolt *b = allocSBool(false); 1134 sArrayPushTiny(&a, (smallt *) b); 1135 sDoublet *D = allocSDouble(10); 1136 sArrayPushTiny(&a, (smallt *) D); 1137 sStringt *s = allocSStringTiny("sheepy"); 1138 sArrayPushTiny(&a, (smallt *) s); 1139 sArrayPushTiny(&a, NULL); 1140 sArrayPushTiny(&a, NULL); 1141 b = (sBoolt *) sArrayGetP(a, 0); 1142 ck_assert(!b->value); 1143 ck_assert_uint_eq(a->count, 5); 1144 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1145 ck_assert_uint_eq(a->maxCount, 8); 1146 sArrayFreeTiny(a); 1147 1148 END_TEST 1149 1150 1151 START_TEST(sArraySetPT) 1152 1153 sArrayt *a = allocSArray(); 1154 sBoolt *b = allocSBool(false); 1155 sArrayPushTiny(&a, (smallt *) b); 1156 sDoublet *D = allocSDouble(10); 1157 sArrayPushTiny(&a, (smallt *) D); 1158 sStringt *s = allocSStringTiny("sheepy"); 1159 sArrayPushTiny(&a, (smallt *) s); 1160 sArrayPushTiny(&a, NULL); 1161 sArrayPushTiny(&a, NULL); 1162 b = (sBoolt *) sArrayGetTiny(a, 0); 1163 sBoolt *b2 = allocSBool(true); 1164 sArraySetP(a, 0, (smallt *) b2); 1165 b2 = (sBoolt *) sArrayGetTiny(a, 0); 1166 ck_assert(!b->value); 1167 ck_assert(b2->value); 1168 sFree((smallt *) b); 1169 ck_assert_uint_eq(a->count, 5); 1170 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1171 ck_assert_uint_eq(a->maxCount, 8); 1172 sArrayFreeTiny(a); 1173 1174 END_TEST 1175 1176 1177 START_TEST(sArraySetT) 1178 1179 sArrayt *a = allocSArray(); 1180 sBoolt *b = allocSBool(false); 1181 sArrayPushTiny(&a, (smallt *) b); 1182 sDoublet *D = allocSDouble(10); 1183 sArrayPushTiny(&a, (smallt *) D); 1184 sStringt *s = allocSStringTiny("sheepy"); 1185 sArrayPushTiny(&a, (smallt *) s); 1186 sArrayPushTiny(&a, NULL); 1187 sArrayPushTiny(&a, NULL); 1188 b = (sBoolt *) sArrayGetTiny(a, 0); 1189 b = allocSBool(true); 1190 sArraySetTiny(a, 0, (smallt *) b); 1191 b = (sBoolt *) sArrayGetTiny(a, 0); 1192 ck_assert(b->value); 1193 ck_assert_uint_eq(a->count, 5); 1194 // TODO depends on defines SARRAY_REALLOC_STEPS and SARRAY_MIN_ELEMENTS 1195 ck_assert_uint_eq(a->maxCount, 8); 1196 sArrayFreeTiny(a); 1197 1198 END_TEST 1199 1200 1201 START_TEST(sArrayReverseT) 1202 1203 sArrayt *a = allocSArray(); 1204 sBoolt *b = allocSBool(false); 1205 sArrayPushTiny(&a, (smallt *) b); 1206 sDoublet *D = allocSDouble(10); 1207 sArrayPushTiny(&a, (smallt *) D); 1208 sStringt *s = allocSStringTiny("sheepy"); 1209 sArrayPushTiny(&a, (smallt *) s); 1210 sArrayPushTiny(&a, NULL); 1211 sArrayPushTiny(&a, NULL); 1212 int r = sArrayReverseTiny(a); 1213 ck_assert_int_ne(r,0); 1214 b = (sBoolt *) sArrayGetTiny(a, 4); 1215 ck_assert(!b->value); 1216 ck_assert_uint_eq(a->count, 5); 1217 sArrayFreeTiny(a); 1218 1219 END_TEST 1220 1221 1222 START_TEST(sArrayDelT) 1223 1224 sArrayt *a = allocSArray(); 1225 sBoolt *b = allocSBool(false); 1226 sArrayPushTiny(&a, (smallt *) b); 1227 sDoublet *D = allocSDouble(10); 1228 sArrayPushTiny(&a, (smallt *) D); 1229 sStringt *s = allocSStringTiny("sheepy"); 1230 sArrayPushTiny(&a, (smallt *) s); 1231 sArrayDelTiny(a, 0); 1232 b = (sBoolt *) sArrayGetTiny(a, 0); 1233 ck_assert_ptr_eq(b, NULL); 1234 sArrayFreeTiny(a); 1235 1236 END_TEST 1237 1238 START_TEST(sArrayDelRangeT) 1239 1240 sArrayt *a = allocSArray(); 1241 sBoolt *b = allocSBool(false); 1242 sArrayPushTiny(&a, (smallt *) b); 1243 sDoublet *D = allocSDouble(10); 1244 sArrayPushTiny(&a, (smallt *) D); 1245 sStringt *s = allocSStringTiny("sheepy"); 1246 sArrayPushTiny(&a, (smallt *) s); 1247 sArrayDelRangeTiny(a, 0,1); 1248 ck_assert_uint_eq(a->count, 2); 1249 D = (sDoublet *) sArrayGetTiny(a, 0); 1250 ck_assert_uint_eq((uint32_t)(D->value), 10); 1251 sArrayFreeTiny(a); 1252 1253 END_TEST 1254 1255 1256 1257 START_TEST(sBytesGetT) 1258 1259 char *T = "sheepy"; 1260 sBytest *B = allocSBytes(); 1261 sBytesPushBuffer(&B, T, strlen(T)+1); 1262 char *S = sBytesGet(B); 1263 ck_assert_str_eq(S, "sheepy"); 1264 free(B); 1265 1266 END_TEST 1267 1268 1269 START_TEST(sBytesPushT) 1270 1271 sBytest *B = allocSBytes(); 1272 sBytesPush(&B, 1); 1273 sBytesPush(&B, 2); 1274 sBytesPush(&B, 3); 1275 ck_assert_uint_eq(B->count, 3); 1276 free(B); 1277 //NULL 1278 B = NULL; 1279 sBytesPush(&B, 1); 1280 sBytesPush(&B, 2); 1281 sBytesPush(&B, 3); 1282 ck_assert_uint_eq(B->count, 3); 1283 free(B); 1284 1285 END_TEST 1286 1287 1288 START_TEST(sBytesPushBufferT) 1289 1290 char s[] = {1,2,3}; 1291 sBytest *B = NULL; 1292 sBytesPushBuffer(&B, s, 3); 1293 ck_assert_uint_eq(B->count, 3); 1294 char *S = sBytesToStringTiny(B); 1295 ck_assert_str_eq(S, "[0x01,0x02,0x03]"); 1296 free(S); 1297 // push to existing 1298 sBytesPushBuffer(&B, s, 3); 1299 ck_assert_uint_eq(B->count, 6); 1300 S = sBytesToStringTiny(B); 1301 ck_assert_str_eq(S, "[0x01,0x02,0x03,0x01,0x02,0x03]"); 1302 free(S); 1303 free(B); 1304 // null 1305 B = NULL; 1306 sBytesPushBuffer(&B, NULL, 3); 1307 ck_assert_uint_eq(B->count, 0); 1308 free(B); 1309 // size 0 1310 B = NULL; 1311 sBytesPushBuffer(&B, s, 0); 1312 ck_assert_uint_eq(B->count, 0); 1313 free(B); 1314 1315 END_TEST 1316 1317 1318 START_TEST(sSerialT) 1319 1320 char *S; 1321 1322 // dict 1323 sDictt *d = allocSDict(); 1324 sBytest *r = sSerial((smallt *) d); 1325 S = sBytesToStringTiny(r); 1326 ck_assert_str_eq(S, "[0x04,0x00,0x00,0x00,0x00]"); 1327 free(S); 1328 sDictFreeTiny(d); 1329 free(r); 1330 1331 // array 1332 sArrayt *a = allocSArray(); 1333 r = sSerial((smallt *) a); 1334 S = sBytesToStringTiny(r); 1335 ck_assert_str_eq(S, "[0x0a,0x00,0x00,0x00,0x00]"); 1336 free(S); 1337 sArrayFreeTiny(a); 1338 free(r); 1339 1340 // undefined 1341 sUndefinedt *u = allocSUndefined(); 1342 r = sSerial((smallt *) u); 1343 S = sBytesToStringTiny(r); 1344 ck_assert_str_eq(S, "[0x01]"); 1345 free(S); 1346 free(u); 1347 free(r); 1348 //NULL 1349 ck_assert_ptr_eq(sSerial(NULL), NULL); 1350 1351 END_TEST 1352 1353 1354 START_TEST(sDictSerialElementsT) 1355 1356 sBytest *r = NULL; 1357 sDictt *o = NULL; 1358 char *S; 1359 1360 // elements 1361 // bool 1362 sBoolt *b = allocSBool(true); 1363 sDictPushTiny(&o, "a", (smallt *) b); 1364 // undefined 1365 sUndefinedt *u = allocSUndefined(); 1366 sDictPushTiny(&o, "u", (smallt *) u); 1367 // container 1368 sContainert *c = allocSContainer(strdup("sheepy")); 1369 sDictPushTiny(&o, "c", (smallt *) c); 1370 free(c->data); 1371 // double 1372 sDoublet *D = allocSDouble(10); 1373 sDictPushTiny(&o, "d", (smallt *) D); 1374 // int 1375 sIntt *i = allocSInt(10); 1376 sDictPushTiny(&o, "i", (smallt *) i); 1377 // string 1378 sStringt *s = allocSStringTiny("sheepy"); 1379 sDictPushTiny(&o, "s", (smallt *) s); 1380 // bytes 1381 sBytest *B = allocSBytes(); 1382 sBytesPush(&B, 1); 1383 sBytesPush(&B, 2); 1384 sDictPushTiny(&o, "B", (smallt *) B); 1385 // dict 1386 sDictt *d = allocSDict(); 1387 b = allocSBool(true); 1388 sDictPushTiny(&d, "b", (smallt *) b); 1389 sDictPushTiny(&o, "D", (smallt *) d); 1390 // array 1391 sArrayt *a = allocSArray(); 1392 b = allocSBool(true); 1393 sArrayPushTiny(&a, (smallt *) b); 1394 sDictPushTiny(&o, "A", (smallt *) a); 1395 1396 sDictSerialElementsTiny(&r, o); 1397 /* printf ("final count %d\n", r->count); */ 1398 /* S = sToStringTiny((smallt *) o); */ 1399 /* printf("%d %s\n", (int)strlen(S), S); */ 1400 /* free(S); */ 1401 S = sBytesToStringTiny(r); 1402 /* // debug */ 1403 /* char *ref = "[4,9,0,0,0,97,0,2,1,117,0,1,99,0,3,100,0,6,0,0,0,0,0,0,36,64,105,0,7,10,0,0,0,0,0,0,0,115,0,8,115,104,101,101,112,121,0,66,0,11,2,0,0,0,1,2,68,0,4,1,0,0,0,98,0,2,1,65,0,10,1,0,0,0,2,1]"; */ 1404 /* printf("%d %d\n", (int)strlen(ref), (int)strlen(S)); */ 1405 /* puts(ref); */ 1406 /* puts(S); */ 1407 /* for (size_t i = 0; i < strlen(ref);i++) { */ 1408 /* if (i < strlen(S)) { */ 1409 /* if (ref[i] != S[i]) printf(">'%c' '%c' %d<", ref[i], S[i], (int)i); */ 1410 /* } else { */ 1411 /* printf(">%c X<", ref[i]); */ 1412 /* } */ 1413 /* } */ 1414 /* puts(""); */ 1415 ck_assert_str_eq(S, "[0x04,0x09,0x00,0x00,0x00,0x61,0x00,0x02,0x01,0x75,0x00,0x01,0x63,0x00,0x03,0x64,0x00,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x24,0x40,0x69,0x00,0x07,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x73,0x00,0x08,0x73,0x68,0x65,0x65,0x70,0x79,0x00,0x42,0x00,0x0b,0x02,0x00,0x00,0x00,0x01,0x02,0x44,0x00,0x04,0x01,0x00,0x00,0x00,0x62,0x00,0x02,0x01,0x41,0x00,0x0a,0x01,0x00,0x00,0x00,0x02,0x01]"); 1416 free(S); 1417 sDictFreeTiny(o); 1418 free(r); 1419 1420 END_TEST 1421 1422 1423 START_TEST(sArraySerialElementsT) 1424 1425 sBytest *r = NULL; 1426 sArrayt *o = NULL; 1427 char *S; 1428 1429 // elements 1430 // bool 1431 sBoolt *b = allocSBool(true); 1432 sArrayPushTiny(&o, (smallt *) b); 1433 // undefined 1434 sUndefinedt *u = allocSUndefined(); 1435 sArrayPushTiny(&o, (smallt *) u); 1436 // container 1437 sContainert *c = allocSContainer(strdup("sheepy")); 1438 sArrayPushTiny(&o, (smallt *) c); 1439 // double 1440 sDoublet *D = allocSDouble(10); 1441 sArrayPushTiny(&o, (smallt *) D); 1442 // int 1443 sIntt *i = allocSInt(10); 1444 sArrayPushTiny(&o, (smallt *) i); 1445 // string 1446 sStringt *s = allocSStringTiny("sheepy"); 1447 sArrayPushTiny(&o, (smallt *) s); 1448 // bytes 1449 sBytest *B = allocSBytes(); 1450 sBytesPush(&B, 1); 1451 sBytesPush(&B, 2); 1452 sArrayPushTiny(&o, (smallt *) B); 1453 // dict 1454 sDictt *d = allocSDict(); 1455 sArrayPushTiny(&o, (smallt *) d); 1456 // array 1457 sArrayt *a = allocSArray(); 1458 sArrayPushTiny(&o, (smallt *) a); 1459 1460 sArraySerialElementsTiny(&r, o); 1461 /* printf("final count %d\n", r->count); */ 1462 /* S = sToStringTiny((smallt *) o); */ 1463 /* printf("%d %s\n", (int)strlen(S), S); */ 1464 /* free(S); */ 1465 S = sBytesToStringTiny(r); 1466 ck_assert_str_eq(S, "[0x0a,0x09,0x00,0x00,0x00,0x02,0x01,0x01,0x03,0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x24,0x40,0x07,0x0a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x73,0x68,0x65,0x65,0x70,0x79,0x00,0x0b,0x02,0x00,0x00,0x00,0x01,0x02,0x04,0x00,0x00,0x00,0x00,0x0a,0x00,0x00,0x00,0x00]"); 1467 free(S); 1468 free(c->data); 1469 sArrayFreeTiny(o); 1470 free(r); 1471 // array with 1 NULL element 1472 r = NULL; 1473 o = allocSArray(); 1474 sArrayPushTiny(&o, NULL); 1475 sArraySerialElementsTiny(&r, o); 1476 S = sBytesToStringTiny(r); 1477 ck_assert_str_eq(S, "[0x0a,0x01,0x00,0x00,0x00,0x01]"); 1478 free(S); 1479 free(r); 1480 sArrayFreeTiny(o); 1481 1482 END_TEST 1483 1484 1485 START_TEST(sDeserialT) 1486 sBytest *r = NULL; 1487 char *S; 1488 1489 // undefined 1490 sUndefinedt *u = allocSUndefined(); 1491 r = sSerialTiny((smallt *) u); 1492 free(u); 1493 u = (sUndefinedt *) sDeserial(r); 1494 free(r); 1495 S = sToStringTiny((smallt *) u); 1496 //printf("%s\n", S); 1497 ck_assert_str_eq(S, "null"); 1498 free(S); 1499 free(u); 1500 1501 // bool 1502 sBoolt *b = allocSBool(true); 1503 r = sSerialTiny((smallt *) b); 1504 free(b); 1505 b = (sBoolt *) sDeserial(r); 1506 free(r); 1507 S = sToStringTiny((smallt *) b); 1508 //printf("%s\n", S); 1509 ck_assert_str_eq(S, "true"); 1510 free(S); 1511 free(b); 1512 // container 1513 sContainert *c = allocSContainer(strdup("sheepy")); 1514 r = sSerialTiny((smallt *) c); 1515 free(c->data); 1516 free(c); 1517 c = (sContainert *) sDeserial(r); 1518 free(r); 1519 S = sToStringTiny((smallt *) c); 1520 //printf("%s\n", S); 1521 ck_assert_str_eq(S, "<data container>"); 1522 free(S); 1523 free(c); 1524 // double 1525 sDoublet *D = allocSDouble(10); 1526 r = sSerialTiny((smallt *) D); 1527 free(D); 1528 D = (sDoublet *) sDeserial(r); 1529 free(r); 1530 S = sToStringTiny((smallt *) D); 1531 //printf("%s\n", S); 1532 ck_assert_str_eq(S, "1.000000e+01"); 1533 free(S); 1534 free(D); 1535 // int 1536 sIntt *i = allocSInt(10); 1537 r = sSerialTiny((smallt *) i); 1538 free(i); 1539 i = (sIntt *) sDeserial(r); 1540 free(r); 1541 S = sToStringTiny((smallt *) i); 1542 //printf("%s\n", S); 1543 ck_assert_str_eq(S, "10"); 1544 free(S); 1545 free(i); 1546 // string 1547 sStringt *s = allocSStringTiny("sheepy"); 1548 r = sSerialTiny((smallt *) s); 1549 free(s); 1550 s = (sStringt *) sDeserial(r); 1551 free(r); 1552 S = sToStringTiny((smallt *) s); 1553 //printf("%s\n", S); 1554 ck_assert_str_eq(S, "sheepy"); 1555 free(S); 1556 free(s); 1557 // bytes 1558 sBytest *B = allocSBytes(); 1559 sBytesPush(&B, 1); 1560 sBytesPush(&B, 2); 1561 r = sSerialTiny((smallt *) B); 1562 free(B); 1563 B = (sBytest *) sDeserial(r); 1564 free(r); 1565 S = sToStringTiny((smallt *) B); 1566 //printf("%s\n", S); 1567 ck_assert_str_eq(S, "[0x01,0x02]"); 1568 free(S); 1569 free(B); 1570 //empty sBytes 1571 B = allocSBytes(); 1572 ck_assert_ptr_eq(sDeserial(B), NULL); 1573 free(B); 1574 //NULL 1575 ck_assert_ptr_eq(sDeserial(NULL), NULL); 1576 1577 1578 END_TEST 1579 1580 1581 START_TEST(sDictDeserialElementsT) 1582 sBytest *r = NULL; 1583 sDictt *o = NULL; 1584 char *S; 1585 1586 // elements 1587 // bool 1588 sBoolt *b = allocSBool(true); 1589 sDictPushTiny(&o, "a", (smallt *) b); 1590 // undefined 1591 sUndefinedt *u = allocSUndefined(); 1592 sDictPushTiny(&o, "u", (smallt *) u); 1593 // container 1594 sContainert *c = allocSContainer(strdup("sheepy")); 1595 sDictPushTiny(&o, "c", (smallt *) c); 1596 free(c->data); 1597 // double 1598 sDoublet *D = allocSDouble(10); 1599 sDictPushTiny(&o, "d", (smallt *) D); 1600 // int 1601 sIntt *i = allocSInt(10); 1602 sDictPushTiny(&o, "i", (smallt *) i); 1603 // string 1604 sStringt *s = allocSStringTiny("sheepy"); 1605 sDictPushTiny(&o, "s", (smallt *) s); 1606 // bytes 1607 sBytest *B = allocSBytes(); 1608 sBytesPush(&B, 1); 1609 sBytesPush(&B, 2); 1610 sDictPushTiny(&o, "B", (smallt *) B); 1611 // dict 1612 sDictt *d = allocSDict(); 1613 b = allocSBool(true); 1614 sDictPushTiny(&d, "b", (smallt *) b); 1615 sDictPushTiny(&o, "D", (smallt *) d); 1616 // array 1617 sArrayt *a = allocSArray(); 1618 b = allocSBool(true); 1619 sArrayPushTiny(&a, (smallt *) b); 1620 sDictPushTiny(&o, "A", (smallt *) a); 1621 sDictSerialElementsTiny(&r, o); 1622 sDictFreeTiny(o); 1623 /* S = sToStringTiny((smallt *) r); */ 1624 /* printf("%d %s\n", (int)strlen(S), S); */ 1625 /* free(S); */ 1626 o = (sDictt *) sDeserialTiny(r); 1627 S = sToStringTiny((smallt *) o); 1628 ck_assert_str_eq(S, "{\"a\":true,\"u\":null,\"c\":\"<data container>\",\"d\":1.000000e+01,\"i\":10,\"s\":\"sheepy\",\"B\":[0x01,0x02],\"D\":{\"b\":true},\"A\":[true]}"); 1629 free(S); 1630 sDictFreeTiny(o); 1631 free(r); 1632 1633 END_TEST 1634 1635 1636 START_TEST(sArrayDeserialElementsT) 1637 1638 sBytest *src = NULL; 1639 sArrayt *r = NULL; 1640 sUndefinedt *u; 1641 char *S; 1642 1643 // empty array 1644 r = allocSArray(); 1645 sArraySerialElementsTiny(&src, r); 1646 sArrayFreeTiny(r); 1647 r = (sArrayt *) sDeserialTiny(src); 1648 S = sToStringTiny((smallt *) r); 1649 ck_assert_str_eq(S, "[]"); 1650 free(S); 1651 sArrayFreeTiny(r); 1652 free(src); 1653 // array 1654 src = NULL; 1655 r = NULL; 1656 // undefined 1657 u = allocSUndefined(); 1658 sArrayPushTiny(&r, (smallt *) u); 1659 // bool 1660 sBoolt *b = allocSBool(true); 1661 sArrayPushTiny(&r, (smallt *) b); 1662 // container 1663 sContainert *c = allocSContainer(strdup("sheepy")); 1664 sArrayPushTiny(&r, (smallt *) c); 1665 free(c->data); 1666 // double 1667 sDoublet *D = allocSDouble(10); 1668 sArrayPushTiny(&r, (smallt *) D); 1669 // int 1670 sIntt *i = allocSInt(10); 1671 sArrayPushTiny(&r, (smallt *) i); 1672 // string 1673 sStringt *s = allocSStringTiny("sheepy"); 1674 sArrayPushTiny(&r, (smallt *) s); 1675 // bytes 1676 sBytest *B = allocSBytes(); 1677 sBytesPush(&B, 1); 1678 sBytesPush(&B, 2); 1679 sArrayPushTiny(&r, (smallt *) B); 1680 // dict 1681 sDictt *d = allocSDict(); 1682 sArrayPushTiny(&r, (smallt *) d); 1683 // array 1684 sArrayt *a = allocSArray(); 1685 sArrayPushTiny(&r, (smallt *) a); 1686 1687 sArraySerialElementsTiny(&src, r); 1688 sArrayFreeTiny(r); 1689 /* S = sToStringTiny((smallt *) src); */ 1690 /* printf("%d %s\n", (int)strlen(S), S); */ 1691 /* free(S); */ 1692 r = (sArrayt *) sDeserialTiny(src); 1693 S = sToStringTiny((smallt *) r); 1694 //printf("%s\n", S); 1695 ck_assert_str_eq(S, "[null,true,\"<data container>\",1.000000e+01,10,\"sheepy\",[0x01,0x02],{},[]]"); 1696 free(S); 1697 sArrayFreeTiny(r); 1698 free(src); 1699 1700 END_TEST 1701 1702 1703 1704 Suite * libsheepySuite(void) { 1705 Suite *s; 1706 TCase *tc_core; 1707 1708 s = suite_create("libsheepySmall"); 1709 1710 /* Core test case */ 1711 tc_core = tcase_create("Small"); 1712 1713 1714 tcase_add_test(tc_core, isSTypeFT); 1715 tcase_add_test(tc_core, sSizeT); 1716 tcase_add_test(tc_core, allocSBoolT); 1717 tcase_add_test(tc_core, allocSContainerT); 1718 tcase_add_test(tc_core, allocSDictT); 1719 tcase_add_test(tc_core, allocSDoubleT); 1720 tcase_add_test(tc_core, allocSIntT); 1721 tcase_add_test(tc_core, allocSStringT); 1722 tcase_add_test(tc_core, allocSArrayT); 1723 tcase_add_test(tc_core, allocSUndefinedT); 1724 tcase_add_test(tc_core, allocSBytesT); 1725 tcase_add_test(tc_core, sFreeT); 1726 tcase_add_test(tc_core, sDictFreeT); 1727 tcase_add_test(tc_core, sArrayFreeT); 1728 tcase_add_test(tc_core, sDuplicateT); 1729 tcase_add_test(tc_core, sDictDuplicateT); 1730 tcase_add_test(tc_core, sArrayDuplicateT); 1731 tcase_add_test(tc_core, sBoolToStringT); 1732 tcase_add_test(tc_core, sContainerToStringT); 1733 tcase_add_test(tc_core, sDictToStringT); 1734 tcase_add_test(tc_core, sDoubleToStringT); 1735 tcase_add_test(tc_core, sIntToStringT); 1736 tcase_add_test(tc_core, sStringToStringT); 1737 tcase_add_test(tc_core, sArrayToStringT); 1738 tcase_add_test(tc_core, sUndefinedToStringT); 1739 tcase_add_test(tc_core, sBytesToStringT); 1740 tcase_add_test(tc_core, sToStringT); 1741 tcase_add_test(tc_core, sTypesT); 1742 tcase_add_test(tc_core, sTypesToBytesT); 1743 tcase_add_test(tc_core, sDictTypeStringsT); 1744 tcase_add_test(tc_core, sDictTypesT); 1745 tcase_add_test(tc_core, sArrayTypeStringsT); 1746 tcase_add_test(tc_core, sArrayTypesT); 1747 tcase_add_test(tc_core, sDictGetT); 1748 tcase_add_test(tc_core, sDictGetPT); 1749 tcase_add_test(tc_core, sDictSetPT); 1750 tcase_add_test(tc_core, sDictSetT); 1751 tcase_add_test(tc_core, sDictPushT); 1752 tcase_add_test(tc_core, sDictDelT); 1753 tcase_add_test(tc_core, sStringGetT); 1754 tcase_add_test(tc_core, sStringSetT); 1755 tcase_add_test(tc_core, sArrayPushT); 1756 tcase_add_test(tc_core, sArrayPrependT); 1757 tcase_add_test(tc_core, sArrayPopT); 1758 tcase_add_test(tc_core, sArrayDequeueT); 1759 tcase_add_test(tc_core, sArrayGetT); 1760 tcase_add_test(tc_core, sArrayGetPT); 1761 tcase_add_test(tc_core, sArraySetPT); 1762 tcase_add_test(tc_core, sArraySetT); 1763 tcase_add_test(tc_core, sArrayReverseT); 1764 tcase_add_test(tc_core, sArrayDelT); 1765 tcase_add_test(tc_core, sArrayDelRangeT); 1766 tcase_add_test(tc_core, sBytesGetT); 1767 tcase_add_test(tc_core, sBytesPushT); 1768 tcase_add_test(tc_core, sBytesPushBufferT); 1769 tcase_add_test(tc_core, sSerialT); 1770 tcase_add_test(tc_core, sDictSerialElementsT); 1771 tcase_add_test(tc_core, sArraySerialElementsT); 1772 tcase_add_test(tc_core, sDeserialT); 1773 tcase_add_test(tc_core, sDictDeserialElementsT); 1774 tcase_add_test(tc_core, sArrayDeserialElementsT); 1775 1776 1777 suite_add_tcase(s, tc_core); 1778 1779 return s; 1780 } 1781 1782 int main(int ARGC UNUSED, char** ARGV UNUSED) { 1783 int number_failed; 1784 Suite *s; 1785 SRunner *sr; 1786 1787 s = libsheepySuite(); 1788 sr = srunner_create(s); 1789 1790 srunner_run_all(sr, CK_NORMAL); 1791 number_failed = srunner_ntests_failed(sr); 1792 srunner_free(sr); 1793 1794 exit((number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE); 1795 }