libsheepyCSmallArrayTest.c (719081B)
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(allocArraySmallArrayT) 20 21 smallArrayt* r; 22 char *array[] = {"a", "bb", NULL}; 23 24 r = allocArraySmallArray(array); 25 ck_assert_ptr_ne(r, NULL); 26 char *s = toStringO(r); 27 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 28 free(s); 29 30 terminateO(r); 31 32 END_TEST 33 34 35 START_TEST(allocCArraySmallArrayT) 36 37 smallArrayt* r; 38 const char *array[] = {"a", "bb", NULL}; 39 40 r = allocCArraySmallArray(array); 41 ck_assert_ptr_ne(r, NULL); 42 char *s = toStringO(r); 43 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 44 free(s); 45 46 terminateO(r); 47 48 END_TEST 49 50 51 START_TEST(createSAFT) 52 53 smallArrayt* r; 54 55 r = createSA("a", "bb"); 56 ck_assert_ptr_ne(r, NULL); 57 char *s = toStringO(r); 58 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 59 free(s); 60 61 terminateO(r); 62 63 64 END_TEST 65 66 67 START_TEST(getsoSmallArrayT) 68 69 sArrayt* r; 70 smallArrayt *self = allocG(rtSmallArrayt); 71 72 pushG(self, 1); 73 r = getsoO(self); 74 ck_assert_ptr_eq(r, self->a); 75 terminateO(self); 76 77 END_TEST 78 79 80 START_TEST(setsoSmallArrayT) 81 82 smallArrayt *self = allocG(rtSmallArrayt); 83 sArrayt *so; 84 85 createSmallArray(a); 86 87 pushG(&a, 1); 88 pushG(&a, 2); 89 90 char *as = null; 91 // reset test: free iterElement in a 92 iter(&a, E) { 93 as = toStringO(E); 94 break; 95 } 96 ck_assert_str_eq(as, "1"); 97 free(as); 98 99 so = getsoO(&a); 100 resetO(&a); 101 102 setsoO(self, so); 103 ck_assert_ptr_eq(so, self->a); 104 terminateO(self); 105 106 END_TEST 107 108 109 START_TEST(mirrorSmallArrayT) 110 111 smallArrayt* r; 112 smallArrayt *self = allocG(rtSmallArrayt); 113 114 // empty self 115 r = mirrorO(self); 116 ck_assert_ptr_eq(r->a, null); 117 finishO(r); 118 119 // non empty with iterator 120 pushG(self, 1); 121 pushG(self, 2); 122 char *as = null; 123 iter(self, E) { 124 as = toStringO(E); 125 break; 126 } 127 ck_assert_str_eq(as, "1"); 128 free(as); 129 r = mirrorO(self); 130 ck_assert_ptr_eq(r->a, self->a); 131 finishO(r); 132 133 terminateO(self); 134 135 END_TEST 136 137 138 START_TEST(fromArrayNFreeSmallArrayT) 139 140 smallArrayt* r; 141 smallArrayt *self = allocG(rtSmallArrayt); 142 char **array; 143 size_t size = 3; 144 145 // libsheepy list 146 array = listCreateS("a", "bb", "ccc"); 147 r = fromArrayNFreeO(self, array, 0); 148 ck_assert_ptr_eq(self, r); 149 char *s = toStringO(r); 150 ck_assert_str_eq(s, "[\"a\",\"bb\",\"ccc\"]"); 151 free(s); 152 153 // array with strings 154 array = allocArray(array, size); 155 array[0] = strdup("a1"); 156 array[1] = strdup("bb1"); 157 array[2] = strdup("ccc1"); 158 r = fromArrayNFreeO(self, array, size); 159 ck_assert_ptr_eq(self, r); 160 s = toStringO(r); 161 ck_assert_str_eq(s, "[\"a1\",\"bb1\",\"ccc1\"]"); 162 free(s); 163 164 // NULL array 165 r = fromArrayNFreeO(self, null, 1); 166 ck_assert_ptr_eq(r, null); 167 terminateO(self); 168 169 END_TEST 170 171 172 START_TEST(pushUndefinedSmallArrayT) 173 174 smallArrayt* r; 175 smallArrayt *self = allocG(rtSmallArrayt); 176 177 // add an element to check that push adds the second element 178 // at the end 179 r = self->f->pushInt(self, 1); 180 ck_assert_ptr_ne(r, null); 181 182 r = self->f->pushUndefined(self); 183 ck_assert_ptr_ne(r, null); 184 ck_assert_int_eq(lenO(r), 2); 185 char *s = toStringO(r); 186 ck_assert_str_eq(s, "[1,null]"); 187 free(s); 188 terminateO(self); 189 190 END_TEST 191 192 193 START_TEST(pushBoolSmallArrayT) 194 195 smallArrayt* r; 196 smallArrayt *self = allocG(rtSmallArrayt); 197 198 // add an element to check that push adds the second element 199 // at the end 200 r = self->f->pushInt(self, 1); 201 ck_assert_ptr_ne(r, null); 202 203 r = self->f->pushBool(self, TRUE); 204 ck_assert_ptr_ne(r, null); 205 ck_assert_int_eq(lenO(r), 2); 206 char *s = toStringO(r); 207 ck_assert_str_eq(s, "[1,true]"); 208 free(s); 209 terminateO(self); 210 211 END_TEST 212 213 214 START_TEST(pushDoubleSmallArrayT) 215 216 smallArrayt* r; 217 smallArrayt *self = allocG(rtSmallArrayt); 218 219 // add an element to check that push adds the second element 220 // at the end 221 r = self->f->pushInt(self, 1); 222 ck_assert_ptr_ne(r, null); 223 224 r = self->f->pushDouble(self, 1.0); 225 ck_assert_ptr_ne(r, null); 226 ck_assert_int_eq(lenO(r), 2); 227 char *s = toStringO(r); 228 ck_assert_str_eq(s, "[1,1.000000e+00]"); 229 free(s); 230 terminateO(self); 231 232 END_TEST 233 234 235 START_TEST(pushIntSmallArrayT) 236 237 smallArrayt* r; 238 smallArrayt *self = allocG(rtSmallArrayt); 239 240 // add an element to check that push adds the second element 241 // at the end 242 r = self->f->pushInt(self, 1); 243 ck_assert_ptr_ne(r, null); 244 245 r = self->f->pushInt(self, 1); 246 ck_assert_ptr_ne(r, null); 247 ck_assert_int_eq(lenO(r), 2); 248 char *s = toStringO(r); 249 ck_assert_str_eq(s, "[1,1]"); 250 free(s); 251 terminateO(self); 252 253 END_TEST 254 255 256 START_TEST(pushSSmallArrayT) 257 258 smallArrayt* r; 259 smallArrayt *self = allocG(rtSmallArrayt); 260 261 // add an element to check that push adds the second element 262 // at the end 263 r = self->f->pushInt(self, 1); 264 ck_assert_ptr_ne(r, null); 265 266 r = self->f->pushS(self, null); 267 ck_assert_ptr_eq(r, null); 268 ck_assert_int_eq(lenO(self), 1); 269 char *s = toStringO(self); 270 ck_assert_str_eq(s, "[1]"); 271 free(s); 272 273 char *str = "poi"; 274 r = self->f->pushS(self, str); 275 ck_assert_ptr_ne(r, null); 276 ck_assert_int_eq(lenO(self), 2); 277 s = toStringO(r); 278 ck_assert_str_eq(s, "[1,\"poi\"]"); 279 free(s); 280 281 terminateO(self); 282 283 END_TEST 284 285 286 START_TEST(pushCharSmallArrayT) 287 288 smallArrayt* r; 289 smallArrayt *self = allocG(rtSmallArrayt); 290 291 // add an element to check that push adds the second element 292 // at the end 293 r = self->f->pushInt(self, 1); 294 ck_assert_ptr_ne(r, null); 295 296 r = self->f->pushChar(self, 'a'); 297 ck_assert_ptr_ne(r, null); 298 ck_assert_int_eq(lenO(r), 2); 299 char *s = toStringO(r); 300 ck_assert_str_eq(s, "[1,\"a\"]"); 301 free(s); 302 terminateO(self); 303 304 END_TEST 305 306 307 START_TEST(pushDictSmallArrayT) 308 309 smallArrayt* r; 310 smallArrayt *self = allocG(rtSmallArrayt); 311 smallDictt *dict = allocG(rtSmallDictt); 312 313 // add an element to check that push adds the second element 314 // at the end 315 r = self->f->pushInt(self, 1); 316 ck_assert_ptr_ne(r, null); 317 318 // push dict 319 r = self->f->pushDict(self, dict); 320 ck_assert_ptr_ne(r, null); 321 ck_assert_int_eq(lenO(r), 2); 322 finishO(dict); 323 ck_assert_ptr_ne(r, null); 324 char *s = toStringO(r); 325 ck_assert_str_eq(s, "[1,{}]"); 326 free(s); 327 // non smallDict object 328 dict = (smallDictt*) allocSmallInt(2); 329 r = self->f->pushDict(self, dict); 330 ck_assert_ptr_eq(r, null); 331 terminateO(dict); 332 // null 333 r = self->f->pushDict(self, null); 334 ck_assert_ptr_eq(r, null); 335 ck_assert_int_eq(lenO(self), 2); 336 s = toStringO(self); 337 ck_assert_str_eq(s, "[1,{}]"); 338 free(s); 339 terminateO(self); 340 341 END_TEST 342 343 344 START_TEST(pushArraySmallArrayT) 345 346 smallArrayt* r; 347 smallArrayt *self = allocG(rtSmallArrayt); 348 smallArrayt *array = allocG(rtSmallArrayt); 349 350 // add an element to check that push adds the second element 351 // at the end 352 r = self->f->pushInt(self, 1); 353 ck_assert_ptr_ne(r, null); 354 355 r = self->f->pushArray(self, array); 356 ck_assert_ptr_ne(r, null); 357 ck_assert_int_eq(lenO(r), 2); 358 finishO(array); 359 char *s = toStringO(r); 360 ck_assert_str_eq(s, "[1,[]]"); 361 free(s); 362 // non smallArray object 363 array = (smallArrayt*) allocSmallInt(2); 364 r = self->f->pushArray(self, array); 365 ck_assert_ptr_eq(r, null); 366 terminateO(array); 367 // null 368 r = self->f->pushArray(self, null); 369 ck_assert_ptr_eq(r, null); 370 ck_assert_int_eq(lenO(self), 2); 371 s = toStringO(self); 372 ck_assert_str_eq(s, "[1,[]]"); 373 free(s); 374 terminateO(self); 375 376 END_TEST 377 378 379 START_TEST(pushArraycSmallArrayT) 380 381 smallArrayt* r; 382 smallArrayt *self = allocG(rtSmallArrayt); 383 char **array = listCreateS("a","bb"); 384 385 // add an element to check that push adds the second element 386 // at the end 387 r = self->f->pushInt(self, 1); 388 ck_assert_ptr_ne(r, null); 389 390 r = self->f->pushArrayc(self, array); 391 ck_assert_ptr_ne(r, null); 392 ck_assert_int_eq(lenO(r), 2); 393 listFreeS(array); 394 char *s = toStringO(r); 395 ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]"); 396 free(s); 397 // null 398 r = self->f->pushArrayc(self, null); 399 ck_assert_ptr_eq(r, null); 400 ck_assert_int_eq(lenO(self), 2); 401 s = toStringO(self); 402 ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]"); 403 free(s); 404 terminateO(self); 405 406 END_TEST 407 408 409 START_TEST(pushSmallBoolSmallArrayT) 410 411 smallArrayt* r; 412 smallArrayt *self = allocG(rtSmallArrayt); 413 smallBoolt *value = allocG(TRUE); 414 415 // add an element to check that push adds the second element 416 // at the end 417 r = self->f->pushInt(self, 1); 418 ck_assert_ptr_ne(r, null); 419 420 r = self->f->pushSmallBool(self, value); 421 ck_assert_ptr_ne(r, null); 422 ck_assert_int_eq(lenO(r), 2); 423 finishO(value); 424 char *s = toStringO(r); 425 ck_assert_str_eq(s, "[1,true]"); 426 free(s); 427 // non smallBool object 428 value = (smallBoolt*) allocSmallInt(2); 429 r = self->f->pushSmallBool(self, value); 430 ck_assert_ptr_eq(r, null); 431 terminateO(value); 432 // bool object with no data 433 createAllocateSmallBool(b); 434 r = self->f->pushSmallBool(self, b); 435 ck_assert_ptr_ne(r, null); 436 ck_assert_int_eq(lenO(r), 3); 437 finishO(b); 438 s = toStringO(r); 439 ck_assert_str_eq(s, "[1,true,false]"); 440 free(s); 441 // null 442 r = self->f->pushSmallBool(self, null); 443 ck_assert_ptr_eq(r, null); 444 ck_assert_int_eq(lenO(self), 3); 445 s = toStringO(self); 446 ck_assert_str_eq(s, "[1,true,false]"); 447 free(s); 448 terminateO(self); 449 450 END_TEST 451 452 453 START_TEST(pushSmallBytesSmallArrayT) 454 455 smallArrayt* r; 456 smallArrayt *self = allocG(rtSmallArrayt); 457 createAllocateSmallBytes(value); 458 459 // add an element to check that push adds the second element 460 // at the end 461 r = self->f->pushInt(self, 1); 462 ck_assert_ptr_ne(r, null); 463 // the smallBytes container is empty 464 r = self->f->pushSmallBytes(self, value); 465 ck_assert_ptr_ne(r, null); 466 ck_assert_int_eq(lenO(r), 2); 467 char *s = toStringO(r); 468 ck_assert_str_eq(s, "[1,[]]"); 469 free(s); 470 // reuse value 471 value->B = null; 472 char *buffer = "poi"; 473 pushBufferO(value, buffer, strlen(buffer)); 474 r = self->f->pushSmallBytes(self, value); 475 finishO(value); 476 ck_assert_ptr_ne(r, null); 477 ck_assert_int_eq(lenO(r), 3); 478 s = toStringO(r); 479 ck_assert_str_eq(s, "[1,[],[0x70,0x6f,0x69]]"); 480 free(s); 481 // non smallBytes object 482 value = (smallBytest*) allocSmallInt(2); 483 r = self->f->pushSmallBytes(self, value); 484 ck_assert_ptr_eq(r, null); 485 terminateO(value); 486 // null 487 r = self->f->pushSmallBytes(self, null); 488 ck_assert_ptr_eq(r, null); 489 ck_assert_int_eq(lenO(self), 3); 490 s = toStringO(self); 491 ck_assert_str_eq(s, "[1,[],[0x70,0x6f,0x69]]"); 492 free(s); 493 terminateO(self); 494 495 END_TEST 496 497 498 START_TEST(pushSmallDoubleSmallArrayT) 499 500 smallArrayt* r; 501 smallArrayt *self = allocG(rtSmallArrayt); 502 smallDoublet *value = allocG(1.0); 503 504 // add an element to check that push adds the second element 505 // at the end 506 r = self->f->pushInt(self, 1); 507 ck_assert_ptr_ne(r, null); 508 509 r = self->f->pushSmallDouble(self, value); 510 ck_assert_ptr_ne(r, null); 511 ck_assert_int_eq(lenO(r), 2); 512 finishO(value); 513 char *s = toStringO(r); 514 ck_assert_str_eq(s, "[1,1.000000e+00]"); 515 free(s); 516 // object with no data 517 createAllocateSmallDouble(b); 518 r = self->f->pushSmallDouble(self, b); 519 ck_assert_ptr_ne(r, null); 520 ck_assert_int_eq(lenO(r), 3); 521 finishO(b); 522 s = toStringO(r); 523 ck_assert_str_eq(s, "[1,1.000000e+00,0.000000e+00]"); 524 free(s); 525 // non smallDouble object 526 value = (smallDoublet*) allocSmallInt(2); 527 r = self->f->pushSmallDouble(self, value); 528 ck_assert_ptr_eq(r, null); 529 terminateO(value); 530 // null 531 r = self->f->pushSmallDouble(self, null); 532 ck_assert_ptr_eq(r, null); 533 ck_assert_int_eq(lenO(self), 3); 534 s = toStringO(self); 535 ck_assert_str_eq(s, "[1,1.000000e+00,0.000000e+00]"); 536 free(s); 537 terminateO(self); 538 539 END_TEST 540 541 542 START_TEST(pushSmallIntSmallArrayT) 543 544 smallArrayt* r; 545 smallArrayt *self = allocG(rtSmallArrayt); 546 smallIntt *value = allocG(1); 547 548 // add an element to check that push adds the second element 549 // at the end 550 r = self->f->pushInt(self, 1); 551 ck_assert_ptr_ne(r, null); 552 553 r = self->f->pushSmallInt(self, value); 554 ck_assert_ptr_ne(r, null); 555 ck_assert_int_eq(lenO(r), 2); 556 finishO(value); 557 char *s = toStringO(r); 558 ck_assert_str_eq(s, "[1,1]"); 559 free(s); 560 // int object with no data 561 createAllocateSmallInt(b); 562 r = self->f->pushSmallInt(self, b); 563 ck_assert_ptr_ne(r, null); 564 ck_assert_int_eq(lenO(r), 3); 565 finishO(b); 566 s = toStringO(r); 567 ck_assert_str_eq(s, "[1,1,0]"); 568 free(s); 569 // non smallInt object 570 value = (smallIntt*) allocSmallBool(true); 571 r = self->f->pushSmallInt(self, value); 572 ck_assert_ptr_eq(r, null); 573 terminateO(value); 574 // null 575 r = self->f->pushSmallInt(self, null); 576 ck_assert_ptr_eq(r, null); 577 ck_assert_int_eq(lenO(self), 3); 578 s = toStringO(self); 579 ck_assert_str_eq(s, "[1,1,0]"); 580 free(s); 581 terminateO(self); 582 583 END_TEST 584 585 586 START_TEST(pushSmallJsonSmallArrayT) 587 588 smallArrayt* r; 589 smallArrayt *self = allocG(rtSmallArrayt); 590 smallJsont *value = allocG(rtSmallJsont); 591 592 // add an element to check that push adds the second element 593 // at the end 594 r = self->f->pushInt(self, 1); 595 ck_assert_ptr_ne(r, null); 596 597 // the smallJson container is empty 598 r = self->f->pushSmallJson(self, value); 599 ck_assert_ptr_ne(r, null); 600 ck_assert_int_eq(lenO(r), 2); 601 char *s = toStringO(r); 602 ck_assert_str_eq(s, "[1,{}]"); 603 free(s); 604 resetO(value); 605 parseO(value, "{}"); 606 r = self->f->pushSmallJson(self, value); 607 finishO(value); 608 ck_assert_ptr_ne(r, null); 609 ck_assert_int_eq(lenO(r), 3); 610 s = toStringO(r); 611 ck_assert_str_eq(s, "[1,{},{}]"); 612 free(s); 613 // non smallJson object 614 value = (smallJsont*) allocSmallInt(2); 615 r = self->f->pushSmallJson(self, value); 616 ck_assert_ptr_eq(r, null); 617 terminateO(value); 618 // null 619 r = self->f->pushSmallJson(self, null); 620 ck_assert_ptr_eq(r, null); 621 ck_assert_int_eq(lenO(self), 3); 622 s = toStringO(self); 623 ck_assert_str_eq(s, "[1,{},{}]"); 624 free(s); 625 terminateO(self); 626 627 END_TEST 628 629 630 START_TEST(pushSmallStringSmallArrayT) 631 632 smallArrayt* r; 633 smallArrayt *self = allocG(rtSmallArrayt); 634 createAllocateSmallString(string); 635 636 // add an element to check that push adds the second element 637 // at the end 638 r = self->f->pushInt(self, 1); 639 ck_assert_ptr_ne(r, null); 640 641 r = self->f->pushSmallString(self, string); 642 ck_assert_ptr_ne(r, null); 643 ck_assert_int_eq(lenO(r), 2); 644 finishO(string); 645 char *s = toStringO(r); 646 ck_assert_str_eq(s, "[1,\"\"]"); 647 free(s); 648 // non smallString object 649 string = (smallStringt*) allocSmallInt(2); 650 r = self->f->pushSmallString(self, string); 651 ck_assert_ptr_eq(r, null); 652 terminateO(string); 653 // null 654 r = self->f->pushSmallString(self, null); 655 ck_assert_ptr_eq(r, null); 656 ck_assert_int_eq(lenO(self), 2); 657 s = toStringO(self); 658 ck_assert_str_eq(s, "[1,\"\"]"); 659 free(s); 660 terminateO(self); 661 662 END_TEST 663 664 665 START_TEST(pushSmallContainerSmallArrayT) 666 667 smallArrayt* r; 668 smallArrayt *self = allocG(rtSmallArrayt); 669 createAllocateSmallContainer(container); 670 671 // add an element to check that push adds the second element 672 // at the end 673 r = self->f->pushInt(self, 1); 674 ck_assert_ptr_ne(r, null); 675 676 r = self->f->pushSmallContainer(self, container); 677 ck_assert_ptr_ne(r, null); 678 ck_assert_int_eq(lenO(r), 2); 679 finishO(container); 680 char *s = toStringO(r); 681 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 682 free(s); 683 // non smallContainer object 684 container = (smallContainert*) allocSmallInt(2); 685 r = self->f->pushSmallContainer(self, container); 686 ck_assert_ptr_eq(r, null); 687 terminateO(container); 688 // null 689 r = self->f->pushSmallContainer(self, null); 690 ck_assert_ptr_eq(r, null); 691 ck_assert_int_eq(lenO(self), 2); 692 s = toStringO(self); 693 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 694 free(s); 695 terminateO(self); 696 697 END_TEST 698 699 700 START_TEST(pushNFreeSmallArrayT) 701 702 smallArrayt* r; 703 smallArrayt *self = allocG(rtSmallArrayt); 704 baset *value = (baset*) allocG(2); 705 706 // add an element to check that push adds the second element 707 // at the end 708 r = self->f->pushInt(self, 1); 709 ck_assert_ptr_ne(r, null); 710 711 r = self->f->pushNFree(self, value); 712 ck_assert_ptr_ne(r, null); 713 ck_assert_int_eq(lenO(r), 2); 714 char *s = toStringO(r); 715 ck_assert_str_eq(s, "[1,2]"); 716 free(s); 717 // null 718 r = self->f->pushNFree(self, null); 719 ck_assert_ptr_eq(r, null); 720 ck_assert_int_eq(lenO(self), 2); 721 s = toStringO(self); 722 ck_assert_str_eq(s, "[1,2]"); 723 free(s); 724 terminateO(self); 725 726 END_TEST 727 728 729 START_TEST(pushNFreeUndefinedSmallArrayT) 730 731 smallArrayt* r; 732 smallArrayt *self = allocG(rtSmallArrayt); 733 734 // add an element to check that push adds the second element 735 // at the end 736 r = self->f->pushInt(self, 1); 737 ck_assert_ptr_ne(r, null); 738 739 createAllocateUndefined(value); 740 r = self->f->pushNFreeUndefined(self, value); 741 ck_assert_ptr_ne(r, null); 742 ck_assert_int_eq(lenO(r), 2); 743 char *s = toStringO(r); 744 ck_assert_str_eq(s, "[1,null]"); 745 free(s); 746 terminateO(self); 747 748 END_TEST 749 750 751 START_TEST(pushNFreeSSmallArrayT) 752 753 smallArrayt* r; 754 smallArrayt *self = allocG(rtSmallArrayt); 755 756 // add an element to check that push adds the second element 757 // at the end 758 r = self->f->pushInt(self, 1); 759 ck_assert_ptr_ne(r, null); 760 761 r = self->f->pushNFreeS(self, null); 762 ck_assert_ptr_eq(r, null); 763 ck_assert_int_eq(lenO(self), 1); 764 char *s = toStringO(self); 765 ck_assert_str_eq(s, "[1]"); 766 free(s); 767 768 char *str = strdup("poi"); 769 r = self->f->pushNFreeS(self, str); 770 ck_assert_ptr_ne(r, null); 771 ck_assert_int_eq(lenO(self), 2); 772 s = toStringO(r); 773 ck_assert_str_eq(s, "[1,\"poi\"]"); 774 free(s); 775 776 terminateO(self); 777 778 END_TEST 779 780 781 START_TEST(pushNFreeDictSmallArrayT) 782 783 smallArrayt* r; 784 smallArrayt *self = allocG(rtSmallArrayt); 785 smallDictt *dict = allocG(rtSmallDictt); 786 787 // add an element to check that push adds the second element 788 // at the end 789 r = self->f->pushInt(self, 1); 790 ck_assert_ptr_ne(r, null); 791 792 // push dict 793 r = self->f->pushNFreeDict(self, dict); 794 ck_assert_ptr_ne(r, null); 795 ck_assert_int_eq(lenO(r), 2); 796 ck_assert_ptr_ne(r, null); 797 char *s = toStringO(r); 798 ck_assert_str_eq(s, "[1,{}]"); 799 free(s); 800 // null 801 r = self->f->pushNFreeDict(self, null); 802 ck_assert_ptr_eq(r, null); 803 ck_assert_int_eq(lenO(self), 2); 804 s = toStringO(self); 805 ck_assert_str_eq(s, "[1,{}]"); 806 free(s); 807 terminateO(self); 808 809 END_TEST 810 811 812 START_TEST(pushNFreeArraySmallArrayT) 813 814 smallArrayt* r; 815 smallArrayt *self = allocG(rtSmallArrayt); 816 smallArrayt *array = allocG(rtSmallArrayt); 817 818 // add an element to check that push adds the second element 819 // at the end 820 r = self->f->pushInt(self, 1); 821 ck_assert_ptr_ne(r, null); 822 823 r = self->f->pushNFreeArray(self, array); 824 ck_assert_ptr_ne(r, null); 825 ck_assert_int_eq(lenO(r), 2); 826 char *s = toStringO(r); 827 ck_assert_str_eq(s, "[1,[]]"); 828 free(s); 829 // null 830 r = self->f->pushNFreeArray(self, null); 831 ck_assert_ptr_eq(r, null); 832 ck_assert_int_eq(lenO(self), 2); 833 s = toStringO(self); 834 ck_assert_str_eq(s, "[1,[]]"); 835 free(s); 836 terminateO(self); 837 838 END_TEST 839 840 841 START_TEST(pushNFreeArraycSmallArrayT) 842 843 smallArrayt* r; 844 smallArrayt *self = allocG(rtSmallArrayt); 845 char **array = listCreateS("a","bb"); 846 847 // add an element to check that push adds the second element 848 // at the end 849 r = self->f->pushInt(self, 1); 850 ck_assert_ptr_ne(r, null); 851 852 r = self->f->pushNFreeArrayc(self, array); 853 ck_assert_ptr_ne(r, null); 854 ck_assert_int_eq(lenO(r), 2); 855 char *s = toStringO(r); 856 ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]"); 857 free(s); 858 // null 859 r = self->f->pushNFreeArrayc(self, null); 860 ck_assert_ptr_eq(r, null); 861 ck_assert_int_eq(lenO(self), 2); 862 s = toStringO(self); 863 ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]"); 864 free(s); 865 terminateO(self); 866 867 END_TEST 868 869 870 START_TEST(pushNFreeSmallBoolSmallArrayT) 871 872 smallArrayt* r; 873 smallArrayt *self = allocG(rtSmallArrayt); 874 smallBoolt *value = allocG(TRUE); 875 876 // add an element to check that push adds the second element 877 // at the end 878 r = self->f->pushInt(self, 1); 879 ck_assert_ptr_ne(r, null); 880 881 r = self->f->pushNFreeSmallBool(self, value); 882 ck_assert_ptr_ne(r, null); 883 ck_assert_int_eq(lenO(r), 2); 884 char *s = toStringO(r); 885 ck_assert_str_eq(s, "[1,true]"); 886 free(s); 887 // bool object with no data 888 createAllocateSmallBool(b); 889 r = self->f->pushNFreeSmallBool(self, b); 890 ck_assert_ptr_ne(r, null); 891 ck_assert_int_eq(lenO(r), 3); 892 s = toStringO(r); 893 ck_assert_str_eq(s, "[1,true,false]"); 894 free(s); 895 // null 896 r = self->f->pushNFreeSmallBool(self, null); 897 ck_assert_ptr_eq(r, null); 898 ck_assert_int_eq(lenO(self), 3); 899 s = toStringO(self); 900 ck_assert_str_eq(s, "[1,true,false]"); 901 free(s); 902 terminateO(self); 903 904 END_TEST 905 906 907 START_TEST(pushNFreeSmallBytesSmallArrayT) 908 909 smallArrayt* r; 910 smallArrayt *self = allocG(rtSmallArrayt); 911 createAllocateSmallBytes(value); 912 913 // add an element to check that push adds the second element 914 // at the end 915 r = self->f->pushInt(self, 1); 916 ck_assert_ptr_ne(r, null); 917 918 // the smallBytes container is empty 919 r = self->f->pushNFreeSmallBytes(self, value); 920 ck_assert_ptr_ne(r, null); 921 ck_assert_int_eq(lenO(r), 2); 922 char *s = toStringO(r); 923 ck_assert_str_eq(s, "[1,[]]"); 924 free(s); 925 926 char *buffer = "poi"; 927 value = allocSmallBytes(buffer, strlen(buffer)); 928 r = self->f->pushNFreeSmallBytes(self, value); 929 ck_assert_ptr_ne(r, null); 930 ck_assert_int_eq(lenO(r), 3); 931 s = toStringO(r); 932 ck_assert_str_eq(s, "[1,[],[0x70,0x6f,0x69]]"); 933 free(s); 934 // null 935 r = self->f->pushNFreeSmallBytes(self, null); 936 ck_assert_ptr_eq(r, null); 937 ck_assert_int_eq(lenO(self), 3); 938 s = toStringO(self); 939 ck_assert_str_eq(s, "[1,[],[0x70,0x6f,0x69]]"); 940 free(s); 941 terminateO(self); 942 943 END_TEST 944 945 946 START_TEST(pushNFreeSmallDoubleSmallArrayT) 947 948 smallArrayt* r; 949 smallArrayt *self = allocG(rtSmallArrayt); 950 smallDoublet *value = allocG(1.0); 951 952 // add an element to check that push adds the second element 953 // at the end 954 r = self->f->pushInt(self, 1); 955 ck_assert_ptr_ne(r, null); 956 957 r = self->f->pushNFreeSmallDouble(self, value); 958 ck_assert_ptr_ne(r, null); 959 ck_assert_int_eq(lenO(r), 2); 960 char *s = toStringO(r); 961 ck_assert_str_eq(s, "[1,1.000000e+00]"); 962 free(s); 963 // object with no data 964 createAllocateSmallDouble(b); 965 r = self->f->pushNFreeSmallDouble(self, b); 966 ck_assert_ptr_ne(r, null); 967 ck_assert_int_eq(lenO(r), 3); 968 s = toStringO(r); 969 ck_assert_str_eq(s, "[1,1.000000e+00,0.000000e+00]"); 970 free(s); 971 // null 972 r = self->f->pushNFreeSmallDouble(self, null); 973 ck_assert_ptr_eq(r, null); 974 ck_assert_int_eq(lenO(self), 3); 975 s = toStringO(self); 976 ck_assert_str_eq(s, "[1,1.000000e+00,0.000000e+00]"); 977 free(s); 978 terminateO(self); 979 980 END_TEST 981 982 983 START_TEST(pushNFreeSmallIntSmallArrayT) 984 985 smallArrayt* r; 986 smallArrayt *self = allocG(rtSmallArrayt); 987 smallIntt *value = allocG(1); 988 989 // add an element to check that push adds the second element 990 // at the end 991 r = self->f->pushInt(self, 1); 992 ck_assert_ptr_ne(r, null); 993 994 r = self->f->pushNFreeSmallInt(self, value); 995 ck_assert_ptr_ne(r, null); 996 ck_assert_int_eq(lenO(r), 2); 997 char *s = toStringO(r); 998 ck_assert_str_eq(s, "[1,1]"); 999 free(s); 1000 // bool object with no data 1001 createAllocateSmallInt(b); 1002 r = self->f->pushNFreeSmallInt(self, b); 1003 ck_assert_ptr_ne(r, null); 1004 ck_assert_int_eq(lenO(r), 3); 1005 s = toStringO(r); 1006 ck_assert_str_eq(s, "[1,1,0]"); 1007 free(s); 1008 // null 1009 r = self->f->pushNFreeSmallInt(self, null); 1010 ck_assert_ptr_eq(r, null); 1011 ck_assert_int_eq(lenO(self), 3); 1012 s = toStringO(self); 1013 ck_assert_str_eq(s, "[1,1,0]"); 1014 free(s); 1015 terminateO(self); 1016 1017 END_TEST 1018 1019 1020 START_TEST(pushNFreeSmallJsonSmallArrayT) 1021 1022 smallArrayt* r; 1023 smallArrayt *self = allocG(rtSmallArrayt); 1024 smallJsont *value = allocG(rtSmallJsont); 1025 1026 // add an element to check that push adds the second element 1027 // at the end 1028 r = self->f->pushInt(self, 1); 1029 ck_assert_ptr_ne(r, null); 1030 1031 // the smallJson container is empty 1032 r = self->f->pushNFreeSmallJson(self, value); 1033 ck_assert_ptr_ne(r, null); 1034 ck_assert_int_eq(lenO(r), 2); 1035 char *s = toStringO(r); 1036 ck_assert_str_eq(s, "[1,{}]"); 1037 free(s); 1038 1039 value = allocG(rtSmallJsont); 1040 parseO(value, "{}"); 1041 r = self->f->pushNFreeSmallJson(self, value); 1042 ck_assert_ptr_ne(r, null); 1043 ck_assert_int_eq(lenO(r), 3); 1044 s = toStringO(r); 1045 ck_assert_str_eq(s, "[1,{},{}]"); 1046 free(s); 1047 // null 1048 r = self->f->pushNFreeSmallJson(self, null); 1049 ck_assert_ptr_eq(r, null); 1050 ck_assert_int_eq(lenO(self), 3); 1051 s = toStringO(self); 1052 ck_assert_str_eq(s, "[1,{},{}]"); 1053 free(s); 1054 terminateO(self); 1055 1056 END_TEST 1057 1058 1059 START_TEST(pushNFreeSmallStringSmallArrayT) 1060 1061 smallArrayt* r; 1062 smallArrayt *self = allocG(rtSmallArrayt); 1063 createAllocateSmallString(string); 1064 1065 // add an element to check that push adds the second element 1066 // at the end 1067 r = self->f->pushInt(self, 1); 1068 ck_assert_ptr_ne(r, null); 1069 1070 r = self->f->pushNFreeSmallString(self, string); 1071 ck_assert_ptr_ne(r, null); 1072 ck_assert_int_eq(lenO(r), 2); 1073 char *s = toStringO(r); 1074 ck_assert_str_eq(s, "[1,\"\"]"); 1075 free(s); 1076 // null 1077 r = self->f->pushNFreeSmallString(self, null); 1078 ck_assert_ptr_eq(r, null); 1079 ck_assert_int_eq(lenO(self), 2); 1080 s = toStringO(self); 1081 ck_assert_str_eq(s, "[1,\"\"]"); 1082 free(s); 1083 terminateO(self); 1084 1085 END_TEST 1086 1087 1088 START_TEST(pushNFreeSmallContainerSmallArrayT) 1089 1090 smallArrayt* r; 1091 smallArrayt *self = allocG(rtSmallArrayt); 1092 createAllocateSmallContainer(container); 1093 1094 // add an element to check that push adds the second element 1095 // at the end 1096 r = self->f->pushInt(self, 1); 1097 ck_assert_ptr_ne(r, null); 1098 1099 r = self->f->pushNFreeSmallContainer(self, container); 1100 ck_assert_ptr_ne(r, null); 1101 ck_assert_int_eq(lenO(r), 2); 1102 char *s = toStringO(r); 1103 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 1104 free(s); 1105 // null 1106 r = self->f->pushNFreeSmallContainer(self, null); 1107 ck_assert_ptr_eq(r, null); 1108 ck_assert_int_eq(lenO(self), 2); 1109 s = toStringO(self); 1110 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 1111 free(s); 1112 terminateO(self); 1113 1114 END_TEST 1115 1116 1117 START_TEST(pushManySmallArrayT) 1118 1119 smallArrayt* r; 1120 smallArrayt *self = allocG(rtSmallArrayt); 1121 smallIntt *v1 = allocG(1); 1122 smallIntt *v2 = allocG(2); 1123 1124 r = self->f->pushMany(self, v1, v2, null); 1125 finishO(v1); 1126 finishO(v2); 1127 ck_assert_ptr_ne(r, null); 1128 ck_assert_int_eq(lenO(r), 2); 1129 char *s = toStringO(r); 1130 ck_assert_str_eq(s, "[1,2]"); 1131 free(s); 1132 terminateO(self); 1133 1134 END_TEST 1135 1136 1137 START_TEST(pushManySSmallArrayT) 1138 1139 smallArrayt* r; 1140 smallArrayt *self = allocG(rtSmallArrayt); 1141 char *v1 = "a"; 1142 char *v2 = "bb"; 1143 1144 r = self->f->pushManyS(self, v1, v2, null); 1145 ck_assert_ptr_ne(r, null); 1146 ck_assert_int_eq(lenO(r), 2); 1147 char *s = toStringO(r); 1148 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 1149 free(s); 1150 terminateO(self); 1151 1152 END_TEST 1153 1154 1155 START_TEST(pushNFreeManySmallArrayT) 1156 1157 smallArrayt* r; 1158 smallArrayt *self = allocG(rtSmallArrayt); 1159 smallIntt *v1 = allocG(1); 1160 smallIntt *v2 = allocG(2); 1161 1162 r = self->f->pushNFreeMany(self, v1, v2, null); 1163 ck_assert_ptr_ne(r, null); 1164 ck_assert_int_eq(lenO(r), 2); 1165 char *s = toStringO(r); 1166 ck_assert_str_eq(s, "[1,2]"); 1167 free(s); 1168 terminateO(self); 1169 1170 END_TEST 1171 1172 1173 START_TEST(pushNFreeManySSmallArrayT) 1174 1175 smallArrayt* r; 1176 smallArrayt *self = allocG(rtSmallArrayt); 1177 char *v1 = strdup("a"); 1178 char *v2 = strdup("bb"); 1179 1180 r = self->f->pushNFreeManyS(self, v1, v2, null); 1181 ck_assert_ptr_ne(r, null); 1182 ck_assert_int_eq(lenO(r), 2); 1183 char *s = toStringO(r); 1184 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 1185 free(s); 1186 terminateO(self); 1187 1188 END_TEST 1189 1190 1191 START_TEST(popSmallArrayT) 1192 1193 baset* r; 1194 smallArrayt *self = allocG(rtSmallArrayt); 1195 smallArrayt *r2; 1196 1197 // add an element to check that the second element is poped 1198 // at the end 1199 r2 = self->f->pushInt(self, 1); 1200 ck_assert_ptr_ne(r2, null); 1201 1202 // push a base object of unknown type 1203 smallIntt *o = allocSmallInt(2); 1204 o->type = "newType"; 1205 r2 = self->f->pushNFree(self, (baset*)o); 1206 ck_assert_ptr_ne(r2, null); 1207 1208 r = self->f->pop(self); 1209 ck_assert_ptr_ne(r, null); 1210 ck_assert_str_eq(r->type, "newType"); 1211 char *s = toStringO(r); 1212 terminateO(r); 1213 ck_assert_str_eq(s, "2"); 1214 free(s); 1215 ck_assert_int_eq(lenO(self), 1); 1216 s = toStringO(self); 1217 ck_assert_str_eq(s, "[1]"); 1218 free(s); 1219 1220 // empty array 1221 r = self->f->pop(self); 1222 ck_assert_ptr_ne(r, null); 1223 terminateO(r); 1224 s = toStringO(self); 1225 ck_assert_str_eq(s, "[]"); 1226 free(s); 1227 r = self->f->pop(self); 1228 ck_assert_ptr_eq(r, null); 1229 s = toStringO(self); 1230 ck_assert_str_eq(s, "[]"); 1231 free(s); 1232 terminateO(self); 1233 1234 END_TEST 1235 1236 1237 START_TEST(popUndefinedSmallArrayT) 1238 1239 undefinedt* r; 1240 smallArrayt *self = allocG(rtSmallArrayt); 1241 smallArrayt *r2; 1242 baset *r3; 1243 1244 // add an element to check that the second element is poped 1245 // at the end 1246 r2 = self->f->pushInt(self, 1); 1247 ck_assert_ptr_ne(r2, null); 1248 // add second element 1249 r2 = self->f->pushUndefined(self); 1250 ck_assert_ptr_ne(r2, null); 1251 r2 = self->f->pushUndefined(self); 1252 ck_assert_ptr_ne(r2, null); 1253 delElemO(self, -1); 1254 // pop 1255 r = self->f->popUndefined(self); 1256 ck_assert_ptr_ne(r, null); 1257 char *s = toStringO(r); 1258 terminateO(r); 1259 ck_assert_str_eq(s, "null"); 1260 free(s); 1261 ck_assert_int_eq(lenO(self), 1); 1262 s = toStringO(self); 1263 ck_assert_str_eq(s, "[1]"); 1264 free(s); 1265 // pop element of unexpected type 1266 r = self->f->popUndefined(self); 1267 ck_assert_ptr_eq(r, null); 1268 ck_assert_int_eq(lenO(self), 1); 1269 s = toStringO(self); 1270 ck_assert_str_eq(s, "[1]"); 1271 free(s); 1272 // empty array 1273 r3 = self->f->pop(self); 1274 ck_assert_ptr_ne(r3, null); 1275 terminateO(r3); 1276 s = toStringO(self); 1277 ck_assert_str_eq(s, "[]"); 1278 free(s); 1279 r = self->f->popUndefined(self); 1280 ck_assert_ptr_eq(r, null); 1281 s = toStringO(self); 1282 ck_assert_str_eq(s, "[]"); 1283 free(s); 1284 r2 = self->f->pushUndefined(self); 1285 ck_assert_ptr_ne(r2, null); 1286 delElemO(self,-1); 1287 r = self->f->popUndefined(self); 1288 ck_assert_ptr_eq(r, null); 1289 terminateO(self); 1290 1291 END_TEST 1292 1293 1294 START_TEST(popBoolSmallArrayT) 1295 1296 bool r; 1297 smallArrayt *self = allocG(rtSmallArrayt); 1298 smallArrayt *r2; 1299 baset *r3; 1300 1301 // add an element to check that the second element is poped 1302 // at the end 1303 r2 = self->f->pushInt(self, 1); 1304 ck_assert_ptr_ne(r2, null); 1305 1306 // add second element 1307 r2 = self->f->pushBool(self, TRUE); 1308 ck_assert_ptr_ne(r2, null); 1309 1310 // pop 1311 r = self->f->popBool(self); 1312 ck_assert(r); 1313 ck_assert_int_eq(lenO(self), 1); 1314 char *s = toStringO(self); 1315 ck_assert_str_eq(s, "[1]"); 1316 free(s); 1317 1318 // pop element of unexpected type 1319 r = self->f->popBool(self); 1320 ck_assert(!r); 1321 ck_assert_int_eq(lenO(self), 1); 1322 s = toStringO(self); 1323 ck_assert_str_eq(s, "[1]"); 1324 free(s); 1325 1326 // empty array 1327 r3 = self->f->pop(self); 1328 ck_assert_ptr_ne(r3, null); 1329 terminateO(r3); 1330 s = toStringO(self); 1331 ck_assert_str_eq(s, "[]"); 1332 free(s); 1333 r = self->f->popBool(self); 1334 ck_assert(!r); 1335 s = toStringO(self); 1336 ck_assert_str_eq(s, "[]"); 1337 free(s); 1338 terminateO(self); 1339 1340 END_TEST 1341 1342 1343 START_TEST(popDoubleSmallArrayT) 1344 1345 double r; 1346 smallArrayt *self = allocG(rtSmallArrayt); 1347 smallArrayt *r2; 1348 baset *r3; 1349 1350 // add an element to check that the second element is poped 1351 // at the end 1352 r2 = self->f->pushInt(self, 1); 1353 ck_assert_ptr_ne(r2, null); 1354 1355 // add second element 1356 r2 = self->f->pushDouble(self, 2.0); 1357 ck_assert_ptr_ne(r2, null); 1358 1359 // pop 1360 r = self->f->popDouble(self); 1361 ck_assert(r==2.0); 1362 ck_assert_int_eq(lenO(self), 1); 1363 char *s = toStringO(self); 1364 ck_assert_str_eq(s, "[1]"); 1365 free(s); 1366 1367 // pop element of unexpected type 1368 r = self->f->popDouble(self); 1369 ck_assert(!r); 1370 ck_assert_int_eq(lenO(self), 1); 1371 s = toStringO(self); 1372 ck_assert_str_eq(s, "[1]"); 1373 free(s); 1374 1375 // empty array 1376 r3 = self->f->pop(self); 1377 ck_assert_ptr_ne(r3, null); 1378 terminateO(r3); 1379 s = toStringO(self); 1380 ck_assert_str_eq(s, "[]"); 1381 free(s); 1382 r = self->f->popDouble(self); 1383 ck_assert(!r); 1384 s = toStringO(self); 1385 ck_assert_str_eq(s, "[]"); 1386 free(s); 1387 terminateO(self); 1388 1389 END_TEST 1390 1391 1392 START_TEST(popIntSmallArrayT) 1393 1394 int64_t r; 1395 smallArrayt *self = allocG(rtSmallArrayt); 1396 smallArrayt *r2; 1397 baset *r3; 1398 1399 // add an element to check that the second element is poped 1400 // at the end 1401 r2 = self->f->pushBool(self, FALSE); 1402 ck_assert_ptr_ne(r2, null); 1403 1404 // add second element 1405 r2 = self->f->pushInt(self, 2); 1406 ck_assert_ptr_ne(r2, null); 1407 1408 // pop 1409 r = self->f->popInt(self); 1410 ck_assert_int_eq(r, 2); 1411 ck_assert_int_eq(lenO(self), 1); 1412 char *s = toStringO(self); 1413 ck_assert_str_eq(s, "[false]"); 1414 free(s); 1415 1416 // pop element of unexpected type 1417 r = self->f->popInt(self); 1418 ck_assert(!r); 1419 ck_assert_int_eq(lenO(self), 1); 1420 s = toStringO(self); 1421 ck_assert_str_eq(s, "[false]"); 1422 free(s); 1423 1424 // empty array 1425 r3 = self->f->pop(self); 1426 ck_assert_ptr_ne(r3, null); 1427 terminateO(r3); 1428 s = toStringO(self); 1429 ck_assert_str_eq(s, "[]"); 1430 free(s); 1431 r = self->f->popInt(self); 1432 ck_assert(!r); 1433 s = toStringO(self); 1434 ck_assert_str_eq(s, "[]"); 1435 free(s); 1436 terminateO(self); 1437 1438 END_TEST 1439 1440 1441 START_TEST(popInt32SmallArrayT) 1442 1443 int32_t r; 1444 smallArrayt *self = allocG(rtSmallArrayt); 1445 smallArrayt *r2; 1446 baset *r3; 1447 1448 // add an element to check that the second element is poped 1449 // at the end 1450 r2 = self->f->pushBool(self, FALSE); 1451 ck_assert_ptr_ne(r2, null); 1452 1453 // add second element 1454 r2 = self->f->pushInt(self, 2); 1455 ck_assert_ptr_ne(r2, null); 1456 1457 // pop 1458 r = self->f->popInt32(self); 1459 ck_assert_int_eq(r, 2); 1460 ck_assert_int_eq(lenO(self), 1); 1461 char *s = toStringO(self); 1462 ck_assert_str_eq(s, "[false]"); 1463 free(s); 1464 1465 // pop element of unexpected type 1466 r = self->f->popInt32(self); 1467 ck_assert(!r); 1468 ck_assert_int_eq(lenO(self), 1); 1469 s = toStringO(self); 1470 ck_assert_str_eq(s, "[false]"); 1471 free(s); 1472 1473 // empty array 1474 r3 = self->f->pop(self); 1475 ck_assert_ptr_ne(r3, null); 1476 terminateO(r3); 1477 s = toStringO(self); 1478 ck_assert_str_eq(s, "[]"); 1479 free(s); 1480 r = self->f->popInt32(self); 1481 ck_assert(!r); 1482 s = toStringO(self); 1483 ck_assert_str_eq(s, "[]"); 1484 free(s); 1485 terminateO(self); 1486 1487 END_TEST 1488 1489 1490 START_TEST(popUintSmallArrayT) 1491 1492 uint64_t r; 1493 smallArrayt *self = allocG(rtSmallArrayt); 1494 smallArrayt *r2; 1495 baset *r3; 1496 1497 // add an element to check that the second element is poped 1498 // at the end 1499 r2 = self->f->pushBool(self, FALSE); 1500 ck_assert_ptr_ne(r2, null); 1501 1502 // add second element 1503 r2 = self->f->pushInt(self, 2); 1504 ck_assert_ptr_ne(r2, null); 1505 1506 // pop 1507 r = self->f->popUint(self); 1508 ck_assert_int_eq(r, 2); 1509 ck_assert_int_eq(lenO(self), 1); 1510 char *s = toStringO(self); 1511 ck_assert_str_eq(s, "[false]"); 1512 free(s); 1513 1514 // pop element of unexpected type 1515 r = self->f->popUint(self); 1516 ck_assert(!r); 1517 ck_assert_int_eq(lenO(self), 1); 1518 s = toStringO(self); 1519 ck_assert_str_eq(s, "[false]"); 1520 free(s); 1521 1522 // empty array 1523 r3 = self->f->pop(self); 1524 ck_assert_ptr_ne(r3, null); 1525 terminateO(r3); 1526 s = toStringO(self); 1527 ck_assert_str_eq(s, "[]"); 1528 free(s); 1529 r = self->f->popUint(self); 1530 ck_assert(!r); 1531 s = toStringO(self); 1532 ck_assert_str_eq(s, "[]"); 1533 free(s); 1534 terminateO(self); 1535 1536 END_TEST 1537 1538 1539 START_TEST(popUint32SmallArrayT) 1540 1541 uint32_t r; 1542 smallArrayt *self = allocG(rtSmallArrayt); 1543 smallArrayt *r2; 1544 baset *r3; 1545 1546 // add an element to check that the second element is poped 1547 // at the end 1548 r2 = self->f->pushBool(self, FALSE); 1549 ck_assert_ptr_ne(r2, null); 1550 1551 // add second element 1552 r2 = self->f->pushInt(self, 2); 1553 ck_assert_ptr_ne(r2, null); 1554 1555 // pop 1556 r = self->f->popUint32(self); 1557 ck_assert_int_eq(r, 2); 1558 ck_assert_int_eq(lenO(self), 1); 1559 char *s = toStringO(self); 1560 ck_assert_str_eq(s, "[false]"); 1561 free(s); 1562 1563 // pop element of unexpected type 1564 r = self->f->popUint32(self); 1565 ck_assert(!r); 1566 ck_assert_int_eq(lenO(self), 1); 1567 s = toStringO(self); 1568 ck_assert_str_eq(s, "[false]"); 1569 free(s); 1570 1571 // empty array 1572 r3 = self->f->pop(self); 1573 ck_assert_ptr_ne(r3, null); 1574 terminateO(r3); 1575 s = toStringO(self); 1576 ck_assert_str_eq(s, "[]"); 1577 free(s); 1578 r = self->f->popUint32(self); 1579 ck_assert(!r); 1580 s = toStringO(self); 1581 ck_assert_str_eq(s, "[]"); 1582 free(s); 1583 terminateO(self); 1584 1585 END_TEST 1586 1587 1588 START_TEST(popSSmallArrayT) 1589 1590 char* r; 1591 smallArrayt *self = allocG(rtSmallArrayt); 1592 smallArrayt *r2; 1593 baset *r3; 1594 1595 // add an element to check that the second element is poped 1596 // at the end 1597 r2 = self->f->pushInt(self, 1); 1598 ck_assert_ptr_ne(r2, null); 1599 1600 // add second element 1601 r2 = self->f->pushS(self, "bb"); 1602 ck_assert_ptr_ne(r2, null); 1603 1604 // pop 1605 r = self->f->popS(self); 1606 ck_assert_str_eq(r, "bb"); 1607 free(r); 1608 ck_assert_int_eq(lenO(self), 1); 1609 char *s = toStringO(self); 1610 ck_assert_str_eq(s, "[1]"); 1611 free(s); 1612 1613 // pop element of unexpected type 1614 r = self->f->popS(self); 1615 ck_assert(!r); 1616 ck_assert_int_eq(lenO(self), 1); 1617 s = toStringO(self); 1618 ck_assert_str_eq(s, "[1]"); 1619 free(s); 1620 1621 // empty array 1622 r3 = self->f->pop(self); 1623 ck_assert_ptr_ne(r3, null); 1624 terminateO(r3); 1625 s = toStringO(self); 1626 ck_assert_str_eq(s, "[]"); 1627 free(s); 1628 r = self->f->popS(self); 1629 ck_assert(!r); 1630 s = toStringO(self); 1631 ck_assert_str_eq(s, "[]"); 1632 free(s); 1633 terminateO(self); 1634 1635 END_TEST 1636 1637 1638 START_TEST(popDictSmallArrayT) 1639 1640 smallDictt* r; 1641 smallArrayt *self = allocG(rtSmallArrayt); 1642 smallArrayt *r2; 1643 baset *r3; 1644 1645 // add an element to check that the second element is poped 1646 // at the end 1647 r2 = self->f->pushInt(self, 1); 1648 ck_assert_ptr_ne(r2, null); 1649 // add second element 1650 createSmallDict(e); 1651 r2 = self->f->pushDict(self, &e); 1652 ck_assert_ptr_ne(r2, null); 1653 r2 = self->f->pushUndefined(self); 1654 ck_assert_ptr_ne(r2, null); 1655 delElemO(self, -1); 1656 // pop 1657 r = self->f->popDict(self); 1658 ck_assert_ptr_ne(r, null); 1659 char *s = toStringO(r); 1660 terminateO(r); 1661 ck_assert_str_eq(s, "{}"); 1662 free(s); 1663 ck_assert_int_eq(lenO(self), 1); 1664 s = toStringO(self); 1665 ck_assert_str_eq(s, "[1]"); 1666 free(s); 1667 // pop element of unexpected type 1668 r = self->f->popDict(self); 1669 ck_assert(!r); 1670 ck_assert_int_eq(lenO(self), 1); 1671 s = toStringO(self); 1672 ck_assert_str_eq(s, "[1]"); 1673 free(s); 1674 // empty array 1675 r3 = self->f->pop(self); 1676 ck_assert_ptr_ne(r3, null); 1677 terminateO(r3); 1678 s = toStringO(self); 1679 ck_assert_str_eq(s, "[]"); 1680 free(s); 1681 r = self->f->popDict(self); 1682 ck_assert(!r); 1683 s = toStringO(self); 1684 ck_assert_str_eq(s, "[]"); 1685 free(s); 1686 r2 = self->f->pushUndefined(self); 1687 ck_assert_ptr_ne(r2, null); 1688 delElemO(self,-1); 1689 r = self->f->popDict(self); 1690 ck_assert_ptr_eq(r, null); 1691 terminateO(self); 1692 1693 END_TEST 1694 1695 1696 START_TEST(popArraySmallArrayT) 1697 1698 smallArrayt* r; 1699 smallArrayt *self = allocG(rtSmallArrayt); 1700 smallArrayt *r2; 1701 baset *r3; 1702 1703 // add an element to check that the second element is poped 1704 // at the end 1705 r2 = self->f->pushInt(self, 1); 1706 ck_assert_ptr_ne(r2, null); 1707 // add second element 1708 createSmallArray(e); 1709 r2 = self->f->pushArray(self, &e); 1710 ck_assert_ptr_ne(r2, null); 1711 r2 = self->f->pushUndefined(self); 1712 ck_assert_ptr_ne(r2, null); 1713 delElemO(self, -1); 1714 // pop 1715 r = self->f->popArray(self); 1716 ck_assert_ptr_ne(r, null); 1717 char *s = toStringO(r); 1718 terminateO(r); 1719 ck_assert_str_eq(s, "[]"); 1720 free(s); 1721 ck_assert_int_eq(lenO(self), 1); 1722 s = toStringO(self); 1723 ck_assert_str_eq(s, "[1]"); 1724 free(s); 1725 // pop element of unexpected type 1726 r = self->f->popArray(self); 1727 ck_assert(!r); 1728 ck_assert_int_eq(lenO(self), 1); 1729 s = toStringO(self); 1730 ck_assert_str_eq(s, "[1]"); 1731 free(s); 1732 // empty array 1733 r3 = self->f->pop(self); 1734 ck_assert_ptr_ne(r3, null); 1735 terminateO(r3); 1736 s = toStringO(self); 1737 ck_assert_str_eq(s, "[]"); 1738 free(s); 1739 r = self->f->popArray(self); 1740 ck_assert(!r); 1741 s = toStringO(self); 1742 ck_assert_str_eq(s, "[]"); 1743 free(s); 1744 r2 = self->f->pushUndefined(self); 1745 ck_assert_ptr_ne(r2, null); 1746 delElemO(self,-1); 1747 r = self->f->popArray(self); 1748 ck_assert_ptr_eq(r, null); 1749 terminateO(self); 1750 1751 END_TEST 1752 1753 1754 START_TEST(popSmallBoolSmallArrayT) 1755 1756 smallBoolt* r; 1757 smallArrayt *self = allocG(rtSmallArrayt); 1758 smallArrayt *r2; 1759 baset *r3; 1760 1761 // add an element to check that the second element is poped 1762 // at the end 1763 r2 = self->f->pushInt(self, 1); 1764 ck_assert_ptr_ne(r2, null); 1765 // add second element 1766 createSmallBool(e); 1767 r2 = self->f->pushSmallBool(self, &e); 1768 ck_assert_ptr_ne(r2, null); 1769 r2 = self->f->pushUndefined(self); 1770 ck_assert_ptr_ne(r2, null); 1771 delElemO(self, -1); 1772 // pop 1773 r = self->f->popSmallBool(self); 1774 ck_assert_ptr_ne(r, null); 1775 char *s = toStringO(r); 1776 terminateO(r); 1777 ck_assert_str_eq(s, "false"); 1778 free(s); 1779 ck_assert_int_eq(lenO(self), 1); 1780 s = toStringO(self); 1781 ck_assert_str_eq(s, "[1]"); 1782 free(s); 1783 // pop element of unexpected type 1784 r = self->f->popSmallBool(self); 1785 ck_assert(!r); 1786 ck_assert_int_eq(lenO(self), 1); 1787 s = toStringO(self); 1788 ck_assert_str_eq(s, "[1]"); 1789 free(s); 1790 // empty array 1791 r3 = self->f->pop(self); 1792 ck_assert_ptr_ne(r3, null); 1793 terminateO(r3); 1794 s = toStringO(self); 1795 ck_assert_str_eq(s, "[]"); 1796 free(s); 1797 r = self->f->popSmallBool(self); 1798 ck_assert(!r); 1799 s = toStringO(self); 1800 ck_assert_str_eq(s, "[]"); 1801 free(s); 1802 r2 = self->f->pushUndefined(self); 1803 ck_assert_ptr_ne(r2, null); 1804 delElemO(self,-1); 1805 r = self->f->popSmallBool(self); 1806 ck_assert_ptr_eq(r, null); 1807 terminateO(self); 1808 1809 END_TEST 1810 1811 1812 START_TEST(popSmallBytesSmallArrayT) 1813 1814 smallBytest* r; 1815 smallArrayt *self = allocG(rtSmallArrayt); 1816 smallArrayt *r2; 1817 baset *r3; 1818 1819 // add an element to check that the second element is poped 1820 // at the end 1821 r2 = self->f->pushInt(self, 1); 1822 ck_assert_ptr_ne(r2, null); 1823 // add second element 1824 createSmallBytes(e); 1825 r2 = self->f->pushSmallBytes(self, &e); 1826 ck_assert_ptr_ne(r2, null); 1827 r2 = self->f->pushUndefined(self); 1828 ck_assert_ptr_ne(r2, null); 1829 delElemO(self, -1); 1830 // pop 1831 r = self->f->popSmallBytes(self); 1832 ck_assert_ptr_ne(r, null); 1833 char *s = toStringO(r); 1834 terminateO(r); 1835 ck_assert_str_eq(s, "[]"); 1836 free(s); 1837 ck_assert_int_eq(lenO(self), 1); 1838 s = toStringO(self); 1839 ck_assert_str_eq(s, "[1]"); 1840 free(s); 1841 // pop element of unexpected type 1842 r = self->f->popSmallBytes(self); 1843 ck_assert(!r); 1844 ck_assert_int_eq(lenO(self), 1); 1845 s = toStringO(self); 1846 ck_assert_str_eq(s, "[1]"); 1847 free(s); 1848 // empty array 1849 r3 = self->f->pop(self); 1850 ck_assert_ptr_ne(r3, null); 1851 terminateO(r3); 1852 s = toStringO(self); 1853 ck_assert_str_eq(s, "[]"); 1854 free(s); 1855 r = self->f->popSmallBytes(self); 1856 ck_assert(!r); 1857 s = toStringO(self); 1858 ck_assert_str_eq(s, "[]"); 1859 free(s); 1860 r2 = self->f->pushUndefined(self); 1861 ck_assert_ptr_ne(r2, null); 1862 delElemO(self,-1); 1863 r = self->f->popSmallBytes(self); 1864 ck_assert_ptr_eq(r, null); 1865 terminateO(self); 1866 1867 END_TEST 1868 1869 1870 START_TEST(popSmallDoubleSmallArrayT) 1871 1872 smallDoublet* r; 1873 smallArrayt *self = allocG(rtSmallArrayt); 1874 smallArrayt *r2; 1875 baset *r3; 1876 1877 // add an element to check that the second element is poped 1878 // at the end 1879 r2 = self->f->pushInt(self, 1); 1880 ck_assert_ptr_ne(r2, null); 1881 // add second element 1882 createSmallDouble(e); 1883 r2 = self->f->pushSmallDouble(self, &e); 1884 ck_assert_ptr_ne(r2, null); 1885 r2 = self->f->pushUndefined(self); 1886 ck_assert_ptr_ne(r2, null); 1887 delElemO(self, -1); 1888 // pop 1889 r = self->f->popSmallDouble(self); 1890 ck_assert_ptr_ne(r, null); 1891 char *s = toStringO(r); 1892 terminateO(r); 1893 ck_assert_str_eq(s, "0.000000e+00"); 1894 free(s); 1895 ck_assert_int_eq(lenO(self), 1); 1896 s = toStringO(self); 1897 ck_assert_str_eq(s, "[1]"); 1898 free(s); 1899 // pop element of unexpected type 1900 r = self->f->popSmallDouble(self); 1901 ck_assert(!r); 1902 ck_assert_int_eq(lenO(self), 1); 1903 s = toStringO(self); 1904 ck_assert_str_eq(s, "[1]"); 1905 free(s); 1906 // empty array 1907 r3 = self->f->pop(self); 1908 ck_assert_ptr_ne(r3, null); 1909 terminateO(r3); 1910 s = toStringO(self); 1911 ck_assert_str_eq(s, "[]"); 1912 free(s); 1913 r = self->f->popSmallDouble(self); 1914 ck_assert(!r); 1915 s = toStringO(self); 1916 ck_assert_str_eq(s, "[]"); 1917 free(s); 1918 r2 = self->f->pushUndefined(self); 1919 ck_assert_ptr_ne(r2, null); 1920 delElemO(self,-1); 1921 r = self->f->popSmallDouble(self); 1922 ck_assert_ptr_eq(r, null); 1923 terminateO(self); 1924 1925 END_TEST 1926 1927 1928 START_TEST(popSmallIntSmallArrayT) 1929 1930 smallIntt* r; 1931 smallArrayt *self = allocG(rtSmallArrayt); 1932 smallArrayt *r2; 1933 baset *r3; 1934 1935 // add an element to check that the second element is poped 1936 // at the end 1937 r2 = self->f->pushBool(self, TRUE); 1938 ck_assert_ptr_ne(r2, null); 1939 // add second element 1940 createSmallInt(e); 1941 r2 = self->f->pushSmallInt(self, &e); 1942 ck_assert_ptr_ne(r2, null); 1943 r2 = self->f->pushUndefined(self); 1944 ck_assert_ptr_ne(r2, null); 1945 delElemO(self, -1); 1946 // pop 1947 r = self->f->popSmallInt(self); 1948 ck_assert_ptr_ne(r, null); 1949 char *s = toStringO(r); 1950 terminateO(r); 1951 ck_assert_str_eq(s, "0"); 1952 free(s); 1953 ck_assert_int_eq(lenO(self), 1); 1954 s = toStringO(self); 1955 ck_assert_str_eq(s, "[true]"); 1956 free(s); 1957 // pop element of unexpected type 1958 r = self->f->popSmallInt(self); 1959 ck_assert(!r); 1960 ck_assert_int_eq(lenO(self), 1); 1961 s = toStringO(self); 1962 ck_assert_str_eq(s, "[true]"); 1963 free(s); 1964 // empty array 1965 r3 = self->f->pop(self); 1966 ck_assert_ptr_ne(r3, null); 1967 terminateO(r3); 1968 s = toStringO(self); 1969 ck_assert_str_eq(s, "[]"); 1970 free(s); 1971 r = self->f->popSmallInt(self); 1972 ck_assert(!r); 1973 s = toStringO(self); 1974 ck_assert_str_eq(s, "[]"); 1975 free(s); 1976 r2 = self->f->pushUndefined(self); 1977 ck_assert_ptr_ne(r2, null); 1978 delElemO(self,-1); 1979 r = self->f->popSmallInt(self); 1980 ck_assert_ptr_eq(r, null); 1981 terminateO(self); 1982 1983 END_TEST 1984 1985 1986 START_TEST(popSmallJsonSmallArrayT) 1987 1988 smallJsont* r; 1989 smallArrayt *self = allocG(rtSmallArrayt); 1990 smallArrayt *r2; 1991 baset *r3; 1992 1993 // add an element to check that the second element is poped 1994 // at the end 1995 createSmallBytes(B); 1996 r2 = self->f->pushSmallBytes(self, &B); 1997 ck_assert_ptr_ne(r2, null); 1998 // add second element 1999 createSmallJson(e); 2000 r2 = self->f->pushSmallJson(self, &e); 2001 ck_assert_ptr_ne(r2, null); 2002 r2 = self->f->pushUndefined(self); 2003 ck_assert_ptr_ne(r2, null); 2004 delElemO(self, -1); 2005 // pop 2006 r = self->f->popSmallJson(self); 2007 ck_assert_ptr_ne(r, null); 2008 char *s = toStringO(r); 2009 terminateO(r); 2010 ck_assert_str_eq(s, "{}"); 2011 free(s); 2012 ck_assert_int_eq(lenO(self), 1); 2013 s = toStringO(self); 2014 ck_assert_str_eq(s, "[[]]"); 2015 free(s); 2016 // pop element of unexpected type 2017 r = self->f->popSmallJson(self); 2018 ck_assert(!r); 2019 ck_assert_int_eq(lenO(self), 1); 2020 s = toStringO(self); 2021 ck_assert_str_eq(s, "[[]]"); 2022 free(s); 2023 // empty array 2024 r3 = self->f->pop(self); 2025 ck_assert_ptr_ne(r3, null); 2026 terminateO(r3); 2027 s = toStringO(self); 2028 ck_assert_str_eq(s, "[]"); 2029 free(s); 2030 r = self->f->popSmallJson(self); 2031 ck_assert(!r); 2032 s = toStringO(self); 2033 ck_assert_str_eq(s, "[]"); 2034 free(s); 2035 r2 = self->f->pushUndefined(self); 2036 ck_assert_ptr_ne(r2, null); 2037 delElemO(self,-1); 2038 r = self->f->popSmallJson(self); 2039 ck_assert_ptr_eq(r, null); 2040 terminateO(self); 2041 2042 END_TEST 2043 2044 2045 START_TEST(popSmallStringSmallArrayT) 2046 2047 smallStringt* r; 2048 smallArrayt *self = allocG(rtSmallArrayt); 2049 smallArrayt *r2; 2050 baset *r3; 2051 2052 // add an element to check that the second element is poped 2053 // at the end 2054 r2 = self->f->pushInt(self, 1); 2055 ck_assert_ptr_ne(r2, null); 2056 // add second element 2057 createSmallString(e); 2058 r2 = self->f->pushSmallString(self, &e); 2059 ck_assert_ptr_ne(r2, null); 2060 r2 = self->f->pushUndefined(self); 2061 ck_assert_ptr_ne(r2, null); 2062 delElemO(self, -1); 2063 // pop 2064 r = self->f->popSmallString(self); 2065 ck_assert_ptr_ne(r, null); 2066 char *s = toStringO(r); 2067 terminateO(r); 2068 ck_assert_str_eq(s, ""); 2069 free(s); 2070 ck_assert_int_eq(lenO(self), 1); 2071 s = toStringO(self); 2072 ck_assert_str_eq(s, "[1]"); 2073 free(s); 2074 // pop element of unexpected type 2075 r = self->f->popSmallString(self); 2076 ck_assert(!r); 2077 ck_assert_int_eq(lenO(self), 1); 2078 s = toStringO(self); 2079 ck_assert_str_eq(s, "[1]"); 2080 free(s); 2081 // empty array 2082 r3 = self->f->pop(self); 2083 ck_assert_ptr_ne(r3, null); 2084 terminateO(r3); 2085 s = toStringO(self); 2086 ck_assert_str_eq(s, "[]"); 2087 free(s); 2088 r = self->f->popSmallString(self); 2089 ck_assert(!r); 2090 s = toStringO(self); 2091 ck_assert_str_eq(s, "[]"); 2092 free(s); 2093 r2 = self->f->pushUndefined(self); 2094 ck_assert_ptr_ne(r2, null); 2095 delElemO(self,-1); 2096 r = self->f->popSmallString(self); 2097 ck_assert_ptr_eq(r, null); 2098 terminateO(self); 2099 2100 END_TEST 2101 2102 2103 START_TEST(popVoidSmallArrayT) 2104 2105 void* r; 2106 smallArrayt *self = allocG(rtSmallArrayt); 2107 smallArrayt *r2; 2108 baset *r3; 2109 2110 // add an element to check that the second element is poped 2111 // at the end 2112 r2 = self->f->pushInt(self, 1); 2113 ck_assert_ptr_ne(r2, null); 2114 // add second element 2115 createSmallContainer(e); 2116 setValO(&e, &r); 2117 r2 = self->f->pushSmallContainer(self, &e); 2118 ck_assert_ptr_ne(r2, null); 2119 // pop 2120 r = self->f->popVoid(self); 2121 ck_assert_ptr_eq(r, &r); 2122 ck_assert_int_eq(lenO(self), 1); 2123 char *s = toStringO(self); 2124 ck_assert_str_eq(s, "[1]"); 2125 free(s); 2126 // pop element of unexpected type 2127 r = self->f->popVoid(self); 2128 ck_assert(!r); 2129 ck_assert_int_eq(lenO(self), 1); 2130 s = toStringO(self); 2131 ck_assert_str_eq(s, "[1]"); 2132 free(s); 2133 // empty array 2134 r3 = self->f->pop(self); 2135 ck_assert_ptr_ne(r3, null); 2136 terminateO(r3); 2137 s = toStringO(self); 2138 ck_assert_str_eq(s, "[]"); 2139 free(s); 2140 r = self->f->popVoid(self); 2141 ck_assert(!r); 2142 s = toStringO(self); 2143 ck_assert_str_eq(s, "[]"); 2144 free(s); 2145 terminateO(self); 2146 2147 END_TEST 2148 2149 2150 START_TEST(popSmallContainerSmallArrayT) 2151 2152 smallContainert* r; 2153 smallArrayt *self = allocG(rtSmallArrayt); 2154 smallArrayt *r2; 2155 baset *r3; 2156 2157 // add an element to check that the second element is poped 2158 // at the end 2159 r2 = self->f->pushInt(self, 1); 2160 ck_assert_ptr_ne(r2, null); 2161 // add second element 2162 createSmallContainer(e); 2163 r2 = self->f->pushSmallContainer(self, &e); 2164 ck_assert_ptr_ne(r2, null); 2165 r2 = self->f->pushUndefined(self); 2166 ck_assert_ptr_ne(r2, null); 2167 delElemO(self, -1); 2168 // pop 2169 r = self->f->popSmallContainer(self); 2170 ck_assert_ptr_ne(r, null); 2171 char *s = toStringO(r); 2172 terminateO(r); 2173 ck_assert_str_eq(s, "<data smallContainer>"); 2174 free(s); 2175 ck_assert_int_eq(lenO(self), 1); 2176 s = toStringO(self); 2177 ck_assert_str_eq(s, "[1]"); 2178 free(s); 2179 // container with baset object 2180 // push a base object of unknown type 2181 smallIntt *o = allocSmallInt(2); 2182 o->type = "newType"; 2183 r2 = self->f->pushNFree(self, (baset*)o); 2184 ck_assert_ptr_ne(r2, null); 2185 r = self->f->popSmallContainer(self); 2186 ck_assert_ptr_eq(r, NULL); 2187 ck_assert_int_eq(lenO(self), 2); 2188 s = toStringO(self); 2189 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 2190 free(s); 2191 r3 = self->f->pop(self); 2192 ck_assert_ptr_ne(r3, null); 2193 terminateO(r3); 2194 // pop element of unexpected type 2195 r = self->f->popSmallContainer(self); 2196 ck_assert_ptr_eq(r, NULL); 2197 ck_assert_int_eq(lenO(self), 1); 2198 s = toStringO(self); 2199 ck_assert_str_eq(s, "[1]"); 2200 free(s); 2201 // empty array 2202 r3 = self->f->pop(self); 2203 ck_assert_ptr_ne(r3, null); 2204 terminateO(r3); 2205 s = toStringO(self); 2206 ck_assert_str_eq(s, "[]"); 2207 free(s); 2208 r = self->f->popSmallContainer(self); 2209 ck_assert(!r); 2210 s = toStringO(self); 2211 ck_assert_str_eq(s, "[]"); 2212 free(s); 2213 r2 = self->f->pushUndefined(self); 2214 ck_assert_ptr_ne(r2, null); 2215 delElemO(self,-1); 2216 r = self->f->popSmallContainer(self); 2217 ck_assert_ptr_eq(r, null); 2218 terminateO(self); 2219 2220 END_TEST 2221 2222 2223 START_TEST(popNumSmallArrayT) 2224 2225 double r; 2226 smallArrayt *self = allocG(rtSmallArrayt); 2227 smallArrayt *r2; 2228 baset *r3; 2229 2230 // add an element to check that the second element is poped 2231 // at the end 2232 r2 = self->f->pushBool(self, TRUE); 2233 ck_assert_ptr_ne(r2, null); 2234 // add second element 2235 r2 = self->f->pushInt(self, 2); 2236 ck_assert_ptr_ne(r2, null); 2237 r2 = self->f->pushDouble(self, 2.5); 2238 ck_assert_ptr_ne(r2, null); 2239 r2 = self->f->pushUndefined(self); 2240 ck_assert_ptr_ne(r2, null); 2241 delElemO(self, -1); 2242 // pop 2243 r = self->f->popNum(self); 2244 ck_assert(r==2.5); 2245 ck_assert_int_eq(lenO(self), 2); 2246 char *s = toStringO(self); 2247 ck_assert_str_eq(s, "[true,2]"); 2248 free(s); 2249 r = self->f->popNum(self); 2250 ck_assert_int_eq(r, 2); 2251 ck_assert_int_eq(lenO(self), 1); 2252 s = toStringO(self); 2253 ck_assert_str_eq(s, "[true]"); 2254 free(s); 2255 // pop element of unexpected type 2256 r = self->f->popNum(self); 2257 ck_assert(!r); 2258 ck_assert_int_eq(lenO(self), 1); 2259 s = toStringO(self); 2260 ck_assert_str_eq(s, "[true]"); 2261 free(s); 2262 // empty array 2263 r3 = self->f->pop(self); 2264 ck_assert_ptr_ne(r3, null); 2265 terminateO(r3); 2266 s = toStringO(self); 2267 ck_assert_str_eq(s, "[]"); 2268 free(s); 2269 r = self->f->popNum(self); 2270 ck_assert(!r); 2271 s = toStringO(self); 2272 ck_assert_str_eq(s, "[]"); 2273 free(s); 2274 r2 = self->f->pushUndefined(self); 2275 ck_assert_ptr_ne(r2, null); 2276 delElemO(self,-1); 2277 r = self->f->popNum(self); 2278 ck_assert(!r); 2279 terminateO(self); 2280 2281 END_TEST 2282 2283 2284 START_TEST(prependSmallArrayT) 2285 2286 smallArrayt* r; 2287 smallArrayt *self = allocG(rtSmallArrayt); 2288 baset *value = (baset*) allocG(2); 2289 2290 // add an element to check that prepend adds the second element 2291 // at the start 2292 r = self->f->pushInt(self, 1); 2293 ck_assert_ptr_ne(r, null); 2294 2295 r = self->f->prepend(self, value); 2296 ck_assert_ptr_ne(r, null); 2297 ck_assert_int_eq(lenO(r), 2); 2298 finishO(value); 2299 char *s = toStringO(r); 2300 ck_assert_str_eq(s, "[2,1]"); 2301 free(s); 2302 // null 2303 r = self->f->prepend(self, null); 2304 ck_assert_ptr_eq(r, null); 2305 ck_assert_int_eq(lenO(self), 2); 2306 s = toStringO(self); 2307 ck_assert_str_eq(s, "[2,1]"); 2308 free(s); 2309 2310 //r = prependO(self); 2311 terminateO(self); 2312 2313 END_TEST 2314 2315 2316 START_TEST(prependUndefinedSmallArrayT) 2317 2318 smallArrayt* r; 2319 smallArrayt *self = allocG(rtSmallArrayt); 2320 2321 // add an element to check that push adds the second element 2322 // at the end 2323 r = self->f->pushInt(self, 1); 2324 ck_assert_ptr_ne(r, null); 2325 2326 r = self->f->prependUndefined(self); 2327 ck_assert_ptr_ne(r, null); 2328 ck_assert_int_eq(lenO(r), 2); 2329 char *s = toStringO(r); 2330 ck_assert_str_eq(s, "[null,1]"); 2331 free(s); 2332 terminateO(self); 2333 2334 END_TEST 2335 2336 2337 START_TEST(prependBoolSmallArrayT) 2338 2339 smallArrayt* r; 2340 smallArrayt *self = allocG(rtSmallArrayt); 2341 2342 // add an element to check that push adds the second element 2343 // at the end 2344 r = self->f->pushInt(self, 1); 2345 ck_assert_ptr_ne(r, null); 2346 2347 r = self->f->prependBool(self, TRUE); 2348 ck_assert_ptr_ne(r, null); 2349 ck_assert_int_eq(lenO(r), 2); 2350 char *s = toStringO(r); 2351 ck_assert_str_eq(s, "[true,1]"); 2352 free(s); 2353 terminateO(self); 2354 2355 END_TEST 2356 2357 2358 START_TEST(prependDoubleSmallArrayT) 2359 2360 smallArrayt* r; 2361 smallArrayt *self = allocG(rtSmallArrayt); 2362 2363 // add an element to check that push adds the second element 2364 // at the end 2365 r = self->f->pushInt(self, 1); 2366 ck_assert_ptr_ne(r, null); 2367 2368 r = self->f->prependDouble(self, 1.0); 2369 ck_assert_ptr_ne(r, null); 2370 ck_assert_int_eq(lenO(r), 2); 2371 char *s = toStringO(r); 2372 ck_assert_str_eq(s, "[1.000000e+00,1]"); 2373 free(s); 2374 terminateO(self); 2375 2376 END_TEST 2377 2378 2379 START_TEST(prependIntSmallArrayT) 2380 2381 smallArrayt* r; 2382 smallArrayt *self = allocG(rtSmallArrayt); 2383 2384 // add an element to check that push adds the second element 2385 // at the end 2386 r = self->f->prependInt(self, 1); 2387 ck_assert_ptr_ne(r, null); 2388 2389 r = self->f->prependInt(self, 1); 2390 ck_assert_ptr_ne(r, null); 2391 ck_assert_int_eq(lenO(r), 2); 2392 char *s = toStringO(r); 2393 ck_assert_str_eq(s, "[1,1]"); 2394 free(s); 2395 terminateO(self); 2396 2397 END_TEST 2398 2399 2400 START_TEST(prependSSmallArrayT) 2401 2402 smallArrayt* r; 2403 smallArrayt *self = allocG(rtSmallArrayt); 2404 2405 // add an element to check that push adds the second element 2406 // at the end 2407 r = self->f->pushInt(self, 1); 2408 ck_assert_ptr_ne(r, null); 2409 2410 r = self->f->prependS(self, null); 2411 ck_assert_ptr_eq(r, null); 2412 ck_assert_int_eq(lenO(self), 1); 2413 char *s = toStringO(self); 2414 ck_assert_str_eq(s, "[1]"); 2415 free(s); 2416 2417 char *str = "poi"; 2418 r = self->f->prependS(self, str); 2419 ck_assert_ptr_ne(r, null); 2420 ck_assert_int_eq(lenO(self), 2); 2421 s = toStringO(r); 2422 ck_assert_str_eq(s, "[\"poi\",1]"); 2423 free(s); 2424 2425 terminateO(self); 2426 2427 END_TEST 2428 2429 2430 START_TEST(prependCharSmallArrayT) 2431 2432 smallArrayt* r; 2433 smallArrayt *self = allocG(rtSmallArrayt); 2434 2435 // add an element to check that push adds the second element 2436 // at the end 2437 r = self->f->pushInt(self, 1); 2438 ck_assert_ptr_ne(r, null); 2439 2440 r = self->f->prependChar(self, 'a'); 2441 ck_assert_ptr_ne(r, null); 2442 ck_assert_int_eq(lenO(r), 2); 2443 char *s = toStringO(r); 2444 ck_assert_str_eq(s, "[\"a\",1]"); 2445 free(s); 2446 terminateO(self); 2447 2448 END_TEST 2449 2450 2451 START_TEST(prependDictSmallArrayT) 2452 2453 smallArrayt* r; 2454 smallArrayt *self = allocG(rtSmallArrayt); 2455 smallDictt *dict = allocG(rtSmallDictt); 2456 2457 // add an element to check that push adds the second element 2458 // at the end 2459 r = self->f->pushInt(self, 1); 2460 ck_assert_ptr_ne(r, null); 2461 2462 // push dict 2463 r = self->f->prependDict(self, dict); 2464 ck_assert_ptr_ne(r, null); 2465 ck_assert_int_eq(lenO(r), 2); 2466 finishO(dict); 2467 ck_assert_ptr_ne(r, null); 2468 char *s = toStringO(r); 2469 ck_assert_str_eq(s, "[{},1]"); 2470 free(s); 2471 // non smallDict object 2472 dict = (smallDictt*) allocSmallInt(2); 2473 r = self->f->prependDict(self, dict); 2474 ck_assert_ptr_eq(r, null); 2475 terminateO(dict); 2476 // null 2477 r = self->f->prependDict(self, null); 2478 ck_assert_ptr_eq(r, null); 2479 ck_assert_int_eq(lenO(self), 2); 2480 s = toStringO(self); 2481 ck_assert_str_eq(s, "[{},1]"); 2482 free(s); 2483 terminateO(self); 2484 2485 END_TEST 2486 2487 2488 START_TEST(prependArraySmallArrayT) 2489 2490 smallArrayt* r; 2491 smallArrayt *self = allocG(rtSmallArrayt); 2492 smallArrayt *array = allocG(rtSmallArrayt); 2493 2494 // add an element to check that push adds the second element 2495 // at the end 2496 r = self->f->pushInt(self, 1); 2497 ck_assert_ptr_ne(r, null); 2498 2499 r = self->f->prependArray(self, array); 2500 ck_assert_ptr_ne(r, null); 2501 ck_assert_int_eq(lenO(r), 2); 2502 finishO(array); 2503 char *s = toStringO(r); 2504 ck_assert_str_eq(s, "[[],1]"); 2505 free(s); 2506 // non smallArray object 2507 array = (smallArrayt*) allocSmallInt(2); 2508 r = self->f->prependArray(self, array); 2509 ck_assert_ptr_eq(r, null); 2510 terminateO(array); 2511 // null 2512 r = self->f->prependArray(self, null); 2513 ck_assert_ptr_eq(r, null); 2514 ck_assert_int_eq(lenO(self), 2); 2515 s = toStringO(self); 2516 ck_assert_str_eq(s, "[[],1]"); 2517 free(s); 2518 terminateO(self); 2519 2520 END_TEST 2521 2522 2523 START_TEST(prependArraycSmallArrayT) 2524 2525 smallArrayt* r; 2526 smallArrayt *self = allocG(rtSmallArrayt); 2527 char **array = listCreateS("a","bb"); 2528 2529 // add an element to check that push adds the second element 2530 // at the end 2531 r = self->f->pushInt(self, 1); 2532 ck_assert_ptr_ne(r, null); 2533 2534 r = self->f->prependArrayc(self, array); 2535 ck_assert_ptr_ne(r, null); 2536 ck_assert_int_eq(lenO(r), 2); 2537 listFreeS(array); 2538 char *s = toStringO(r); 2539 ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]"); 2540 free(s); 2541 // null 2542 r = self->f->prependArrayc(self, null); 2543 ck_assert_ptr_eq(r, null); 2544 ck_assert_int_eq(lenO(self), 2); 2545 s = toStringO(self); 2546 ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]"); 2547 free(s); 2548 terminateO(self); 2549 2550 END_TEST 2551 2552 2553 START_TEST(prependSmallBoolSmallArrayT) 2554 2555 smallArrayt* r; 2556 smallArrayt *self = allocG(rtSmallArrayt); 2557 smallBoolt *value = allocG(TRUE); 2558 2559 // add an element to check that push adds the second element 2560 // at the end 2561 r = self->f->pushInt(self, 1); 2562 ck_assert_ptr_ne(r, null); 2563 2564 r = self->f->prependSmallBool(self, value); 2565 ck_assert_ptr_ne(r, null); 2566 ck_assert_int_eq(lenO(r), 2); 2567 finishO(value); 2568 char *s = toStringO(r); 2569 ck_assert_str_eq(s, "[true,1]"); 2570 free(s); 2571 // bool object with no data 2572 createAllocateSmallBool(b); 2573 r = self->f->prependSmallBool(self, b); 2574 ck_assert_ptr_ne(r, null); 2575 ck_assert_int_eq(lenO(r), 3); 2576 finishO(b); 2577 s = toStringO(r); 2578 ck_assert_str_eq(s, "[false,true,1]"); 2579 free(s); 2580 // non smallBool object 2581 value = (smallBoolt*) allocSmallInt(2); 2582 r = self->f->prependSmallBool(self, value); 2583 ck_assert_ptr_eq(r, null); 2584 terminateO(value); 2585 // null 2586 r = self->f->prependSmallBool(self, null); 2587 ck_assert_ptr_eq(r, null); 2588 ck_assert_int_eq(lenO(self), 3); 2589 s = toStringO(self); 2590 ck_assert_str_eq(s, "[false,true,1]"); 2591 free(s); 2592 terminateO(self); 2593 2594 END_TEST 2595 2596 2597 START_TEST(prependSmallBytesSmallArrayT) 2598 2599 smallArrayt* r; 2600 smallArrayt *self = allocG(rtSmallArrayt); 2601 createAllocateSmallBytes(value); 2602 2603 // add an element to check that push adds the second element 2604 // at the end 2605 r = self->f->pushInt(self, 1); 2606 ck_assert_ptr_ne(r, null); 2607 2608 // the smallBytes container is empty 2609 r = self->f->prependSmallBytes(self, value); 2610 ck_assert_ptr_ne(r, null); 2611 ck_assert_int_eq(lenO(r), 2); 2612 char *s = toStringO(r); 2613 ck_assert_str_eq(s, "[[],1]"); 2614 free(s); 2615 // reuse value 2616 value->B = null; 2617 char *buffer = "poi"; 2618 pushBufferO(value, buffer, strlen(buffer)); 2619 r = self->f->prependSmallBytes(self, value); 2620 finishO(value); 2621 ck_assert_ptr_ne(r, null); 2622 ck_assert_int_eq(lenO(r), 3); 2623 s = toStringO(r); 2624 ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]"); 2625 free(s); 2626 // non smallBytes object 2627 value = (smallBytest*) allocSmallInt(2); 2628 r = self->f->prependSmallBytes(self, value); 2629 ck_assert_ptr_eq(r, null); 2630 terminateO(value); 2631 // null 2632 r = self->f->prependSmallBytes(self, null); 2633 ck_assert_ptr_eq(r, null); 2634 ck_assert_int_eq(lenO(self), 3); 2635 s = toStringO(self); 2636 ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]"); 2637 free(s); 2638 terminateO(self); 2639 2640 END_TEST 2641 2642 2643 START_TEST(prependSmallDoubleSmallArrayT) 2644 2645 smallArrayt* r; 2646 smallArrayt *self = allocG(rtSmallArrayt); 2647 smallDoublet *value = allocG(1.0); 2648 2649 // add an element to check that push adds the second element 2650 // at the end 2651 r = self->f->pushInt(self, 1); 2652 ck_assert_ptr_ne(r, null); 2653 2654 r = self->f->prependSmallDouble(self, value); 2655 ck_assert_ptr_ne(r, null); 2656 ck_assert_int_eq(lenO(r), 2); 2657 finishO(value); 2658 char *s = toStringO(r); 2659 ck_assert_str_eq(s, "[1.000000e+00,1]"); 2660 free(s); 2661 // object with no data 2662 createAllocateSmallDouble(b); 2663 r = self->f->prependSmallDouble(self, b); 2664 ck_assert_ptr_ne(r, null); 2665 ck_assert_int_eq(lenO(r), 3); 2666 finishO(b); 2667 s = toStringO(r); 2668 ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]"); 2669 free(s); 2670 // non smallDouble object 2671 value = (smallDoublet*) allocSmallInt(2); 2672 r = self->f->prependSmallDouble(self, value); 2673 ck_assert_ptr_eq(r, null); 2674 terminateO(value); 2675 // null 2676 r = self->f->prependSmallDouble(self, null); 2677 ck_assert_ptr_eq(r, null); 2678 ck_assert_int_eq(lenO(self), 3); 2679 s = toStringO(self); 2680 ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]"); 2681 free(s); 2682 terminateO(self); 2683 2684 END_TEST 2685 2686 2687 START_TEST(prependSmallIntSmallArrayT) 2688 2689 smallArrayt* r; 2690 smallArrayt *self = allocG(rtSmallArrayt); 2691 smallIntt *value = allocG(1); 2692 2693 // add an element to check that push adds the second element 2694 // at the end 2695 r = self->f->pushInt(self, 1); 2696 ck_assert_ptr_ne(r, null); 2697 2698 r = self->f->prependSmallInt(self, value); 2699 ck_assert_ptr_ne(r, null); 2700 ck_assert_int_eq(lenO(r), 2); 2701 finishO(value); 2702 char *s = toStringO(r); 2703 ck_assert_str_eq(s, "[1,1]"); 2704 free(s); 2705 // bool object with no data 2706 createAllocateSmallInt(b); 2707 r = self->f->prependSmallInt(self, b); 2708 ck_assert_ptr_ne(r, null); 2709 ck_assert_int_eq(lenO(r), 3); 2710 finishO(b); 2711 s = toStringO(r); 2712 ck_assert_str_eq(s, "[0,1,1]"); 2713 free(s); 2714 // non smallInt object 2715 value = (smallIntt*) allocSmallBool(true); 2716 r = self->f->prependSmallInt(self, value); 2717 ck_assert_ptr_eq(r, null); 2718 terminateO(value); 2719 // null 2720 r = self->f->prependSmallInt(self, null); 2721 ck_assert_ptr_eq(r, null); 2722 ck_assert_int_eq(lenO(self), 3); 2723 s = toStringO(self); 2724 ck_assert_str_eq(s, "[0,1,1]"); 2725 free(s); 2726 terminateO(self); 2727 2728 END_TEST 2729 2730 2731 START_TEST(prependSmallJsonSmallArrayT) 2732 2733 smallArrayt* r; 2734 smallArrayt *self = allocG(rtSmallArrayt); 2735 smallJsont *value = allocG(rtSmallJsont); 2736 2737 // add an element to check that push adds the second element 2738 // at the end 2739 r = self->f->pushInt(self, 1); 2740 ck_assert_ptr_ne(r, null); 2741 2742 // the smallJson container is empty 2743 r = self->f->prependSmallJson(self, value); 2744 ck_assert_ptr_ne(r, null); 2745 ck_assert_int_eq(lenO(r), 2); 2746 char *s = toStringO(r); 2747 ck_assert_str_eq(s, "[{},1]"); 2748 free(s); 2749 resetO(value); 2750 parseO(value, "{}"); 2751 r = self->f->prependSmallJson(self, value); 2752 finishO(value); 2753 ck_assert_ptr_ne(r, null); 2754 ck_assert_int_eq(lenO(r), 3); 2755 s = toStringO(r); 2756 ck_assert_str_eq(s, "[{},{},1]"); 2757 free(s); 2758 // non smallJson object 2759 value = (smallJsont*) allocSmallInt(2); 2760 r = self->f->prependSmallJson(self, value); 2761 ck_assert_ptr_eq(r, null); 2762 terminateO(value); 2763 // null 2764 r = self->f->prependSmallJson(self, null); 2765 ck_assert_ptr_eq(r, null); 2766 ck_assert_int_eq(lenO(self), 3); 2767 s = toStringO(self); 2768 ck_assert_str_eq(s, "[{},{},1]"); 2769 free(s); 2770 terminateO(self); 2771 2772 END_TEST 2773 2774 2775 START_TEST(prependSmallStringSmallArrayT) 2776 2777 smallArrayt* r; 2778 smallArrayt *self = allocG(rtSmallArrayt); 2779 createAllocateSmallString(string); 2780 2781 // add an element to check that push adds the second element 2782 // at the end 2783 r = self->f->pushInt(self, 1); 2784 ck_assert_ptr_ne(r, null); 2785 2786 r = self->f->prependSmallString(self, string); 2787 ck_assert_ptr_ne(r, null); 2788 ck_assert_int_eq(lenO(r), 2); 2789 finishO(string); 2790 char *s = toStringO(r); 2791 ck_assert_str_eq(s, "[\"\",1]"); 2792 free(s); 2793 // non smallString object 2794 string = (smallStringt*) allocSmallInt(2); 2795 r = self->f->prependSmallString(self, string); 2796 ck_assert_ptr_eq(r, null); 2797 terminateO(string); 2798 // null 2799 r = self->f->prependSmallString(self, null); 2800 ck_assert_ptr_eq(r, null); 2801 ck_assert_int_eq(lenO(self), 2); 2802 s = toStringO(self); 2803 ck_assert_str_eq(s, "[\"\",1]"); 2804 free(s); 2805 terminateO(self); 2806 2807 END_TEST 2808 2809 2810 START_TEST(prependSmallContainerSmallArrayT) 2811 2812 smallArrayt* r; 2813 smallArrayt *self = allocG(rtSmallArrayt); 2814 createAllocateSmallContainer(container); 2815 2816 // add an element to check that push adds the second element 2817 // at the end 2818 r = self->f->pushInt(self, 1); 2819 ck_assert_ptr_ne(r, null); 2820 2821 r = self->f->prependSmallContainer(self, container); 2822 ck_assert_ptr_ne(r, null); 2823 ck_assert_int_eq(lenO(r), 2); 2824 finishO(container); 2825 char *s = toStringO(r); 2826 ck_assert_str_eq(s, "[\"<data container>\",1]"); 2827 free(s); 2828 // non smallContainer object 2829 container = (smallContainert*) allocSmallInt(2); 2830 r = self->f->prependSmallContainer(self, container); 2831 ck_assert_ptr_eq(r, null); 2832 terminateO(container); 2833 // null 2834 r = self->f->prependSmallContainer(self, null); 2835 ck_assert_ptr_eq(r, null); 2836 ck_assert_int_eq(lenO(self), 2); 2837 s = toStringO(self); 2838 ck_assert_str_eq(s, "[\"<data container>\",1]"); 2839 free(s); 2840 terminateO(self); 2841 2842 END_TEST 2843 2844 2845 START_TEST(prependNFreeSmallArrayT) 2846 2847 smallArrayt* r; 2848 smallArrayt *self = allocG(rtSmallArrayt); 2849 baset *value = (baset*) allocG(2); 2850 2851 // add an element to check that prepend adds the second element 2852 // at the start 2853 r = self->f->pushInt(self, 1); 2854 ck_assert_ptr_ne(r, null); 2855 2856 r = self->f->prependNFree(self, value); 2857 ck_assert_ptr_ne(r, null); 2858 ck_assert_int_eq(lenO(r), 2); 2859 char *s = toStringO(r); 2860 ck_assert_str_eq(s, "[2,1]"); 2861 free(s); 2862 // null 2863 r = self->f->prependNFree(self, null); 2864 ck_assert_ptr_eq(r, null); 2865 ck_assert_int_eq(lenO(self), 2); 2866 s = toStringO(self); 2867 ck_assert_str_eq(s, "[2,1]"); 2868 free(s); 2869 2870 //r = prependO(self); 2871 terminateO(self); 2872 2873 END_TEST 2874 2875 2876 START_TEST(prependNFreeUndefinedSmallArrayT) 2877 2878 smallArrayt* r; 2879 smallArrayt *self = allocG(rtSmallArrayt); 2880 2881 // add an element to check that push adds the second element 2882 // at the end 2883 r = self->f->pushInt(self, 1); 2884 ck_assert_ptr_ne(r, null); 2885 2886 createAllocateUndefined(value); 2887 r = self->f->prependNFreeUndefined(self, value); 2888 ck_assert_ptr_ne(r, null); 2889 ck_assert_int_eq(lenO(r), 2); 2890 char *s = toStringO(r); 2891 ck_assert_str_eq(s, "[null,1]"); 2892 free(s); 2893 terminateO(self); 2894 2895 END_TEST 2896 2897 2898 START_TEST(prependNFreeSSmallArrayT) 2899 2900 smallArrayt* r; 2901 smallArrayt *self = allocG(rtSmallArrayt); 2902 2903 // add an element to check that push adds the second element 2904 // at the end 2905 r = self->f->pushInt(self, 1); 2906 ck_assert_ptr_ne(r, null); 2907 2908 r = self->f->prependNFreeS(self, null); 2909 ck_assert_ptr_eq(r, null); 2910 ck_assert_int_eq(lenO(self), 1); 2911 char *s = toStringO(self); 2912 ck_assert_str_eq(s, "[1]"); 2913 free(s); 2914 2915 char *str = strdup("poi"); 2916 r = self->f->prependNFreeS(self, str); 2917 ck_assert_ptr_ne(r, null); 2918 ck_assert_int_eq(lenO(self), 2); 2919 s = toStringO(r); 2920 ck_assert_str_eq(s, "[\"poi\",1]"); 2921 free(s); 2922 2923 terminateO(self); 2924 2925 END_TEST 2926 2927 2928 START_TEST(prependNFreeDictSmallArrayT) 2929 2930 smallArrayt* r; 2931 smallArrayt *self = allocG(rtSmallArrayt); 2932 smallDictt *dict = allocG(rtSmallDictt); 2933 2934 // add an element to check that push adds the second element 2935 // at the end 2936 r = self->f->pushInt(self, 1); 2937 ck_assert_ptr_ne(r, null); 2938 2939 // push dict 2940 r = self->f->prependNFreeDict(self, dict); 2941 ck_assert_ptr_ne(r, null); 2942 ck_assert_int_eq(lenO(r), 2); 2943 ck_assert_ptr_ne(r, null); 2944 char *s = toStringO(r); 2945 ck_assert_str_eq(s, "[{},1]"); 2946 free(s); 2947 // null 2948 r = self->f->prependNFreeDict(self, null); 2949 ck_assert_ptr_eq(r, null); 2950 ck_assert_int_eq(lenO(self), 2); 2951 s = toStringO(self); 2952 ck_assert_str_eq(s, "[{},1]"); 2953 free(s); 2954 terminateO(self); 2955 2956 END_TEST 2957 2958 2959 START_TEST(prependNFreeArraySmallArrayT) 2960 2961 smallArrayt* r; 2962 smallArrayt *self = allocG(rtSmallArrayt); 2963 smallArrayt *array = allocG(rtSmallArrayt); 2964 2965 // add an element to check that push adds the second element 2966 // at the end 2967 r = self->f->pushInt(self, 1); 2968 ck_assert_ptr_ne(r, null); 2969 2970 r = self->f->prependNFreeArray(self, array); 2971 ck_assert_ptr_ne(r, null); 2972 ck_assert_int_eq(lenO(r), 2); 2973 char *s = toStringO(r); 2974 ck_assert_str_eq(s, "[[],1]"); 2975 free(s); 2976 // null 2977 r = self->f->prependNFreeArray(self, null); 2978 ck_assert_ptr_eq(r, null); 2979 ck_assert_int_eq(lenO(self), 2); 2980 s = toStringO(self); 2981 ck_assert_str_eq(s, "[[],1]"); 2982 free(s); 2983 terminateO(self); 2984 2985 END_TEST 2986 2987 2988 START_TEST(prependNFreeArraycSmallArrayT) 2989 2990 smallArrayt* r; 2991 smallArrayt *self = allocG(rtSmallArrayt); 2992 char **array = listCreateS("a","bb"); 2993 2994 // add an element to check that push adds the second element 2995 // at the end 2996 r = self->f->pushInt(self, 1); 2997 ck_assert_ptr_ne(r, null); 2998 2999 r = self->f->prependNFreeArrayc(self, array); 3000 ck_assert_ptr_ne(r, null); 3001 ck_assert_int_eq(lenO(r), 2); 3002 char *s = toStringO(r); 3003 ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]"); 3004 free(s); 3005 // null 3006 r = self->f->prependNFreeArrayc(self, null); 3007 ck_assert_ptr_eq(r, null); 3008 ck_assert_int_eq(lenO(self), 2); 3009 s = toStringO(self); 3010 ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]"); 3011 free(s); 3012 terminateO(self); 3013 3014 END_TEST 3015 3016 3017 START_TEST(prependNFreeSmallBoolSmallArrayT) 3018 3019 smallArrayt* r; 3020 smallArrayt *self = allocG(rtSmallArrayt); 3021 smallBoolt *value = allocG(TRUE); 3022 3023 // add an element to check that push adds the second element 3024 // at the end 3025 r = self->f->pushInt(self, 1); 3026 ck_assert_ptr_ne(r, null); 3027 3028 r = self->f->prependNFreeSmallBool(self, value); 3029 ck_assert_ptr_ne(r, null); 3030 ck_assert_int_eq(lenO(r), 2); 3031 char *s = toStringO(r); 3032 ck_assert_str_eq(s, "[true,1]"); 3033 free(s); 3034 // bool object with no data 3035 createAllocateSmallBool(b); 3036 r = self->f->prependNFreeSmallBool(self, b); 3037 ck_assert_ptr_ne(r, null); 3038 ck_assert_int_eq(lenO(r), 3); 3039 s = toStringO(r); 3040 ck_assert_str_eq(s, "[false,true,1]"); 3041 free(s); 3042 // null 3043 r = self->f->prependNFreeSmallBool(self, null); 3044 ck_assert_ptr_eq(r, null); 3045 ck_assert_int_eq(lenO(self), 3); 3046 s = toStringO(self); 3047 ck_assert_str_eq(s, "[false,true,1]"); 3048 free(s); 3049 terminateO(self); 3050 3051 END_TEST 3052 3053 3054 START_TEST(prependNFreeSmallBytesSmallArrayT) 3055 3056 smallArrayt* r; 3057 smallArrayt *self = allocG(rtSmallArrayt); 3058 createAllocateSmallBytes(value); 3059 3060 // add an element to check that push adds the second element 3061 // at the end 3062 r = self->f->pushInt(self, 1); 3063 ck_assert_ptr_ne(r, null); 3064 3065 // the smallBytes container is empty 3066 r = self->f->prependNFreeSmallBytes(self, value); 3067 ck_assert_ptr_ne(r, null); 3068 ck_assert_int_eq(lenO(r), 2); 3069 char *s = toStringO(r); 3070 ck_assert_str_eq(s, "[[],1]"); 3071 free(s); 3072 3073 char *buffer = "poi"; 3074 value = allocSmallBytes(buffer, strlen(buffer)); 3075 r = self->f->prependNFreeSmallBytes(self, value); 3076 ck_assert_ptr_ne(r, null); 3077 ck_assert_int_eq(lenO(r), 3); 3078 s = toStringO(r); 3079 ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]"); 3080 free(s); 3081 // null 3082 r = self->f->prependNFreeSmallBytes(self, null); 3083 ck_assert_ptr_eq(r, null); 3084 ck_assert_int_eq(lenO(self), 3); 3085 s = toStringO(self); 3086 ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]"); 3087 free(s); 3088 terminateO(self); 3089 3090 END_TEST 3091 3092 3093 START_TEST(prependNFreeSmallDoubleSmallArrayT) 3094 3095 smallArrayt* r; 3096 smallArrayt *self = allocG(rtSmallArrayt); 3097 smallDoublet *value = allocG(1.0); 3098 3099 // add an element to check that push adds the second element 3100 // at the end 3101 r = self->f->pushInt(self, 1); 3102 ck_assert_ptr_ne(r, null); 3103 3104 r = self->f->prependNFreeSmallDouble(self, value); 3105 ck_assert_ptr_ne(r, null); 3106 ck_assert_int_eq(lenO(r), 2); 3107 char *s = toStringO(r); 3108 ck_assert_str_eq(s, "[1.000000e+00,1]"); 3109 free(s); 3110 // object with no data 3111 createAllocateSmallDouble(b); 3112 r = self->f->prependNFreeSmallDouble(self, b); 3113 ck_assert_ptr_ne(r, null); 3114 ck_assert_int_eq(lenO(r), 3); 3115 s = toStringO(r); 3116 ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]"); 3117 free(s); 3118 // null 3119 r = self->f->prependNFreeSmallDouble(self, null); 3120 ck_assert_ptr_eq(r, null); 3121 ck_assert_int_eq(lenO(self), 3); 3122 s = toStringO(self); 3123 ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]"); 3124 free(s); 3125 terminateO(self); 3126 3127 END_TEST 3128 3129 3130 START_TEST(prependNFreeSmallIntSmallArrayT) 3131 3132 smallArrayt* r; 3133 smallArrayt *self = allocG(rtSmallArrayt); 3134 smallIntt *value = allocG(1); 3135 3136 // add an element to check that push adds the second element 3137 // at the end 3138 r = self->f->pushInt(self, 1); 3139 ck_assert_ptr_ne(r, null); 3140 3141 r = self->f->prependNFreeSmallInt(self, value); 3142 ck_assert_ptr_ne(r, null); 3143 ck_assert_int_eq(lenO(r), 2); 3144 char *s = toStringO(r); 3145 ck_assert_str_eq(s, "[1,1]"); 3146 free(s); 3147 // bool object with no data 3148 createAllocateSmallInt(b); 3149 r = self->f->prependNFreeSmallInt(self, b); 3150 ck_assert_ptr_ne(r, null); 3151 ck_assert_int_eq(lenO(r), 3); 3152 s = toStringO(r); 3153 ck_assert_str_eq(s, "[0,1,1]"); 3154 free(s); 3155 // null 3156 r = self->f->prependNFreeSmallInt(self, null); 3157 ck_assert_ptr_eq(r, null); 3158 ck_assert_int_eq(lenO(self), 3); 3159 s = toStringO(self); 3160 ck_assert_str_eq(s, "[0,1,1]"); 3161 free(s); 3162 terminateO(self); 3163 3164 END_TEST 3165 3166 3167 START_TEST(prependNFreeSmallJsonSmallArrayT) 3168 3169 smallArrayt* r; 3170 smallArrayt *self = allocG(rtSmallArrayt); 3171 smallJsont *value = allocG(rtSmallJsont); 3172 3173 // add an element to check that push adds the second element 3174 // at the end 3175 r = self->f->pushInt(self, 1); 3176 ck_assert_ptr_ne(r, null); 3177 3178 // the smallJson container is empty 3179 r = self->f->prependNFreeSmallJson(self, value); 3180 ck_assert_ptr_ne(r, null); 3181 ck_assert_int_eq(lenO(r), 2); 3182 char *s = toStringO(r); 3183 ck_assert_str_eq(s, "[{},1]"); 3184 free(s); 3185 3186 value = allocG(rtSmallJsont); 3187 parseO(value, "{}"); 3188 r = self->f->prependNFreeSmallJson(self, value); 3189 ck_assert_ptr_ne(r, null); 3190 ck_assert_int_eq(lenO(r), 3); 3191 s = toStringO(r); 3192 ck_assert_str_eq(s, "[{},{},1]"); 3193 free(s); 3194 // null 3195 r = self->f->prependNFreeSmallJson(self, null); 3196 ck_assert_ptr_eq(r, null); 3197 ck_assert_int_eq(lenO(self), 3); 3198 s = toStringO(self); 3199 ck_assert_str_eq(s, "[{},{},1]"); 3200 free(s); 3201 terminateO(self); 3202 3203 END_TEST 3204 3205 3206 START_TEST(prependNFreeSmallStringSmallArrayT) 3207 3208 smallArrayt* r; 3209 smallArrayt *self = allocG(rtSmallArrayt); 3210 createAllocateSmallString(string); 3211 3212 // add an element to check that push adds the second element 3213 // at the end 3214 r = self->f->pushInt(self, 1); 3215 ck_assert_ptr_ne(r, null); 3216 3217 r = self->f->prependNFreeSmallString(self, string); 3218 ck_assert_ptr_ne(r, null); 3219 ck_assert_int_eq(lenO(r), 2); 3220 char *s = toStringO(r); 3221 ck_assert_str_eq(s, "[\"\",1]"); 3222 free(s); 3223 // null 3224 r = self->f->prependNFreeSmallString(self, null); 3225 ck_assert_ptr_eq(r, null); 3226 ck_assert_int_eq(lenO(self), 2); 3227 s = toStringO(self); 3228 ck_assert_str_eq(s, "[\"\",1]"); 3229 free(s); 3230 terminateO(self); 3231 3232 END_TEST 3233 3234 3235 START_TEST(prependNFreeSmallContainerSmallArrayT) 3236 3237 smallArrayt* r; 3238 smallArrayt *self = allocG(rtSmallArrayt); 3239 createAllocateSmallContainer(container); 3240 3241 // add an element to check that push adds the second element 3242 // at the end 3243 r = self->f->pushInt(self, 1); 3244 ck_assert_ptr_ne(r, null); 3245 3246 r = self->f->prependNFreeSmallContainer(self, container); 3247 ck_assert_ptr_ne(r, null); 3248 ck_assert_int_eq(lenO(r), 2); 3249 char *s = toStringO(r); 3250 ck_assert_str_eq(s, "[\"<data container>\",1]"); 3251 free(s); 3252 // null 3253 r = self->f->prependNFreeSmallContainer(self, null); 3254 ck_assert_ptr_eq(r, null); 3255 ck_assert_int_eq(lenO(self), 2); 3256 s = toStringO(self); 3257 ck_assert_str_eq(s, "[\"<data container>\",1]"); 3258 free(s); 3259 terminateO(self); 3260 3261 END_TEST 3262 3263 3264 START_TEST(dequeueSmallArrayT) 3265 3266 baset* r; 3267 smallArrayt *self = allocG(rtSmallArrayt); 3268 smallArrayt *r2; 3269 3270 // add an element to check that the second element is dequeueed 3271 // at the end 3272 r2 = self->f->prependInt(self, 1); 3273 ck_assert_ptr_ne(r2, null); 3274 // prepend a base object of unknown type 3275 smallIntt *o = allocSmallInt(2); 3276 o->type = "newType"; 3277 r2 = self->f->prependNFree(self, (baset*)o); 3278 ck_assert_ptr_ne(r2, null); 3279 r2 = self->f->prependUndefined(self); 3280 ck_assert_ptr_ne(r2, null); 3281 r = self->f->dequeue(self); 3282 ck_assert_ptr_ne(r, null); 3283 ck_assert(isOUndefined(r)); 3284 terminateO(r); 3285 r = self->f->dequeue(self); 3286 ck_assert_ptr_ne(r, null); 3287 ck_assert_str_eq(r->type, "newType"); 3288 char *s = toStringO(r); 3289 terminateO(r); 3290 ck_assert_str_eq(s, "2"); 3291 free(s); 3292 ck_assert_int_eq(lenO(self), 1); 3293 s = toStringO(self); 3294 ck_assert_str_eq(s, "[1]"); 3295 free(s); 3296 // empty array 3297 r = self->f->dequeue(self); 3298 ck_assert_ptr_ne(r, null); 3299 terminateO(r); 3300 s = toStringO(self); 3301 ck_assert_str_eq(s, "[]"); 3302 free(s); 3303 r = self->f->dequeue(self); 3304 ck_assert_ptr_eq(r, null); 3305 s = toStringO(self); 3306 ck_assert_str_eq(s, "[]"); 3307 free(s); 3308 r2 = self->f->pushUndefined(self); 3309 ck_assert_ptr_ne(r2, null); 3310 delElemO(self,-1); 3311 r = self->f->dequeue(self); 3312 ck_assert_ptr_eq(r, null); 3313 terminateO(self); 3314 3315 END_TEST 3316 3317 3318 START_TEST(dequeueUndefinedSmallArrayT) 3319 3320 undefinedt* r; 3321 smallArrayt *self = allocG(rtSmallArrayt); 3322 smallArrayt *r2; 3323 baset *r3; 3324 3325 // add an element to check that the second element is poped 3326 // at the end 3327 r2 = self->f->pushInt(self, 1); 3328 ck_assert_ptr_ne(r2, null); 3329 // add second element 3330 r2 = self->f->prependUndefined(self); 3331 ck_assert_ptr_ne(r2, null); 3332 // pop 3333 r = self->f->dequeueUndefined(self); 3334 ck_assert_ptr_ne(r, null); 3335 char *s = toStringO(r); 3336 terminateO(r); 3337 ck_assert_str_eq(s, "null"); 3338 free(s); 3339 ck_assert_int_eq(lenO(self), 1); 3340 s = toStringO(self); 3341 ck_assert_str_eq(s, "[1]"); 3342 free(s); 3343 // pop element of unexpected type 3344 r = self->f->dequeueUndefined(self); 3345 ck_assert_ptr_eq(r, null); 3346 ck_assert_int_eq(lenO(self), 1); 3347 s = toStringO(self); 3348 ck_assert_str_eq(s, "[1]"); 3349 free(s); 3350 // empty array 3351 r3 = self->f->pop(self); 3352 ck_assert_ptr_ne(r3, null); 3353 terminateO(r3); 3354 s = toStringO(self); 3355 ck_assert_str_eq(s, "[]"); 3356 free(s); 3357 r = self->f->dequeueUndefined(self); 3358 ck_assert_ptr_eq(r, null); 3359 s = toStringO(self); 3360 ck_assert_str_eq(s, "[]"); 3361 free(s); 3362 r2 = self->f->pushUndefined(self); 3363 ck_assert_ptr_ne(r2, null); 3364 delElemO(self,-1); 3365 r = self->f->dequeueUndefined(self); 3366 ck_assert_ptr_eq(r, null); 3367 terminateO(self); 3368 3369 END_TEST 3370 3371 3372 START_TEST(dequeueBoolSmallArrayT) 3373 3374 bool r; 3375 smallArrayt *self = allocG(rtSmallArrayt); 3376 smallArrayt *r2; 3377 baset *r3; 3378 3379 // add an element to check that the second element is poped 3380 // at the end 3381 r2 = self->f->pushInt(self, 1); 3382 ck_assert_ptr_ne(r2, null); 3383 3384 // add second element 3385 r2 = self->f->prependBool(self, TRUE); 3386 ck_assert_ptr_ne(r2, null); 3387 3388 // pop 3389 r = self->f->dequeueBool(self); 3390 ck_assert(r); 3391 ck_assert_int_eq(lenO(self), 1); 3392 char *s = toStringO(self); 3393 ck_assert_str_eq(s, "[1]"); 3394 free(s); 3395 3396 // pop element of unexpected type 3397 r = self->f->dequeueBool(self); 3398 ck_assert(!r); 3399 ck_assert_int_eq(lenO(self), 1); 3400 s = toStringO(self); 3401 ck_assert_str_eq(s, "[1]"); 3402 free(s); 3403 3404 // empty array 3405 r3 = self->f->pop(self); 3406 ck_assert_ptr_ne(r3, null); 3407 terminateO(r3); 3408 s = toStringO(self); 3409 ck_assert_str_eq(s, "[]"); 3410 free(s); 3411 r = self->f->dequeueBool(self); 3412 ck_assert(!r); 3413 s = toStringO(self); 3414 ck_assert_str_eq(s, "[]"); 3415 free(s); 3416 terminateO(self); 3417 3418 END_TEST 3419 3420 3421 START_TEST(dequeueDoubleSmallArrayT) 3422 3423 double r; 3424 smallArrayt *self = allocG(rtSmallArrayt); 3425 smallArrayt *r2; 3426 baset *r3; 3427 3428 // add an element to check that the second element is poped 3429 // at the end 3430 r2 = self->f->pushInt(self, 1); 3431 ck_assert_ptr_ne(r2, null); 3432 3433 // add second element 3434 r2 = self->f->prependDouble(self, 2.0); 3435 ck_assert_ptr_ne(r2, null); 3436 3437 // pop 3438 r = self->f->dequeueDouble(self); 3439 ck_assert(r==2.0); 3440 ck_assert_int_eq(lenO(self), 1); 3441 char *s = toStringO(self); 3442 ck_assert_str_eq(s, "[1]"); 3443 free(s); 3444 3445 // pop element of unexpected type 3446 r = self->f->dequeueDouble(self); 3447 ck_assert(!r); 3448 ck_assert_int_eq(lenO(self), 1); 3449 s = toStringO(self); 3450 ck_assert_str_eq(s, "[1]"); 3451 free(s); 3452 3453 // empty array 3454 r3 = self->f->pop(self); 3455 ck_assert_ptr_ne(r3, null); 3456 terminateO(r3); 3457 s = toStringO(self); 3458 ck_assert_str_eq(s, "[]"); 3459 free(s); 3460 r = self->f->dequeueDouble(self); 3461 ck_assert(!r); 3462 s = toStringO(self); 3463 ck_assert_str_eq(s, "[]"); 3464 free(s); 3465 terminateO(self); 3466 3467 END_TEST 3468 3469 3470 START_TEST(dequeueIntSmallArrayT) 3471 3472 int64_t r; 3473 smallArrayt *self = allocG(rtSmallArrayt); 3474 smallArrayt *r2; 3475 baset *r3; 3476 3477 // add an element to check that the second element is poped 3478 // at the end 3479 r2 = self->f->pushBool(self, FALSE); 3480 ck_assert_ptr_ne(r2, null); 3481 3482 // add second element 3483 r2 = self->f->prependInt(self, 2); 3484 ck_assert_ptr_ne(r2, null); 3485 3486 // pop 3487 r = self->f->dequeueInt(self); 3488 ck_assert_int_eq(r, 2); 3489 ck_assert_int_eq(lenO(self), 1); 3490 char *s = toStringO(self); 3491 ck_assert_str_eq(s, "[false]"); 3492 free(s); 3493 3494 // pop element of unexpected type 3495 r = self->f->dequeueInt(self); 3496 ck_assert(!r); 3497 ck_assert_int_eq(lenO(self), 1); 3498 s = toStringO(self); 3499 ck_assert_str_eq(s, "[false]"); 3500 free(s); 3501 3502 // empty array 3503 r3 = self->f->pop(self); 3504 ck_assert_ptr_ne(r3, null); 3505 terminateO(r3); 3506 s = toStringO(self); 3507 ck_assert_str_eq(s, "[]"); 3508 free(s); 3509 r = self->f->dequeueInt(self); 3510 ck_assert(!r); 3511 s = toStringO(self); 3512 ck_assert_str_eq(s, "[]"); 3513 free(s); 3514 terminateO(self); 3515 3516 END_TEST 3517 3518 3519 START_TEST(dequeueInt32SmallArrayT) 3520 3521 int32_t r; 3522 smallArrayt *self = allocG(rtSmallArrayt); 3523 smallArrayt *r2; 3524 baset *r3; 3525 3526 // add an element to check that the second element is poped 3527 // at the end 3528 r2 = self->f->pushBool(self, FALSE); 3529 ck_assert_ptr_ne(r2, null); 3530 3531 // add second element 3532 r2 = self->f->prependInt(self, 2); 3533 ck_assert_ptr_ne(r2, null); 3534 3535 // pop 3536 r = self->f->dequeueInt32(self); 3537 ck_assert_int_eq(r, 2); 3538 ck_assert_int_eq(lenO(self), 1); 3539 char *s = toStringO(self); 3540 ck_assert_str_eq(s, "[false]"); 3541 free(s); 3542 3543 // pop element of unexpected type 3544 r = self->f->dequeueInt32(self); 3545 ck_assert(!r); 3546 ck_assert_int_eq(lenO(self), 1); 3547 s = toStringO(self); 3548 ck_assert_str_eq(s, "[false]"); 3549 free(s); 3550 3551 // empty array 3552 r3 = self->f->pop(self); 3553 ck_assert_ptr_ne(r3, null); 3554 terminateO(r3); 3555 s = toStringO(self); 3556 ck_assert_str_eq(s, "[]"); 3557 free(s); 3558 r = self->f->dequeueInt32(self); 3559 ck_assert(!r); 3560 s = toStringO(self); 3561 ck_assert_str_eq(s, "[]"); 3562 free(s); 3563 terminateO(self); 3564 3565 END_TEST 3566 3567 3568 START_TEST(dequeueUintSmallArrayT) 3569 3570 uint64_t r; 3571 smallArrayt *self = allocG(rtSmallArrayt); 3572 smallArrayt *r2; 3573 baset *r3; 3574 3575 // add an element to check that the second element is poped 3576 // at the end 3577 r2 = self->f->pushBool(self, FALSE); 3578 ck_assert_ptr_ne(r2, null); 3579 3580 // add second element 3581 r2 = self->f->prependInt(self, 2); 3582 ck_assert_ptr_ne(r2, null); 3583 3584 // pop 3585 r = self->f->dequeueUint(self); 3586 ck_assert_int_eq(r, 2); 3587 ck_assert_int_eq(lenO(self), 1); 3588 char *s = toStringO(self); 3589 ck_assert_str_eq(s, "[false]"); 3590 free(s); 3591 3592 // pop element of unexpected type 3593 r = self->f->dequeueUint(self); 3594 ck_assert(!r); 3595 ck_assert_int_eq(lenO(self), 1); 3596 s = toStringO(self); 3597 ck_assert_str_eq(s, "[false]"); 3598 free(s); 3599 3600 // empty array 3601 r3 = self->f->pop(self); 3602 ck_assert_ptr_ne(r3, null); 3603 terminateO(r3); 3604 s = toStringO(self); 3605 ck_assert_str_eq(s, "[]"); 3606 free(s); 3607 r = self->f->dequeueUint(self); 3608 ck_assert(!r); 3609 s = toStringO(self); 3610 ck_assert_str_eq(s, "[]"); 3611 free(s); 3612 terminateO(self); 3613 3614 END_TEST 3615 3616 3617 START_TEST(dequeueUint32SmallArrayT) 3618 3619 uint32_t r; 3620 smallArrayt *self = allocG(rtSmallArrayt); 3621 smallArrayt *r2; 3622 baset *r3; 3623 3624 // add an element to check that the second element is poped 3625 // at the end 3626 r2 = self->f->pushBool(self, FALSE); 3627 ck_assert_ptr_ne(r2, null); 3628 3629 // add second element 3630 r2 = self->f->prependInt(self, 2); 3631 ck_assert_ptr_ne(r2, null); 3632 3633 // pop 3634 r = self->f->dequeueUint32(self); 3635 ck_assert_int_eq(r, 2); 3636 ck_assert_int_eq(lenO(self), 1); 3637 char *s = toStringO(self); 3638 ck_assert_str_eq(s, "[false]"); 3639 free(s); 3640 3641 // pop element of unexpected type 3642 r = self->f->dequeueUint32(self); 3643 ck_assert(!r); 3644 ck_assert_int_eq(lenO(self), 1); 3645 s = toStringO(self); 3646 ck_assert_str_eq(s, "[false]"); 3647 free(s); 3648 3649 // empty array 3650 r3 = self->f->pop(self); 3651 ck_assert_ptr_ne(r3, null); 3652 terminateO(r3); 3653 s = toStringO(self); 3654 ck_assert_str_eq(s, "[]"); 3655 free(s); 3656 r = self->f->dequeueUint32(self); 3657 ck_assert(!r); 3658 s = toStringO(self); 3659 ck_assert_str_eq(s, "[]"); 3660 free(s); 3661 terminateO(self); 3662 3663 END_TEST 3664 3665 3666 START_TEST(dequeueSSmallArrayT) 3667 3668 char* r; 3669 smallArrayt *self = allocG(rtSmallArrayt); 3670 smallArrayt *r2; 3671 baset *r3; 3672 3673 // add an element to check that the second element is poped 3674 // at the end 3675 r2 = self->f->pushInt(self, 1); 3676 ck_assert_ptr_ne(r2, null); 3677 3678 // add second element 3679 r2 = self->f->prependS(self, "bb"); 3680 ck_assert_ptr_ne(r2, null); 3681 3682 // pop 3683 r = self->f->dequeueS(self); 3684 ck_assert_str_eq(r, "bb"); 3685 free(r); 3686 ck_assert_int_eq(lenO(self), 1); 3687 char *s = toStringO(self); 3688 ck_assert_str_eq(s, "[1]"); 3689 free(s); 3690 3691 // pop element of unexpected type 3692 r = self->f->dequeueS(self); 3693 ck_assert(!r); 3694 ck_assert_int_eq(lenO(self), 1); 3695 s = toStringO(self); 3696 ck_assert_str_eq(s, "[1]"); 3697 free(s); 3698 3699 // empty array 3700 r3 = self->f->pop(self); 3701 ck_assert_ptr_ne(r3, null); 3702 terminateO(r3); 3703 s = toStringO(self); 3704 ck_assert_str_eq(s, "[]"); 3705 free(s); 3706 r = self->f->dequeueS(self); 3707 ck_assert(!r); 3708 s = toStringO(self); 3709 ck_assert_str_eq(s, "[]"); 3710 free(s); 3711 terminateO(self); 3712 3713 END_TEST 3714 3715 3716 START_TEST(dequeueDictSmallArrayT) 3717 3718 smallDictt* r; 3719 smallArrayt *self = allocG(rtSmallArrayt); 3720 smallArrayt *r2; 3721 baset *r3; 3722 3723 // add an element to check that the second element is poped 3724 // at the end 3725 r2 = self->f->pushInt(self, 1); 3726 ck_assert_ptr_ne(r2, null); 3727 // add second element 3728 createSmallDict(e); 3729 r2 = self->f->prependDict(self, &e); 3730 ck_assert_ptr_ne(r2, null); 3731 // pop 3732 r = self->f->dequeueDict(self); 3733 ck_assert_ptr_ne(r, null); 3734 char *s = toStringO(r); 3735 terminateO(r); 3736 ck_assert_str_eq(s, "{}"); 3737 free(s); 3738 ck_assert_int_eq(lenO(self), 1); 3739 s = toStringO(self); 3740 ck_assert_str_eq(s, "[1]"); 3741 free(s); 3742 // pop element of unexpected type 3743 r = self->f->dequeueDict(self); 3744 ck_assert(!r); 3745 ck_assert_int_eq(lenO(self), 1); 3746 s = toStringO(self); 3747 ck_assert_str_eq(s, "[1]"); 3748 free(s); 3749 // empty array 3750 r3 = self->f->pop(self); 3751 ck_assert_ptr_ne(r3, null); 3752 terminateO(r3); 3753 s = toStringO(self); 3754 ck_assert_str_eq(s, "[]"); 3755 free(s); 3756 r = self->f->dequeueDict(self); 3757 ck_assert(!r); 3758 s = toStringO(self); 3759 ck_assert_str_eq(s, "[]"); 3760 free(s); 3761 r2 = self->f->pushUndefined(self); 3762 ck_assert_ptr_ne(r2, null); 3763 delElemO(self,-1); 3764 r = self->f->dequeueDict(self); 3765 ck_assert_ptr_eq(r, null); 3766 terminateO(self); 3767 3768 END_TEST 3769 3770 3771 START_TEST(dequeueArraySmallArrayT) 3772 3773 smallArrayt* r; 3774 smallArrayt *self = allocG(rtSmallArrayt); 3775 smallArrayt *r2; 3776 baset *r3; 3777 3778 // add an element to check that the second element is poped 3779 // at the end 3780 r2 = self->f->pushInt(self, 1); 3781 ck_assert_ptr_ne(r2, null); 3782 // add second element 3783 createSmallArray(e); 3784 r2 = self->f->prependArray(self, &e); 3785 ck_assert_ptr_ne(r2, null); 3786 // pop 3787 r = self->f->dequeueArray(self); 3788 ck_assert_ptr_ne(r, null); 3789 char *s = toStringO(r); 3790 terminateO(r); 3791 ck_assert_str_eq(s, "[]"); 3792 free(s); 3793 ck_assert_int_eq(lenO(self), 1); 3794 s = toStringO(self); 3795 ck_assert_str_eq(s, "[1]"); 3796 free(s); 3797 // pop element of unexpected type 3798 r = self->f->dequeueArray(self); 3799 ck_assert(!r); 3800 ck_assert_int_eq(lenO(self), 1); 3801 s = toStringO(self); 3802 ck_assert_str_eq(s, "[1]"); 3803 free(s); 3804 // empty array 3805 r3 = self->f->pop(self); 3806 ck_assert_ptr_ne(r3, null); 3807 terminateO(r3); 3808 s = toStringO(self); 3809 ck_assert_str_eq(s, "[]"); 3810 free(s); 3811 r = self->f->dequeueArray(self); 3812 ck_assert(!r); 3813 s = toStringO(self); 3814 ck_assert_str_eq(s, "[]"); 3815 free(s); 3816 r2 = self->f->pushUndefined(self); 3817 ck_assert_ptr_ne(r2, null); 3818 delElemO(self,-1); 3819 r = self->f->dequeueArray(self); 3820 ck_assert_ptr_eq(r, null); 3821 terminateO(self); 3822 3823 END_TEST 3824 3825 3826 START_TEST(dequeueSmallBoolSmallArrayT) 3827 3828 smallBoolt* r; 3829 smallArrayt *self = allocG(rtSmallArrayt); 3830 smallArrayt *r2; 3831 baset *r3; 3832 3833 // add an element to check that the second element is poped 3834 // at the end 3835 r2 = self->f->pushInt(self, 1); 3836 ck_assert_ptr_ne(r2, null); 3837 3838 // add second element 3839 createSmallBool(e); 3840 r2 = self->f->prependSmallBool(self, &e); 3841 ck_assert_ptr_ne(r2, null); 3842 // pop 3843 r = self->f->dequeueSmallBool(self); 3844 ck_assert_ptr_ne(r, null); 3845 char *s = toStringO(r); 3846 terminateO(r); 3847 ck_assert_str_eq(s, "false"); 3848 free(s); 3849 ck_assert_int_eq(lenO(self), 1); 3850 s = toStringO(self); 3851 ck_assert_str_eq(s, "[1]"); 3852 free(s); 3853 // pop element of unexpected type 3854 r = self->f->dequeueSmallBool(self); 3855 ck_assert(!r); 3856 ck_assert_int_eq(lenO(self), 1); 3857 s = toStringO(self); 3858 ck_assert_str_eq(s, "[1]"); 3859 free(s); 3860 // empty array 3861 r3 = self->f->pop(self); 3862 ck_assert_ptr_ne(r3, null); 3863 terminateO(r3); 3864 s = toStringO(self); 3865 ck_assert_str_eq(s, "[]"); 3866 free(s); 3867 r = self->f->dequeueSmallBool(self); 3868 ck_assert(!r); 3869 s = toStringO(self); 3870 ck_assert_str_eq(s, "[]"); 3871 free(s); 3872 r2 = self->f->pushUndefined(self); 3873 ck_assert_ptr_ne(r2, null); 3874 delElemO(self,-1); 3875 r = self->f->dequeueSmallBool(self); 3876 ck_assert_ptr_eq(r, null); 3877 terminateO(self); 3878 3879 END_TEST 3880 3881 3882 START_TEST(dequeueSmallBytesSmallArrayT) 3883 3884 smallBytest* r; 3885 smallArrayt *self = allocG(rtSmallArrayt); 3886 smallArrayt *r2; 3887 baset *r3; 3888 3889 // add an element to check that the second element is poped 3890 // at the end 3891 r2 = self->f->pushInt(self, 1); 3892 ck_assert_ptr_ne(r2, null); 3893 // add second element 3894 createSmallBytes(e); 3895 r2 = self->f->prependSmallBytes(self, &e); 3896 ck_assert_ptr_ne(r2, null); 3897 // pop 3898 r = self->f->dequeueSmallBytes(self); 3899 ck_assert_ptr_ne(r, null); 3900 char *s = toStringO(r); 3901 terminateO(r); 3902 ck_assert_str_eq(s, "[]"); 3903 free(s); 3904 ck_assert_int_eq(lenO(self), 1); 3905 s = toStringO(self); 3906 ck_assert_str_eq(s, "[1]"); 3907 free(s); 3908 // pop element of unexpected type 3909 r = self->f->dequeueSmallBytes(self); 3910 ck_assert(!r); 3911 ck_assert_int_eq(lenO(self), 1); 3912 s = toStringO(self); 3913 ck_assert_str_eq(s, "[1]"); 3914 free(s); 3915 // empty array 3916 r3 = self->f->pop(self); 3917 ck_assert_ptr_ne(r3, null); 3918 terminateO(r3); 3919 s = toStringO(self); 3920 ck_assert_str_eq(s, "[]"); 3921 free(s); 3922 r = self->f->dequeueSmallBytes(self); 3923 ck_assert(!r); 3924 s = toStringO(self); 3925 ck_assert_str_eq(s, "[]"); 3926 free(s); 3927 r2 = self->f->pushUndefined(self); 3928 ck_assert_ptr_ne(r2, null); 3929 delElemO(self,-1); 3930 r = self->f->dequeueSmallBytes(self); 3931 ck_assert_ptr_eq(r, null); 3932 terminateO(self); 3933 3934 END_TEST 3935 3936 3937 START_TEST(dequeueSmallDoubleSmallArrayT) 3938 3939 smallDoublet* r; 3940 smallArrayt *self = allocG(rtSmallArrayt); 3941 smallArrayt *r2; 3942 baset *r3; 3943 3944 // add an element to check that the second element is poped 3945 // at the end 3946 r2 = self->f->pushInt(self, 1); 3947 ck_assert_ptr_ne(r2, null); 3948 // add second element 3949 createSmallDouble(e); 3950 r2 = self->f->prependSmallDouble(self, &e); 3951 ck_assert_ptr_ne(r2, null); 3952 // pop 3953 r = self->f->dequeueSmallDouble(self); 3954 ck_assert_ptr_ne(r, null); 3955 char *s = toStringO(r); 3956 terminateO(r); 3957 ck_assert_str_eq(s, "0.000000e+00"); 3958 free(s); 3959 ck_assert_int_eq(lenO(self), 1); 3960 s = toStringO(self); 3961 ck_assert_str_eq(s, "[1]"); 3962 free(s); 3963 // pop element of unexpected type 3964 r = self->f->dequeueSmallDouble(self); 3965 ck_assert(!r); 3966 ck_assert_int_eq(lenO(self), 1); 3967 s = toStringO(self); 3968 ck_assert_str_eq(s, "[1]"); 3969 free(s); 3970 // empty array 3971 r3 = self->f->pop(self); 3972 ck_assert_ptr_ne(r3, null); 3973 terminateO(r3); 3974 s = toStringO(self); 3975 ck_assert_str_eq(s, "[]"); 3976 free(s); 3977 r = self->f->dequeueSmallDouble(self); 3978 ck_assert(!r); 3979 s = toStringO(self); 3980 ck_assert_str_eq(s, "[]"); 3981 free(s); 3982 r2 = self->f->pushUndefined(self); 3983 ck_assert_ptr_ne(r2, null); 3984 delElemO(self,-1); 3985 r = self->f->dequeueSmallDouble(self); 3986 ck_assert_ptr_eq(r, null); 3987 terminateO(self); 3988 3989 END_TEST 3990 3991 3992 START_TEST(dequeueSmallIntSmallArrayT) 3993 3994 smallIntt* r; 3995 smallArrayt *self = allocG(rtSmallArrayt); 3996 smallArrayt *r2; 3997 baset *r3; 3998 3999 // add an element to check that the second element is poped 4000 // at the end 4001 r2 = self->f->pushBool(self, TRUE); 4002 ck_assert_ptr_ne(r2, null); 4003 // add second element 4004 createSmallInt(e); 4005 r2 = self->f->prependSmallInt(self, &e); 4006 ck_assert_ptr_ne(r2, null); 4007 // pop 4008 r = self->f->dequeueSmallInt(self); 4009 ck_assert_ptr_ne(r, null); 4010 char *s = toStringO(r); 4011 terminateO(r); 4012 ck_assert_str_eq(s, "0"); 4013 free(s); 4014 ck_assert_int_eq(lenO(self), 1); 4015 s = toStringO(self); 4016 ck_assert_str_eq(s, "[true]"); 4017 free(s); 4018 // pop element of unexpected type 4019 r = self->f->dequeueSmallInt(self); 4020 ck_assert(!r); 4021 ck_assert_int_eq(lenO(self), 1); 4022 s = toStringO(self); 4023 ck_assert_str_eq(s, "[true]"); 4024 free(s); 4025 // empty array 4026 r3 = self->f->pop(self); 4027 ck_assert_ptr_ne(r3, null); 4028 terminateO(r3); 4029 s = toStringO(self); 4030 ck_assert_str_eq(s, "[]"); 4031 free(s); 4032 r = self->f->dequeueSmallInt(self); 4033 ck_assert(!r); 4034 s = toStringO(self); 4035 ck_assert_str_eq(s, "[]"); 4036 free(s); 4037 r2 = self->f->pushUndefined(self); 4038 ck_assert_ptr_ne(r2, null); 4039 delElemO(self,-1); 4040 r = self->f->dequeueSmallInt(self); 4041 ck_assert_ptr_eq(r, null); 4042 terminateO(self); 4043 4044 END_TEST 4045 4046 4047 START_TEST(dequeueSmallJsonSmallArrayT) 4048 4049 smallJsont* r; 4050 smallArrayt *self = allocG(rtSmallArrayt); 4051 smallArrayt *r2; 4052 baset *r3; 4053 4054 // add an element to check that the second element is poped 4055 // at the end 4056 createSmallBytes(B); 4057 r2 = self->f->pushSmallBytes(self, &B); 4058 ck_assert_ptr_ne(r2, null); 4059 // add second element 4060 createSmallJson(e); 4061 r2 = self->f->prependSmallJson(self, &e); 4062 ck_assert_ptr_ne(r2, null); 4063 // pop 4064 r = self->f->dequeueSmallJson(self); 4065 ck_assert_ptr_ne(r, null); 4066 char *s = toStringO(r); 4067 terminateO(r); 4068 ck_assert_str_eq(s, "{}"); 4069 free(s); 4070 ck_assert_int_eq(lenO(self), 1); 4071 s = toStringO(self); 4072 ck_assert_str_eq(s, "[[]]"); 4073 free(s); 4074 // pop element of unexpected type 4075 r = self->f->dequeueSmallJson(self); 4076 ck_assert(!r); 4077 ck_assert_int_eq(lenO(self), 1); 4078 s = toStringO(self); 4079 ck_assert_str_eq(s, "[[]]"); 4080 free(s); 4081 // empty array 4082 r3 = self->f->pop(self); 4083 ck_assert_ptr_ne(r3, null); 4084 terminateO(r3); 4085 s = toStringO(self); 4086 ck_assert_str_eq(s, "[]"); 4087 free(s); 4088 r = self->f->dequeueSmallJson(self); 4089 ck_assert(!r); 4090 s = toStringO(self); 4091 ck_assert_str_eq(s, "[]"); 4092 free(s); 4093 r2 = self->f->pushUndefined(self); 4094 ck_assert_ptr_ne(r2, null); 4095 delElemO(self,-1); 4096 r = self->f->dequeueSmallJson(self); 4097 ck_assert_ptr_eq(r, null); 4098 terminateO(self); 4099 4100 END_TEST 4101 4102 4103 START_TEST(dequeueSmallStringSmallArrayT) 4104 4105 smallStringt* r; 4106 smallArrayt *self = allocG(rtSmallArrayt); 4107 smallArrayt *r2; 4108 baset *r3; 4109 4110 // add an element to check that the second element is poped 4111 // at the end 4112 r2 = self->f->pushInt(self, 1); 4113 ck_assert_ptr_ne(r2, null); 4114 // add second element 4115 createSmallString(e); 4116 r2 = self->f->prependSmallString(self, &e); 4117 ck_assert_ptr_ne(r2, null); 4118 // pop 4119 r = self->f->dequeueSmallString(self); 4120 ck_assert_ptr_ne(r, null); 4121 char *s = toStringO(r); 4122 terminateO(r); 4123 ck_assert_str_eq(s, ""); 4124 free(s); 4125 ck_assert_int_eq(lenO(self), 1); 4126 s = toStringO(self); 4127 ck_assert_str_eq(s, "[1]"); 4128 free(s); 4129 // pop element of unexpected type 4130 r = self->f->dequeueSmallString(self); 4131 ck_assert(!r); 4132 ck_assert_int_eq(lenO(self), 1); 4133 s = toStringO(self); 4134 ck_assert_str_eq(s, "[1]"); 4135 free(s); 4136 // empty array 4137 r3 = self->f->pop(self); 4138 ck_assert_ptr_ne(r3, null); 4139 terminateO(r3); 4140 s = toStringO(self); 4141 ck_assert_str_eq(s, "[]"); 4142 free(s); 4143 r = self->f->dequeueSmallString(self); 4144 ck_assert(!r); 4145 s = toStringO(self); 4146 ck_assert_str_eq(s, "[]"); 4147 free(s); 4148 r2 = self->f->pushUndefined(self); 4149 ck_assert_ptr_ne(r2, null); 4150 delElemO(self,-1); 4151 r = self->f->dequeueSmallString(self); 4152 ck_assert_ptr_eq(r, null); 4153 terminateO(self); 4154 4155 END_TEST 4156 4157 4158 START_TEST(dequeueVoidSmallArrayT) 4159 4160 void* r; 4161 smallArrayt *self = allocG(rtSmallArrayt); 4162 smallArrayt *r2; 4163 baset *r3; 4164 4165 // add an element to check that the second element is poped 4166 // at the end 4167 r2 = self->f->pushInt(self, 1); 4168 ck_assert_ptr_ne(r2, null); 4169 4170 // add second element 4171 createSmallContainer(e); 4172 setValO(&e, &r); 4173 r2 = self->f->prependSmallContainer(self, &e); 4174 ck_assert_ptr_ne(r2, null); 4175 4176 // pop 4177 r = self->f->dequeueVoid(self); 4178 ck_assert_ptr_eq(r, &r); 4179 ck_assert_int_eq(lenO(self), 1); 4180 char *s = toStringO(self); 4181 ck_assert_str_eq(s, "[1]"); 4182 free(s); 4183 4184 // pop element of unexpected type 4185 r = self->f->dequeueVoid(self); 4186 ck_assert(!r); 4187 ck_assert_int_eq(lenO(self), 1); 4188 s = toStringO(self); 4189 ck_assert_str_eq(s, "[1]"); 4190 free(s); 4191 4192 // empty array 4193 r3 = self->f->pop(self); 4194 ck_assert_ptr_ne(r3, null); 4195 terminateO(r3); 4196 s = toStringO(self); 4197 ck_assert_str_eq(s, "[]"); 4198 free(s); 4199 r = self->f->dequeueVoid(self); 4200 ck_assert(!r); 4201 s = toStringO(self); 4202 ck_assert_str_eq(s, "[]"); 4203 free(s); 4204 terminateO(self); 4205 4206 END_TEST 4207 4208 4209 START_TEST(dequeueSmallContainerSmallArrayT) 4210 4211 smallContainert* r; 4212 smallArrayt *self = allocG(rtSmallArrayt); 4213 smallArrayt *r2; 4214 baset *r3; 4215 4216 // add an element to check that the second element is poped 4217 // at the end 4218 r2 = self->f->pushInt(self, 1); 4219 ck_assert_ptr_ne(r2, null); 4220 // add second element 4221 createSmallContainer(e); 4222 r2 = self->f->prependSmallContainer(self, &e); 4223 ck_assert_ptr_ne(r2, null); 4224 // pop 4225 r = self->f->dequeueSmallContainer(self); 4226 ck_assert_ptr_ne(r, null); 4227 char *s = toStringO(r); 4228 terminateO(r); 4229 ck_assert_str_eq(s, "<data smallContainer>"); 4230 free(s); 4231 ck_assert_int_eq(lenO(self), 1); 4232 s = toStringO(self); 4233 ck_assert_str_eq(s, "[1]"); 4234 free(s); 4235 // container with baset object 4236 // push a base object of unknown type 4237 smallIntt *o = allocSmallInt(2); 4238 o->type = "newType"; 4239 r2 = self->f->prependNFree(self, (baset*)o); 4240 ck_assert_ptr_ne(r2, null); 4241 r = self->f->dequeueSmallContainer(self); 4242 ck_assert_ptr_eq(r, NULL); 4243 ck_assert_int_eq(lenO(self), 2); 4244 s = toStringO(self); 4245 ck_assert_str_eq(s, "[\"<data container>\",1]"); 4246 free(s); 4247 r3 = self->f->dequeue(self); 4248 ck_assert_ptr_ne(r3, null); 4249 terminateO(r3); 4250 // pop element of unexpected type 4251 r = self->f->dequeueSmallContainer(self); 4252 ck_assert_ptr_eq(r, NULL); 4253 ck_assert_int_eq(lenO(self), 1); 4254 s = toStringO(self); 4255 ck_assert_str_eq(s, "[1]"); 4256 free(s); 4257 // empty array 4258 r3 = self->f->pop(self); 4259 ck_assert_ptr_ne(r3, null); 4260 terminateO(r3); 4261 s = toStringO(self); 4262 ck_assert_str_eq(s, "[]"); 4263 free(s); 4264 r = self->f->dequeueSmallContainer(self); 4265 ck_assert(!r); 4266 s = toStringO(self); 4267 ck_assert_str_eq(s, "[]"); 4268 free(s); 4269 r2 = self->f->pushUndefined(self); 4270 ck_assert_ptr_ne(r2, null); 4271 delElemO(self,-1); 4272 r = self->f->dequeueSmallContainer(self); 4273 ck_assert_ptr_eq(r, null); 4274 terminateO(self); 4275 4276 END_TEST 4277 4278 4279 START_TEST(dequeueNumSmallArrayT) 4280 4281 double r; 4282 smallArrayt *self = allocG(rtSmallArrayt); 4283 smallArrayt *r2; 4284 baset *r3; 4285 4286 // add an element to check that the second element is poped 4287 // at the end 4288 r2 = self->f->pushBool(self, TRUE); 4289 ck_assert_ptr_ne(r2, null); 4290 // add second element 4291 r2 = self->f->prependInt(self, 2); 4292 ck_assert_ptr_ne(r2, null); 4293 r2 = self->f->prependDouble(self, 2.5); 4294 ck_assert_ptr_ne(r2, null); 4295 // pop 4296 r = self->f->dequeueNum(self); 4297 ck_assert(r==2.5); 4298 ck_assert_int_eq(lenO(self), 2); 4299 char *s = toStringO(self); 4300 ck_assert_str_eq(s, "[2,true]"); 4301 free(s); 4302 r = self->f->dequeueNum(self); 4303 ck_assert_int_eq(r, 2); 4304 ck_assert_int_eq(lenO(self), 1); 4305 s = toStringO(self); 4306 ck_assert_str_eq(s, "[true]"); 4307 free(s); 4308 // pop element of unexpected type 4309 r = self->f->dequeueNum(self); 4310 ck_assert(!r); 4311 ck_assert_int_eq(lenO(self), 1); 4312 s = toStringO(self); 4313 ck_assert_str_eq(s, "[true]"); 4314 free(s); 4315 // empty array 4316 r3 = self->f->pop(self); 4317 ck_assert_ptr_ne(r3, null); 4318 terminateO(r3); 4319 s = toStringO(self); 4320 ck_assert_str_eq(s, "[]"); 4321 free(s); 4322 r = self->f->dequeueNum(self); 4323 ck_assert(!r); 4324 s = toStringO(self); 4325 ck_assert_str_eq(s, "[]"); 4326 free(s); 4327 r2 = self->f->pushUndefined(self); 4328 ck_assert_ptr_ne(r2, null); 4329 delElemO(self,-1); 4330 r = self->f->dequeueNum(self); 4331 ck_assert(!r); 4332 terminateO(self); 4333 4334 END_TEST 4335 4336 4337 START_TEST(reverseSmallArrayT) 4338 4339 smallArrayt* r; 4340 smallArrayt *self = allocG(rtSmallArrayt); 4341 4342 // empty array 4343 r = reverseO(self); 4344 ck_assert_ptr_ne(r, NULL); 4345 char *s = toStringO(r); 4346 ck_assert_str_eq(s, "[]"); 4347 free(s); 4348 // 1 element array 4349 self->f->pushInt(self,1); 4350 r = reverseO(self); 4351 ck_assert_ptr_ne(r, NULL); 4352 s = toStringO(r); 4353 ck_assert_str_eq(s, "[1]"); 4354 free(s); 4355 // 2 elements array 4356 self->f->pushInt(self,2); 4357 r = reverseO(self); 4358 ck_assert_ptr_ne(r, NULL); 4359 s = toStringO(r); 4360 ck_assert_str_eq(s, "[2,1]"); 4361 free(s); 4362 terminateO(self); 4363 4364 END_TEST 4365 4366 4367 START_TEST(catSmallArrayT) 4368 4369 smallArrayt* r; 4370 smallArrayt *self = allocG(rtSmallArrayt); 4371 4372 // cat arrays 4373 self->f->pushInt(self,1); 4374 createAllocateSmallArray(a); 4375 createAllocateSmallArray(a2); 4376 a2->f->pushInt(a2,2); 4377 r = catO(self, a, a2); 4378 char *s = toStringO(r); 4379 ck_assert_str_eq(s, "[1,2]"); 4380 free(s); 4381 smashManyO(a,a2); 4382 emptyO(self); 4383 4384 // null parameter 4385 r = catO(self, null); 4386 s = toStringO(r); 4387 ck_assert_str_eq(s, "[]"); 4388 free(s); 4389 terminateO(self); 4390 4391 END_TEST 4392 4393 4394 START_TEST(appendSmallJsonSmallArrayT) 4395 4396 smallArrayt* r; 4397 smallArrayt *self = allocG(rtSmallArrayt); 4398 createAllocateSmallJson(json); 4399 4400 // add an element to check that the second array is appended 4401 // at the end 4402 r = self->f->pushInt(self, 1); 4403 ck_assert_ptr_ne(r, null); 4404 4405 // append json array 4406 json->f->pushInt(json, 2); 4407 r = self->f->appendSmallJson(self, json); 4408 smashO(json); 4409 ck_assert_ptr_ne(r, null); 4410 char *s = toStringO(r); 4411 ck_assert_str_eq(s, "[1,2]"); 4412 free(s); 4413 // length 0 4414 json = allocSmallJson(); 4415 json->f->pushInt(json, 2); 4416 baset *o = json->f->pop(json); 4417 terminateO(o); 4418 r = self->f->appendSmallJson(self, json); 4419 smashO(json); 4420 ck_assert_ptr_ne(r, null); 4421 s = toStringO(r); 4422 ck_assert_str_eq(s, "[1,2]"); 4423 free(s); 4424 // same sArray in both self and json 4425 json = allocSmallJson(); 4426 setsoO(json, (smallt*) getsoO(self)); 4427 r = self->f->appendSmallJson(self, json); 4428 ck_assert_ptr_eq(r, null); 4429 finishO(json); 4430 s = toStringO(self); 4431 ck_assert_str_eq(s, "[1,2]"); 4432 free(s); 4433 // json of type not array 4434 json = allocSmallJson(); 4435 setTopIntO(json, 1); 4436 r = self->f->appendSmallJson(self, json); 4437 ck_assert_ptr_eq(r, null); 4438 terminateO(json); 4439 s = toStringO(self); 4440 ck_assert_str_eq(s, "[1,2]"); 4441 free(s); 4442 // non smallJson object 4443 json = (smallJsont*) allocSmallInt(2); 4444 r = self->f->appendSmallJson(self, json); 4445 ck_assert_ptr_eq(r, null); 4446 terminateO(json); 4447 // null 4448 r = self->f->appendSmallJson(self, null); 4449 ck_assert_ptr_eq(r, null); 4450 s = toStringO(self); 4451 ck_assert_str_eq(s, "[1,2]"); 4452 free(s); 4453 terminateO(self); 4454 4455 END_TEST 4456 4457 4458 START_TEST(appendNSmashSmallArrayT) 4459 4460 smallArrayt* r; 4461 smallArrayt *self = allocG(rtSmallArrayt); 4462 createAllocateSmallArray(a); 4463 4464 // add an element to check that the second array is appended 4465 // at the end 4466 r = self->f->pushInt(self, 1); 4467 ck_assert_ptr_ne(r, null); 4468 4469 // append array 4470 a->f->pushInt(a, 2); 4471 r = self->f->appendNSmash(self, a); 4472 ck_assert_ptr_ne(r, null); 4473 char *s = toStringO(r); 4474 ck_assert_str_eq(s, "[1,2]"); 4475 free(s); 4476 // length 0 4477 a = allocSmallArray(); 4478 a->f->pushInt(a, 2); 4479 delElemO(a,0); 4480 r = self->f->appendNSmash(self, a); 4481 ck_assert_ptr_ne(r, null); 4482 s = toStringO(r); 4483 ck_assert_str_eq(s, "[1,2]"); 4484 free(s); 4485 // same sArray in both self and a 4486 a = allocSmallArray(); 4487 setsoO(a, getsoO(self)); 4488 r = self->f->appendNSmash(self, a); 4489 ck_assert_ptr_eq(r, null); 4490 finishO(a); 4491 s = toStringO(self); 4492 ck_assert_str_eq(s, "[1,2]"); 4493 free(s); 4494 // null 4495 r = self->f->appendNSmash(self, null); 4496 ck_assert_ptr_eq(r, null); 4497 s = toStringO(self); 4498 ck_assert_str_eq(s, "[1,2]"); 4499 free(s); 4500 terminateO(self); 4501 4502 END_TEST 4503 4504 4505 START_TEST(appendNSmashSmallJsonSmallArrayT) 4506 4507 smallArrayt* r; 4508 smallArrayt *self = allocG(rtSmallArrayt); 4509 createAllocateSmallJson(json); 4510 4511 // add an element to check that the second array is appended 4512 // at the end 4513 r = self->f->pushInt(self, 1); 4514 ck_assert_ptr_ne(r, null); 4515 4516 // append json array 4517 json->f->pushInt(json, 2); 4518 r = self->f->appendNSmashSmallJson(self, json); 4519 ck_assert_ptr_ne(r, null); 4520 char *s = toStringO(r); 4521 ck_assert_str_eq(s, "[1,2]"); 4522 free(s); 4523 // null 4524 r = self->f->appendNSmashSmallJson(self, null); 4525 ck_assert_ptr_eq(r, null); 4526 s = toStringO(self); 4527 ck_assert_str_eq(s, "[1,2]"); 4528 free(s); 4529 terminateO(self); 4530 4531 END_TEST 4532 4533 4534 START_TEST(appendArraySmallArrayT) 4535 4536 smallArrayt* r; 4537 smallArrayt *self = allocG(rtSmallArrayt); 4538 char **array; 4539 4540 // add an element to check that the second array is appended 4541 // at the end 4542 r = self->f->pushInt(self, 1); 4543 ck_assert_ptr_ne(r, null); 4544 4545 // append array 4546 array = null; 4547 listPushS(&array, "2"); 4548 r = self->f->appendArray(self, array); 4549 listFreeS(array); 4550 ck_assert_ptr_ne(r, null); 4551 char *s = toStringO(r); 4552 ck_assert_str_eq(s, "[1,\"2\"]"); 4553 free(s); 4554 // length 0 4555 listEmptyS(array); 4556 r = self->f->appendArray(self, array); 4557 free(array); 4558 ck_assert_ptr_ne(r, null); 4559 s = toStringO(r); 4560 ck_assert_str_eq(s, "[1,\"2\"]"); 4561 free(s); 4562 // null 4563 r = self->f->appendArray(self, null); 4564 ck_assert_ptr_eq(r, null); 4565 s = toStringO(self); 4566 ck_assert_str_eq(s, "[1,\"2\"]"); 4567 free(s); 4568 terminateO(self); 4569 4570 END_TEST 4571 4572 4573 START_TEST(appendNSmashArraySmallArrayT) 4574 4575 smallArrayt* r; 4576 smallArrayt *self = allocG(rtSmallArrayt); 4577 char **array; 4578 4579 // add an element to check that the second array is appended 4580 // at the end 4581 r = self->f->pushInt(self, 1); 4582 ck_assert_ptr_ne(r, null); 4583 4584 // append array 4585 array = null; 4586 listPushS(&array, "2"); 4587 r = self->f->appendNSmashArray(self, array); 4588 ck_assert_ptr_ne(r, null); 4589 char *s = toStringO(r); 4590 ck_assert_str_eq(s, "[1,\"2\"]"); 4591 free(s); 4592 // length 0 4593 listEmptyS(array); 4594 r = self->f->appendNSmashArray(self, array); 4595 ck_assert_ptr_ne(r, null); 4596 s = toStringO(r); 4597 ck_assert_str_eq(s, "[1,\"2\"]"); 4598 free(s); 4599 // null 4600 r = self->f->appendNSmashArray(self, null); 4601 ck_assert_ptr_eq(r, null); 4602 s = toStringO(self); 4603 ck_assert_str_eq(s, "[1,\"2\"]"); 4604 free(s); 4605 terminateO(self); 4606 4607 END_TEST 4608 4609 4610 START_TEST(shiftSmallArrayT) 4611 4612 smallArrayt* r; 4613 smallArrayt *self = allocG(rtSmallArrayt); 4614 createAllocateSmallArray(a); 4615 4616 // add an element to check that the second array is appended 4617 // at the end 4618 r = self->f->pushInt(self, 1); 4619 ck_assert_ptr_ne(r, null); 4620 4621 // append array 4622 a->f->pushInt(a, 2); 4623 r = self->f->shift(self, a); 4624 smashO(a); 4625 ck_assert_ptr_ne(r, null); 4626 char *s = toStringO(r); 4627 ck_assert_str_eq(s, "[2,1]"); 4628 free(s); 4629 // length 0 4630 a = allocSmallArray(); 4631 a->f->pushInt(a, 2); 4632 delElemO(a,0); 4633 r = self->f->shift(self, a); 4634 smashO(a); 4635 ck_assert_ptr_ne(r, null); 4636 s = toStringO(r); 4637 ck_assert_str_eq(s, "[2,1]"); 4638 free(s); 4639 // same sArray in both self and a 4640 a = allocSmallArray(); 4641 setsoO(a, getsoO(self)); 4642 r = self->f->shift(self, a); 4643 ck_assert_ptr_eq(r, null); 4644 finishO(a); 4645 s = toStringO(self); 4646 ck_assert_str_eq(s, "[2,1]"); 4647 free(s); 4648 // null 4649 r = self->f->shift(self, null); 4650 ck_assert_ptr_eq(r, null); 4651 s = toStringO(self); 4652 ck_assert_str_eq(s, "[2,1]"); 4653 free(s); 4654 terminateO(self); 4655 4656 END_TEST 4657 4658 4659 START_TEST(shiftSmallJsonSmallArrayT) 4660 4661 smallArrayt* r; 4662 smallArrayt *self = allocG(rtSmallArrayt); 4663 createAllocateSmallJson(json); 4664 4665 // add an element to check that the second array is shifted 4666 // at the end 4667 r = self->f->pushInt(self, 1); 4668 ck_assert_ptr_ne(r, null); 4669 4670 // shift json array 4671 json->f->pushInt(json, 2); 4672 r = self->f->shiftSmallJson(self, json); 4673 smashO(json); 4674 ck_assert_ptr_ne(r, null); 4675 char *s = toStringO(r); 4676 ck_assert_str_eq(s, "[2,1]"); 4677 free(s); 4678 // length 0 4679 json = allocSmallJson(); 4680 json->f->pushInt(json, 2); 4681 baset *o = json->f->pop(json); 4682 terminateO(o); 4683 r = self->f->shiftSmallJson(self, json); 4684 smashO(json); 4685 ck_assert_ptr_ne(r, null); 4686 s = toStringO(r); 4687 ck_assert_str_eq(s, "[2,1]"); 4688 free(s); 4689 // same sArray in both self and json 4690 json = allocSmallJson(); 4691 setsoO(json, (smallt*) getsoO(self)); 4692 r = self->f->shiftSmallJson(self, json); 4693 ck_assert_ptr_eq(r, null); 4694 finishO(json); 4695 s = toStringO(self); 4696 ck_assert_str_eq(s, "[2,1]"); 4697 free(s); 4698 // json of type not array 4699 json = allocSmallJson(); 4700 setTopIntO(json, 1); 4701 r = self->f->shiftSmallJson(self, json); 4702 ck_assert_ptr_eq(r, null); 4703 terminateO(json); 4704 s = toStringO(self); 4705 ck_assert_str_eq(s, "[2,1]"); 4706 free(s); 4707 // null 4708 r = self->f->shiftSmallJson(self, null); 4709 ck_assert_ptr_eq(r, null); 4710 s = toStringO(self); 4711 ck_assert_str_eq(s, "[2,1]"); 4712 free(s); 4713 terminateO(self); 4714 4715 END_TEST 4716 4717 4718 START_TEST(shiftNSmashSmallArrayT) 4719 4720 smallArrayt* r; 4721 smallArrayt *self = allocG(rtSmallArrayt); 4722 createAllocateSmallArray(a); 4723 4724 // add an element to check that the second array is appended 4725 // at the end 4726 r = self->f->pushInt(self, 1); 4727 ck_assert_ptr_ne(r, null); 4728 4729 // append array 4730 a->f->pushInt(a, 2); 4731 r = self->f->shiftNSmash(self, a); 4732 ck_assert_ptr_ne(r, null); 4733 char *s = toStringO(r); 4734 ck_assert_str_eq(s, "[2,1]"); 4735 free(s); 4736 // length 0 4737 a = allocSmallArray(); 4738 a->f->pushInt(a, 2); 4739 delElemO(a,0); 4740 r = self->f->shiftNSmash(self, a); 4741 ck_assert_ptr_ne(r, null); 4742 s = toStringO(r); 4743 ck_assert_str_eq(s, "[2,1]"); 4744 free(s); 4745 // same sArray in both self and a 4746 a = allocSmallArray(); 4747 setsoO(a, getsoO(self)); 4748 r = self->f->shiftNSmash(self, a); 4749 ck_assert_ptr_eq(r, null); 4750 finishO(a); 4751 s = toStringO(self); 4752 ck_assert_str_eq(s, "[2,1]"); 4753 free(s); 4754 // null 4755 r = self->f->shiftNSmash(self, null); 4756 ck_assert_ptr_eq(r, null); 4757 s = toStringO(self); 4758 ck_assert_str_eq(s, "[2,1]"); 4759 free(s); 4760 terminateO(self); 4761 4762 END_TEST 4763 4764 4765 START_TEST(shiftNSmashSmallJsonSmallArrayT) 4766 4767 smallArrayt* r; 4768 smallArrayt *self = allocG(rtSmallArrayt); 4769 createAllocateSmallJson(json); 4770 4771 // add an element to check that the second array is shifted 4772 // at the end 4773 r = self->f->pushInt(self, 1); 4774 ck_assert_ptr_ne(r, null); 4775 4776 // shift json array 4777 json->f->pushInt(json, 2); 4778 r = self->f->shiftNSmashSmallJson(self, json); 4779 ck_assert_ptr_ne(r, null); 4780 char *s = toStringO(r); 4781 ck_assert_str_eq(s, "[2,1]"); 4782 free(s); 4783 // length 0 4784 json = allocSmallJson(); 4785 json->f->pushInt(json, 2); 4786 baset *o = json->f->pop(json); 4787 terminateO(o); 4788 r = self->f->shiftNSmashSmallJson(self, json); 4789 ck_assert_ptr_ne(r, null); 4790 s = toStringO(r); 4791 ck_assert_str_eq(s, "[2,1]"); 4792 free(s); 4793 // same sArray in both self and json 4794 json = allocSmallJson(); 4795 setsoO(json, (smallt*) getsoO(self)); 4796 r = self->f->shiftNSmashSmallJson(self, json); 4797 ck_assert_ptr_eq(r, null); 4798 finishO(json); 4799 s = toStringO(self); 4800 ck_assert_str_eq(s, "[2,1]"); 4801 free(s); 4802 // json of type not array 4803 json = allocSmallJson(); 4804 setTopIntO(json, 1); 4805 r = self->f->shiftNSmashSmallJson(self, json); 4806 ck_assert_ptr_eq(r, null); 4807 terminateO(json); 4808 s = toStringO(self); 4809 ck_assert_str_eq(s, "[2,1]"); 4810 free(s); 4811 // null 4812 r = self->f->shiftNSmashSmallJson(self, null); 4813 ck_assert_ptr_eq(r, null); 4814 s = toStringO(self); 4815 ck_assert_str_eq(s, "[2,1]"); 4816 free(s); 4817 terminateO(self); 4818 4819 END_TEST 4820 4821 4822 START_TEST(addSmallArrayT) 4823 4824 smallArrayt* r; 4825 smallArrayt *self = allocG(rtSmallArrayt); 4826 createAllocateSmallArray(a); 4827 4828 // add an element to check that the second array is added 4829 // at the end 4830 r = self->f->pushInt(self, 1); 4831 ck_assert_ptr_ne(r, null); 4832 4833 // add array 4834 a->f->pushInt(a, 2); 4835 r = addO(self, a); 4836 smashO(a); 4837 ck_assert_ptr_ne(r, null); 4838 char *s = toStringO(r); 4839 terminateO(r); 4840 ck_assert_str_eq(s, "[1,2]"); 4841 free(s); 4842 // length 0 4843 a = allocSmallArray(); 4844 a->f->pushInt(a, 2); 4845 delElemO(a,0); 4846 r = addO(self, a); 4847 smashO(a); 4848 ck_assert_ptr_ne(r, null); 4849 s = toStringO(r); 4850 terminateO(r); 4851 ck_assert_str_eq(s, "[1]"); 4852 free(s); 4853 // same sArray in both self and a 4854 a = allocSmallArray(); 4855 setsoO(a, getsoO(self)); 4856 r = addO(self, a); 4857 ck_assert_ptr_eq(r, null); 4858 finishO(a); 4859 s = toStringO(self); 4860 ck_assert_str_eq(s, "[1]"); 4861 free(s); 4862 // null 4863 r = addO(self, null); 4864 ck_assert_ptr_eq(r, null); 4865 s = toStringO(self); 4866 ck_assert_str_eq(s, "[1]"); 4867 free(s); 4868 terminateO(self); 4869 4870 END_TEST 4871 4872 4873 START_TEST(cropSmallArrayT) 4874 4875 smallArrayt* r; 4876 smallArrayt *self = allocG(rtSmallArrayt); 4877 4878 // add elements to self 4879 r = self->f->pushInt(self, 1); 4880 ck_assert_ptr_ne(r, null); 4881 r = self->f->pushInt(self, 2); 4882 ck_assert_ptr_ne(r, null); 4883 r = self->f->pushInt(self, 3); 4884 ck_assert_ptr_ne(r, null); 4885 r = self->f->pushInt(self, 4); 4886 ck_assert_ptr_ne(r, null); 4887 4888 // negative index 4889 r = cropO(self, 1, -1); 4890 ck_assert_ptr_ne(r, null); 4891 ck_assert_int_eq(lenO(r), 2); 4892 char *s = toStringO(r); 4893 terminateO(r); 4894 ck_assert_str_eq(s, "[2,3]"); 4895 free(s); 4896 s = toStringO(self); 4897 ck_assert_str_eq(s, "[1,4]"); 4898 free(s); 4899 // start outside 4900 ck_assert_ptr_eq(cropO(self, 20, -4), NULL); 4901 // end outside 4902 r = cropO(self, 0, 40); 4903 ck_assert_ptr_ne(r, null); 4904 ck_assert_int_eq(lenO(r), 2); 4905 s = toStringO(r); 4906 terminateO(r); 4907 ck_assert_str_eq(s, "[1,4]"); 4908 free(s); 4909 s = toStringO(self); 4910 ck_assert_str_eq(s, "[]"); 4911 free(s); 4912 // end negative and outside 4913 // add elements to self 4914 r = self->f->pushInt(self, 1); 4915 ck_assert_ptr_ne(r, null); 4916 r = self->f->pushInt(self, 2); 4917 ck_assert_ptr_ne(r, null); 4918 r = self->f->pushInt(self, 3); 4919 ck_assert_ptr_ne(r, null); 4920 r = self->f->pushInt(self, 4); 4921 ck_assert_ptr_ne(r, null); 4922 ck_assert_ptr_eq(cropO(self, 2, -40), NULL); 4923 s = toStringO(self); 4924 ck_assert_str_eq(s, "[1,2,3,4]"); 4925 free(s); 4926 // end before start 4927 ck_assert_ptr_eq(cropO(self, 3, 2), NULL); 4928 s = toStringO(self); 4929 ck_assert_str_eq(s, "[1,2,3,4]"); 4930 free(s); 4931 // negative start last element 4932 r = cropO(self, -1, 0); 4933 ck_assert_ptr_ne(r, null); 4934 ck_assert_int_eq(lenO(r), 1); 4935 s = toStringO(r); 4936 terminateO(r); 4937 ck_assert_str_eq(s, "[4]"); 4938 free(s); 4939 s = toStringO(self); 4940 ck_assert_str_eq(s, "[1,2,3]"); 4941 free(s); 4942 // negative start and outside 4943 r = cropO(self, -10, 1); 4944 ck_assert_ptr_ne(r, null); 4945 ck_assert_int_eq(lenO(r), 1); 4946 s = toStringO(r); 4947 terminateO(r); 4948 ck_assert_str_eq(s, "[1]"); 4949 free(s); 4950 s = toStringO(self); 4951 ck_assert_str_eq(s, "[2,3]"); 4952 free(s); 4953 // start = end 4954 r = cropO(self, 1, 1); 4955 ck_assert_ptr_ne(r, null); 4956 ck_assert_int_eq(lenO(r), 0); 4957 terminateO(r); 4958 s = toStringO(self); 4959 ck_assert_str_eq(s, "[2,3]"); 4960 free(s); 4961 // empty list 4962 emptyO(self); 4963 ck_assert_ptr_eq(cropO(self, 0, 0), NULL); 4964 ck_assert_ptr_eq(cropO(self, -1, 0), NULL); 4965 terminateO(self); 4966 4967 END_TEST 4968 4969 4970 START_TEST(cropElemSmallArrayT) 4971 4972 baset* r; 4973 smallArrayt *self = allocG(rtSmallArrayt); 4974 smallArrayt *r2; 4975 4976 // add elements to self 4977 r2 = self->f->pushInt(self, 1); 4978 ck_assert_ptr_ne(r2, null); 4979 r2 = self->f->pushInt(self, 2); 4980 ck_assert_ptr_ne(r2, null); 4981 r2 = self->f->pushInt(self, 3); 4982 ck_assert_ptr_ne(r2, null); 4983 r2 = self->f->pushInt(self, 4); 4984 ck_assert_ptr_ne(r2, null); 4985 4986 // positive index 4987 r = cropElemO(self,1); 4988 ck_assert_ptr_ne(r, null); 4989 char *s = toStringO(r); 4990 terminateO(r); 4991 ck_assert_str_eq(s, "2"); 4992 free(s); 4993 s = toStringO(self); 4994 ck_assert_str_eq(s, "[1,3,4]"); 4995 free(s); 4996 // negative index 4997 r = cropElemO(self,-1); 4998 ck_assert_ptr_ne(r, null); 4999 s = toStringO(r); 5000 terminateO(r); 5001 ck_assert_str_eq(s, "4"); 5002 free(s); 5003 s = toStringO(self); 5004 ck_assert_str_eq(s, "[1,3]"); 5005 free(s); 5006 // undefined object 5007 r2 = self->f->pushUndefined(self); 5008 ck_assert_ptr_ne(r2, null); 5009 r = cropElemO(self,2); 5010 ck_assert_ptr_ne(r, null); 5011 s = toStringO(r); 5012 terminateO(r); 5013 ck_assert_str_eq(s, "null"); 5014 free(s); 5015 s = toStringO(self); 5016 ck_assert_str_eq(s, "[1,3]"); 5017 free(s); 5018 // container 5019 createSmallContainer(c); 5020 r2 = self->f->pushSmallContainer(self, &c); 5021 r = cropElemO(self,2); 5022 ck_assert_ptr_ne(r, null); 5023 s = toStringO(r); 5024 terminateO(r); 5025 ck_assert_str_eq(s, "<data smallContainer>"); 5026 free(s); 5027 s = toStringO(self); 5028 ck_assert_str_eq(s, "[1,3]"); 5029 free(s); 5030 // base object in container 5031 createAllocateSmallInt(I); 5032 setValG(I, 11); 5033 I->type = "anothertype"; 5034 r2 = self->f->push(self, (baset*)I); 5035 r = cropElemO(self,2); 5036 ck_assert_ptr_ne(r, null); 5037 ck_assert_str_eq(r->type, "anothertype"); 5038 s = toStringO(r); 5039 terminateO(r); 5040 ck_assert_str_eq(s, "11"); 5041 free(s); 5042 s = toStringO(self); 5043 ck_assert_str_eq(s, "[1,3]"); 5044 free(s); 5045 // index outside 5046 ck_assert_ptr_eq(cropElemO(self, 20), NULL); 5047 ck_assert_ptr_eq(cropElemO(self, -4), NULL); 5048 // empty list 5049 emptyO(self); 5050 ck_assert_ptr_eq(cropElemO(self, 0), NULL); 5051 ck_assert_ptr_eq(cropElemO(self, -1), NULL); 5052 // crop empty slot in array 5053 r2 = self->f->pushUndefined(self); 5054 ck_assert_ptr_ne(r2, null); 5055 delElemO(self,0); 5056 ck_assert_ptr_eq(cropElemO(self, 0), NULL); 5057 terminateO(self); 5058 5059 END_TEST 5060 5061 5062 START_TEST(cropElemUndefinedSmallArrayT) 5063 5064 undefinedt* r; 5065 smallArrayt *self = allocG(rtSmallArrayt); 5066 smallArrayt *r2; 5067 5068 // add elements to self 5069 r2 = self->f->pushInt(self, 1); 5070 ck_assert_ptr_ne(r2, null); 5071 r2 = self->f->pushUndefined(self); 5072 ck_assert_ptr_ne(r2, null); 5073 r2 = self->f->pushInt(self, 3); 5074 ck_assert_ptr_ne(r2, null); 5075 r2 = self->f->pushUndefined(self); 5076 ck_assert_ptr_ne(r2, null); 5077 5078 // positive index 5079 r = cropElemUndefinedO(self,1); 5080 ck_assert_ptr_ne(r, null); 5081 char *s = toStringO(r); 5082 terminateO(r); 5083 ck_assert_str_eq(s, "null"); 5084 free(s); 5085 s = toStringO(self); 5086 ck_assert_str_eq(s, "[1,3,null]"); 5087 free(s); 5088 // negative index 5089 r = cropElemUndefinedO(self,-1); 5090 ck_assert_ptr_ne(r, null); 5091 s = toStringO(r); 5092 terminateO(r); 5093 ck_assert_str_eq(s, "null"); 5094 free(s); 5095 s = toStringO(self); 5096 ck_assert_str_eq(s, "[1,3]"); 5097 free(s); 5098 // wrong object type 5099 createSmallInt(I); 5100 setValG(&I, 11); 5101 r2 = self->f->pushSmallInt(self, &I); 5102 ck_assert_ptr_ne(r2, null); 5103 r = cropElemUndefinedO(self,2); 5104 ck_assert_ptr_eq(r, null); 5105 s = toStringO(self); 5106 ck_assert_str_eq(s, "[1,3,11]"); 5107 free(s); 5108 // index outside 5109 ck_assert_ptr_eq(cropElemUndefinedO(self, 20), NULL); 5110 ck_assert_ptr_eq(cropElemUndefinedO(self, -4), NULL); 5111 // empty list 5112 emptyO(self); 5113 ck_assert_ptr_eq(cropElemUndefinedO(self, 0), NULL); 5114 ck_assert_ptr_eq(cropElemUndefinedO(self, -1), NULL); 5115 // crop empty slot in array 5116 r2 = self->f->pushUndefined(self); 5117 ck_assert_ptr_ne(r2, null); 5118 delElemO(self,0); 5119 ck_assert_ptr_eq(cropElemUndefinedO(self, 0), NULL); 5120 terminateO(self); 5121 5122 END_TEST 5123 5124 5125 START_TEST(cropElemBoolSmallArrayT) 5126 5127 bool r; 5128 smallArrayt *self = allocG(rtSmallArrayt); 5129 smallArrayt *r2; 5130 5131 // add elements to self 5132 r2 = self->f->pushInt(self, 1); 5133 ck_assert_ptr_ne(r2, null); 5134 r2 = self->f->pushBool(self, TRUE); 5135 ck_assert_ptr_ne(r2, null); 5136 r2 = self->f->pushInt(self, 3); 5137 ck_assert_ptr_ne(r2, null); 5138 r2 = self->f->pushBool(self, TRUE); 5139 ck_assert_ptr_ne(r2, null); 5140 5141 // positive index 5142 r = cropElemBoolO(self,1); 5143 ck_assert(r); 5144 char *s = toStringO(self); 5145 ck_assert_str_eq(s, "[1,3,true]"); 5146 free(s); 5147 // negative index 5148 r = cropElemBoolO(self,-1); 5149 ck_assert(r); 5150 s = toStringO(self); 5151 ck_assert_str_eq(s, "[1,3]"); 5152 free(s); 5153 // wrong object type 5154 createSmallInt(I); 5155 setValG(&I, 11); 5156 r2 = self->f->pushSmallInt(self, &I); 5157 r = cropElemBoolO(self,2); 5158 ck_assert(!r); 5159 s = toStringO(self); 5160 ck_assert_str_eq(s, "[1,3,11]"); 5161 free(s); 5162 // wrong object type of another user class 5163 // User classes are stored in containers transparently 5164 createAllocateSmallInt(ip); 5165 ip->type = "anothertype"; 5166 setValG(ip, 11); 5167 r2 = self->f->push(self, (baset*)ip); 5168 ck_assert_ptr_ne(r2, null); 5169 r = cropElemBoolO(self,3); 5170 ck_assert(!r); 5171 s = toStringO(self); 5172 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5173 free(s); 5174 // index outside 5175 ck_assert(!cropElemBoolO(self, 20)); 5176 ck_assert(!cropElemBoolO(self, -5)); 5177 // empty list 5178 emptyO(self); 5179 ck_assert(!cropElemBoolO(self, 0)); 5180 ck_assert(!cropElemBoolO(self, -1)); 5181 // crop empty slot in array 5182 r2 = self->f->pushUndefined(self); 5183 ck_assert_ptr_ne(r2, null); 5184 delElemO(self,0); 5185 ck_assert(!cropElemBoolO(self, 0)); 5186 terminateO(self); 5187 5188 END_TEST 5189 5190 5191 START_TEST(cropElemDoubleSmallArrayT) 5192 5193 double r; 5194 smallArrayt *self = allocG(rtSmallArrayt); 5195 smallArrayt *r2; 5196 5197 // add elements to self 5198 r2 = self->f->pushInt(self, 1); 5199 ck_assert_ptr_ne(r2, null); 5200 r2 = self->f->pushDouble(self, 2); 5201 ck_assert_ptr_ne(r2, null); 5202 r2 = self->f->pushInt(self, 3); 5203 ck_assert_ptr_ne(r2, null); 5204 r2 = self->f->pushDouble(self, 4); 5205 ck_assert_ptr_ne(r2, null); 5206 5207 // positive index 5208 r = cropElemDoubleO(self,1); 5209 ck_assert(r==2); 5210 char *s = toStringO(self); 5211 ck_assert_str_eq(s, "[1,3,4.000000e+00]"); 5212 free(s); 5213 // negative index 5214 r = cropElemDoubleO(self,-1); 5215 ck_assert(r==4); 5216 s = toStringO(self); 5217 ck_assert_str_eq(s, "[1,3]"); 5218 free(s); 5219 // wrong object type 5220 createSmallInt(I); 5221 setValG(&I, 11); 5222 r2 = self->f->pushSmallInt(self, &I); 5223 r = cropElemDoubleO(self,2); 5224 ck_assert(!r); 5225 s = toStringO(self); 5226 ck_assert_str_eq(s, "[1,3,11]"); 5227 free(s); 5228 // wrong object type of another user class 5229 // User classes are stored in containers transparently 5230 createAllocateSmallInt(ip); 5231 ip->type = "anothertype"; 5232 setValG(ip, 11); 5233 r2 = self->f->push(self, (baset*)ip); 5234 ck_assert_ptr_ne(r2, null); 5235 r = cropElemDoubleO(self,3); 5236 ck_assert(!r); 5237 s = toStringO(self); 5238 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5239 free(s); 5240 // index outside 5241 ck_assert(!cropElemDoubleO(self, 20)); 5242 ck_assert(!cropElemDoubleO(self, -5)); 5243 // empty list 5244 emptyO(self); 5245 ck_assert(!cropElemDoubleO(self, 0)); 5246 ck_assert(!cropElemDoubleO(self, -1)); 5247 // crop empty slot in array 5248 r2 = self->f->pushUndefined(self); 5249 ck_assert_ptr_ne(r2, null); 5250 delElemO(self,0); 5251 ck_assert(!cropElemDoubleO(self, 0)); 5252 terminateO(self); 5253 5254 END_TEST 5255 5256 5257 START_TEST(cropElemIntSmallArrayT) 5258 5259 int64_t r; 5260 smallArrayt *self = allocG(rtSmallArrayt); 5261 smallArrayt *r2; 5262 5263 // add elements to self 5264 r2 = self->f->pushInt(self, 1); 5265 ck_assert_ptr_ne(r2, null); 5266 r2 = self->f->pushInt(self, 2); 5267 ck_assert_ptr_ne(r2, null); 5268 r2 = self->f->pushInt(self, 3); 5269 ck_assert_ptr_ne(r2, null); 5270 r2 = self->f->pushInt(self, 4); 5271 ck_assert_ptr_ne(r2, null); 5272 5273 // positive index 5274 r = cropElemIntO(self,1); 5275 ck_assert(r==2); 5276 char *s = toStringO(self); 5277 ck_assert_str_eq(s, "[1,3,4]"); 5278 free(s); 5279 // negative index 5280 r = cropElemIntO(self,-1); 5281 ck_assert(r==4); 5282 s = toStringO(self); 5283 ck_assert_str_eq(s, "[1,3]"); 5284 free(s); 5285 // wrong object type 5286 createSmallDouble(I); 5287 setValG(&I, 11); 5288 r2 = self->f->pushSmallDouble(self, &I); 5289 r = cropElemIntO(self,2); 5290 ck_assert(!r); 5291 s = toStringO(self); 5292 ck_assert_str_eq(s, "[1,3,1.100000e+01]"); 5293 free(s); 5294 // wrong object type of another user class 5295 // User classes are stored in containers transparently 5296 createAllocateSmallInt(ip); 5297 ip->type = "anothertype"; 5298 setValG(ip, 11); 5299 r2 = self->f->push(self, (baset*)ip); 5300 ck_assert_ptr_ne(r2, null); 5301 r = cropElemIntO(self,3); 5302 ck_assert(!r); 5303 s = toStringO(self); 5304 ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]"); 5305 free(s); 5306 // index outside 5307 ck_assert(!cropElemIntO(self, 20)); 5308 ck_assert(!cropElemIntO(self, -5)); 5309 // empty list 5310 emptyO(self); 5311 ck_assert(!cropElemIntO(self, 0)); 5312 ck_assert(!cropElemIntO(self, -1)); 5313 // crop empty slot in array 5314 r2 = self->f->pushUndefined(self); 5315 ck_assert_ptr_ne(r2, null); 5316 delElemO(self,0); 5317 ck_assert_int_eq(cropElemIntO(self, 0), 0); 5318 terminateO(self); 5319 5320 END_TEST 5321 5322 5323 START_TEST(cropElemInt32SmallArrayT) 5324 5325 int32_t r; 5326 smallArrayt *self = allocG(rtSmallArrayt); 5327 smallArrayt *r2; 5328 5329 // add elements to self 5330 r2 = self->f->pushInt(self, 1); 5331 ck_assert_ptr_ne(r2, null); 5332 r2 = self->f->pushInt(self, 2); 5333 ck_assert_ptr_ne(r2, null); 5334 r2 = self->f->pushInt(self, 3); 5335 ck_assert_ptr_ne(r2, null); 5336 r2 = self->f->pushInt(self, 4); 5337 ck_assert_ptr_ne(r2, null); 5338 5339 // positive index 5340 r = cropElemInt32O(self,1); 5341 ck_assert(r==2); 5342 char *s = toStringO(self); 5343 ck_assert_str_eq(s, "[1,3,4]"); 5344 free(s); 5345 // negative index 5346 r = cropElemInt32O(self,-1); 5347 ck_assert(r==4); 5348 s = toStringO(self); 5349 ck_assert_str_eq(s, "[1,3]"); 5350 free(s); 5351 // wrong object type 5352 createSmallDouble(I); 5353 setValG(&I, 11); 5354 r2 = self->f->pushSmallDouble(self, &I); 5355 r = cropElemInt32O(self,2); 5356 ck_assert(!r); 5357 s = toStringO(self); 5358 ck_assert_str_eq(s, "[1,3,1.100000e+01]"); 5359 free(s); 5360 // wrong object type of another user class 5361 // User classes are stored in containers transparently 5362 createAllocateSmallInt(ip); 5363 ip->type = "anothertype"; 5364 setValG(ip, 11); 5365 r2 = self->f->push(self, (baset*)ip); 5366 ck_assert_ptr_ne(r2, null); 5367 r = cropElemInt32O(self,3); 5368 ck_assert(!r); 5369 s = toStringO(self); 5370 ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]"); 5371 free(s); 5372 // index outside 5373 ck_assert(!cropElemInt32O(self, 20)); 5374 ck_assert(!cropElemInt32O(self, -5)); 5375 // empty list 5376 emptyO(self); 5377 ck_assert(!cropElemInt32O(self, 0)); 5378 ck_assert(!cropElemInt32O(self, -1)); 5379 // crop empty slot in array 5380 r2 = self->f->pushUndefined(self); 5381 ck_assert_ptr_ne(r2, null); 5382 delElemO(self,0); 5383 ck_assert_int_eq(cropElemInt32O(self, 0), 0); 5384 terminateO(self); 5385 5386 END_TEST 5387 5388 5389 START_TEST(cropElemUintSmallArrayT) 5390 5391 uint64_t r; 5392 smallArrayt *self = allocG(rtSmallArrayt); 5393 smallArrayt *r2; 5394 5395 // add elements to self 5396 r2 = self->f->pushInt(self, 1); 5397 ck_assert_ptr_ne(r2, null); 5398 r2 = self->f->pushInt(self, 2); 5399 ck_assert_ptr_ne(r2, null); 5400 r2 = self->f->pushInt(self, 3); 5401 ck_assert_ptr_ne(r2, null); 5402 r2 = self->f->pushInt(self, 4); 5403 ck_assert_ptr_ne(r2, null); 5404 5405 // positive index 5406 r = cropElemUintO(self,1); 5407 ck_assert(r==2); 5408 char *s = toStringO(self); 5409 ck_assert_str_eq(s, "[1,3,4]"); 5410 free(s); 5411 // negative index 5412 r = cropElemUintO(self,-1); 5413 ck_assert(r==4); 5414 s = toStringO(self); 5415 ck_assert_str_eq(s, "[1,3]"); 5416 free(s); 5417 // wrong object type 5418 createSmallDouble(I); 5419 setValG(&I, 11); 5420 r2 = self->f->pushSmallDouble(self, &I); 5421 r = cropElemUintO(self,2); 5422 ck_assert(!r); 5423 s = toStringO(self); 5424 ck_assert_str_eq(s, "[1,3,1.100000e+01]"); 5425 free(s); 5426 // wrong object type of another user class 5427 // User classes are stored in containers transparently 5428 createAllocateSmallInt(ip); 5429 ip->type = "anothertype"; 5430 setValG(ip, 11); 5431 r2 = self->f->push(self, (baset*)ip); 5432 ck_assert_ptr_ne(r2, null); 5433 r = cropElemUintO(self,3); 5434 ck_assert(!r); 5435 s = toStringO(self); 5436 ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]"); 5437 free(s); 5438 // index outside 5439 ck_assert(!cropElemUintO(self, 20)); 5440 ck_assert(!cropElemUintO(self, -5)); 5441 // empty list 5442 emptyO(self); 5443 ck_assert(!cropElemUintO(self, 0)); 5444 ck_assert(!cropElemUintO(self, -1)); 5445 // crop empty slot in array 5446 r2 = self->f->pushUndefined(self); 5447 ck_assert_ptr_ne(r2, null); 5448 delElemO(self,0); 5449 ck_assert_int_eq(cropElemUintO(self, 0), 0); 5450 terminateO(self); 5451 5452 END_TEST 5453 5454 5455 START_TEST(cropElemUint32SmallArrayT) 5456 5457 uint32_t r; 5458 smallArrayt *self = allocG(rtSmallArrayt); 5459 smallArrayt *r2; 5460 5461 // add elements to self 5462 r2 = self->f->pushInt(self, 1); 5463 ck_assert_ptr_ne(r2, null); 5464 r2 = self->f->pushInt(self, 2); 5465 ck_assert_ptr_ne(r2, null); 5466 r2 = self->f->pushInt(self, 3); 5467 ck_assert_ptr_ne(r2, null); 5468 r2 = self->f->pushInt(self, 4); 5469 ck_assert_ptr_ne(r2, null); 5470 5471 // positive index 5472 r = cropElemUint32O(self,1); 5473 ck_assert(r==2); 5474 char *s = toStringO(self); 5475 ck_assert_str_eq(s, "[1,3,4]"); 5476 free(s); 5477 // negative index 5478 r = cropElemUint32O(self,-1); 5479 ck_assert(r==4); 5480 s = toStringO(self); 5481 ck_assert_str_eq(s, "[1,3]"); 5482 free(s); 5483 // wrong object type 5484 createSmallDouble(I); 5485 setValG(&I, 11); 5486 r2 = self->f->pushSmallDouble(self, &I); 5487 r = cropElemUint32O(self,2); 5488 ck_assert(!r); 5489 s = toStringO(self); 5490 ck_assert_str_eq(s, "[1,3,1.100000e+01]"); 5491 free(s); 5492 // wrong object type of another user class 5493 // User classes are stored in containers transparently 5494 createAllocateSmallInt(ip); 5495 ip->type = "anothertype"; 5496 setValG(ip, 11); 5497 r2 = self->f->push(self, (baset*)ip); 5498 ck_assert_ptr_ne(r2, null); 5499 r = cropElemUint32O(self,3); 5500 ck_assert(!r); 5501 s = toStringO(self); 5502 ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]"); 5503 free(s); 5504 // index outside 5505 ck_assert(!cropElemUint32O(self, 20)); 5506 ck_assert(!cropElemUint32O(self, -5)); 5507 // empty list 5508 emptyO(self); 5509 ck_assert(!cropElemUint32O(self, 0)); 5510 ck_assert(!cropElemUint32O(self, -1)); 5511 // crop empty slot in array 5512 r2 = self->f->pushUndefined(self); 5513 ck_assert_ptr_ne(r2, null); 5514 delElemO(self,0); 5515 ck_assert_int_eq(cropElemUint32O(self, 0), 0); 5516 terminateO(self); 5517 5518 END_TEST 5519 5520 5521 START_TEST(cropElemSSmallArrayT) 5522 5523 char* r; 5524 smallArrayt *self = allocG(rtSmallArrayt); 5525 smallArrayt *r2; 5526 5527 // add elements to self 5528 r2 = self->f->pushInt(self, 1); 5529 ck_assert_ptr_ne(r2, null); 5530 r2 = self->f->pushS(self, "2"); 5531 ck_assert_ptr_ne(r2, null); 5532 r2 = self->f->pushInt(self, 3); 5533 ck_assert_ptr_ne(r2, null); 5534 r2 = self->f->pushS(self, "4"); 5535 ck_assert_ptr_ne(r2, null); 5536 5537 // positive index 5538 r = cropElemSO(self,1); 5539 ck_assert_ptr_ne(r, null); 5540 ck_assert_str_eq(r, "2"); 5541 free(r); 5542 char *s = toStringO(self); 5543 ck_assert_str_eq(s, "[1,3,\"4\"]"); 5544 free(s); 5545 // negative index 5546 r = cropElemSO(self,-1); 5547 ck_assert_ptr_ne(r, null); 5548 ck_assert_str_eq(r, "4"); 5549 free(r); 5550 s = toStringO(self); 5551 ck_assert_str_eq(s, "[1,3]"); 5552 free(s); 5553 // wrong object type 5554 createSmallInt(I); 5555 setValG(&I, 11); 5556 r2 = self->f->pushSmallInt(self, &I); 5557 r = cropElemSO(self,2); 5558 ck_assert_ptr_eq(r, NULL); 5559 s = toStringO(self); 5560 ck_assert_str_eq(s, "[1,3,11]"); 5561 free(s); 5562 // wrong object type of another user class 5563 // User classes are stored in containers transparently 5564 createAllocateSmallInt(ip); 5565 ip->type = "anothertype"; 5566 setValG(ip, 11); 5567 r2 = self->f->push(self, (baset*)ip); 5568 ck_assert_ptr_ne(r2, null); 5569 r = cropElemSO(self,3); 5570 ck_assert_ptr_eq(r, NULL); 5571 s = toStringO(self); 5572 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5573 free(s); 5574 // index outside 5575 ck_assert_ptr_eq(cropElemSO(self, 20), NULL); 5576 ck_assert_ptr_eq(cropElemSO(self, -5), NULL); 5577 // empty list 5578 emptyO(self); 5579 ck_assert_ptr_eq(cropElemSO(self, 0), NULL); 5580 ck_assert_ptr_eq(cropElemSO(self, -1), NULL); 5581 // crop empty slot in array 5582 r2 = self->f->pushUndefined(self); 5583 ck_assert_ptr_ne(r2, null); 5584 delElemO(self,0); 5585 ck_assert_ptr_eq(cropElemSO(self, 0), NULL); 5586 terminateO(self); 5587 5588 END_TEST 5589 5590 5591 START_TEST(cropElemDictSmallArrayT) 5592 5593 smallDictt* r; 5594 smallArrayt *self = allocG(rtSmallArrayt); 5595 smallArrayt *r2; 5596 5597 // add elements to self 5598 r2 = self->f->pushInt(self, 1); 5599 ck_assert_ptr_ne(r2, null); 5600 createSmallDict(e2); 5601 r2 = self->f->pushDict(self, &e2); 5602 ck_assert_ptr_ne(r2, null); 5603 r2 = self->f->pushInt(self, 3); 5604 ck_assert_ptr_ne(r2, null); 5605 createSmallDict(e4); 5606 r2 = self->f->pushDict(self, &e4); 5607 ck_assert_ptr_ne(r2, null); 5608 5609 // positive index 5610 r = cropElemDictO(self,1); 5611 ck_assert_ptr_ne(r, null); 5612 char *s = toStringO(r); 5613 terminateO(r); 5614 ck_assert_str_eq(s, "{}"); 5615 free(s); 5616 s = toStringO(self); 5617 ck_assert_str_eq(s, "[1,3,{}]"); 5618 free(s); 5619 // negative index 5620 r = cropElemDictO(self,-1); 5621 ck_assert_ptr_ne(r, null); 5622 s = toStringO(r); 5623 terminateO(r); 5624 ck_assert_str_eq(s, "{}"); 5625 free(s); 5626 s = toStringO(self); 5627 ck_assert_str_eq(s, "[1,3]"); 5628 free(s); 5629 // wrong object type 5630 createSmallInt(I); 5631 setValG(&I, 11); 5632 r2 = self->f->pushSmallInt(self, &I); 5633 r = cropElemDictO(self,2); 5634 ck_assert_ptr_eq(r, NULL); 5635 s = toStringO(self); 5636 ck_assert_str_eq(s, "[1,3,11]"); 5637 free(s); 5638 // wrong object type of another user class 5639 // User classes are stored in containers transparently 5640 createAllocateSmallInt(ip); 5641 ip->type = "anothertype"; 5642 setValG(ip, 11); 5643 r2 = self->f->push(self, (baset*)ip); 5644 ck_assert_ptr_ne(r2, null); 5645 r = cropElemDictO(self,3); 5646 ck_assert_ptr_eq(r, NULL); 5647 s = toStringO(self); 5648 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5649 free(s); 5650 // index outside 5651 ck_assert_ptr_eq(cropElemDictO(self, 20), NULL); 5652 ck_assert_ptr_eq(cropElemDictO(self, -5), NULL); 5653 // empty list 5654 emptyO(self); 5655 ck_assert_ptr_eq(cropElemDictO(self, 0), NULL); 5656 ck_assert_ptr_eq(cropElemDictO(self, -1), NULL); 5657 // crop empty slot in array 5658 r2 = self->f->pushUndefined(self); 5659 ck_assert_ptr_ne(r2, null); 5660 delElemO(self,0); 5661 ck_assert_ptr_eq(cropElemDictO(self, 0), NULL); 5662 terminateO(self); 5663 5664 END_TEST 5665 5666 5667 START_TEST(cropElemArraySmallArrayT) 5668 5669 smallArrayt* r; 5670 smallArrayt *self = allocG(rtSmallArrayt); 5671 smallArrayt *r2; 5672 5673 // add elements to self 5674 r2 = self->f->pushInt(self, 1); 5675 ck_assert_ptr_ne(r2, null); 5676 createSmallArray(e2); 5677 r2 = self->f->pushArray(self, &e2); 5678 ck_assert_ptr_ne(r2, null); 5679 r2 = self->f->pushInt(self, 3); 5680 ck_assert_ptr_ne(r2, null); 5681 createSmallArray(e4); 5682 r2 = self->f->pushArray(self, &e4); 5683 ck_assert_ptr_ne(r2, null); 5684 5685 // positive index 5686 r = cropElemArrayO(self,1); 5687 ck_assert_ptr_ne(r, null); 5688 char *s = toStringO(r); 5689 terminateO(r); 5690 ck_assert_str_eq(s, "[]"); 5691 free(s); 5692 s = toStringO(self); 5693 ck_assert_str_eq(s, "[1,3,[]]"); 5694 free(s); 5695 // negative index 5696 r = cropElemArrayO(self,-1); 5697 ck_assert_ptr_ne(r, null); 5698 s = toStringO(r); 5699 terminateO(r); 5700 ck_assert_str_eq(s, "[]"); 5701 free(s); 5702 s = toStringO(self); 5703 ck_assert_str_eq(s, "[1,3]"); 5704 free(s); 5705 // wrong object type 5706 createSmallInt(I); 5707 setValG(&I, 11); 5708 r2 = self->f->pushSmallInt(self, &I); 5709 r = cropElemArrayO(self,2); 5710 ck_assert_ptr_eq(r, NULL); 5711 s = toStringO(self); 5712 ck_assert_str_eq(s, "[1,3,11]"); 5713 free(s); 5714 // wrong object type of another user class 5715 // User classes are stored in containers transparently 5716 createAllocateSmallInt(ip); 5717 ip->type = "anothertype"; 5718 setValG(ip, 11); 5719 r2 = self->f->push(self, (baset*)ip); 5720 ck_assert_ptr_ne(r2, null); 5721 r = cropElemArrayO(self,3); 5722 ck_assert_ptr_eq(r, NULL); 5723 s = toStringO(self); 5724 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5725 free(s); 5726 // index outside 5727 ck_assert_ptr_eq(cropElemArrayO(self, 20), NULL); 5728 ck_assert_ptr_eq(cropElemArrayO(self, -5), NULL); 5729 // empty list 5730 emptyO(self); 5731 ck_assert_ptr_eq(cropElemArrayO(self, 0), NULL); 5732 ck_assert_ptr_eq(cropElemArrayO(self, -1), NULL); 5733 // crop empty slot in array 5734 r2 = self->f->pushUndefined(self); 5735 ck_assert_ptr_ne(r2, null); 5736 delElemO(self,0); 5737 ck_assert_ptr_eq(cropElemArrayO(self, 0), NULL); 5738 terminateO(self); 5739 5740 END_TEST 5741 5742 5743 START_TEST(cropElemSmallBoolSmallArrayT) 5744 5745 smallBoolt* r; 5746 smallArrayt *self = allocG(rtSmallArrayt); 5747 smallArrayt *r2; 5748 5749 // add elements to self 5750 r2 = self->f->pushInt(self, 1); 5751 ck_assert_ptr_ne(r2, null); 5752 createSmallBool(e2); 5753 r2 = self->f->pushBool(self, true); 5754 ck_assert_ptr_ne(r2, null); 5755 r2 = self->f->pushInt(self, 3); 5756 ck_assert_ptr_ne(r2, null); 5757 createSmallBool(e4); 5758 r2 = self->f->pushBool(self, true); 5759 ck_assert_ptr_ne(r2, null); 5760 5761 // positive index 5762 r = cropElemSmallBoolO(self,1); 5763 ck_assert_ptr_ne(r, null); 5764 char *s = toStringO(r); 5765 terminateO(r); 5766 ck_assert_str_eq(s, "true"); 5767 free(s); 5768 s = toStringO(self); 5769 ck_assert_str_eq(s, "[1,3,true]"); 5770 free(s); 5771 // negative index 5772 r = cropElemSmallBoolO(self,-1); 5773 ck_assert_ptr_ne(r, null); 5774 s = toStringO(r); 5775 terminateO(r); 5776 ck_assert_str_eq(s, "true"); 5777 free(s); 5778 s = toStringO(self); 5779 ck_assert_str_eq(s, "[1,3]"); 5780 free(s); 5781 // wrong object type 5782 createSmallInt(I); 5783 setValG(&I, 11); 5784 r2 = self->f->pushSmallInt(self, &I); 5785 r = cropElemSmallBoolO(self,2); 5786 ck_assert_ptr_eq(r, NULL); 5787 s = toStringO(self); 5788 ck_assert_str_eq(s, "[1,3,11]"); 5789 free(s); 5790 // wrong object type of another user class 5791 // User classes are stored in containers transparently 5792 createAllocateSmallInt(ip); 5793 ip->type = "anothertype"; 5794 setValG(ip, 11); 5795 r2 = self->f->push(self, (baset*)ip); 5796 ck_assert_ptr_ne(r2, null); 5797 r = cropElemSmallBoolO(self,3); 5798 ck_assert_ptr_eq(r, NULL); 5799 s = toStringO(self); 5800 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5801 free(s); 5802 // index outside 5803 ck_assert_ptr_eq(cropElemSmallBoolO(self, 20), NULL); 5804 ck_assert_ptr_eq(cropElemSmallBoolO(self, -5), NULL); 5805 // empty list 5806 emptyO(self); 5807 ck_assert_ptr_eq(cropElemSmallBoolO(self, 0), NULL); 5808 ck_assert_ptr_eq(cropElemSmallBoolO(self, -1), NULL); 5809 // crop empty slot in array 5810 r2 = self->f->pushUndefined(self); 5811 ck_assert_ptr_ne(r2, null); 5812 delElemO(self,0); 5813 ck_assert_ptr_eq(cropElemSmallBoolO(self, 0), NULL); 5814 terminateO(self); 5815 5816 END_TEST 5817 5818 5819 START_TEST(cropElemSmallBytesSmallArrayT) 5820 5821 smallBytest* r; 5822 smallArrayt *self = allocG(rtSmallArrayt); 5823 smallArrayt *r2; 5824 5825 // add elements to self 5826 r2 = self->f->pushInt(self, 1); 5827 ck_assert_ptr_ne(r2, null); 5828 createSmallBytes(e2); 5829 r2 = self->f->pushSmallBytes(self, &e2); 5830 ck_assert_ptr_ne(r2, null); 5831 r2 = self->f->pushInt(self, 3); 5832 ck_assert_ptr_ne(r2, null); 5833 createSmallBytes(e4); 5834 r2 = self->f->pushSmallBytes(self, &e4); 5835 ck_assert_ptr_ne(r2, null); 5836 5837 // positive index 5838 r = cropElemSmallBytesO(self,1); 5839 ck_assert_ptr_ne(r, null); 5840 char *s = toStringO(r); 5841 terminateO(r); 5842 ck_assert_str_eq(s, "[]"); 5843 free(s); 5844 s = toStringO(self); 5845 ck_assert_str_eq(s, "[1,3,[]]"); 5846 free(s); 5847 // negative index 5848 r = cropElemSmallBytesO(self,-1); 5849 ck_assert_ptr_ne(r, null); 5850 s = toStringO(r); 5851 terminateO(r); 5852 ck_assert_str_eq(s, "[]"); 5853 free(s); 5854 s = toStringO(self); 5855 ck_assert_str_eq(s, "[1,3]"); 5856 free(s); 5857 // wrong object type 5858 createSmallInt(I); 5859 setValG(&I, 11); 5860 r2 = self->f->pushSmallInt(self, &I); 5861 r = cropElemSmallBytesO(self,2); 5862 ck_assert_ptr_eq(r, NULL); 5863 s = toStringO(self); 5864 ck_assert_str_eq(s, "[1,3,11]"); 5865 free(s); 5866 // wrong object type of another user class 5867 // User classes are stored in containers transparently 5868 createAllocateSmallInt(ip); 5869 ip->type = "anothertype"; 5870 setValG(ip, 11); 5871 r2 = self->f->push(self, (baset*)ip); 5872 ck_assert_ptr_ne(r2, null); 5873 r = cropElemSmallBytesO(self,3); 5874 ck_assert_ptr_eq(r, NULL); 5875 s = toStringO(self); 5876 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5877 free(s); 5878 // index outside 5879 ck_assert_ptr_eq(cropElemSmallBytesO(self, 20), NULL); 5880 ck_assert_ptr_eq(cropElemSmallBytesO(self, -5), NULL); 5881 // empty list 5882 emptyO(self); 5883 ck_assert_ptr_eq(cropElemSmallBytesO(self, 0), NULL); 5884 ck_assert_ptr_eq(cropElemSmallBytesO(self, -1), NULL); 5885 // crop empty slot in array 5886 r2 = self->f->pushUndefined(self); 5887 ck_assert_ptr_ne(r2, null); 5888 delElemO(self,0); 5889 ck_assert_ptr_eq(cropElemSmallBytesO(self, 0), NULL); 5890 terminateO(self); 5891 5892 END_TEST 5893 5894 5895 START_TEST(cropElemSmallDoubleSmallArrayT) 5896 5897 smallDoublet* r; 5898 smallArrayt *self = allocG(rtSmallArrayt); 5899 smallArrayt *r2; 5900 5901 // add elements to self 5902 r2 = self->f->pushInt(self, 1); 5903 ck_assert_ptr_ne(r2, null); 5904 createSmallDouble(e2); 5905 r2 = self->f->pushSmallDouble(self, &e2); 5906 ck_assert_ptr_ne(r2, null); 5907 r2 = self->f->pushInt(self, 3); 5908 ck_assert_ptr_ne(r2, null); 5909 createSmallDouble(e4); 5910 r2 = self->f->pushSmallDouble(self, &e4); 5911 ck_assert_ptr_ne(r2, null); 5912 5913 // positive index 5914 r = cropElemSmallDoubleO(self,1); 5915 ck_assert_ptr_ne(r, null); 5916 char *s = toStringO(r); 5917 terminateO(r); 5918 ck_assert_str_eq(s, "0.000000e+00"); 5919 free(s); 5920 s = toStringO(self); 5921 ck_assert_str_eq(s, "[1,3,0.000000e+00]"); 5922 free(s); 5923 // negative index 5924 r = cropElemSmallDoubleO(self,-1); 5925 ck_assert_ptr_ne(r, null); 5926 s = toStringO(r); 5927 terminateO(r); 5928 ck_assert_str_eq(s, "0.000000e+00"); 5929 free(s); 5930 s = toStringO(self); 5931 ck_assert_str_eq(s, "[1,3]"); 5932 free(s); 5933 // wrong object type 5934 createSmallInt(I); 5935 setValG(&I, 11); 5936 r2 = self->f->pushSmallInt(self, &I); 5937 r = cropElemSmallDoubleO(self,2); 5938 ck_assert_ptr_eq(r, NULL); 5939 s = toStringO(self); 5940 ck_assert_str_eq(s, "[1,3,11]"); 5941 free(s); 5942 // wrong object type of another user class 5943 // User classes are stored in containers transparently 5944 createAllocateSmallInt(ip); 5945 ip->type = "anothertype"; 5946 setValG(ip, 11); 5947 r2 = self->f->push(self, (baset*)ip); 5948 ck_assert_ptr_ne(r2, null); 5949 r = cropElemSmallDoubleO(self,3); 5950 ck_assert_ptr_eq(r, NULL); 5951 s = toStringO(self); 5952 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5953 free(s); 5954 // index outside 5955 ck_assert_ptr_eq(cropElemSmallDoubleO(self, 20), NULL); 5956 ck_assert_ptr_eq(cropElemSmallDoubleO(self, -5), NULL); 5957 // empty list 5958 emptyO(self); 5959 ck_assert_ptr_eq(cropElemSmallDoubleO(self, 0), NULL); 5960 ck_assert_ptr_eq(cropElemSmallDoubleO(self, -1), NULL); 5961 // crop empty slot in array 5962 r2 = self->f->pushUndefined(self); 5963 ck_assert_ptr_ne(r2, null); 5964 delElemO(self,0); 5965 ck_assert_ptr_eq(cropElemSmallDoubleO(self, 0), NULL); 5966 terminateO(self); 5967 5968 END_TEST 5969 5970 5971 START_TEST(cropElemSmallIntSmallArrayT) 5972 5973 smallIntt* r; 5974 smallArrayt *self = allocG(rtSmallArrayt); 5975 smallArrayt *r2; 5976 5977 // add elements to self 5978 r2 = self->f->pushBool(self, true); 5979 ck_assert_ptr_ne(r2, null); 5980 createSmallInt(e2); 5981 r2 = self->f->pushSmallInt(self, &e2); 5982 ck_assert_ptr_ne(r2, null); 5983 r2 = self->f->pushBool(self, true); 5984 ck_assert_ptr_ne(r2, null); 5985 createSmallInt(e4); 5986 r2 = self->f->pushSmallInt(self, &e4); 5987 ck_assert_ptr_ne(r2, null); 5988 5989 // positive index 5990 r = cropElemSmallIntO(self,1); 5991 ck_assert_ptr_ne(r, null); 5992 char *s = toStringO(r); 5993 terminateO(r); 5994 ck_assert_str_eq(s, "0"); 5995 free(s); 5996 s = toStringO(self); 5997 ck_assert_str_eq(s, "[true,true,0]"); 5998 free(s); 5999 // negative index 6000 r = cropElemSmallIntO(self,-1); 6001 ck_assert_ptr_ne(r, null); 6002 s = toStringO(r); 6003 terminateO(r); 6004 ck_assert_str_eq(s, "0"); 6005 free(s); 6006 s = toStringO(self); 6007 ck_assert_str_eq(s, "[true,true]"); 6008 free(s); 6009 // wrong object type 6010 createSmallDouble(I); 6011 setValG(&I, 11); 6012 r2 = self->f->pushSmallDouble(self, &I); 6013 r = cropElemSmallIntO(self,2); 6014 ck_assert_ptr_eq(r, NULL); 6015 s = toStringO(self); 6016 ck_assert_str_eq(s, "[true,true,1.100000e+01]"); 6017 free(s); 6018 // wrong object type of another user class 6019 // User classes are stored in containers transparently 6020 createAllocateSmallInt(ip); 6021 ip->type = "anothertype"; 6022 setValG(ip, 11); 6023 r2 = self->f->push(self, (baset*)ip); 6024 ck_assert_ptr_ne(r2, null); 6025 r = cropElemSmallIntO(self,3); 6026 ck_assert_ptr_eq(r, NULL); 6027 s = toStringO(self); 6028 ck_assert_str_eq(s, "[true,true,1.100000e+01,\"<data container>\"]"); 6029 free(s); 6030 // index outside 6031 ck_assert_ptr_eq(cropElemSmallIntO(self, 20), NULL); 6032 ck_assert_ptr_eq(cropElemSmallIntO(self, -5), NULL); 6033 // empty list 6034 emptyO(self); 6035 ck_assert_ptr_eq(cropElemSmallIntO(self, 0), NULL); 6036 ck_assert_ptr_eq(cropElemSmallIntO(self, -1), NULL); 6037 // crop empty slot in array 6038 r2 = self->f->pushUndefined(self); 6039 ck_assert_ptr_ne(r2, null); 6040 delElemO(self,0); 6041 ck_assert_ptr_eq(cropElemSmallIntO(self, 0), NULL); 6042 terminateO(self); 6043 6044 END_TEST 6045 6046 6047 START_TEST(cropElemSmallJsonSmallArrayT) 6048 6049 smallJsont* r; 6050 smallArrayt *self = allocG(rtSmallArrayt); 6051 smallArrayt *r2; 6052 6053 // add elements to self 6054 r2 = self->f->pushInt(self, 1); 6055 ck_assert_ptr_ne(r2, null); 6056 createSmallJson(e2); 6057 r2 = self->f->pushSmallJson(self, &e2); 6058 ck_assert_ptr_ne(r2, null); 6059 r2 = self->f->pushInt(self, 3); 6060 ck_assert_ptr_ne(r2, null); 6061 createSmallJson(e4); 6062 r2 = self->f->pushSmallJson(self, &e4); 6063 ck_assert_ptr_ne(r2, null); 6064 6065 // positive index 6066 r = cropElemSmallJsonO(self,1); 6067 ck_assert_ptr_ne(r, null); 6068 char *s = toStringO(r); 6069 terminateO(r); 6070 ck_assert_str_eq(s, "{}"); 6071 free(s); 6072 s = toStringO(self); 6073 ck_assert_str_eq(s, "[1,3,{}]"); 6074 free(s); 6075 // negative index 6076 r = cropElemSmallJsonO(self,-1); 6077 ck_assert_ptr_ne(r, null); 6078 s = toStringO(r); 6079 terminateO(r); 6080 ck_assert_str_eq(s, "{}"); 6081 free(s); 6082 s = toStringO(self); 6083 ck_assert_str_eq(s, "[1,3]"); 6084 free(s); 6085 // wrong object type 6086 createSmallBytes(I); 6087 r2 = self->f->pushSmallBytes(self, &I); 6088 r = cropElemSmallJsonO(self,2); 6089 ck_assert_ptr_eq(r, NULL); 6090 s = toStringO(self); 6091 ck_assert_str_eq(s, "[1,3,[]]"); 6092 free(s); 6093 // wrong object type of another user class 6094 // User classes are stored in containers transparently 6095 createAllocateSmallInt(ip); 6096 ip->type = "anothertype"; 6097 setValG(ip, 11); 6098 r2 = self->f->push(self, (baset*)ip); 6099 ck_assert_ptr_ne(r2, null); 6100 r = cropElemSmallJsonO(self,3); 6101 ck_assert_ptr_eq(r, NULL); 6102 s = toStringO(self); 6103 ck_assert_str_eq(s, "[1,3,[],\"<data container>\"]"); 6104 free(s); 6105 // index outside 6106 ck_assert_ptr_eq(cropElemSmallJsonO(self, 20), NULL); 6107 ck_assert_ptr_eq(cropElemSmallJsonO(self, -5), NULL); 6108 // empty list 6109 emptyO(self); 6110 ck_assert_ptr_eq(cropElemSmallJsonO(self, 0), NULL); 6111 ck_assert_ptr_eq(cropElemSmallJsonO(self, -1), NULL); 6112 // crop empty slot in array 6113 r2 = self->f->pushUndefined(self); 6114 ck_assert_ptr_ne(r2, null); 6115 delElemO(self,0); 6116 ck_assert_ptr_eq(cropElemSmallJsonO(self, 0), NULL); 6117 terminateO(self); 6118 6119 END_TEST 6120 6121 6122 START_TEST(cropElemSmallStringSmallArrayT) 6123 6124 smallStringt* r; 6125 smallArrayt *self = allocG(rtSmallArrayt); 6126 smallArrayt *r2; 6127 6128 // add elements to self 6129 r2 = self->f->pushInt(self, 1); 6130 ck_assert_ptr_ne(r2, null); 6131 createSmallString(e2); 6132 r2 = self->f->pushSmallString(self, &e2); 6133 ck_assert_ptr_ne(r2, null); 6134 r2 = self->f->pushInt(self, 3); 6135 ck_assert_ptr_ne(r2, null); 6136 createSmallString(e4); 6137 r2 = self->f->pushSmallString(self, &e4); 6138 ck_assert_ptr_ne(r2, null); 6139 6140 // positive index 6141 r = cropElemSmallStringO(self,1); 6142 ck_assert_ptr_ne(r, null); 6143 char *s = toStringO(r); 6144 terminateO(r); 6145 ck_assert_str_eq(s, ""); 6146 free(s); 6147 s = toStringO(self); 6148 ck_assert_str_eq(s, "[1,3,\"\"]"); 6149 free(s); 6150 // negative index 6151 r = cropElemSmallStringO(self,-1); 6152 ck_assert_ptr_ne(r, null); 6153 s = toStringO(r); 6154 terminateO(r); 6155 ck_assert_str_eq(s, ""); 6156 free(s); 6157 s = toStringO(self); 6158 ck_assert_str_eq(s, "[1,3]"); 6159 free(s); 6160 // wrong object type 6161 createSmallInt(I); 6162 setValG(&I, 11); 6163 r2 = self->f->pushSmallInt(self, &I); 6164 r = cropElemSmallStringO(self,2); 6165 ck_assert_ptr_eq(r, NULL); 6166 s = toStringO(self); 6167 ck_assert_str_eq(s, "[1,3,11]"); 6168 free(s); 6169 // wrong object type of another user class 6170 // User classes are stored in containers transparently 6171 createAllocateSmallInt(ip); 6172 ip->type = "anothertype"; 6173 setValG(ip, 11); 6174 r2 = self->f->push(self, (baset*)ip); 6175 ck_assert_ptr_ne(r2, null); 6176 r = cropElemSmallStringO(self,3); 6177 ck_assert_ptr_eq(r, NULL); 6178 s = toStringO(self); 6179 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 6180 free(s); 6181 // index outside 6182 ck_assert_ptr_eq(cropElemSmallStringO(self, 20), NULL); 6183 ck_assert_ptr_eq(cropElemSmallStringO(self, -5), NULL); 6184 // empty list 6185 emptyO(self); 6186 ck_assert_ptr_eq(cropElemSmallStringO(self, 0), NULL); 6187 ck_assert_ptr_eq(cropElemSmallStringO(self, -1), NULL); 6188 // crop empty slot in array 6189 r2 = self->f->pushUndefined(self); 6190 ck_assert_ptr_ne(r2, null); 6191 delElemO(self,0); 6192 ck_assert_ptr_eq(cropElemSmallStringO(self, 0), NULL); 6193 terminateO(self); 6194 6195 END_TEST 6196 6197 6198 START_TEST(cropElemVoidSmallArrayT) 6199 6200 void* r; 6201 smallArrayt *self = allocG(rtSmallArrayt); 6202 smallArrayt *r2; 6203 6204 // add elements to self 6205 r2 = self->f->pushInt(self, 1); 6206 ck_assert_ptr_ne(r2, null); 6207 r2 = pushVoidSmallArrayG(self, &r); 6208 ck_assert_ptr_ne(r2, null); 6209 r2 = self->f->pushInt(self, 3); 6210 ck_assert_ptr_ne(r2, null); 6211 r2 = pushVoidSmallArrayG(self, &self); 6212 ck_assert_ptr_ne(r2, null); 6213 6214 // positive index 6215 r = cropElemVoidO(self,1); 6216 ck_assert_ptr_eq(r, &r); 6217 char *s = toStringO(self); 6218 ck_assert_str_eq(s, "[1,3,\"<data container>\"]"); 6219 free(s); 6220 // negative index 6221 r = cropElemVoidO(self,-1); 6222 ck_assert_ptr_eq(r, &self); 6223 s = toStringO(self); 6224 ck_assert_str_eq(s, "[1,3]"); 6225 free(s); 6226 // wrong object type 6227 createSmallInt(I); 6228 setValG(&I, 11); 6229 r2 = self->f->pushSmallInt(self, &I); 6230 r = cropElemVoidO(self,2); 6231 ck_assert_ptr_eq(r, NULL); 6232 s = toStringO(self); 6233 ck_assert_str_eq(s, "[1,3,11]"); 6234 free(s); 6235 // wrong object type of another user class 6236 // User classes are stored in containers transparently 6237 createAllocateSmallInt(ip); 6238 ip->type = "anothertype"; 6239 setValG(ip, 11); 6240 r2 = self->f->push(self, (baset*)ip); 6241 ck_assert_ptr_ne(r2, null); 6242 r = cropElemVoidO(self,3); 6243 ck_assert_ptr_eq(r, NULL); 6244 s = toStringO(self); 6245 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 6246 free(s); 6247 // index outside 6248 ck_assert_ptr_eq(cropElemVoidO(self, 20), NULL); 6249 ck_assert_ptr_eq(cropElemVoidO(self, -5), NULL); 6250 // empty list 6251 emptyO(self); 6252 ck_assert_ptr_eq(cropElemVoidO(self, 0), NULL); 6253 ck_assert_ptr_eq(cropElemVoidO(self, -1), NULL); 6254 // crop empty slot in array 6255 r2 = self->f->pushUndefined(self); 6256 ck_assert_ptr_ne(r2, null); 6257 delElemO(self,0); 6258 ck_assert_ptr_eq(cropElemVoidO(self, 0), NULL); 6259 terminateO(self); 6260 6261 END_TEST 6262 6263 6264 START_TEST(cropElemSmallContainerSmallArrayT) 6265 6266 smallContainert* r; 6267 smallArrayt *self = allocG(rtSmallArrayt); 6268 smallArrayt *r2; 6269 6270 // add elements to self 6271 r2 = self->f->pushInt(self, 1); 6272 ck_assert_ptr_ne(r2, null); 6273 createSmallContainer(e2); 6274 r2 = self->f->pushSmallContainer(self, &e2); 6275 ck_assert_ptr_ne(r2, null); 6276 r2 = self->f->pushInt(self, 3); 6277 ck_assert_ptr_ne(r2, null); 6278 createSmallContainer(e4); 6279 r2 = self->f->pushSmallContainer(self, &e4); 6280 ck_assert_ptr_ne(r2, null); 6281 6282 // positive index 6283 r = cropElemSmallContainerO(self,1); 6284 ck_assert_ptr_ne(r, null); 6285 char *s = toStringO(r); 6286 terminateO(r); 6287 ck_assert_str_eq(s, "<data smallContainer>"); 6288 free(s); 6289 s = toStringO(self); 6290 ck_assert_str_eq(s, "[1,3,\"<data container>\"]"); 6291 free(s); 6292 // negative index 6293 r = cropElemSmallContainerO(self,-1); 6294 ck_assert_ptr_ne(r, null); 6295 s = toStringO(r); 6296 terminateO(r); 6297 ck_assert_str_eq(s, "<data smallContainer>"); 6298 free(s); 6299 s = toStringO(self); 6300 ck_assert_str_eq(s, "[1,3]"); 6301 free(s); 6302 // wrong object type 6303 createSmallInt(I); 6304 setValG(&I, 11); 6305 r2 = self->f->pushSmallInt(self, &I); 6306 r = cropElemSmallContainerO(self,2); 6307 ck_assert_ptr_eq(r, NULL); 6308 s = toStringO(self); 6309 ck_assert_str_eq(s, "[1,3,11]"); 6310 free(s); 6311 // wrong object type of another user class 6312 // User classes are stored in containers transparently 6313 createAllocateSmallInt(ip); 6314 ip->type = "anothertype"; 6315 setValG(ip, 11); 6316 r2 = self->f->push(self, (baset*)ip); 6317 ck_assert_ptr_ne(r2, null); 6318 r = cropElemSmallContainerO(self,3); 6319 ck_assert_ptr_eq(r, NULL); 6320 s = toStringO(self); 6321 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 6322 free(s); 6323 // index outside 6324 ck_assert_ptr_eq(cropElemSmallContainerO(self, 20), NULL); 6325 ck_assert_ptr_eq(cropElemSmallContainerO(self, -5), NULL); 6326 // empty list 6327 emptyO(self); 6328 ck_assert_ptr_eq(cropElemSmallContainerO(self, 0), NULL); 6329 ck_assert_ptr_eq(cropElemSmallContainerO(self, -1), NULL); 6330 // crop empty slot in array 6331 r2 = self->f->pushUndefined(self); 6332 ck_assert_ptr_ne(r2, null); 6333 delElemO(self,0); 6334 ck_assert_ptr_eq(cropElemSmallContainerO(self, 0), NULL); 6335 terminateO(self); 6336 6337 END_TEST 6338 6339 6340 START_TEST(copySmallArrayT) 6341 6342 smallArrayt* r; 6343 smallArrayt *self = allocG(rtSmallArrayt); 6344 6345 // add elements to self 6346 r = self->f->pushInt(self, 1); 6347 ck_assert_ptr_ne(r, null); 6348 r = self->f->pushInt(self, 2); 6349 ck_assert_ptr_ne(r, null); 6350 r = self->f->pushInt(self, 3); 6351 ck_assert_ptr_ne(r, null); 6352 r = self->f->pushInt(self, 4); 6353 ck_assert_ptr_ne(r, null); 6354 6355 // negative index 6356 r = copyRngO(self, 1, -1); 6357 ck_assert_ptr_ne(r, null); 6358 ck_assert_int_eq(lenO(r), 2); 6359 char *s = toStringO(r); 6360 terminateO(r); 6361 ck_assert_str_eq(s, "[2,3]"); 6362 free(s); 6363 s = toStringO(self); 6364 ck_assert_str_eq(s, "[1,2,3,4]"); 6365 free(s); 6366 // start outside 6367 ck_assert_ptr_eq(copyRngO(self, 20, -3), NULL); 6368 // end outside 6369 r = copyRngO(self, 0, 40); 6370 ck_assert_ptr_ne(r, null); 6371 ck_assert_int_eq(lenO(r), 4); 6372 s = toStringO(r); 6373 terminateO(r); 6374 ck_assert_str_eq(s, "[1,2,3,4]"); 6375 free(s); 6376 s = toStringO(self); 6377 ck_assert_str_eq(s, "[1,2,3,4]"); 6378 free(s); 6379 // end negative and outside 6380 ck_assert_ptr_eq(copyRngO(self, 2, -40), NULL); 6381 s = toStringO(self); 6382 ck_assert_str_eq(s, "[1,2,3,4]"); 6383 free(s); 6384 // end before start 6385 ck_assert_ptr_eq(copyRngO(self, 3, 2), NULL); 6386 s = toStringO(self); 6387 ck_assert_str_eq(s, "[1,2,3,4]"); 6388 free(s); 6389 // negative start last element 6390 r = copyRngO(self, -1, 0); 6391 ck_assert_ptr_ne(r, null); 6392 ck_assert_int_eq(lenO(r), 1); 6393 s = toStringO(r); 6394 terminateO(r); 6395 ck_assert_str_eq(s, "[4]"); 6396 free(s); 6397 s = toStringO(self); 6398 ck_assert_str_eq(s, "[1,2,3,4]"); 6399 free(s); 6400 // negative start and outside 6401 r = copyRngO(self, -10, 1); 6402 ck_assert_ptr_ne(r, null); 6403 ck_assert_int_eq(lenO(r), 1); 6404 s = toStringO(r); 6405 terminateO(r); 6406 ck_assert_str_eq(s, "[1]"); 6407 free(s); 6408 s = toStringO(self); 6409 ck_assert_str_eq(s, "[1,2,3,4]"); 6410 free(s); 6411 // start = end 6412 r = copyRngO(self, 1, 1); 6413 ck_assert_ptr_ne(r, null); 6414 ck_assert_int_eq(lenO(r), 0); 6415 terminateO(r); 6416 s = toStringO(self); 6417 ck_assert_str_eq(s, "[1,2,3,4]"); 6418 free(s); 6419 // empty list 6420 emptyO(self); 6421 ck_assert_ptr_eq(copyRngO(self, 0, 0), NULL); 6422 ck_assert_ptr_eq(copyRngO(self, -1, 0), NULL); 6423 terminateO(self); 6424 6425 END_TEST 6426 6427 6428 START_TEST(insertSmallArrayT) 6429 6430 smallArrayt* r; 6431 smallArrayt *self = allocG(rtSmallArrayt); 6432 smallArrayt *toInsert; 6433 6434 // add elements to self 6435 r = self->f->pushInt(self, 1); 6436 ck_assert_ptr_ne(r, null); 6437 r = self->f->pushInt(self, 2); 6438 ck_assert_ptr_ne(r, null); 6439 6440 // positive index 6441 toInsert = allocSmallArray(); 6442 toInsert->f->pushInt(toInsert, 3); 6443 r = self->f->insert(self, 1, toInsert); 6444 smashO(toInsert); 6445 ck_assert_ptr_ne(r, null); 6446 char *s = toStringO(r); 6447 ck_assert_str_eq(s, "[1,3,2]"); 6448 free(s); 6449 // negative index 6450 toInsert = allocSmallArray(); 6451 toInsert->f->pushInt(toInsert, 4); 6452 r = self->f->insert(self, -1, toInsert); 6453 smashO(toInsert); 6454 ck_assert_ptr_ne(r, null); 6455 s = toStringO(r); 6456 ck_assert_str_eq(s, "[1,3,2,4]"); 6457 free(s); 6458 // empty list 6459 emptyO(self); 6460 toInsert = allocSmallArray(); 6461 toInsert->f->pushInt(toInsert, 3); 6462 r = self->f->insert(self, 0, toInsert); 6463 smashO(toInsert); 6464 ck_assert_ptr_ne(r, null); 6465 s = toStringO(r); 6466 ck_assert_str_eq(s, "[3]"); 6467 free(s); 6468 emptyO(self); 6469 toInsert = allocSmallArray(); 6470 toInsert->f->pushInt(toInsert, 3); 6471 r = self->f->insert(self, -1, toInsert); 6472 smashO(toInsert); 6473 ck_assert_ptr_ne(r, null); 6474 s = toStringO(r); 6475 ck_assert_str_eq(s, "[3]"); 6476 free(s); 6477 // Array array length 0 6478 toInsert = allocSmallArray(); 6479 r = self->f->insert(self, -1, toInsert); 6480 smashO(toInsert); 6481 ck_assert_ptr_ne(r, null); 6482 s = toStringO(r); 6483 ck_assert_str_eq(s, "[3]"); 6484 free(s); 6485 // index outside 6486 toInsert = allocSmallArray(); 6487 ck_assert_ptr_eq(self->f->insert(self, 20, toInsert), NULL); 6488 ck_assert_ptr_eq(self->f->insert(self, -5, toInsert), NULL); 6489 smashO(toInsert); 6490 // non smallArray toInsert 6491 toInsert = (smallArrayt*) allocSmallInt(1); 6492 ck_assert_ptr_eq(self->f->insert(self, 0, toInsert), NULL); 6493 terminateO(toInsert); 6494 // insert NULL 6495 ck_assert_ptr_eq(self->f->insert(self, 0, NULL), NULL); 6496 terminateO(self); 6497 6498 END_TEST 6499 6500 6501 START_TEST(insertSmallJsonSmallArrayT) 6502 6503 smallArrayt* r; 6504 smallArrayt *self = allocG(rtSmallArrayt); 6505 smallJsont *toInsert; 6506 6507 // add elements to self 6508 r = self->f->pushInt(self, 1); 6509 ck_assert_ptr_ne(r, null); 6510 r = self->f->pushInt(self, 2); 6511 ck_assert_ptr_ne(r, null); 6512 6513 // positive index 6514 toInsert = allocSmallJson(); 6515 toInsert->f->pushInt(toInsert, 3); 6516 r = self->f->insertSmallJson(self, 1, toInsert); 6517 smashO(toInsert); 6518 ck_assert_ptr_ne(r, null); 6519 char *s = toStringO(r); 6520 ck_assert_str_eq(s, "[1,3,2]"); 6521 free(s); 6522 // negative index 6523 toInsert = allocSmallJson(); 6524 toInsert->f->pushInt(toInsert, 4); 6525 r = self->f->insertSmallJson(self, -1, toInsert); 6526 smashO(toInsert); 6527 ck_assert_ptr_ne(r, null); 6528 s = toStringO(r); 6529 ck_assert_str_eq(s, "[1,3,2,4]"); 6530 free(s); 6531 // empty list 6532 emptyO(self); 6533 toInsert = allocSmallJson(); 6534 toInsert->f->pushInt(toInsert, 3); 6535 r = self->f->insertSmallJson(self, 0, toInsert); 6536 smashO(toInsert); 6537 ck_assert_ptr_ne(r, null); 6538 s = toStringO(r); 6539 ck_assert_str_eq(s, "[3]"); 6540 free(s); 6541 emptyO(self); 6542 toInsert = allocSmallJson(); 6543 toInsert->f->pushInt(toInsert, 3); 6544 r = self->f->insertSmallJson(self, -1, toInsert); 6545 smashO(toInsert); 6546 ck_assert_ptr_ne(r, null); 6547 s = toStringO(r); 6548 ck_assert_str_eq(s, "[3]"); 6549 free(s); 6550 // json array length 0 6551 toInsert = allocSmallJson(); 6552 setTypeArrayG(toInsert); 6553 r = self->f->insertSmallJson(self, -1, toInsert); 6554 smashO(toInsert); 6555 ck_assert_ptr_ne(r, null); 6556 s = toStringO(r); 6557 ck_assert_str_eq(s, "[3]"); 6558 free(s); 6559 // json with no type 6560 toInsert = allocSmallJson(); 6561 r = self->f->insertSmallJson(self, -1, toInsert); 6562 smashO(toInsert); 6563 ck_assert_ptr_eq(r, null); 6564 s = toStringO(self); 6565 ck_assert_str_eq(s, "[3]"); 6566 free(s); 6567 // non smallJson object 6568 toInsert = (smallJsont*) allocSmallInt(2); 6569 r = self->f->insertSmallJson(self, -1, toInsert); 6570 ck_assert_ptr_eq(r, null); 6571 terminateO(toInsert); 6572 // index outside 6573 toInsert = allocSmallJson(); 6574 ck_assert_ptr_eq(self->f->insertSmallJson(self, 20, toInsert), NULL); 6575 ck_assert_ptr_eq(self->f->insertSmallJson(self, -5, toInsert), NULL); 6576 smashO(toInsert); 6577 // insert NULL 6578 ck_assert_ptr_eq(self->f->insertSmallJson(self, 0, NULL), NULL); 6579 terminateO(self); 6580 6581 END_TEST 6582 6583 6584 START_TEST(insertNSmashSmallArrayT) 6585 6586 smallArrayt* r; 6587 smallArrayt *self = allocG(rtSmallArrayt); 6588 smallArrayt *toInsert; 6589 6590 // add elements to self 6591 r = self->f->pushInt(self, 1); 6592 ck_assert_ptr_ne(r, null); 6593 r = self->f->pushInt(self, 2); 6594 ck_assert_ptr_ne(r, null); 6595 6596 // positive index 6597 toInsert = allocSmallArray(); 6598 toInsert->f->pushInt(toInsert, 3); 6599 r = self->f->insertNSmash(self, 1, toInsert); 6600 ck_assert_ptr_ne(r, null); 6601 char *s = toStringO(r); 6602 ck_assert_str_eq(s, "[1,3,2]"); 6603 free(s); 6604 // negative index 6605 toInsert = allocSmallArray(); 6606 toInsert->f->pushInt(toInsert, 4); 6607 r = self->f->insertNSmash(self, -1, toInsert); 6608 ck_assert_ptr_ne(r, null); 6609 s = toStringO(r); 6610 ck_assert_str_eq(s, "[1,3,2,4]"); 6611 free(s); 6612 // empty list 6613 emptyO(self); 6614 toInsert = allocSmallArray(); 6615 toInsert->f->pushInt(toInsert, 3); 6616 r = self->f->insertNSmash(self, 0, toInsert); 6617 ck_assert_ptr_ne(r, null); 6618 s = toStringO(r); 6619 ck_assert_str_eq(s, "[3]"); 6620 free(s); 6621 emptyO(self); 6622 toInsert = allocSmallArray(); 6623 toInsert->f->pushInt(toInsert, 3); 6624 r = self->f->insertNSmash(self, -1, toInsert); 6625 ck_assert_ptr_ne(r, null); 6626 s = toStringO(r); 6627 ck_assert_str_eq(s, "[3]"); 6628 free(s); 6629 // Array array length 0 6630 toInsert = allocSmallArray(); 6631 r = self->f->insertNSmash(self, -1, toInsert); 6632 ck_assert_ptr_ne(r, null); 6633 s = toStringO(r); 6634 ck_assert_str_eq(s, "[3]"); 6635 free(s); 6636 // index outside 6637 toInsert = allocSmallArray(); 6638 ck_assert_ptr_eq(self->f->insertNSmash(self, 20, toInsert), NULL); 6639 ck_assert_ptr_eq(self->f->insertNSmash(self, -5, toInsert), NULL); 6640 smashO(toInsert); 6641 // insert NULL 6642 ck_assert_ptr_eq(self->f->insertNSmash(self, 0, NULL), NULL); 6643 terminateO(self); 6644 6645 END_TEST 6646 6647 6648 START_TEST(insertNSmashSmallJsonSmallArrayT) 6649 6650 smallArrayt* r; 6651 smallArrayt *self = allocG(rtSmallArrayt); 6652 smallJsont *toInsert; 6653 6654 // add elements to self 6655 r = self->f->pushInt(self, 1); 6656 ck_assert_ptr_ne(r, null); 6657 r = self->f->pushInt(self, 2); 6658 ck_assert_ptr_ne(r, null); 6659 6660 // positive index 6661 toInsert = allocSmallJson(); 6662 toInsert->f->pushInt(toInsert, 3); 6663 r = self->f->insertNSmashSmallJson(self, 1, toInsert); 6664 ck_assert_ptr_ne(r, null); 6665 char *s = toStringO(r); 6666 ck_assert_str_eq(s, "[1,3,2]"); 6667 free(s); 6668 // negative index 6669 toInsert = allocSmallJson(); 6670 toInsert->f->pushInt(toInsert, 4); 6671 r = self->f->insertNSmashSmallJson(self, -1, toInsert); 6672 ck_assert_ptr_ne(r, null); 6673 s = toStringO(r); 6674 ck_assert_str_eq(s, "[1,3,2,4]"); 6675 free(s); 6676 // empty list 6677 emptyO(self); 6678 toInsert = allocSmallJson(); 6679 toInsert->f->pushInt(toInsert, 3); 6680 r = self->f->insertNSmashSmallJson(self, 0, toInsert); 6681 ck_assert_ptr_ne(r, null); 6682 s = toStringO(r); 6683 ck_assert_str_eq(s, "[3]"); 6684 free(s); 6685 emptyO(self); 6686 toInsert = allocSmallJson(); 6687 toInsert->f->pushInt(toInsert, 3); 6688 r = self->f->insertNSmashSmallJson(self, -1, toInsert); 6689 ck_assert_ptr_ne(r, null); 6690 s = toStringO(r); 6691 ck_assert_str_eq(s, "[3]"); 6692 free(s); 6693 // json array length 0 6694 toInsert = allocSmallJson(); 6695 setTypeArrayG(toInsert); 6696 r = self->f->insertNSmashSmallJson(self, -1, toInsert); 6697 ck_assert_ptr_ne(r, null); 6698 s = toStringO(r); 6699 ck_assert_str_eq(s, "[3]"); 6700 free(s); 6701 // json with no type 6702 toInsert = allocSmallJson(); 6703 r = self->f->insertNSmashSmallJson(self, -1, toInsert); 6704 smashO(toInsert); 6705 ck_assert_ptr_eq(r, null); 6706 s = toStringO(self); 6707 ck_assert_str_eq(s, "[3]"); 6708 free(s); 6709 // index outside 6710 toInsert = allocSmallJson(); 6711 ck_assert_ptr_eq(self->f->insertNSmashSmallJson(self, 20, toInsert), NULL); 6712 ck_assert_ptr_eq(self->f->insertNSmashSmallJson(self, -5, toInsert), NULL); 6713 smashO(toInsert); 6714 // insert NULL 6715 ck_assert_ptr_eq(self->f->insertNSmashSmallJson(self, 0, NULL), NULL); 6716 terminateO(self); 6717 6718 END_TEST 6719 6720 6721 START_TEST(injectSmallArrayT) 6722 6723 smallArrayt* r; 6724 smallArrayt *self = allocG(rtSmallArrayt); 6725 baset *toInject; 6726 6727 // add elements to self 6728 r = self->f->pushInt(self, 1); 6729 ck_assert_ptr_ne(r, null); 6730 r = self->f->pushInt(self, 2); 6731 ck_assert_ptr_ne(r, null); 6732 r = self->f->pushInt(self, 3); 6733 ck_assert_ptr_ne(r, null); 6734 r = self->f->pushInt(self, 4); 6735 ck_assert_ptr_ne(r, null); 6736 6737 // positive index 6738 toInject = (baset*) allocSmallInt(8); 6739 r = self->f->inject(self, 1, toInject); 6740 ck_assert_ptr_ne(r, null); 6741 finishO(toInject); 6742 char *s = toStringO(r); 6743 ck_assert_str_eq(s, "[1,8,2,3,4]"); 6744 free(s); 6745 // negative index 6746 toInject = (baset*) allocSmallInt(9); 6747 r = self->f->inject(self,-1, toInject); 6748 ck_assert_ptr_ne(r, null); 6749 finishO(toInject); 6750 s = toStringO(r); 6751 ck_assert_str_eq(s, "[1,8,2,3,4,9]"); 6752 free(s); 6753 // index 0 6754 toInject = (baset*) allocSmallInt(6); 6755 r = self->f->inject(self,0, toInject); 6756 ck_assert_ptr_ne(r, null); 6757 finishO(toInject); 6758 s = toStringO(r); 6759 ck_assert_str_eq(s, "[6,1,8,2,3,4,9]"); 6760 free(s); 6761 // index outside 6762 toInject = (baset*) allocSmallInt(7); 6763 ck_assert_ptr_eq(self->f->inject(self, 20, toInject), NULL); 6764 ck_assert_ptr_eq(self->f->inject(self, -9, toInject), NULL); 6765 terminateO(toInject); 6766 // empty list 6767 emptyO(self); 6768 toInject = (baset*) allocSmallInt(7); 6769 ck_assert_ptr_ne(self->f->inject(self, 0, toInject), NULL); 6770 finishO(toInject); 6771 s = toStringO(r); 6772 ck_assert_str_eq(s, "[7]"); 6773 free(s); 6774 emptyO(self); 6775 toInject = (baset*) allocSmallInt(7); 6776 ck_assert_ptr_ne(self->f->inject(self, -1, toInject), NULL); 6777 finishO(toInject); 6778 s = toStringO(r); 6779 ck_assert_str_eq(s, "[7]"); 6780 free(s); 6781 // null toInsert 6782 ck_assert_ptr_eq(self->f->inject(self, 0, NULL), NULL); 6783 terminateO(self); 6784 6785 END_TEST 6786 6787 6788 START_TEST(injectUndefinedSmallArrayT) 6789 6790 smallArrayt* r; 6791 smallArrayt *self = allocG(rtSmallArrayt); 6792 6793 // add elements to self 6794 r = self->f->pushInt(self, 1); 6795 ck_assert_ptr_ne(r, null); 6796 r = self->f->pushInt(self, 2); 6797 ck_assert_ptr_ne(r, null); 6798 r = self->f->pushInt(self, 3); 6799 ck_assert_ptr_ne(r, null); 6800 r = self->f->pushInt(self, 4); 6801 ck_assert_ptr_ne(r, null); 6802 6803 // positive index 6804 r = self->f->injectUndefined(self, 1); 6805 ck_assert_ptr_ne(r, null); 6806 char *s = toStringO(r); 6807 ck_assert_str_eq(s, "[1,null,2,3,4]"); 6808 free(s); 6809 // negative index 6810 r = self->f->injectUndefined(self,-1); 6811 ck_assert_ptr_ne(r, null); 6812 s = toStringO(r); 6813 ck_assert_str_eq(s, "[1,null,2,3,4,null]"); 6814 free(s); 6815 // index 0 6816 r = self->f->injectUndefined(self,0); 6817 ck_assert_ptr_ne(r, null); 6818 s = toStringO(r); 6819 ck_assert_str_eq(s, "[null,1,null,2,3,4,null]"); 6820 free(s); 6821 // index outside 6822 ck_assert_ptr_eq(self->f->injectUndefined(self, 20), NULL); 6823 ck_assert_ptr_eq(self->f->injectUndefined(self, -9), NULL); 6824 // empty list 6825 emptyO(self); 6826 ck_assert_ptr_ne(self->f->injectUndefined(self, 0), NULL); 6827 s = toStringO(r); 6828 ck_assert_str_eq(s, "[null]"); 6829 free(s); 6830 emptyO(self); 6831 ck_assert_ptr_ne(self->f->injectUndefined(self, -1), NULL); 6832 s = toStringO(r); 6833 ck_assert_str_eq(s, "[null]"); 6834 free(s); 6835 terminateO(self); 6836 6837 END_TEST 6838 6839 6840 START_TEST(injectBoolSmallArrayT) 6841 6842 smallArrayt* r; 6843 smallArrayt *self = allocG(rtSmallArrayt); 6844 6845 // add elements to self 6846 r = self->f->pushInt(self, 1); 6847 ck_assert_ptr_ne(r, null); 6848 r = self->f->pushInt(self, 2); 6849 ck_assert_ptr_ne(r, null); 6850 r = self->f->pushInt(self, 3); 6851 ck_assert_ptr_ne(r, null); 6852 r = self->f->pushInt(self, 4); 6853 ck_assert_ptr_ne(r, null); 6854 6855 // positive index 6856 r = self->f->injectBool(self, 1, true); 6857 ck_assert_ptr_ne(r, null); 6858 char *s = toStringO(r); 6859 ck_assert_str_eq(s, "[1,true,2,3,4]"); 6860 free(s); 6861 // negative index 6862 r = self->f->injectBool(self,-1, true); 6863 ck_assert_ptr_ne(r, null); 6864 s = toStringO(r); 6865 ck_assert_str_eq(s, "[1,true,2,3,4,true]"); 6866 free(s); 6867 // index 0 6868 r = self->f->injectBool(self,0, true); 6869 ck_assert_ptr_ne(r, null); 6870 s = toStringO(r); 6871 ck_assert_str_eq(s, "[true,1,true,2,3,4,true]"); 6872 free(s); 6873 // index outside 6874 ck_assert_ptr_eq(self->f->injectBool(self, 20, true), NULL); 6875 ck_assert_ptr_eq(self->f->injectBool(self, -9, true), NULL); 6876 // empty list 6877 emptyO(self); 6878 ck_assert_ptr_ne(self->f->injectBool(self, 0, true), NULL); 6879 s = toStringO(r); 6880 ck_assert_str_eq(s, "[true]"); 6881 free(s); 6882 emptyO(self); 6883 ck_assert_ptr_ne(self->f->injectBool(self, -1, true), NULL); 6884 s = toStringO(r); 6885 ck_assert_str_eq(s, "[true]"); 6886 free(s); 6887 terminateO(self); 6888 6889 END_TEST 6890 6891 6892 START_TEST(injectDoubleSmallArrayT) 6893 6894 smallArrayt* r; 6895 smallArrayt *self = allocG(rtSmallArrayt); 6896 6897 // add elements to self 6898 r = self->f->pushInt(self, 1); 6899 ck_assert_ptr_ne(r, null); 6900 r = self->f->pushInt(self, 2); 6901 ck_assert_ptr_ne(r, null); 6902 r = self->f->pushInt(self, 3); 6903 ck_assert_ptr_ne(r, null); 6904 r = self->f->pushInt(self, 4); 6905 ck_assert_ptr_ne(r, null); 6906 6907 // positive index 6908 r = self->f->injectDouble(self, 1, 7); 6909 ck_assert_ptr_ne(r, null); 6910 char *s = toStringO(r); 6911 ck_assert_str_eq(s, "[1,7.000000e+00,2,3,4]"); 6912 free(s); 6913 // negative index 6914 r = self->f->injectDouble(self,-1, 8); 6915 ck_assert_ptr_ne(r, null); 6916 s = toStringO(r); 6917 ck_assert_str_eq(s, "[1,7.000000e+00,2,3,4,8.000000e+00]"); 6918 free(s); 6919 // index 0 6920 r = self->f->injectDouble(self,0, 9); 6921 ck_assert_ptr_ne(r, null); 6922 s = toStringO(r); 6923 ck_assert_str_eq(s, "[9.000000e+00,1,7.000000e+00,2,3,4,8.000000e+00]"); 6924 free(s); 6925 // index outside 6926 ck_assert_ptr_eq(self->f->injectDouble(self, 20, 7.000000e+00), NULL); 6927 ck_assert_ptr_eq(self->f->injectDouble(self, -9, 7.000000e+00), NULL); 6928 // empty list 6929 emptyO(self); 6930 ck_assert_ptr_ne(self->f->injectDouble(self, 0, 9), NULL); 6931 s = toStringO(r); 6932 ck_assert_str_eq(s, "[9.000000e+00]"); 6933 free(s); 6934 emptyO(self); 6935 ck_assert_ptr_ne(self->f->injectDouble(self, -1, 9), NULL); 6936 s = toStringO(r); 6937 ck_assert_str_eq(s, "[9.000000e+00]"); 6938 free(s); 6939 terminateO(self); 6940 6941 END_TEST 6942 6943 6944 START_TEST(injectIntSmallArrayT) 6945 6946 smallArrayt* r; 6947 smallArrayt *self = allocG(rtSmallArrayt); 6948 6949 // add elements to self 6950 r = self->f->pushInt(self, 1); 6951 ck_assert_ptr_ne(r, null); 6952 r = self->f->pushInt(self, 2); 6953 ck_assert_ptr_ne(r, null); 6954 r = self->f->pushInt(self, 3); 6955 ck_assert_ptr_ne(r, null); 6956 r = self->f->pushInt(self, 4); 6957 ck_assert_ptr_ne(r, null); 6958 6959 // positive index 6960 r = self->f->injectInt(self, 1, 5); 6961 ck_assert_ptr_ne(r, null); 6962 char *s = toStringO(r); 6963 ck_assert_str_eq(s, "[1,5,2,3,4]"); 6964 free(s); 6965 // negative index 6966 r = self->f->injectInt(self,-1, 6); 6967 ck_assert_ptr_ne(r, null); 6968 s = toStringO(r); 6969 ck_assert_str_eq(s, "[1,5,2,3,4,6]"); 6970 free(s); 6971 // index 0 6972 r = self->f->injectInt(self,0, 7); 6973 ck_assert_ptr_ne(r, null); 6974 s = toStringO(r); 6975 ck_assert_str_eq(s, "[7,1,5,2,3,4,6]"); 6976 free(s); 6977 // index outside 6978 ck_assert_ptr_eq(self->f->injectInt(self, 20, true), NULL); 6979 ck_assert_ptr_eq(self->f->injectInt(self, -9, true), NULL); 6980 // empty list 6981 emptyO(self); 6982 ck_assert_ptr_ne(self->f->injectInt(self, 0, 7), NULL); 6983 s = toStringO(r); 6984 ck_assert_str_eq(s, "[7]"); 6985 free(s); 6986 emptyO(self); 6987 ck_assert_ptr_ne(self->f->injectInt(self, -1, 7), NULL); 6988 s = toStringO(r); 6989 ck_assert_str_eq(s, "[7]"); 6990 free(s); 6991 terminateO(self); 6992 6993 END_TEST 6994 6995 6996 START_TEST(injectSSmallArrayT) 6997 6998 smallArrayt* r; 6999 smallArrayt *self = allocG(rtSmallArrayt); 7000 7001 // add elements to self 7002 r = self->f->pushInt(self, 1); 7003 ck_assert_ptr_ne(r, null); 7004 r = self->f->pushInt(self, 2); 7005 ck_assert_ptr_ne(r, null); 7006 r = self->f->pushInt(self, 3); 7007 ck_assert_ptr_ne(r, null); 7008 r = self->f->pushInt(self, 4); 7009 ck_assert_ptr_ne(r, null); 7010 // positive index 7011 r = self->f->injectS(self, 1, "5"); 7012 ck_assert_ptr_ne(r, null); 7013 char *s = toStringO(r); 7014 ck_assert_str_eq(s, "[1,\"5\",2,3,4]"); 7015 free(s); 7016 // negative index 7017 r = self->f->injectS(self,-1, "6"); 7018 ck_assert_ptr_ne(r, null); 7019 s = toStringO(r); 7020 ck_assert_str_eq(s, "[1,\"5\",2,3,4,\"6\"]"); 7021 free(s); 7022 // index 0 7023 r = self->f->injectS(self,0, "7"); 7024 ck_assert_ptr_ne(r, null); 7025 s = toStringO(r); 7026 ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]"); 7027 free(s); 7028 // null toInject 7029 r = self->f->injectS(self,0, null); 7030 ck_assert_ptr_eq(r, null); 7031 s = toStringO(self); 7032 ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]"); 7033 free(s); 7034 // index outside 7035 ck_assert_ptr_eq(self->f->injectS(self, 20, ""), NULL); 7036 ck_assert_ptr_eq(self->f->injectS(self, -9, ""), NULL); 7037 // empty list 7038 emptyO(self); 7039 ck_assert_ptr_ne(self->f->injectS(self, 0, "7"), NULL); 7040 s = toStringO(self); 7041 ck_assert_str_eq(s, "[\"7\"]"); 7042 free(s); 7043 emptyO(self); 7044 ck_assert_ptr_ne(self->f->injectS(self, -1, "7"), NULL); 7045 s = toStringO(self); 7046 ck_assert_str_eq(s, "[\"7\"]"); 7047 free(s); 7048 terminateO(self); 7049 7050 END_TEST 7051 7052 7053 START_TEST(injectCharSmallArrayT) 7054 7055 smallArrayt* r; 7056 smallArrayt *self = allocG(rtSmallArrayt); 7057 7058 // add elements to self 7059 r = self->f->pushInt(self, 1); 7060 ck_assert_ptr_ne(r, null); 7061 r = self->f->pushInt(self, 2); 7062 ck_assert_ptr_ne(r, null); 7063 r = self->f->pushInt(self, 3); 7064 ck_assert_ptr_ne(r, null); 7065 r = self->f->pushInt(self, 4); 7066 ck_assert_ptr_ne(r, null); 7067 7068 // positive index 7069 r = self->f->injectChar(self, 1, '5'); 7070 ck_assert_ptr_ne(r, null); 7071 char *s = toStringO(r); 7072 ck_assert_str_eq(s, "[1,\"5\",2,3,4]"); 7073 free(s); 7074 // negative index 7075 r = self->f->injectChar(self,-1, '6'); 7076 ck_assert_ptr_ne(r, null); 7077 s = toStringO(r); 7078 ck_assert_str_eq(s, "[1,\"5\",2,3,4,\"6\"]"); 7079 free(s); 7080 // index 0 7081 r = self->f->injectChar(self,0, '7'); 7082 ck_assert_ptr_ne(r, null); 7083 s = toStringO(r); 7084 ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]"); 7085 free(s); 7086 // index outside 7087 ck_assert_ptr_eq(self->f->injectChar(self, 20, 'y'), NULL); 7088 ck_assert_ptr_eq(self->f->injectChar(self, -9, 'y'), NULL); 7089 // empty list 7090 emptyO(self); 7091 ck_assert_ptr_ne(self->f->injectChar(self, 0, '7'), NULL); 7092 s = toStringO(r); 7093 ck_assert_str_eq(s, "[\"7\"]"); 7094 free(s); 7095 emptyO(self); 7096 ck_assert_ptr_ne(self->f->injectChar(self, -1, '7'), NULL); 7097 s = toStringO(r); 7098 ck_assert_str_eq(s, "[\"7\"]"); 7099 free(s); 7100 terminateO(self); 7101 7102 END_TEST 7103 7104 7105 START_TEST(injectDictSmallArrayT) 7106 7107 smallArrayt* r; 7108 smallArrayt *self = allocG(rtSmallArrayt); 7109 smallDictt *toInject; 7110 7111 // add elements to self 7112 r = self->f->pushInt(self, 1); 7113 ck_assert_ptr_ne(r, null); 7114 r = self->f->pushInt(self, 2); 7115 ck_assert_ptr_ne(r, null); 7116 r = self->f->pushInt(self, 3); 7117 ck_assert_ptr_ne(r, null); 7118 r = self->f->pushInt(self, 4); 7119 ck_assert_ptr_ne(r, null); 7120 7121 // positive index 7122 toInject = allocSmallDict(); 7123 r = self->f->injectDict(self, 1, toInject); 7124 ck_assert_ptr_ne(r, null); 7125 finishO(toInject); 7126 char *s = toStringO(r); 7127 ck_assert_str_eq(s, "[1,{},2,3,4]"); 7128 free(s); 7129 // negative index 7130 toInject = allocSmallDict(); 7131 r = self->f->injectDict(self,-1, toInject); 7132 ck_assert_ptr_ne(r, null); 7133 finishO(toInject); 7134 s = toStringO(r); 7135 ck_assert_str_eq(s, "[1,{},2,3,4,{}]"); 7136 free(s); 7137 // index 0 7138 toInject = allocSmallDict(); 7139 r = self->f->injectDict(self,0, toInject); 7140 ck_assert_ptr_ne(r, null); 7141 finishO(toInject); 7142 s = toStringO(r); 7143 ck_assert_str_eq(s, "[{},1,{},2,3,4,{}]"); 7144 free(s); 7145 // index outside 7146 toInject = allocSmallDict(); 7147 ck_assert_ptr_eq(self->f->injectDict(self, 20, toInject), NULL); 7148 ck_assert_ptr_eq(self->f->injectDict(self, -9, toInject), NULL); 7149 terminateO(toInject); 7150 // empty list 7151 emptyO(self); 7152 toInject = allocSmallDict(); 7153 ck_assert_ptr_ne(self->f->injectDict(self, 0, toInject), NULL); 7154 finishO(toInject); 7155 s = toStringO(r); 7156 ck_assert_str_eq(s, "[{}]"); 7157 free(s); 7158 emptyO(self); 7159 toInject = allocSmallDict(); 7160 ck_assert_ptr_ne(self->f->injectDict(self, -1, toInject), NULL); 7161 finishO(toInject); 7162 s = toStringO(r); 7163 ck_assert_str_eq(s, "[{}]"); 7164 free(s); 7165 // non smallDict object 7166 toInject = (smallDictt*) allocSmallInt(2); 7167 r = self->f->injectDict(self, 0, toInject); 7168 ck_assert_ptr_eq(r, null); 7169 terminateO(toInject); 7170 // null toInsert 7171 ck_assert_ptr_eq(self->f->injectDict(self, 0, NULL), NULL); 7172 terminateO(self); 7173 7174 END_TEST 7175 7176 7177 START_TEST(injectArraySmallArrayT) 7178 7179 smallArrayt* r; 7180 smallArrayt *self = allocG(rtSmallArrayt); 7181 smallArrayt *toInject; 7182 7183 // add elements to self 7184 r = self->f->pushInt(self, 1); 7185 ck_assert_ptr_ne(r, null); 7186 r = self->f->pushInt(self, 2); 7187 ck_assert_ptr_ne(r, null); 7188 r = self->f->pushInt(self, 3); 7189 ck_assert_ptr_ne(r, null); 7190 r = self->f->pushInt(self, 4); 7191 ck_assert_ptr_ne(r, null); 7192 7193 // positive index 7194 toInject = allocSmallArray(); 7195 r = self->f->injectArray(self, 1, toInject); 7196 ck_assert_ptr_ne(r, null); 7197 finishO(toInject); 7198 char *s = toStringO(r); 7199 ck_assert_str_eq(s, "[1,[],2,3,4]"); 7200 free(s); 7201 // negative index 7202 toInject = allocSmallArray(); 7203 r = self->f->injectArray(self,-1, toInject); 7204 ck_assert_ptr_ne(r, null); 7205 finishO(toInject); 7206 s = toStringO(r); 7207 ck_assert_str_eq(s, "[1,[],2,3,4,[]]"); 7208 free(s); 7209 // index 0 7210 toInject = allocSmallArray(); 7211 r = self->f->injectArray(self,0, toInject); 7212 ck_assert_ptr_ne(r, null); 7213 finishO(toInject); 7214 s = toStringO(r); 7215 ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]"); 7216 free(s); 7217 // index outside 7218 toInject = allocSmallArray(); 7219 ck_assert_ptr_eq(self->f->injectArray(self, 20, toInject), NULL); 7220 ck_assert_ptr_eq(self->f->injectArray(self, -9, toInject), NULL); 7221 terminateO(toInject); 7222 // empty list 7223 emptyO(self); 7224 toInject = allocSmallArray(); 7225 ck_assert_ptr_ne(self->f->injectArray(self, 0, toInject), NULL); 7226 finishO(toInject); 7227 s = toStringO(r); 7228 ck_assert_str_eq(s, "[[]]"); 7229 free(s); 7230 emptyO(self); 7231 toInject = allocSmallArray(); 7232 ck_assert_ptr_ne(self->f->injectArray(self, -1, toInject), NULL); 7233 finishO(toInject); 7234 s = toStringO(r); 7235 ck_assert_str_eq(s, "[[]]"); 7236 free(s); 7237 // non smallArray object 7238 toInject = (smallArrayt*) allocSmallInt(2); 7239 r = self->f->injectArray(self, 0, toInject); 7240 ck_assert_ptr_eq(r, null); 7241 terminateO(toInject); 7242 // null toInsert 7243 ck_assert_ptr_eq(self->f->injectArray(self, 0, NULL), NULL); 7244 terminateO(self); 7245 7246 END_TEST 7247 7248 7249 START_TEST(injectArraycSmallArrayT) 7250 7251 smallArrayt* r; 7252 smallArrayt *self = allocG(rtSmallArrayt); 7253 char **toInject; 7254 7255 // add elements to self 7256 r = self->f->pushInt(self, 1); 7257 ck_assert_ptr_ne(r, null); 7258 r = self->f->pushInt(self, 2); 7259 ck_assert_ptr_ne(r, null); 7260 r = self->f->pushInt(self, 3); 7261 ck_assert_ptr_ne(r, null); 7262 r = self->f->pushInt(self, 4); 7263 ck_assert_ptr_ne(r, null); 7264 7265 // positive index 7266 toInject = listCreateS("a","b"); 7267 r = self->f->injectArrayc(self, 1, toInject); 7268 listFreeS(toInject); 7269 ck_assert_ptr_ne(r, null); 7270 char *s = toStringO(r); 7271 ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4]"); 7272 free(s); 7273 // negative index 7274 toInject = listCreateS("c","d"); 7275 r = self->f->injectArrayc(self,-1, toInject); 7276 listFreeS(toInject); 7277 ck_assert_ptr_ne(r, null); 7278 s = toStringO(r); 7279 ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]"); 7280 free(s); 7281 // index 0 7282 toInject = listCreateS("e","ff"); 7283 r = self->f->injectArrayc(self,0, toInject); 7284 listFreeS(toInject); 7285 ck_assert_ptr_ne(r, null); 7286 s = toStringO(r); 7287 ck_assert_str_eq(s, "[[\"e\",\"ff\"],1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]"); 7288 free(s); 7289 // index outside 7290 toInject = listCreateS("a","b"); 7291 ck_assert_ptr_eq(self->f->injectArrayc(self, 20, toInject), NULL); 7292 ck_assert_ptr_eq(self->f->injectArrayc(self, -9, toInject), NULL); 7293 listFreeS(toInject); 7294 // empty list 7295 emptyO(self); 7296 toInject = listCreateS("a","b"); 7297 ck_assert_ptr_ne(self->f->injectArrayc(self, 0, toInject), NULL); 7298 listFreeS(toInject); 7299 s = toStringO(r); 7300 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 7301 free(s); 7302 emptyO(self); 7303 toInject = listCreateS("a","b"); 7304 ck_assert_ptr_ne(self->f->injectArrayc(self, -1, toInject), NULL); 7305 listFreeS(toInject); 7306 s = toStringO(r); 7307 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 7308 free(s); 7309 // null toInsert 7310 ck_assert_ptr_eq(self->f->injectArrayc(self, 0, NULL), NULL); 7311 terminateO(self); 7312 7313 END_TEST 7314 7315 7316 START_TEST(injectSmallBoolSmallArrayT) 7317 7318 smallArrayt* r; 7319 smallArrayt *self = allocG(rtSmallArrayt); 7320 smallBoolt *toInject; 7321 7322 // add elements to self 7323 r = self->f->pushInt(self, 1); 7324 ck_assert_ptr_ne(r, null); 7325 r = self->f->pushInt(self, 2); 7326 ck_assert_ptr_ne(r, null); 7327 r = self->f->pushInt(self, 3); 7328 ck_assert_ptr_ne(r, null); 7329 r = self->f->pushInt(self, 4); 7330 ck_assert_ptr_ne(r, null); 7331 7332 // positive index 7333 toInject = allocSmallBool(true); 7334 r = self->f->injectSmallBool(self, 1, toInject); 7335 ck_assert_ptr_ne(r, null); 7336 finishO(toInject); 7337 char *s = toStringO(r); 7338 ck_assert_str_eq(s, "[1,true,2,3,4]"); 7339 free(s); 7340 // negative index 7341 toInject = allocSmallBool(true); 7342 r = self->f->injectSmallBool(self,-1, toInject); 7343 ck_assert_ptr_ne(r, null); 7344 finishO(toInject); 7345 s = toStringO(r); 7346 ck_assert_str_eq(s, "[1,true,2,3,4,true]"); 7347 free(s); 7348 // index 0 7349 toInject = allocSmallBool(true); 7350 r = self->f->injectSmallBool(self,0, toInject); 7351 ck_assert_ptr_ne(r, null); 7352 finishO(toInject); 7353 s = toStringO(r); 7354 ck_assert_str_eq(s, "[true,1,true,2,3,4,true]"); 7355 free(s); 7356 // index outside 7357 toInject = allocSmallBool(true); 7358 ck_assert_ptr_eq(self->f->injectSmallBool(self, 20, toInject), NULL); 7359 ck_assert_ptr_eq(self->f->injectSmallBool(self, -9, toInject), NULL); 7360 terminateO(toInject); 7361 // empty object 7362 emptyO(self); 7363 toInject = allocSmallBool(true); 7364 freeO(toInject); 7365 ck_assert_ptr_ne(self->f->injectSmallBool(self, 0, toInject), NULL); 7366 finishO(toInject); 7367 s = toStringO(r); 7368 ck_assert_str_eq(s, "[false]"); 7369 free(s); 7370 // empty list 7371 emptyO(self); 7372 toInject = allocSmallBool(true); 7373 ck_assert_ptr_ne(self->f->injectSmallBool(self, 0, toInject), NULL); 7374 finishO(toInject); 7375 s = toStringO(r); 7376 ck_assert_str_eq(s, "[true]"); 7377 free(s); 7378 emptyO(self); 7379 toInject = allocSmallBool(true); 7380 ck_assert_ptr_ne(self->f->injectSmallBool(self, -1, toInject), NULL); 7381 finishO(toInject); 7382 s = toStringO(r); 7383 ck_assert_str_eq(s, "[true]"); 7384 free(s); 7385 // non smallBool object 7386 toInject = (smallBoolt*) allocSmallInt(2); 7387 r = self->f->injectSmallBool(self, 0, toInject); 7388 ck_assert_ptr_eq(r, null); 7389 terminateO(toInject); 7390 // null toInsert 7391 ck_assert_ptr_eq(self->f->injectSmallBool(self, 0, NULL), NULL); 7392 terminateO(self); 7393 7394 END_TEST 7395 7396 7397 START_TEST(injectSmallBytesSmallArrayT) 7398 7399 smallArrayt* r; 7400 smallArrayt *self = allocG(rtSmallArrayt); 7401 smallBytest *toInject; 7402 7403 // add elements to self 7404 r = self->f->pushInt(self, 1); 7405 ck_assert_ptr_ne(r, null); 7406 r = self->f->pushInt(self, 2); 7407 ck_assert_ptr_ne(r, null); 7408 r = self->f->pushInt(self, 3); 7409 ck_assert_ptr_ne(r, null); 7410 r = self->f->pushInt(self, 4); 7411 ck_assert_ptr_ne(r, null); 7412 7413 // positive index 7414 toInject = allocSmallBytes(null, 0); 7415 r = self->f->injectSmallBytes(self, 1, toInject); 7416 ck_assert_ptr_ne(r, null); 7417 finishO(toInject); 7418 char *s = toStringO(r); 7419 ck_assert_str_eq(s, "[1,[],2,3,4]"); 7420 free(s); 7421 // negative index 7422 toInject = allocSmallBytes(null, 0); 7423 r = self->f->injectSmallBytes(self,-1, toInject); 7424 ck_assert_ptr_ne(r, null); 7425 finishO(toInject); 7426 s = toStringO(r); 7427 ck_assert_str_eq(s, "[1,[],2,3,4,[]]"); 7428 free(s); 7429 // index 0 7430 toInject = allocSmallBytes(null, 0); 7431 r = self->f->injectSmallBytes(self,0, toInject); 7432 ck_assert_ptr_ne(r, null); 7433 finishO(toInject); 7434 s = toStringO(r); 7435 ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]"); 7436 free(s); 7437 // index outside 7438 toInject = allocSmallBytes(null, 0); 7439 ck_assert_ptr_eq(self->f->injectSmallBytes(self, 20, toInject), NULL); 7440 ck_assert_ptr_eq(self->f->injectSmallBytes(self, -9, toInject), NULL); 7441 terminateO(toInject); 7442 // empty object 7443 emptyO(self); 7444 toInject = allocSmallBytes(null, 0); 7445 freeO(toInject); 7446 ck_assert_ptr_ne(self->f->injectSmallBytes(self, 0, toInject), NULL); 7447 finishO(toInject); 7448 s = toStringO(r); 7449 ck_assert_str_eq(s, "[[]]"); 7450 free(s); 7451 // empty list 7452 emptyO(self); 7453 toInject = allocSmallBytes(null, 0); 7454 ck_assert_ptr_ne(self->f->injectSmallBytes(self, 0, toInject), NULL); 7455 finishO(toInject); 7456 s = toStringO(r); 7457 ck_assert_str_eq(s, "[[]]"); 7458 free(s); 7459 emptyO(self); 7460 toInject = allocSmallBytes(null, 0); 7461 ck_assert_ptr_ne(self->f->injectSmallBytes(self, -1, toInject), NULL); 7462 finishO(toInject); 7463 s = toStringO(r); 7464 ck_assert_str_eq(s, "[[]]"); 7465 free(s); 7466 // non smallBytes object 7467 toInject = (smallBytest*) allocSmallInt(2); 7468 r = self->f->injectSmallBytes(self, 0, toInject); 7469 ck_assert_ptr_eq(r, null); 7470 terminateO(toInject); 7471 // null toInsert 7472 ck_assert_ptr_eq(self->f->injectSmallBytes(self, 0, NULL), NULL); 7473 terminateO(self); 7474 7475 END_TEST 7476 7477 7478 START_TEST(injectSmallDoubleSmallArrayT) 7479 7480 smallArrayt* r; 7481 smallArrayt *self = allocG(rtSmallArrayt); 7482 smallDoublet *toInject; 7483 7484 // add elements to self 7485 r = self->f->pushInt(self, 1); 7486 ck_assert_ptr_ne(r, null); 7487 r = self->f->pushInt(self, 2); 7488 ck_assert_ptr_ne(r, null); 7489 r = self->f->pushInt(self, 3); 7490 ck_assert_ptr_ne(r, null); 7491 r = self->f->pushInt(self, 4); 7492 ck_assert_ptr_ne(r, null); 7493 7494 // positive index 7495 toInject = allocSmallDouble(2); 7496 r = self->f->injectSmallDouble(self, 1, toInject); 7497 ck_assert_ptr_ne(r, null); 7498 finishO(toInject); 7499 char *s = toStringO(r); 7500 ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4]"); 7501 free(s); 7502 // negative index 7503 toInject = allocSmallDouble(3); 7504 r = self->f->injectSmallDouble(self,-1, toInject); 7505 ck_assert_ptr_ne(r, null); 7506 finishO(toInject); 7507 s = toStringO(r); 7508 ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4,3.000000e+00]"); 7509 free(s); 7510 // index 0 7511 toInject = allocSmallDouble(1); 7512 r = self->f->injectSmallDouble(self,0, toInject); 7513 ck_assert_ptr_ne(r, null); 7514 finishO(toInject); 7515 s = toStringO(r); 7516 ck_assert_str_eq(s, "[1.000000e+00,1,2.000000e+00,2,3,4,3.000000e+00]"); 7517 free(s); 7518 // index outside 7519 toInject = allocSmallDouble(1); 7520 ck_assert_ptr_eq(self->f->injectSmallDouble(self, 20, toInject), NULL); 7521 ck_assert_ptr_eq(self->f->injectSmallDouble(self, -9, toInject), NULL); 7522 terminateO(toInject); 7523 // empty object 7524 emptyO(self); 7525 toInject = allocSmallDouble(1); 7526 freeO(toInject); 7527 ck_assert_ptr_ne(self->f->injectSmallDouble(self, 0, toInject), NULL); 7528 finishO(toInject); 7529 s = toStringO(r); 7530 ck_assert_str_eq(s, "[0.000000e+00]"); 7531 free(s); 7532 // empty list 7533 emptyO(self); 7534 toInject = allocSmallDouble(1); 7535 ck_assert_ptr_ne(self->f->injectSmallDouble(self, 0, toInject), NULL); 7536 finishO(toInject); 7537 s = toStringO(r); 7538 ck_assert_str_eq(s, "[1.000000e+00]"); 7539 free(s); 7540 emptyO(self); 7541 toInject = allocSmallDouble(1); 7542 ck_assert_ptr_ne(self->f->injectSmallDouble(self, -1, toInject), NULL); 7543 finishO(toInject); 7544 s = toStringO(r); 7545 ck_assert_str_eq(s, "[1.000000e+00]"); 7546 free(s); 7547 // non smallDouble object 7548 toInject = (smallDoublet*) allocSmallInt(2); 7549 r = self->f->injectSmallDouble(self, 0, toInject); 7550 ck_assert_ptr_eq(r, null); 7551 terminateO(toInject); 7552 // null toInsert 7553 ck_assert_ptr_eq(self->f->injectSmallDouble(self, 0, NULL), NULL); 7554 terminateO(self); 7555 7556 END_TEST 7557 7558 7559 START_TEST(injectSmallIntSmallArrayT) 7560 7561 smallArrayt* r; 7562 smallArrayt *self = allocG(rtSmallArrayt); 7563 smallIntt *toInject; 7564 7565 // add elements to self 7566 r = self->f->pushInt(self, 1); 7567 ck_assert_ptr_ne(r, null); 7568 r = self->f->pushInt(self, 2); 7569 ck_assert_ptr_ne(r, null); 7570 r = self->f->pushInt(self, 3); 7571 ck_assert_ptr_ne(r, null); 7572 r = self->f->pushInt(self, 4); 7573 ck_assert_ptr_ne(r, null); 7574 7575 // positive index 7576 toInject = allocSmallInt(10); 7577 r = self->f->injectSmallInt(self, 1, toInject); 7578 ck_assert_ptr_ne(r, null); 7579 finishO(toInject); 7580 char *s = toStringO(r); 7581 ck_assert_str_eq(s, "[1,10,2,3,4]"); 7582 free(s); 7583 // negative index 7584 toInject = allocSmallInt(11); 7585 r = self->f->injectSmallInt(self,-1, toInject); 7586 ck_assert_ptr_ne(r, null); 7587 finishO(toInject); 7588 s = toStringO(r); 7589 ck_assert_str_eq(s, "[1,10,2,3,4,11]"); 7590 free(s); 7591 // index 0 7592 toInject = allocSmallInt(12); 7593 r = self->f->injectSmallInt(self,0, toInject); 7594 ck_assert_ptr_ne(r, null); 7595 finishO(toInject); 7596 s = toStringO(r); 7597 ck_assert_str_eq(s, "[12,1,10,2,3,4,11]"); 7598 free(s); 7599 // index outside 7600 toInject = allocSmallInt(10); 7601 ck_assert_ptr_eq(self->f->injectSmallInt(self, 20, toInject), NULL); 7602 ck_assert_ptr_eq(self->f->injectSmallInt(self, -9, toInject), NULL); 7603 terminateO(toInject); 7604 // empty object 7605 emptyO(self); 7606 toInject = allocSmallInt(10); 7607 freeO(toInject); 7608 ck_assert_ptr_ne(self->f->injectSmallInt(self, 0, toInject), NULL); 7609 finishO(toInject); 7610 s = toStringO(r); 7611 ck_assert_str_eq(s, "[0]"); 7612 free(s); 7613 // empty list 7614 emptyO(self); 7615 toInject = allocSmallInt(10); 7616 ck_assert_ptr_ne(self->f->injectSmallInt(self, 0, toInject), NULL); 7617 finishO(toInject); 7618 s = toStringO(r); 7619 ck_assert_str_eq(s, "[10]"); 7620 free(s); 7621 emptyO(self); 7622 toInject = allocSmallInt(10); 7623 ck_assert_ptr_ne(self->f->injectSmallInt(self, -1, toInject), NULL); 7624 finishO(toInject); 7625 s = toStringO(r); 7626 ck_assert_str_eq(s, "[10]"); 7627 free(s); 7628 // non smallInt object 7629 toInject = (smallIntt*) allocSmallBool(true); 7630 r = self->f->injectSmallInt(self, 0, toInject); 7631 ck_assert_ptr_eq(r, null); 7632 terminateO(toInject); 7633 // null toInsert 7634 ck_assert_ptr_eq(self->f->injectSmallInt(self, 0, NULL), NULL); 7635 terminateO(self); 7636 7637 END_TEST 7638 7639 7640 START_TEST(injectSmallJsonSmallArrayT) 7641 7642 smallArrayt* r; 7643 smallArrayt *self = allocG(rtSmallArrayt); 7644 smallJsont *toInject; 7645 7646 // add elements to self 7647 r = self->f->pushInt(self, 1); 7648 ck_assert_ptr_ne(r, null); 7649 r = self->f->pushInt(self, 2); 7650 ck_assert_ptr_ne(r, null); 7651 r = self->f->pushInt(self, 3); 7652 ck_assert_ptr_ne(r, null); 7653 r = self->f->pushInt(self, 4); 7654 ck_assert_ptr_ne(r, null); 7655 7656 // positive index 7657 toInject = allocSmallJson(); 7658 r = self->f->injectSmallJson(self, 1, toInject); 7659 ck_assert_ptr_ne(r, null); 7660 finishO(toInject); 7661 char *s = toStringO(r); 7662 ck_assert_str_eq(s, "[1,{},2,3,4]"); 7663 free(s); 7664 // negative index 7665 toInject = allocSmallJson(); 7666 r = self->f->injectSmallJson(self,-1, toInject); 7667 ck_assert_ptr_ne(r, null); 7668 finishO(toInject); 7669 s = toStringO(r); 7670 ck_assert_str_eq(s, "[1,{},2,3,4,{}]"); 7671 free(s); 7672 // index 0 7673 toInject = allocSmallJson(); 7674 toInject->f->setS(toInject, "key", "value"); 7675 r = self->f->injectSmallJson(self,0, toInject); 7676 ck_assert_ptr_ne(r, null); 7677 finishO(toInject); 7678 s = toStringO(r); 7679 ck_assert_str_eq(s, "[{\"key\":\"value\"},1,{},2,3,4,{}]"); 7680 free(s); 7681 // index outside 7682 toInject = allocSmallJson(); 7683 ck_assert_ptr_eq(self->f->injectSmallJson(self, 20, toInject), NULL); 7684 ck_assert_ptr_eq(self->f->injectSmallJson(self, -9, toInject), NULL); 7685 terminateO(toInject); 7686 // empty object 7687 emptyO(self); 7688 toInject = allocSmallJson(); 7689 freeO(toInject); 7690 ck_assert_ptr_ne(self->f->injectSmallJson(self, 0, toInject), NULL); 7691 finishO(toInject); 7692 s = toStringO(r); 7693 ck_assert_str_eq(s, "[{}]"); 7694 free(s); 7695 // empty list 7696 emptyO(self); 7697 toInject = allocSmallJson(); 7698 ck_assert_ptr_ne(self->f->injectSmallJson(self, 0, toInject), NULL); 7699 finishO(toInject); 7700 s = toStringO(r); 7701 ck_assert_str_eq(s, "[{}]"); 7702 free(s); 7703 emptyO(self); 7704 toInject = allocSmallJson(); 7705 ck_assert_ptr_ne(self->f->injectSmallJson(self, -1, toInject), NULL); 7706 finishO(toInject); 7707 s = toStringO(r); 7708 ck_assert_str_eq(s, "[{}]"); 7709 free(s); 7710 // non smallJson object 7711 toInject = (smallJsont*) allocSmallInt(2); 7712 r = self->f->injectSmallJson(self, 0, toInject); 7713 ck_assert_ptr_eq(r, null); 7714 terminateO(toInject); 7715 // null toInsert 7716 ck_assert_ptr_eq(self->f->injectSmallJson(self, 0, NULL), NULL); 7717 terminateO(self); 7718 7719 END_TEST 7720 7721 7722 START_TEST(injectSmallStringSmallArrayT) 7723 7724 smallArrayt* r; 7725 smallArrayt *self = allocG(rtSmallArrayt); 7726 smallStringt *toInject; 7727 7728 // add elements to self 7729 r = self->f->pushInt(self, 1); 7730 ck_assert_ptr_ne(r, null); 7731 r = self->f->pushInt(self, 2); 7732 ck_assert_ptr_ne(r, null); 7733 r = self->f->pushInt(self, 3); 7734 ck_assert_ptr_ne(r, null); 7735 r = self->f->pushInt(self, 4); 7736 ck_assert_ptr_ne(r, null); 7737 7738 // positive index 7739 toInject = allocSmallString("1"); 7740 r = self->f->injectSmallString(self, 1, toInject); 7741 ck_assert_ptr_ne(r, null); 7742 finishO(toInject); 7743 char *s = toStringO(r); 7744 ck_assert_str_eq(s, "[1,\"1\",2,3,4]"); 7745 free(s); 7746 // negative index 7747 toInject = allocSmallString("2"); 7748 r = self->f->injectSmallString(self,-1, toInject); 7749 ck_assert_ptr_ne(r, null); 7750 finishO(toInject); 7751 s = toStringO(r); 7752 ck_assert_str_eq(s, "[1,\"1\",2,3,4,\"2\"]"); 7753 free(s); 7754 // index 0 7755 toInject = allocSmallString("3"); 7756 r = self->f->injectSmallString(self,0, toInject); 7757 ck_assert_ptr_ne(r, null); 7758 finishO(toInject); 7759 s = toStringO(r); 7760 ck_assert_str_eq(s, "[\"3\",1,\"1\",2,3,4,\"2\"]"); 7761 free(s); 7762 // index outside 7763 toInject = allocSmallString("1"); 7764 ck_assert_ptr_eq(self->f->injectSmallString(self, 20, toInject), NULL); 7765 ck_assert_ptr_eq(self->f->injectSmallString(self, -9, toInject), NULL); 7766 terminateO(toInject); 7767 // empty object 7768 emptyO(self); 7769 toInject = allocSmallString("1"); 7770 freeO(toInject); 7771 ck_assert_ptr_ne(self->f->injectSmallString(self, 0, toInject), NULL); 7772 finishO(toInject); 7773 s = toStringO(r); 7774 ck_assert_str_eq(s, "[\"\"]"); 7775 free(s); 7776 // empty list 7777 emptyO(self); 7778 toInject = allocSmallString("1"); 7779 ck_assert_ptr_ne(self->f->injectSmallString(self, 0, toInject), NULL); 7780 finishO(toInject); 7781 s = toStringO(r); 7782 ck_assert_str_eq(s, "[\"1\"]"); 7783 free(s); 7784 emptyO(self); 7785 toInject = allocSmallString("1"); 7786 ck_assert_ptr_ne(self->f->injectSmallString(self, -1, toInject), NULL); 7787 finishO(toInject); 7788 s = toStringO(r); 7789 ck_assert_str_eq(s, "[\"1\"]"); 7790 free(s); 7791 // non smallString object 7792 toInject = (smallStringt*) allocSmallInt(2); 7793 r = self->f->injectSmallString(self, 0, toInject); 7794 ck_assert_ptr_eq(r, null); 7795 terminateO(toInject); 7796 // null toInsert 7797 ck_assert_ptr_eq(self->f->injectSmallString(self, 0, NULL), NULL); 7798 terminateO(self); 7799 7800 END_TEST 7801 7802 7803 START_TEST(injectSmallContainerSmallArrayT) 7804 7805 smallArrayt* r; 7806 smallArrayt *self = allocG(rtSmallArrayt); 7807 smallContainert *toInject; 7808 7809 // add elements to self 7810 r = self->f->pushInt(self, 1); 7811 ck_assert_ptr_ne(r, null); 7812 r = self->f->pushInt(self, 2); 7813 ck_assert_ptr_ne(r, null); 7814 r = self->f->pushInt(self, 3); 7815 ck_assert_ptr_ne(r, null); 7816 r = self->f->pushInt(self, 4); 7817 ck_assert_ptr_ne(r, null); 7818 7819 // positive index 7820 toInject = allocSmallContainer(NULL); 7821 r = self->f->injectSmallContainer(self, 1, toInject); 7822 ck_assert_ptr_ne(r, null); 7823 finishO(toInject); 7824 char *s = toStringO(r); 7825 ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4]"); 7826 free(s); 7827 // negative index 7828 toInject = allocSmallContainer(NULL); 7829 r = self->f->injectSmallContainer(self,-1, toInject); 7830 ck_assert_ptr_ne(r, null); 7831 finishO(toInject); 7832 s = toStringO(r); 7833 ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4,\"<data container>\"]"); 7834 free(s); 7835 // index 0 7836 toInject = allocSmallContainer(NULL); 7837 r = self->f->injectSmallContainer(self,0, toInject); 7838 ck_assert_ptr_ne(r, null); 7839 finishO(toInject); 7840 s = toStringO(r); 7841 ck_assert_str_eq(s, "[\"<data container>\",1,\"<data container>\",2,3,4,\"<data container>\"]"); 7842 free(s); 7843 // index outside 7844 toInject = allocSmallContainer(NULL); 7845 ck_assert_ptr_eq(self->f->injectSmallContainer(self, 20, toInject), NULL); 7846 ck_assert_ptr_eq(self->f->injectSmallContainer(self, -9, toInject), NULL); 7847 terminateO(toInject); 7848 // empty object 7849 emptyO(self); 7850 toInject = allocSmallContainer(NULL); 7851 freeO(toInject); 7852 ck_assert_ptr_ne(self->f->injectSmallContainer(self, 0, toInject), NULL); 7853 finishO(toInject); 7854 s = toStringO(r); 7855 ck_assert_str_eq(s, "[\"<data container>\"]"); 7856 free(s); 7857 // empty list 7858 emptyO(self); 7859 toInject = allocSmallContainer(NULL); 7860 ck_assert_ptr_ne(self->f->injectSmallContainer(self, 0, toInject), NULL); 7861 finishO(toInject); 7862 s = toStringO(r); 7863 ck_assert_str_eq(s, "[\"<data container>\"]"); 7864 free(s); 7865 emptyO(self); 7866 toInject = allocSmallContainer(NULL); 7867 ck_assert_ptr_ne(self->f->injectSmallContainer(self, -1, toInject), NULL); 7868 finishO(toInject); 7869 s = toStringO(r); 7870 ck_assert_str_eq(s, "[\"<data container>\"]"); 7871 free(s); 7872 // non smallContainer object 7873 toInject = (smallContainert*) allocSmallInt(2); 7874 r = self->f->injectSmallContainer(self, 0, toInject); 7875 ck_assert_ptr_eq(r, null); 7876 terminateO(toInject); 7877 // null toInsert 7878 ck_assert_ptr_eq(self->f->injectSmallContainer(self, 0, NULL), NULL); 7879 terminateO(self); 7880 7881 END_TEST 7882 7883 7884 START_TEST(injectNFreeSmallArrayT) 7885 7886 smallArrayt* r; 7887 smallArrayt *self = allocG(rtSmallArrayt); 7888 baset *toInject; 7889 7890 // add elements to self 7891 r = self->f->pushInt(self, 1); 7892 ck_assert_ptr_ne(r, null); 7893 r = self->f->pushInt(self, 2); 7894 ck_assert_ptr_ne(r, null); 7895 r = self->f->pushInt(self, 3); 7896 ck_assert_ptr_ne(r, null); 7897 r = self->f->pushInt(self, 4); 7898 ck_assert_ptr_ne(r, null); 7899 7900 // positive index 7901 toInject = (baset*) allocSmallInt(8); 7902 r = self->f->injectNFree(self, 1, toInject); 7903 ck_assert_ptr_ne(r, null); 7904 char *s = toStringO(r); 7905 ck_assert_str_eq(s, "[1,8,2,3,4]"); 7906 free(s); 7907 // negative index 7908 toInject = (baset*) allocSmallInt(9); 7909 r = self->f->injectNFree(self,-1, toInject); 7910 ck_assert_ptr_ne(r, null); 7911 s = toStringO(r); 7912 ck_assert_str_eq(s, "[1,8,2,3,4,9]"); 7913 free(s); 7914 // index 0 7915 toInject = (baset*) allocSmallInt(6); 7916 r = self->f->injectNFree(self,0, toInject); 7917 ck_assert_ptr_ne(r, null); 7918 s = toStringO(r); 7919 ck_assert_str_eq(s, "[6,1,8,2,3,4,9]"); 7920 free(s); 7921 // index outside 7922 toInject = (baset*) allocSmallInt(7); 7923 ck_assert_ptr_eq(self->f->injectNFree(self, 20, toInject), NULL); 7924 ck_assert_ptr_eq(self->f->injectNFree(self, -9, toInject), NULL); 7925 terminateO(toInject); 7926 // empty list 7927 emptyO(self); 7928 toInject = (baset*) allocSmallInt(7); 7929 ck_assert_ptr_ne(self->f->injectNFree(self, 0, toInject), NULL); 7930 s = toStringO(r); 7931 ck_assert_str_eq(s, "[7]"); 7932 free(s); 7933 emptyO(self); 7934 toInject = (baset*) allocSmallInt(7); 7935 ck_assert_ptr_ne(self->f->injectNFree(self, -1, toInject), NULL); 7936 s = toStringO(r); 7937 ck_assert_str_eq(s, "[7]"); 7938 free(s); 7939 // null toInsert 7940 ck_assert_ptr_eq(self->f->injectNFree(self, 0, NULL), NULL); 7941 terminateO(self); 7942 7943 END_TEST 7944 7945 7946 START_TEST(injectNFreeUndefinedSmallArrayT) 7947 7948 smallArrayt* r; 7949 smallArrayt *self = allocG(rtSmallArrayt); 7950 undefinedt *value = NULL; 7951 7952 7953 // add elements to self 7954 r = self->f->pushInt(self, 1); 7955 ck_assert_ptr_ne(r, null); 7956 r = self->f->pushInt(self, 2); 7957 ck_assert_ptr_ne(r, null); 7958 r = self->f->pushInt(self, 3); 7959 ck_assert_ptr_ne(r, null); 7960 r = self->f->pushInt(self, 4); 7961 ck_assert_ptr_ne(r, null); 7962 7963 // positive index 7964 value = allocUndefined(); 7965 r = self->f->injectNFreeUndefined(self, 1, value); 7966 ck_assert_ptr_ne(r, null); 7967 char *s = toStringO(r); 7968 ck_assert_str_eq(s, "[1,null,2,3,4]"); 7969 free(s); 7970 // negative index 7971 value = allocUndefined(); 7972 r = self->f->injectNFreeUndefined(self,-1, value); 7973 ck_assert_ptr_ne(r, null); 7974 s = toStringO(r); 7975 ck_assert_str_eq(s, "[1,null,2,3,4,null]"); 7976 free(s); 7977 // index 0 7978 value = allocUndefined(); 7979 r = self->f->injectNFreeUndefined(self,0, value); 7980 ck_assert_ptr_ne(r, null); 7981 s = toStringO(r); 7982 ck_assert_str_eq(s, "[null,1,null,2,3,4,null]"); 7983 free(s); 7984 // index outside 7985 value = allocUndefined(); 7986 ck_assert_ptr_eq(self->f->injectNFreeUndefined(self, 20, value), NULL); 7987 terminateO(value); 7988 7989 value = allocUndefined(); 7990 ck_assert_ptr_eq(self->f->injectNFreeUndefined(self, -9, value), NULL); 7991 terminateO(value); 7992 7993 // empty list 7994 emptyO(self); 7995 value = allocUndefined(); 7996 ck_assert_ptr_ne(self->f->injectNFreeUndefined(self, 0, value), NULL); 7997 s = toStringO(r); 7998 ck_assert_str_eq(s, "[null]"); 7999 free(s); 8000 emptyO(self); 8001 value = allocUndefined(); 8002 ck_assert_ptr_ne(self->f->injectNFreeUndefined(self, -1, value), NULL); 8003 s = toStringO(r); 8004 ck_assert_str_eq(s, "[null]"); 8005 free(s); 8006 terminateO(self); 8007 8008 END_TEST 8009 8010 8011 START_TEST(injectNFreeSSmallArrayT) 8012 8013 smallArrayt* r; 8014 smallArrayt *self = allocG(rtSmallArrayt); 8015 8016 // add elements to self 8017 r = self->f->pushInt(self, 1); 8018 ck_assert_ptr_ne(r, null); 8019 r = self->f->pushInt(self, 2); 8020 ck_assert_ptr_ne(r, null); 8021 r = self->f->pushInt(self, 3); 8022 ck_assert_ptr_ne(r, null); 8023 r = self->f->pushInt(self, 4); 8024 ck_assert_ptr_ne(r, null); 8025 8026 // positive index 8027 r = self->f->injectNFreeS(self, 1, strdup("5")); 8028 ck_assert_ptr_ne(r, null); 8029 char *s = toStringO(r); 8030 ck_assert_str_eq(s, "[1,\"5\",2,3,4]"); 8031 free(s); 8032 // negative index 8033 r = self->f->injectNFreeS(self,-1, strdup("6")); 8034 ck_assert_ptr_ne(r, null); 8035 s = toStringO(r); 8036 ck_assert_str_eq(s, "[1,\"5\",2,3,4,\"6\"]"); 8037 free(s); 8038 // index 0 8039 r = self->f->injectNFreeS(self,0, strdup("7")); 8040 ck_assert_ptr_ne(r, null); 8041 s = toStringO(r); 8042 ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]"); 8043 free(s); 8044 // index outside 8045 ck_assert_ptr_eq(self->f->injectNFreeS(self, 20, ""), NULL); 8046 ck_assert_ptr_eq(self->f->injectNFreeS(self, -9, ""), NULL); 8047 // empty list 8048 emptyO(self); 8049 ck_assert_ptr_ne(self->f->injectNFreeS(self, 0, strdup("7")), NULL); 8050 s = toStringO(r); 8051 ck_assert_str_eq(s, "[\"7\"]"); 8052 free(s); 8053 emptyO(self); 8054 ck_assert_ptr_ne(self->f->injectNFreeS(self, -1, strdup("7")), NULL); 8055 s = toStringO(r); 8056 ck_assert_str_eq(s, "[\"7\"]"); 8057 free(s); 8058 terminateO(self); 8059 8060 END_TEST 8061 8062 8063 START_TEST(injectNFreeDictSmallArrayT) 8064 8065 smallArrayt* r; 8066 smallArrayt *self = allocG(rtSmallArrayt); 8067 smallDictt *toInject; 8068 8069 // add elements to self 8070 r = self->f->pushInt(self, 1); 8071 ck_assert_ptr_ne(r, null); 8072 r = self->f->pushInt(self, 2); 8073 ck_assert_ptr_ne(r, null); 8074 r = self->f->pushInt(self, 3); 8075 ck_assert_ptr_ne(r, null); 8076 r = self->f->pushInt(self, 4); 8077 ck_assert_ptr_ne(r, null); 8078 8079 // positive index 8080 toInject = allocSmallDict(); 8081 r = self->f->injectNFreeDict(self, 1, toInject); 8082 ck_assert_ptr_ne(r, null); 8083 char *s = toStringO(r); 8084 ck_assert_str_eq(s, "[1,{},2,3,4]"); 8085 free(s); 8086 // negative index 8087 toInject = allocSmallDict(); 8088 r = self->f->injectNFreeDict(self,-1, toInject); 8089 ck_assert_ptr_ne(r, null); 8090 s = toStringO(r); 8091 ck_assert_str_eq(s, "[1,{},2,3,4,{}]"); 8092 free(s); 8093 // index 0 8094 toInject = allocSmallDict(); 8095 r = self->f->injectNFreeDict(self,0, toInject); 8096 ck_assert_ptr_ne(r, null); 8097 s = toStringO(r); 8098 ck_assert_str_eq(s, "[{},1,{},2,3,4,{}]"); 8099 free(s); 8100 // index outside 8101 toInject = allocSmallDict(); 8102 ck_assert_ptr_eq(self->f->injectNFreeDict(self, 20, toInject), NULL); 8103 ck_assert_ptr_eq(self->f->injectNFreeDict(self, -9, toInject), NULL); 8104 terminateO(toInject); 8105 // empty list 8106 emptyO(self); 8107 toInject = allocSmallDict(); 8108 ck_assert_ptr_ne(self->f->injectNFreeDict(self, 0, toInject), NULL); 8109 s = toStringO(r); 8110 ck_assert_str_eq(s, "[{}]"); 8111 free(s); 8112 emptyO(self); 8113 toInject = allocSmallDict(); 8114 ck_assert_ptr_ne(self->f->injectNFreeDict(self, -1, toInject), NULL); 8115 s = toStringO(r); 8116 ck_assert_str_eq(s, "[{}]"); 8117 free(s); 8118 // null toInsert 8119 ck_assert_ptr_eq(self->f->injectNFreeDict(self, 0, NULL), NULL); 8120 terminateO(self); 8121 8122 END_TEST 8123 8124 8125 START_TEST(injectNFreeArraySmallArrayT) 8126 8127 smallArrayt* r; 8128 smallArrayt *self = allocG(rtSmallArrayt); 8129 smallArrayt *toInject; 8130 8131 // add elements to self 8132 r = self->f->pushInt(self, 1); 8133 ck_assert_ptr_ne(r, null); 8134 r = self->f->pushInt(self, 2); 8135 ck_assert_ptr_ne(r, null); 8136 r = self->f->pushInt(self, 3); 8137 ck_assert_ptr_ne(r, null); 8138 r = self->f->pushInt(self, 4); 8139 ck_assert_ptr_ne(r, null); 8140 8141 // positive index 8142 toInject = allocSmallArray(); 8143 r = self->f->injectNFreeArray(self, 1, toInject); 8144 ck_assert_ptr_ne(r, null); 8145 char *s = toStringO(r); 8146 ck_assert_str_eq(s, "[1,[],2,3,4]"); 8147 free(s); 8148 // negative index 8149 toInject = allocSmallArray(); 8150 r = self->f->injectNFreeArray(self,-1, toInject); 8151 ck_assert_ptr_ne(r, null); 8152 s = toStringO(r); 8153 ck_assert_str_eq(s, "[1,[],2,3,4,[]]"); 8154 free(s); 8155 // index 0 8156 toInject = allocSmallArray(); 8157 r = self->f->injectNFreeArray(self,0, toInject); 8158 ck_assert_ptr_ne(r, null); 8159 s = toStringO(r); 8160 ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]"); 8161 free(s); 8162 // index outside 8163 toInject = allocSmallArray(); 8164 ck_assert_ptr_eq(self->f->injectNFreeArray(self, 20, toInject), NULL); 8165 ck_assert_ptr_eq(self->f->injectNFreeArray(self, -9, toInject), NULL); 8166 terminateO(toInject); 8167 // empty list 8168 emptyO(self); 8169 toInject = allocSmallArray(); 8170 ck_assert_ptr_ne(self->f->injectNFreeArray(self, 0, toInject), NULL); 8171 s = toStringO(r); 8172 ck_assert_str_eq(s, "[[]]"); 8173 free(s); 8174 emptyO(self); 8175 toInject = allocSmallArray(); 8176 ck_assert_ptr_ne(self->f->injectNFreeArray(self, -1, toInject), NULL); 8177 s = toStringO(r); 8178 ck_assert_str_eq(s, "[[]]"); 8179 free(s); 8180 // null toInsert 8181 ck_assert_ptr_eq(self->f->injectNFreeArray(self, 0, NULL), NULL); 8182 terminateO(self); 8183 8184 END_TEST 8185 8186 8187 START_TEST(injectNFreeArraycSmallArrayT) 8188 8189 smallArrayt* r; 8190 smallArrayt *self = allocG(rtSmallArrayt); 8191 char **toInject; 8192 8193 // add elements to self 8194 r = self->f->pushInt(self, 1); 8195 ck_assert_ptr_ne(r, null); 8196 r = self->f->pushInt(self, 2); 8197 ck_assert_ptr_ne(r, null); 8198 r = self->f->pushInt(self, 3); 8199 ck_assert_ptr_ne(r, null); 8200 r = self->f->pushInt(self, 4); 8201 ck_assert_ptr_ne(r, null); 8202 8203 // positive index 8204 toInject = listCreateS("a","b"); 8205 r = self->f->injectNFreeArrayc(self, 1, toInject); 8206 ck_assert_ptr_ne(r, null); 8207 char *s = toStringO(r); 8208 ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4]"); 8209 free(s); 8210 // negative index 8211 toInject = listCreateS("c","d"); 8212 r = self->f->injectNFreeArrayc(self,-1, toInject); 8213 ck_assert_ptr_ne(r, null); 8214 s = toStringO(r); 8215 ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]"); 8216 free(s); 8217 // index 0 8218 toInject = listCreateS("e","ff"); 8219 r = self->f->injectNFreeArrayc(self,0, toInject); 8220 ck_assert_ptr_ne(r, null); 8221 s = toStringO(r); 8222 ck_assert_str_eq(s, "[[\"e\",\"ff\"],1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]"); 8223 free(s); 8224 // index outside 8225 toInject = listCreateS("a","b"); 8226 ck_assert_ptr_eq(self->f->injectNFreeArrayc(self, 20, toInject), NULL); 8227 ck_assert_ptr_eq(self->f->injectNFreeArrayc(self, -9, toInject), NULL); 8228 listFreeS(toInject); 8229 // empty list 8230 emptyO(self); 8231 toInject = listCreateS("a","b"); 8232 ck_assert_ptr_ne(self->f->injectNFreeArrayc(self, 0, toInject), NULL); 8233 s = toStringO(r); 8234 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 8235 free(s); 8236 emptyO(self); 8237 toInject = listCreateS("a","b"); 8238 ck_assert_ptr_ne(self->f->injectNFreeArrayc(self, -1, toInject), NULL); 8239 s = toStringO(r); 8240 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 8241 free(s); 8242 // null toInsert 8243 ck_assert_ptr_eq(self->f->injectNFreeArrayc(self, 0, NULL), NULL); 8244 terminateO(self); 8245 8246 END_TEST 8247 8248 8249 START_TEST(injectNFreeSmallBoolSmallArrayT) 8250 8251 smallArrayt* r; 8252 smallArrayt *self = allocG(rtSmallArrayt); 8253 smallBoolt *toInject; 8254 8255 // add elements to self 8256 r = self->f->pushInt(self, 1); 8257 ck_assert_ptr_ne(r, null); 8258 r = self->f->pushInt(self, 2); 8259 ck_assert_ptr_ne(r, null); 8260 r = self->f->pushInt(self, 3); 8261 ck_assert_ptr_ne(r, null); 8262 r = self->f->pushInt(self, 4); 8263 ck_assert_ptr_ne(r, null); 8264 8265 // positive index 8266 toInject = allocSmallBool(true); 8267 r = self->f->injectNFreeSmallBool(self, 1, toInject); 8268 ck_assert_ptr_ne(r, null); 8269 char *s = toStringO(r); 8270 ck_assert_str_eq(s, "[1,true,2,3,4]"); 8271 free(s); 8272 // negative index 8273 toInject = allocSmallBool(true); 8274 r = self->f->injectNFreeSmallBool(self,-1, toInject); 8275 ck_assert_ptr_ne(r, null); 8276 s = toStringO(r); 8277 ck_assert_str_eq(s, "[1,true,2,3,4,true]"); 8278 free(s); 8279 // index 0 8280 toInject = allocSmallBool(true); 8281 r = self->f->injectNFreeSmallBool(self,0, toInject); 8282 ck_assert_ptr_ne(r, null); 8283 s = toStringO(r); 8284 ck_assert_str_eq(s, "[true,1,true,2,3,4,true]"); 8285 free(s); 8286 // index outside 8287 toInject = allocSmallBool(true); 8288 ck_assert_ptr_eq(self->f->injectNFreeSmallBool(self, 20, toInject), NULL); 8289 ck_assert_ptr_eq(self->f->injectNFreeSmallBool(self, -9, toInject), NULL); 8290 terminateO(toInject); 8291 // empty object 8292 emptyO(self); 8293 toInject = allocSmallBool(true); 8294 freeO(toInject); 8295 ck_assert_ptr_ne(self->f->injectNFreeSmallBool(self, 0, toInject), NULL); 8296 s = toStringO(r); 8297 ck_assert_str_eq(s, "[false]"); 8298 free(s); 8299 // empty list 8300 emptyO(self); 8301 toInject = allocSmallBool(true); 8302 ck_assert_ptr_ne(self->f->injectNFreeSmallBool(self, 0, toInject), NULL); 8303 s = toStringO(r); 8304 ck_assert_str_eq(s, "[true]"); 8305 free(s); 8306 emptyO(self); 8307 toInject = allocSmallBool(true); 8308 ck_assert_ptr_ne(self->f->injectNFreeSmallBool(self, -1, toInject), NULL); 8309 s = toStringO(r); 8310 ck_assert_str_eq(s, "[true]"); 8311 free(s); 8312 // null toInsert 8313 ck_assert_ptr_eq(self->f->injectNFreeSmallBool(self, 0, NULL), NULL); 8314 terminateO(self); 8315 8316 END_TEST 8317 8318 8319 START_TEST(injectNFreeSmallBytesSmallArrayT) 8320 8321 smallArrayt* r; 8322 smallArrayt *self = allocG(rtSmallArrayt); 8323 smallBytest *toInject; 8324 8325 // add elements to self 8326 r = self->f->pushInt(self, 1); 8327 ck_assert_ptr_ne(r, null); 8328 r = self->f->pushInt(self, 2); 8329 ck_assert_ptr_ne(r, null); 8330 r = self->f->pushInt(self, 3); 8331 ck_assert_ptr_ne(r, null); 8332 r = self->f->pushInt(self, 4); 8333 ck_assert_ptr_ne(r, null); 8334 8335 // positive index 8336 toInject = allocSmallBytes(null, 0); 8337 r = self->f->injectNFreeSmallBytes(self, 1, toInject); 8338 ck_assert_ptr_ne(r, null); 8339 char *s = toStringO(r); 8340 ck_assert_str_eq(s, "[1,[],2,3,4]"); 8341 free(s); 8342 // negative index 8343 toInject = allocSmallBytes(null, 0); 8344 r = self->f->injectNFreeSmallBytes(self,-1, toInject); 8345 ck_assert_ptr_ne(r, null); 8346 s = toStringO(r); 8347 ck_assert_str_eq(s, "[1,[],2,3,4,[]]"); 8348 free(s); 8349 // index 0 8350 toInject = allocSmallBytes(null, 0); 8351 r = self->f->injectNFreeSmallBytes(self,0, toInject); 8352 ck_assert_ptr_ne(r, null); 8353 s = toStringO(r); 8354 ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]"); 8355 free(s); 8356 // index outside 8357 toInject = allocSmallBytes(null, 0); 8358 ck_assert_ptr_eq(self->f->injectNFreeSmallBytes(self, 20, toInject), NULL); 8359 ck_assert_ptr_eq(self->f->injectNFreeSmallBytes(self, -9, toInject), NULL); 8360 terminateO(toInject); 8361 // empty object 8362 emptyO(self); 8363 toInject = allocSmallBytes(null, 0); 8364 freeO(toInject); 8365 ck_assert_ptr_ne(self->f->injectNFreeSmallBytes(self, 0, toInject), NULL); 8366 s = toStringO(r); 8367 ck_assert_str_eq(s, "[[]]"); 8368 free(s); 8369 // empty list 8370 emptyO(self); 8371 toInject = allocSmallBytes(null, 0); 8372 ck_assert_ptr_ne(self->f->injectNFreeSmallBytes(self, 0, toInject), NULL); 8373 s = toStringO(r); 8374 ck_assert_str_eq(s, "[[]]"); 8375 free(s); 8376 emptyO(self); 8377 toInject = allocSmallBytes(null, 0); 8378 ck_assert_ptr_ne(self->f->injectNFreeSmallBytes(self, -1, toInject), NULL); 8379 s = toStringO(r); 8380 ck_assert_str_eq(s, "[[]]"); 8381 free(s); 8382 // null toInsert 8383 ck_assert_ptr_eq(self->f->injectNFreeSmallBytes(self, 0, NULL), NULL); 8384 terminateO(self); 8385 8386 END_TEST 8387 8388 8389 START_TEST(injectNFreeSmallDoubleSmallArrayT) 8390 8391 smallArrayt* r; 8392 smallArrayt *self = allocG(rtSmallArrayt); 8393 smallDoublet *toInject; 8394 8395 // add elements to self 8396 r = self->f->pushInt(self, 1); 8397 ck_assert_ptr_ne(r, null); 8398 r = self->f->pushInt(self, 2); 8399 ck_assert_ptr_ne(r, null); 8400 r = self->f->pushInt(self, 3); 8401 ck_assert_ptr_ne(r, null); 8402 r = self->f->pushInt(self, 4); 8403 ck_assert_ptr_ne(r, null); 8404 8405 // positive index 8406 toInject = allocSmallDouble(2); 8407 r = self->f->injectNFreeSmallDouble(self, 1, toInject); 8408 ck_assert_ptr_ne(r, null); 8409 char *s = toStringO(r); 8410 ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4]"); 8411 free(s); 8412 // negative index 8413 toInject = allocSmallDouble(3); 8414 r = self->f->injectNFreeSmallDouble(self,-1, toInject); 8415 ck_assert_ptr_ne(r, null); 8416 s = toStringO(r); 8417 ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4,3.000000e+00]"); 8418 free(s); 8419 // index 0 8420 toInject = allocSmallDouble(1); 8421 r = self->f->injectNFreeSmallDouble(self,0, toInject); 8422 ck_assert_ptr_ne(r, null); 8423 s = toStringO(r); 8424 ck_assert_str_eq(s, "[1.000000e+00,1,2.000000e+00,2,3,4,3.000000e+00]"); 8425 free(s); 8426 // index outside 8427 toInject = allocSmallDouble(1); 8428 ck_assert_ptr_eq(self->f->injectNFreeSmallDouble(self, 20, toInject), NULL); 8429 ck_assert_ptr_eq(self->f->injectNFreeSmallDouble(self, -9, toInject), NULL); 8430 terminateO(toInject); 8431 // empty object 8432 emptyO(self); 8433 toInject = allocSmallDouble(1); 8434 freeO(toInject); 8435 ck_assert_ptr_ne(self->f->injectNFreeSmallDouble(self, 0, toInject), NULL); 8436 s = toStringO(r); 8437 ck_assert_str_eq(s, "[0.000000e+00]"); 8438 free(s); 8439 // empty list 8440 emptyO(self); 8441 toInject = allocSmallDouble(1); 8442 ck_assert_ptr_ne(self->f->injectNFreeSmallDouble(self, 0, toInject), NULL); 8443 s = toStringO(r); 8444 ck_assert_str_eq(s, "[1.000000e+00]"); 8445 free(s); 8446 emptyO(self); 8447 toInject = allocSmallDouble(1); 8448 ck_assert_ptr_ne(self->f->injectNFreeSmallDouble(self, -1, toInject), NULL); 8449 s = toStringO(r); 8450 ck_assert_str_eq(s, "[1.000000e+00]"); 8451 free(s); 8452 // null toInsert 8453 ck_assert_ptr_eq(self->f->injectNFreeSmallDouble(self, 0, NULL), NULL); 8454 terminateO(self); 8455 8456 END_TEST 8457 8458 8459 START_TEST(injectNFreeSmallIntSmallArrayT) 8460 8461 smallArrayt* r; 8462 smallArrayt *self = allocG(rtSmallArrayt); 8463 smallIntt *toInject; 8464 8465 // add elements to self 8466 r = self->f->pushInt(self, 1); 8467 ck_assert_ptr_ne(r, null); 8468 r = self->f->pushInt(self, 2); 8469 ck_assert_ptr_ne(r, null); 8470 r = self->f->pushInt(self, 3); 8471 ck_assert_ptr_ne(r, null); 8472 r = self->f->pushInt(self, 4); 8473 ck_assert_ptr_ne(r, null); 8474 8475 // positive index 8476 toInject = allocSmallInt(10); 8477 r = self->f->injectNFreeSmallInt(self, 1, toInject); 8478 ck_assert_ptr_ne(r, null); 8479 char *s = toStringO(r); 8480 ck_assert_str_eq(s, "[1,10,2,3,4]"); 8481 free(s); 8482 // negative index 8483 toInject = allocSmallInt(11); 8484 r = self->f->injectNFreeSmallInt(self,-1, toInject); 8485 ck_assert_ptr_ne(r, null); 8486 s = toStringO(r); 8487 ck_assert_str_eq(s, "[1,10,2,3,4,11]"); 8488 free(s); 8489 // index 0 8490 toInject = allocSmallInt(12); 8491 r = self->f->injectNFreeSmallInt(self,0, toInject); 8492 ck_assert_ptr_ne(r, null); 8493 s = toStringO(r); 8494 ck_assert_str_eq(s, "[12,1,10,2,3,4,11]"); 8495 free(s); 8496 // index outside 8497 toInject = allocSmallInt(10); 8498 ck_assert_ptr_eq(self->f->injectNFreeSmallInt(self, 20, toInject), NULL); 8499 ck_assert_ptr_eq(self->f->injectNFreeSmallInt(self, -9, toInject), NULL); 8500 terminateO(toInject); 8501 // empty object 8502 emptyO(self); 8503 toInject = allocSmallInt(10); 8504 freeO(toInject); 8505 ck_assert_ptr_ne(self->f->injectNFreeSmallInt(self, 0, toInject), NULL); 8506 s = toStringO(r); 8507 ck_assert_str_eq(s, "[0]"); 8508 free(s); 8509 // empty list 8510 emptyO(self); 8511 toInject = allocSmallInt(10); 8512 ck_assert_ptr_ne(self->f->injectNFreeSmallInt(self, 0, toInject), NULL); 8513 s = toStringO(r); 8514 ck_assert_str_eq(s, "[10]"); 8515 free(s); 8516 emptyO(self); 8517 toInject = allocSmallInt(10); 8518 ck_assert_ptr_ne(self->f->injectNFreeSmallInt(self, -1, toInject), NULL); 8519 s = toStringO(r); 8520 ck_assert_str_eq(s, "[10]"); 8521 free(s); 8522 // null toInsert 8523 ck_assert_ptr_eq(self->f->injectNFreeSmallInt(self, 0, NULL), NULL); 8524 terminateO(self); 8525 8526 END_TEST 8527 8528 8529 START_TEST(injectNFreeSmallJsonSmallArrayT) 8530 8531 smallArrayt* r; 8532 smallArrayt *self = allocG(rtSmallArrayt); 8533 smallJsont *toInject; 8534 8535 // add elements to self 8536 r = self->f->pushInt(self, 1); 8537 ck_assert_ptr_ne(r, null); 8538 r = self->f->pushInt(self, 2); 8539 ck_assert_ptr_ne(r, null); 8540 r = self->f->pushInt(self, 3); 8541 ck_assert_ptr_ne(r, null); 8542 r = self->f->pushInt(self, 4); 8543 ck_assert_ptr_ne(r, null); 8544 8545 // positive index 8546 toInject = allocSmallJson(); 8547 r = self->f->injectNFreeSmallJson(self, 1, toInject); 8548 ck_assert_ptr_ne(r, null); 8549 char *s = toStringO(r); 8550 ck_assert_str_eq(s, "[1,{},2,3,4]"); 8551 free(s); 8552 // negative index 8553 toInject = allocSmallJson(); 8554 r = self->f->injectNFreeSmallJson(self,-1, toInject); 8555 ck_assert_ptr_ne(r, null); 8556 s = toStringO(r); 8557 ck_assert_str_eq(s, "[1,{},2,3,4,{}]"); 8558 free(s); 8559 // index 0 8560 toInject = allocSmallJson(); 8561 toInject->f->setS(toInject, "key", "value"); 8562 r = self->f->injectNFreeSmallJson(self,0, toInject); 8563 ck_assert_ptr_ne(r, null); 8564 s = toStringO(r); 8565 ck_assert_str_eq(s, "[{\"key\":\"value\"},1,{},2,3,4,{}]"); 8566 free(s); 8567 // index outside 8568 toInject = allocSmallJson(); 8569 ck_assert_ptr_eq(self->f->injectNFreeSmallJson(self, 20, toInject), NULL); 8570 ck_assert_ptr_eq(self->f->injectNFreeSmallJson(self, -9, toInject), NULL); 8571 terminateO(toInject); 8572 // empty object 8573 emptyO(self); 8574 toInject = allocSmallJson(); 8575 freeO(toInject); 8576 ck_assert_ptr_ne(self->f->injectNFreeSmallJson(self, 0, toInject), NULL); 8577 s = toStringO(r); 8578 ck_assert_str_eq(s, "[{}]"); 8579 free(s); 8580 // empty list 8581 emptyO(self); 8582 toInject = allocSmallJson(); 8583 ck_assert_ptr_ne(self->f->injectNFreeSmallJson(self, 0, toInject), NULL); 8584 s = toStringO(r); 8585 ck_assert_str_eq(s, "[{}]"); 8586 free(s); 8587 emptyO(self); 8588 toInject = allocSmallJson(); 8589 ck_assert_ptr_ne(self->f->injectNFreeSmallJson(self, -1, toInject), NULL); 8590 s = toStringO(r); 8591 ck_assert_str_eq(s, "[{}]"); 8592 free(s); 8593 // null toInsert 8594 ck_assert_ptr_eq(self->f->injectNFreeSmallJson(self, 0, NULL), NULL); 8595 terminateO(self); 8596 8597 END_TEST 8598 8599 8600 START_TEST(injectNFreeSmallStringSmallArrayT) 8601 8602 smallArrayt* r; 8603 smallArrayt *self = allocG(rtSmallArrayt); 8604 smallStringt *toInject; 8605 8606 // add elements to self 8607 r = self->f->pushInt(self, 1); 8608 ck_assert_ptr_ne(r, null); 8609 r = self->f->pushInt(self, 2); 8610 ck_assert_ptr_ne(r, null); 8611 r = self->f->pushInt(self, 3); 8612 ck_assert_ptr_ne(r, null); 8613 r = self->f->pushInt(self, 4); 8614 ck_assert_ptr_ne(r, null); 8615 8616 // positive index 8617 toInject = allocSmallString("1"); 8618 r = self->f->injectNFreeSmallString(self, 1, toInject); 8619 ck_assert_ptr_ne(r, null); 8620 char *s = toStringO(r); 8621 ck_assert_str_eq(s, "[1,\"1\",2,3,4]"); 8622 free(s); 8623 // negative index 8624 toInject = allocSmallString("2"); 8625 r = self->f->injectNFreeSmallString(self,-1, toInject); 8626 ck_assert_ptr_ne(r, null); 8627 s = toStringO(r); 8628 ck_assert_str_eq(s, "[1,\"1\",2,3,4,\"2\"]"); 8629 free(s); 8630 // index 0 8631 toInject = allocSmallString("3"); 8632 r = self->f->injectNFreeSmallString(self,0, toInject); 8633 ck_assert_ptr_ne(r, null); 8634 s = toStringO(r); 8635 ck_assert_str_eq(s, "[\"3\",1,\"1\",2,3,4,\"2\"]"); 8636 free(s); 8637 // index outside 8638 toInject = allocSmallString("1"); 8639 ck_assert_ptr_eq(self->f->injectNFreeSmallString(self, 20, toInject), NULL); 8640 ck_assert_ptr_eq(self->f->injectNFreeSmallString(self, -9, toInject), NULL); 8641 terminateO(toInject); 8642 // empty object 8643 emptyO(self); 8644 toInject = allocSmallString("1"); 8645 freeO(toInject); 8646 ck_assert_ptr_ne(self->f->injectNFreeSmallString(self, 0, toInject), NULL); 8647 s = toStringO(r); 8648 ck_assert_str_eq(s, "[\"\"]"); 8649 free(s); 8650 // empty list 8651 emptyO(self); 8652 toInject = allocSmallString("1"); 8653 ck_assert_ptr_ne(self->f->injectNFreeSmallString(self, 0, toInject), NULL); 8654 s = toStringO(r); 8655 ck_assert_str_eq(s, "[\"1\"]"); 8656 free(s); 8657 emptyO(self); 8658 toInject = allocSmallString("1"); 8659 ck_assert_ptr_ne(self->f->injectNFreeSmallString(self, -1, toInject), NULL); 8660 s = toStringO(r); 8661 ck_assert_str_eq(s, "[\"1\"]"); 8662 free(s); 8663 // null toInsert 8664 ck_assert_ptr_eq(self->f->injectNFreeSmallString(self, 0, NULL), NULL); 8665 terminateO(self); 8666 8667 END_TEST 8668 8669 8670 START_TEST(injectNFreeSmallContainerSmallArrayT) 8671 8672 smallArrayt* r; 8673 smallArrayt *self = allocG(rtSmallArrayt); 8674 smallContainert *toInject; 8675 8676 // add elements to self 8677 r = self->f->pushInt(self, 1); 8678 ck_assert_ptr_ne(r, null); 8679 r = self->f->pushInt(self, 2); 8680 ck_assert_ptr_ne(r, null); 8681 r = self->f->pushInt(self, 3); 8682 ck_assert_ptr_ne(r, null); 8683 r = self->f->pushInt(self, 4); 8684 ck_assert_ptr_ne(r, null); 8685 8686 // positive index 8687 toInject = allocSmallContainer(NULL); 8688 r = self->f->injectNFreeSmallContainer(self, 1, toInject); 8689 ck_assert_ptr_ne(r, null); 8690 char *s = toStringO(r); 8691 ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4]"); 8692 free(s); 8693 // negative index 8694 toInject = allocSmallContainer(NULL); 8695 r = self->f->injectNFreeSmallContainer(self,-1, toInject); 8696 ck_assert_ptr_ne(r, null); 8697 s = toStringO(r); 8698 ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4,\"<data container>\"]"); 8699 free(s); 8700 // index 0 8701 toInject = allocSmallContainer(NULL); 8702 r = self->f->injectNFreeSmallContainer(self,0, toInject); 8703 ck_assert_ptr_ne(r, null); 8704 s = toStringO(r); 8705 ck_assert_str_eq(s, "[\"<data container>\",1,\"<data container>\",2,3,4,\"<data container>\"]"); 8706 free(s); 8707 // index outside 8708 toInject = allocSmallContainer(NULL); 8709 ck_assert_ptr_eq(self->f->injectNFreeSmallContainer(self, 20, toInject), NULL); 8710 ck_assert_ptr_eq(self->f->injectNFreeSmallContainer(self, -9, toInject), NULL); 8711 terminateO(toInject); 8712 // empty object 8713 emptyO(self); 8714 toInject = allocSmallContainer(NULL); 8715 freeO(toInject); 8716 ck_assert_ptr_ne(self->f->injectNFreeSmallContainer(self, 0, toInject), NULL); 8717 s = toStringO(r); 8718 ck_assert_str_eq(s, "[\"<data container>\"]"); 8719 free(s); 8720 // empty list 8721 emptyO(self); 8722 toInject = allocSmallContainer(NULL); 8723 ck_assert_ptr_ne(self->f->injectNFreeSmallContainer(self, 0, toInject), NULL); 8724 s = toStringO(r); 8725 ck_assert_str_eq(s, "[\"<data container>\"]"); 8726 free(s); 8727 emptyO(self); 8728 toInject = allocSmallContainer(NULL); 8729 ck_assert_ptr_ne(self->f->injectNFreeSmallContainer(self, -1, toInject), NULL); 8730 s = toStringO(r); 8731 ck_assert_str_eq(s, "[\"<data container>\"]"); 8732 free(s); 8733 // null toInsert 8734 ck_assert_ptr_eq(self->f->injectNFreeSmallContainer(self, 0, NULL), NULL); 8735 terminateO(self); 8736 8737 END_TEST 8738 8739 8740 START_TEST(removeSmallArrayT) 8741 8742 smallArrayt* r; 8743 smallArrayt *self = allocG(rtSmallArrayt); 8744 8745 // add elements to self 8746 r = self->f->pushInt(self, 1); 8747 ck_assert_ptr_ne(r, null); 8748 r = self->f->pushInt(self, 2); 8749 ck_assert_ptr_ne(r, null); 8750 r = self->f->pushInt(self, 3); 8751 ck_assert_ptr_ne(r, null); 8752 r = self->f->pushInt(self, 4); 8753 ck_assert_ptr_ne(r, null); 8754 8755 smallIntt *e[4]; 8756 arange(i,e) { 8757 e[i] = self->f->getAtSmallInt(self, i); 8758 } 8759 8760 // negative index 8761 r = removeO(self, 1, -1); 8762 ck_assert_ptr_ne(r, null); 8763 char *s = toStringO(self); 8764 ck_assert_str_eq(s, "[1,4]"); 8765 free(s); 8766 // start outside 8767 ck_assert_ptr_eq(removeO(self, 20, -4), NULL); 8768 // end outside 8769 r = removeO(self, 0, 40); 8770 ck_assert_ptr_ne(r, null); 8771 s = toStringO(self); 8772 ck_assert_str_eq(s, "[]"); 8773 free(s); 8774 arange(i,e) { 8775 terminateO(e[i]); 8776 } 8777 // end negative and outside 8778 // remove elements with NULL (set by removeO) 8779 trimO(self); 8780 // add elements to self 8781 r = self->f->pushInt(self, 1); 8782 ck_assert_ptr_ne(r, null); 8783 r = self->f->pushInt(self, 2); 8784 ck_assert_ptr_ne(r, null); 8785 r = self->f->pushInt(self, 3); 8786 ck_assert_ptr_ne(r, null); 8787 r = self->f->pushInt(self, 4); 8788 ck_assert_ptr_ne(r, null); 8789 arange(i,e) { 8790 e[i] = self->f->getAtSmallInt(self, i); 8791 } 8792 ck_assert_ptr_eq(removeO(self, 2, -40), NULL); 8793 s = toStringO(self); 8794 ck_assert_str_eq(s, "[1,2,3,4]"); 8795 free(s); 8796 // end before start 8797 ck_assert_ptr_eq(removeO(self, 3, 2), NULL); 8798 s = toStringO(self); 8799 ck_assert_str_eq(s, "[1,2,3,4]"); 8800 free(s); 8801 // negative start last element 8802 r = removeO(self, -1, 0); 8803 ck_assert_ptr_ne(r, null); 8804 s = toStringO(self); 8805 ck_assert_str_eq(s, "[1,2,3]"); 8806 free(s); 8807 // negative start and outside 8808 r = removeO(self, -10, 1); 8809 ck_assert_ptr_ne(r, null); 8810 s = toStringO(self); 8811 ck_assert_str_eq(s, "[2,3]"); 8812 free(s); 8813 // start = end 8814 r = removeO(self, 1, 1); 8815 ck_assert_ptr_ne(r, null); 8816 s = toStringO(self); 8817 ck_assert_str_eq(s, "[2,3]"); 8818 free(s); 8819 // remove all 8820 r = removeO(self, 0, 0); 8821 ck_assert_ptr_ne(r, null); 8822 s = toStringO(self); 8823 ck_assert_str_eq(s, "[]"); 8824 free(s); 8825 arange(i,e) { 8826 terminateO(e[i]); 8827 } 8828 // empty list 8829 emptyO(self); 8830 ck_assert_ptr_eq(removeO(self, 0, 0), NULL); 8831 ck_assert_ptr_eq(removeO(self, -1, 0), NULL); 8832 terminateO(self); 8833 8834 END_TEST 8835 8836 8837 START_TEST(removeElemSmallArrayT) 8838 8839 smallArrayt* r; 8840 smallArrayt *self = allocG(rtSmallArrayt); 8841 8842 // add elements to self 8843 r = self->f->pushInt(self, 1); 8844 ck_assert_ptr_ne(r, null); 8845 r = self->f->pushInt(self, 2); 8846 ck_assert_ptr_ne(r, null); 8847 r = self->f->pushInt(self, 3); 8848 ck_assert_ptr_ne(r, null); 8849 r = self->f->pushInt(self, 4); 8850 ck_assert_ptr_ne(r, null); 8851 8852 smallIntt *e[2]; 8853 e[0] = self->f->getAtSmallInt(self, 1); 8854 e[1] = self->f->getAtSmallInt(self, 3); 8855 8856 // positive index 8857 r = removeElemO(self,1); 8858 ck_assert_ptr_ne(r, null); 8859 char *s = toStringO(self); 8860 ck_assert_str_eq(s, "[1,3,4]"); 8861 free(s); 8862 // negative index 8863 r = removeElemO(self,-1); 8864 ck_assert_ptr_ne(r, null); 8865 s = toStringO(self); 8866 ck_assert_str_eq(s, "[1,3]"); 8867 free(s); 8868 terminateO(e[0]); 8869 terminateO(e[1]); 8870 // index outside 8871 ck_assert_ptr_eq(removeElemO(self, 20), NULL); 8872 ck_assert_ptr_eq(removeElemO(self, -5), NULL); 8873 // empty list 8874 emptyO(self); 8875 ck_assert_ptr_eq(removeElemO(self, 0), NULL); 8876 ck_assert_ptr_eq(removeElemO(self, -1), NULL); 8877 terminateO(self); 8878 8879 END_TEST 8880 8881 8882 START_TEST(sortSmallArrayT) 8883 8884 smallArrayt* r; 8885 smallArrayt *self = allocG(rtSmallArrayt); 8886 8887 // sort undefined 8888 self->f->pushInt(self, 0); 8889 self->f->pushUndefined(self); 8890 self->f->pushUndefined(self); 8891 self->f->pushUndefined(self); 8892 self->f->pushUndefined(self); 8893 r = sortO(self); 8894 ck_assert_ptr_ne(r, null); 8895 char *s = toStringO(r); 8896 ck_assert_str_eq(s, "[null,null,null,null,0]"); 8897 free(s); 8898 // sort bool 8899 emptyO(self); 8900 self->f->pushBool(self, false); 8901 self->f->pushBool(self, true); 8902 r = sortO(self); 8903 ck_assert_ptr_ne(r, null); 8904 s = toStringO(r); 8905 ck_assert_str_eq(s, "[false,true]"); 8906 free(s); 8907 // sort container 8908 emptyO(self); 8909 pushVoidSmallArrayG(self, &r); 8910 pushVoidSmallArrayG(self, &r); 8911 r = sortO(self); 8912 ck_assert_ptr_ne(r, null); 8913 s = toStringO(r); 8914 ck_assert_str_eq(s, "[\"<data container>\",\"<data container>\"]"); 8915 free(s); 8916 // sort dict 8917 emptyO(self); 8918 smallDictt *d[4]; 8919 arange(i,d) d[i] = allocSmallDict(); 8920 d[0]->f->setInt(d[0], "a", 1); 8921 d[1]->f->setInt(d[1], "a", 0); 8922 d[3]->f->setInt(d[3], "a", 0); 8923 d[3]->f->setInt(d[3], "b", 0); 8924 arange(i,d) self->f->pushNFreeDict(self, d[i]); 8925 r = sortO(self); 8926 ck_assert_ptr_ne(r, null); 8927 s = toStringO(r); 8928 ck_assert_str_eq(s, "[{},{\"a\":0},{\"a\":1},{\"a\":0,\"b\":0}]"); 8929 free(s); 8930 // sort double 8931 emptyO(self); 8932 self->f->pushDouble(self, 0); 8933 self->f->pushDouble(self, 0); 8934 self->f->pushDouble(self, 1); 8935 self->f->pushDouble(self, -1); 8936 r = sortO(self); 8937 ck_assert_ptr_ne(r, null); 8938 s = toStringO(r); 8939 ck_assert_str_eq(s, "[-1.000000e+00,0.000000e+00,0.000000e+00,1.000000e+00]"); 8940 free(s); 8941 // sort Int 8942 emptyO(self); 8943 self->f->pushInt(self, 0); 8944 self->f->pushInt(self, 0); 8945 self->f->pushInt(self, 1); 8946 self->f->pushInt(self, -1); 8947 r = sortO(self); 8948 ck_assert_ptr_ne(r, null); 8949 s = toStringO(r); 8950 ck_assert_str_eq(s, "[-1,0,0,1]"); 8951 free(s); 8952 // sort strings 8953 emptyO(self); 8954 self->f->pushS(self, "bb"); 8955 self->f->pushS(self, "a"); 8956 r = sortO(self); 8957 ck_assert_ptr_ne(r, null); 8958 s = toStringO(r); 8959 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 8960 free(s); 8961 // sort Array 8962 emptyO(self); 8963 smallArrayt *a[4]; 8964 arange(i,a) a[i] = allocSmallArray(); 8965 a[0]->f->pushInt(a[0], 1); 8966 a[1]->f->pushInt(a[1], 0); 8967 a[3]->f->pushInt(a[3], 0); 8968 a[3]->f->pushInt(a[3], 0); 8969 arange(i,a) self->f->pushNFreeArray(self, a[i]); 8970 r = sortO(self); 8971 ck_assert_ptr_ne(r, null); 8972 s = toStringO(r); 8973 ck_assert_str_eq(s, "[[],[0],[1],[0,0]]"); 8974 free(s); 8975 // sort bytes 8976 emptyO(self); 8977 smallBytest *B[4]; 8978 range(i,3) B[i] = allocSmallBytes("12345678", i); 8979 B[3] = allocSmallBytes("0", 1); 8980 arange(i,B) self->f->pushNFreeSmallBytes(self, B[i]); 8981 r = sortO(self); 8982 ck_assert_ptr_ne(r, null); 8983 s = toStringO(r); 8984 ck_assert_str_eq(s, "[[],[0x30],[0x31],[0x31,0x32]]"); 8985 free(s); 8986 // TODO add element and remove some elements 8987 emptyO(self); 8988 self->f->pushInt(self, 0); 8989 self->f->pushInt(self, 0); 8990 self->f->pushInt(self, 1); 8991 self->f->pushInt(self, -1); 8992 smallIntt *i1 = self->f->getAtSmallInt(self, 1); 8993 smallIntt *i2 = self->f->getAtSmallInt(self, 2); 8994 removeO(self, 1, 3); 8995 terminateO(i1); 8996 terminateO(i2); 8997 r = sortO(self); 8998 ck_assert_ptr_ne(r, null); 8999 s = toStringO(r); 9000 ck_assert_str_eq(s, "[-1,0]"); 9001 free(s); 9002 // length 0 9003 emptyO(self); 9004 r = sortO(self); 9005 ck_assert_ptr_eq(r, null); 9006 terminateO(self); 9007 9008 END_TEST 9009 9010 9011 START_TEST(icSortSmallArrayT) 9012 9013 smallArrayt* r; 9014 smallArrayt *self = allocG(rtSmallArrayt); 9015 9016 // sort undefined 9017 self->f->pushInt(self, 0); 9018 self->f->pushUndefined(self); 9019 self->f->pushUndefined(self); 9020 self->f->pushUndefined(self); 9021 self->f->pushUndefined(self); 9022 r = icSortO(self); 9023 ck_assert_ptr_ne(r, null); 9024 char *s = toStringO(r); 9025 ck_assert_str_eq(s, "[null,null,null,null,0]"); 9026 free(s); 9027 // sort bool 9028 emptyO(self); 9029 self->f->pushBool(self, false); 9030 self->f->pushBool(self, true); 9031 r = icSortO(self); 9032 ck_assert_ptr_ne(r, null); 9033 s = toStringO(r); 9034 ck_assert_str_eq(s, "[false,true]"); 9035 free(s); 9036 // sort container 9037 emptyO(self); 9038 pushVoidSmallArrayG(self, &r); 9039 pushVoidSmallArrayG(self, &r); 9040 r = icSortO(self); 9041 ck_assert_ptr_ne(r, null); 9042 s = toStringO(r); 9043 ck_assert_str_eq(s, "[\"<data container>\",\"<data container>\"]"); 9044 free(s); 9045 // sort dict 9046 emptyO(self); 9047 smallDictt *d[4]; 9048 arange(i,d) d[i] = allocSmallDict(); 9049 d[0]->f->setInt(d[0], "a", 1); 9050 d[1]->f->setInt(d[1], "A", 0); 9051 d[3]->f->setInt(d[3], "a", 0); 9052 d[3]->f->setInt(d[3], "b", 0); 9053 arange(i,d) self->f->pushNFreeDict(self, d[i]); 9054 r = icSortO(self); 9055 ck_assert_ptr_ne(r, null); 9056 s = toStringO(r); 9057 ck_assert_str_eq(s, "[{},{\"A\":0},{\"a\":1},{\"a\":0,\"b\":0}]"); 9058 free(s); 9059 // sort double 9060 emptyO(self); 9061 self->f->pushDouble(self, 0); 9062 self->f->pushDouble(self, 0); 9063 self->f->pushDouble(self, 1); 9064 self->f->pushDouble(self, -1); 9065 r = icSortO(self); 9066 ck_assert_ptr_ne(r, null); 9067 s = toStringO(r); 9068 ck_assert_str_eq(s, "[-1.000000e+00,0.000000e+00,0.000000e+00,1.000000e+00]"); 9069 free(s); 9070 // sort Int 9071 emptyO(self); 9072 self->f->pushInt(self, 0); 9073 self->f->pushInt(self, 0); 9074 self->f->pushInt(self, 1); 9075 self->f->pushInt(self, -1); 9076 r = icSortO(self); 9077 ck_assert_ptr_ne(r, null); 9078 s = toStringO(r); 9079 ck_assert_str_eq(s, "[-1,0,0,1]"); 9080 free(s); 9081 // sort strings 9082 emptyO(self); 9083 self->f->pushS(self, "bb"); 9084 self->f->pushS(self, "B"); 9085 r = icSortO(self); 9086 ck_assert_ptr_ne(r, null); 9087 s = toStringO(r); 9088 ck_assert_str_eq(s, "[\"B\",\"bb\"]"); 9089 free(s); 9090 // sort Array 9091 emptyO(self); 9092 smallArrayt *a[4]; 9093 arange(i,a) a[i] = allocSmallArray(); 9094 a[0]->f->pushInt(a[0], 1); 9095 a[1]->f->pushInt(a[1], 0); 9096 a[3]->f->pushInt(a[3], 0); 9097 a[3]->f->pushInt(a[3], 0); 9098 arange(i,a) self->f->pushNFreeArray(self, a[i]); 9099 r = icSortO(self); 9100 ck_assert_ptr_ne(r, null); 9101 s = toStringO(r); 9102 ck_assert_str_eq(s, "[[],[0],[1],[0,0]]"); 9103 free(s); 9104 // sort bytes 9105 emptyO(self); 9106 smallBytest *B[4]; 9107 range(i,3) B[i] = allocSmallBytes("12345678", i); 9108 B[3] = allocSmallBytes("0", 1); 9109 arange(i,B) self->f->pushNFreeSmallBytes(self, B[i]); 9110 r = icSortO(self); 9111 ck_assert_ptr_ne(r, null); 9112 s = toStringO(r); 9113 ck_assert_str_eq(s, "[[],[0x30],[0x31],[0x31,0x32]]"); 9114 free(s); 9115 // TODO add element and remove some elements 9116 emptyO(self); 9117 self->f->pushInt(self, 0); 9118 self->f->pushInt(self, 0); 9119 self->f->pushInt(self, 1); 9120 self->f->pushInt(self, -1); 9121 smallIntt *i1 = self->f->getAtSmallInt(self, 1); 9122 smallIntt *i2 = self->f->getAtSmallInt(self, 2); 9123 removeO(self, 1, 3); 9124 terminateO(i1); 9125 terminateO(i2); 9126 r = icSortO(self); 9127 ck_assert_ptr_ne(r, null); 9128 s = toStringO(r); 9129 ck_assert_str_eq(s, "[-1,0]"); 9130 free(s); 9131 // length 0 9132 emptyO(self); 9133 r = icSortO(self); 9134 ck_assert_ptr_eq(r, null); 9135 terminateO(self); 9136 9137 END_TEST 9138 9139 int sortFOCmp(const void *A, const void *B) { 9140 cast(smallDictt*, a, A); 9141 cast(smallDictt*, b, B); 9142 9143 if (lenO(a) < lenO(b)) 9144 return -1; 9145 else if (lenO(a) == lenO(b)) { 9146 var As = toStringO(a); 9147 var Bs = toStringO(b); 9148 int r = strcmp(As,Bs); 9149 freeManyS(As,Bs); 9150 return r; 9151 } 9152 else 9153 return 1; 9154 } 9155 9156 START_TEST(sortFSmallArrayT) 9157 9158 smallArrayt* r; 9159 smallArrayt *self = allocG(rtSmallArrayt); 9160 9161 // sort dict 9162 smallDictt *d[4]; 9163 arange(i,d) d[i] = allocSmallDict(); 9164 d[0]->f->setInt(d[0], "a", 1); 9165 d[1]->f->setInt(d[1], "a", 0); 9166 d[3]->f->setInt(d[3], "a", 0); 9167 d[3]->f->setInt(d[3], "b", 0); 9168 arange(i,d) self->f->pushNFreeDict(self, d[i]); 9169 r = sortFO(self, sortFOCmp); 9170 ck_assert_ptr_ne(r, null); 9171 char *s = toStringO(r); 9172 ck_assert_str_eq(s, "[{},{\"a\":0},{\"a\":1},{\"a\":0,\"b\":0}]"); 9173 free(s); 9174 // no compare function 9175 r = sortFO(self, NULL); 9176 ck_assert_ptr_eq(r, null); 9177 // empty array 9178 emptyO(self); 9179 r = sortFO(self, sortFOCmp); 9180 ck_assert_ptr_eq(r, null); 9181 terminateO(self); 9182 9183 END_TEST 9184 9185 9186 START_TEST(equalSmallArrayT) 9187 9188 bool r; 9189 smallArrayt *self = allocG(rtSmallArrayt); 9190 smallArrayt *array = allocG(rtSmallArrayt); 9191 9192 // empty arrays 9193 r = equalO(self, array); 9194 ck_assert(r); 9195 // empty self, non empty array 9196 array->f->pushInt(array, 1); 9197 r = equalO(self, array); 9198 ck_assert(!r); 9199 // non empty self, empty array 9200 emptyO(array); 9201 self->f->pushInt(self, 1); 9202 r = equalO(self, array); 9203 ck_assert(!r); 9204 // different lengths 9205 array->f->pushInt(array, 1); 9206 self->f->pushInt(self, 1); 9207 r = equalO(self, array); 9208 ck_assert(!r); 9209 // equal arrays 9210 array->f->pushInt(array, 1); 9211 r = equalO(self, array); 9212 ck_assert(r); 9213 // different int value 9214 array->f->setAtInt(array, 1, 2); 9215 r = equalO(self, array); 9216 ck_assert(!r); 9217 // array same length with a null element in self 9218 smallIntt *i = self->f->getAtSmallInt(self, 1); 9219 removeElemO(self, 1); 9220 terminateO(i); 9221 r = equalO(self, array); 9222 ck_assert(!r); 9223 // array same length with a null element in both arrays 9224 i = array->f->getAtSmallInt(array, 1); 9225 removeElemO(array, 1); 9226 terminateO(i); 9227 r = equalO(self, array); 9228 ck_assert(r); 9229 // elements of different types 9230 self->f->setAtBool(self, 1, true); 9231 array->f->setAtInt(array, 1, 1); 9232 r = equalO(self, array); 9233 ck_assert(!r); 9234 // compare bool 9235 array->f->setAtBool(array, 1, true); 9236 r = equalO(self, array); 9237 ck_assert(r); 9238 array->f->setAtBool(array, 1, false); 9239 r = equalO(self, array); 9240 ck_assert(!r); 9241 // compare dict 9242 createSmallDict(d1); 9243 createSmallDict(d2); 9244 self->f->setAtDict(self, 1, &d1); 9245 array->f->setAtDict(array, 1, &d2); 9246 r = equalO(self, array); 9247 ck_assert(r); 9248 // reuse dict container, the data is in self already 9249 resetO(&d1); 9250 (&d1)->f->setInt(&d1, "a", 1); 9251 self->f->setAtDict(self, 1, &d1); 9252 r = equalO(self, array); 9253 ck_assert(!r); 9254 // compare double 9255 self->f->setAtDouble(self, 1, 0); 9256 array->f->setAtDouble(array, 1, 0); 9257 r = equalO(self, array); 9258 ck_assert(r); 9259 array->f->setAtDouble(array, 1, 10.5); 9260 r = equalO(self, array); 9261 ck_assert(!r); 9262 // compare string 9263 self->f->setAtS(self, 1, ""); 9264 array->f->setAtS(array, 1, ""); 9265 r = equalO(self, array); 9266 ck_assert(r); 9267 array->f->setAtS(array, 1, "NO"); 9268 r = equalO(self, array); 9269 ck_assert(!r); 9270 // compare array elements 9271 createSmallArray(a1); 9272 createSmallArray(a2); 9273 self->f->setAtArray(self, 1, &a1); 9274 array->f->setAtArray(array, 1, &a2); 9275 r = equalO(self, array); 9276 ck_assert(r); 9277 // reuse Array container, the data is in self already 9278 resetO(&a1); 9279 (&a1)->f->pushInt(&a1, 1); 9280 self->f->setAtArray(self, 1, &a1); 9281 r = equalO(self, array); 9282 ck_assert(!r); 9283 // compare bytes 9284 createSmallBytes(b1); 9285 createSmallBytes(b2); 9286 self->f->setAtSmallBytes(self, 1, &b1); 9287 array->f->setAtSmallBytes(array, 1, &b2); 9288 r = equalO(self, array); 9289 ck_assert(r); 9290 // reuse SmallBytes container, the data is in self already 9291 b1.B = null; 9292 pushBufferO(&b1, &self, 2); 9293 self->f->setAtSmallBytes(self, 1, &b1); 9294 r = equalO(self, array); 9295 ck_assert(!r); 9296 // compare data in both smallBytes elements 9297 b2.B = null; 9298 pushBufferO(&b2, (char*)(&self) + 4, 2); 9299 array->f->setAtSmallBytes(array, 1, &b2); 9300 r = equalO(self, array); 9301 ck_assert(!r); 9302 // non smallArray object 9303 terminateO(array); 9304 array = (smallArrayt*) allocSmallInt(2); 9305 r = equalO(self, array); 9306 ck_assert(!r); 9307 // NULL array 9308 r = equalO(self, NULL); 9309 ck_assert(!r); 9310 terminateO(self); 9311 terminateO(array); 9312 9313 END_TEST 9314 9315 9316 START_TEST(equalSmallArraySmallJsonT) 9317 9318 bool r; 9319 smallArrayt *self = allocG(rtSmallArrayt); 9320 smallJsont *array = allocG(rtSmallJsont); 9321 9322 // NULL array 9323 r = self->f->equalSmallJson(self, NULL); 9324 ck_assert(!r); 9325 // compare 9326 r = self->f->equalSmallJson(self, array); 9327 // the smallJson is empty, so the result is false 9328 ck_assert(!r); 9329 // non smallJson object 9330 terminateO(array); 9331 array = (smallJsont*) allocSmallInt(2); 9332 r = self->f->equalSmallJson(self, array); 9333 ck_assert(!r); 9334 terminateO(self); 9335 terminateO(array); 9336 9337 END_TEST 9338 9339 9340 START_TEST(equalSmallArrayArrayT) 9341 9342 bool r; 9343 smallArrayt* self = allocG(rtSmallArrayt); 9344 char ** p2 = NULL; 9345 9346 // empty arrays 9347 r = self->f->equalArray(self, NULL); 9348 ck_assert(r); 9349 // empty self, non empty array 9350 p2 = listCreateS("a"); 9351 r = self->f->equalArray(self, p2); 9352 ck_assert(!r); 9353 // non empty self, empty array 9354 self->f->pushInt(self, 1); 9355 listFreeS(p2); 9356 listEmptyS(p2); 9357 r = self->f->equalArray(self, p2); 9358 ck_assert(!r); 9359 // different lengths 9360 listPushS(&p2, "a"); 9361 self->f->pushInt(self, 2); 9362 r = self->f->equalArray(self, p2); 9363 ck_assert(!r); 9364 // equal arrays 9365 emptyO(self); 9366 self->f->pushS(self, "a"); 9367 r = self->f->equalArray(self, p2); 9368 ck_assert(r); 9369 // not string type in self 9370 self->f->setAtInt(self, 0, 0); 9371 r = self->f->equalArray(self, p2); 9372 ck_assert(!r); 9373 // array same length with a null element in self 9374 smallIntt *i = self->f->getAtSmallInt(self, 0); 9375 terminateO(i); 9376 removeElemO(self, 0); 9377 r = self->f->equalArray(self, p2); 9378 ck_assert(!r); 9379 // different strings 9380 self->f->setAtS(self, 0, "bb"); 9381 r = self->f->equalArray(self, p2); 9382 ck_assert(!r); 9383 terminateO(self); 9384 listFreeS(p2); 9385 9386 9387 END_TEST 9388 9389 9390 START_TEST(equalSmallArrayBaseT) 9391 9392 bool r; 9393 smallArrayt* self = allocG(rtSmallArrayt); 9394 baset* p2 = (baset*) allocG(1); 9395 9396 // empty self array 9397 r = self->f->equalBase(self, p2); 9398 ck_assert(!r); 9399 // NULL 9400 r = self->f->equalBase(self, NULL); 9401 ck_assert(!r); 9402 // not array type 9403 self->f->pushInt(self, 1); 9404 r = self->f->equalBase(self, p2); 9405 ck_assert(!r); 9406 // equal 9407 terminateO(p2); 9408 p2 = (baset*) allocG(rtSmallArrayt); 9409 r = self->f->equalBase(self, p2); 9410 ck_assert(!r); 9411 terminateO(self); 9412 terminateO(p2); 9413 9414 END_TEST 9415 9416 9417 START_TEST(icEqualSmallArrayT) 9418 9419 bool r; 9420 smallArrayt *self = allocG(rtSmallArrayt); 9421 smallArrayt *array = allocG(rtSmallArrayt); 9422 9423 // empty arrays 9424 r = icEqualO(self, array); 9425 ck_assert(r); 9426 // empty self, non empty array 9427 array->f->pushInt(array, 1); 9428 r = icEqualO(self, array); 9429 ck_assert(!r); 9430 // non empty self, empty array 9431 emptyO(array); 9432 self->f->pushInt(self, 1); 9433 r = icEqualO(self, array); 9434 ck_assert(!r); 9435 // different lengths 9436 array->f->pushInt(array, 1); 9437 self->f->pushInt(self, 1); 9438 r = icEqualO(self, array); 9439 ck_assert(!r); 9440 // equal arrays 9441 array->f->pushInt(array, 1); 9442 r = icEqualO(self, array); 9443 ck_assert(r); 9444 // different int value 9445 array->f->setAtInt(array, 1, 2); 9446 r = icEqualO(self, array); 9447 ck_assert(!r); 9448 // array same length with a null element in self 9449 smallIntt *i = self->f->getAtSmallInt(self, 1); 9450 removeElemO(self, 1); 9451 terminateO(i); 9452 r = icEqualO(self, array); 9453 ck_assert(!r); 9454 // array same length with a null element in both arrays 9455 i = array->f->getAtSmallInt(array, 1); 9456 removeElemO(array, 1); 9457 terminateO(i); 9458 r = icEqualO(self, array); 9459 ck_assert(r); 9460 // elements of different types 9461 self->f->setAtBool(self, 1, true); 9462 array->f->setAtInt(array, 1, 1); 9463 r = icEqualO(self, array); 9464 ck_assert(!r); 9465 // compare bool 9466 array->f->setAtBool(array, 1, true); 9467 r = icEqualO(self, array); 9468 ck_assert(r); 9469 array->f->setAtBool(array, 1, false); 9470 r = icEqualO(self, array); 9471 ck_assert(!r); 9472 // compare dict 9473 createSmallDict(d1); 9474 createSmallDict(d2); 9475 self->f->setAtDict(self, 1, &d1); 9476 array->f->setAtDict(array, 1, &d2); 9477 r = icEqualO(self, array); 9478 ck_assert(r); 9479 // reuse dict container, the data is in self already 9480 resetO(&d1); 9481 (&d1)->f->setInt(&d1, "a", 1); 9482 self->f->setAtDict(self, 1, &d1); 9483 r = icEqualO(self, array); 9484 ck_assert(!r); 9485 // compare double 9486 self->f->setAtDouble(self, 1, 0); 9487 array->f->setAtDouble(array, 1, 0); 9488 r = icEqualO(self, array); 9489 ck_assert(r); 9490 array->f->setAtDouble(array, 1, 10.5); 9491 r = icEqualO(self, array); 9492 ck_assert(!r); 9493 // compare string 9494 self->f->setAtS(self, 1, "a"); 9495 array->f->setAtS(array, 1, "A"); 9496 r = icEqualO(self, array); 9497 ck_assert(r); 9498 array->f->setAtS(array, 1, "NO"); 9499 r = icEqualO(self, array); 9500 ck_assert(!r); 9501 // compare array elements 9502 createSmallArray(a1); 9503 createSmallArray(a2); 9504 self->f->setAtArray(self, 1, &a1); 9505 array->f->setAtArray(array, 1, &a2); 9506 r = icEqualO(self, array); 9507 ck_assert(r); 9508 // reuse Array container, the data is in self already 9509 resetO(&a1); 9510 (&a1)->f->pushInt(&a1, 1); 9511 self->f->setAtArray(self, 1, &a1); 9512 r = icEqualO(self, array); 9513 ck_assert(!r); 9514 // compare bytes 9515 createSmallBytes(b1); 9516 createSmallBytes(b2); 9517 self->f->setAtSmallBytes(self, 1, &b1); 9518 array->f->setAtSmallBytes(array, 1, &b2); 9519 r = icEqualO(self, array); 9520 ck_assert(r); 9521 // reuse SmallBytes container, the data is in self already 9522 b1.B = null; 9523 pushBufferO(&b1, &self, 2); 9524 self->f->setAtSmallBytes(self, 1, &b1); 9525 r = icEqualO(self, array); 9526 ck_assert(!r); 9527 // compare data in both smallBytes elements 9528 b2.B = null; 9529 pushBufferO(&b2, &self + 4, 2); 9530 array->f->setAtSmallBytes(array, 1, &b2); 9531 r = icEqualO(self, array); 9532 ck_assert(!r); 9533 // non smallArray object 9534 terminateO(array); 9535 array = (smallArrayt*) allocSmallInt(2); 9536 r = icEqualO(self, array); 9537 ck_assert(!r); 9538 // NULL array 9539 r = icEqualO(self, NULL); 9540 ck_assert(!r); 9541 terminateO(self); 9542 terminateO(array); 9543 9544 END_TEST 9545 9546 9547 START_TEST(icEqualSmallArraySmallJsonT) 9548 9549 bool r; 9550 smallArrayt *self = allocG(rtSmallArrayt); 9551 smallJsont *array = allocG(rtSmallJsont); 9552 9553 // NULL array 9554 r = self->f->icEqualSmallJson(self, NULL); 9555 ck_assert(!r); 9556 // json is not array 9557 r = self->f->icEqualSmallJson(self, array); 9558 ck_assert(!r); 9559 // compare 9560 self->f->pushS(self, "A"); 9561 array->f->pushS(array, "a"); 9562 r = self->f->icEqualSmallJson(self, array); 9563 ck_assert(r); 9564 // non smallJson object 9565 terminateO(array); 9566 array = (smallJsont*) allocSmallInt(2); 9567 r = self->f->icEqualSmallJson(self, array); 9568 ck_assert(!r); 9569 terminateO(self); 9570 terminateO(array); 9571 9572 END_TEST 9573 9574 9575 START_TEST(icEqualSmallArrayArrayT) 9576 9577 bool r; 9578 smallArrayt* self = allocG(rtSmallArrayt); 9579 char ** p2 = NULL; 9580 9581 // empty arrays 9582 r = self->f->icEqualArray(self, NULL); 9583 ck_assert(r); 9584 // empty self, non empty array 9585 p2 = listCreateS("a"); 9586 r = self->f->icEqualArray(self, p2); 9587 ck_assert(!r); 9588 // non empty self, empty array 9589 self->f->pushInt(self, 1); 9590 listFreeS(p2); 9591 listEmptyS(p2); 9592 r = self->f->icEqualArray(self, p2); 9593 ck_assert(!r); 9594 // different lengths 9595 listPushS(&p2, "a"); 9596 self->f->pushInt(self, 2); 9597 r = self->f->icEqualArray(self, p2); 9598 ck_assert(!r); 9599 // equal arrays 9600 emptyO(self); 9601 self->f->pushS(self, "A"); 9602 r = self->f->icEqualArray(self, p2); 9603 ck_assert(r); 9604 // not string type in self 9605 self->f->setAtInt(self, 0, 0); 9606 r = self->f->icEqualArray(self, p2); 9607 ck_assert(!r); 9608 // array same length with a null element in self 9609 smallIntt *i = self->f->getAtSmallInt(self, 0); 9610 terminateO(i); 9611 removeElemO(self, 0); 9612 r = self->f->icEqualArray(self, p2); 9613 ck_assert(!r); 9614 // different strings 9615 self->f->setAtS(self, 0, "bb"); 9616 r = self->f->icEqualArray(self, p2); 9617 ck_assert(!r); 9618 terminateO(self); 9619 listFreeS(p2); 9620 9621 END_TEST 9622 9623 9624 START_TEST(icEqualSmallArrayBaseT) 9625 9626 bool r; 9627 smallArrayt* self = allocG(rtSmallArrayt); 9628 baset* p2 = (baset*) allocG(1); 9629 9630 // empty self array 9631 r = self->f->icEqualBase(self, p2); 9632 ck_assert(!r); 9633 // NULL 9634 r = self->f->icEqualBase(self, NULL); 9635 ck_assert(!r); 9636 // not array type 9637 self->f->pushInt(self, 1); 9638 r = self->f->icEqualBase(self, p2); 9639 ck_assert(!r); 9640 // equal 9641 terminateO(p2); 9642 self->f->setAtS(self, 0, "a"); 9643 smallArrayt *a = allocG(rtSmallArrayt); 9644 a->f->pushS(a, "A"); 9645 p2 = (baset*) a; 9646 r = self->f->icEqualBase(self, p2); 9647 ck_assert(r); 9648 terminateO(self); 9649 terminateO(p2); 9650 9651 END_TEST 9652 9653 9654 START_TEST(getAtUndefinedSmallArrayT) 9655 9656 undefinedt* r; 9657 smallArrayt *self = allocG(rtSmallArrayt); 9658 smallArrayt *r2; 9659 9660 // add elements to self 9661 r2 = self->f->pushInt(self, 1); 9662 ck_assert_ptr_ne(r2, null); 9663 r2 = self->f->pushUndefined(self); 9664 ck_assert_ptr_ne(r2, null); 9665 r2 = self->f->pushInt(self, 3); 9666 ck_assert_ptr_ne(r2, null); 9667 r2 = self->f->pushUndefined(self); 9668 ck_assert_ptr_ne(r2, null); 9669 9670 // positive index 9671 r = self->f->getAtUndefined(self,1); 9672 ck_assert_ptr_ne(r, null); 9673 char *s = toStringO(r); 9674 finishO(r); 9675 ck_assert_str_eq(s, "null"); 9676 free(s); 9677 s = toStringO(self); 9678 ck_assert_str_eq(s, "[1,null,3,null]"); 9679 free(s); 9680 // negative index 9681 r = self->f->getAtUndefined(self,-1); 9682 ck_assert_ptr_ne(r, null); 9683 s = toStringO(r); 9684 finishO(r); 9685 ck_assert_str_eq(s, "null"); 9686 free(s); 9687 s = toStringO(self); 9688 ck_assert_str_eq(s, "[1,null,3,null]"); 9689 free(s); 9690 // wrong object type 9691 createSmallInt(I); 9692 setValG(&I, 11); 9693 r2 = self->f->pushSmallInt(self, &I); 9694 ck_assert_ptr_ne(r2, null); 9695 r = self->f->getAtUndefined(self,-1); 9696 ck_assert_ptr_eq(r, null); 9697 s = toStringO(self); 9698 ck_assert_str_eq(s, "[1,null,3,null,11]"); 9699 free(s); 9700 // index outside 9701 ck_assert_ptr_eq(self->f->getAtUndefined(self, 20), NULL); 9702 ck_assert_ptr_eq(self->f->getAtUndefined(self, -6), NULL); 9703 // empty list 9704 emptyO(self); 9705 ck_assert_ptr_eq(self->f->getAtUndefined(self, 0), NULL); 9706 ck_assert_ptr_eq(self->f->getAtUndefined(self, -1), NULL); 9707 // get empty slot in array 9708 r2 = self->f->pushUndefined(self); 9709 ck_assert_ptr_ne(r2, null); 9710 delElemO(self,0); 9711 ck_assert_ptr_eq(self->f->getAtUndefined(self, 0), NULL); 9712 terminateO(self); 9713 9714 END_TEST 9715 9716 9717 START_TEST(getAtBoolSmallArrayT) 9718 9719 bool r; 9720 smallArrayt *self = allocG(rtSmallArrayt); 9721 smallArrayt *r2; 9722 9723 // add elements to self 9724 r2 = self->f->pushInt(self, 1); 9725 ck_assert_ptr_ne(r2, null); 9726 r2 = self->f->pushBool(self, TRUE); 9727 ck_assert_ptr_ne(r2, null); 9728 r2 = self->f->pushInt(self, 3); 9729 ck_assert_ptr_ne(r2, null); 9730 r2 = self->f->pushBool(self, TRUE); 9731 ck_assert_ptr_ne(r2, null); 9732 9733 // positive index 9734 r = self->f->getAtBool(self,1); 9735 ck_assert(r); 9736 char *s = toStringO(self); 9737 ck_assert_str_eq(s, "[1,true,3,true]"); 9738 free(s); 9739 // negative index 9740 r = self->f->getAtBool(self,-1); 9741 ck_assert(r); 9742 s = toStringO(self); 9743 ck_assert_str_eq(s, "[1,true,3,true]"); 9744 free(s); 9745 // wrong object type 9746 createSmallInt(I); 9747 setValG(&I, 11); 9748 r2 = self->f->pushSmallInt(self, &I); 9749 r = self->f->getAtBool(self,-1); 9750 ck_assert(!r); 9751 s = toStringO(self); 9752 ck_assert_str_eq(s, "[1,true,3,true,11]"); 9753 free(s); 9754 // wrong object type of another user class 9755 // User classes are stored in containers transparently 9756 createAllocateSmallInt(ip); 9757 ip->type = "anothertype"; 9758 setValG(ip, 11); 9759 r2 = self->f->push(self, (baset*)ip); 9760 ck_assert_ptr_ne(r2, null); 9761 r = self->f->getAtBool(self,-1); 9762 ck_assert(!r); 9763 s = toStringO(self); 9764 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 9765 free(s); 9766 // index outside 9767 ck_assert(!self->f->getAtBool(self, 20)); 9768 ck_assert(!self->f->getAtBool(self, -7)); 9769 // empty list 9770 emptyO(self); 9771 ck_assert(!self->f->getAtBool(self, 0)); 9772 ck_assert(!self->f->getAtBool(self, -1)); 9773 terminateO(self); 9774 9775 END_TEST 9776 9777 9778 START_TEST(getAtBoolPSmallArrayT) 9779 9780 bool* r; 9781 smallArrayt *self = allocG(rtSmallArrayt); 9782 smallArrayt *r2; 9783 9784 // add elements to self 9785 r2 = self->f->pushInt(self, 1); 9786 ck_assert_ptr_ne(r2, null); 9787 r2 = self->f->pushBool(self, TRUE); 9788 ck_assert_ptr_ne(r2, null); 9789 r2 = self->f->pushInt(self, 3); 9790 ck_assert_ptr_ne(r2, null); 9791 r2 = self->f->pushBool(self, TRUE); 9792 ck_assert_ptr_ne(r2, null); 9793 9794 // positive index 9795 r = self->f->getAtBoolP(self,1); 9796 ck_assert_ptr_ne(r, null); 9797 ck_assert(*r); 9798 char *s = toStringO(self); 9799 ck_assert_str_eq(s, "[1,true,3,true]"); 9800 free(s); 9801 // negative index 9802 r = self->f->getAtBoolP(self,-1); 9803 ck_assert_ptr_ne(r, null); 9804 ck_assert(*r); 9805 s = toStringO(self); 9806 ck_assert_str_eq(s, "[1,true,3,true]"); 9807 free(s); 9808 // wrong object type 9809 createSmallInt(I); 9810 setValG(&I, 11); 9811 r2 = self->f->pushSmallInt(self, &I); 9812 r = self->f->getAtBoolP(self,-1); 9813 ck_assert_ptr_eq(r, null); 9814 s = toStringO(self); 9815 ck_assert_str_eq(s, "[1,true,3,true,11]"); 9816 free(s); 9817 // wrong object type of another user class 9818 // User classes are stored in containers transparently 9819 createAllocateSmallInt(ip); 9820 ip->type = "anothertype"; 9821 setValG(ip, 11); 9822 r2 = self->f->push(self, (baset*)ip); 9823 ck_assert_ptr_ne(r2, null); 9824 r = self->f->getAtBoolP(self,-1); 9825 ck_assert_ptr_eq(r, null); 9826 s = toStringO(self); 9827 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 9828 free(s); 9829 // index outside 9830 ck_assert(!self->f->getAtBoolP(self, 20)); 9831 ck_assert(!self->f->getAtBoolP(self, -7)); 9832 // empty list 9833 emptyO(self); 9834 ck_assert(!self->f->getAtBoolP(self, 0)); 9835 ck_assert(!self->f->getAtBoolP(self, -1)); 9836 terminateO(self); 9837 9838 END_TEST 9839 9840 9841 START_TEST(getAtDoubleSmallArrayT) 9842 9843 double r; 9844 smallArrayt *self = allocG(rtSmallArrayt); 9845 smallArrayt *r2; 9846 9847 // add elements to self 9848 r2 = self->f->pushInt(self, 1); 9849 ck_assert_ptr_ne(r2, null); 9850 r2 = self->f->pushDouble(self, 2); 9851 ck_assert_ptr_ne(r2, null); 9852 r2 = self->f->pushInt(self, 3); 9853 ck_assert_ptr_ne(r2, null); 9854 r2 = self->f->pushDouble(self, 4); 9855 ck_assert_ptr_ne(r2, null); 9856 9857 // positive index 9858 r = self->f->getAtDouble(self,1); 9859 ck_assert(r==2); 9860 char *s = toStringO(self); 9861 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 9862 free(s); 9863 // negative index 9864 r = self->f->getAtDouble(self,-1); 9865 ck_assert(r==4); 9866 s = toStringO(self); 9867 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 9868 free(s); 9869 // wrong object type 9870 createSmallInt(I); 9871 setValG(&I, 11); 9872 r2 = self->f->pushSmallInt(self, &I); 9873 r = self->f->getAtDouble(self,-1); 9874 ck_assert(!r); 9875 s = toStringO(self); 9876 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11]"); 9877 free(s); 9878 // wrong object type of another user class 9879 // User classes are stored in containers transparently 9880 createAllocateSmallInt(ip); 9881 ip->type = "anothertype"; 9882 setValG(ip, 11); 9883 r2 = self->f->push(self, (baset*)ip); 9884 ck_assert_ptr_ne(r2, null); 9885 r = self->f->getAtDouble(self,-1); 9886 ck_assert(!r); 9887 s = toStringO(self); 9888 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11,\"<data container>\"]"); 9889 free(s); 9890 // index outside 9891 ck_assert(!self->f->getAtDouble(self, 20)); 9892 ck_assert(!self->f->getAtDouble(self, -7)); 9893 // empty list 9894 emptyO(self); 9895 ck_assert(!self->f->getAtDouble(self, 0)); 9896 ck_assert(!self->f->getAtDouble(self, -1)); 9897 terminateO(self); 9898 9899 END_TEST 9900 9901 9902 START_TEST(getAtDoublePSmallArrayT) 9903 9904 double* r; 9905 smallArrayt *self = allocG(rtSmallArrayt); 9906 smallArrayt *r2; 9907 9908 // add elements to self 9909 r2 = self->f->pushInt(self, 1); 9910 ck_assert_ptr_ne(r2, null); 9911 r2 = self->f->pushDouble(self, 2); 9912 ck_assert_ptr_ne(r2, null); 9913 r2 = self->f->pushInt(self, 3); 9914 ck_assert_ptr_ne(r2, null); 9915 r2 = self->f->pushDouble(self, 4); 9916 ck_assert_ptr_ne(r2, null); 9917 9918 // positive index 9919 r = self->f->getAtDoubleP(self,1); 9920 ck_assert_ptr_ne(r, null); 9921 ck_assert(*r==2); 9922 char *s = toStringO(self); 9923 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 9924 free(s); 9925 // negative index 9926 r = self->f->getAtDoubleP(self,-1); 9927 ck_assert_ptr_ne(r, null); 9928 ck_assert(*r==4); 9929 s = toStringO(self); 9930 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 9931 free(s); 9932 // wrong object type 9933 createSmallInt(I); 9934 setValG(&I, 11); 9935 r2 = self->f->pushSmallInt(self, &I); 9936 r = self->f->getAtDoubleP(self,-1); 9937 ck_assert_ptr_eq(r, null); 9938 s = toStringO(self); 9939 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11]"); 9940 free(s); 9941 // wrong object type of another user class 9942 // User classes are stored in containers transparently 9943 createAllocateSmallInt(ip); 9944 ip->type = "anothertype"; 9945 setValG(ip, 11); 9946 r2 = self->f->push(self, (baset*)ip); 9947 ck_assert_ptr_ne(r2, null); 9948 r = self->f->getAtDoubleP(self,-1); 9949 ck_assert_ptr_eq(r, null); 9950 s = toStringO(self); 9951 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11,\"<data container>\"]"); 9952 free(s); 9953 // index outside 9954 ck_assert(!self->f->getAtDoubleP(self, 20)); 9955 ck_assert(!self->f->getAtDoubleP(self, -7)); 9956 // empty list 9957 emptyO(self); 9958 ck_assert(!self->f->getAtDoubleP(self, 0)); 9959 ck_assert(!self->f->getAtDoubleP(self, -1)); 9960 terminateO(self); 9961 9962 END_TEST 9963 9964 9965 START_TEST(getAtIntSmallArrayT) 9966 9967 int64_t r; 9968 smallArrayt *self = allocG(rtSmallArrayt); 9969 smallArrayt *r2; 9970 9971 // add elements to self 9972 r2 = self->f->pushInt(self, 1); 9973 ck_assert_ptr_ne(r2, null); 9974 r2 = self->f->pushInt(self, 2); 9975 ck_assert_ptr_ne(r2, null); 9976 r2 = self->f->pushInt(self, 3); 9977 ck_assert_ptr_ne(r2, null); 9978 r2 = self->f->pushInt(self, 4); 9979 ck_assert_ptr_ne(r2, null); 9980 9981 // positive index 9982 r = self->f->getAtInt(self,1); 9983 ck_assert(r==2); 9984 char *s = toStringO(self); 9985 ck_assert_str_eq(s, "[1,2,3,4]"); 9986 free(s); 9987 // negative index 9988 r = self->f->getAtInt(self,-1); 9989 ck_assert(r==4); 9990 s = toStringO(self); 9991 ck_assert_str_eq(s, "[1,2,3,4]"); 9992 free(s); 9993 // wrong object type 9994 createSmallDouble(I); 9995 setValG(&I, 11); 9996 r2 = self->f->pushSmallDouble(self, &I); 9997 r = self->f->getAtInt(self,-1); 9998 ck_assert(!r); 9999 s = toStringO(self); 10000 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10001 free(s); 10002 // wrong object type of another user class 10003 // User classes are stored in containers transparently 10004 createAllocateSmallInt(ip); 10005 ip->type = "anothertype"; 10006 setValG(ip, 11); 10007 r2 = self->f->push(self, (baset*)ip); 10008 ck_assert_ptr_ne(r2, null); 10009 r = self->f->getAtInt(self,-1); 10010 ck_assert(!r); 10011 s = toStringO(self); 10012 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10013 free(s); 10014 // index outside 10015 ck_assert(!self->f->getAtInt(self, 20)); 10016 ck_assert(!self->f->getAtInt(self, -7)); 10017 // empty list 10018 emptyO(self); 10019 ck_assert(!self->f->getAtInt(self, 0)); 10020 ck_assert(!self->f->getAtInt(self, -1)); 10021 terminateO(self); 10022 10023 END_TEST 10024 10025 10026 START_TEST(getAtIntPSmallArrayT) 10027 10028 int64_t* r; 10029 smallArrayt *self = allocG(rtSmallArrayt); 10030 smallArrayt *r2; 10031 10032 // add elements to self 10033 r2 = self->f->pushInt(self, 1); 10034 ck_assert_ptr_ne(r2, null); 10035 r2 = self->f->pushInt(self, 2); 10036 ck_assert_ptr_ne(r2, null); 10037 r2 = self->f->pushInt(self, 3); 10038 ck_assert_ptr_ne(r2, null); 10039 r2 = self->f->pushInt(self, 4); 10040 ck_assert_ptr_ne(r2, null); 10041 10042 // positive index 10043 r = self->f->getAtIntP(self,1); 10044 ck_assert_ptr_ne(r, null); 10045 ck_assert(*r==2); 10046 char *s = toStringO(self); 10047 ck_assert_str_eq(s, "[1,2,3,4]"); 10048 free(s); 10049 // negative index 10050 r = self->f->getAtIntP(self,-1); 10051 ck_assert_ptr_ne(r, null); 10052 ck_assert(*r==4); 10053 s = toStringO(self); 10054 ck_assert_str_eq(s, "[1,2,3,4]"); 10055 free(s); 10056 // wrong object type 10057 createSmallDouble(I); 10058 setValG(&I, 11); 10059 r2 = self->f->pushSmallDouble(self, &I); 10060 r = self->f->getAtIntP(self,-1); 10061 ck_assert_ptr_eq(r, null); 10062 s = toStringO(self); 10063 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10064 free(s); 10065 // wrong object type of another user class 10066 // User classes are stored in containers transparently 10067 createAllocateSmallInt(ip); 10068 ip->type = "anothertype"; 10069 setValG(ip, 11); 10070 r2 = self->f->push(self, (baset*)ip); 10071 ck_assert_ptr_ne(r2, null); 10072 r = self->f->getAtIntP(self,-1); 10073 ck_assert_ptr_eq(r, null); 10074 s = toStringO(self); 10075 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10076 free(s); 10077 // index outside 10078 ck_assert(!self->f->getAtIntP(self, 20)); 10079 ck_assert(!self->f->getAtIntP(self, -7)); 10080 // empty list 10081 emptyO(self); 10082 ck_assert(!self->f->getAtIntP(self, 0)); 10083 ck_assert(!self->f->getAtIntP(self, -1)); 10084 terminateO(self); 10085 10086 END_TEST 10087 10088 10089 START_TEST(getAtInt32SmallArrayT) 10090 10091 int32_t r; 10092 smallArrayt *self = allocG(rtSmallArrayt); 10093 smallArrayt *r2; 10094 10095 // add elements to self 10096 r2 = self->f->pushInt(self, 1); 10097 ck_assert_ptr_ne(r2, null); 10098 r2 = self->f->pushInt(self, 2); 10099 ck_assert_ptr_ne(r2, null); 10100 r2 = self->f->pushInt(self, 3); 10101 ck_assert_ptr_ne(r2, null); 10102 r2 = self->f->pushInt(self, 4); 10103 ck_assert_ptr_ne(r2, null); 10104 10105 // positive index 10106 r = self->f->getAtInt32(self,1); 10107 ck_assert(r==2); 10108 char *s = toStringO(self); 10109 ck_assert_str_eq(s, "[1,2,3,4]"); 10110 free(s); 10111 // negative index 10112 r = self->f->getAtInt32(self,-1); 10113 ck_assert(r==4); 10114 s = toStringO(self); 10115 ck_assert_str_eq(s, "[1,2,3,4]"); 10116 free(s); 10117 // wrong object type 10118 createSmallDouble(I); 10119 setValG(&I, 11); 10120 r2 = self->f->pushSmallDouble(self, &I); 10121 r = self->f->getAtInt32(self,-1); 10122 ck_assert(!r); 10123 s = toStringO(self); 10124 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10125 free(s); 10126 // wrong object type of another user class 10127 // User classes are stored in containers transparently 10128 createAllocateSmallInt(ip); 10129 ip->type = "anothertype"; 10130 setValG(ip, 11); 10131 r2 = self->f->push(self, (baset*)ip); 10132 ck_assert_ptr_ne(r2, null); 10133 r = self->f->getAtInt32(self,-1); 10134 ck_assert(!r); 10135 s = toStringO(self); 10136 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10137 free(s); 10138 // index outside 10139 ck_assert(!self->f->getAtInt32(self, 20)); 10140 ck_assert(!self->f->getAtInt32(self, -7)); 10141 // empty list 10142 emptyO(self); 10143 ck_assert(!self->f->getAtInt32(self, 0)); 10144 ck_assert(!self->f->getAtInt32(self, -1)); 10145 terminateO(self); 10146 10147 END_TEST 10148 10149 10150 START_TEST(getAtInt32PSmallArrayT) 10151 10152 int32_t* r; 10153 smallArrayt *self = allocG(rtSmallArrayt); 10154 smallArrayt *r2; 10155 10156 // add elements to self 10157 r2 = self->f->pushInt(self, 1); 10158 ck_assert_ptr_ne(r2, null); 10159 r2 = self->f->pushInt(self, 2); 10160 ck_assert_ptr_ne(r2, null); 10161 r2 = self->f->pushInt(self, 3); 10162 ck_assert_ptr_ne(r2, null); 10163 r2 = self->f->pushInt(self, 4); 10164 ck_assert_ptr_ne(r2, null); 10165 10166 // positive index 10167 r = self->f->getAtInt32P(self,1); 10168 ck_assert_ptr_ne(r, null); 10169 ck_assert(*r==2); 10170 char *s = toStringO(self); 10171 ck_assert_str_eq(s, "[1,2,3,4]"); 10172 free(s); 10173 // negative index 10174 r = self->f->getAtInt32P(self,-1); 10175 ck_assert_ptr_ne(r, null); 10176 ck_assert(*r==4); 10177 s = toStringO(self); 10178 ck_assert_str_eq(s, "[1,2,3,4]"); 10179 free(s); 10180 // wrong object type 10181 createSmallDouble(I); 10182 setValG(&I, 11); 10183 r2 = self->f->pushSmallDouble(self, &I); 10184 r = self->f->getAtInt32P(self,-1); 10185 ck_assert_ptr_eq(r, null); 10186 s = toStringO(self); 10187 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10188 free(s); 10189 // wrong object type of another user class 10190 // User classes are stored in containers transparently 10191 createAllocateSmallInt(ip); 10192 ip->type = "anothertype"; 10193 setValG(ip, 11); 10194 r2 = self->f->push(self, (baset*)ip); 10195 ck_assert_ptr_ne(r2, null); 10196 r = self->f->getAtInt32P(self,-1); 10197 ck_assert_ptr_eq(r, null); 10198 s = toStringO(self); 10199 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10200 free(s); 10201 // index outside 10202 ck_assert(!self->f->getAtInt32P(self, 20)); 10203 ck_assert(!self->f->getAtInt32P(self, -7)); 10204 // empty list 10205 emptyO(self); 10206 ck_assert(!self->f->getAtInt32P(self, 0)); 10207 ck_assert(!self->f->getAtInt32P(self, -1)); 10208 terminateO(self); 10209 10210 END_TEST 10211 10212 10213 START_TEST(getAtUintSmallArrayT) 10214 10215 uint64_t r; 10216 smallArrayt *self = allocG(rtSmallArrayt); 10217 smallArrayt *r2; 10218 10219 // add elements to self 10220 r2 = self->f->pushInt(self, 1); 10221 ck_assert_ptr_ne(r2, null); 10222 r2 = self->f->pushInt(self, 2); 10223 ck_assert_ptr_ne(r2, null); 10224 r2 = self->f->pushInt(self, 3); 10225 ck_assert_ptr_ne(r2, null); 10226 r2 = self->f->pushInt(self, 4); 10227 ck_assert_ptr_ne(r2, null); 10228 10229 // positive index 10230 r = self->f->getAtUint(self,1); 10231 ck_assert(r==2); 10232 char *s = toStringO(self); 10233 ck_assert_str_eq(s, "[1,2,3,4]"); 10234 free(s); 10235 // negative index 10236 r = self->f->getAtUint(self,-1); 10237 ck_assert(r==4); 10238 s = toStringO(self); 10239 ck_assert_str_eq(s, "[1,2,3,4]"); 10240 free(s); 10241 // wrong object type 10242 createSmallDouble(I); 10243 setValG(&I, 11); 10244 r2 = self->f->pushSmallDouble(self, &I); 10245 r = self->f->getAtUint(self,-1); 10246 ck_assert(!r); 10247 s = toStringO(self); 10248 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10249 free(s); 10250 // wrong object type of another user class 10251 // User classes are stored in containers transparently 10252 createAllocateSmallInt(ip); 10253 ip->type = "anothertype"; 10254 setValG(ip, 11); 10255 r2 = self->f->push(self, (baset*)ip); 10256 ck_assert_ptr_ne(r2, null); 10257 r = self->f->getAtUint(self,-1); 10258 ck_assert(!r); 10259 s = toStringO(self); 10260 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10261 free(s); 10262 // index outside 10263 ck_assert(!self->f->getAtUint(self, 20)); 10264 ck_assert(!self->f->getAtUint(self, -7)); 10265 // empty list 10266 emptyO(self); 10267 ck_assert(!self->f->getAtUint(self, 0)); 10268 ck_assert(!self->f->getAtUint(self, -1)); 10269 terminateO(self); 10270 10271 END_TEST 10272 10273 10274 START_TEST(getAtUintPSmallArrayT) 10275 10276 uint64_t* r; 10277 smallArrayt *self = allocG(rtSmallArrayt); 10278 smallArrayt *r2; 10279 10280 // add elements to self 10281 r2 = self->f->pushInt(self, 1); 10282 ck_assert_ptr_ne(r2, null); 10283 r2 = self->f->pushInt(self, 2); 10284 ck_assert_ptr_ne(r2, null); 10285 r2 = self->f->pushInt(self, 3); 10286 ck_assert_ptr_ne(r2, null); 10287 r2 = self->f->pushInt(self, 4); 10288 ck_assert_ptr_ne(r2, null); 10289 10290 // positive index 10291 r = self->f->getAtUintP(self,1); 10292 ck_assert_ptr_ne(r, null); 10293 ck_assert(*r==2); 10294 char *s = toStringO(self); 10295 ck_assert_str_eq(s, "[1,2,3,4]"); 10296 free(s); 10297 // negative index 10298 r = self->f->getAtUintP(self,-1); 10299 ck_assert_ptr_ne(r, null); 10300 ck_assert(*r==4); 10301 s = toStringO(self); 10302 ck_assert_str_eq(s, "[1,2,3,4]"); 10303 free(s); 10304 // wrong object type 10305 createSmallDouble(I); 10306 setValG(&I, 11); 10307 r2 = self->f->pushSmallDouble(self, &I); 10308 r = self->f->getAtUintP(self,-1); 10309 ck_assert_ptr_eq(r, null); 10310 s = toStringO(self); 10311 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10312 free(s); 10313 // wrong object type of another user class 10314 // User classes are stored in containers transparently 10315 createAllocateSmallInt(ip); 10316 ip->type = "anothertype"; 10317 setValG(ip, 11); 10318 r2 = self->f->push(self, (baset*)ip); 10319 ck_assert_ptr_ne(r2, null); 10320 r = self->f->getAtUintP(self,-1); 10321 ck_assert_ptr_eq(r, null); 10322 s = toStringO(self); 10323 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10324 free(s); 10325 // index outside 10326 ck_assert(!self->f->getAtUintP(self, 20)); 10327 ck_assert(!self->f->getAtUintP(self, -7)); 10328 // empty list 10329 emptyO(self); 10330 ck_assert(!self->f->getAtUintP(self, 0)); 10331 ck_assert(!self->f->getAtUintP(self, -1)); 10332 terminateO(self); 10333 10334 END_TEST 10335 10336 10337 START_TEST(getAtUint32SmallArrayT) 10338 10339 uint32_t r; 10340 smallArrayt *self = allocG(rtSmallArrayt); 10341 smallArrayt *r2; 10342 10343 // add elements to self 10344 r2 = self->f->pushInt(self, 1); 10345 ck_assert_ptr_ne(r2, null); 10346 r2 = self->f->pushInt(self, 2); 10347 ck_assert_ptr_ne(r2, null); 10348 r2 = self->f->pushInt(self, 3); 10349 ck_assert_ptr_ne(r2, null); 10350 r2 = self->f->pushInt(self, 4); 10351 ck_assert_ptr_ne(r2, null); 10352 10353 // positive index 10354 r = self->f->getAtUint32(self,1); 10355 ck_assert(r==2); 10356 char *s = toStringO(self); 10357 ck_assert_str_eq(s, "[1,2,3,4]"); 10358 free(s); 10359 // negative index 10360 r = self->f->getAtUint32(self,-1); 10361 ck_assert(r==4); 10362 s = toStringO(self); 10363 ck_assert_str_eq(s, "[1,2,3,4]"); 10364 free(s); 10365 // wrong object type 10366 createSmallDouble(I); 10367 setValG(&I, 11); 10368 r2 = self->f->pushSmallDouble(self, &I); 10369 r = self->f->getAtUint32(self,-1); 10370 ck_assert(!r); 10371 s = toStringO(self); 10372 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10373 free(s); 10374 // wrong object type of another user class 10375 // User classes are stored in containers transparently 10376 createAllocateSmallInt(ip); 10377 ip->type = "anothertype"; 10378 setValG(ip, 11); 10379 r2 = self->f->push(self, (baset*)ip); 10380 ck_assert_ptr_ne(r2, null); 10381 r = self->f->getAtUint32(self,-1); 10382 ck_assert(!r); 10383 s = toStringO(self); 10384 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10385 free(s); 10386 // index outside 10387 ck_assert(!self->f->getAtUint32(self, 20)); 10388 ck_assert(!self->f->getAtUint32(self, -7)); 10389 // empty list 10390 emptyO(self); 10391 ck_assert(!self->f->getAtUint32(self, 0)); 10392 ck_assert(!self->f->getAtUint32(self, -1)); 10393 terminateO(self); 10394 10395 END_TEST 10396 10397 10398 START_TEST(getAtUint32PSmallArrayT) 10399 10400 uint32_t* r; 10401 smallArrayt *self = allocG(rtSmallArrayt); 10402 smallArrayt *r2; 10403 10404 // add elements to self 10405 r2 = self->f->pushInt(self, 1); 10406 ck_assert_ptr_ne(r2, null); 10407 r2 = self->f->pushInt(self, 2); 10408 ck_assert_ptr_ne(r2, null); 10409 r2 = self->f->pushInt(self, 3); 10410 ck_assert_ptr_ne(r2, null); 10411 r2 = self->f->pushInt(self, 4); 10412 ck_assert_ptr_ne(r2, null); 10413 10414 // positive index 10415 r = self->f->getAtUint32P(self,1); 10416 ck_assert_ptr_ne(r, null); 10417 ck_assert(*r==2); 10418 char *s = toStringO(self); 10419 ck_assert_str_eq(s, "[1,2,3,4]"); 10420 free(s); 10421 // negative index 10422 r = self->f->getAtUint32P(self,-1); 10423 ck_assert_ptr_ne(r, null); 10424 ck_assert(*r==4); 10425 s = toStringO(self); 10426 ck_assert_str_eq(s, "[1,2,3,4]"); 10427 free(s); 10428 // wrong object type 10429 createSmallDouble(I); 10430 setValG(&I, 11); 10431 r2 = self->f->pushSmallDouble(self, &I); 10432 r = self->f->getAtUint32P(self,-1); 10433 ck_assert_ptr_eq(r, null); 10434 s = toStringO(self); 10435 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10436 free(s); 10437 // wrong object type of another user class 10438 // User classes are stored in containers transparently 10439 createAllocateSmallInt(ip); 10440 ip->type = "anothertype"; 10441 setValG(ip, 11); 10442 r2 = self->f->push(self, (baset*)ip); 10443 ck_assert_ptr_ne(r2, null); 10444 r = self->f->getAtUint32P(self,-1); 10445 ck_assert_ptr_eq(r, null); 10446 s = toStringO(self); 10447 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10448 free(s); 10449 // index outside 10450 ck_assert(!self->f->getAtUint32P(self, 20)); 10451 ck_assert(!self->f->getAtUint32P(self, -7)); 10452 // empty list 10453 emptyO(self); 10454 ck_assert(!self->f->getAtUint32P(self, 0)); 10455 ck_assert(!self->f->getAtUint32P(self, -1)); 10456 terminateO(self); 10457 10458 END_TEST 10459 10460 10461 START_TEST(getAtSSmallArrayT) 10462 10463 char* r; 10464 smallArrayt *self = allocG(rtSmallArrayt); 10465 smallArrayt *r2; 10466 10467 // add elements to self 10468 r2 = self->f->pushInt(self, 1); 10469 ck_assert_ptr_ne(r2, null); 10470 r2 = self->f->pushS(self, "2"); 10471 ck_assert_ptr_ne(r2, null); 10472 r2 = self->f->pushInt(self, 3); 10473 ck_assert_ptr_ne(r2, null); 10474 r2 = self->f->pushS(self, "4"); 10475 ck_assert_ptr_ne(r2, null); 10476 10477 // positive index 10478 r = self->f->getAtS(self,1); 10479 ck_assert_ptr_ne(r, null); 10480 ck_assert_str_eq(r, "2"); 10481 char *s = toStringO(self); 10482 ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]"); 10483 free(s); 10484 // negative index 10485 r = self->f->getAtS(self,-1); 10486 ck_assert_ptr_ne(r, null); 10487 ck_assert_str_eq(r, "4"); 10488 s = toStringO(self); 10489 ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]"); 10490 free(s); 10491 // wrong object type 10492 createSmallInt(I); 10493 setValG(&I, 11); 10494 r2 = self->f->pushSmallInt(self, &I); 10495 r = self->f->getAtS(self,-1); 10496 ck_assert_ptr_eq(r, NULL); 10497 s = toStringO(self); 10498 ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11]"); 10499 free(s); 10500 // wrong object type of another user class 10501 // User classes are stored in containers transparently 10502 createAllocateSmallInt(ip); 10503 ip->type = "anothertype"; 10504 setValG(ip, 11); 10505 r2 = self->f->push(self, (baset*)ip); 10506 ck_assert_ptr_ne(r2, null); 10507 r = self->f->getAtS(self,-1); 10508 ck_assert_ptr_eq(r, NULL); 10509 s = toStringO(self); 10510 ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11,\"<data container>\"]"); 10511 free(s); 10512 // index outside 10513 ck_assert_ptr_eq(self->f->getAtS(self, 20), NULL); 10514 ck_assert_ptr_eq(self->f->getAtS(self, -7), NULL); 10515 // empty list 10516 emptyO(self); 10517 ck_assert_ptr_eq(self->f->getAtS(self, 0), NULL); 10518 ck_assert_ptr_eq(self->f->getAtS(self, -1), NULL); 10519 terminateO(self); 10520 10521 END_TEST 10522 10523 10524 START_TEST(getAtDictSmallArrayT) 10525 10526 smallDictt* r; 10527 smallArrayt *self = allocG(rtSmallArrayt); 10528 smallArrayt *r2; 10529 10530 // add elements to self 10531 r2 = self->f->pushInt(self, 1); 10532 ck_assert_ptr_ne(r2, null); 10533 createSmallDict(e2); 10534 r2 = self->f->pushDict(self, &e2); 10535 ck_assert_ptr_ne(r2, null); 10536 r2 = self->f->pushInt(self, 3); 10537 ck_assert_ptr_ne(r2, null); 10538 createSmallDict(e4); 10539 r2 = self->f->pushDict(self, &e4); 10540 ck_assert_ptr_ne(r2, null); 10541 10542 // positive index 10543 r = self->f->getAtDict(self,1); 10544 ck_assert_ptr_ne(r, null); 10545 char *s = toStringO(r); 10546 finishO(r); 10547 ck_assert_str_eq(s, "{}"); 10548 free(s); 10549 s = toStringO(self); 10550 ck_assert_str_eq(s, "[1,{},3,{}]"); 10551 free(s); 10552 // negative index 10553 r = self->f->getAtDict(self,-1); 10554 ck_assert_ptr_ne(r, null); 10555 s = toStringO(r); 10556 finishO(r); 10557 ck_assert_str_eq(s, "{}"); 10558 free(s); 10559 s = toStringO(self); 10560 ck_assert_str_eq(s, "[1,{},3,{}]"); 10561 free(s); 10562 // wrong object type 10563 createSmallInt(I); 10564 setValG(&I, 11); 10565 r2 = self->f->pushSmallInt(self, &I); 10566 r = self->f->getAtDict(self,-1); 10567 ck_assert_ptr_eq(r, NULL); 10568 s = toStringO(self); 10569 ck_assert_str_eq(s, "[1,{},3,{},11]"); 10570 free(s); 10571 // wrong object type of another user class 10572 // User classes are stored in containers transparently 10573 createAllocateSmallInt(ip); 10574 ip->type = "anothertype"; 10575 setValG(ip, 11); 10576 r2 = self->f->push(self, (baset*)ip); 10577 ck_assert_ptr_ne(r2, null); 10578 r = self->f->getAtDict(self,-1); 10579 ck_assert_ptr_eq(r, NULL); 10580 s = toStringO(self); 10581 ck_assert_str_eq(s, "[1,{},3,{},11,\"<data container>\"]"); 10582 free(s); 10583 // index outside 10584 ck_assert_ptr_eq(self->f->getAtDict(self, 20), NULL); 10585 ck_assert_ptr_eq(self->f->getAtDict(self, -7), NULL); 10586 // empty list 10587 emptyO(self); 10588 ck_assert_ptr_eq(self->f->getAtDict(self, 0), NULL); 10589 ck_assert_ptr_eq(self->f->getAtDict(self, -1), NULL); 10590 // get empty slot in array 10591 r2 = self->f->pushUndefined(self); 10592 ck_assert_ptr_ne(r2, null); 10593 delElemO(self,0); 10594 ck_assert_ptr_eq(self->f->getAtDict(self, 0), NULL); 10595 terminateO(self); 10596 10597 END_TEST 10598 10599 10600 START_TEST(getAtArraySmallArrayT) 10601 10602 smallArrayt* r; 10603 smallArrayt *self = allocG(rtSmallArrayt); 10604 smallArrayt *r2; 10605 10606 // add elements to self 10607 r2 = self->f->pushInt(self, 1); 10608 ck_assert_ptr_ne(r2, null); 10609 createSmallArray(e2); 10610 r2 = self->f->pushArray(self, &e2); 10611 ck_assert_ptr_ne(r2, null); 10612 r2 = self->f->pushInt(self, 3); 10613 ck_assert_ptr_ne(r2, null); 10614 createSmallArray(e4); 10615 r2 = self->f->pushArray(self, &e4); 10616 ck_assert_ptr_ne(r2, null); 10617 10618 // positive index 10619 r = self->f->getAtArray(self,1); 10620 ck_assert_ptr_ne(r, null); 10621 char *s = toStringO(r); 10622 finishO(r); 10623 ck_assert_str_eq(s, "[]"); 10624 free(s); 10625 s = toStringO(self); 10626 ck_assert_str_eq(s, "[1,[],3,[]]"); 10627 free(s); 10628 // negative index 10629 r = self->f->getAtArray(self,-1); 10630 ck_assert_ptr_ne(r, null); 10631 s = toStringO(r); 10632 finishO(r); 10633 ck_assert_str_eq(s, "[]"); 10634 free(s); 10635 s = toStringO(self); 10636 ck_assert_str_eq(s, "[1,[],3,[]]"); 10637 free(s); 10638 // wrong object type 10639 createSmallInt(I); 10640 setValG(&I, 11); 10641 r2 = self->f->pushSmallInt(self, &I); 10642 r = self->f->getAtArray(self,-1); 10643 ck_assert_ptr_eq(r, NULL); 10644 s = toStringO(self); 10645 ck_assert_str_eq(s, "[1,[],3,[],11]"); 10646 free(s); 10647 // wrong object type of another user class 10648 // User classes are stored in containers transparently 10649 createAllocateSmallInt(ip); 10650 ip->type = "anothertype"; 10651 setValG(ip, 11); 10652 r2 = self->f->push(self, (baset*)ip); 10653 ck_assert_ptr_ne(r2, null); 10654 r = self->f->getAtArray(self,-1); 10655 ck_assert_ptr_eq(r, NULL); 10656 s = toStringO(self); 10657 ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]"); 10658 free(s); 10659 // index outside 10660 ck_assert_ptr_eq(self->f->getAtArray(self, 20), NULL); 10661 ck_assert_ptr_eq(self->f->getAtArray(self, -7), NULL); 10662 // empty list 10663 emptyO(self); 10664 ck_assert_ptr_eq(self->f->getAtArray(self, 0), NULL); 10665 ck_assert_ptr_eq(self->f->getAtArray(self, -1), NULL); 10666 // get empty slot in array 10667 r2 = self->f->pushUndefined(self); 10668 ck_assert_ptr_ne(r2, null); 10669 delElemO(self,0); 10670 ck_assert_ptr_eq(self->f->getAtArray(self, 0), NULL); 10671 terminateO(self); 10672 10673 END_TEST 10674 10675 10676 START_TEST(getAtSmallBoolSmallArrayT) 10677 10678 smallBoolt* r; 10679 smallArrayt *self = allocG(rtSmallArrayt); 10680 smallArrayt *r2; 10681 10682 // add elements to self 10683 r2 = self->f->pushInt(self, 1); 10684 ck_assert_ptr_ne(r2, null); 10685 createSmallBool(e2); 10686 r2 = self->f->pushBool(self, true); 10687 ck_assert_ptr_ne(r2, null); 10688 r2 = self->f->pushInt(self, 3); 10689 ck_assert_ptr_ne(r2, null); 10690 createSmallBool(e4); 10691 r2 = self->f->pushBool(self, true); 10692 ck_assert_ptr_ne(r2, null); 10693 10694 // positive index 10695 r = self->f->getAtSmallBool(self,1); 10696 ck_assert_ptr_ne(r, null); 10697 char *s = toStringO(r); 10698 finishO(r); 10699 ck_assert_str_eq(s, "true"); 10700 free(s); 10701 s = toStringO(self); 10702 ck_assert_str_eq(s, "[1,true,3,true]"); 10703 free(s); 10704 // negative index 10705 r = self->f->getAtSmallBool(self,-1); 10706 ck_assert_ptr_ne(r, null); 10707 s = toStringO(r); 10708 finishO(r); 10709 ck_assert_str_eq(s, "true"); 10710 free(s); 10711 s = toStringO(self); 10712 ck_assert_str_eq(s, "[1,true,3,true]"); 10713 free(s); 10714 // wrong object type 10715 createSmallInt(I); 10716 setValG(&I, 11); 10717 r2 = self->f->pushSmallInt(self, &I); 10718 r = self->f->getAtSmallBool(self,2); 10719 ck_assert_ptr_eq(r, NULL); 10720 s = toStringO(self); 10721 ck_assert_str_eq(s, "[1,true,3,true,11]"); 10722 free(s); 10723 // wrong object type of another user class 10724 // User classes are stored in containers transparently 10725 createAllocateSmallInt(ip); 10726 ip->type = "anothertype"; 10727 setValG(ip, 11); 10728 r2 = self->f->push(self, (baset*)ip); 10729 ck_assert_ptr_ne(r2, null); 10730 r = self->f->getAtSmallBool(self,-1); 10731 ck_assert_ptr_eq(r, NULL); 10732 s = toStringO(self); 10733 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 10734 free(s); 10735 // index outside 10736 ck_assert_ptr_eq(self->f->getAtSmallBool(self, 20), NULL); 10737 ck_assert_ptr_eq(self->f->getAtSmallBool(self, -7), NULL); 10738 // empty list 10739 emptyO(self); 10740 ck_assert_ptr_eq(self->f->getAtSmallBool(self, 0), NULL); 10741 ck_assert_ptr_eq(self->f->getAtSmallBool(self, -1), NULL); 10742 // get empty slot in array 10743 r2 = self->f->pushUndefined(self); 10744 ck_assert_ptr_ne(r2, null); 10745 delElemO(self,0); 10746 ck_assert_ptr_eq(self->f->getAtSmallBool(self, 0), NULL); 10747 terminateO(self); 10748 10749 END_TEST 10750 10751 10752 START_TEST(getAtSmallBytesSmallArrayT) 10753 10754 smallBytest* r; 10755 smallArrayt *self = allocG(rtSmallArrayt); 10756 smallArrayt *r2; 10757 10758 // add elements to self 10759 r2 = self->f->pushInt(self, 1); 10760 ck_assert_ptr_ne(r2, null); 10761 createSmallBytes(e2); 10762 r2 = self->f->pushSmallBytes(self, &e2); 10763 ck_assert_ptr_ne(r2, null); 10764 r2 = self->f->pushInt(self, 3); 10765 ck_assert_ptr_ne(r2, null); 10766 createSmallBytes(e4); 10767 r2 = self->f->pushSmallBytes(self, &e4); 10768 ck_assert_ptr_ne(r2, null); 10769 10770 // positive index 10771 r = self->f->getAtSmallBytes(self,1); 10772 ck_assert_ptr_ne(r, null); 10773 char *s = toStringO(r); 10774 finishO(r); 10775 ck_assert_str_eq(s, "[]"); 10776 free(s); 10777 s = toStringO(self); 10778 ck_assert_str_eq(s, "[1,[],3,[]]"); 10779 free(s); 10780 // negative index 10781 r = self->f->getAtSmallBytes(self,-1); 10782 ck_assert_ptr_ne(r, null); 10783 s = toStringO(r); 10784 finishO(r); 10785 ck_assert_str_eq(s, "[]"); 10786 free(s); 10787 s = toStringO(self); 10788 ck_assert_str_eq(s, "[1,[],3,[]]"); 10789 free(s); 10790 // wrong object type 10791 createSmallInt(I); 10792 setValG(&I, 11); 10793 r2 = self->f->pushSmallInt(self, &I); 10794 r = self->f->getAtSmallBytes(self,-1); 10795 ck_assert_ptr_eq(r, NULL); 10796 s = toStringO(self); 10797 ck_assert_str_eq(s, "[1,[],3,[],11]"); 10798 free(s); 10799 // wrong object type of another user class 10800 // User classes are stored in containers transparently 10801 createAllocateSmallInt(ip); 10802 ip->type = "anothertype"; 10803 setValG(ip, 11); 10804 r2 = self->f->push(self, (baset*)ip); 10805 ck_assert_ptr_ne(r2, null); 10806 r = self->f->getAtSmallBytes(self,-1); 10807 ck_assert_ptr_eq(r, NULL); 10808 s = toStringO(self); 10809 ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]"); 10810 free(s); 10811 // index outside 10812 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, 20), NULL); 10813 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, -7), NULL); 10814 // empty list 10815 emptyO(self); 10816 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, 0), NULL); 10817 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, -1), NULL); 10818 // get empty slot in array 10819 r2 = self->f->pushUndefined(self); 10820 ck_assert_ptr_ne(r2, null); 10821 delElemO(self,0); 10822 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, 0), NULL); 10823 terminateO(self); 10824 10825 END_TEST 10826 10827 10828 START_TEST(getAtSmallDoubleSmallArrayT) 10829 10830 smallDoublet* r; 10831 smallArrayt *self = allocG(rtSmallArrayt); 10832 smallArrayt *r2; 10833 10834 // add elements to self 10835 r2 = self->f->pushInt(self, 1); 10836 ck_assert_ptr_ne(r2, null); 10837 createSmallDouble(e2); 10838 r2 = self->f->pushSmallDouble(self, &e2); 10839 ck_assert_ptr_ne(r2, null); 10840 r2 = self->f->pushInt(self, 3); 10841 ck_assert_ptr_ne(r2, null); 10842 createSmallDouble(e4); 10843 r2 = self->f->pushSmallDouble(self, &e4); 10844 ck_assert_ptr_ne(r2, null); 10845 10846 // positive index 10847 r = self->f->getAtSmallDouble(self,1); 10848 ck_assert_ptr_ne(r, null); 10849 char *s = toStringO(r); 10850 finishO(r); 10851 ck_assert_str_eq(s, "0.000000e+00"); 10852 free(s); 10853 s = toStringO(self); 10854 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]"); 10855 free(s); 10856 // negative index 10857 r = self->f->getAtSmallDouble(self,-1); 10858 ck_assert_ptr_ne(r, null); 10859 s = toStringO(r); 10860 finishO(r); 10861 ck_assert_str_eq(s, "0.000000e+00"); 10862 free(s); 10863 s = toStringO(self); 10864 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]"); 10865 free(s); 10866 // wrong object type 10867 createSmallInt(I); 10868 setValG(&I, 11); 10869 r2 = self->f->pushSmallInt(self, &I); 10870 r = self->f->getAtSmallDouble(self,-1); 10871 ck_assert_ptr_eq(r, NULL); 10872 s = toStringO(self); 10873 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11]"); 10874 free(s); 10875 // wrong object type of another user class 10876 // User classes are stored in containers transparently 10877 createAllocateSmallInt(ip); 10878 ip->type = "anothertype"; 10879 setValG(ip, 11); 10880 r2 = self->f->push(self, (baset*)ip); 10881 ck_assert_ptr_ne(r2, null); 10882 r = self->f->getAtSmallDouble(self,-1); 10883 ck_assert_ptr_eq(r, NULL); 10884 s = toStringO(self); 10885 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11,\"<data container>\"]"); 10886 free(s); 10887 // index outside 10888 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, 20), NULL); 10889 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, -7), NULL); 10890 // empty list 10891 emptyO(self); 10892 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, 0), NULL); 10893 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, -1), NULL); 10894 // get empty slot in array 10895 r2 = self->f->pushUndefined(self); 10896 ck_assert_ptr_ne(r2, null); 10897 delElemO(self,0); 10898 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, 0), NULL); 10899 terminateO(self); 10900 10901 END_TEST 10902 10903 10904 START_TEST(getAtSmallIntSmallArrayT) 10905 10906 smallIntt* r; 10907 smallArrayt *self = allocG(rtSmallArrayt); 10908 smallArrayt *r2; 10909 10910 // add elements to self 10911 r2 = self->f->pushBool(self, true); 10912 ck_assert_ptr_ne(r2, null); 10913 createSmallInt(e2); 10914 r2 = self->f->pushSmallInt(self, &e2); 10915 ck_assert_ptr_ne(r2, null); 10916 r2 = self->f->pushBool(self, true); 10917 ck_assert_ptr_ne(r2, null); 10918 createSmallInt(e4); 10919 r2 = self->f->pushSmallInt(self, &e4); 10920 ck_assert_ptr_ne(r2, null); 10921 10922 // positive index 10923 r = self->f->getAtSmallInt(self,1); 10924 ck_assert_ptr_ne(r, null); 10925 char *s = toStringO(r); 10926 finishO(r); 10927 ck_assert_str_eq(s, "0"); 10928 free(s); 10929 s = toStringO(self); 10930 ck_assert_str_eq(s, "[true,0,true,0]"); 10931 free(s); 10932 // negative index 10933 r = self->f->getAtSmallInt(self,-1); 10934 ck_assert_ptr_ne(r, null); 10935 s = toStringO(r); 10936 finishO(r); 10937 ck_assert_str_eq(s, "0"); 10938 free(s); 10939 s = toStringO(self); 10940 ck_assert_str_eq(s, "[true,0,true,0]"); 10941 free(s); 10942 // wrong object type 10943 createSmallDouble(I); 10944 setValG(&I, 11); 10945 r2 = self->f->pushSmallDouble(self, &I); 10946 r = self->f->getAtSmallInt(self,-1); 10947 ck_assert_ptr_eq(r, NULL); 10948 s = toStringO(self); 10949 ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01]"); 10950 free(s); 10951 // wrong object type of another user class 10952 // User classes are stored in containers transparently 10953 createAllocateSmallInt(ip); 10954 ip->type = "anothertype"; 10955 setValG(ip, 11); 10956 r2 = self->f->push(self, (baset*)ip); 10957 ck_assert_ptr_ne(r2, null); 10958 r = self->f->getAtSmallInt(self,-1); 10959 ck_assert_ptr_eq(r, NULL); 10960 s = toStringO(self); 10961 ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01,\"<data container>\"]"); 10962 free(s); 10963 // index outside 10964 ck_assert_ptr_eq(self->f->getAtSmallInt(self, 20), NULL); 10965 ck_assert_ptr_eq(self->f->getAtSmallInt(self, -7), NULL); 10966 // empty list 10967 emptyO(self); 10968 ck_assert_ptr_eq(self->f->getAtSmallInt(self, 0), NULL); 10969 ck_assert_ptr_eq(self->f->getAtSmallInt(self, -1), NULL); 10970 // get empty slot in array 10971 r2 = self->f->pushUndefined(self); 10972 ck_assert_ptr_ne(r2, null); 10973 delElemO(self,0); 10974 ck_assert_ptr_eq(self->f->getAtSmallInt(self, 0), NULL); 10975 terminateO(self); 10976 10977 END_TEST 10978 10979 10980 START_TEST(getAtSmallJsonSmallArrayT) 10981 10982 smallJsont* r; 10983 smallArrayt *self = allocG(rtSmallArrayt); 10984 smallArrayt *r2; 10985 10986 // add elements to self 10987 r2 = self->f->pushInt(self, 1); 10988 ck_assert_ptr_ne(r2, null); 10989 createSmallJson(e2); 10990 r2 = self->f->pushSmallJson(self, &e2); 10991 ck_assert_ptr_ne(r2, null); 10992 r2 = self->f->pushInt(self, 3); 10993 ck_assert_ptr_ne(r2, null); 10994 createSmallJson(e4); 10995 r2 = self->f->pushSmallJson(self, &e4); 10996 ck_assert_ptr_ne(r2, null); 10997 10998 // positive index 10999 r = self->f->getAtSmallJson(self,1); 11000 ck_assert_ptr_ne(r, null); 11001 char *s = toStringO(r); 11002 finishO(r); 11003 ck_assert_str_eq(s, "{}"); 11004 free(s); 11005 s = toStringO(self); 11006 ck_assert_str_eq(s, "[1,{},3,{}]"); 11007 free(s); 11008 // negative index 11009 r = self->f->getAtSmallJson(self,-1); 11010 ck_assert_ptr_ne(r, null); 11011 s = toStringO(r); 11012 finishO(r); 11013 ck_assert_str_eq(s, "{}"); 11014 free(s); 11015 s = toStringO(self); 11016 ck_assert_str_eq(s, "[1,{},3,{}]"); 11017 free(s); 11018 // wrong object type 11019 createSmallBytes(I); 11020 r2 = self->f->pushSmallBytes(self, &I); 11021 r = self->f->getAtSmallJson(self,-1); 11022 ck_assert_ptr_eq(r, NULL); 11023 s = toStringO(self); 11024 ck_assert_str_eq(s, "[1,{},3,{},[]]"); 11025 free(s); 11026 // wrong object type of another user class 11027 // User classes are stored in containers transparently 11028 createAllocateSmallInt(ip); 11029 ip->type = "anothertype"; 11030 setValG(ip, 11); 11031 r2 = self->f->push(self, (baset*)ip); 11032 ck_assert_ptr_ne(r2, null); 11033 r = self->f->getAtSmallJson(self,-1); 11034 ck_assert_ptr_eq(r, NULL); 11035 s = toStringO(self); 11036 ck_assert_str_eq(s, "[1,{},3,{},[],\"<data container>\"]"); 11037 free(s); 11038 // index outside 11039 ck_assert_ptr_eq(self->f->getAtSmallJson(self, 20), NULL); 11040 ck_assert_ptr_eq(self->f->getAtSmallJson(self, -7), NULL); 11041 // empty list 11042 emptyO(self); 11043 ck_assert_ptr_eq(self->f->getAtSmallJson(self, 0), NULL); 11044 ck_assert_ptr_eq(self->f->getAtSmallJson(self, -1), NULL); 11045 // get empty slot in array 11046 r2 = self->f->pushUndefined(self); 11047 ck_assert_ptr_ne(r2, null); 11048 delElemO(self,0); 11049 ck_assert_ptr_eq(self->f->getAtSmallJson(self, 0), NULL); 11050 terminateO(self); 11051 11052 END_TEST 11053 11054 11055 START_TEST(getAtSmallStringSmallArrayT) 11056 11057 smallStringt* r; 11058 smallArrayt *self = allocG(rtSmallArrayt); 11059 smallArrayt *r2; 11060 11061 // add elements to self 11062 r2 = self->f->pushInt(self, 1); 11063 ck_assert_ptr_ne(r2, null); 11064 createSmallString(e2); 11065 r2 = self->f->pushSmallString(self, &e2); 11066 ck_assert_ptr_ne(r2, null); 11067 r2 = self->f->pushInt(self, 3); 11068 ck_assert_ptr_ne(r2, null); 11069 createSmallString(e4); 11070 r2 = self->f->pushSmallString(self, &e4); 11071 ck_assert_ptr_ne(r2, null); 11072 11073 // positive index 11074 r = self->f->getAtSmallString(self,1); 11075 ck_assert_ptr_ne(r, null); 11076 char *s = toStringO(r); 11077 finishO(r); 11078 ck_assert_str_eq(s, ""); 11079 free(s); 11080 s = toStringO(self); 11081 ck_assert_str_eq(s, "[1,\"\",3,\"\"]"); 11082 free(s); 11083 // negative index 11084 r = self->f->getAtSmallString(self,-1); 11085 ck_assert_ptr_ne(r, null); 11086 s = toStringO(r); 11087 finishO(r); 11088 ck_assert_str_eq(s, ""); 11089 free(s); 11090 s = toStringO(self); 11091 ck_assert_str_eq(s, "[1,\"\",3,\"\"]"); 11092 free(s); 11093 // wrong object type 11094 createSmallInt(I); 11095 setValG(&I, 11); 11096 r2 = self->f->pushSmallInt(self, &I); 11097 r = self->f->getAtSmallString(self,-1); 11098 ck_assert_ptr_eq(r, NULL); 11099 s = toStringO(self); 11100 ck_assert_str_eq(s, "[1,\"\",3,\"\",11]"); 11101 free(s); 11102 // wrong object type of another user class 11103 // User classes are stored in containers transparently 11104 createAllocateSmallInt(ip); 11105 ip->type = "anothertype"; 11106 setValG(ip, 11); 11107 r2 = self->f->push(self, (baset*)ip); 11108 ck_assert_ptr_ne(r2, null); 11109 r = self->f->getAtSmallString(self,-1); 11110 ck_assert_ptr_eq(r, NULL); 11111 s = toStringO(self); 11112 ck_assert_str_eq(s, "[1,\"\",3,\"\",11,\"<data container>\"]"); 11113 free(s); 11114 // index outside 11115 ck_assert_ptr_eq(self->f->getAtSmallString(self, 20), NULL); 11116 ck_assert_ptr_eq(self->f->getAtSmallString(self, -7), NULL); 11117 // empty list 11118 emptyO(self); 11119 ck_assert_ptr_eq(self->f->getAtSmallString(self, 0), NULL); 11120 ck_assert_ptr_eq(self->f->getAtSmallString(self, -1), NULL); 11121 // get empty slot in array 11122 r2 = self->f->pushUndefined(self); 11123 ck_assert_ptr_ne(r2, null); 11124 delElemO(self,0); 11125 ck_assert_ptr_eq(self->f->getAtSmallString(self, 0), NULL); 11126 terminateO(self); 11127 11128 END_TEST 11129 11130 11131 START_TEST(getAtVoidSmallArrayT) 11132 11133 void* r; 11134 smallArrayt *self = allocG(rtSmallArrayt); 11135 smallArrayt *r2; 11136 11137 // add elements to self 11138 r2 = self->f->pushInt(self, 1); 11139 ck_assert_ptr_ne(r2, null); 11140 r2 = pushVoidSmallArrayG(self, &r); 11141 ck_assert_ptr_ne(r2, null); 11142 r2 = self->f->pushInt(self, 3); 11143 ck_assert_ptr_ne(r2, null); 11144 r2 = pushVoidSmallArrayG(self, &self); 11145 ck_assert_ptr_ne(r2, null); 11146 11147 // positive index 11148 r = self->f->getAtVoid(self,1); 11149 ck_assert_ptr_eq(r, &r); 11150 char *s = toStringO(self); 11151 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 11152 free(s); 11153 // negative index 11154 r = self->f->getAtVoid(self,-1); 11155 ck_assert_ptr_eq(r, &self); 11156 s = toStringO(self); 11157 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 11158 free(s); 11159 // wrong object type 11160 createSmallInt(I); 11161 setValG(&I, 11); 11162 r2 = self->f->pushSmallInt(self, &I); 11163 r = self->f->getAtVoid(self,-1); 11164 ck_assert_ptr_eq(r, NULL); 11165 s = toStringO(self); 11166 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]"); 11167 free(s); 11168 // wrong object type of another user class 11169 // User classes are stored in containers transparently 11170 createAllocateSmallInt(ip); 11171 ip->type = "anothertype"; 11172 setValG(ip, 11); 11173 r2 = self->f->push(self, (baset*)ip); 11174 ck_assert_ptr_ne(r2, null); 11175 r = self->f->getAtVoid(self,-1); 11176 ck_assert_ptr_eq(r, NULL); 11177 s = toStringO(self); 11178 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]"); 11179 free(s); 11180 // index outside 11181 ck_assert_ptr_eq(self->f->getAtVoid(self, 20), NULL); 11182 ck_assert_ptr_eq(self->f->getAtVoid(self, -7), NULL); 11183 // empty list 11184 emptyO(self); 11185 ck_assert_ptr_eq(self->f->getAtVoid(self, 0), NULL); 11186 ck_assert_ptr_eq(self->f->getAtVoid(self, -1), NULL); 11187 terminateO(self); 11188 11189 END_TEST 11190 11191 11192 START_TEST(getAtSmallContainerSmallArrayT) 11193 11194 smallContainert* r; 11195 smallArrayt *self = allocG(rtSmallArrayt); 11196 smallArrayt *r2; 11197 11198 // add elements to self 11199 r2 = self->f->pushInt(self, 1); 11200 ck_assert_ptr_ne(r2, null); 11201 createSmallContainer(e2); 11202 r2 = self->f->pushSmallContainer(self, &e2); 11203 ck_assert_ptr_ne(r2, null); 11204 r2 = self->f->pushInt(self, 3); 11205 ck_assert_ptr_ne(r2, null); 11206 createSmallContainer(e4); 11207 r2 = self->f->pushSmallContainer(self, &e4); 11208 ck_assert_ptr_ne(r2, null); 11209 11210 // positive index 11211 r = self->f->getAtSmallContainer(self,1); 11212 ck_assert_ptr_ne(r, null); 11213 char *s = toStringO(r); 11214 finishO(r); 11215 ck_assert_str_eq(s, "<data smallContainer>"); 11216 free(s); 11217 s = toStringO(self); 11218 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 11219 free(s); 11220 // negative index 11221 r = self->f->getAtSmallContainer(self,-1); 11222 ck_assert_ptr_ne(r, null); 11223 s = toStringO(r); 11224 finishO(r); 11225 ck_assert_str_eq(s, "<data smallContainer>"); 11226 free(s); 11227 s = toStringO(self); 11228 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 11229 free(s); 11230 // wrong object type 11231 createSmallInt(I); 11232 setValG(&I, 11); 11233 r2 = self->f->pushSmallInt(self, &I); 11234 r = self->f->getAtSmallContainer(self,-1); 11235 ck_assert_ptr_eq(r, NULL); 11236 s = toStringO(self); 11237 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]"); 11238 free(s); 11239 // wrong object type of another user class 11240 // User classes are stored in containers transparently 11241 createAllocateSmallInt(ip); 11242 ip->type = "anothertype"; 11243 setValG(ip, 11); 11244 r2 = self->f->push(self, (baset*)ip); 11245 ck_assert_ptr_ne(r2, null); 11246 r = self->f->getAtSmallContainer(self,-1); 11247 ck_assert_ptr_eq(r, NULL); 11248 s = toStringO(self); 11249 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]"); 11250 free(s); 11251 // index outside 11252 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, 20), NULL); 11253 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, -7), NULL); 11254 // empty list 11255 emptyO(self); 11256 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, 0), NULL); 11257 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, -1), NULL); 11258 // get empty slot in array 11259 r2 = self->f->pushUndefined(self); 11260 ck_assert_ptr_ne(r2, null); 11261 delElemO(self,0); 11262 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, 0), NULL); 11263 terminateO(self); 11264 11265 END_TEST 11266 11267 11268 START_TEST(getAtNDupSmallArrayT) 11269 11270 baset* r; 11271 smallArrayt *self = allocG(rtSmallArrayt); 11272 smallArrayt *r2; 11273 11274 // add elements to self 11275 r2 = self->f->pushInt(self, 1); 11276 ck_assert_ptr_ne(r2, null); 11277 r2 = self->f->pushInt(self, 2); 11278 ck_assert_ptr_ne(r2, null); 11279 r2 = self->f->pushInt(self, 3); 11280 ck_assert_ptr_ne(r2, null); 11281 r2 = self->f->pushInt(self, 4); 11282 ck_assert_ptr_ne(r2, null); 11283 11284 // positive index 11285 r = self->f->getAtNDup(self,1); 11286 ck_assert_ptr_ne(r, null); 11287 char *s = toStringO(r); 11288 terminateO(r); 11289 ck_assert_str_eq(s, "2"); 11290 free(s); 11291 s = toStringO(self); 11292 ck_assert_str_eq(s, "[1,2,3,4]"); 11293 free(s); 11294 // negative index 11295 r = self->f->getAtNDup(self,-1); 11296 ck_assert_ptr_ne(r, null); 11297 s = toStringO(r); 11298 terminateO(r); 11299 ck_assert_str_eq(s, "4"); 11300 free(s); 11301 s = toStringO(self); 11302 ck_assert_str_eq(s, "[1,2,3,4]"); 11303 free(s); 11304 // undefined object 11305 r2 = self->f->pushUndefined(self); 11306 ck_assert_ptr_ne(r2, null); 11307 r = self->f->getAtNDup(self,-1); 11308 ck_assert_ptr_ne(r, null); 11309 s = toStringO(r); 11310 terminateO(r); 11311 ck_assert_str_eq(s, "null"); 11312 free(s); 11313 s = toStringO(self); 11314 ck_assert_str_eq(s, "[1,2,3,4,null]"); 11315 free(s); 11316 // container 11317 createSmallContainer(c); 11318 r2 = self->f->pushSmallContainer(self, &c); 11319 r = self->f->getAtNDup(self,-1); 11320 ck_assert_ptr_ne(r, null); 11321 s = toStringO(r); 11322 terminateO(r); 11323 ck_assert_str_eq(s, "<data smallContainer>"); 11324 free(s); 11325 s = toStringO(self); 11326 ck_assert_str_eq(s, "[1,2,3,4,null,\"<data container>\"]"); 11327 free(s); 11328 // base object in container 11329 createAllocateSmallInt(I); 11330 setValG(I, 11); 11331 I->type = "anothertype"; 11332 r2 = self->f->push(self, (baset*)I); 11333 r = self->f->getAtNDup(self,-1); 11334 ck_assert_ptr_ne(r, null); 11335 // r->type is not anothertype, because the duplicate function is from the smallInt class 11336 ck_assert_str_eq(r->type, "smallInt"); 11337 s = toStringO(r); 11338 terminateO(r); 11339 ck_assert_str_eq(s, "11"); 11340 free(s); 11341 s = toStringO(self); 11342 ck_assert_str_eq(s, "[1,2,3,4,null,\"<data container>\",\"<data container>\"]"); 11343 free(s); 11344 // index outside 11345 ck_assert_ptr_eq(self->f->getAtNDup(self, 20), NULL); 11346 ck_assert_ptr_eq(self->f->getAtNDup(self, -8), NULL); 11347 // empty list 11348 emptyO(self); 11349 ck_assert_ptr_eq(self->f->getAtNDup(self, 0), NULL); 11350 ck_assert_ptr_eq(self->f->getAtNDup(self, -1), NULL); 11351 // get empty slot in array 11352 r2 = self->f->pushUndefined(self); 11353 ck_assert_ptr_ne(r2, null); 11354 delElemO(self,0); 11355 ck_assert_ptr_eq(self->f->getAtNDup(self, 0), NULL); 11356 terminateO(self); 11357 11358 END_TEST 11359 11360 11361 START_TEST(getAtNDupUndefinedSmallArrayT) 11362 11363 undefinedt* r; 11364 smallArrayt *self = allocG(rtSmallArrayt); 11365 smallArrayt *r2; 11366 11367 // add elements to self 11368 r2 = self->f->pushInt(self, 1); 11369 ck_assert_ptr_ne(r2, null); 11370 r2 = self->f->pushUndefined(self); 11371 ck_assert_ptr_ne(r2, null); 11372 r2 = self->f->pushInt(self, 3); 11373 ck_assert_ptr_ne(r2, null); 11374 r2 = self->f->pushUndefined(self); 11375 ck_assert_ptr_ne(r2, null); 11376 11377 // positive index 11378 r = self->f->getAtNDupUndefined(self,1); 11379 ck_assert_ptr_ne(r, null); 11380 char *s = toStringO(r); 11381 terminateO(r); 11382 ck_assert_str_eq(s, "null"); 11383 free(s); 11384 s = toStringO(self); 11385 ck_assert_str_eq(s, "[1,null,3,null]"); 11386 free(s); 11387 // negative index 11388 r = self->f->getAtNDupUndefined(self,-1); 11389 ck_assert_ptr_ne(r, null); 11390 s = toStringO(r); 11391 terminateO(r); 11392 ck_assert_str_eq(s, "null"); 11393 free(s); 11394 s = toStringO(self); 11395 ck_assert_str_eq(s, "[1,null,3,null]"); 11396 free(s); 11397 // wrong object type 11398 createSmallInt(I); 11399 setValG(&I, 11); 11400 r2 = self->f->pushSmallInt(self, &I); 11401 ck_assert_ptr_ne(r2, null); 11402 r = self->f->getAtNDupUndefined(self,-1); 11403 ck_assert_ptr_eq(r, null); 11404 s = toStringO(self); 11405 ck_assert_str_eq(s, "[1,null,3,null,11]"); 11406 free(s); 11407 // index outside 11408 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, 20), NULL); 11409 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, -6), NULL); 11410 // empty list 11411 emptyO(self); 11412 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, 0), NULL); 11413 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, -1), NULL); 11414 // get empty slot in array 11415 r2 = self->f->pushUndefined(self); 11416 ck_assert_ptr_ne(r2, null); 11417 delElemO(self,0); 11418 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, 0), NULL); 11419 terminateO(self); 11420 11421 END_TEST 11422 11423 11424 START_TEST(getAtNDupBoolSmallArrayT) 11425 11426 bool r; 11427 smallArrayt *self = allocG(rtSmallArrayt); 11428 smallArrayt *r2; 11429 11430 // add elements to self 11431 r2 = self->f->pushInt(self, 1); 11432 ck_assert_ptr_ne(r2, null); 11433 r2 = self->f->pushBool(self, TRUE); 11434 ck_assert_ptr_ne(r2, null); 11435 r2 = self->f->pushInt(self, 3); 11436 ck_assert_ptr_ne(r2, null); 11437 r2 = self->f->pushBool(self, TRUE); 11438 ck_assert_ptr_ne(r2, null); 11439 11440 // positive index 11441 r = self->f->getAtNDupBool(self,1); 11442 ck_assert(r); 11443 char *s = toStringO(self); 11444 ck_assert_str_eq(s, "[1,true,3,true]"); 11445 free(s); 11446 // negative index 11447 r = self->f->getAtNDupBool(self,-1); 11448 ck_assert(r); 11449 s = toStringO(self); 11450 ck_assert_str_eq(s, "[1,true,3,true]"); 11451 free(s); 11452 // wrong object type 11453 createSmallInt(I); 11454 setValG(&I, 11); 11455 r2 = self->f->pushSmallInt(self, &I); 11456 r = self->f->getAtNDupBool(self,-1); 11457 ck_assert(!r); 11458 s = toStringO(self); 11459 ck_assert_str_eq(s, "[1,true,3,true,11]"); 11460 free(s); 11461 // wrong object type of another user class 11462 // User classes are stored in containers transparently 11463 createAllocateSmallInt(ip); 11464 ip->type = "anothertype"; 11465 setValG(ip, 11); 11466 r2 = self->f->push(self, (baset*)ip); 11467 ck_assert_ptr_ne(r2, null); 11468 r = self->f->getAtNDupBool(self,-1); 11469 ck_assert(!r); 11470 s = toStringO(self); 11471 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 11472 free(s); 11473 // index outside 11474 ck_assert(!self->f->getAtNDupBool(self, 20)); 11475 ck_assert(!self->f->getAtNDupBool(self, -7)); 11476 // empty list 11477 emptyO(self); 11478 ck_assert(!self->f->getAtNDupBool(self, 0)); 11479 ck_assert(!self->f->getAtNDupBool(self, -1)); 11480 terminateO(self); 11481 11482 END_TEST 11483 11484 11485 START_TEST(getAtNDupDoubleSmallArrayT) 11486 11487 double r; 11488 smallArrayt *self = allocG(rtSmallArrayt); 11489 smallArrayt *r2; 11490 11491 // add elements to self 11492 r2 = self->f->pushInt(self, 1); 11493 ck_assert_ptr_ne(r2, null); 11494 r2 = self->f->pushDouble(self, 2); 11495 ck_assert_ptr_ne(r2, null); 11496 r2 = self->f->pushInt(self, 3); 11497 ck_assert_ptr_ne(r2, null); 11498 r2 = self->f->pushDouble(self, 4); 11499 ck_assert_ptr_ne(r2, null); 11500 11501 // positive index 11502 r = self->f->getAtNDupDouble(self,1); 11503 ck_assert(r==2); 11504 char *s = toStringO(self); 11505 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 11506 free(s); 11507 // negative index 11508 r = self->f->getAtNDupDouble(self,-1); 11509 ck_assert(r==4); 11510 s = toStringO(self); 11511 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 11512 free(s); 11513 // wrong object type 11514 createSmallInt(I); 11515 setValG(&I, 11); 11516 r2 = self->f->pushSmallInt(self, &I); 11517 r = self->f->getAtNDupDouble(self,-1); 11518 ck_assert(!r); 11519 s = toStringO(self); 11520 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11]"); 11521 free(s); 11522 // wrong object type of another user class 11523 // User classes are stored in containers transparently 11524 createAllocateSmallInt(ip); 11525 ip->type = "anothertype"; 11526 setValG(ip, 11); 11527 r2 = self->f->push(self, (baset*)ip); 11528 ck_assert_ptr_ne(r2, null); 11529 r = self->f->getAtNDupDouble(self,-1); 11530 ck_assert(!r); 11531 s = toStringO(self); 11532 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11,\"<data container>\"]"); 11533 free(s); 11534 // index outside 11535 ck_assert(!self->f->getAtNDupDouble(self, 20)); 11536 ck_assert(!self->f->getAtNDupDouble(self, -7)); 11537 // empty list 11538 emptyO(self); 11539 ck_assert(!self->f->getAtNDupDouble(self, 0)); 11540 ck_assert(!self->f->getAtNDupDouble(self, -1)); 11541 terminateO(self); 11542 11543 END_TEST 11544 11545 11546 START_TEST(getAtNDupIntSmallArrayT) 11547 11548 int64_t r; 11549 smallArrayt *self = allocG(rtSmallArrayt); 11550 smallArrayt *r2; 11551 11552 // add elements to self 11553 r2 = self->f->pushInt(self, 1); 11554 ck_assert_ptr_ne(r2, null); 11555 r2 = self->f->pushInt(self, 2); 11556 ck_assert_ptr_ne(r2, null); 11557 r2 = self->f->pushInt(self, 3); 11558 ck_assert_ptr_ne(r2, null); 11559 r2 = self->f->pushInt(self, 4); 11560 ck_assert_ptr_ne(r2, null); 11561 11562 // positive index 11563 r = self->f->getAtNDupInt(self,1); 11564 ck_assert(r==2); 11565 char *s = toStringO(self); 11566 ck_assert_str_eq(s, "[1,2,3,4]"); 11567 free(s); 11568 // negative index 11569 r = self->f->getAtNDupInt(self,-1); 11570 ck_assert(r==4); 11571 s = toStringO(self); 11572 ck_assert_str_eq(s, "[1,2,3,4]"); 11573 free(s); 11574 // wrong object type 11575 createSmallDouble(I); 11576 setValG(&I, 11); 11577 r2 = self->f->pushSmallDouble(self, &I); 11578 r = self->f->getAtNDupInt(self,-1); 11579 ck_assert(!r); 11580 s = toStringO(self); 11581 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 11582 free(s); 11583 // wrong object type of another user class 11584 // User classes are stored in containers transparently 11585 createAllocateSmallInt(ip); 11586 ip->type = "anothertype"; 11587 setValG(ip, 11); 11588 r2 = self->f->push(self, (baset*)ip); 11589 ck_assert_ptr_ne(r2, null); 11590 r = self->f->getAtNDupInt(self,-1); 11591 ck_assert(!r); 11592 s = toStringO(self); 11593 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 11594 free(s); 11595 // index outside 11596 ck_assert(!self->f->getAtNDupInt(self, 20)); 11597 ck_assert(!self->f->getAtNDupInt(self, -7)); 11598 // empty list 11599 emptyO(self); 11600 ck_assert(!self->f->getAtNDupInt(self, 0)); 11601 ck_assert(!self->f->getAtNDupInt(self, -1)); 11602 terminateO(self); 11603 11604 END_TEST 11605 11606 11607 START_TEST(getAtNDupInt32SmallArrayT) 11608 11609 int32_t r; 11610 smallArrayt *self = allocG(rtSmallArrayt); 11611 smallArrayt *r2; 11612 11613 // add elements to self 11614 r2 = self->f->pushInt(self, 1); 11615 ck_assert_ptr_ne(r2, null); 11616 r2 = self->f->pushInt(self, 2); 11617 ck_assert_ptr_ne(r2, null); 11618 r2 = self->f->pushInt(self, 3); 11619 ck_assert_ptr_ne(r2, null); 11620 r2 = self->f->pushInt(self, 4); 11621 ck_assert_ptr_ne(r2, null); 11622 11623 // positive index 11624 r = self->f->getAtNDupInt32(self,1); 11625 ck_assert(r==2); 11626 char *s = toStringO(self); 11627 ck_assert_str_eq(s, "[1,2,3,4]"); 11628 free(s); 11629 // negative index 11630 r = self->f->getAtNDupInt32(self,-1); 11631 ck_assert(r==4); 11632 s = toStringO(self); 11633 ck_assert_str_eq(s, "[1,2,3,4]"); 11634 free(s); 11635 // wrong object type 11636 createSmallDouble(I); 11637 setValG(&I, 11); 11638 r2 = self->f->pushSmallDouble(self, &I); 11639 r = self->f->getAtNDupInt32(self,-1); 11640 ck_assert(!r); 11641 s = toStringO(self); 11642 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 11643 free(s); 11644 // wrong object type of another user class 11645 // User classes are stored in containers transparently 11646 createAllocateSmallInt(ip); 11647 ip->type = "anothertype"; 11648 setValG(ip, 11); 11649 r2 = self->f->push(self, (baset*)ip); 11650 ck_assert_ptr_ne(r2, null); 11651 r = self->f->getAtNDupInt32(self,-1); 11652 ck_assert(!r); 11653 s = toStringO(self); 11654 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 11655 free(s); 11656 // index outside 11657 ck_assert(!self->f->getAtNDupInt32(self, 20)); 11658 ck_assert(!self->f->getAtNDupInt32(self, -7)); 11659 // empty list 11660 emptyO(self); 11661 ck_assert(!self->f->getAtNDupInt32(self, 0)); 11662 ck_assert(!self->f->getAtNDupInt32(self, -1)); 11663 terminateO(self); 11664 11665 END_TEST 11666 11667 11668 START_TEST(getAtNDupUintSmallArrayT) 11669 11670 uint64_t r; 11671 smallArrayt *self = allocG(rtSmallArrayt); 11672 smallArrayt *r2; 11673 11674 // add elements to self 11675 r2 = self->f->pushInt(self, 1); 11676 ck_assert_ptr_ne(r2, null); 11677 r2 = self->f->pushInt(self, 2); 11678 ck_assert_ptr_ne(r2, null); 11679 r2 = self->f->pushInt(self, 3); 11680 ck_assert_ptr_ne(r2, null); 11681 r2 = self->f->pushInt(self, 4); 11682 ck_assert_ptr_ne(r2, null); 11683 11684 // positive index 11685 r = self->f->getAtNDupUint(self,1); 11686 ck_assert(r==2); 11687 char *s = toStringO(self); 11688 ck_assert_str_eq(s, "[1,2,3,4]"); 11689 free(s); 11690 // negative index 11691 r = self->f->getAtNDupUint(self,-1); 11692 ck_assert(r==4); 11693 s = toStringO(self); 11694 ck_assert_str_eq(s, "[1,2,3,4]"); 11695 free(s); 11696 // wrong object type 11697 createSmallDouble(I); 11698 setValG(&I, 11); 11699 r2 = self->f->pushSmallDouble(self, &I); 11700 r = self->f->getAtNDupUint(self,-1); 11701 ck_assert(!r); 11702 s = toStringO(self); 11703 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 11704 free(s); 11705 // wrong object type of another user class 11706 // User classes are stored in containers transparently 11707 createAllocateSmallInt(ip); 11708 ip->type = "anothertype"; 11709 setValG(ip, 11); 11710 r2 = self->f->push(self, (baset*)ip); 11711 ck_assert_ptr_ne(r2, null); 11712 r = self->f->getAtNDupUint(self,-1); 11713 ck_assert(!r); 11714 s = toStringO(self); 11715 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 11716 free(s); 11717 // index outside 11718 ck_assert(!self->f->getAtNDupUint(self, 20)); 11719 ck_assert(!self->f->getAtNDupUint(self, -7)); 11720 // empty list 11721 emptyO(self); 11722 ck_assert(!self->f->getAtNDupUint(self, 0)); 11723 ck_assert(!self->f->getAtNDupUint(self, -1)); 11724 terminateO(self); 11725 11726 END_TEST 11727 11728 11729 START_TEST(getAtNDupUint32SmallArrayT) 11730 11731 uint32_t r; 11732 smallArrayt *self = allocG(rtSmallArrayt); 11733 smallArrayt *r2; 11734 11735 // add elements to self 11736 r2 = self->f->pushInt(self, 1); 11737 ck_assert_ptr_ne(r2, null); 11738 r2 = self->f->pushInt(self, 2); 11739 ck_assert_ptr_ne(r2, null); 11740 r2 = self->f->pushInt(self, 3); 11741 ck_assert_ptr_ne(r2, null); 11742 r2 = self->f->pushInt(self, 4); 11743 ck_assert_ptr_ne(r2, null); 11744 11745 // positive index 11746 r = self->f->getAtNDupUint32(self,1); 11747 ck_assert(r==2); 11748 char *s = toStringO(self); 11749 ck_assert_str_eq(s, "[1,2,3,4]"); 11750 free(s); 11751 // negative index 11752 r = self->f->getAtNDupUint32(self,-1); 11753 ck_assert(r==4); 11754 s = toStringO(self); 11755 ck_assert_str_eq(s, "[1,2,3,4]"); 11756 free(s); 11757 // wrong object type 11758 createSmallDouble(I); 11759 setValG(&I, 11); 11760 r2 = self->f->pushSmallDouble(self, &I); 11761 r = self->f->getAtNDupUint32(self,-1); 11762 ck_assert(!r); 11763 s = toStringO(self); 11764 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 11765 free(s); 11766 // wrong object type of another user class 11767 // User classes are stored in containers transparently 11768 createAllocateSmallInt(ip); 11769 ip->type = "anothertype"; 11770 setValG(ip, 11); 11771 r2 = self->f->push(self, (baset*)ip); 11772 ck_assert_ptr_ne(r2, null); 11773 r = self->f->getAtNDupUint32(self,-1); 11774 ck_assert(!r); 11775 s = toStringO(self); 11776 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 11777 free(s); 11778 // index outside 11779 ck_assert(!self->f->getAtNDupUint32(self, 20)); 11780 ck_assert(!self->f->getAtNDupUint32(self, -7)); 11781 // empty list 11782 emptyO(self); 11783 ck_assert(!self->f->getAtNDupUint32(self, 0)); 11784 ck_assert(!self->f->getAtNDupUint32(self, -1)); 11785 terminateO(self); 11786 11787 END_TEST 11788 11789 11790 START_TEST(getAtNDupSSmallArrayT) 11791 11792 char* r; 11793 smallArrayt *self = allocG(rtSmallArrayt); 11794 smallArrayt *r2; 11795 11796 // add elements to self 11797 r2 = self->f->pushInt(self, 1); 11798 ck_assert_ptr_ne(r2, null); 11799 r2 = self->f->pushS(self, "2"); 11800 ck_assert_ptr_ne(r2, null); 11801 r2 = self->f->pushInt(self, 3); 11802 ck_assert_ptr_ne(r2, null); 11803 r2 = self->f->pushS(self, "4"); 11804 ck_assert_ptr_ne(r2, null); 11805 11806 // positive index 11807 r = self->f->getAtNDupS(self,1); 11808 ck_assert_ptr_ne(r, null); 11809 ck_assert_str_eq(r, "2"); 11810 free(r); 11811 char *s = toStringO(self); 11812 ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]"); 11813 free(s); 11814 // negative index 11815 r = self->f->getAtNDupS(self,-1); 11816 ck_assert_ptr_ne(r, null); 11817 ck_assert_str_eq(r, "4"); 11818 free(r); 11819 s = toStringO(self); 11820 ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]"); 11821 free(s); 11822 // wrong object type 11823 createSmallInt(I); 11824 setValG(&I, 11); 11825 r2 = self->f->pushSmallInt(self, &I); 11826 r = self->f->getAtNDupS(self,-1); 11827 ck_assert_ptr_eq(r, NULL); 11828 s = toStringO(self); 11829 ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11]"); 11830 free(s); 11831 // wrong object type of another user class 11832 // User classes are stored in containers transparently 11833 createAllocateSmallInt(ip); 11834 ip->type = "anothertype"; 11835 setValG(ip, 11); 11836 r2 = self->f->push(self, (baset*)ip); 11837 ck_assert_ptr_ne(r2, null); 11838 r = self->f->getAtNDupS(self,-1); 11839 ck_assert_ptr_eq(r, NULL); 11840 s = toStringO(self); 11841 ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11,\"<data container>\"]"); 11842 free(s); 11843 // index outside 11844 ck_assert_ptr_eq(self->f->getAtNDupS(self, 20), NULL); 11845 ck_assert_ptr_eq(self->f->getAtNDupS(self, -7), NULL); 11846 // empty list 11847 emptyO(self); 11848 ck_assert_ptr_eq(self->f->getAtNDupS(self, 0), NULL); 11849 ck_assert_ptr_eq(self->f->getAtNDupS(self, -1), NULL); 11850 terminateO(self); 11851 11852 END_TEST 11853 11854 11855 START_TEST(getAtNDupDictSmallArrayT) 11856 11857 smallDictt* r; 11858 smallArrayt *self = allocG(rtSmallArrayt); 11859 smallArrayt *r2; 11860 11861 // add elements to self 11862 r2 = self->f->pushInt(self, 1); 11863 ck_assert_ptr_ne(r2, null); 11864 createSmallDict(e2); 11865 r2 = self->f->pushDict(self, &e2); 11866 ck_assert_ptr_ne(r2, null); 11867 r2 = self->f->pushInt(self, 3); 11868 ck_assert_ptr_ne(r2, null); 11869 createSmallDict(e4); 11870 r2 = self->f->pushDict(self, &e4); 11871 ck_assert_ptr_ne(r2, null); 11872 11873 // positive index 11874 r = self->f->getAtNDupDict(self,1); 11875 ck_assert_ptr_ne(r, null); 11876 char *s = toStringO(r); 11877 terminateO(r); 11878 ck_assert_str_eq(s, "{}"); 11879 free(s); 11880 s = toStringO(self); 11881 ck_assert_str_eq(s, "[1,{},3,{}]"); 11882 free(s); 11883 // negative index 11884 r = self->f->getAtNDupDict(self,-1); 11885 ck_assert_ptr_ne(r, null); 11886 s = toStringO(r); 11887 terminateO(r); 11888 ck_assert_str_eq(s, "{}"); 11889 free(s); 11890 s = toStringO(self); 11891 ck_assert_str_eq(s, "[1,{},3,{}]"); 11892 free(s); 11893 // wrong object type 11894 createSmallInt(I); 11895 setValG(&I, 11); 11896 r2 = self->f->pushSmallInt(self, &I); 11897 r = self->f->getAtNDupDict(self,-1); 11898 ck_assert_ptr_eq(r, NULL); 11899 s = toStringO(self); 11900 ck_assert_str_eq(s, "[1,{},3,{},11]"); 11901 free(s); 11902 // wrong object type of another user class 11903 // User classes are stored in containers transparently 11904 createAllocateSmallInt(ip); 11905 ip->type = "anothertype"; 11906 setValG(ip, 11); 11907 r2 = self->f->push(self, (baset*)ip); 11908 ck_assert_ptr_ne(r2, null); 11909 r = self->f->getAtNDupDict(self,-1); 11910 ck_assert_ptr_eq(r, NULL); 11911 s = toStringO(self); 11912 ck_assert_str_eq(s, "[1,{},3,{},11,\"<data container>\"]"); 11913 free(s); 11914 // index outside 11915 ck_assert_ptr_eq(self->f->getAtNDupDict(self, 20), NULL); 11916 ck_assert_ptr_eq(self->f->getAtNDupDict(self, -7), NULL); 11917 // empty list 11918 emptyO(self); 11919 ck_assert_ptr_eq(self->f->getAtNDupDict(self, 0), NULL); 11920 ck_assert_ptr_eq(self->f->getAtNDupDict(self, -1), NULL); 11921 // get empty slot in array 11922 r2 = self->f->pushUndefined(self); 11923 ck_assert_ptr_ne(r2, null); 11924 delElemO(self,0); 11925 ck_assert_ptr_eq(self->f->getAtNDupDict(self, 0), NULL); 11926 terminateO(self); 11927 11928 END_TEST 11929 11930 11931 START_TEST(getAtNDupArraySmallArrayT) 11932 11933 smallArrayt* r; 11934 smallArrayt *self = allocG(rtSmallArrayt); 11935 smallArrayt *r2; 11936 11937 // add elements to self 11938 r2 = self->f->pushInt(self, 1); 11939 ck_assert_ptr_ne(r2, null); 11940 createSmallArray(e2); 11941 r2 = self->f->pushArray(self, &e2); 11942 ck_assert_ptr_ne(r2, null); 11943 r2 = self->f->pushInt(self, 3); 11944 ck_assert_ptr_ne(r2, null); 11945 createSmallArray(e4); 11946 r2 = self->f->pushArray(self, &e4); 11947 ck_assert_ptr_ne(r2, null); 11948 11949 // positive index 11950 r = self->f->getAtNDupArray(self,1); 11951 ck_assert_ptr_ne(r, null); 11952 char *s = toStringO(r); 11953 terminateO(r); 11954 ck_assert_str_eq(s, "[]"); 11955 free(s); 11956 s = toStringO(self); 11957 ck_assert_str_eq(s, "[1,[],3,[]]"); 11958 free(s); 11959 // negative index 11960 r = self->f->getAtNDupArray(self,-1); 11961 ck_assert_ptr_ne(r, null); 11962 s = toStringO(r); 11963 terminateO(r); 11964 ck_assert_str_eq(s, "[]"); 11965 free(s); 11966 s = toStringO(self); 11967 ck_assert_str_eq(s, "[1,[],3,[]]"); 11968 free(s); 11969 // wrong object type 11970 createSmallInt(I); 11971 setValG(&I, 11); 11972 r2 = self->f->pushSmallInt(self, &I); 11973 r = self->f->getAtNDupArray(self,-1); 11974 ck_assert_ptr_eq(r, NULL); 11975 s = toStringO(self); 11976 ck_assert_str_eq(s, "[1,[],3,[],11]"); 11977 free(s); 11978 // wrong object type of another user class 11979 // User classes are stored in containers transparently 11980 createAllocateSmallInt(ip); 11981 ip->type = "anothertype"; 11982 setValG(ip, 11); 11983 r2 = self->f->push(self, (baset*)ip); 11984 ck_assert_ptr_ne(r2, null); 11985 r = self->f->getAtNDupArray(self,-1); 11986 ck_assert_ptr_eq(r, NULL); 11987 s = toStringO(self); 11988 ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]"); 11989 free(s); 11990 // index outside 11991 ck_assert_ptr_eq(self->f->getAtNDupArray(self, 20), NULL); 11992 ck_assert_ptr_eq(self->f->getAtNDupArray(self, -7), NULL); 11993 // empty list 11994 emptyO(self); 11995 ck_assert_ptr_eq(self->f->getAtNDupArray(self, 0), NULL); 11996 ck_assert_ptr_eq(self->f->getAtNDupArray(self, -1), NULL); 11997 // get empty slot in array 11998 r2 = self->f->pushUndefined(self); 11999 ck_assert_ptr_ne(r2, null); 12000 delElemO(self,0); 12001 ck_assert_ptr_eq(self->f->getAtNDupArray(self, 0), NULL); 12002 terminateO(self); 12003 12004 END_TEST 12005 12006 12007 START_TEST(getAtNDupSmallBoolSmallArrayT) 12008 12009 smallBoolt* r; 12010 smallArrayt *self = allocG(rtSmallArrayt); 12011 smallArrayt *r2; 12012 12013 // add elements to self 12014 r2 = self->f->pushInt(self, 1); 12015 ck_assert_ptr_ne(r2, null); 12016 createSmallBool(e2); 12017 r2 = self->f->pushBool(self, true); 12018 ck_assert_ptr_ne(r2, null); 12019 r2 = self->f->pushInt(self, 3); 12020 ck_assert_ptr_ne(r2, null); 12021 createSmallBool(e4); 12022 r2 = self->f->pushBool(self, true); 12023 ck_assert_ptr_ne(r2, null); 12024 12025 // positive index 12026 r = self->f->getAtNDupSmallBool(self,1); 12027 ck_assert_ptr_ne(r, null); 12028 char *s = toStringO(r); 12029 terminateO(r); 12030 ck_assert_str_eq(s, "true"); 12031 free(s); 12032 s = toStringO(self); 12033 ck_assert_str_eq(s, "[1,true,3,true]"); 12034 free(s); 12035 // negative index 12036 r = self->f->getAtNDupSmallBool(self,-1); 12037 ck_assert_ptr_ne(r, null); 12038 s = toStringO(r); 12039 terminateO(r); 12040 ck_assert_str_eq(s, "true"); 12041 free(s); 12042 s = toStringO(self); 12043 ck_assert_str_eq(s, "[1,true,3,true]"); 12044 free(s); 12045 // wrong object type 12046 createSmallInt(I); 12047 setValG(&I, 11); 12048 r2 = self->f->pushSmallInt(self, &I); 12049 r = self->f->getAtNDupSmallBool(self,2); 12050 ck_assert_ptr_eq(r, NULL); 12051 s = toStringO(self); 12052 ck_assert_str_eq(s, "[1,true,3,true,11]"); 12053 free(s); 12054 // wrong object type of another user class 12055 // User classes are stored in containers transparently 12056 createAllocateSmallInt(ip); 12057 ip->type = "anothertype"; 12058 setValG(ip, 11); 12059 r2 = self->f->push(self, (baset*)ip); 12060 ck_assert_ptr_ne(r2, null); 12061 r = self->f->getAtNDupSmallBool(self,-1); 12062 ck_assert_ptr_eq(r, NULL); 12063 s = toStringO(self); 12064 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 12065 free(s); 12066 // index outside 12067 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, 20), NULL); 12068 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, -7), NULL); 12069 // empty list 12070 emptyO(self); 12071 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, 0), NULL); 12072 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, -1), NULL); 12073 // get empty slot in array 12074 r2 = self->f->pushUndefined(self); 12075 ck_assert_ptr_ne(r2, null); 12076 delElemO(self,0); 12077 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, 0), NULL); 12078 terminateO(self); 12079 12080 END_TEST 12081 12082 12083 START_TEST(getAtNDupSmallBytesSmallArrayT) 12084 12085 smallBytest* r; 12086 smallArrayt *self = allocG(rtSmallArrayt); 12087 smallArrayt *r2; 12088 12089 // add elements to self 12090 r2 = self->f->pushInt(self, 1); 12091 ck_assert_ptr_ne(r2, null); 12092 createSmallBytes(e2); 12093 r2 = self->f->pushSmallBytes(self, &e2); 12094 ck_assert_ptr_ne(r2, null); 12095 r2 = self->f->pushInt(self, 3); 12096 ck_assert_ptr_ne(r2, null); 12097 createSmallBytes(e4); 12098 r2 = self->f->pushSmallBytes(self, &e4); 12099 ck_assert_ptr_ne(r2, null); 12100 12101 // positive index 12102 r = self->f->getAtNDupSmallBytes(self,1); 12103 ck_assert_ptr_ne(r, null); 12104 char *s = toStringO(r); 12105 terminateO(r); 12106 ck_assert_str_eq(s, "[]"); 12107 free(s); 12108 s = toStringO(self); 12109 ck_assert_str_eq(s, "[1,[],3,[]]"); 12110 free(s); 12111 // negative index 12112 r = self->f->getAtNDupSmallBytes(self,-1); 12113 ck_assert_ptr_ne(r, null); 12114 s = toStringO(r); 12115 terminateO(r); 12116 ck_assert_str_eq(s, "[]"); 12117 free(s); 12118 s = toStringO(self); 12119 ck_assert_str_eq(s, "[1,[],3,[]]"); 12120 free(s); 12121 // wrong object type 12122 createSmallInt(I); 12123 setValG(&I, 11); 12124 r2 = self->f->pushSmallInt(self, &I); 12125 r = self->f->getAtNDupSmallBytes(self,-1); 12126 ck_assert_ptr_eq(r, NULL); 12127 s = toStringO(self); 12128 ck_assert_str_eq(s, "[1,[],3,[],11]"); 12129 free(s); 12130 // wrong object type of another user class 12131 // User classes are stored in containers transparently 12132 createAllocateSmallInt(ip); 12133 ip->type = "anothertype"; 12134 setValG(ip, 11); 12135 r2 = self->f->push(self, (baset*)ip); 12136 ck_assert_ptr_ne(r2, null); 12137 r = self->f->getAtNDupSmallBytes(self,-1); 12138 ck_assert_ptr_eq(r, NULL); 12139 s = toStringO(self); 12140 ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]"); 12141 free(s); 12142 // index outside 12143 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, 20), NULL); 12144 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, -7), NULL); 12145 // empty list 12146 emptyO(self); 12147 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, 0), NULL); 12148 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, -1), NULL); 12149 // get empty slot in array 12150 r2 = self->f->pushUndefined(self); 12151 ck_assert_ptr_ne(r2, null); 12152 delElemO(self,0); 12153 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, 0), NULL); 12154 terminateO(self); 12155 12156 END_TEST 12157 12158 12159 START_TEST(getAtNDupSmallDoubleSmallArrayT) 12160 12161 smallDoublet* r; 12162 smallArrayt *self = allocG(rtSmallArrayt); 12163 smallArrayt *r2; 12164 12165 // add elements to self 12166 r2 = self->f->pushInt(self, 1); 12167 ck_assert_ptr_ne(r2, null); 12168 createSmallDouble(e2); 12169 r2 = self->f->pushSmallDouble(self, &e2); 12170 ck_assert_ptr_ne(r2, null); 12171 r2 = self->f->pushInt(self, 3); 12172 ck_assert_ptr_ne(r2, null); 12173 createSmallDouble(e4); 12174 r2 = self->f->pushSmallDouble(self, &e4); 12175 ck_assert_ptr_ne(r2, null); 12176 12177 // positive index 12178 r = self->f->getAtNDupSmallDouble(self,1); 12179 ck_assert_ptr_ne(r, null); 12180 char *s = toStringO(r); 12181 terminateO(r); 12182 ck_assert_str_eq(s, "0.000000e+00"); 12183 free(s); 12184 s = toStringO(self); 12185 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]"); 12186 free(s); 12187 // negative index 12188 r = self->f->getAtNDupSmallDouble(self,-1); 12189 ck_assert_ptr_ne(r, null); 12190 s = toStringO(r); 12191 terminateO(r); 12192 ck_assert_str_eq(s, "0.000000e+00"); 12193 free(s); 12194 s = toStringO(self); 12195 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]"); 12196 free(s); 12197 // wrong object type 12198 createSmallInt(I); 12199 setValG(&I, 11); 12200 r2 = self->f->pushSmallInt(self, &I); 12201 r = self->f->getAtNDupSmallDouble(self,-1); 12202 ck_assert_ptr_eq(r, NULL); 12203 s = toStringO(self); 12204 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11]"); 12205 free(s); 12206 // wrong object type of another user class 12207 // User classes are stored in containers transparently 12208 createAllocateSmallInt(ip); 12209 ip->type = "anothertype"; 12210 setValG(ip, 11); 12211 r2 = self->f->push(self, (baset*)ip); 12212 ck_assert_ptr_ne(r2, null); 12213 r = self->f->getAtNDupSmallDouble(self,-1); 12214 ck_assert_ptr_eq(r, NULL); 12215 s = toStringO(self); 12216 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11,\"<data container>\"]"); 12217 free(s); 12218 // index outside 12219 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, 20), NULL); 12220 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, -7), NULL); 12221 // empty list 12222 emptyO(self); 12223 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, 0), NULL); 12224 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, -1), NULL); 12225 // get empty slot in array 12226 r2 = self->f->pushUndefined(self); 12227 ck_assert_ptr_ne(r2, null); 12228 delElemO(self,0); 12229 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, 0), NULL); 12230 terminateO(self); 12231 12232 END_TEST 12233 12234 12235 START_TEST(getAtNDupSmallIntSmallArrayT) 12236 12237 smallIntt* r; 12238 smallArrayt *self = allocG(rtSmallArrayt); 12239 smallArrayt *r2; 12240 12241 // add elements to self 12242 r2 = self->f->pushBool(self, true); 12243 ck_assert_ptr_ne(r2, null); 12244 createSmallInt(e2); 12245 r2 = self->f->pushSmallInt(self, &e2); 12246 ck_assert_ptr_ne(r2, null); 12247 r2 = self->f->pushBool(self, true); 12248 ck_assert_ptr_ne(r2, null); 12249 createSmallInt(e4); 12250 r2 = self->f->pushSmallInt(self, &e4); 12251 ck_assert_ptr_ne(r2, null); 12252 12253 // positive index 12254 r = self->f->getAtNDupSmallInt(self,1); 12255 ck_assert_ptr_ne(r, null); 12256 char *s = toStringO(r); 12257 terminateO(r); 12258 ck_assert_str_eq(s, "0"); 12259 free(s); 12260 s = toStringO(self); 12261 ck_assert_str_eq(s, "[true,0,true,0]"); 12262 free(s); 12263 // negative index 12264 r = self->f->getAtNDupSmallInt(self,-1); 12265 ck_assert_ptr_ne(r, null); 12266 s = toStringO(r); 12267 terminateO(r); 12268 ck_assert_str_eq(s, "0"); 12269 free(s); 12270 s = toStringO(self); 12271 ck_assert_str_eq(s, "[true,0,true,0]"); 12272 free(s); 12273 // wrong object type 12274 createSmallDouble(I); 12275 setValG(&I, 11); 12276 r2 = self->f->pushSmallDouble(self, &I); 12277 r = self->f->getAtNDupSmallInt(self,-1); 12278 ck_assert_ptr_eq(r, NULL); 12279 s = toStringO(self); 12280 ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01]"); 12281 free(s); 12282 // wrong object type of another user class 12283 // User classes are stored in containers transparently 12284 createAllocateSmallInt(ip); 12285 ip->type = "anothertype"; 12286 setValG(ip, 11); 12287 r2 = self->f->push(self, (baset*)ip); 12288 ck_assert_ptr_ne(r2, null); 12289 r = self->f->getAtNDupSmallInt(self,-1); 12290 ck_assert_ptr_eq(r, NULL); 12291 s = toStringO(self); 12292 ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01,\"<data container>\"]"); 12293 free(s); 12294 // index outside 12295 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, 20), NULL); 12296 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, -7), NULL); 12297 // empty list 12298 emptyO(self); 12299 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, 0), NULL); 12300 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, -1), NULL); 12301 // get empty slot in array 12302 r2 = self->f->pushUndefined(self); 12303 ck_assert_ptr_ne(r2, null); 12304 delElemO(self,0); 12305 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, 0), NULL); 12306 terminateO(self); 12307 12308 END_TEST 12309 12310 12311 START_TEST(getAtNDupSmallJsonSmallArrayT) 12312 12313 smallJsont* r; 12314 smallArrayt *self = allocG(rtSmallArrayt); 12315 smallArrayt *r2; 12316 12317 // add elements to self 12318 r2 = self->f->pushInt(self, 1); 12319 ck_assert_ptr_ne(r2, null); 12320 createSmallJson(e2); 12321 r2 = self->f->pushSmallJson(self, &e2); 12322 ck_assert_ptr_ne(r2, null); 12323 r2 = self->f->pushInt(self, 3); 12324 ck_assert_ptr_ne(r2, null); 12325 createSmallJson(e4); 12326 r2 = self->f->pushSmallJson(self, &e4); 12327 ck_assert_ptr_ne(r2, null); 12328 12329 // positive index 12330 r = self->f->getAtNDupSmallJson(self,1); 12331 ck_assert_ptr_ne(r, null); 12332 char *s = toStringO(r); 12333 terminateO(r); 12334 ck_assert_str_eq(s, "{}"); 12335 free(s); 12336 s = toStringO(self); 12337 ck_assert_str_eq(s, "[1,{},3,{}]"); 12338 free(s); 12339 // negative index 12340 r = self->f->getAtNDupSmallJson(self,-1); 12341 ck_assert_ptr_ne(r, null); 12342 s = toStringO(r); 12343 terminateO(r); 12344 ck_assert_str_eq(s, "{}"); 12345 free(s); 12346 s = toStringO(self); 12347 ck_assert_str_eq(s, "[1,{},3,{}]"); 12348 free(s); 12349 // wrong object type 12350 createSmallBytes(I); 12351 r2 = self->f->pushSmallBytes(self, &I); 12352 r = self->f->getAtNDupSmallJson(self,-1); 12353 ck_assert_ptr_eq(r, NULL); 12354 s = toStringO(self); 12355 ck_assert_str_eq(s, "[1,{},3,{},[]]"); 12356 free(s); 12357 // wrong object type of another user class 12358 // User classes are stored in containers transparently 12359 createAllocateSmallInt(ip); 12360 ip->type = "anothertype"; 12361 setValG(ip, 11); 12362 r2 = self->f->push(self, (baset*)ip); 12363 ck_assert_ptr_ne(r2, null); 12364 r = self->f->getAtNDupSmallJson(self,-1); 12365 ck_assert_ptr_eq(r, NULL); 12366 s = toStringO(self); 12367 ck_assert_str_eq(s, "[1,{},3,{},[],\"<data container>\"]"); 12368 free(s); 12369 // index outside 12370 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, 20), NULL); 12371 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, -7), NULL); 12372 // empty list 12373 emptyO(self); 12374 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, 0), NULL); 12375 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, -1), NULL); 12376 // get empty slot in array 12377 r2 = self->f->pushUndefined(self); 12378 ck_assert_ptr_ne(r2, null); 12379 delElemO(self,0); 12380 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, 0), NULL); 12381 terminateO(self); 12382 12383 END_TEST 12384 12385 12386 START_TEST(getAtNDupSmallStringSmallArrayT) 12387 12388 smallStringt* r; 12389 smallArrayt *self = allocG(rtSmallArrayt); 12390 smallArrayt *r2; 12391 12392 // add elements to self 12393 r2 = self->f->pushInt(self, 1); 12394 ck_assert_ptr_ne(r2, null); 12395 createSmallString(e2); 12396 r2 = self->f->pushSmallString(self, &e2); 12397 ck_assert_ptr_ne(r2, null); 12398 r2 = self->f->pushInt(self, 3); 12399 ck_assert_ptr_ne(r2, null); 12400 createSmallString(e4); 12401 r2 = self->f->pushSmallString(self, &e4); 12402 ck_assert_ptr_ne(r2, null); 12403 12404 // positive index 12405 r = self->f->getAtNDupSmallString(self,1); 12406 ck_assert_ptr_ne(r, null); 12407 char *s = toStringO(r); 12408 terminateO(r); 12409 ck_assert_str_eq(s, ""); 12410 free(s); 12411 s = toStringO(self); 12412 ck_assert_str_eq(s, "[1,\"\",3,\"\"]"); 12413 free(s); 12414 // negative index 12415 r = self->f->getAtNDupSmallString(self,-1); 12416 ck_assert_ptr_ne(r, null); 12417 s = toStringO(r); 12418 terminateO(r); 12419 ck_assert_str_eq(s, ""); 12420 free(s); 12421 s = toStringO(self); 12422 ck_assert_str_eq(s, "[1,\"\",3,\"\"]"); 12423 free(s); 12424 // wrong object type 12425 createSmallInt(I); 12426 setValG(&I, 11); 12427 r2 = self->f->pushSmallInt(self, &I); 12428 r = self->f->getAtNDupSmallString(self,-1); 12429 ck_assert_ptr_eq(r, NULL); 12430 s = toStringO(self); 12431 ck_assert_str_eq(s, "[1,\"\",3,\"\",11]"); 12432 free(s); 12433 // wrong object type of another user class 12434 // User classes are stored in containers transparently 12435 createAllocateSmallInt(ip); 12436 ip->type = "anothertype"; 12437 setValG(ip, 11); 12438 r2 = self->f->push(self, (baset*)ip); 12439 ck_assert_ptr_ne(r2, null); 12440 r = self->f->getAtNDupSmallString(self,-1); 12441 ck_assert_ptr_eq(r, NULL); 12442 s = toStringO(self); 12443 ck_assert_str_eq(s, "[1,\"\",3,\"\",11,\"<data container>\"]"); 12444 free(s); 12445 // index outside 12446 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, 20), NULL); 12447 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, -7), NULL); 12448 // empty list 12449 emptyO(self); 12450 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, 0), NULL); 12451 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, -1), NULL); 12452 // get empty slot in array 12453 r2 = self->f->pushUndefined(self); 12454 ck_assert_ptr_ne(r2, null); 12455 delElemO(self,0); 12456 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, 0), NULL); 12457 terminateO(self); 12458 12459 END_TEST 12460 12461 12462 START_TEST(getAtNDupVoidSmallArrayT) 12463 12464 void* r; 12465 smallArrayt *self = allocG(rtSmallArrayt); 12466 smallArrayt *r2; 12467 12468 // add elements to self 12469 r2 = self->f->pushInt(self, 1); 12470 ck_assert_ptr_ne(r2, null); 12471 r2 = pushVoidSmallArrayG(self, &r); 12472 ck_assert_ptr_ne(r2, null); 12473 r2 = self->f->pushInt(self, 3); 12474 ck_assert_ptr_ne(r2, null); 12475 r2 = pushVoidSmallArrayG(self, &self); 12476 ck_assert_ptr_ne(r2, null); 12477 12478 // positive index 12479 r = self->f->getAtNDupVoid(self,1); 12480 // duplicate function is not set so the data is not duplicated 12481 ck_assert_ptr_eq(r, NULL); 12482 char *s = toStringO(self); 12483 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 12484 free(s); 12485 // negative index 12486 r = self->f->getAtNDupVoid(self,-1); 12487 // duplicate function is not set so the data is not duplicated 12488 ck_assert_ptr_eq(r, NULL); 12489 s = toStringO(self); 12490 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 12491 free(s); 12492 // wrong object type 12493 createSmallInt(I); 12494 setValG(&I, 11); 12495 r2 = self->f->pushSmallInt(self, &I); 12496 r = self->f->getAtNDupVoid(self,-1); 12497 ck_assert_ptr_eq(r, NULL); 12498 s = toStringO(self); 12499 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]"); 12500 free(s); 12501 // wrong object type of another user class 12502 // User classes are stored in containers transparently 12503 createAllocateSmallInt(ip); 12504 ip->type = "anothertype"; 12505 setValG(ip, 11); 12506 r2 = self->f->push(self, (baset*)ip); 12507 ck_assert_ptr_ne(r2, null); 12508 r = self->f->getAtNDupVoid(self,-1); 12509 ck_assert_ptr_eq(r, NULL); 12510 s = toStringO(self); 12511 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]"); 12512 free(s); 12513 // index outside 12514 ck_assert_ptr_eq(self->f->getAtNDupVoid(self, 20), NULL); 12515 ck_assert_ptr_eq(self->f->getAtNDupVoid(self, -7), NULL); 12516 // empty list 12517 emptyO(self); 12518 ck_assert_ptr_eq(self->f->getAtNDupVoid(self, 0), NULL); 12519 ck_assert_ptr_eq(self->f->getAtNDupVoid(self, -1), NULL); 12520 terminateO(self); 12521 12522 END_TEST 12523 12524 12525 START_TEST(getAtNDupSmallContainerSmallArrayT) 12526 12527 smallContainert* r; 12528 smallArrayt *self = allocG(rtSmallArrayt); 12529 smallArrayt *r2; 12530 12531 // add elements to self 12532 r2 = self->f->pushInt(self, 1); 12533 ck_assert_ptr_ne(r2, null); 12534 createSmallContainer(e2); 12535 r2 = self->f->pushSmallContainer(self, &e2); 12536 ck_assert_ptr_ne(r2, null); 12537 r2 = self->f->pushInt(self, 3); 12538 ck_assert_ptr_ne(r2, null); 12539 createSmallContainer(e4); 12540 r2 = self->f->pushSmallContainer(self, &e4); 12541 ck_assert_ptr_ne(r2, null); 12542 12543 // positive index 12544 r = self->f->getAtNDupSmallContainer(self,1); 12545 ck_assert_ptr_ne(r, null); 12546 char *s = toStringO(r); 12547 terminateO(r); 12548 ck_assert_str_eq(s, "<data smallContainer>"); 12549 free(s); 12550 s = toStringO(self); 12551 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 12552 free(s); 12553 // negative index 12554 r = self->f->getAtNDupSmallContainer(self,-1); 12555 ck_assert_ptr_ne(r, null); 12556 s = toStringO(r); 12557 terminateO(r); 12558 ck_assert_str_eq(s, "<data smallContainer>"); 12559 free(s); 12560 s = toStringO(self); 12561 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 12562 free(s); 12563 // wrong object type 12564 createSmallInt(I); 12565 setValG(&I, 11); 12566 r2 = self->f->pushSmallInt(self, &I); 12567 r = self->f->getAtNDupSmallContainer(self,-1); 12568 ck_assert_ptr_eq(r, NULL); 12569 s = toStringO(self); 12570 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]"); 12571 free(s); 12572 // wrong object type of another user class 12573 // User classes are stored in containers transparently 12574 createAllocateSmallInt(ip); 12575 ip->type = "anothertype"; 12576 setValG(ip, 11); 12577 r2 = self->f->push(self, (baset*)ip); 12578 ck_assert_ptr_ne(r2, null); 12579 r = self->f->getAtNDupSmallContainer(self,-1); 12580 ck_assert_ptr_eq(r, NULL); 12581 s = toStringO(self); 12582 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]"); 12583 free(s); 12584 // index outside 12585 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, 20), NULL); 12586 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, -7), NULL); 12587 // empty list 12588 emptyO(self); 12589 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, 0), NULL); 12590 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, -1), NULL); 12591 // get empty slot in array 12592 r2 = self->f->pushUndefined(self); 12593 ck_assert_ptr_ne(r2, null); 12594 delElemO(self,0); 12595 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, 0), NULL); 12596 terminateO(self); 12597 12598 END_TEST 12599 12600 12601 START_TEST(setAtSmallArrayT) 12602 12603 smallArrayt* r; 12604 smallArrayt *self = allocG(rtSmallArrayt); 12605 baset *value; 12606 12607 // add elements to self 12608 r = self->f->pushInt(self, 1); 12609 ck_assert_ptr_ne(r, null); 12610 r = self->f->pushInt(self, 2); 12611 ck_assert_ptr_ne(r, null); 12612 r = self->f->pushInt(self, 3); 12613 ck_assert_ptr_ne(r, null); 12614 r = self->f->pushInt(self, 4); 12615 ck_assert_ptr_ne(r, null); 12616 12617 // positive index 12618 value = (baset*)allocSmallInt(123); 12619 r = self->f->setAt(self, 1, value); 12620 ck_assert_ptr_ne(r, null); 12621 finishO(value); 12622 char *s = toStringO(r); 12623 ck_assert_str_eq(s, "[1,123,3,4]"); 12624 free(s); 12625 // negative index 12626 value = (baset*)allocSmallInt(234); 12627 r = self->f->setAt(self, -1, value); 12628 ck_assert_ptr_ne(r, null); 12629 finishO(value); 12630 s = toStringO(r); 12631 ck_assert_str_eq(s, "[1,123,3,234]"); 12632 free(s); 12633 // undefined object 12634 value = (baset*)allocUndefined(); 12635 r = self->f->setAt(self, -1, value); 12636 ck_assert_ptr_ne(r, null); 12637 finishO(value); 12638 s = toStringO(r); 12639 ck_assert_str_eq(s, "[1,123,3,null]"); 12640 free(s); 12641 // container 12642 createAllocateSmallContainer(c); 12643 r = self->f->setAt(self, -1, (baset*)c); 12644 ck_assert_ptr_ne(r, null); 12645 finishO(c); 12646 s = toStringO(r); 12647 ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]"); 12648 free(s); 12649 // base object in container 12650 createAllocateSmallInt(I); 12651 setValG(I, 11); 12652 I->type = "anothertype"; 12653 r = self->f->setAt(self, -1, (baset*)I); 12654 ck_assert_ptr_ne(r, null); 12655 s = toStringO(r); 12656 ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]"); 12657 free(s); 12658 // index outside 12659 value = (baset*)allocSmallInt(123); 12660 ck_assert_ptr_eq(self->f->setAt(self, 20, value), NULL); 12661 ck_assert_ptr_eq(self->f->setAt(self, -8, value), NULL); 12662 // empty list 12663 emptyO(self); 12664 ck_assert_ptr_eq(self->f->setAt(self, 0, value), NULL); 12665 ck_assert_ptr_eq(self->f->setAt(self, -1, value), NULL); 12666 terminateO(value); 12667 // NULL value 12668 ck_assert_ptr_eq(self->f->setAt(self, 0, NULL), NULL); 12669 terminateO(self); 12670 12671 END_TEST 12672 12673 12674 START_TEST(setAtUndefinedSmallArrayT) 12675 12676 smallArrayt* r; 12677 smallArrayt *self = allocG(rtSmallArrayt); 12678 12679 // add elements to self 12680 r = self->f->pushInt(self, 1); 12681 ck_assert_ptr_ne(r, null); 12682 r = self->f->pushInt(self, 2); 12683 ck_assert_ptr_ne(r, null); 12684 r = self->f->pushInt(self, 3); 12685 ck_assert_ptr_ne(r, null); 12686 r = self->f->pushInt(self, 4); 12687 ck_assert_ptr_ne(r, null); 12688 12689 // positive index 12690 r = self->f->setAtUndefined(self, 1); 12691 ck_assert_ptr_ne(r, null); 12692 char *s = toStringO(r); 12693 ck_assert_str_eq(s, "[1,null,3,4]"); 12694 free(s); 12695 // negative index 12696 r = self->f->setAtUndefined(self, -1); 12697 ck_assert_ptr_ne(r, null); 12698 s = toStringO(r); 12699 ck_assert_str_eq(s, "[1,null,3,null]"); 12700 free(s); 12701 // index outside 12702 ck_assert_ptr_eq(self->f->setAtUndefined(self, 20), NULL); 12703 ck_assert_ptr_eq(self->f->setAtUndefined(self, -8), NULL); 12704 // empty list 12705 emptyO(self); 12706 ck_assert_ptr_eq(self->f->setAtUndefined(self, 0), NULL); 12707 ck_assert_ptr_eq(self->f->setAtUndefined(self, -1), NULL); 12708 terminateO(self); 12709 12710 END_TEST 12711 12712 12713 START_TEST(setAtBoolSmallArrayT) 12714 12715 smallArrayt* r; 12716 smallArrayt *self = allocG(rtSmallArrayt); 12717 12718 // add elements to self 12719 r = self->f->pushInt(self, 1); 12720 ck_assert_ptr_ne(r, null); 12721 r = self->f->pushInt(self, 2); 12722 ck_assert_ptr_ne(r, null); 12723 r = self->f->pushInt(self, 3); 12724 ck_assert_ptr_ne(r, null); 12725 r = self->f->pushInt(self, 4); 12726 ck_assert_ptr_ne(r, null); 12727 12728 // positive index 12729 r = self->f->setAtBool(self, 1, true); 12730 ck_assert_ptr_ne(r, null); 12731 char *s = toStringO(r); 12732 ck_assert_str_eq(s, "[1,true,3,4]"); 12733 free(s); 12734 // negative index 12735 r = self->f->setAtBool(self, -1, true); 12736 ck_assert_ptr_ne(r, null); 12737 s = toStringO(r); 12738 ck_assert_str_eq(s, "[1,true,3,true]"); 12739 free(s); 12740 // index outside 12741 ck_assert_ptr_eq(self->f->setAtBool(self, 20, true), NULL); 12742 ck_assert_ptr_eq(self->f->setAtBool(self, -8, true), NULL); 12743 // empty list 12744 emptyO(self); 12745 ck_assert_ptr_eq(self->f->setAtBool(self, 0, true), NULL); 12746 ck_assert_ptr_eq(self->f->setAtBool(self, -1, true), NULL); 12747 terminateO(self); 12748 12749 END_TEST 12750 12751 12752 START_TEST(setAtDoubleSmallArrayT) 12753 12754 smallArrayt* r; 12755 smallArrayt *self = allocG(rtSmallArrayt); 12756 12757 // add elements to self 12758 r = self->f->pushInt(self, 1); 12759 ck_assert_ptr_ne(r, null); 12760 r = self->f->pushInt(self, 2); 12761 ck_assert_ptr_ne(r, null); 12762 r = self->f->pushInt(self, 3); 12763 ck_assert_ptr_ne(r, null); 12764 r = self->f->pushInt(self, 4); 12765 ck_assert_ptr_ne(r, null); 12766 12767 // positive index 12768 r = self->f->setAtDouble(self, 1, 12); 12769 ck_assert_ptr_ne(r, null); 12770 char *s = toStringO(r); 12771 ck_assert_str_eq(s, "[1,1.200000e+01,3,4]"); 12772 free(s); 12773 // negative index 12774 r = self->f->setAtDouble(self, -1, 14); 12775 ck_assert_ptr_ne(r, null); 12776 s = toStringO(r); 12777 ck_assert_str_eq(s, "[1,1.200000e+01,3,1.400000e+01]"); 12778 free(s); 12779 // index outside 12780 ck_assert_ptr_eq(self->f->setAtDouble(self, 20, 1), NULL); 12781 ck_assert_ptr_eq(self->f->setAtDouble(self, -8, 1), NULL); 12782 // empty list 12783 emptyO(self); 12784 ck_assert_ptr_eq(self->f->setAtDouble(self, 0, 1), NULL); 12785 ck_assert_ptr_eq(self->f->setAtDouble(self, -1, 1), NULL); 12786 terminateO(self); 12787 12788 END_TEST 12789 12790 12791 START_TEST(setAtIntSmallArrayT) 12792 12793 smallArrayt* r; 12794 smallArrayt *self = allocG(rtSmallArrayt); 12795 12796 // add elements to self 12797 r = self->f->pushInt(self, 1); 12798 ck_assert_ptr_ne(r, null); 12799 r = self->f->pushInt(self, 2); 12800 ck_assert_ptr_ne(r, null); 12801 r = self->f->pushInt(self, 3); 12802 ck_assert_ptr_ne(r, null); 12803 r = self->f->pushInt(self, 4); 12804 ck_assert_ptr_ne(r, null); 12805 12806 // positive index 12807 r = self->f->setAtInt(self, 1, 12); 12808 ck_assert_ptr_ne(r, null); 12809 char *s = toStringO(r); 12810 ck_assert_str_eq(s, "[1,12,3,4]"); 12811 free(s); 12812 // negative index 12813 r = self->f->setAtInt(self, -1, 14); 12814 ck_assert_ptr_ne(r, null); 12815 s = toStringO(r); 12816 ck_assert_str_eq(s, "[1,12,3,14]"); 12817 free(s); 12818 // index outside 12819 ck_assert_ptr_eq(self->f->setAtInt(self, 20, 1), NULL); 12820 ck_assert_ptr_eq(self->f->setAtInt(self, -8, 1), NULL); 12821 // empty list 12822 emptyO(self); 12823 ck_assert_ptr_eq(self->f->setAtInt(self, 0, 1), NULL); 12824 ck_assert_ptr_eq(self->f->setAtInt(self, -1, 1), NULL); 12825 terminateO(self); 12826 12827 END_TEST 12828 12829 12830 START_TEST(setAtSSmallArrayT) 12831 12832 smallArrayt* r; 12833 smallArrayt *self = allocG(rtSmallArrayt); 12834 12835 // add elements to self 12836 r = self->f->pushInt(self, 1); 12837 ck_assert_ptr_ne(r, null); 12838 r = self->f->pushInt(self, 2); 12839 ck_assert_ptr_ne(r, null); 12840 r = self->f->pushInt(self, 3); 12841 ck_assert_ptr_ne(r, null); 12842 r = self->f->pushInt(self, 4); 12843 ck_assert_ptr_ne(r, null); 12844 12845 // positive index 12846 r = self->f->setAtS(self, 1, "a"); 12847 ck_assert_ptr_ne(r, null); 12848 char *s = toStringO(r); 12849 ck_assert_str_eq(s, "[1,\"a\",3,4]"); 12850 free(s); 12851 // negative index 12852 r = self->f->setAtS(self, -1, "b"); 12853 ck_assert_ptr_ne(r, null); 12854 s = toStringO(r); 12855 ck_assert_str_eq(s, "[1,\"a\",3,\"b\"]"); 12856 free(s); 12857 // NULL string 12858 r = self->f->setAtS(self, -1, NULL); 12859 ck_assert_ptr_eq(r, null); 12860 // index outside 12861 ck_assert_ptr_eq(self->f->setAtS(self, 20, ""), NULL); 12862 ck_assert_ptr_eq(self->f->setAtS(self, -8, ""), NULL); 12863 // empty list 12864 emptyO(self); 12865 ck_assert_ptr_eq(self->f->setAtS(self, 0, ""), NULL); 12866 ck_assert_ptr_eq(self->f->setAtS(self, -1, ""), NULL); 12867 terminateO(self); 12868 12869 END_TEST 12870 12871 12872 START_TEST(setAtCharSmallArrayT) 12873 12874 smallArrayt* r; 12875 smallArrayt *self = allocG(rtSmallArrayt); 12876 12877 // add elements to self 12878 r = self->f->pushInt(self, 1); 12879 ck_assert_ptr_ne(r, null); 12880 r = self->f->pushInt(self, 2); 12881 ck_assert_ptr_ne(r, null); 12882 r = self->f->pushInt(self, 3); 12883 ck_assert_ptr_ne(r, null); 12884 r = self->f->pushInt(self, 4); 12885 ck_assert_ptr_ne(r, null); 12886 12887 // positive index 12888 r = self->f->setAtChar(self, 1, 'a'); 12889 ck_assert_ptr_ne(r, null); 12890 char *s = toStringO(r); 12891 ck_assert_str_eq(s, "[1,\"a\",3,4]"); 12892 free(s); 12893 // negative index 12894 r = self->f->setAtChar(self, -1, 'b'); 12895 ck_assert_ptr_ne(r, null); 12896 s = toStringO(r); 12897 ck_assert_str_eq(s, "[1,\"a\",3,\"b\"]"); 12898 free(s); 12899 // index outside 12900 ck_assert_ptr_eq(self->f->setAtChar(self, 20, 'a'), NULL); 12901 ck_assert_ptr_eq(self->f->setAtChar(self, -8, 's'), NULL); 12902 // empty list 12903 emptyO(self); 12904 ck_assert_ptr_eq(self->f->setAtChar(self, 0, 'a'), NULL); 12905 ck_assert_ptr_eq(self->f->setAtChar(self, -1, 's'), NULL); 12906 terminateO(self); 12907 12908 END_TEST 12909 12910 12911 START_TEST(setAtDictSmallArrayT) 12912 12913 smallArrayt* r; 12914 smallArrayt *self = allocG(rtSmallArrayt); 12915 smallDictt *value; 12916 12917 // add elements to self 12918 r = self->f->pushInt(self, 1); 12919 ck_assert_ptr_ne(r, null); 12920 r = self->f->pushInt(self, 2); 12921 ck_assert_ptr_ne(r, null); 12922 r = self->f->pushInt(self, 3); 12923 ck_assert_ptr_ne(r, null); 12924 r = self->f->pushInt(self, 4); 12925 ck_assert_ptr_ne(r, null); 12926 12927 // positive index 12928 value = allocSmallDict(); 12929 r = self->f->setAtDict(self, 1, value); 12930 ck_assert_ptr_ne(r, null); 12931 finishO(value); 12932 char *s = toStringO(r); 12933 ck_assert_str_eq(s, "[1,{},3,4]"); 12934 free(s); 12935 // negative index 12936 value = allocSmallDict(); 12937 r = self->f->setAtDict(self, -1, value); 12938 ck_assert_ptr_ne(r, null); 12939 finishO(value); 12940 s = toStringO(r); 12941 ck_assert_str_eq(s, "[1,{},3,{}]"); 12942 free(s); 12943 // index outside 12944 value = allocSmallDict(); 12945 ck_assert_ptr_eq(self->f->setAtDict(self, 20, value), NULL); 12946 ck_assert_ptr_eq(self->f->setAtDict(self, -8, value), NULL); 12947 // empty list 12948 emptyO(self); 12949 ck_assert_ptr_eq(self->f->setAtDict(self, 0, value), NULL); 12950 ck_assert_ptr_eq(self->f->setAtDict(self, -1, value), NULL); 12951 terminateO(value); 12952 // non smallDict object 12953 value = (smallDictt*) allocSmallInt(2); 12954 r = self->f->setAtDict(self, 0, value); 12955 ck_assert_ptr_eq(r, null); 12956 terminateO(value); 12957 // NULL value 12958 ck_assert_ptr_eq(self->f->setAtDict(self, 0, NULL), NULL); 12959 terminateO(self); 12960 12961 END_TEST 12962 12963 12964 START_TEST(setAtArraySmallArrayT) 12965 12966 smallArrayt* r; 12967 smallArrayt *self = allocG(rtSmallArrayt); 12968 smallArrayt *value; 12969 12970 // add elements to self 12971 r = self->f->pushInt(self, 1); 12972 ck_assert_ptr_ne(r, null); 12973 r = self->f->pushInt(self, 2); 12974 ck_assert_ptr_ne(r, null); 12975 r = self->f->pushInt(self, 3); 12976 ck_assert_ptr_ne(r, null); 12977 r = self->f->pushInt(self, 4); 12978 ck_assert_ptr_ne(r, null); 12979 12980 // positive index 12981 value = allocSmallArray(); 12982 r = self->f->setAtArray(self, 1, value); 12983 ck_assert_ptr_ne(r, null); 12984 finishO(value); 12985 char *s = toStringO(r); 12986 ck_assert_str_eq(s, "[1,[],3,4]"); 12987 free(s); 12988 // negative index 12989 value = allocSmallArray(); 12990 r = self->f->setAtArray(self, -1, value); 12991 ck_assert_ptr_ne(r, null); 12992 finishO(value); 12993 s = toStringO(r); 12994 ck_assert_str_eq(s, "[1,[],3,[]]"); 12995 free(s); 12996 // index outside 12997 value = allocSmallArray(); 12998 ck_assert_ptr_eq(self->f->setAtArray(self, 20, value), NULL); 12999 ck_assert_ptr_eq(self->f->setAtArray(self, -8, value), NULL); 13000 // empty list 13001 emptyO(self); 13002 ck_assert_ptr_eq(self->f->setAtArray(self, 0, value), NULL); 13003 ck_assert_ptr_eq(self->f->setAtArray(self, -1, value), NULL); 13004 terminateO(value); 13005 // non smallArray object 13006 value = (smallArrayt*) allocSmallInt(2); 13007 r = self->f->setAtArray(self, 0, value); 13008 ck_assert_ptr_eq(r, null); 13009 terminateO(value); 13010 // NULL value 13011 ck_assert_ptr_eq(self->f->setAtArray(self, 0, NULL), NULL); 13012 terminateO(self); 13013 13014 END_TEST 13015 13016 13017 START_TEST(setAtArraycSmallArrayT) 13018 13019 smallArrayt* r; 13020 smallArrayt *self = allocG(rtSmallArrayt); 13021 char **value; 13022 13023 // add elements to self 13024 r = self->f->pushInt(self, 1); 13025 ck_assert_ptr_ne(r, null); 13026 r = self->f->pushInt(self, 2); 13027 ck_assert_ptr_ne(r, null); 13028 r = self->f->pushInt(self, 3); 13029 ck_assert_ptr_ne(r, null); 13030 r = self->f->pushInt(self, 4); 13031 ck_assert_ptr_ne(r, null); 13032 13033 // positive index 13034 value = listCreateS("a"); 13035 r = self->f->setAtArrayc(self, 1, value); 13036 ck_assert_ptr_ne(r, null); 13037 listFreeS(value); 13038 char *s = toStringO(r); 13039 ck_assert_str_eq(s, "[1,[\"a\"],3,4]"); 13040 free(s); 13041 // negative index 13042 value = listCreateS("b"); 13043 r = self->f->setAtArrayc(self, -1, value); 13044 ck_assert_ptr_ne(r, null); 13045 listFreeS(value); 13046 s = toStringO(r); 13047 ck_assert_str_eq(s, "[1,[\"a\"],3,[\"b\"]]"); 13048 free(s); 13049 // index outside 13050 value = (char**)r; 13051 ck_assert_ptr_eq(self->f->setAtArrayc(self, 20, value), NULL); 13052 ck_assert_ptr_eq(self->f->setAtArrayc(self, -8, value), NULL); 13053 // empty list 13054 emptyO(self); 13055 ck_assert_ptr_eq(self->f->setAtArrayc(self, 0, value), NULL); 13056 ck_assert_ptr_eq(self->f->setAtArrayc(self, -1, value), NULL); 13057 // NULL value 13058 ck_assert_ptr_eq(self->f->setAtArrayc(self, 0, NULL), NULL); 13059 terminateO(self); 13060 13061 END_TEST 13062 13063 13064 START_TEST(setAtSmallBoolSmallArrayT) 13065 13066 smallArrayt* r; 13067 smallArrayt *self = allocG(rtSmallArrayt); 13068 smallBoolt *value; 13069 13070 // add elements to self 13071 r = self->f->pushInt(self, 1); 13072 ck_assert_ptr_ne(r, null); 13073 r = self->f->pushInt(self, 2); 13074 ck_assert_ptr_ne(r, null); 13075 r = self->f->pushInt(self, 3); 13076 ck_assert_ptr_ne(r, null); 13077 r = self->f->pushInt(self, 4); 13078 ck_assert_ptr_ne(r, null); 13079 13080 // positive index 13081 value = allocSmallBool(true); 13082 r = self->f->setAtSmallBool(self, 1, value); 13083 ck_assert_ptr_ne(r, null); 13084 finishO(value); 13085 char *s = toStringO(r); 13086 ck_assert_str_eq(s, "[1,true,3,4]"); 13087 free(s); 13088 // negative index 13089 value = allocSmallBool(true); 13090 r = self->f->setAtSmallBool(self, -1, value); 13091 ck_assert_ptr_ne(r, null); 13092 finishO(value); 13093 s = toStringO(r); 13094 ck_assert_str_eq(s, "[1,true,3,true]"); 13095 free(s); 13096 // empty smallBool 13097 value = allocSmallBool(true); 13098 freeO(value); 13099 r = self->f->setAtSmallBool(self, -1, value); 13100 ck_assert_ptr_ne(r, null); 13101 finishO(value); 13102 s = toStringO(r); 13103 ck_assert_str_eq(s, "[1,true,3,false]"); 13104 free(s); 13105 // index outside 13106 value = allocSmallBool(true); 13107 ck_assert_ptr_eq(self->f->setAtSmallBool(self, 20, value), NULL); 13108 ck_assert_ptr_eq(self->f->setAtSmallBool(self, -8, value), NULL); 13109 // empty list 13110 emptyO(self); 13111 ck_assert_ptr_eq(self->f->setAtSmallBool(self, 0, value), NULL); 13112 ck_assert_ptr_eq(self->f->setAtSmallBool(self, -1, value), NULL); 13113 terminateO(value); 13114 // non smallBool object 13115 value = (smallBoolt*) allocSmallInt(2); 13116 r = self->f->setAtSmallBool(self, 0, value); 13117 ck_assert_ptr_eq(r, null); 13118 terminateO(value); 13119 // NULL value 13120 ck_assert_ptr_eq(self->f->setAtSmallBool(self, 0, NULL), NULL); 13121 terminateO(self); 13122 13123 END_TEST 13124 13125 13126 START_TEST(setAtSmallBytesSmallArrayT) 13127 13128 smallArrayt* r; 13129 smallArrayt *self = allocG(rtSmallArrayt); 13130 smallBytest *value; 13131 13132 // add elements to self 13133 r = self->f->pushInt(self, 1); 13134 ck_assert_ptr_ne(r, null); 13135 r = self->f->pushInt(self, 2); 13136 ck_assert_ptr_ne(r, null); 13137 r = self->f->pushInt(self, 3); 13138 ck_assert_ptr_ne(r, null); 13139 r = self->f->pushInt(self, 4); 13140 ck_assert_ptr_ne(r, null); 13141 13142 // positive index 13143 value = allocSmallBytes(NULL, 0); 13144 r = self->f->setAtSmallBytes(self, 1, value); 13145 ck_assert_ptr_ne(r, null); 13146 finishO(value); 13147 char *s = toStringO(r); 13148 ck_assert_str_eq(s, "[1,[],3,4]"); 13149 free(s); 13150 // negative index 13151 value = allocSmallBytes(NULL, 0); 13152 r = self->f->setAtSmallBytes(self, -1, value); 13153 ck_assert_ptr_ne(r, null); 13154 finishO(value); 13155 s = toStringO(r); 13156 ck_assert_str_eq(s, "[1,[],3,[]]"); 13157 free(s); 13158 // index outside 13159 value = allocSmallBytes(NULL, 0); 13160 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, 20, value), NULL); 13161 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, -5, value), NULL); 13162 // empty list 13163 emptyO(self); 13164 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, 0, value), NULL); 13165 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, -1, value), NULL); 13166 terminateO(value); 13167 // non smallBytes object 13168 value = (smallBytest*) allocSmallInt(2); 13169 r = self->f->setAtSmallBytes(self, 0, value); 13170 ck_assert_ptr_eq(r, null); 13171 terminateO(value); 13172 // NULL value 13173 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, 0, NULL), NULL); 13174 terminateO(self); 13175 13176 END_TEST 13177 13178 13179 START_TEST(setAtSmallDoubleSmallArrayT) 13180 13181 smallArrayt* r; 13182 smallArrayt *self = allocG(rtSmallArrayt); 13183 smallDoublet *value; 13184 13185 // add elements to self 13186 r = self->f->pushInt(self, 1); 13187 ck_assert_ptr_ne(r, null); 13188 r = self->f->pushInt(self, 2); 13189 ck_assert_ptr_ne(r, null); 13190 r = self->f->pushInt(self, 3); 13191 ck_assert_ptr_ne(r, null); 13192 r = self->f->pushInt(self, 4); 13193 ck_assert_ptr_ne(r, null); 13194 13195 // positive index 13196 value = allocSmallDouble(5); 13197 r = self->f->setAtSmallDouble(self, 1, value); 13198 ck_assert_ptr_ne(r, null); 13199 finishO(value); 13200 char *s = toStringO(r); 13201 ck_assert_str_eq(s, "[1,5.000000e+00,3,4]"); 13202 free(s); 13203 // negative index 13204 value = allocSmallDouble(6); 13205 r = self->f->setAtSmallDouble(self, -1, value); 13206 ck_assert_ptr_ne(r, null); 13207 finishO(value); 13208 s = toStringO(r); 13209 ck_assert_str_eq(s, "[1,5.000000e+00,3,6.000000e+00]"); 13210 free(s); 13211 // empty smallDouble 13212 value = allocSmallDouble(0); 13213 freeO(value); 13214 r = self->f->setAtSmallDouble(self, -1, value); 13215 ck_assert_ptr_ne(r, null); 13216 finishO(value); 13217 s = toStringO(r); 13218 ck_assert_str_eq(s, "[1,5.000000e+00,3,0.000000e+00]"); 13219 free(s); 13220 // index outside 13221 value = allocSmallDouble(1); 13222 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, 20, value), NULL); 13223 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, -8, value), NULL); 13224 // empty list 13225 emptyO(self); 13226 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, 0, value), NULL); 13227 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, -1, value), NULL); 13228 terminateO(value); 13229 // non smallDouble object 13230 value = (smallDoublet*) allocSmallInt(2); 13231 r = self->f->setAtSmallDouble(self, 0, value); 13232 ck_assert_ptr_eq(r, null); 13233 terminateO(value); 13234 // NULL value 13235 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, 0, NULL), NULL); 13236 terminateO(self); 13237 13238 END_TEST 13239 13240 13241 START_TEST(setAtSmallIntSmallArrayT) 13242 13243 smallArrayt* r; 13244 smallArrayt *self = allocG(rtSmallArrayt); 13245 smallIntt *value; 13246 13247 // add elements to self 13248 r = self->f->pushInt(self, 1); 13249 ck_assert_ptr_ne(r, null); 13250 r = self->f->pushInt(self, 2); 13251 ck_assert_ptr_ne(r, null); 13252 r = self->f->pushInt(self, 3); 13253 ck_assert_ptr_ne(r, null); 13254 r = self->f->pushInt(self, 4); 13255 ck_assert_ptr_ne(r, null); 13256 13257 // positive index 13258 value = allocSmallInt(5); 13259 r = self->f->setAtSmallInt(self, 1, value); 13260 ck_assert_ptr_ne(r, null); 13261 finishO(value); 13262 char *s = toStringO(r); 13263 ck_assert_str_eq(s, "[1,5,3,4]"); 13264 free(s); 13265 // negative index 13266 value = allocSmallInt(6); 13267 r = self->f->setAtSmallInt(self, -1, value); 13268 ck_assert_ptr_ne(r, null); 13269 finishO(value); 13270 s = toStringO(r); 13271 ck_assert_str_eq(s, "[1,5,3,6]"); 13272 free(s); 13273 // empty SmallInt 13274 value = allocSmallInt(0); 13275 freeO(value); 13276 r = self->f->setAtSmallInt(self, -1, value); 13277 ck_assert_ptr_ne(r, null); 13278 finishO(value); 13279 s = toStringO(r); 13280 ck_assert_str_eq(s, "[1,5,3,0]"); 13281 free(s); 13282 // index outside 13283 value = allocSmallInt(1); 13284 ck_assert_ptr_eq(self->f->setAtSmallInt(self, 20, value), NULL); 13285 ck_assert_ptr_eq(self->f->setAtSmallInt(self, -8, value), NULL); 13286 // empty list 13287 emptyO(self); 13288 ck_assert_ptr_eq(self->f->setAtSmallInt(self, 0, value), NULL); 13289 ck_assert_ptr_eq(self->f->setAtSmallInt(self, -1, value), NULL); 13290 terminateO(value); 13291 // non smallInt object 13292 value = (smallIntt*) allocSmallBool(true); 13293 r = self->f->setAtSmallInt(self, 0, value); 13294 ck_assert_ptr_eq(r, null); 13295 terminateO(value); 13296 // NULL value 13297 ck_assert_ptr_eq(self->f->setAtSmallInt(self, 0, NULL), NULL); 13298 terminateO(self); 13299 13300 END_TEST 13301 13302 13303 START_TEST(setAtSmallJsonSmallArrayT) 13304 13305 smallArrayt* r; 13306 smallArrayt *self = allocG(rtSmallArrayt); 13307 smallJsont *value; 13308 13309 // add elements to self 13310 r = self->f->pushInt(self, 1); 13311 ck_assert_ptr_ne(r, null); 13312 r = self->f->pushInt(self, 2); 13313 ck_assert_ptr_ne(r, null); 13314 r = self->f->pushInt(self, 3); 13315 ck_assert_ptr_ne(r, null); 13316 r = self->f->pushInt(self, 4); 13317 ck_assert_ptr_ne(r, null); 13318 13319 // positive index 13320 value = allocSmallJson(); 13321 r = self->f->setAtSmallJson(self, 1, value); 13322 ck_assert_ptr_ne(r, null); 13323 finishO(value); 13324 char *s = toStringO(r); 13325 ck_assert_str_eq(s, "[1,{},3,4]"); 13326 free(s); 13327 // negative index 13328 value = allocSmallJson(); 13329 r = self->f->setAtSmallJson(self, -1, value); 13330 ck_assert_ptr_ne(r, null); 13331 finishO(value); 13332 s = toStringO(r); 13333 ck_assert_str_eq(s, "[1,{},3,{}]"); 13334 free(s); 13335 // index outside 13336 value = allocSmallJson(); 13337 ck_assert_ptr_eq(self->f->setAtSmallJson(self, 20, value), NULL); 13338 ck_assert_ptr_eq(self->f->setAtSmallJson(self, -8, value), NULL); 13339 // empty list 13340 emptyO(self); 13341 ck_assert_ptr_eq(self->f->setAtSmallJson(self, 0, value), NULL); 13342 ck_assert_ptr_eq(self->f->setAtSmallJson(self, -1, value), NULL); 13343 terminateO(value); 13344 // non smallJson object 13345 value = (smallJsont*) allocSmallInt(2); 13346 r = self->f->setAtSmallJson(self, 0, value); 13347 ck_assert_ptr_eq(r, null); 13348 terminateO(value); 13349 // NULL value 13350 ck_assert_ptr_eq(self->f->setAtSmallJson(self, 0, NULL), NULL); 13351 terminateO(self); 13352 13353 END_TEST 13354 13355 13356 START_TEST(setAtSmallStringSmallArrayT) 13357 13358 smallArrayt* r; 13359 smallArrayt *self = allocG(rtSmallArrayt); 13360 smallStringt *value; 13361 13362 // add elements to self 13363 r = self->f->pushInt(self, 1); 13364 ck_assert_ptr_ne(r, null); 13365 r = self->f->pushInt(self, 2); 13366 ck_assert_ptr_ne(r, null); 13367 r = self->f->pushInt(self, 3); 13368 ck_assert_ptr_ne(r, null); 13369 r = self->f->pushInt(self, 4); 13370 ck_assert_ptr_ne(r, null); 13371 13372 // positive index 13373 initiateAllocateSmallString(&value); 13374 r = self->f->setAtSmallString(self, 1, value); 13375 ck_assert_ptr_ne(r, null); 13376 finishO(value); 13377 char *s = toStringO(r); 13378 ck_assert_str_eq(s, "[1,\"\",3,4]"); 13379 free(s); 13380 // negative index 13381 value = allocSmallString("a"); 13382 r = self->f->setAtSmallString(self, -1, value); 13383 ck_assert_ptr_ne(r, null); 13384 finishO(value); 13385 s = toStringO(r); 13386 ck_assert_str_eq(s, "[1,\"\",3,\"a\"]"); 13387 free(s); 13388 // index outside 13389 value = allocSmallString("asd"); 13390 ck_assert_ptr_eq(self->f->setAtSmallString(self, 20, value), NULL); 13391 ck_assert_ptr_eq(self->f->setAtSmallString(self, -8, value), NULL); 13392 // empty list 13393 emptyO(self); 13394 ck_assert_ptr_eq(self->f->setAtSmallString(self, 0, value), NULL); 13395 ck_assert_ptr_eq(self->f->setAtSmallString(self, -1, value), NULL); 13396 terminateO(value); 13397 // non smallString object 13398 value = (smallStringt*) allocSmallInt(2); 13399 r = self->f->setAtSmallString(self, 0, value); 13400 ck_assert_ptr_eq(r, null); 13401 terminateO(value); 13402 // NULL value 13403 ck_assert_ptr_eq(self->f->setAtSmallString(self, 0, NULL), NULL); 13404 terminateO(self); 13405 13406 END_TEST 13407 13408 13409 START_TEST(setAtSmallContainerSmallArrayT) 13410 13411 smallArrayt* r; 13412 smallArrayt *self = allocG(rtSmallArrayt); 13413 smallContainert *value; 13414 13415 // add elements to self 13416 r = self->f->pushInt(self, 1); 13417 ck_assert_ptr_ne(r, null); 13418 r = self->f->pushInt(self, 2); 13419 ck_assert_ptr_ne(r, null); 13420 r = self->f->pushInt(self, 3); 13421 ck_assert_ptr_ne(r, null); 13422 r = self->f->pushInt(self, 4); 13423 ck_assert_ptr_ne(r, null); 13424 13425 // positive index 13426 initiateAllocateSmallContainer(&value); 13427 r = self->f->setAtSmallContainer(self, 1, value); 13428 ck_assert_ptr_ne(r, null); 13429 finishO(value); 13430 char *s = toStringO(r); 13431 ck_assert_str_eq(s, "[1,\"<data container>\",3,4]"); 13432 free(s); 13433 // negative index 13434 initiateAllocateSmallContainer(&value); 13435 r = self->f->setAtSmallContainer(self, -1, value); 13436 ck_assert_ptr_ne(r, null); 13437 finishO(value); 13438 s = toStringO(r); 13439 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 13440 free(s); 13441 // index outside 13442 initiateAllocateSmallContainer(&value); 13443 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, 20, value), NULL); 13444 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, -8, value), NULL); 13445 // empty list 13446 emptyO(self); 13447 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, 0, value), NULL); 13448 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, -1, value), NULL); 13449 terminateO(value); 13450 // non smallContainer object 13451 value = (smallContainert*) allocSmallInt(2); 13452 r = self->f->setAtSmallContainer(self, 0, value); 13453 ck_assert_ptr_eq(r, null); 13454 terminateO(value); 13455 // NULL value 13456 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, 0, NULL), NULL); 13457 terminateO(self); 13458 13459 END_TEST 13460 13461 13462 START_TEST(setAtNFreeSmallArrayT) 13463 13464 smallArrayt* r; 13465 smallArrayt *self = allocG(rtSmallArrayt); 13466 baset *value; 13467 13468 // add elements to self 13469 r = self->f->pushInt(self, 1); 13470 ck_assert_ptr_ne(r, null); 13471 r = self->f->pushInt(self, 2); 13472 ck_assert_ptr_ne(r, null); 13473 r = self->f->pushInt(self, 3); 13474 ck_assert_ptr_ne(r, null); 13475 r = self->f->pushInt(self, 4); 13476 ck_assert_ptr_ne(r, null); 13477 13478 // positive index 13479 value = (baset*)allocSmallInt(123); 13480 r = self->f->setAtNFree(self, 1, value); 13481 ck_assert_ptr_ne(r, null); 13482 char *s = toStringO(r); 13483 ck_assert_str_eq(s, "[1,123,3,4]"); 13484 free(s); 13485 // negative index 13486 value = (baset*)allocSmallInt(234); 13487 r = self->f->setAtNFree(self, -1, value); 13488 ck_assert_ptr_ne(r, null); 13489 s = toStringO(r); 13490 ck_assert_str_eq(s, "[1,123,3,234]"); 13491 free(s); 13492 // undefined object 13493 value = (baset*)allocUndefined(); 13494 r = self->f->setAtNFree(self, -1, value); 13495 ck_assert_ptr_ne(r, null); 13496 s = toStringO(r); 13497 ck_assert_str_eq(s, "[1,123,3,null]"); 13498 free(s); 13499 // container 13500 createAllocateSmallContainer(c); 13501 r = self->f->setAtNFree(self, -1, (baset*)c); 13502 ck_assert_ptr_ne(r, null); 13503 s = toStringO(r); 13504 ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]"); 13505 free(s); 13506 // base object in container 13507 createAllocateSmallInt(I); 13508 setValG(I, 11); 13509 I->type = "anothertype"; 13510 r = self->f->setAtNFree(self, -1, (baset*)I); 13511 ck_assert_ptr_ne(r, null); 13512 s = toStringO(r); 13513 ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]"); 13514 free(s); 13515 // index outside 13516 value = (baset*)allocSmallInt(123); 13517 ck_assert_ptr_eq(self->f->setAtNFree(self, 20, value), NULL); 13518 ck_assert_ptr_eq(self->f->setAtNFree(self, -8, value), NULL); 13519 // empty list 13520 emptyO(self); 13521 ck_assert_ptr_eq(self->f->setAtNFree(self, 0, value), NULL); 13522 ck_assert_ptr_eq(self->f->setAtNFree(self, -1, value), NULL); 13523 terminateO(value); 13524 // NULL value 13525 ck_assert_ptr_eq(self->f->setAtNFree(self, 0, NULL), NULL); 13526 terminateO(self); 13527 13528 END_TEST 13529 13530 13531 START_TEST(setAtNFreeUndefinedSmallArrayT) 13532 13533 smallArrayt* r; 13534 smallArrayt *self = allocG(rtSmallArrayt); 13535 undefinedt *value = NULL; 13536 13537 13538 // add elements to self 13539 r = self->f->pushInt(self, 1); 13540 ck_assert_ptr_ne(r, null); 13541 r = self->f->pushInt(self, 2); 13542 ck_assert_ptr_ne(r, null); 13543 r = self->f->pushInt(self, 3); 13544 ck_assert_ptr_ne(r, null); 13545 r = self->f->pushInt(self, 4); 13546 ck_assert_ptr_ne(r, null); 13547 13548 // positive index 13549 value = allocUndefined(); 13550 r = self->f->setAtNFreeUndefined(self, 1, value); 13551 ck_assert_ptr_ne(r, null); 13552 char *s = toStringO(r); 13553 ck_assert_str_eq(s, "[1,null,3,4]"); 13554 free(s); 13555 // negative index 13556 value = allocUndefined(); 13557 r = self->f->setAtNFreeUndefined(self, -1, value); 13558 ck_assert_ptr_ne(r, null); 13559 s = toStringO(r); 13560 ck_assert_str_eq(s, "[1,null,3,null]"); 13561 free(s); 13562 // index outside 13563 value = allocUndefined(); 13564 ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, 20, value), NULL); 13565 terminateO(value); 13566 13567 value = allocUndefined(); 13568 ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, -8, value), NULL); 13569 terminateO(value); 13570 13571 // empty list 13572 emptyO(self); 13573 value = allocUndefined(); 13574 ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, 0, value), NULL); 13575 terminateO(value); 13576 13577 value = allocUndefined(); 13578 ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, -1, value), NULL); 13579 terminateO(value); 13580 13581 terminateO(self); 13582 13583 END_TEST 13584 13585 13586 START_TEST(setAtNFreeSSmallArrayT) 13587 13588 smallArrayt* r; 13589 smallArrayt *self = allocG(rtSmallArrayt); 13590 13591 // add elements to self 13592 r = self->f->pushInt(self, 1); 13593 ck_assert_ptr_ne(r, null); 13594 r = self->f->pushInt(self, 2); 13595 ck_assert_ptr_ne(r, null); 13596 r = self->f->pushInt(self, 3); 13597 ck_assert_ptr_ne(r, null); 13598 r = self->f->pushInt(self, 4); 13599 ck_assert_ptr_ne(r, null); 13600 13601 // positive index 13602 r = self->f->setAtNFreeS(self, 1, strdup("a")); 13603 ck_assert_ptr_ne(r, null); 13604 char *s = toStringO(r); 13605 ck_assert_str_eq(s, "[1,\"a\",3,4]"); 13606 free(s); 13607 // negative index 13608 r = self->f->setAtNFreeS(self, -1, strdup("b")); 13609 ck_assert_ptr_ne(r, null); 13610 s = toStringO(r); 13611 ck_assert_str_eq(s, "[1,\"a\",3,\"b\"]"); 13612 free(s); 13613 // NULL string 13614 r = self->f->setAtNFreeS(self, -1, NULL); 13615 ck_assert_ptr_eq(r, null); 13616 // index outside 13617 ck_assert_ptr_eq(self->f->setAtNFreeS(self, 20, ""), NULL); 13618 ck_assert_ptr_eq(self->f->setAtNFreeS(self, -8, ""), NULL); 13619 // empty list 13620 emptyO(self); 13621 ck_assert_ptr_eq(self->f->setAtNFreeS(self, 0, ""), NULL); 13622 ck_assert_ptr_eq(self->f->setAtNFreeS(self, -1, ""), NULL); 13623 terminateO(self); 13624 13625 END_TEST 13626 13627 13628 START_TEST(setAtNFreeDictSmallArrayT) 13629 13630 smallArrayt* r; 13631 smallArrayt *self = allocG(rtSmallArrayt); 13632 smallDictt *value; 13633 13634 // add elements to self 13635 r = self->f->pushInt(self, 1); 13636 ck_assert_ptr_ne(r, null); 13637 r = self->f->pushInt(self, 2); 13638 ck_assert_ptr_ne(r, null); 13639 r = self->f->pushInt(self, 3); 13640 ck_assert_ptr_ne(r, null); 13641 r = self->f->pushInt(self, 4); 13642 ck_assert_ptr_ne(r, null); 13643 13644 // positive index 13645 value = allocSmallDict(); 13646 r = self->f->setAtNFreeDict(self, 1, value); 13647 ck_assert_ptr_ne(r, null); 13648 char *s = toStringO(r); 13649 ck_assert_str_eq(s, "[1,{},3,4]"); 13650 free(s); 13651 // negative index 13652 value = allocSmallDict(); 13653 r = self->f->setAtNFreeDict(self, -1, value); 13654 ck_assert_ptr_ne(r, null); 13655 s = toStringO(r); 13656 ck_assert_str_eq(s, "[1,{},3,{}]"); 13657 free(s); 13658 // index outside 13659 value = allocSmallDict(); 13660 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, 20, value), NULL); 13661 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, -8, value), NULL); 13662 // empty list 13663 emptyO(self); 13664 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, 0, value), NULL); 13665 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, -1, value), NULL); 13666 terminateO(value); 13667 // NULL value 13668 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, 0, NULL), NULL); 13669 terminateO(self); 13670 13671 END_TEST 13672 13673 13674 START_TEST(setAtNFreeArraySmallArrayT) 13675 13676 smallArrayt* r; 13677 smallArrayt *self = allocG(rtSmallArrayt); 13678 smallArrayt *value; 13679 13680 // add elements to self 13681 r = self->f->pushInt(self, 1); 13682 ck_assert_ptr_ne(r, null); 13683 r = self->f->pushInt(self, 2); 13684 ck_assert_ptr_ne(r, null); 13685 r = self->f->pushInt(self, 3); 13686 ck_assert_ptr_ne(r, null); 13687 r = self->f->pushInt(self, 4); 13688 ck_assert_ptr_ne(r, null); 13689 13690 // positive index 13691 value = allocSmallArray(); 13692 r = self->f->setAtNFreeArray(self, 1, value); 13693 ck_assert_ptr_ne(r, null); 13694 char *s = toStringO(r); 13695 ck_assert_str_eq(s, "[1,[],3,4]"); 13696 free(s); 13697 // negative index 13698 value = allocSmallArray(); 13699 r = self->f->setAtNFreeArray(self, -1, value); 13700 ck_assert_ptr_ne(r, null); 13701 s = toStringO(r); 13702 ck_assert_str_eq(s, "[1,[],3,[]]"); 13703 free(s); 13704 // index outside 13705 value = allocSmallArray(); 13706 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, 20, value), NULL); 13707 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, -8, value), NULL); 13708 // empty list 13709 emptyO(self); 13710 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, 0, value), NULL); 13711 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, -1, value), NULL); 13712 terminateO(value); 13713 // NULL value 13714 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, 0, NULL), NULL); 13715 terminateO(self); 13716 13717 END_TEST 13718 13719 13720 START_TEST(setAtNFreeArraycSmallArrayT) 13721 13722 smallArrayt* r; 13723 smallArrayt *self = allocG(rtSmallArrayt); 13724 char **value; 13725 13726 // add elements to self 13727 r = self->f->pushInt(self, 1); 13728 ck_assert_ptr_ne(r, null); 13729 r = self->f->pushInt(self, 2); 13730 ck_assert_ptr_ne(r, null); 13731 r = self->f->pushInt(self, 3); 13732 ck_assert_ptr_ne(r, null); 13733 r = self->f->pushInt(self, 4); 13734 ck_assert_ptr_ne(r, null); 13735 13736 // positive index 13737 value = listCreateS("a"); 13738 r = self->f->setAtNFreeArrayc(self, 1, value); 13739 ck_assert_ptr_ne(r, null); 13740 char *s = toStringO(r); 13741 ck_assert_str_eq(s, "[1,[\"a\"],3,4]"); 13742 free(s); 13743 // negative index 13744 value = listCreateS("b"); 13745 r = self->f->setAtNFreeArrayc(self, -1, value); 13746 ck_assert_ptr_ne(r, null); 13747 s = toStringO(r); 13748 ck_assert_str_eq(s, "[1,[\"a\"],3,[\"b\"]]"); 13749 free(s); 13750 // index outside 13751 value = (char**)r; 13752 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, 20, value), NULL); 13753 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, -8, value), NULL); 13754 // empty list 13755 emptyO(self); 13756 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, 0, value), NULL); 13757 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, -1, value), NULL); 13758 // NULL value 13759 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, 0, NULL), NULL); 13760 terminateO(self); 13761 13762 END_TEST 13763 13764 13765 START_TEST(setAtNFreeSmallBoolSmallArrayT) 13766 13767 smallArrayt* r; 13768 smallArrayt *self = allocG(rtSmallArrayt); 13769 smallBoolt *value; 13770 13771 // add elements to self 13772 r = self->f->pushInt(self, 1); 13773 ck_assert_ptr_ne(r, null); 13774 r = self->f->pushInt(self, 2); 13775 ck_assert_ptr_ne(r, null); 13776 r = self->f->pushInt(self, 3); 13777 ck_assert_ptr_ne(r, null); 13778 r = self->f->pushInt(self, 4); 13779 ck_assert_ptr_ne(r, null); 13780 13781 // positive index 13782 value = allocSmallBool(true); 13783 r = self->f->setAtNFreeSmallBool(self, 1, value); 13784 ck_assert_ptr_ne(r, null); 13785 char *s = toStringO(r); 13786 ck_assert_str_eq(s, "[1,true,3,4]"); 13787 free(s); 13788 // negative index 13789 value = allocSmallBool(true); 13790 r = self->f->setAtNFreeSmallBool(self, -1, value); 13791 ck_assert_ptr_ne(r, null); 13792 s = toStringO(r); 13793 ck_assert_str_eq(s, "[1,true,3,true]"); 13794 free(s); 13795 // index outside 13796 value = allocSmallBool(true); 13797 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, 20, value), NULL); 13798 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, -8, value), NULL); 13799 // empty list 13800 emptyO(self); 13801 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, 0, value), NULL); 13802 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, -1, value), NULL); 13803 terminateO(value); 13804 // NULL value 13805 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, 0, NULL), NULL); 13806 terminateO(self); 13807 13808 END_TEST 13809 13810 13811 START_TEST(setAtNFreeSmallBytesSmallArrayT) 13812 13813 smallArrayt* r; 13814 smallArrayt *self = allocG(rtSmallArrayt); 13815 smallBytest *value; 13816 13817 // add elements to self 13818 r = self->f->pushInt(self, 1); 13819 ck_assert_ptr_ne(r, null); 13820 r = self->f->pushInt(self, 2); 13821 ck_assert_ptr_ne(r, null); 13822 r = self->f->pushInt(self, 3); 13823 ck_assert_ptr_ne(r, null); 13824 r = self->f->pushInt(self, 4); 13825 ck_assert_ptr_ne(r, null); 13826 13827 // positive index 13828 value = allocSmallBytes(NULL, 0); 13829 r = self->f->setAtNFreeSmallBytes(self, 1, value); 13830 ck_assert_ptr_ne(r, null); 13831 char *s = toStringO(r); 13832 ck_assert_str_eq(s, "[1,[],3,4]"); 13833 free(s); 13834 // negative index 13835 value = allocSmallBytes(NULL, 0); 13836 r = self->f->setAtNFreeSmallBytes(self, -1, value); 13837 ck_assert_ptr_ne(r, null); 13838 s = toStringO(r); 13839 ck_assert_str_eq(s, "[1,[],3,[]]"); 13840 free(s); 13841 // index outside 13842 value = allocSmallBytes(NULL, 0); 13843 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, 20, value), NULL); 13844 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, -5, value), NULL); 13845 // empty list 13846 emptyO(self); 13847 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, 0, value), NULL); 13848 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, -1, value), NULL); 13849 terminateO(value); 13850 // NULL value 13851 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, 0, NULL), NULL); 13852 terminateO(self); 13853 13854 END_TEST 13855 13856 13857 START_TEST(setAtNFreeSmallDoubleSmallArrayT) 13858 13859 smallArrayt* r; 13860 smallArrayt *self = allocG(rtSmallArrayt); 13861 smallDoublet *value; 13862 13863 // add elements to self 13864 r = self->f->pushInt(self, 1); 13865 ck_assert_ptr_ne(r, null); 13866 r = self->f->pushInt(self, 2); 13867 ck_assert_ptr_ne(r, null); 13868 r = self->f->pushInt(self, 3); 13869 ck_assert_ptr_ne(r, null); 13870 r = self->f->pushInt(self, 4); 13871 ck_assert_ptr_ne(r, null); 13872 13873 // positive index 13874 value = allocSmallDouble(5); 13875 r = self->f->setAtNFreeSmallDouble(self, 1, value); 13876 ck_assert_ptr_ne(r, null); 13877 char *s = toStringO(r); 13878 ck_assert_str_eq(s, "[1,5.000000e+00,3,4]"); 13879 free(s); 13880 // negative index 13881 value = allocSmallDouble(6); 13882 r = self->f->setAtNFreeSmallDouble(self, -1, value); 13883 ck_assert_ptr_ne(r, null); 13884 s = toStringO(r); 13885 ck_assert_str_eq(s, "[1,5.000000e+00,3,6.000000e+00]"); 13886 free(s); 13887 // index outside 13888 value = allocSmallDouble(1); 13889 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, 20, value), NULL); 13890 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, -8, value), NULL); 13891 // empty list 13892 emptyO(self); 13893 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, 0, value), NULL); 13894 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, -1, value), NULL); 13895 terminateO(value); 13896 // NULL value 13897 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, 0, NULL), NULL); 13898 terminateO(self); 13899 13900 END_TEST 13901 13902 13903 START_TEST(setAtNFreeSmallIntSmallArrayT) 13904 13905 smallArrayt* r; 13906 smallArrayt *self = allocG(rtSmallArrayt); 13907 smallIntt *value; 13908 13909 // add elements to self 13910 r = self->f->pushInt(self, 1); 13911 ck_assert_ptr_ne(r, null); 13912 r = self->f->pushInt(self, 2); 13913 ck_assert_ptr_ne(r, null); 13914 r = self->f->pushInt(self, 3); 13915 ck_assert_ptr_ne(r, null); 13916 r = self->f->pushInt(self, 4); 13917 ck_assert_ptr_ne(r, null); 13918 13919 // positive index 13920 value = allocSmallInt(5); 13921 r = self->f->setAtNFreeSmallInt(self, 1, value); 13922 ck_assert_ptr_ne(r, null); 13923 char *s = toStringO(r); 13924 ck_assert_str_eq(s, "[1,5,3,4]"); 13925 free(s); 13926 // negative index 13927 value = allocSmallInt(6); 13928 r = self->f->setAtNFreeSmallInt(self, -1, value); 13929 ck_assert_ptr_ne(r, null); 13930 s = toStringO(r); 13931 ck_assert_str_eq(s, "[1,5,3,6]"); 13932 free(s); 13933 // index outside 13934 value = allocSmallInt(1); 13935 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, 20, value), NULL); 13936 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, -8, value), NULL); 13937 // empty list 13938 emptyO(self); 13939 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, 0, value), NULL); 13940 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, -1, value), NULL); 13941 terminateO(value); 13942 // NULL value 13943 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, 0, NULL), NULL); 13944 terminateO(self); 13945 13946 END_TEST 13947 13948 13949 START_TEST(setAtNFreeSmallJsonSmallArrayT) 13950 13951 smallArrayt* r; 13952 smallArrayt *self = allocG(rtSmallArrayt); 13953 smallJsont *value; 13954 13955 // add elements to self 13956 r = self->f->pushInt(self, 1); 13957 ck_assert_ptr_ne(r, null); 13958 r = self->f->pushInt(self, 2); 13959 ck_assert_ptr_ne(r, null); 13960 r = self->f->pushInt(self, 3); 13961 ck_assert_ptr_ne(r, null); 13962 r = self->f->pushInt(self, 4); 13963 ck_assert_ptr_ne(r, null); 13964 13965 // positive index 13966 value = allocSmallJson(); 13967 r = self->f->setAtNFreeSmallJson(self, 1, value); 13968 ck_assert_ptr_ne(r, null); 13969 char *s = toStringO(r); 13970 ck_assert_str_eq(s, "[1,{},3,4]"); 13971 free(s); 13972 // negative index 13973 value = allocSmallJson(); 13974 r = self->f->setAtNFreeSmallJson(self, -1, value); 13975 ck_assert_ptr_ne(r, null); 13976 s = toStringO(r); 13977 ck_assert_str_eq(s, "[1,{},3,{}]"); 13978 free(s); 13979 // index outside 13980 value = allocSmallJson(); 13981 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, 20, value), NULL); 13982 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, -8, value), NULL); 13983 // empty list 13984 emptyO(self); 13985 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, 0, value), NULL); 13986 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, -1, value), NULL); 13987 terminateO(value); 13988 // NULL value 13989 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, 0, NULL), NULL); 13990 terminateO(self); 13991 13992 END_TEST 13993 13994 13995 START_TEST(setAtNFreeSmallStringSmallArrayT) 13996 13997 smallArrayt* r; 13998 smallArrayt *self = allocG(rtSmallArrayt); 13999 smallStringt *value; 14000 14001 // add elements to self 14002 r = self->f->pushInt(self, 1); 14003 ck_assert_ptr_ne(r, null); 14004 r = self->f->pushInt(self, 2); 14005 ck_assert_ptr_ne(r, null); 14006 r = self->f->pushInt(self, 3); 14007 ck_assert_ptr_ne(r, null); 14008 r = self->f->pushInt(self, 4); 14009 ck_assert_ptr_ne(r, null); 14010 14011 // positive index 14012 initiateAllocateSmallString(&value); 14013 r = self->f->setAtNFreeSmallString(self, 1, value); 14014 ck_assert_ptr_ne(r, null); 14015 char *s = toStringO(r); 14016 ck_assert_str_eq(s, "[1,\"\",3,4]"); 14017 free(s); 14018 // negative index 14019 value = allocSmallString("a"); 14020 r = self->f->setAtNFreeSmallString(self, -1, value); 14021 ck_assert_ptr_ne(r, null); 14022 s = toStringO(r); 14023 ck_assert_str_eq(s, "[1,\"\",3,\"a\"]"); 14024 free(s); 14025 // index outside 14026 value = allocSmallString("asd"); 14027 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, 20, value), NULL); 14028 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, -8, value), NULL); 14029 // empty list 14030 emptyO(self); 14031 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, 0, value), NULL); 14032 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, -1, value), NULL); 14033 terminateO(value); 14034 // NULL value 14035 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, 0, NULL), NULL); 14036 terminateO(self); 14037 14038 END_TEST 14039 14040 14041 START_TEST(setAtNFreeSmallContainerSmallArrayT) 14042 14043 smallArrayt* r; 14044 smallArrayt *self = allocG(rtSmallArrayt); 14045 smallContainert *value; 14046 14047 // add elements to self 14048 r = self->f->pushInt(self, 1); 14049 ck_assert_ptr_ne(r, null); 14050 r = self->f->pushInt(self, 2); 14051 ck_assert_ptr_ne(r, null); 14052 r = self->f->pushInt(self, 3); 14053 ck_assert_ptr_ne(r, null); 14054 r = self->f->pushInt(self, 4); 14055 ck_assert_ptr_ne(r, null); 14056 14057 // positive index 14058 initiateAllocateSmallContainer(&value); 14059 r = self->f->setAtNFreeSmallContainer(self, 1, value); 14060 ck_assert_ptr_ne(r, null); 14061 char *s = toStringO(r); 14062 ck_assert_str_eq(s, "[1,\"<data container>\",3,4]"); 14063 free(s); 14064 // negative index 14065 initiateAllocateSmallContainer(&value); 14066 r = self->f->setAtNFreeSmallContainer(self, -1, value); 14067 ck_assert_ptr_ne(r, null); 14068 s = toStringO(r); 14069 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 14070 free(s); 14071 // index outside 14072 initiateAllocateSmallContainer(&value); 14073 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, 20, value), NULL); 14074 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, -8, value), NULL); 14075 // empty list 14076 emptyO(self); 14077 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, 0, value), NULL); 14078 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, -1, value), NULL); 14079 terminateO(value); 14080 // NULL value 14081 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, 0, NULL), NULL); 14082 terminateO(self); 14083 14084 END_TEST 14085 14086 14087 START_TEST(setPAtDictSmallArrayT) 14088 14089 smallArrayt* r; 14090 smallArrayt *self = allocG(rtSmallArrayt); 14091 smallDictt *value; 14092 14093 // add elements to self 14094 r = self->f->pushInt(self, 1); 14095 ck_assert_ptr_ne(r, null); 14096 r = self->f->pushInt(self, 2); 14097 ck_assert_ptr_ne(r, null); 14098 r = self->f->pushInt(self, 3); 14099 ck_assert_ptr_ne(r, null); 14100 r = self->f->pushInt(self, 4); 14101 ck_assert_ptr_ne(r, null); 14102 14103 // positive index 14104 value = allocSmallDict(); 14105 r = self->f->setAtDict(self, 1, value); 14106 ck_assert_ptr_ne(r, null); 14107 value->f->setInt(value, "a", 1); 14108 r = self->f->setPAtDict(self, 1, value); 14109 ck_assert_ptr_ne(r, null); 14110 finishO(value); 14111 char *s = toStringO(r); 14112 ck_assert_str_eq(s, "[1,{\"a\":1},3,4]"); 14113 free(s); 14114 // negative index 14115 value = allocSmallDict(); 14116 r = self->f->setAtDict(self, -1, value); 14117 ck_assert_ptr_ne(r, null); 14118 value->f->setInt(value, "a", 2); 14119 r = self->f->setPAtDict(self, -1, value); 14120 ck_assert_ptr_ne(r, null); 14121 finishO(value); 14122 s = toStringO(r); 14123 ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]"); 14124 free(s); 14125 // empty smallDict 14126 value = allocSmallDict(); 14127 r = self->f->setPAtDict(self, -1, value); 14128 ck_assert_ptr_eq(r, null); 14129 terminateO(value); 14130 // non smallDict object 14131 value = (smallDictt*) allocSmallInt(2); 14132 r = self->f->setPAtDict(self, 0, value); 14133 ck_assert_ptr_eq(r, null); 14134 terminateO(value); 14135 // index outside 14136 value = allocSmallDict(); 14137 ck_assert_ptr_eq(self->f->setPAtDict(self, 20, value), NULL); 14138 ck_assert_ptr_eq(self->f->setPAtDict(self, -8, value), NULL); 14139 // empty list 14140 emptyO(self); 14141 ck_assert_ptr_eq(self->f->setPAtDict(self, 0, value), NULL); 14142 ck_assert_ptr_eq(self->f->setPAtDict(self, -1, value), NULL); 14143 terminateO(value); 14144 // NULL value 14145 ck_assert_ptr_eq(self->f->setPAtDict(self, 0, NULL), NULL); 14146 terminateO(self); 14147 14148 END_TEST 14149 14150 14151 START_TEST(setPAtArraySmallArrayT) 14152 14153 smallArrayt* r; 14154 smallArrayt *self = allocG(rtSmallArrayt); 14155 smallArrayt *value; 14156 14157 // add elements to self 14158 r = self->f->pushInt(self, 1); 14159 ck_assert_ptr_ne(r, null); 14160 r = self->f->pushInt(self, 2); 14161 ck_assert_ptr_ne(r, null); 14162 r = self->f->pushInt(self, 3); 14163 ck_assert_ptr_ne(r, null); 14164 r = self->f->pushInt(self, 4); 14165 ck_assert_ptr_ne(r, null); 14166 14167 // positive index 14168 value = allocSmallArray(); 14169 r = self->f->setAtArray(self, 1, value); 14170 ck_assert_ptr_ne(r, null); 14171 value->f->pushInt(value, 1); 14172 r = self->f->setPAtArray(self, 1, value); 14173 ck_assert_ptr_ne(r, null); 14174 finishO(value); 14175 char *s = toStringO(r); 14176 ck_assert_str_eq(s, "[1,[1],3,4]"); 14177 free(s); 14178 // negative index 14179 value = allocSmallArray(); 14180 r = self->f->setAtArray(self, -1, value); 14181 ck_assert_ptr_ne(r, null); 14182 value->f->pushInt(value, 2); 14183 r = self->f->setPAtArray(self, -1, value); 14184 ck_assert_ptr_ne(r, null); 14185 finishO(value); 14186 s = toStringO(r); 14187 ck_assert_str_eq(s, "[1,[1],3,[2]]"); 14188 free(s); 14189 // empty smallArray 14190 value = allocSmallArray(); 14191 r = self->f->setPAtArray(self, -1, value); 14192 ck_assert_ptr_eq(r, null); 14193 terminateO(value); 14194 // non smallArray object 14195 value = (smallArrayt*) allocSmallInt(2); 14196 r = self->f->setPAtArray(self, 0, value); 14197 ck_assert_ptr_eq(r, null); 14198 terminateO(value); 14199 // index outside 14200 value = allocSmallArray(); 14201 ck_assert_ptr_eq(self->f->setPAtArray(self, 20, value), NULL); 14202 ck_assert_ptr_eq(self->f->setPAtArray(self, -8, value), NULL); 14203 // empty list 14204 emptyO(self); 14205 ck_assert_ptr_eq(self->f->setPAtArray(self, 0, value), NULL); 14206 ck_assert_ptr_eq(self->f->setPAtArray(self, -1, value), NULL); 14207 terminateO(value); 14208 // NULL value 14209 ck_assert_ptr_eq(self->f->setPAtArray(self, 0, NULL), NULL); 14210 terminateO(self); 14211 14212 END_TEST 14213 14214 14215 START_TEST(setPAtSmallJsonSmallArrayT) 14216 14217 smallArrayt* r; 14218 smallArrayt *self = allocG(rtSmallArrayt); 14219 smallJsont *value; 14220 14221 // add elements to self 14222 r = self->f->pushInt(self, 1); 14223 ck_assert_ptr_ne(r, null); 14224 r = self->f->pushInt(self, 2); 14225 ck_assert_ptr_ne(r, null); 14226 r = self->f->pushInt(self, 3); 14227 ck_assert_ptr_ne(r, null); 14228 r = self->f->pushInt(self, 4); 14229 ck_assert_ptr_ne(r, null); 14230 14231 // positive index 14232 value = allocSmallJson(); 14233 r = self->f->setAtSmallJson(self, 1, value); 14234 ck_assert_ptr_ne(r, null); 14235 value->f->setInt(value, "a", 1); 14236 r = self->f->setPAtSmallJson(self, 1, value); 14237 ck_assert_ptr_ne(r, null); 14238 finishO(value); 14239 char *s = toStringO(r); 14240 ck_assert_str_eq(s, "[1,{\"a\":1},3,4]"); 14241 free(s); 14242 // negative index 14243 value = allocSmallJson(); 14244 r = self->f->setAtSmallJson(self, -1, value); 14245 ck_assert_ptr_ne(r, null); 14246 value->f->setInt(value, "a", 2); 14247 r = self->f->setPAtSmallJson(self, -1, value); 14248 ck_assert_ptr_ne(r, null); 14249 finishO(value); 14250 s = toStringO(r); 14251 ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]"); 14252 free(s); 14253 // empty smallJson 14254 value = allocSmallJson(); 14255 r = self->f->setPAtSmallJson(self, -1, value); 14256 ck_assert_ptr_eq(r, null); 14257 terminateO(value); 14258 // non smallJson object 14259 value = (smallJsont*) allocSmallInt(2); 14260 r = self->f->setPAtSmallJson(self, 0, value); 14261 ck_assert_ptr_eq(r, null); 14262 terminateO(value); 14263 // index outside 14264 value = allocSmallJson(); 14265 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, 20, value), NULL); 14266 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, -8, value), NULL); 14267 // empty list 14268 emptyO(self); 14269 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, 0, value), NULL); 14270 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, -1, value), NULL); 14271 terminateO(value); 14272 // NULL value 14273 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, 0, NULL), NULL); 14274 terminateO(self); 14275 14276 END_TEST 14277 14278 14279 START_TEST(setPAtSmallStringSmallArrayT) 14280 14281 smallArrayt* r; 14282 smallArrayt *self = allocG(rtSmallArrayt); 14283 smallStringt *value; 14284 14285 // add elements to self 14286 r = self->f->pushInt(self, 1); 14287 ck_assert_ptr_ne(r, null); 14288 r = self->f->pushInt(self, 2); 14289 ck_assert_ptr_ne(r, null); 14290 r = self->f->pushInt(self, 3); 14291 ck_assert_ptr_ne(r, null); 14292 r = self->f->pushInt(self, 4); 14293 ck_assert_ptr_ne(r, null); 14294 14295 // positive index 14296 initiateAllocateSmallString(&value); 14297 r = self->f->setAtSmallString(self, 1, value); 14298 ck_assert_ptr_ne(r, null); 14299 value->f->appendS(value, "1"); 14300 r = self->f->setPAtSmallString(self, 1, value); 14301 ck_assert_ptr_ne(r, null); 14302 finishO(value); 14303 char *s = toStringO(r); 14304 ck_assert_str_eq(s, "[1,\"1\",3,4]"); 14305 free(s); 14306 // negative index 14307 value = allocSmallString("a"); 14308 r = self->f->setAtSmallString(self, -1, value); 14309 ck_assert_ptr_ne(r, null); 14310 value->f->appendS(value, "2"); 14311 r = self->f->setPAtSmallString(self, -1, value); 14312 ck_assert_ptr_ne(r, null); 14313 finishO(value); 14314 s = toStringO(r); 14315 ck_assert_str_eq(s, "[1,\"1\",3,\"a2\"]"); 14316 free(s); 14317 // empty SmallString 14318 value = allocSmallString(""); 14319 freeO(value); 14320 r = self->f->setPAtSmallString(self, -1, value); 14321 ck_assert_ptr_eq(r, null); 14322 terminateO(value); 14323 // non smallString object 14324 value = (smallStringt*) allocSmallInt(2); 14325 r = self->f->setPAtSmallString(self, 0, value); 14326 ck_assert_ptr_eq(r, null); 14327 terminateO(value); 14328 // index outside 14329 value = allocSmallString("asd"); 14330 ck_assert_ptr_eq(self->f->setPAtSmallString(self, 20, value), NULL); 14331 ck_assert_ptr_eq(self->f->setPAtSmallString(self, -8, value), NULL); 14332 // empty list 14333 emptyO(self); 14334 ck_assert_ptr_eq(self->f->setPAtSmallString(self, 0, value), NULL); 14335 ck_assert_ptr_eq(self->f->setPAtSmallString(self, -1, value), NULL); 14336 terminateO(value); 14337 // NULL value 14338 ck_assert_ptr_eq(self->f->setPAtSmallString(self, 0, NULL), NULL); 14339 terminateO(self); 14340 14341 END_TEST 14342 14343 14344 START_TEST(setPAtNFreeDictSmallArrayT) 14345 14346 smallArrayt* r; 14347 smallArrayt *self = allocG(rtSmallArrayt); 14348 smallDictt *value; 14349 14350 // add elements to self 14351 r = self->f->pushInt(self, 1); 14352 ck_assert_ptr_ne(r, null); 14353 r = self->f->pushInt(self, 2); 14354 ck_assert_ptr_ne(r, null); 14355 r = self->f->pushInt(self, 3); 14356 ck_assert_ptr_ne(r, null); 14357 r = self->f->pushInt(self, 4); 14358 ck_assert_ptr_ne(r, null); 14359 14360 // positive index 14361 value = allocSmallDict(); 14362 r = self->f->setAtDict(self, 1, value); 14363 ck_assert_ptr_ne(r, null); 14364 value->f->setInt(value, "a", 1); 14365 r = self->f->setPAtNFreeDict(self, 1, value); 14366 ck_assert_ptr_ne(r, null); 14367 char *s = toStringO(r); 14368 ck_assert_str_eq(s, "[1,{\"a\":1},3,4]"); 14369 free(s); 14370 // negative index 14371 value = allocSmallDict(); 14372 r = self->f->setAtDict(self, -1, value); 14373 ck_assert_ptr_ne(r, null); 14374 value->f->setInt(value, "a", 2); 14375 r = self->f->setPAtNFreeDict(self, -1, value); 14376 ck_assert_ptr_ne(r, null); 14377 s = toStringO(r); 14378 ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]"); 14379 free(s); 14380 // empty smallDict 14381 value = allocSmallDict(); 14382 r = self->f->setPAtNFreeDict(self, -1, value); 14383 ck_assert_ptr_eq(r, null); 14384 terminateO(value); 14385 // non smallDict object 14386 value = (smallDictt*) allocSmallInt(2); 14387 r = self->f->setPAtNFreeDict(self, 0, value); 14388 ck_assert_ptr_eq(r, null); 14389 terminateO(value); 14390 // index outside 14391 value = allocSmallDict(); 14392 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, 20, value), NULL); 14393 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, -8, value), NULL); 14394 // empty list 14395 emptyO(self); 14396 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, 0, value), NULL); 14397 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, -1, value), NULL); 14398 terminateO(value); 14399 // NULL value 14400 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, 0, NULL), NULL); 14401 terminateO(self); 14402 14403 END_TEST 14404 14405 14406 START_TEST(setPAtNFreeArraySmallArrayT) 14407 14408 smallArrayt* r; 14409 smallArrayt *self = allocG(rtSmallArrayt); 14410 smallArrayt *value; 14411 14412 // add elements to self 14413 r = self->f->pushInt(self, 1); 14414 ck_assert_ptr_ne(r, null); 14415 r = self->f->pushInt(self, 2); 14416 ck_assert_ptr_ne(r, null); 14417 r = self->f->pushInt(self, 3); 14418 ck_assert_ptr_ne(r, null); 14419 r = self->f->pushInt(self, 4); 14420 ck_assert_ptr_ne(r, null); 14421 14422 // positive index 14423 value = allocSmallArray(); 14424 r = self->f->setAtArray(self, 1, value); 14425 ck_assert_ptr_ne(r, null); 14426 value->f->pushInt(value, 1); 14427 r = self->f->setPAtNFreeArray(self, 1, value); 14428 ck_assert_ptr_ne(r, null); 14429 char *s = toStringO(r); 14430 ck_assert_str_eq(s, "[1,[1],3,4]"); 14431 free(s); 14432 // negative index 14433 value = allocSmallArray(); 14434 r = self->f->setAtArray(self, -1, value); 14435 ck_assert_ptr_ne(r, null); 14436 value->f->pushInt(value, 2); 14437 r = self->f->setPAtNFreeArray(self, -1, value); 14438 ck_assert_ptr_ne(r, null); 14439 s = toStringO(r); 14440 ck_assert_str_eq(s, "[1,[1],3,[2]]"); 14441 free(s); 14442 // empty smallArray 14443 value = allocSmallArray(); 14444 r = self->f->setPAtNFreeArray(self, -1, value); 14445 ck_assert_ptr_eq(r, null); 14446 terminateO(value); 14447 // non smallArray object 14448 value = (smallArrayt*) allocSmallInt(2); 14449 r = self->f->setPAtNFreeArray(self, 0, value); 14450 ck_assert_ptr_eq(r, null); 14451 terminateO(value); 14452 // index outside 14453 value = allocSmallArray(); 14454 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, 20, value), NULL); 14455 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, -8, value), NULL); 14456 // empty list 14457 emptyO(self); 14458 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, 0, value), NULL); 14459 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, -1, value), NULL); 14460 terminateO(value); 14461 // NULL value 14462 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, 0, NULL), NULL); 14463 terminateO(self); 14464 14465 END_TEST 14466 14467 14468 START_TEST(setPAtNFreeSmallJsonSmallArrayT) 14469 14470 smallArrayt* r; 14471 smallArrayt *self = allocG(rtSmallArrayt); 14472 smallJsont *value; 14473 14474 // add elements to self 14475 r = self->f->pushInt(self, 1); 14476 ck_assert_ptr_ne(r, null); 14477 r = self->f->pushInt(self, 2); 14478 ck_assert_ptr_ne(r, null); 14479 r = self->f->pushInt(self, 3); 14480 ck_assert_ptr_ne(r, null); 14481 r = self->f->pushInt(self, 4); 14482 ck_assert_ptr_ne(r, null); 14483 14484 // positive index 14485 value = allocSmallJson(); 14486 r = self->f->setAtSmallJson(self, 1, value); 14487 ck_assert_ptr_ne(r, null); 14488 value->f->setInt(value, "a", 1); 14489 r = self->f->setPAtNFreeSmallJson(self, 1, value); 14490 ck_assert_ptr_ne(r, null); 14491 char *s = toStringO(r); 14492 ck_assert_str_eq(s, "[1,{\"a\":1},3,4]"); 14493 free(s); 14494 // negative index 14495 value = allocSmallJson(); 14496 r = self->f->setAtSmallJson(self, -1, value); 14497 ck_assert_ptr_ne(r, null); 14498 value->f->setInt(value, "a", 2); 14499 r = self->f->setPAtNFreeSmallJson(self, -1, value); 14500 ck_assert_ptr_ne(r, null); 14501 s = toStringO(r); 14502 ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]"); 14503 free(s); 14504 // empty smallJson 14505 value = allocSmallJson(); 14506 r = self->f->setPAtNFreeSmallJson(self, -1, value); 14507 ck_assert_ptr_eq(r, null); 14508 terminateO(value); 14509 // non smallJson object 14510 value = (smallJsont*) allocSmallInt(2); 14511 r = self->f->setPAtNFreeSmallJson(self, 0, value); 14512 ck_assert_ptr_eq(r, null); 14513 terminateO(value); 14514 // index outside 14515 value = allocSmallJson(); 14516 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, 20, value), NULL); 14517 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, -8, value), NULL); 14518 // empty list 14519 emptyO(self); 14520 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, 0, value), NULL); 14521 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, -1, value), NULL); 14522 terminateO(value); 14523 // NULL value 14524 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, 0, NULL), NULL); 14525 terminateO(self); 14526 14527 END_TEST 14528 14529 14530 START_TEST(setPAtNFreeSmallStringSmallArrayT) 14531 14532 smallArrayt* r; 14533 smallArrayt *self = allocG(rtSmallArrayt); 14534 smallStringt *value; 14535 14536 // add elements to self 14537 r = self->f->pushInt(self, 1); 14538 ck_assert_ptr_ne(r, null); 14539 r = self->f->pushInt(self, 2); 14540 ck_assert_ptr_ne(r, null); 14541 r = self->f->pushInt(self, 3); 14542 ck_assert_ptr_ne(r, null); 14543 r = self->f->pushInt(self, 4); 14544 ck_assert_ptr_ne(r, null); 14545 14546 // positive index 14547 initiateAllocateSmallString(&value); 14548 r = self->f->setAtSmallString(self, 1, value); 14549 ck_assert_ptr_ne(r, null); 14550 value->f->appendS(value, "1"); 14551 r = self->f->setPAtNFreeSmallString(self, 1, value); 14552 ck_assert_ptr_ne(r, null); 14553 char *s = toStringO(r); 14554 ck_assert_str_eq(s, "[1,\"1\",3,4]"); 14555 free(s); 14556 // negative index 14557 value = allocSmallString("a"); 14558 r = self->f->setAtSmallString(self, -1, value); 14559 ck_assert_ptr_ne(r, null); 14560 value->f->appendS(value, "2"); 14561 r = self->f->setPAtNFreeSmallString(self, -1, value); 14562 ck_assert_ptr_ne(r, null); 14563 s = toStringO(r); 14564 ck_assert_str_eq(s, "[1,\"1\",3,\"a2\"]"); 14565 free(s); 14566 // empty SmallString 14567 value = allocSmallString(""); 14568 freeO(value); 14569 r = self->f->setPAtNFreeSmallString(self, -1, value); 14570 ck_assert_ptr_eq(r, null); 14571 terminateO(value); 14572 // non smallString object 14573 value = (smallStringt*) allocSmallInt(2); 14574 r = self->f->setPAtNFreeSmallString(self, 0, value); 14575 ck_assert_ptr_eq(r, null); 14576 terminateO(value); 14577 // index outside 14578 value = allocSmallString("asd"); 14579 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, 20, value), NULL); 14580 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, -8, value), NULL); 14581 // empty list 14582 emptyO(self); 14583 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, 0, value), NULL); 14584 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, -1, value), NULL); 14585 terminateO(value); 14586 // NULL value 14587 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, 0, NULL), NULL); 14588 terminateO(self); 14589 14590 END_TEST 14591 14592 14593 START_TEST(getNumSmallArrayT) 14594 14595 double r; 14596 smallArrayt *self = allocG(rtSmallArrayt); 14597 smallArrayt *r2; 14598 14599 // add elements to self 14600 r2 = self->f->pushInt(self, 1); 14601 ck_assert_ptr_ne(r2, null); 14602 r2 = self->f->pushDouble(self, 2); 14603 ck_assert_ptr_ne(r2, null); 14604 r2 = self->f->pushInt(self, 3); 14605 ck_assert_ptr_ne(r2, null); 14606 r2 = self->f->pushInt(self, 4); 14607 ck_assert_ptr_ne(r2, null); 14608 14609 // positive index 14610 r = self->f->getNum(self,1); 14611 ck_assert(r==2); 14612 char *s = toStringO(self); 14613 ck_assert_str_eq(s, "[1,2.000000e+00,3,4]"); 14614 free(s); 14615 // negative index 14616 r = self->f->getNum(self,-1); 14617 ck_assert(r==4); 14618 s = toStringO(self); 14619 ck_assert_str_eq(s, "[1,2.000000e+00,3,4]"); 14620 free(s); 14621 // wrong object type of another user class 14622 // User classes are stored in containers transparently 14623 createAllocateSmallInt(ip); 14624 ip->type = "anothertype"; 14625 setValG(ip, 11); 14626 r2 = self->f->push(self, (baset*)ip); 14627 ck_assert_ptr_ne(r2, null); 14628 r = self->f->getNum(self,-1); 14629 ck_assert(!r); 14630 s = toStringO(self); 14631 ck_assert_str_eq(s, "[1,2.000000e+00,3,4,\"<data container>\"]"); 14632 free(s); 14633 // index outside 14634 ck_assert(!self->f->getNum(self, 20)); 14635 ck_assert(!self->f->getNum(self, -7)); 14636 // empty list 14637 emptyO(self); 14638 ck_assert(!self->f->getNum(self, 0)); 14639 ck_assert(!self->f->getNum(self, -1)); 14640 terminateO(self); 14641 14642 END_TEST 14643 14644 14645 START_TEST(hasSmallArrayT) 14646 14647 bool r; 14648 smallArrayt *self = allocG(rtSmallArrayt); 14649 baset *value = (baset*)allocSmallInt(1); 14650 14651 // has 14652 self->f->pushInt(self, 1); 14653 r = hasO(self, value); 14654 ck_assert(r); 14655 // not has 14656 emptyO(self); 14657 r = hasO(self, value); 14658 ck_assert(!r); 14659 // NULL value 14660 r = hasO(self, NULL); 14661 ck_assert(!r); 14662 terminateO(self); 14663 terminateO(value); 14664 14665 END_TEST 14666 14667 14668 START_TEST(hasUndefinedSmallArrayT) 14669 14670 bool r; 14671 smallArrayt *self = allocG(rtSmallArrayt); 14672 undefinedt *value = allocUndefined(); 14673 14674 // has 14675 self->f->pushUndefined(self); 14676 r = hasUndefinedO(self, value); 14677 ck_assert(r); 14678 // not has 14679 emptyO(self); 14680 r = hasUndefinedO(self, value); 14681 ck_assert(!r); 14682 // non undefined object 14683 terminateO(value); 14684 value = (undefinedt*) allocSmallInt(2); 14685 r = hasUndefinedO(self, value); 14686 ck_assert(!r); 14687 // NULL value 14688 r = hasUndefinedO(self, NULL); 14689 ck_assert(!r); 14690 terminateO(self); 14691 terminateO(value); 14692 14693 END_TEST 14694 14695 14696 START_TEST(hasBoolSmallArrayT) 14697 14698 bool r; 14699 smallArrayt *self = allocG(rtSmallArrayt); 14700 bool value = true; 14701 14702 // has 14703 self->f->pushBool(self, true); 14704 r = hasBoolO(self, value); 14705 ck_assert(r); 14706 // not has 14707 emptyO(self); 14708 r = hasBoolO(self, value); 14709 ck_assert(!r); 14710 terminateO(self); 14711 14712 END_TEST 14713 14714 14715 START_TEST(hasDoubleSmallArrayT) 14716 14717 bool r; 14718 smallArrayt *self = allocG(rtSmallArrayt); 14719 double value = 2; 14720 14721 // has 14722 self->f->pushDouble(self, 2); 14723 r = hasDoubleO(self, value); 14724 ck_assert(r); 14725 // not has 14726 emptyO(self); 14727 r = hasDoubleO(self, value); 14728 ck_assert(!r); 14729 terminateO(self); 14730 14731 END_TEST 14732 14733 14734 START_TEST(hasIntSmallArrayT) 14735 14736 bool r; 14737 smallArrayt *self = allocG(rtSmallArrayt); 14738 int64_t value = 1000; 14739 14740 // has 14741 self->f->pushInt(self, 1000); 14742 r = hasIntO(self, value); 14743 ck_assert(r); 14744 // not has 14745 emptyO(self); 14746 r = hasIntO(self, value); 14747 ck_assert(!r); 14748 terminateO(self); 14749 14750 END_TEST 14751 14752 14753 START_TEST(hasSSmallArrayT) 14754 14755 bool r; 14756 smallArrayt *self = allocG(rtSmallArrayt); 14757 const char *value = "asd"; 14758 14759 // has 14760 self->f->pushS(self, "asd"); 14761 r = hasSO(self, value); 14762 ck_assert(r); 14763 // not has 14764 emptyO(self); 14765 r = hasSO(self, value); 14766 ck_assert(!r); 14767 // NULL value 14768 r = hasSO(self, NULL); 14769 ck_assert(!r); 14770 terminateO(self); 14771 14772 END_TEST 14773 14774 14775 START_TEST(hasCharSmallArrayT) 14776 14777 bool r; 14778 smallArrayt *self = allocG(rtSmallArrayt); 14779 char value = 'a'; 14780 14781 // has 14782 self->f->pushS(self, "a"); 14783 r = hasCharO(self, value); 14784 ck_assert(r); 14785 // not has 14786 emptyO(self); 14787 r = hasCharO(self, value); 14788 ck_assert(!r); 14789 terminateO(self); 14790 14791 END_TEST 14792 14793 14794 START_TEST(hasDictSmallArrayT) 14795 14796 bool r; 14797 smallArrayt *self = allocG(rtSmallArrayt); 14798 smallDictt *value = allocSmallDict(); 14799 14800 // has 14801 self->f->pushNFreeDict(self, allocSmallDict()); 14802 r = hasDictO(self, value); 14803 ck_assert(r); 14804 // not has 14805 emptyO(self); 14806 r = hasDictO(self, value); 14807 ck_assert(!r); 14808 // non smallDict object 14809 terminateO(value); 14810 value = (smallDictt*) allocSmallInt(2); 14811 r = hasDictO(self, value); 14812 ck_assert(!r); 14813 // NULL value 14814 r = hasDictO(self, NULL); 14815 ck_assert(!r); 14816 terminateO(self); 14817 terminateO(value); 14818 14819 END_TEST 14820 14821 14822 START_TEST(hasArraySmallArrayT) 14823 14824 bool r; 14825 smallArrayt *self = allocG(rtSmallArrayt); 14826 smallArrayt *value = allocSmallArray(); 14827 14828 // has 14829 self->f->pushNFreeArray(self, allocSmallArray()); 14830 r = hasArrayO(self, value); 14831 ck_assert(r); 14832 // not has 14833 emptyO(self); 14834 r = hasArrayO(self, value); 14835 ck_assert(!r); 14836 // non smallArray object 14837 terminateO(value); 14838 value = (smallArrayt*) allocSmallInt(2); 14839 r = hasArrayO(self, value); 14840 ck_assert(!r); 14841 // NULL value 14842 r = hasArrayO(self, NULL); 14843 ck_assert(!r); 14844 terminateO(self); 14845 terminateO(value); 14846 14847 END_TEST 14848 14849 14850 START_TEST(hasArraycSmallArrayT) 14851 14852 bool r; 14853 smallArrayt *self = allocG(rtSmallArrayt); 14854 char **value = listCreateS("a","bb"); 14855 14856 // has 14857 self->f->pushNFreeArrayc(self, listCreateS("a","bb")); 14858 r = hasArraycO(self, value); 14859 ck_assert(r); 14860 // not has 14861 emptyO(self); 14862 r = hasArraycO(self, value); 14863 ck_assert(!r); 14864 // NULL value 14865 r = hasArraycO(self, NULL); 14866 ck_assert(!r); 14867 terminateO(self); 14868 listFreeS(value); 14869 14870 END_TEST 14871 14872 14873 START_TEST(hasSmallBoolSmallArrayT) 14874 14875 bool r; 14876 smallArrayt *self = allocG(rtSmallArrayt); 14877 smallBoolt *value = allocSmallBool(true); 14878 14879 // has 14880 self->f->pushBool(self, true); 14881 r = hasSmallBoolO(self, value); 14882 ck_assert(r); 14883 // not has 14884 emptyO(self); 14885 r = hasSmallBoolO(self, value); 14886 ck_assert(!r); 14887 // non smallBool object 14888 terminateO(value); 14889 value = (smallBoolt*) allocSmallInt(2); 14890 r = hasSmallBoolO(self, value); 14891 ck_assert(!r); 14892 // NULL value 14893 r = hasSmallBoolO(self, NULL); 14894 ck_assert(!r); 14895 terminateO(self); 14896 terminateO(value); 14897 14898 END_TEST 14899 14900 14901 START_TEST(hasSmallBytesSmallArrayT) 14902 14903 bool r; 14904 smallArrayt *self = allocG(rtSmallArrayt); 14905 createAllocateSmallBytes(value); 14906 pushBufferO(value, &self, 8); 14907 14908 // has 14909 createAllocateSmallBytes(elem); 14910 pushBufferO(elem, &self, 8); 14911 self->f->pushNFreeSmallBytes(self, elem); 14912 r = hasSmallBytesO(self, value); 14913 ck_assert(r); 14914 // not has 14915 emptyO(self); 14916 r = hasSmallBytesO(self, value); 14917 ck_assert(!r); 14918 // non smallBytes object 14919 terminateO(value); 14920 value = (smallBytest*) allocSmallInt(2); 14921 r = hasSmallBytesO(self, value); 14922 ck_assert(!r); 14923 // NULL value 14924 r = hasSmallBytesO(self, NULL); 14925 ck_assert(!r); 14926 terminateO(self); 14927 terminateO(value); 14928 14929 END_TEST 14930 14931 14932 START_TEST(hasSmallDoubleSmallArrayT) 14933 14934 bool r; 14935 smallArrayt *self = allocG(rtSmallArrayt); 14936 smallDoublet *value = allocSmallDouble(2); 14937 14938 // has 14939 self->f->pushDouble(self, 2); 14940 r = hasSmallDoubleO(self, value); 14941 ck_assert(r); 14942 // not has 14943 emptyO(self); 14944 r = hasSmallDoubleO(self, value); 14945 ck_assert(!r); 14946 // non smallDouble object 14947 terminateO(value); 14948 value = (smallDoublet*) allocSmallInt(2); 14949 r = hasSmallDoubleO(self, value); 14950 ck_assert(!r); 14951 // NULL value 14952 r = hasSmallDoubleO(self, NULL); 14953 ck_assert(!r); 14954 terminateO(self); 14955 terminateO(value); 14956 14957 END_TEST 14958 14959 14960 START_TEST(hasSmallIntSmallArrayT) 14961 14962 bool r; 14963 smallArrayt *self = allocG(rtSmallArrayt); 14964 smallIntt *value = allocSmallInt(12); 14965 14966 // has 14967 self->f->pushInt(self, 12); 14968 r = hasSmallIntO(self, value); 14969 ck_assert(r); 14970 // not has 14971 emptyO(self); 14972 r = hasSmallIntO(self, value); 14973 ck_assert(!r); 14974 // non smallInt object 14975 terminateO(value); 14976 value = (smallIntt*) allocSmallBool(true); 14977 r = hasSmallIntO(self, value); 14978 ck_assert(!r); 14979 // NULL value 14980 r = hasSmallIntO(self, NULL); 14981 ck_assert(!r); 14982 terminateO(self); 14983 terminateO(value); 14984 14985 END_TEST 14986 14987 14988 START_TEST(hasSmallJsonSmallArrayT) 14989 14990 bool r; 14991 smallArrayt *self = allocG(rtSmallArrayt); 14992 smallJsont *value = allocSmallJson(); 14993 value->f->pushInt(value, 1); 14994 14995 // has 14996 createAllocateSmallJson(elem); 14997 elem->f->pushInt(elem, 1); 14998 self->f->pushNFreeSmallJson(self, elem); 14999 r = self->f->hasSmallJson(self, value); 15000 ck_assert(r); 15001 // not has 15002 emptyO(self); 15003 r = self->f->hasSmallJson(self, value); 15004 ck_assert(!r); 15005 // non smallJson object 15006 terminateO(value); 15007 value = (smallJsont*) allocSmallInt(2); 15008 r = self->f->hasSmallJson(self, value); 15009 ck_assert(!r); 15010 // NULL value 15011 r = self->f->hasSmallJson(self, NULL); 15012 ck_assert(!r); 15013 terminateO(self); 15014 terminateO(value); 15015 15016 END_TEST 15017 15018 15019 START_TEST(hasSmallStringSmallArrayT) 15020 15021 bool r; 15022 smallArrayt *self = allocG(rtSmallArrayt); 15023 smallStringt *value = allocSmallString("qwe"); 15024 15025 // has 15026 self->f->pushS(self, "qwe"); 15027 r = self->f->hasSmallString(self, value); 15028 ck_assert(r); 15029 // not has 15030 emptyO(self); 15031 r = self->f->hasSmallString(self, value); 15032 ck_assert(!r); 15033 // non smallString object 15034 terminateO(value); 15035 value = (smallStringt*) allocSmallInt(2); 15036 r = self->f->hasSmallString(self, value); 15037 ck_assert(!r); 15038 // NULL value 15039 r = self->f->hasSmallString(self, NULL); 15040 ck_assert(!r); 15041 terminateO(self); 15042 terminateO(value); 15043 15044 END_TEST 15045 15046 15047 START_TEST(hasSmallContainerSmallArrayT) 15048 15049 bool r; 15050 smallArrayt *self = allocG(rtSmallArrayt); 15051 createAllocateSmallContainer(value); 15052 15053 // has 15054 createAllocateSmallContainer(elem); 15055 self->f->pushNFreeSmallContainer(self, elem); 15056 r = hasSmallContainerO(self, value); 15057 ck_assert(!r); 15058 // not has 15059 emptyO(self); 15060 r = hasSmallContainerO(self, value); 15061 ck_assert(!r); 15062 // non smallContainer object 15063 terminateO(value); 15064 value = (smallContainert*) allocSmallInt(2); 15065 r = self->f->hasSmallContainer(self, value); 15066 ck_assert(!r); 15067 // NULL value 15068 r = hasSmallContainerO(self, NULL); 15069 ck_assert(!r); 15070 terminateO(self); 15071 terminateO(value); 15072 15073 END_TEST 15074 15075 15076 START_TEST(indexOfSmallArrayT) 15077 15078 ssize_t r; 15079 smallArrayt *self = allocG(rtSmallArrayt); 15080 baset *value = (baset*)allocSmallInt(1); 15081 15082 // index 15083 self->f->pushInt(self, 2); 15084 self->f->pushInt(self, 0); 15085 delElemO(self, 1); 15086 self->f->pushInt(self, 1); 15087 r = indexOfO(self, value); 15088 ck_assert_int_eq(r, 2); 15089 // not index 15090 smallIntt *v = (smallIntt*) value; 15091 setValO(v, 0); 15092 r = indexOfO(self, value); 15093 ck_assert_int_eq(r, -1); 15094 // NULL value 15095 r = indexOfO(self, NULL); 15096 ck_assert_int_eq(r, -1); 15097 terminateO(self); 15098 terminateO(value); 15099 15100 END_TEST 15101 15102 15103 START_TEST(indexOfUndefinedSmallArrayT) 15104 15105 ssize_t r; 15106 smallArrayt *self = allocG(rtSmallArrayt); 15107 undefinedt *value = allocUndefined(); 15108 15109 // indexOf 15110 self->f->pushInt(self, 1); 15111 self->f->pushUndefined(self); 15112 delElemO(self, 1); 15113 self->f->pushUndefined(self); 15114 r = indexOfUndefinedO(self, value); 15115 ck_assert_int_eq(r, 2); 15116 // not indexOf 15117 delElemO(self, 2); 15118 r = indexOfUndefinedO(self, value); 15119 ck_assert_int_eq(r, -1); 15120 // non undefined object 15121 terminateO(value); 15122 value = (undefinedt*) allocSmallInt(2); 15123 r = indexOfUndefinedO(self, value); 15124 ck_assert_int_eq(r, -1); 15125 // NULL value 15126 r = indexOfUndefinedO(self, NULL); 15127 ck_assert_int_eq(r, -1); 15128 terminateO(self); 15129 terminateO(value); 15130 15131 END_TEST 15132 15133 15134 START_TEST(indexOfBoolSmallArrayT) 15135 15136 ssize_t r; 15137 smallArrayt *self = allocG(rtSmallArrayt); 15138 bool value = true; 15139 15140 // indexOf 15141 self->f->pushInt(self, 1); 15142 self->f->pushUndefined(self); 15143 delElemO(self, 1); 15144 self->f->pushBool(self, true); 15145 r = indexOfBoolO(self, value); 15146 ck_assert_int_eq(r, 2); 15147 // not indexOf 15148 delElemO(self, 2); 15149 r = indexOfBoolO(self, value); 15150 ck_assert_int_eq(r, -1); 15151 terminateO(self); 15152 15153 END_TEST 15154 15155 15156 START_TEST(indexOfDoubleSmallArrayT) 15157 15158 ssize_t r; 15159 smallArrayt *self = allocG(rtSmallArrayt); 15160 double value = 2; 15161 15162 // indexOf 15163 self->f->pushInt(self, 1); 15164 self->f->pushUndefined(self); 15165 delElemO(self, 1); 15166 self->f->pushDouble(self, 2); 15167 r = indexOfDoubleO(self, value); 15168 ck_assert_int_eq(r, 2); 15169 // not indexOf 15170 delElemO(self, 2); 15171 r = indexOfDoubleO(self, value); 15172 ck_assert_int_eq(r, -1); 15173 terminateO(self); 15174 15175 END_TEST 15176 15177 15178 START_TEST(indexOfIntSmallArrayT) 15179 15180 ssize_t r; 15181 smallArrayt *self = allocG(rtSmallArrayt); 15182 int64_t value = 1000; 15183 15184 // indexOf 15185 self->f->pushUndefined(self); 15186 self->f->pushUndefined(self); 15187 delElemO(self, 1); 15188 self->f->pushInt(self, 1000); 15189 r = indexOfIntO(self, value); 15190 ck_assert_int_eq(r, 2); 15191 // not indexOf 15192 delElemO(self, 2); 15193 r = indexOfIntO(self, value); 15194 ck_assert_int_eq(r, -1); 15195 terminateO(self); 15196 15197 END_TEST 15198 15199 15200 START_TEST(indexOfSSmallArrayT) 15201 15202 ssize_t r; 15203 smallArrayt *self = allocG(rtSmallArrayt); 15204 const char *value = "asd"; 15205 15206 // indexOf 15207 self->f->pushUndefined(self); 15208 self->f->pushUndefined(self); 15209 delElemO(self, 1); 15210 self->f->pushS(self, "asd"); 15211 r = indexOfSO(self, value); 15212 ck_assert_int_eq(r, 2); 15213 // not indexOf 15214 delElemO(self, 2); 15215 r = indexOfSO(self, value); 15216 ck_assert_int_eq(r, -1); 15217 // NULL value 15218 r = indexOfSO(self, NULL); 15219 ck_assert_int_eq(r, -1); 15220 terminateO(self); 15221 15222 END_TEST 15223 15224 15225 START_TEST(indexOfCharSmallArrayT) 15226 15227 ssize_t r; 15228 smallArrayt *self = allocG(rtSmallArrayt); 15229 char value = 'a'; 15230 15231 // indexOf 15232 self->f->pushUndefined(self); 15233 self->f->pushUndefined(self); 15234 delElemO(self, 1); 15235 self->f->pushS(self, "a"); 15236 r = indexOfCharO(self, value); 15237 ck_assert_int_eq(r, 2); 15238 // not indexOf 15239 delElemO(self, 2); 15240 r = indexOfCharO(self, value); 15241 ck_assert_int_eq(r, -1); 15242 terminateO(self); 15243 15244 END_TEST 15245 15246 15247 START_TEST(indexOfDictSmallArrayT) 15248 15249 ssize_t r; 15250 smallArrayt *self = allocG(rtSmallArrayt); 15251 smallDictt *value = allocSmallDict(); 15252 15253 // indexOf 15254 createAllocateSmallDict(elem); 15255 elem->f->setInt(elem, "a", 1); 15256 self->f->pushNFreeDict(self, elem); 15257 self->f->pushUndefined(self); 15258 delElemO(self, 1); 15259 self->f->pushNFreeDict(self, allocSmallDict()); 15260 r = indexOfDictO(self, value); 15261 ck_assert_int_eq(r, 2); 15262 // not indexOf 15263 delElemO(self, 2); 15264 r = indexOfDictO(self, value); 15265 ck_assert_int_eq(r, -1); 15266 // non smallDict object 15267 terminateO(value); 15268 value = (smallDictt*) allocSmallInt(2); 15269 r = indexOfDictO(self, value); 15270 ck_assert_int_eq(r, -1); 15271 // NULL value 15272 r = indexOfDictO(self, NULL); 15273 ck_assert_int_eq(r, -1); 15274 terminateO(self); 15275 terminateO(value); 15276 15277 END_TEST 15278 15279 15280 START_TEST(indexOfArraySmallArrayT) 15281 15282 ssize_t r; 15283 smallArrayt *self = allocG(rtSmallArrayt); 15284 smallArrayt *value = allocSmallArray(); 15285 15286 // indexOf 15287 createAllocateSmallArray(elem); 15288 elem->f->pushInt(elem, 1); 15289 self->f->pushNFreeArray(self, elem); 15290 self->f->pushUndefined(self); 15291 delElemO(self, 1); 15292 self->f->pushNFreeArray(self, allocSmallArray()); 15293 r = indexOfArrayO(self, value); 15294 ck_assert_int_eq(r, 2); 15295 // non smallArray object 15296 terminateO(value); 15297 value = (smallArrayt*) allocSmallInt(2); 15298 r = indexOfArrayO(self, value); 15299 ck_assert_int_eq(r, -1); 15300 // not indexOf 15301 emptyO(self); 15302 r = indexOfArrayO(self, value); 15303 ck_assert_int_eq(r, -1); 15304 // NULL value 15305 r = indexOfArrayO(self, NULL); 15306 ck_assert_int_eq(r, -1); 15307 terminateO(self); 15308 terminateO(value); 15309 15310 END_TEST 15311 15312 15313 START_TEST(indexOfArraycSmallArrayT) 15314 15315 ssize_t r; 15316 smallArrayt *self = allocG(rtSmallArrayt); 15317 char **value = listCreateS("a","bb"); 15318 15319 // indexOf 15320 char **elem = listCreateS("!!","@@@"); 15321 self->f->pushNFreeArrayc(self, elem); 15322 self->f->pushUndefined(self); 15323 delElemO(self, 1); 15324 self->f->pushNFreeArrayc(self, listCreateS("a","bb")); 15325 r = indexOfArraycO(self, value); 15326 ck_assert_int_eq(r, 2); 15327 // not indexOf 15328 delElemO(self, 2); 15329 r = indexOfArraycO(self, value); 15330 ck_assert_int_eq(r, -1); 15331 // NULL value 15332 r = indexOfArraycO(self, NULL); 15333 ck_assert_int_eq(r, -1); 15334 terminateO(self); 15335 listFreeS(value); 15336 15337 END_TEST 15338 15339 15340 START_TEST(indexOfSmallBoolSmallArrayT) 15341 15342 ssize_t r; 15343 smallArrayt *self = allocG(rtSmallArrayt); 15344 smallBoolt *value = allocSmallBool(true); 15345 15346 // indexOf 15347 self->f->pushUndefined(self); 15348 self->f->pushUndefined(self); 15349 delElemO(self, 1); 15350 self->f->pushBool(self, true); 15351 r = indexOfSmallBoolO(self, value); 15352 ck_assert_int_eq(r, 2); 15353 // not indexOf 15354 delElemO(self, 2); 15355 r = indexOfSmallBoolO(self, value); 15356 ck_assert_int_eq(r, -1); 15357 // non smallBool object 15358 terminateO(value); 15359 value = (smallBoolt*) allocSmallInt(2); 15360 r = indexOfSmallBoolO(self, value); 15361 ck_assert_int_eq(r, -1); 15362 // NULL value 15363 r = indexOfSmallBoolO(self, NULL); 15364 ck_assert_int_eq(r, -1); 15365 terminateO(self); 15366 terminateO(value); 15367 15368 END_TEST 15369 15370 15371 START_TEST(indexOfSmallBytesSmallArrayT) 15372 15373 ssize_t r; 15374 smallArrayt *self = allocG(rtSmallArrayt); 15375 createAllocateSmallBytes(value); 15376 pushBufferO(value, &self, 8); 15377 15378 // indexOf 15379 self->f->pushUndefined(self); 15380 self->f->pushUndefined(self); 15381 delElemO(self, 1); 15382 createAllocateSmallBytes(elem); 15383 pushBufferO(elem, &self, 8); 15384 self->f->pushNFreeSmallBytes(self, elem); 15385 r = indexOfSmallBytesO(self, value); 15386 ck_assert_int_eq(r, 2); 15387 // not indexOf 15388 delElemO(self, 2); 15389 r = indexOfSmallBytesO(self, value); 15390 ck_assert_int_eq(r, -1); 15391 // non smallBytes object 15392 terminateO(value); 15393 value = (smallBytest*) allocSmallInt(2); 15394 r = indexOfSmallBytesO(self, value); 15395 ck_assert_int_eq(r, -1); 15396 // NULL value 15397 r = indexOfSmallBytesO(self, NULL); 15398 ck_assert_int_eq(r, -1); 15399 terminateO(self); 15400 terminateO(value); 15401 15402 END_TEST 15403 15404 15405 START_TEST(indexOfSmallDoubleSmallArrayT) 15406 15407 ssize_t r; 15408 smallArrayt *self = allocG(rtSmallArrayt); 15409 smallDoublet *value = allocSmallDouble(2); 15410 15411 // indexOf 15412 self->f->pushUndefined(self); 15413 self->f->pushUndefined(self); 15414 delElemO(self, 1); 15415 self->f->pushDouble(self, 2); 15416 r = indexOfSmallDoubleO(self, value); 15417 ck_assert_int_eq(r, 2); 15418 // not indexOf 15419 delElemO(self, 2); 15420 r = indexOfSmallDoubleO(self, value); 15421 ck_assert_int_eq(r, -1); 15422 // non smallDouble object 15423 terminateO(value); 15424 value = (smallDoublet*) allocSmallInt(2); 15425 r = indexOfSmallDoubleO(self, value); 15426 ck_assert_int_eq(r, -1); 15427 // NULL value 15428 r = indexOfSmallDoubleO(self, NULL); 15429 ck_assert_int_eq(r, -1); 15430 terminateO(self); 15431 terminateO(value); 15432 15433 END_TEST 15434 15435 15436 START_TEST(indexOfSmallIntSmallArrayT) 15437 15438 ssize_t r; 15439 smallArrayt *self = allocG(rtSmallArrayt); 15440 smallIntt *value = allocSmallInt(12); 15441 15442 // indexOf 15443 self->f->pushUndefined(self); 15444 self->f->pushUndefined(self); 15445 delElemO(self, 1); 15446 self->f->pushInt(self, 12); 15447 r = indexOfSmallIntO(self, value); 15448 ck_assert_int_eq(r, 2); 15449 // not indexOf 15450 delElemO(self, 2); 15451 r = indexOfSmallIntO(self, value); 15452 ck_assert_int_eq(r, -1); 15453 // non smallInt object 15454 terminateO(value); 15455 value = (smallIntt*) allocSmallBool(true); 15456 r = indexOfSmallIntO(self, value); 15457 ck_assert_int_eq(r, -1); 15458 // NULL value 15459 r = indexOfSmallIntO(self, NULL); 15460 ck_assert_int_eq(r, -1); 15461 terminateO(self); 15462 terminateO(value); 15463 15464 END_TEST 15465 15466 15467 START_TEST(indexOfSmallJsonSmallArrayT) 15468 15469 ssize_t r; 15470 smallArrayt *self = allocG(rtSmallArrayt); 15471 smallJsont *value = allocSmallJson(); 15472 15473 // indexOf json undefined 15474 createUndefined(u); 15475 setTopO(value, (baset*)&u); 15476 self->f->pushUndefined(self); 15477 r = self->f->indexOfSmallJson(self, value); 15478 ck_assert_int_eq(r, 0); 15479 freeO(value); 15480 // indexOf json bool 15481 smallBoolt *b = allocSmallBool(true); 15482 setTopNFreeSmallBoolO(value, b); 15483 self->f->pushBool(self, true); 15484 r = self->f->indexOfSmallJson(self, value); 15485 ck_assert_int_eq(r, 1); 15486 freeO(value); 15487 // indexOf json double 15488 smallDoublet *d = allocSmallDouble(1); 15489 setTopNFreeSmallDoubleO(value, d); 15490 self->f->pushDouble(self, 1); 15491 r = self->f->indexOfSmallJson(self, value); 15492 ck_assert_int_eq(r, 2); 15493 freeO(value); 15494 // indexOf json int 15495 smallIntt *i = allocSmallInt(1); 15496 setTopNFreeSmallIntO(value, i); 15497 self->f->pushInt(self, 1); 15498 r = self->f->indexOfSmallJson(self, value); 15499 ck_assert_int_eq(r, 3); 15500 freeO(value); 15501 // indexOf json string 15502 smallStringt *s = allocSmallString("asd"); 15503 setTopNFreeSmallStringO(value, s); 15504 self->f->pushS(self, "asd"); 15505 r = self->f->indexOfSmallJson(self, value); 15506 ck_assert_int_eq(r, 4); 15507 freeO(value); 15508 // indexOf json dict 15509 smallDictt *D = allocSmallDict(); 15510 setTopNFreeDictO(value, D); 15511 self->f->pushNFreeDict(self, allocSmallDict()); 15512 r = self->f->indexOfSmallJson(self, value); 15513 ck_assert_int_eq(r, 5); 15514 freeO(value); 15515 // indexOf json array 15516 value->f->pushInt(value, 1); 15517 delElemO(self, 1); 15518 createAllocateSmallJson(elem); 15519 elem->f->pushInt(elem, 1); 15520 self->f->pushNFreeSmallJson(self, elem); 15521 r = self->f->indexOfSmallJson(self, value); 15522 ck_assert_int_eq(r, 6); 15523 // not indexOf 15524 delElemO(self, 6); 15525 r = self->f->indexOfSmallJson(self, value); 15526 ck_assert_int_eq(r, -1); 15527 // empty json object 15528 freeO(value); 15529 r = self->f->indexOfSmallJson(self, value); 15530 ck_assert_int_eq(r, -1); 15531 // non smallJson object 15532 terminateO(value); 15533 value = (smallJsont*) allocSmallInt(2); 15534 r = self->f->indexOfSmallJson(self, value); 15535 ck_assert_int_eq(r, -1); 15536 // NULL value 15537 r = self->f->indexOfSmallJson(self, NULL); 15538 ck_assert_int_eq(r, -1); 15539 terminateO(self); 15540 terminateO(value); 15541 15542 END_TEST 15543 15544 15545 START_TEST(indexOfSmallStringSmallArrayT) 15546 15547 ssize_t r; 15548 smallArrayt *self = allocG(rtSmallArrayt); 15549 smallStringt *value = allocSmallString("qwe"); 15550 15551 // indexOf 15552 self->f->pushUndefined(self); 15553 self->f->pushUndefined(self); 15554 delElemO(self, 1); 15555 self->f->pushS(self, "qwe"); 15556 r = self->f->indexOfSmallString(self, value); 15557 ck_assert_int_eq(r, 2); 15558 // not indexOf 15559 delElemO(self, 2); 15560 r = self->f->indexOfSmallString(self, value); 15561 ck_assert_int_eq(r, -1); 15562 // non smallString object 15563 terminateO(value); 15564 value = (smallStringt*) allocSmallInt(2); 15565 r = self->f->indexOfSmallString(self, value); 15566 ck_assert_int_eq(r, -1); 15567 // NULL value 15568 r = self->f->indexOfSmallString(self, NULL); 15569 ck_assert_int_eq(r, -1); 15570 terminateO(self); 15571 terminateO(value); 15572 15573 END_TEST 15574 15575 15576 START_TEST(indexOfSmallContainerSmallArrayT) 15577 15578 ssize_t r; 15579 smallArrayt *self = allocG(rtSmallArrayt); 15580 createAllocateSmallContainer(value); 15581 15582 // indexOf 15583 self->f->pushUndefined(self); 15584 self->f->pushUndefined(self); 15585 delElemO(self, 1); 15586 createAllocateSmallContainer(elem); 15587 self->f->pushNFreeSmallContainer(self, elem); 15588 r = self->f->indexOfSmallContainer(self, value); 15589 ck_assert_int_eq(r, -1); 15590 // not indexOf 15591 delElemO(self, 2); 15592 r = self->f->indexOfSmallContainer(self, value); 15593 ck_assert_int_eq(r, -1); 15594 // non smallContainer object 15595 terminateO(value); 15596 value = (smallContainert*) allocSmallInt(2); 15597 r = self->f->indexOfSmallContainer(self, value); 15598 ck_assert_int_eq(r, -1); 15599 // NULL value 15600 r = self->f->indexOfSmallContainer(self, NULL); 15601 ck_assert_int_eq(r, -1); 15602 terminateO(self); 15603 terminateO(value); 15604 15605 END_TEST 15606 15607 15608 START_TEST(binarySearchSmallArrayT) 15609 15610 ssize_t r; 15611 smallArrayt *self = allocG(rtSmallArrayt); 15612 baset *value = (baset*)allocSmallString("4"); 15613 15614 // index not trimmed (an element is NULL) 15615 self->f->pushS(self, "0"); 15616 self->f->pushS(self, "1"); 15617 self->f->pushS(self, "2"); 15618 delElemO(self, 2); 15619 self->f->pushS(self, "3"); 15620 self->f->pushS(self, "4"); 15621 self->f->pushS(self, "5"); 15622 r = binarySearchO(self, value); 15623 ck_assert_int_eq(r, -1); 15624 // index 15625 trimO(self); 15626 r = binarySearchO(self, value); 15627 ck_assert_int_eq(r, 3); 15628 smallStringt *v = (smallStringt*) value; 15629 // index in the lower half of the array 15630 setValO(v, "1"); 15631 r = binarySearchO(self, value); 15632 ck_assert_int_eq(r, 1); 15633 // not index 15634 setValO(v, "asd"); 15635 r = binarySearchO(self, value); 15636 ck_assert_int_eq(r, -1); 15637 // NULL value 15638 r = binarySearchO(self, NULL); 15639 ck_assert_int_eq(r, -1); 15640 // empty array 15641 emptyO(self); 15642 r = binarySearchO(self, value); 15643 ck_assert_int_eq(r, -1); 15644 terminateO(self); 15645 terminateO(value); 15646 15647 END_TEST 15648 15649 15650 START_TEST(binarySearchUndefinedSmallArrayT) 15651 15652 ssize_t r; 15653 smallArrayt *self = allocG(rtSmallArrayt); 15654 undefinedt *undefined = (undefinedt*) 1234; 15655 15656 r = binarySearchUndefinedO(self, undefined); 15657 ck_assert_int_eq(r, -1); 15658 terminateO(self); 15659 15660 END_TEST 15661 15662 15663 START_TEST(binarySearchBoolSmallArrayT) 15664 15665 ssize_t r; 15666 smallArrayt *self = allocG(rtSmallArrayt); 15667 bool value = true; 15668 15669 // index not trimmed (an element is NULL) 15670 self->f->pushUndefined(self); 15671 self->f->pushBool(self, false); 15672 self->f->pushUndefined(self); 15673 delElemO(self, 2); 15674 self->f->pushBool(self, true); 15675 self->f->pushS(self, "4"); 15676 self->f->pushS(self, "5"); 15677 r = binarySearchBoolO(self, value); 15678 ck_assert_int_eq(r, -1); 15679 // index 15680 trimO(self); 15681 r = binarySearchBoolO(self, value); 15682 ck_assert_int_eq(r, 2); 15683 // index in the lower half of the array 15684 value = false; 15685 r = binarySearchBoolO(self, value); 15686 ck_assert_int_eq(r, 1); 15687 // not index 15688 delElemO(self, 1); 15689 trimO(self); 15690 r = binarySearchBoolO(self, value); 15691 ck_assert_int_eq(r, -1); 15692 // empty array 15693 emptyO(self); 15694 r = binarySearchBoolO(self, value); 15695 ck_assert_int_eq(r, -1); 15696 terminateO(self); 15697 15698 END_TEST 15699 15700 15701 START_TEST(binarySearchDoubleSmallArrayT) 15702 15703 ssize_t r; 15704 smallArrayt *self = allocG(rtSmallArrayt); 15705 double value = 2; 15706 15707 // index not trimmed (an element is NULL) 15708 self->f->pushUndefined(self); 15709 self->f->pushDouble(self, 1); 15710 self->f->pushUndefined(self); 15711 delElemO(self, 2); 15712 self->f->pushDouble(self, 2); 15713 self->f->pushS(self, "4"); 15714 self->f->pushS(self, "5"); 15715 r = binarySearchDoubleO(self, value); 15716 ck_assert_int_eq(r, -1); 15717 // index 15718 trimO(self); 15719 r = binarySearchDoubleO(self, value); 15720 ck_assert_int_eq(r, 2); 15721 // index in the lower half of the array 15722 value = 1; 15723 r = binarySearchDoubleO(self, value); 15724 ck_assert_int_eq(r, 1); 15725 // not index 15726 delElemO(self, 1); 15727 trimO(self); 15728 r = binarySearchDoubleO(self, value); 15729 ck_assert_int_eq(r, -1); 15730 // empty array 15731 emptyO(self); 15732 r = binarySearchDoubleO(self, value); 15733 ck_assert_int_eq(r, -1); 15734 terminateO(self); 15735 15736 END_TEST 15737 15738 15739 START_TEST(binarySearchIntSmallArrayT) 15740 15741 ssize_t r; 15742 smallArrayt *self = allocG(rtSmallArrayt); 15743 int64_t value = 2; 15744 15745 // index not trimmed (an element is NULL) 15746 self->f->pushUndefined(self); 15747 self->f->pushInt(self, 1); 15748 self->f->pushUndefined(self); 15749 delElemO(self, 2); 15750 self->f->pushInt(self, 2); 15751 self->f->pushS(self, "4"); 15752 self->f->pushS(self, "5"); 15753 r = binarySearchIntO(self, value); 15754 ck_assert_int_eq(r, -1); 15755 // index 15756 trimO(self); 15757 r = binarySearchIntO(self, value); 15758 ck_assert_int_eq(r, 2); 15759 // index in the lower half of the array 15760 value = 1; 15761 r = binarySearchIntO(self, value); 15762 ck_assert_int_eq(r, 1); 15763 // not index 15764 delElemO(self, 1); 15765 trimO(self); 15766 r = binarySearchIntO(self, value); 15767 ck_assert_int_eq(r, -1); 15768 // empty array 15769 emptyO(self); 15770 r = binarySearchIntO(self, value); 15771 ck_assert_int_eq(r, -1); 15772 terminateO(self); 15773 15774 END_TEST 15775 15776 15777 START_TEST(binarySearchSSmallArrayT) 15778 15779 ssize_t r; 15780 smallArrayt *self = allocG(rtSmallArrayt); 15781 const char *value = "4"; 15782 15783 // index not trimmed (an element is NULL) 15784 self->f->pushS(self, "0"); 15785 self->f->pushS(self, "1"); 15786 self->f->pushS(self, "2"); 15787 delElemO(self, 2); 15788 self->f->pushS(self, "3"); 15789 self->f->pushS(self, "4"); 15790 self->f->pushS(self, "5"); 15791 r = binarySearchSO(self, value); 15792 ck_assert_int_eq(r, -1); 15793 // index 15794 trimO(self); 15795 r = binarySearchSO(self, value); 15796 ck_assert_int_eq(r, 3); 15797 // index in the lower half of the array 15798 value = "1"; 15799 r = binarySearchSO(self, value); 15800 ck_assert_int_eq(r, 1); 15801 // not index 15802 value = "asd"; 15803 r = binarySearchSO(self, value); 15804 ck_assert_int_eq(r, -1); 15805 // NULL value 15806 r = binarySearchSO(self, NULL); 15807 ck_assert_int_eq(r, -1); 15808 // empty array 15809 emptyO(self); 15810 r = binarySearchSO(self, value); 15811 ck_assert_int_eq(r, -1); 15812 terminateO(self); 15813 15814 END_TEST 15815 15816 15817 START_TEST(binarySearchCharSmallArrayT) 15818 15819 ssize_t r; 15820 smallArrayt *self = allocG(rtSmallArrayt); 15821 char value = '4'; 15822 15823 // index not trimmed (an element is NULL) 15824 self->f->pushS(self, "0"); 15825 self->f->pushS(self, "1"); 15826 self->f->pushS(self, "2"); 15827 delElemO(self, 2); 15828 self->f->pushS(self, "3"); 15829 self->f->pushS(self, "4"); 15830 self->f->pushS(self, "5"); 15831 r = binarySearchCharO(self, value); 15832 ck_assert_int_eq(r, -1); 15833 // index 15834 trimO(self); 15835 r = binarySearchCharO(self, value); 15836 ck_assert_int_eq(r, 3); 15837 // index in the lower half of the array 15838 value = '1'; 15839 r = binarySearchCharO(self, value); 15840 ck_assert_int_eq(r, 1); 15841 // not index 15842 value = 'a'; 15843 r = binarySearchCharO(self, value); 15844 ck_assert_int_eq(r, -1); 15845 // empty array 15846 emptyO(self); 15847 r = binarySearchCharO(self, value); 15848 ck_assert_int_eq(r, -1); 15849 terminateO(self); 15850 15851 END_TEST 15852 15853 15854 START_TEST(binarySearchDictSmallArrayT) 15855 15856 ssize_t r; 15857 smallArrayt *self = allocG(rtSmallArrayt); 15858 smallDictt *value = allocSmallDict(); 15859 value->f->setInt(value, "b", 2); 15860 15861 // index not trimmed (an element is NULL) 15862 createAllocateSmallDict(elem); 15863 elem->f->setInt(elem, "a", 1); 15864 self->f->pushUndefined(self); 15865 self->f->pushDict(self, elem); 15866 resetO(elem); 15867 self->f->pushUndefined(self); 15868 delElemO(self, 2); 15869 elem->f->setInt(elem, "b", 2); 15870 self->f->pushNFreeDict(self, elem); 15871 self->f->pushS(self, "4"); 15872 self->f->pushS(self, "5"); 15873 r = binarySearchDictO(self, value); 15874 ck_assert_int_eq(r, -1); 15875 // index 15876 trimO(self); 15877 r = binarySearchDictO(self, value); 15878 ck_assert_int_eq(r, 2); 15879 // index in the lower half of the array 15880 freeO(value); 15881 value->f->setInt(value, "a", 1); 15882 r = binarySearchDictO(self, value); 15883 ck_assert_int_eq(r, 1); 15884 // not index 15885 freeO(value); 15886 r = binarySearchDictO(self, value); 15887 ck_assert_int_eq(r, -1); 15888 // non smallDict object 15889 terminateO(value); 15890 value = (smallDictt*) allocSmallInt(2); 15891 r = binarySearchDictO(self, value); 15892 ck_assert_int_eq(r, -1); 15893 // NULL value 15894 r = binarySearchDictO(self, NULL); 15895 ck_assert_int_eq(r, -1); 15896 // empty array 15897 emptyO(self); 15898 r = binarySearchDictO(self, value); 15899 ck_assert_int_eq(r, -1); 15900 terminateO(self); 15901 terminateO(value); 15902 15903 END_TEST 15904 15905 15906 START_TEST(binarySearchArraySmallArrayT) 15907 15908 ssize_t r; 15909 smallArrayt *self = allocG(rtSmallArrayt); 15910 smallArrayt *value = allocSmallArray(); 15911 value->f->pushInt(value, 2); 15912 15913 // index not trimmed (an element is NULL) 15914 createAllocateSmallArray(elem); 15915 elem->f->pushInt(elem, 1); 15916 self->f->pushUndefined(self); 15917 self->f->pushArray(self, elem); 15918 resetO(elem); 15919 self->f->pushUndefined(self); 15920 delElemO(self, 2); 15921 elem->f->pushInt(elem, 2); 15922 self->f->pushNFreeArray(self, elem); 15923 self->f->pushS(self, "4"); 15924 self->f->pushS(self, "5"); 15925 r = binarySearchArrayO(self, value); 15926 ck_assert_int_eq(r, -1); 15927 // index 15928 trimO(self); 15929 r = binarySearchArrayO(self, value); 15930 ck_assert_int_eq(r, 2); 15931 // index in the lower half of the array 15932 freeO(value); 15933 value->f->pushInt(value, 1); 15934 r = binarySearchArrayO(self, value); 15935 ck_assert_int_eq(r, 1); 15936 // not index 15937 freeO(value); 15938 r = binarySearchArrayO(self, value); 15939 ck_assert_int_eq(r, -1); 15940 // non smallArray object 15941 terminateO(value); 15942 value = (smallArrayt*) allocSmallInt(2); 15943 r = binarySearchArrayO(self, value); 15944 ck_assert_int_eq(r, -1); 15945 // NULL value 15946 r = binarySearchArrayO(self, NULL); 15947 ck_assert_int_eq(r, -1); 15948 // empty array 15949 emptyO(self); 15950 r = binarySearchArrayO(self, value); 15951 ck_assert_int_eq(r, -1); 15952 terminateO(self); 15953 terminateO(value); 15954 15955 END_TEST 15956 15957 15958 START_TEST(binarySearchArraycSmallArrayT) 15959 15960 ssize_t r; 15961 smallArrayt *self = allocG(rtSmallArrayt); 15962 char **value = listCreateS("b"); 15963 15964 // index not trimmed (an element is NULL) 15965 char **elem = listCreateS("a"); 15966 self->f->pushUndefined(self); 15967 self->f->pushNFreeArrayc(self, elem); 15968 self->f->pushUndefined(self); 15969 delElemO(self, 2); 15970 elem = listCreateS("b"); 15971 self->f->pushNFreeArrayc(self, elem); 15972 self->f->pushS(self, "4"); 15973 self->f->pushS(self, "5"); 15974 r = binarySearchArraycO(self, value); 15975 ck_assert_int_eq(r, -1); 15976 // index 15977 trimO(self); 15978 r = binarySearchArraycO(self, value); 15979 ck_assert_int_eq(r, 2); 15980 // index in the lower half of the array 15981 free(value[0]); 15982 value[0] = strdup("a"); 15983 r = binarySearchArraycO(self, value); 15984 ck_assert_int_eq(r, 1); 15985 // not index 15986 free(value[0]); 15987 value[0] = strdup("asd"); 15988 r = binarySearchArraycO(self, value); 15989 ck_assert_int_eq(r, -1); 15990 // NULL value 15991 r = binarySearchArraycO(self, NULL); 15992 ck_assert_int_eq(r, -1); 15993 // empty array 15994 emptyO(self); 15995 r = binarySearchArraycO(self, value); 15996 ck_assert_int_eq(r, -1); 15997 terminateO(self); 15998 listFreeS(value); 15999 16000 END_TEST 16001 16002 16003 START_TEST(binarySearchSmallBoolSmallArrayT) 16004 16005 ssize_t r; 16006 smallArrayt *self = allocG(rtSmallArrayt); 16007 smallBoolt *value = allocSmallBool(true); 16008 16009 // index not trimmed (an element is NULL) 16010 self->f->pushUndefined(self); 16011 self->f->pushBool(self, false); 16012 self->f->pushUndefined(self); 16013 delElemO(self, 2); 16014 self->f->pushBool(self, true); 16015 self->f->pushS(self, "4"); 16016 self->f->pushS(self, "5"); 16017 r = binarySearchSmallBoolO(self, value); 16018 ck_assert_int_eq(r, -1); 16019 // index 16020 trimO(self); 16021 r = binarySearchSmallBoolO(self, value); 16022 ck_assert_int_eq(r, 2); 16023 // index in the lower half of the array 16024 setValO(value, false); 16025 r = binarySearchSmallBoolO(self, value); 16026 ck_assert_int_eq(r, 1); 16027 // not index 16028 delElemO(self, 1); 16029 trimO(self); 16030 r = binarySearchSmallBoolO(self, value); 16031 ck_assert_int_eq(r, -1); 16032 // non smallBool object 16033 terminateO(value); 16034 value = (smallBoolt*) allocSmallInt(2); 16035 r = binarySearchSmallBoolO(self, value); 16036 ck_assert_int_eq(r, -1); 16037 // NULL value 16038 r = binarySearchArraycO(self, NULL); 16039 ck_assert_int_eq(r, -1); 16040 // empty array 16041 emptyO(self); 16042 r = binarySearchSmallBoolO(self, value); 16043 ck_assert_int_eq(r, -1); 16044 terminateO(self); 16045 terminateO(value); 16046 16047 END_TEST 16048 16049 16050 START_TEST(binarySearchSmallBytesSmallArrayT) 16051 16052 ssize_t r; 16053 smallArrayt *self = allocG(rtSmallArrayt); 16054 createAllocateSmallBytes(value); 16055 pushBufferO(value, "bbc", 4); 16056 16057 // index not trimmed (an element is NULL) 16058 createAllocateSmallBytes(elem); 16059 pushBufferO(elem, "abc", 4); 16060 self->f->pushUndefined(self); 16061 self->f->pushNFreeSmallBytes(self, elem); 16062 self->f->pushUndefined(self); 16063 delElemO(self, 2); 16064 elem = allocSmallBytes("bbc", 4); 16065 self->f->pushNFreeSmallBytes(self, elem); 16066 self->f->pushS(self, "4"); 16067 self->f->pushS(self, "5"); 16068 r = binarySearchSmallBytesO(self, value); 16069 ck_assert_int_eq(r, -1); 16070 // index 16071 trimO(self); 16072 r = binarySearchSmallBytesO(self, value); 16073 ck_assert_int_eq(r, 2); 16074 // index in the lower half of the array 16075 freeO(value); 16076 pushBufferO(value, "abc", 4); 16077 r = binarySearchSmallBytesO(self, value); 16078 ck_assert_int_eq(r, 1); 16079 // not index 16080 freeO(value); 16081 pushBufferO(value, "###", 4); 16082 r = binarySearchSmallBytesO(self, value); 16083 ck_assert_int_eq(r, -1); 16084 // non smallBytes object 16085 terminateO(value); 16086 value = (smallBytest*) allocSmallInt(2); 16087 r = binarySearchSmallBytesO(self, value); 16088 ck_assert_int_eq(r, -1); 16089 // NULL value 16090 r = binarySearchSmallBytesO(self, NULL); 16091 ck_assert_int_eq(r, -1); 16092 // empty array 16093 emptyO(self); 16094 r = binarySearchSmallBytesO(self, value); 16095 ck_assert_int_eq(r, -1); 16096 terminateO(self); 16097 terminateO(value); 16098 16099 END_TEST 16100 16101 16102 START_TEST(binarySearchSmallDoubleSmallArrayT) 16103 16104 ssize_t r; 16105 smallArrayt *self = allocG(rtSmallArrayt); 16106 smallDoublet *value = allocSmallDouble(2); 16107 16108 // index not trimmed (an element is NULL) 16109 self->f->pushUndefined(self); 16110 self->f->pushDouble(self, 1); 16111 self->f->pushUndefined(self); 16112 delElemO(self, 2); 16113 self->f->pushDouble(self, 2); 16114 self->f->pushS(self, "4"); 16115 self->f->pushS(self, "5"); 16116 r = binarySearchSmallDoubleO(self, value); 16117 ck_assert_int_eq(r, -1); 16118 // index 16119 trimO(self); 16120 r = binarySearchSmallDoubleO(self, value); 16121 ck_assert_int_eq(r, 2); 16122 // index in the lower half of the array 16123 setValO(value, 1); 16124 r = binarySearchSmallDoubleO(self, value); 16125 ck_assert_int_eq(r, 1); 16126 // not index 16127 delElemO(self, 1); 16128 trimO(self); 16129 r = binarySearchSmallDoubleO(self, value); 16130 ck_assert_int_eq(r, -1); 16131 // non smallDouble object 16132 terminateO(value); 16133 value = (smallDoublet*) allocSmallInt(2); 16134 r = binarySearchSmallDoubleO(self, value); 16135 ck_assert_int_eq(r, -1); 16136 // NULL value 16137 r = binarySearchArraycO(self, NULL); 16138 ck_assert_int_eq(r, -1); 16139 // empty array 16140 emptyO(self); 16141 r = binarySearchSmallDoubleO(self, value); 16142 ck_assert_int_eq(r, -1); 16143 terminateO(self); 16144 terminateO(value); 16145 16146 END_TEST 16147 16148 16149 START_TEST(binarySearchSmallIntSmallArrayT) 16150 16151 ssize_t r; 16152 smallArrayt *self = allocG(rtSmallArrayt); 16153 smallIntt *value = allocSmallInt(2); 16154 16155 // index not trimmed (an element is NULL) 16156 self->f->pushUndefined(self); 16157 self->f->pushInt(self, 1); 16158 self->f->pushUndefined(self); 16159 delElemO(self, 2); 16160 self->f->pushInt(self, 2); 16161 self->f->pushS(self, "4"); 16162 self->f->pushS(self, "5"); 16163 r = binarySearchSmallIntO(self, value); 16164 ck_assert_int_eq(r, -1); 16165 // index 16166 trimO(self); 16167 r = binarySearchSmallIntO(self, value); 16168 ck_assert_int_eq(r, 2); 16169 // index in the lower half of the array 16170 setValO(value, 1); 16171 r = binarySearchSmallIntO(self, value); 16172 ck_assert_int_eq(r, 1); 16173 // not index 16174 delElemO(self, 1); 16175 trimO(self); 16176 r = binarySearchSmallIntO(self, value); 16177 ck_assert_int_eq(r, -1); 16178 // non smallInt object 16179 terminateO(value); 16180 value = (smallIntt*) allocSmallBool(true); 16181 r = binarySearchSmallIntO(self, value); 16182 ck_assert_int_eq(r, -1); 16183 // NULL value 16184 r = binarySearchArraycO(self, NULL); 16185 ck_assert_int_eq(r, -1); 16186 // empty array 16187 emptyO(self); 16188 r = binarySearchSmallIntO(self, value); 16189 ck_assert_int_eq(r, -1); 16190 terminateO(self); 16191 terminateO(value); 16192 16193 END_TEST 16194 16195 16196 START_TEST(binarySearchSmallJsonSmallArrayT) 16197 16198 ssize_t r; 16199 smallArrayt *self = allocG(rtSmallArrayt); 16200 smallJsont *value = allocSmallJson(); 16201 value->f->pushInt(value, 2); 16202 16203 // index not trimmed (an element is NULL) 16204 self->f->pushUndefined(self); 16205 createAllocateSmallArray(elem); 16206 elem->f->pushInt(elem, 1); 16207 self->f->pushArray(self, elem); 16208 resetO(elem); 16209 self->f->pushUndefined(self); 16210 delElemO(self, 2); 16211 elem->f->pushInt(elem, 2); 16212 self->f->pushNFreeArray(self, elem); 16213 self->f->pushS(self, "4"); 16214 self->f->pushS(self, "5"); 16215 r = self->f->binarySearchSmallJson(self, value); 16216 ck_assert_int_eq(r, -1); 16217 // index 16218 trimO(self); 16219 r = self->f->binarySearchSmallJson(self, value); 16220 ck_assert_int_eq(r, 2); 16221 // index in the lower half of the array 16222 freeO(value); 16223 value->f->pushInt(value, 1); 16224 r = self->f->binarySearchSmallJson(self, value); 16225 ck_assert_int_eq(r, 1); 16226 // not index (json array) 16227 delElemO(self, 1); 16228 trimO(self); 16229 r = self->f->binarySearchSmallJson(self, value); 16230 ck_assert_int_eq(r, -1); 16231 // not index json undefined 16232 createUndefined(u); 16233 freeO(value); 16234 setTopO(value, (baset*)&u); 16235 r = self->f->binarySearchSmallJson(self, value); 16236 ck_assert_int_eq(r, -1); 16237 // not index json bool 16238 createSmallBool(b); 16239 freeO(value); 16240 setTopO(value, (baset*)&b); 16241 r = self->f->binarySearchSmallJson(self, value); 16242 ck_assert_int_eq(r, -1); 16243 // not index json double 16244 createSmallDouble(d); 16245 freeO(value); 16246 setTopO(value, (baset*)&d); 16247 r = self->f->binarySearchSmallJson(self, value); 16248 ck_assert_int_eq(r, -1); 16249 // not index json int 16250 createSmallInt(i); 16251 freeO(value); 16252 setTopO(value, (baset*)&i); 16253 r = self->f->binarySearchSmallJson(self, value); 16254 ck_assert_int_eq(r, -1); 16255 // not index json string 16256 createSmallString(s); 16257 freeO(value); 16258 setTopO(value, (baset*)&s); 16259 r = self->f->binarySearchSmallJson(self, value); 16260 ck_assert_int_eq(r, -1); 16261 // not index json dict 16262 createSmallDict(D); 16263 freeO(value); 16264 setTopO(value, (baset*)&D); 16265 r = self->f->binarySearchSmallJson(self, value); 16266 ck_assert_int_eq(r, -1); 16267 // empty json object 16268 freeO(value); 16269 r = self->f->binarySearchSmallJson(self, value); 16270 ck_assert_int_eq(r, -1); 16271 // non smallJson object 16272 terminateO(value); 16273 value = (smallJsont*) allocSmallInt(2); 16274 r = self->f->binarySearchSmallJson(self, value); 16275 ck_assert_int_eq(r, -1); 16276 // NULL value 16277 r = self->f->binarySearchSmallJson(self, NULL); 16278 ck_assert_int_eq(r, -1); 16279 // empty array 16280 emptyO(self); 16281 r = self->f->binarySearchSmallJson(self, value); 16282 ck_assert_int_eq(r, -1); 16283 terminateO(self); 16284 terminateO(value); 16285 16286 END_TEST 16287 16288 16289 START_TEST(binarySearchSmallStringSmallArrayT) 16290 16291 ssize_t r; 16292 smallArrayt *self = allocG(rtSmallArrayt); 16293 smallStringt *value = allocSmallString("4"); 16294 16295 // index not trimmed (an element is NULL) 16296 self->f->pushS(self, "0"); 16297 self->f->pushS(self, "1"); 16298 self->f->pushS(self, "2"); 16299 delElemO(self, 2); 16300 self->f->pushS(self, "3"); 16301 self->f->pushS(self, "4"); 16302 self->f->pushS(self, "5"); 16303 r = binarySearchSmallStringO(self, value); 16304 ck_assert_int_eq(r, -1); 16305 // index 16306 trimO(self); 16307 r = binarySearchSmallStringO(self, value); 16308 ck_assert_int_eq(r, 3); 16309 // index in the lower half of the array 16310 setValO(value, "1"); 16311 r = binarySearchSmallStringO(self, value); 16312 ck_assert_int_eq(r, 1); 16313 // not index 16314 setValO(value, "asd"); 16315 r = binarySearchSmallStringO(self, value); 16316 ck_assert_int_eq(r, -1); 16317 // non smallString object 16318 terminateO(value); 16319 value = (smallStringt*) allocSmallInt(2); 16320 r = binarySearchSmallStringO(self, value); 16321 ck_assert_int_eq(r, -1); 16322 // NULL value 16323 r = binarySearchSmallStringO(self, NULL); 16324 ck_assert_int_eq(r, -1); 16325 // empty array 16326 emptyO(self); 16327 r = binarySearchSmallStringO(self, value); 16328 ck_assert_int_eq(r, -1); 16329 terminateO(self); 16330 terminateO(value); 16331 16332 END_TEST 16333 16334 16335 START_TEST(binarySearchSmallContainerSmallArrayT) 16336 16337 ssize_t r; 16338 smallArrayt *self = allocG(rtSmallArrayt); 16339 createAllocateSmallContainer(value); 16340 16341 r = self->f->binarySearchSmallContainer(self, value); 16342 ck_assert_int_eq(r, -1); 16343 terminateO(self); 16344 terminateO(value); 16345 16346 END_TEST 16347 16348 16349 START_TEST(uniqSmallArrayT) 16350 16351 smallArrayt* r; 16352 smallArrayt *self = allocG(rtSmallArrayt); 16353 16354 // empty array 16355 r = self->f->uniq(self); 16356 ck_assert_ptr_eq(r, NULL); 16357 // one element 16358 self->f->pushUndefined(self); 16359 r = self->f->uniq(self); 16360 ck_assert_ptr_eq(r, self); 16361 // uniq elements 16362 self->f->pushUndefined(self); 16363 self->f->pushBool(self, true); 16364 self->f->pushNFreeDict(self, allocSmallDict()); 16365 self->f->pushDouble(self, 1); 16366 self->f->pushInt(self, 2); 16367 self->f->pushS(self, ""); 16368 self->f->pushNFreeArray(self, allocSmallArray()); 16369 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 16370 self->f->pushUndefined(self); 16371 self->f->pushBool(self, true); 16372 self->f->pushNFreeDict(self, allocSmallDict()); 16373 self->f->pushDouble(self, 1); 16374 self->f->pushInt(self, 2); 16375 self->f->pushS(self, ""); 16376 self->f->pushNFreeArray(self, allocSmallArray()); 16377 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 16378 r = self->f->uniq(self); 16379 ck_assert_ptr_ne(r, NULL); 16380 char *s = toStringO(r); 16381 ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"\",[],[0x71,0x77,0x65,0x00]]"); 16382 free(s); 16383 terminateO(self); 16384 16385 END_TEST 16386 16387 16388 START_TEST(icHasSmallArrayT) 16389 16390 bool r; 16391 smallArrayt *self = allocG(rtSmallArrayt); 16392 baset *value = (baset*)allocSmallString("a"); 16393 16394 // has 16395 self->f->pushS(self, "A"); 16396 r = icHasO(self, value); 16397 ck_assert(r); 16398 // not has 16399 emptyO(self); 16400 r = icHasO(self, value); 16401 ck_assert(!r); 16402 // NULL value 16403 r = icHasO(self, NULL); 16404 ck_assert(!r); 16405 terminateO(self); 16406 terminateO(value); 16407 16408 END_TEST 16409 16410 16411 START_TEST(icHasSSmallArrayT) 16412 16413 bool r; 16414 smallArrayt *self = allocG(rtSmallArrayt); 16415 const char *value = "ASD"; 16416 16417 // has 16418 self->f->pushS(self, "asd"); 16419 r = icHasSO(self, value); 16420 ck_assert(r); 16421 // not has 16422 emptyO(self); 16423 r = icHasSO(self, value); 16424 ck_assert(!r); 16425 // NULL value 16426 r = icHasSO(self, NULL); 16427 ck_assert(!r); 16428 terminateO(self); 16429 16430 END_TEST 16431 16432 16433 START_TEST(icHasCharSmallArrayT) 16434 16435 bool r; 16436 smallArrayt *self = allocG(rtSmallArrayt); 16437 char value = 'A'; 16438 16439 // has 16440 self->f->pushS(self, "a"); 16441 r = icHasCharO(self, value); 16442 ck_assert(r); 16443 // not has 16444 emptyO(self); 16445 r = icHasCharO(self, value); 16446 ck_assert(!r); 16447 terminateO(self); 16448 16449 END_TEST 16450 16451 16452 START_TEST(icHasDictSmallArrayT) 16453 16454 bool r; 16455 smallArrayt *self = allocG(rtSmallArrayt); 16456 smallDictt *value = allocSmallDict(); 16457 value->f->setInt(value, "A", 1); 16458 16459 // has 16460 createAllocateSmallDict(d); 16461 d->f->setInt(d, "a", 1); 16462 self->f->pushNFreeDict(self, d); 16463 r = icHasDictO(self, value); 16464 ck_assert(r); 16465 // not has 16466 emptyO(self); 16467 r = icHasDictO(self, value); 16468 ck_assert(!r); 16469 // NULL value 16470 r = icHasDictO(self, NULL); 16471 ck_assert(!r); 16472 terminateO(self); 16473 terminateO(value); 16474 16475 END_TEST 16476 16477 16478 START_TEST(icHasArraySmallArrayT) 16479 16480 bool r; 16481 smallArrayt *self = allocG(rtSmallArrayt); 16482 smallArrayt *value = allocSmallArray(); 16483 value->f->pushS(value, "A"); 16484 16485 // has 16486 createAllocateSmallArray(a); 16487 a->f->pushS(a, "a"); 16488 self->f->pushNFreeArray(self, a); 16489 r = icHasArrayO(self, value); 16490 ck_assert(r); 16491 // not has 16492 emptyO(self); 16493 r = icHasArrayO(self, value); 16494 ck_assert(!r); 16495 // NULL value 16496 r = icHasArrayO(self, NULL); 16497 ck_assert(!r); 16498 terminateO(self); 16499 terminateO(value); 16500 16501 END_TEST 16502 16503 16504 START_TEST(icHasArraycSmallArrayT) 16505 16506 bool r; 16507 smallArrayt *self = allocG(rtSmallArrayt); 16508 char **value = listCreateS("A","BB"); 16509 16510 // has 16511 self->f->pushNFreeArrayc(self, listCreateS("a","bb")); 16512 r = icHasArraycO(self, value); 16513 ck_assert(r); 16514 // not has 16515 emptyO(self); 16516 r = icHasArraycO(self, value); 16517 ck_assert(!r); 16518 // NULL value 16519 r = icHasArraycO(self, NULL); 16520 ck_assert(!r); 16521 terminateO(self); 16522 listFreeS(value); 16523 16524 END_TEST 16525 16526 16527 START_TEST(icHasSmallJsonSmallArrayT) 16528 16529 bool r; 16530 smallArrayt *self = allocG(rtSmallArrayt); 16531 smallJsont *value = allocSmallJson(); 16532 value->f->pushS(value, "A"); 16533 16534 // has 16535 createAllocateSmallJson(elem); 16536 elem->f->pushS(elem, "a"); 16537 self->f->pushNFreeSmallJson(self, elem); 16538 r = self->f->icHasSmallJson(self, value); 16539 ck_assert(r); 16540 // not has 16541 emptyO(self); 16542 r = self->f->icHasSmallJson(self, value); 16543 ck_assert(!r); 16544 // NULL value 16545 r = self->f->icHasSmallJson(self, NULL); 16546 ck_assert(!r); 16547 terminateO(self); 16548 terminateO(value); 16549 16550 END_TEST 16551 16552 16553 START_TEST(icHasSmallStringSmallArrayT) 16554 16555 bool r; 16556 smallArrayt *self = allocG(rtSmallArrayt); 16557 smallStringt *value = allocSmallString("QWE"); 16558 16559 // has 16560 self->f->pushS(self, "qwe"); 16561 r = self->f->icHasSmallString(self, value); 16562 ck_assert(r); 16563 // not has 16564 emptyO(self); 16565 r = self->f->icHasSmallString(self, value); 16566 ck_assert(!r); 16567 // NULL value 16568 r = self->f->icHasSmallString(self, NULL); 16569 ck_assert(!r); 16570 terminateO(self); 16571 terminateO(value); 16572 16573 END_TEST 16574 16575 16576 START_TEST(icIndexOfSmallArrayT) 16577 16578 ssize_t r; 16579 smallArrayt *self = allocG(rtSmallArrayt); 16580 baset *value = (baset*)allocSmallString("A"); 16581 16582 // index 16583 self->f->pushS(self, "2"); 16584 self->f->pushS(self, "3"); 16585 delElemO(self, 1); 16586 self->f->pushS(self, "a"); 16587 r = icIndexOfO(self, value); 16588 ck_assert_int_eq(r, 2); 16589 // not index 16590 smallStringt *v = (smallStringt*) value; 16591 setValO(v, "3"); 16592 r = icIndexOfO(self, value); 16593 ck_assert_int_eq(r, -1); 16594 // NULL value 16595 r = icIndexOfO(self, NULL); 16596 ck_assert_int_eq(r, -1); 16597 terminateO(self); 16598 terminateO(value); 16599 16600 END_TEST 16601 16602 16603 START_TEST(icIndexOfSSmallArrayT) 16604 16605 ssize_t r; 16606 smallArrayt *self = allocG(rtSmallArrayt); 16607 const char *value = "ASD"; 16608 16609 // indexOf 16610 self->f->pushUndefined(self); 16611 self->f->pushUndefined(self); 16612 delElemO(self, 1); 16613 self->f->pushS(self, "asd"); 16614 r = icIndexOfSO(self, value); 16615 ck_assert_int_eq(r, 2); 16616 // not indexOf 16617 delElemO(self, 2); 16618 r = icIndexOfSO(self, value); 16619 ck_assert_int_eq(r, -1); 16620 // NULL value 16621 r = icIndexOfSO(self, NULL); 16622 ck_assert_int_eq(r, -1); 16623 terminateO(self); 16624 16625 END_TEST 16626 16627 16628 START_TEST(icIndexOfCharSmallArrayT) 16629 16630 ssize_t r; 16631 smallArrayt *self = allocG(rtSmallArrayt); 16632 char value = 'A'; 16633 16634 // indexOf 16635 self->f->pushUndefined(self); 16636 self->f->pushUndefined(self); 16637 delElemO(self, 1); 16638 self->f->pushS(self, "a"); 16639 r = icIndexOfCharO(self, value); 16640 ck_assert_int_eq(r, 2); 16641 // not indexOf 16642 delElemO(self, 2); 16643 r = icIndexOfCharO(self, value); 16644 ck_assert_int_eq(r, -1); 16645 terminateO(self); 16646 16647 END_TEST 16648 16649 16650 START_TEST(icIndexOfDictSmallArrayT) 16651 16652 ssize_t r; 16653 smallArrayt *self = allocG(rtSmallArrayt); 16654 smallDictt *value = allocSmallDict(); 16655 value->f->setInt(value, "B", 1); 16656 16657 // indexOf 16658 createAllocateSmallDict(elem); 16659 elem->f->setInt(elem, "a", 1); 16660 self->f->pushDict(self, elem); 16661 resetO(elem); 16662 self->f->pushUndefined(self); 16663 delElemO(self, 1); 16664 elem->f->setInt(elem, "b", 1); 16665 self->f->pushNFreeDict(self, elem); 16666 r = icIndexOfDictO(self, value); 16667 ck_assert_int_eq(r, 2); 16668 // not indexOf 16669 delElemO(self, 2); 16670 r = icIndexOfDictO(self, value); 16671 ck_assert_int_eq(r, -1); 16672 // non smallDict object 16673 terminateO(value); 16674 value = (smallDictt*) allocSmallInt(2); 16675 r = icIndexOfDictO(self, value); 16676 ck_assert_int_eq(r, -1); 16677 // NULL value 16678 r = icIndexOfDictO(self, NULL); 16679 ck_assert_int_eq(r, -1); 16680 terminateO(self); 16681 terminateO(value); 16682 16683 END_TEST 16684 16685 16686 START_TEST(icIndexOfArraySmallArrayT) 16687 16688 ssize_t r; 16689 smallArrayt *self = allocG(rtSmallArrayt); 16690 smallArrayt *value = allocSmallArray(); 16691 value->f->pushS(value, "A"); 16692 16693 // indexOf 16694 createAllocateSmallArray(elem); 16695 elem->f->pushInt(elem, 1); 16696 self->f->pushArray(self, elem); 16697 resetO(elem); 16698 self->f->pushUndefined(self); 16699 delElemO(self, 1); 16700 elem->f->pushS(elem, "a"); 16701 self->f->pushNFreeArray(self, elem); 16702 r = icIndexOfArrayO(self, value); 16703 ck_assert_int_eq(r, 2); 16704 // non smallArray object 16705 terminateO(value); 16706 value = (smallArrayt*) allocSmallInt(2); 16707 r = icIndexOfArrayO(self, value); 16708 ck_assert_int_eq(r, -1); 16709 // not indexOf 16710 emptyO(self); 16711 r = icIndexOfArrayO(self, value); 16712 ck_assert_int_eq(r, -1); 16713 // NULL value 16714 r = icIndexOfArrayO(self, NULL); 16715 ck_assert_int_eq(r, -1); 16716 terminateO(self); 16717 terminateO(value); 16718 16719 END_TEST 16720 16721 16722 START_TEST(icIndexOfArraycSmallArrayT) 16723 16724 ssize_t r; 16725 smallArrayt *self = allocG(rtSmallArrayt); 16726 char **value = listCreateS("A","BB"); 16727 16728 // indexOf 16729 char **elem = listCreateS("!!","@@@"); 16730 self->f->pushNFreeArrayc(self, elem); 16731 self->f->pushUndefined(self); 16732 delElemO(self, 1); 16733 self->f->pushNFreeArrayc(self, listCreateS("a","bb")); 16734 r = icIndexOfArraycO(self, value); 16735 ck_assert_int_eq(r, 2); 16736 // not indexOf 16737 delElemO(self, 2); 16738 r = icIndexOfArraycO(self, value); 16739 ck_assert_int_eq(r, -1); 16740 // NULL value 16741 r = icIndexOfArraycO(self, NULL); 16742 ck_assert_int_eq(r, -1); 16743 terminateO(self); 16744 listFreeS(value); 16745 16746 END_TEST 16747 16748 16749 START_TEST(icIndexOfSmallJsonSmallArrayT) 16750 16751 ssize_t r; 16752 smallArrayt *self = allocG(rtSmallArrayt); 16753 smallJsont *value = allocSmallJson(); 16754 16755 // indexOf json undefined 16756 createUndefined(u); 16757 setTopO(value, (baset*)&u); 16758 self->f->pushUndefined(self); 16759 r = self->f->icIndexOfSmallJson(self, value); 16760 ck_assert_int_eq(r, 0); 16761 freeO(value); 16762 // indexOf json bool 16763 smallBoolt *b = allocSmallBool(true); 16764 setTopNFreeSmallBoolO(value, b); 16765 self->f->pushBool(self, true); 16766 r = self->f->icIndexOfSmallJson(self, value); 16767 ck_assert_int_eq(r, 1); 16768 freeO(value); 16769 // indexOf json double 16770 smallDoublet *d = allocSmallDouble(1); 16771 setTopNFreeSmallDoubleO(value, d); 16772 self->f->pushDouble(self, 1); 16773 r = self->f->icIndexOfSmallJson(self, value); 16774 ck_assert_int_eq(r, 2); 16775 freeO(value); 16776 // indexOf json int 16777 smallIntt *i = allocSmallInt(1); 16778 setTopNFreeSmallIntO(value, i); 16779 self->f->pushInt(self, 1); 16780 r = self->f->icIndexOfSmallJson(self, value); 16781 ck_assert_int_eq(r, 3); 16782 freeO(value); 16783 // indexOf json string 16784 smallStringt *s = allocSmallString("ASD"); 16785 setTopNFreeSmallStringO(value, s); 16786 self->f->pushS(self, "asd"); 16787 r = self->f->icIndexOfSmallJson(self, value); 16788 ck_assert_int_eq(r, 4); 16789 freeO(value); 16790 // indexOf json dict 16791 smallDictt *D = allocSmallDict(); 16792 D->f->setInt(D, "A", 1); 16793 setTopDictO(value, D); 16794 resetO(D); 16795 D->f->setInt(D, "a", 1); 16796 self->f->pushNFreeDict(self, D); 16797 r = self->f->icIndexOfSmallJson(self, value); 16798 ck_assert_int_eq(r, 5); 16799 freeO(value); 16800 // indexOf json array 16801 value->f->pushS(value, "A"); 16802 delElemO(self, 1); 16803 createAllocateSmallJson(elem); 16804 elem->f->pushS(elem, "a"); 16805 self->f->pushNFreeSmallJson(self, elem); 16806 r = self->f->icIndexOfSmallJson(self, value); 16807 ck_assert_int_eq(r, 6); 16808 // not indexOf 16809 delElemO(self, 6); 16810 r = self->f->icIndexOfSmallJson(self, value); 16811 ck_assert_int_eq(r, -1); 16812 // empty json object 16813 freeO(value); 16814 r = self->f->icIndexOfSmallJson(self, value); 16815 ck_assert_int_eq(r, -1); 16816 // non smallJson object 16817 terminateO(value); 16818 value = (smallJsont*) allocSmallInt(2); 16819 r = self->f->icIndexOfSmallJson(self, value); 16820 ck_assert_int_eq(r, -1); 16821 // NULL value 16822 r = self->f->icIndexOfSmallJson(self, NULL); 16823 ck_assert_int_eq(r, -1); 16824 terminateO(self); 16825 terminateO(value); 16826 16827 END_TEST 16828 16829 16830 START_TEST(icIndexOfSmallStringSmallArrayT) 16831 16832 ssize_t r; 16833 smallArrayt *self = allocG(rtSmallArrayt); 16834 smallStringt *value = allocSmallString("QWE"); 16835 16836 // indexOf 16837 self->f->pushUndefined(self); 16838 self->f->pushUndefined(self); 16839 delElemO(self, 1); 16840 self->f->pushS(self, "qwe"); 16841 r = self->f->icIndexOfSmallString(self, value); 16842 ck_assert_int_eq(r, 2); 16843 // not indexOf 16844 delElemO(self, 2); 16845 r = self->f->icIndexOfSmallString(self, value); 16846 ck_assert_int_eq(r, -1); 16847 // non smallString object 16848 terminateO(value); 16849 value = (smallStringt*) allocSmallInt(2); 16850 r = self->f->icIndexOfSmallString(self, value); 16851 ck_assert_int_eq(r, -1); 16852 // NULL value 16853 r = self->f->icIndexOfSmallString(self, NULL); 16854 ck_assert_int_eq(r, -1); 16855 terminateO(self); 16856 terminateO(value); 16857 16858 END_TEST 16859 16860 16861 START_TEST(icBinarySearchSmallArrayT) 16862 16863 ssize_t r; 16864 smallArrayt *self = allocG(rtSmallArrayt); 16865 baset *value = (baset*)allocSmallString("E"); 16866 16867 // index not trimmed (an element is NULL) 16868 self->f->pushS(self, "a"); 16869 self->f->pushS(self, "b"); 16870 self->f->pushS(self, "c"); 16871 delElemO(self, 2); 16872 self->f->pushS(self, "d"); 16873 self->f->pushS(self, "e"); 16874 self->f->pushS(self, "f"); 16875 r = icBinarySearchO(self, value); 16876 ck_assert_int_eq(r, -1); 16877 // index 16878 trimO(self); 16879 r = icBinarySearchO(self, value); 16880 ck_assert_int_eq(r, 3); 16881 smallStringt *v = (smallStringt*) value; 16882 // index in the lower half of the array 16883 setValO(v, "B"); 16884 r = icBinarySearchO(self, value); 16885 ck_assert_int_eq(r, 1); 16886 // not index 16887 setValO(v, "asd"); 16888 r = icBinarySearchO(self, value); 16889 ck_assert_int_eq(r, -1); 16890 // NULL value 16891 r = icBinarySearchO(self, NULL); 16892 ck_assert_int_eq(r, -1); 16893 // empty array 16894 emptyO(self); 16895 r = icBinarySearchO(self, value); 16896 ck_assert_int_eq(r, -1); 16897 terminateO(self); 16898 terminateO(value); 16899 16900 END_TEST 16901 16902 16903 START_TEST(icBinarySearchSSmallArrayT) 16904 16905 ssize_t r; 16906 smallArrayt *self = allocG(rtSmallArrayt); 16907 const char *value = "E"; 16908 16909 // index not trimmed (an element is NULL) 16910 self->f->pushS(self, "a"); 16911 self->f->pushS(self, "b"); 16912 self->f->pushS(self, "c"); 16913 delElemO(self, 2); 16914 self->f->pushS(self, "d"); 16915 self->f->pushS(self, "e"); 16916 self->f->pushS(self, "f"); 16917 r = icBinarySearchSO(self, value); 16918 ck_assert_int_eq(r, -1); 16919 // index 16920 trimO(self); 16921 r = icBinarySearchSO(self, value); 16922 ck_assert_int_eq(r, 3); 16923 // index in the lower half of the array 16924 value = "B"; 16925 r = icBinarySearchSO(self, value); 16926 ck_assert_int_eq(r, 1); 16927 // not index 16928 value = "asd"; 16929 r = icBinarySearchSO(self, value); 16930 ck_assert_int_eq(r, -1); 16931 // NULL value 16932 r = icBinarySearchSO(self, NULL); 16933 ck_assert_int_eq(r, -1); 16934 // empty array 16935 emptyO(self); 16936 r = icBinarySearchSO(self, value); 16937 ck_assert_int_eq(r, -1); 16938 terminateO(self); 16939 16940 END_TEST 16941 16942 16943 START_TEST(icBinarySearchCharSmallArrayT) 16944 16945 ssize_t r; 16946 smallArrayt *self = allocG(rtSmallArrayt); 16947 char value = 'E'; 16948 16949 // index not trimmed (an element is NULL) 16950 self->f->pushS(self, "a"); 16951 self->f->pushS(self, "b"); 16952 self->f->pushS(self, "c"); 16953 delElemO(self, 2); 16954 self->f->pushS(self, "d"); 16955 self->f->pushS(self, "e"); 16956 self->f->pushS(self, "f"); 16957 r = icBinarySearchCharO(self, value); 16958 ck_assert_int_eq(r, -1); 16959 // index 16960 trimO(self); 16961 r = icBinarySearchCharO(self, value); 16962 ck_assert_int_eq(r, 3); 16963 // index in the lower half of the array 16964 value = 'B'; 16965 r = icBinarySearchCharO(self, value); 16966 ck_assert_int_eq(r, 1); 16967 // not index 16968 value = '1'; 16969 r = icBinarySearchCharO(self, value); 16970 ck_assert_int_eq(r, -1); 16971 // empty array 16972 emptyO(self); 16973 r = icBinarySearchCharO(self, value); 16974 ck_assert_int_eq(r, -1); 16975 terminateO(self); 16976 16977 END_TEST 16978 16979 16980 START_TEST(icBinarySearchDictSmallArrayT) 16981 16982 ssize_t r; 16983 smallArrayt *self = allocG(rtSmallArrayt); 16984 smallDictt *value = allocSmallDict(); 16985 value->f->setInt(value, "B", 2); 16986 16987 // index not trimmed (an element is NULL) 16988 createAllocateSmallDict(elem); 16989 elem->f->setInt(elem, "a", 1); 16990 self->f->pushUndefined(self); 16991 self->f->pushDict(self, elem); 16992 resetO(elem); 16993 self->f->pushUndefined(self); 16994 delElemO(self, 2); 16995 elem->f->setInt(elem, "b", 2); 16996 self->f->pushNFreeDict(self, elem); 16997 self->f->pushS(self, "4"); 16998 self->f->pushS(self, "5"); 16999 r = icBinarySearchDictO(self, value); 17000 ck_assert_int_eq(r, -1); 17001 // index 17002 trimO(self); 17003 r = icBinarySearchDictO(self, value); 17004 ck_assert_int_eq(r, 2); 17005 // index in the lower half of the array 17006 freeO(value); 17007 value->f->setInt(value, "A", 1); 17008 r = icBinarySearchDictO(self, value); 17009 ck_assert_int_eq(r, 1); 17010 // not index 17011 freeO(value); 17012 r = icBinarySearchDictO(self, value); 17013 ck_assert_int_eq(r, -1); 17014 // non smallDict object 17015 terminateO(value); 17016 value = (smallDictt*) allocSmallInt(2); 17017 r = icBinarySearchDictO(self, value); 17018 ck_assert_int_eq(r, -1); 17019 // NULL value 17020 r = icBinarySearchDictO(self, NULL); 17021 ck_assert_int_eq(r, -1); 17022 // empty array 17023 emptyO(self); 17024 r = icBinarySearchDictO(self, value); 17025 ck_assert_int_eq(r, -1); 17026 terminateO(self); 17027 terminateO(value); 17028 17029 END_TEST 17030 17031 17032 START_TEST(icBinarySearchArraySmallArrayT) 17033 17034 ssize_t r; 17035 smallArrayt *self = allocG(rtSmallArrayt); 17036 smallArrayt *value = allocSmallArray(); 17037 value->f->pushS(value, "B"); 17038 17039 // index not trimmed (an element is NULL) 17040 createAllocateSmallArray(elem); 17041 elem->f->pushS(elem, "a"); 17042 self->f->pushUndefined(self); 17043 self->f->pushArray(self, elem); 17044 resetO(elem); 17045 self->f->pushUndefined(self); 17046 delElemO(self, 2); 17047 elem->f->pushS(elem, "b"); 17048 self->f->pushNFreeArray(self, elem); 17049 self->f->pushS(self, "4"); 17050 self->f->pushS(self, "5"); 17051 r = icBinarySearchArrayO(self, value); 17052 ck_assert_int_eq(r, -1); 17053 // index 17054 trimO(self); 17055 r = icBinarySearchArrayO(self, value); 17056 ck_assert_int_eq(r, 2); 17057 // index in the lower half of the array 17058 freeO(value); 17059 value->f->pushS(value, "A"); 17060 r = icBinarySearchArrayO(self, value); 17061 ck_assert_int_eq(r, 1); 17062 // not index 17063 freeO(value); 17064 r = icBinarySearchArrayO(self, value); 17065 ck_assert_int_eq(r, -1); 17066 // non smallArray object 17067 terminateO(value); 17068 value = (smallArrayt*) allocSmallInt(2); 17069 r = icBinarySearchArrayO(self, value); 17070 ck_assert_int_eq(r, -1); 17071 // NULL value 17072 r = icBinarySearchArrayO(self, NULL); 17073 ck_assert_int_eq(r, -1); 17074 // empty array 17075 emptyO(self); 17076 r = icBinarySearchArrayO(self, value); 17077 ck_assert_int_eq(r, -1); 17078 terminateO(self); 17079 terminateO(value); 17080 17081 END_TEST 17082 17083 17084 START_TEST(icBinarySearchArraycSmallArrayT) 17085 17086 ssize_t r; 17087 smallArrayt *self = allocG(rtSmallArrayt); 17088 char **value = listCreateS("B"); 17089 17090 // index not trimmed (an element is NULL) 17091 char **elem = listCreateS("a"); 17092 self->f->pushUndefined(self); 17093 self->f->pushNFreeArrayc(self, elem); 17094 self->f->pushUndefined(self); 17095 delElemO(self, 2); 17096 elem = listCreateS("b"); 17097 self->f->pushNFreeArrayc(self, elem); 17098 self->f->pushS(self, "4"); 17099 self->f->pushS(self, "5"); 17100 r = icBinarySearchArraycO(self, value); 17101 ck_assert_int_eq(r, -1); 17102 // index 17103 trimO(self); 17104 r = icBinarySearchArraycO(self, value); 17105 ck_assert_int_eq(r, 2); 17106 // index in the lower half of the array 17107 free(value[0]); 17108 value[0] = strdup("A"); 17109 r = icBinarySearchArraycO(self, value); 17110 ck_assert_int_eq(r, 1); 17111 // not index 17112 free(value[0]); 17113 value[0] = strdup("asd"); 17114 r = icBinarySearchArraycO(self, value); 17115 ck_assert_int_eq(r, -1); 17116 // NULL value 17117 r = icBinarySearchArraycO(self, NULL); 17118 ck_assert_int_eq(r, -1); 17119 // empty array 17120 emptyO(self); 17121 r = icBinarySearchArraycO(self, value); 17122 ck_assert_int_eq(r, -1); 17123 terminateO(self); 17124 listFreeS(value); 17125 17126 END_TEST 17127 17128 17129 START_TEST(icBinarySearchSmallJsonSmallArrayT) 17130 17131 ssize_t r; 17132 smallArrayt *self = allocG(rtSmallArrayt); 17133 smallJsont *value = allocSmallJson(); 17134 value->f->pushS(value, "B"); 17135 17136 // index not trimmed (an element is NULL) 17137 self->f->pushUndefined(self); 17138 createAllocateSmallArray(elem); 17139 elem->f->pushS(elem, "a"); 17140 self->f->pushArray(self, elem); 17141 resetO(elem); 17142 self->f->pushUndefined(self); 17143 delElemO(self, 2); 17144 elem->f->pushS(elem, "b"); 17145 self->f->pushNFreeArray(self, elem); 17146 self->f->pushS(self, "4"); 17147 self->f->pushS(self, "5"); 17148 r = self->f->icBinarySearchSmallJson(self, value); 17149 ck_assert_int_eq(r, -1); 17150 // index 17151 trimO(self); 17152 r = self->f->icBinarySearchSmallJson(self, value); 17153 ck_assert_int_eq(r, 2); 17154 // index in the lower half of the array 17155 freeO(value); 17156 value->f->pushS(value, "A"); 17157 r = self->f->icBinarySearchSmallJson(self, value); 17158 ck_assert_int_eq(r, 1); 17159 // not index (json array) 17160 delElemO(self, 1); 17161 trimO(self); 17162 r = self->f->icBinarySearchSmallJson(self, value); 17163 ck_assert_int_eq(r, -1); 17164 // not index json undefined 17165 createUndefined(u); 17166 freeO(value); 17167 setTopO(value, (baset*)&u); 17168 r = self->f->icBinarySearchSmallJson(self, value); 17169 ck_assert_int_eq(r, -1); 17170 // not index json bool 17171 createSmallBool(b); 17172 freeO(value); 17173 setTopO(value, (baset*)&b); 17174 r = self->f->icBinarySearchSmallJson(self, value); 17175 ck_assert_int_eq(r, -1); 17176 // not index json double 17177 createSmallDouble(d); 17178 freeO(value); 17179 setTopO(value, (baset*)&d); 17180 r = self->f->icBinarySearchSmallJson(self, value); 17181 ck_assert_int_eq(r, -1); 17182 // not index json int 17183 createSmallInt(i); 17184 freeO(value); 17185 setTopO(value, (baset*)&i); 17186 r = self->f->icBinarySearchSmallJson(self, value); 17187 ck_assert_int_eq(r, -1); 17188 // not index json string 17189 createSmallString(s); 17190 freeO(value); 17191 setTopO(value, (baset*)&s); 17192 r = self->f->icBinarySearchSmallJson(self, value); 17193 ck_assert_int_eq(r, -1); 17194 // not index json dict 17195 createSmallDict(D); 17196 freeO(value); 17197 setTopO(value, (baset*)&D); 17198 r = self->f->icBinarySearchSmallJson(self, value); 17199 ck_assert_int_eq(r, -1); 17200 // empty json object 17201 freeO(value); 17202 r = self->f->icBinarySearchSmallJson(self, value); 17203 ck_assert_int_eq(r, -1); 17204 // non smallJson object 17205 terminateO(value); 17206 value = (smallJsont*) allocSmallInt(2); 17207 r = self->f->icBinarySearchSmallJson(self, value); 17208 ck_assert_int_eq(r, -1); 17209 // NULL value 17210 r = self->f->icBinarySearchSmallJson(self, NULL); 17211 ck_assert_int_eq(r, -1); 17212 // empty array 17213 emptyO(self); 17214 r = self->f->icBinarySearchSmallJson(self, value); 17215 ck_assert_int_eq(r, -1); 17216 terminateO(self); 17217 terminateO(value); 17218 17219 END_TEST 17220 17221 17222 START_TEST(icBinarySearchSmallStringSmallArrayT) 17223 17224 ssize_t r; 17225 smallArrayt *self = allocG(rtSmallArrayt); 17226 smallStringt *value = allocSmallString("E"); 17227 17228 // index not trimmed (an element is NULL) 17229 self->f->pushS(self, "a"); 17230 self->f->pushS(self, "b"); 17231 self->f->pushS(self, "c"); 17232 delElemO(self, 2); 17233 self->f->pushS(self, "d"); 17234 self->f->pushS(self, "e"); 17235 self->f->pushS(self, "f"); 17236 r = icBinarySearchSmallStringO(self, value); 17237 ck_assert_int_eq(r, -1); 17238 // index 17239 trimO(self); 17240 r = icBinarySearchSmallStringO(self, value); 17241 ck_assert_int_eq(r, 3); 17242 // index in the lower half of the array 17243 setValO(value, "B"); 17244 r = icBinarySearchSmallStringO(self, value); 17245 ck_assert_int_eq(r, 1); 17246 // not index 17247 setValO(value, "asd"); 17248 r = icBinarySearchSmallStringO(self, value); 17249 ck_assert_int_eq(r, -1); 17250 // non smallString object 17251 terminateO(value); 17252 value = (smallStringt*) allocSmallInt(2); 17253 r = icBinarySearchSmallStringO(self, value); 17254 ck_assert_int_eq(r, -1); 17255 // NULL value 17256 r = icBinarySearchSmallStringO(self, NULL); 17257 ck_assert_int_eq(r, -1); 17258 // empty array 17259 emptyO(self); 17260 r = icBinarySearchSmallStringO(self, value); 17261 ck_assert_int_eq(r, -1); 17262 terminateO(self); 17263 terminateO(value); 17264 17265 END_TEST 17266 17267 17268 START_TEST(icUniqSmallArrayT) 17269 17270 smallArrayt* r; 17271 smallArrayt *self = allocG(rtSmallArrayt); 17272 17273 // empty array 17274 r = self->f->icUniq(self); 17275 ck_assert_ptr_eq(r, NULL); 17276 // one element 17277 self->f->pushUndefined(self); 17278 r = self->f->icUniq(self); 17279 ck_assert_ptr_eq(r, self); 17280 // uniq elements 17281 self->f->pushUndefined(self); 17282 self->f->pushBool(self, true); 17283 self->f->pushNFreeDict(self, allocSmallDict()); 17284 self->f->pushDouble(self, 1); 17285 self->f->pushInt(self, 2); 17286 self->f->pushS(self, "ASD"); 17287 self->f->pushNFreeArray(self, allocSmallArray()); 17288 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 17289 self->f->pushUndefined(self); 17290 self->f->pushBool(self, true); 17291 self->f->pushNFreeDict(self, allocSmallDict()); 17292 self->f->pushDouble(self, 1); 17293 self->f->pushInt(self, 2); 17294 self->f->pushS(self, "asd"); 17295 self->f->pushNFreeArray(self, allocSmallArray()); 17296 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 17297 r = self->f->icUniq(self); 17298 ck_assert_ptr_ne(r, NULL); 17299 char *s = toStringO(r); 17300 ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"ASD\",[],[0x71,0x77,0x65,0x00]]"); 17301 free(s); 17302 terminateO(self); 17303 17304 END_TEST 17305 17306 17307 START_TEST(compactSmallArrayT) 17308 17309 smallArrayt* r; 17310 smallArrayt *self = allocG(rtSmallArrayt); 17311 17312 // add and remove elements 17313 self->f->pushUndefined(self); 17314 // null element 17315 self->f->pushUndefined(self); 17316 delElemO(self, 1); 17317 self->f->pushBool(self, true); 17318 createSmallContainer(c); 17319 self->f->pushSmallContainer(self, &c); 17320 // empty dict 17321 createSmallDict(d); 17322 self->f->pushDict(self, &d); 17323 resetO(&d); 17324 (&d)->f->setInt(&d, "a", 1); 17325 self->f->pushDict(self, &d); 17326 self->f->pushDouble(self, 2); 17327 self->f->pushInt(self, 5); 17328 self->f->pushS(self, " "); 17329 self->f->pushS(self, "asd"); 17330 // empty Array 17331 createSmallArray(a); 17332 self->f->pushArray(self, &a); 17333 resetO(&a); 17334 (&a)->f->pushInt(&a, 1); 17335 self->f->pushArray(self, &a); 17336 // empty bytes 17337 createSmallBytes(b); 17338 self->f->pushSmallBytes(self, &b); 17339 smallBytest *B = allocSmallBytes("asd", 4); 17340 self->f->pushNFreeSmallBytes(self, B); 17341 r = compactO(self); 17342 ck_assert_ptr_ne(r, NULL); 17343 ck_assert_int_eq(lenO(r), 8); 17344 char *s = toStringO(r); 17345 ck_assert_str_eq(s, "[true,\"<data container>\",{\"a\":1},2.000000e+00,5,\"asd\",[1],[0x61,0x73,0x64,0x00]]"); 17346 free(s); 17347 // array with blank elements becomes empty after compact 17348 // self->a should not be null 17349 // self->a should an empty sArray to avoid issues with the setP function 17350 self->f->free(self); 17351 self->f->pushS(self, " "); 17352 self->f->pushS(self, ""); 17353 r = compactO(self); 17354 ck_assert_ptr_ne(r, NULL); 17355 ck_assert_ptr_ne(r->a, NULL); 17356 ck_assert_int_eq(lenO(r), 0); 17357 s = toStringO(r); 17358 ck_assert_str_eq(s, "[]"); 17359 free(s); 17360 // empty array 17361 emptyO(self); 17362 r = compactO(self); 17363 ck_assert_ptr_eq(r, NULL); 17364 terminateO(self); 17365 17366 END_TEST 17367 17368 17369 START_TEST(isBlankSmallArrayT) 17370 17371 bool r; 17372 smallArrayt *self = allocG(rtSmallArrayt); 17373 17374 // bool 17375 self->f->pushBool(self, true); 17376 r = isBlankO(self); 17377 ck_assert(!r); 17378 // container 17379 emptyO(self); 17380 createSmallContainer(c); 17381 self->f->pushSmallContainer(self, &c); 17382 r = isBlankO(self); 17383 ck_assert(!r); 17384 // blank dict 17385 emptyO(self); 17386 createSmallDict(d); 17387 self->f->pushDict(self, &d); 17388 r = isBlankO(self); 17389 ck_assert(r); 17390 // dict 17391 emptyO(self); 17392 resetO(&d); 17393 (&d)->f->setInt(&d, "a", 1); 17394 self->f->pushDict(self, &d); 17395 r = isBlankO(self); 17396 ck_assert(!r); 17397 // double 17398 emptyO(self); 17399 self->f->pushDouble(self, 0); 17400 r = isBlankO(self); 17401 ck_assert(!r); 17402 // int 17403 emptyO(self); 17404 self->f->pushInt(self, 0); 17405 r = isBlankO(self); 17406 ck_assert(!r); 17407 // blank string 17408 emptyO(self); 17409 self->f->pushS(self, " "); 17410 r = isBlankO(self); 17411 ck_assert(r); 17412 // string 17413 emptyO(self); 17414 self->f->pushS(self, "asd"); 17415 r = isBlankO(self); 17416 ck_assert(!r); 17417 // blank dict 17418 emptyO(self); 17419 createSmallArray(a); 17420 self->f->pushArray(self, &a); 17421 r = isBlankO(self); 17422 ck_assert(r); 17423 // dict 17424 emptyO(self); 17425 resetO(&a); 17426 (&a)->f->pushInt(&a, 1); 17427 self->f->pushArray(self, &a); 17428 r = isBlankO(self); 17429 ck_assert(!r); 17430 // blank Bytes 17431 emptyO(self); 17432 createSmallBytes(b); 17433 self->f->pushSmallBytes(self, &b); 17434 r = isBlankO(self); 17435 ck_assert(r); 17436 // Bytes 17437 emptyO(self); 17438 smallBytest *B = allocSmallBytes("asd", 4); 17439 self->f->pushNFreeSmallBytes(self, B); 17440 r = isBlankO(self); 17441 ck_assert(!r); 17442 // empty array 17443 emptyO(self); 17444 r = isBlankO(self); 17445 ck_assert(r); 17446 terminateO(self); 17447 17448 END_TEST 17449 17450 17451 bool fef(void *closure UNUSED, baset *e) { 17452 bool r = true; 17453 if (isOUndefined(e)) r = true; 17454 elif (isOSmallInt(e)) r = false; 17455 else { 17456 static u16 c; 17457 r = !c; 17458 c++; 17459 } 17460 return r; 17461 } 17462 17463 START_TEST(forEachSmallArrayFT) 17464 17465 smallArrayt *self = allocG(rtSmallArrayt); 17466 17467 // empty 17468 self->f->forEach(self, NULL, fef); 17469 // array with elements 17470 self->f->pushUndefined(self); 17471 self->f->pushBool(self, true); 17472 // base class 17473 createAllocateSmallInt(i); 17474 i->type = "userclass"; 17475 self->f->push(self, (baset*)i); 17476 createAllocateSmallInt(j); 17477 j->type = "userclass"; 17478 self->f->push(self, (baset*)j); 17479 delElemO(self, 1); 17480 self->f->pushInt(self, 2); 17481 self->f->forEach(self, NULL, fef); 17482 self->f->del(self, 2, 4); 17483 self->f->forEach(self, NULL, fef); 17484 terminateO(self); 17485 17486 END_TEST 17487 17488 17489 bool ef(void *closure UNUSED, u64 i UNUSED, baset *e) { 17490 bool r = true; 17491 if (isOUndefined(e)) r = true; 17492 elif (isOSmallInt(e)) r = false; 17493 else { 17494 static u16 c; 17495 r = !c; 17496 c++; 17497 } 17498 return r; 17499 } 17500 17501 START_TEST(enumerateSmallArrayFT) 17502 17503 smallArrayt *self = allocG(rtSmallArrayt); 17504 17505 // empty 17506 self->f->enumerate(self, NULL, ef); 17507 // array with elements 17508 self->f->pushUndefined(self); 17509 self->f->pushBool(self, true); 17510 // base class 17511 createAllocateSmallInt(i); 17512 i->type = "userclass"; 17513 self->f->push(self, (baset*)i); 17514 createAllocateSmallInt(j); 17515 j->type = "userclass"; 17516 self->f->push(self, (baset*)j); 17517 delElemO(self, 1); 17518 self->f->pushInt(self, 2); 17519 self->f->enumerate(self, NULL, ef); 17520 self->f->del(self, 2, 4); 17521 self->f->enumerate(self, NULL, ef); 17522 terminateO(self); 17523 17524 END_TEST 17525 17526 17527 START_TEST(iterStartSmallArrayT) 17528 17529 baset* r; 17530 smallArrayt *self = allocG(rtSmallArrayt); 17531 17532 // array with sObjects 17533 self->f->pushUndefined(self); 17534 self->f->pushBool(self, true); 17535 r = iterStartO(self); 17536 ck_assert_ptr_ne(r, NULL); 17537 ck_assert(isOUndefined(r)); 17538 // start again 17539 r = iterStartO(self); 17540 ck_assert_ptr_ne(r, NULL); 17541 ck_assert(isOUndefined(r)); 17542 // array with objects from other classes 17543 emptyO(self); 17544 createAllocateSmallInt(ip); 17545 ip->type = "anothertype"; 17546 setValG(ip, 11); 17547 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17548 ck_assert_ptr_ne(r2, NULL); 17549 r = iterStartO(self); 17550 ck_assert_ptr_ne(r, NULL); 17551 // array with all deleted elements 17552 emptyO(self); 17553 self->f->pushUndefined(self); 17554 delElemO(self, 0); 17555 r = iterStartO(self); 17556 ck_assert_ptr_eq(r, NULL); 17557 // empty array 17558 emptyO(self); 17559 r = iterStartO(self); 17560 ck_assert_ptr_eq(r, NULL); 17561 terminateO(self); 17562 17563 END_TEST 17564 17565 17566 START_TEST(iterStartLastSmallArrayT) 17567 17568 baset* r; 17569 smallArrayt *self = allocG(rtSmallArrayt); 17570 17571 // array with sObjects 17572 self->f->pushUndefined(self); 17573 self->f->pushBool(self, true); 17574 r = iterStartLastO(self); 17575 ck_assert_ptr_ne(r, NULL); 17576 ck_assert(isOSmallBool(r)); 17577 // start again 17578 r = iterStartLastO(self); 17579 ck_assert_ptr_ne(r, NULL); 17580 ck_assert(isOSmallBool(r)); 17581 // array with objects from other classes 17582 emptyO(self); 17583 createAllocateSmallInt(ip); 17584 ip->type = "anothertype"; 17585 setValG(ip, 11); 17586 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17587 ck_assert_ptr_ne(r2, NULL); 17588 r = iterStartLastO(self); 17589 ck_assert_ptr_ne(r, NULL); 17590 ck_assert(isOType(r, "anothertype")); 17591 // array with all deleted elements 17592 emptyO(self); 17593 self->f->pushUndefined(self); 17594 delElemO(self, 0); 17595 r = iterStartLastO(self); 17596 ck_assert_ptr_eq(r, NULL); 17597 // empty array 17598 emptyO(self); 17599 r = iterStartLastO(self); 17600 ck_assert_ptr_eq(r, NULL); 17601 terminateO(self); 17602 17603 END_TEST 17604 17605 17606 START_TEST(iterStartFromSmallArrayT) 17607 17608 baset* r; 17609 smallArrayt *self = allocG(rtSmallArrayt); 17610 17611 // array with sObjects 17612 self->f->pushUndefined(self); 17613 self->f->pushBool(self, true); 17614 r = iterStartFromO(self, 1); 17615 ck_assert_ptr_ne(r, NULL); 17616 ck_assert(isOSmallBool(r)); 17617 // start again 17618 r = iterStartFromO(self, 1); 17619 ck_assert_ptr_ne(r, NULL); 17620 ck_assert(isOSmallBool(r)); 17621 // array with objects from other classes 17622 emptyO(self); 17623 self->f->pushUndefined(self); 17624 createAllocateSmallInt(ip); 17625 ip->type = "anothertype"; 17626 setValG(ip, 11); 17627 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17628 ck_assert_ptr_ne(r2, NULL); 17629 r = iterStartFromO(self, -1); 17630 ck_assert_ptr_ne(r, NULL); 17631 ck_assert(isOType(r, "anothertype")); 17632 // index outside array 17633 r = iterStartFromO(self, 2); 17634 ck_assert_ptr_eq(r, NULL); 17635 r = iterStartFromO(self, -3); 17636 ck_assert_ptr_eq(r, NULL); 17637 // array with all deleted elements 17638 // except the ones before the start index 17639 emptyO(self); 17640 self->f->pushUndefined(self); 17641 self->f->pushUndefined(self); 17642 self->f->pushUndefined(self); 17643 delElemO(self, 1); 17644 delElemO(self, 2); 17645 r = iterStartFromO(self, 1); 17646 ck_assert_ptr_eq(r, NULL); 17647 // array with all deleted elements 17648 emptyO(self); 17649 self->f->pushUndefined(self); 17650 self->f->pushUndefined(self); 17651 self->f->pushUndefined(self); 17652 delElemO(self, 0); 17653 delElemO(self, 1); 17654 delElemO(self, 2); 17655 r = iterStartFromO(self, 1); 17656 ck_assert_ptr_eq(r, NULL); 17657 // empty array 17658 emptyO(self); 17659 r = iterStartFromO(self, 1); 17660 ck_assert_ptr_eq(r, NULL); 17661 terminateO(self); 17662 17663 END_TEST 17664 17665 17666 START_TEST(iterStartFromStepSmallArrayT) 17667 17668 baset* r; 17669 smallArrayt *self = allocG(rtSmallArrayt); 17670 17671 // array with sObjects 17672 self->f->pushUndefined(self); 17673 self->f->pushBool(self, true); 17674 r = iterStartFromStepO(self, 1, 2); 17675 ck_assert_ptr_ne(r, NULL); 17676 ck_assert(isOSmallBool(r)); 17677 // start again 17678 r = iterStartFromStepO(self, 1, 2); 17679 ck_assert_ptr_ne(r, NULL); 17680 ck_assert(isOSmallBool(r)); 17681 // array with objects from other classes 17682 emptyO(self); 17683 self->f->pushUndefined(self); 17684 createAllocateSmallInt(ip); 17685 ip->type = "anothertype"; 17686 setValG(ip, 11); 17687 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17688 ck_assert_ptr_ne(r2, NULL); 17689 r = iterStartFromStepO(self, -1, 2); 17690 ck_assert_ptr_ne(r, NULL); 17691 ck_assert(isOType(r, "anothertype")); 17692 // index outside array 17693 r = iterStartFromStepO(self, 2, 1); 17694 ck_assert_ptr_eq(r, NULL); 17695 r = iterStartFromStepO(self, -3, 1); 17696 ck_assert_ptr_eq(r, NULL); 17697 // array with all deleted elements 17698 // except the ones before the start index 17699 emptyO(self); 17700 self->f->pushUndefined(self); 17701 self->f->pushUndefined(self); 17702 self->f->pushUndefined(self); 17703 delElemO(self, 1); 17704 delElemO(self, 2); 17705 r = iterStartFromStepO(self, 1, 1); 17706 ck_assert_ptr_eq(r, NULL); 17707 // negative step 17708 r = iterStartFromStepO(self, 1, -1); 17709 ck_assert_ptr_ne(r, NULL); 17710 ck_assert(isOUndefined(r)); 17711 // array with all deleted elements 17712 emptyO(self); 17713 self->f->pushUndefined(self); 17714 self->f->pushUndefined(self); 17715 self->f->pushUndefined(self); 17716 delElemO(self, 0); 17717 delElemO(self, 1); 17718 delElemO(self, 2); 17719 r = iterStartFromStepO(self, 1, 2); 17720 ck_assert_ptr_eq(r, NULL); 17721 // empty array 17722 emptyO(self); 17723 r = iterStartFromStepO(self, 1, 1); 17724 ck_assert_ptr_eq(r, NULL); 17725 // step 0 17726 self->f->pushUndefined(self); 17727 r = iterStartFromStepO(self, 0, 0); 17728 ck_assert_ptr_eq(r, NULL); 17729 terminateO(self); 17730 17731 END_TEST 17732 17733 17734 START_TEST(iterNextSmallArrayT) 17735 17736 baset* r; 17737 smallArrayt *self = allocG(rtSmallArrayt); 17738 17739 // array with sObjects 17740 self->f->pushUndefined(self); 17741 self->f->pushBool(self, true); 17742 r = iterStartO(self); 17743 ck_assert_ptr_ne(r, NULL); 17744 ck_assert(isOUndefined(r)); 17745 r = iterNextO(self); 17746 ck_assert(isOSmallBool(r)); 17747 // array with objects from other classes 17748 emptyO(self); 17749 createAllocateSmallInt(ip); 17750 ip->type = "anothertype"; 17751 setValG(ip, 11); 17752 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17753 ck_assert_ptr_ne(r2, NULL); 17754 createAllocateSmallInt(ip2); 17755 ip2->type = "anothertype2"; 17756 setValG(ip2, 11); 17757 r2 = self->f->push(self, (baset*)ip2); 17758 ck_assert_ptr_ne(r2, NULL); 17759 r = iterStartO(self); 17760 ck_assert_ptr_ne(r, NULL); 17761 ck_assert(isOType(r, "anothertype")); 17762 r = iterNextO(self); 17763 ck_assert_ptr_ne(r, NULL); 17764 ck_assert_str_eq(r->type, "anothertype2"); 17765 // iteration ended 17766 r = iterNextO(self); 17767 ck_assert_ptr_eq(r, NULL); 17768 // array with all deleted elements 17769 emptyO(self); 17770 self->f->pushUndefined(self); 17771 delElemO(self, 0); 17772 r = iterStartO(self); 17773 ck_assert_ptr_eq(r, NULL); 17774 // empty array 17775 emptyO(self); 17776 r = iterStartO(self); 17777 ck_assert_ptr_eq(r, NULL); 17778 // empty array, uninitialized iterator 17779 emptyO(self); 17780 r = iterNextO(self); 17781 ck_assert_ptr_eq(r, NULL); 17782 terminateO(self); 17783 17784 END_TEST 17785 17786 17787 START_TEST(iterElementSmallArrayT) 17788 17789 baset* r; 17790 smallArrayt *self = allocG(rtSmallArrayt); 17791 17792 // start iteration 17793 self->f->pushUndefined(self); 17794 r = iterStartO(self); 17795 ck_assert_ptr_ne(r, NULL); 17796 baset *r2 = iterElementO(self); 17797 ck_assert_ptr_eq(r, r2); 17798 ck_assert_str_eq(r->type, "undefined"); 17799 // end iteration 17800 r = iterNextO(self); 17801 ck_assert_ptr_eq(r, NULL); 17802 r = iterElementO(self); 17803 ck_assert_ptr_eq(r, NULL); 17804 terminateO(self); 17805 17806 END_TEST 17807 17808 17809 START_TEST(iterIndexSmallArrayT) 17810 17811 ssize_t r; 17812 baset* r2; 17813 smallArrayt *self = allocG(rtSmallArrayt); 17814 17815 // start iteration 17816 self->f->pushUndefined(self); 17817 r2 = iterStartO(self); 17818 ck_assert_ptr_ne(r2, NULL); 17819 ck_assert_str_eq(r2->type, "undefined"); 17820 r = iterIndexO(self); 17821 ck_assert_int_eq(r, 0); 17822 // end iteration 17823 r2 = iterNextO(self); 17824 ck_assert_ptr_eq(r2, NULL); 17825 r = iterIndexO(self); 17826 ck_assert_int_eq(r, -1); 17827 terminateO(self); 17828 17829 END_TEST 17830 17831 17832 START_TEST(iterStepSmallArrayT) 17833 17834 int64_t r; 17835 baset* r2; 17836 smallArrayt *self = allocG(rtSmallArrayt); 17837 17838 // start iteration 17839 self->f->pushUndefined(self); 17840 r2 = iterStartO(self); 17841 ck_assert_ptr_ne(r2, NULL); 17842 ck_assert_str_eq(r2->type, "undefined"); 17843 r = iterStepO(self); 17844 ck_assert_int_eq(r, 1); 17845 // start iterator twice and 17846 // set step 17847 r2 =iterStartFromStepO(self, 0, 10); 17848 ck_assert_ptr_ne(r2, NULL); 17849 ck_assert_str_eq(r2->type, "undefined"); 17850 r = iterStepO(self); 17851 ck_assert_int_eq(r, 10); 17852 terminateO(self); 17853 17854 END_TEST 17855 17856 17857 START_TEST(joinSmallArrayT) 17858 17859 smallStringt* r; 17860 smallArrayt *self = allocG(rtSmallArrayt); 17861 17862 // join non string objects 17863 self->f->pushUndefined(self); 17864 self->f->pushInt(self, 123); 17865 r = joinO(self, ";"); 17866 ck_assert_ptr_ne(r, NULL); 17867 char *s = toStringO(r); 17868 terminateO(r); 17869 ck_assert_str_eq(s, "null;123"); 17870 free(s); 17871 // join strings 17872 emptyO(self); 17873 self->f->pushS(self, "a"); 17874 self->f->pushS(self, "b"); 17875 self->f->pushS(self, "c"); 17876 self->f->pushS(self, "d"); 17877 delElemO(self, 1); 17878 r = joinO(self, ";"); 17879 ck_assert_ptr_ne(r, NULL); 17880 s = toStringO(r); 17881 terminateO(r); 17882 ck_assert_str_eq(s, "a;c;d"); 17883 free(s); 17884 // null delimiter 17885 r = joinO(self, NULL); 17886 ck_assert_ptr_eq(r, NULL); 17887 // empty array 17888 emptyO(self); 17889 r = joinO(self, ";"); 17890 ck_assert_ptr_eq(r, NULL); 17891 terminateO(self); 17892 17893 END_TEST 17894 17895 17896 START_TEST(joinCharSmallArrayT) 17897 17898 smallStringt* r; 17899 smallArrayt *self = allocG(rtSmallArrayt); 17900 17901 // join non string objects 17902 self->f->pushUndefined(self); 17903 self->f->pushInt(self, 123); 17904 r = joinCharO(self, ';'); 17905 ck_assert_ptr_ne(r, NULL); 17906 char *s = toStringO(r); 17907 terminateO(r); 17908 ck_assert_str_eq(s, "null;123"); 17909 free(s); 17910 // join strings 17911 emptyO(self); 17912 self->f->pushS(self, "a"); 17913 self->f->pushS(self, "b"); 17914 self->f->pushS(self, "c"); 17915 self->f->pushS(self, "d"); 17916 delElemO(self, 1); 17917 r = joinCharO(self, ';'); 17918 ck_assert_ptr_ne(r, NULL); 17919 s = toStringO(r); 17920 terminateO(r); 17921 ck_assert_str_eq(s, "a;c;d"); 17922 free(s); 17923 // empty array 17924 emptyO(self); 17925 r = joinCharO(self, ';'); 17926 ck_assert_ptr_eq(r, NULL); 17927 terminateO(self); 17928 17929 END_TEST 17930 17931 17932 START_TEST(joinSmallJsonSmallArrayT) 17933 17934 smallStringt* r; 17935 smallArrayt *self = allocG(rtSmallArrayt); 17936 smallJsont* delim = allocSmallJson(); 17937 17938 // join non string objects 17939 setTopSO(delim, ";"); 17940 self->f->pushUndefined(self); 17941 self->f->pushInt(self, 123); 17942 r = self->f->joinSmallJson(self, delim); 17943 ck_assert_ptr_ne(r, NULL); 17944 char *s = toStringO(r); 17945 terminateO(r); 17946 ck_assert_str_eq(s, "null;123"); 17947 free(s); 17948 // join strings 17949 emptyO(self); 17950 self->f->pushS(self, "a"); 17951 self->f->pushS(self, "b"); 17952 self->f->pushS(self, "c"); 17953 self->f->pushS(self, "d"); 17954 delElemO(self, 1); 17955 r = self->f->joinSmallJson(self, delim); 17956 ck_assert_ptr_ne(r, NULL); 17957 s = toStringO(r); 17958 terminateO(r); 17959 ck_assert_str_eq(s, "a;c;d"); 17960 free(s); 17961 // delimiter not a string 17962 freeO(delim); 17963 setTopIntO(delim, 1); 17964 r = self->f->joinSmallJson(self, delim); 17965 ck_assert_ptr_eq(r, NULL); 17966 // non smallJson object 17967 terminateO(delim); 17968 delim = (smallJsont*) allocSmallInt(2); 17969 r = self->f->joinSmallJson(self, delim); 17970 ck_assert_ptr_eq(r, NULL); 17971 // null delimiter 17972 r = self->f->joinSmallJson(self, NULL); 17973 ck_assert_ptr_eq(r, NULL); 17974 // empty array 17975 emptyO(self); 17976 freeO(delim); 17977 setTopSO(delim, ";"); 17978 r = self->f->joinSmallJson(self, delim); 17979 ck_assert_ptr_eq(r, NULL); 17980 terminateO(self); 17981 terminateO(delim); 17982 17983 END_TEST 17984 17985 17986 START_TEST(joinSmallStringSmallArrayT) 17987 17988 smallStringt* r; 17989 smallArrayt *self = allocG(rtSmallArrayt); 17990 smallStringt* delim = allocSmallString(";"); 17991 17992 // join non string objects 17993 self->f->pushUndefined(self); 17994 self->f->pushInt(self, 123); 17995 r = joinSmallStringO(self, delim); 17996 ck_assert_ptr_ne(r, NULL); 17997 char *s = toStringO(r); 17998 terminateO(r); 17999 ck_assert_str_eq(s, "null;123"); 18000 free(s); 18001 // join strings 18002 emptyO(self); 18003 self->f->pushS(self, "a"); 18004 self->f->pushS(self, "b"); 18005 self->f->pushS(self, "c"); 18006 self->f->pushS(self, "d"); 18007 delElemO(self, 1); 18008 r = joinSmallStringO(self, delim); 18009 ck_assert_ptr_ne(r, NULL); 18010 s = toStringO(r); 18011 terminateO(r); 18012 ck_assert_str_eq(s, "a;c;d"); 18013 free(s); 18014 // delimiter with no string 18015 freeO(delim); 18016 r = joinSmallStringO(self, delim); 18017 ck_assert_ptr_eq(r, NULL); 18018 // null delimiter 18019 r = joinSmallStringO(self, NULL); 18020 ck_assert_ptr_eq(r, NULL); 18021 // empty array 18022 emptyO(self); 18023 setValO(delim, ";"); 18024 r = joinSmallStringO(self, delim); 18025 ck_assert_ptr_eq(r, NULL); 18026 terminateO(self); 18027 terminateO(delim); 18028 18029 END_TEST 18030 18031 18032 START_TEST(joinSSmallArrayT) 18033 18034 char* r; 18035 smallArrayt *self = allocG(rtSmallArrayt); 18036 18037 // join non string objects 18038 self->f->pushUndefined(self); 18039 self->f->pushInt(self, 123); 18040 r = self->f->joinS(self, ";"); 18041 ck_assert_ptr_ne(r, NULL); 18042 ck_assert_str_eq(r, "null;123"); 18043 free(r); 18044 // join strings 18045 emptyO(self); 18046 self->f->pushS(self, "a"); 18047 self->f->pushS(self, "b"); 18048 self->f->pushS(self, "c"); 18049 self->f->pushS(self, "d"); 18050 delElemO(self, 1); 18051 r = self->f->joinS(self, ";"); 18052 ck_assert_ptr_ne(r, NULL); 18053 ck_assert_str_eq(r, "a;c;d"); 18054 free(r); 18055 // null delimiter 18056 r = self->f->joinS(self, NULL); 18057 ck_assert_ptr_eq(r, NULL); 18058 // empty array 18059 emptyO(self); 18060 r = self->f->joinS(self, ";"); 18061 ck_assert_ptr_eq(r, NULL); 18062 terminateO(self); 18063 18064 END_TEST 18065 18066 18067 START_TEST(joinCharSSmallArrayT) 18068 18069 char* r; 18070 smallArrayt *self = allocG(rtSmallArrayt); 18071 18072 // join non string objects 18073 self->f->pushUndefined(self); 18074 self->f->pushInt(self, 123); 18075 r = joinCharSO(self, ';'); 18076 ck_assert_ptr_ne(r, NULL); 18077 ck_assert_str_eq(r, "null;123"); 18078 free(r); 18079 // join strings 18080 emptyO(self); 18081 self->f->pushS(self, "a"); 18082 self->f->pushS(self, "b"); 18083 self->f->pushS(self, "c"); 18084 self->f->pushS(self, "d"); 18085 delElemO(self, 1); 18086 r = joinCharSO(self, ';'); 18087 ck_assert_ptr_ne(r, NULL); 18088 ck_assert_str_eq(r, "a;c;d"); 18089 free(r); 18090 // empty array 18091 emptyO(self); 18092 r = joinCharSO(self, ';'); 18093 ck_assert_ptr_eq(r, NULL); 18094 terminateO(self); 18095 18096 END_TEST 18097 18098 18099 START_TEST(joinSmallJsonSSmallArrayT) 18100 18101 char* r; 18102 smallArrayt *self = allocG(rtSmallArrayt); 18103 smallJsont* delim = allocSmallJson(); 18104 18105 // join non string objects 18106 setTopSO(delim, ";"); 18107 self->f->pushUndefined(self); 18108 self->f->pushInt(self, 123); 18109 r = joinSmallJsonSO(self, delim); 18110 ck_assert_ptr_ne(r, NULL); 18111 ck_assert_str_eq(r, "null;123"); 18112 free(r); 18113 // join strings 18114 emptyO(self); 18115 self->f->pushS(self, "a"); 18116 self->f->pushS(self, "b"); 18117 self->f->pushS(self, "c"); 18118 self->f->pushS(self, "d"); 18119 delElemO(self, 1); 18120 r = joinSmallJsonSO(self, delim); 18121 ck_assert_ptr_ne(r, NULL); 18122 ck_assert_str_eq(r, "a;c;d"); 18123 free(r); 18124 // delimiter not a string 18125 freeO(delim); 18126 setTopIntO(delim, 1); 18127 r = joinSmallJsonSO(self, delim); 18128 ck_assert_ptr_eq(r, NULL); 18129 // non smallJson object 18130 terminateO(delim); 18131 delim = (smallJsont*) allocSmallInt(2); 18132 r = joinSmallJsonSO(self, delim); 18133 ck_assert_ptr_eq(r, NULL); 18134 // null delimiter 18135 r = joinSmallJsonSO(self, NULL); 18136 ck_assert_ptr_eq(r, NULL); 18137 // empty array 18138 emptyO(self); 18139 freeO(delim); 18140 setTopSO(delim, ";"); 18141 r = joinSmallJsonSO(self, delim); 18142 ck_assert_ptr_eq(r, NULL); 18143 terminateO(self); 18144 terminateO(delim); 18145 18146 END_TEST 18147 18148 18149 START_TEST(joinSmallStringSSmallArrayT) 18150 18151 char* r; 18152 smallArrayt *self = allocG(rtSmallArrayt); 18153 smallStringt* delim = allocSmallString(";"); 18154 18155 // join non string objects 18156 self->f->pushUndefined(self); 18157 self->f->pushInt(self, 123); 18158 r = joinSmallStringSO(self, delim); 18159 ck_assert_ptr_ne(r, NULL); 18160 ck_assert_str_eq(r, "null;123"); 18161 free(r); 18162 // join strings 18163 emptyO(self); 18164 self->f->pushS(self, "a"); 18165 self->f->pushS(self, "b"); 18166 self->f->pushS(self, "c"); 18167 self->f->pushS(self, "d"); 18168 delElemO(self, 1); 18169 r = joinSmallStringSO(self, delim); 18170 ck_assert_ptr_ne(r, NULL); 18171 ck_assert_str_eq(r, "a;c;d"); 18172 free(r); 18173 // delimiter with no string 18174 freeO(delim); 18175 r = joinSmallStringSO(self, delim); 18176 ck_assert_ptr_eq(r, NULL); 18177 // null delimiter 18178 r = joinSmallStringSO(self, NULL); 18179 ck_assert_ptr_eq(r, NULL); 18180 // empty array 18181 emptyO(self); 18182 setValO(delim, ";"); 18183 r = joinSmallStringSO(self, delim); 18184 ck_assert_ptr_eq(r, NULL); 18185 terminateO(self); 18186 terminateO(delim); 18187 18188 END_TEST 18189 18190 18191 START_TEST(zipSmallArrayT) 18192 18193 smallArrayt* r; 18194 smallArrayt *self = allocG(rtSmallArrayt); 18195 smallArrayt *array1 = allocSmallArray(); 18196 smallArrayt *array2 = allocSmallArray(); 18197 18198 // zip arrays 18199 // add an element to self 18200 // array1 has 2 elements 18201 // array2 has 3 elements 18202 // only 2 elements are zipped 18203 self->f->pushS(self, "qwe"); 18204 array1->f->pushS(array1, "a"); 18205 array1->f->pushS(array1, "b"); 18206 array2->f->pushInt(array2, 1); 18207 array2->f->pushInt(array2, 2); 18208 array2->f->pushInt(array2, 3); 18209 r = zipO(self, array1, array2); 18210 ck_assert_ptr_ne(r, NULL); 18211 char *s = toStringO(r); 18212 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18213 free(s); 18214 // delete the element not in self 18215 delElemO(array2, 2); 18216 // empty arrays 18217 disposeO(array2); 18218 r = zipO(self, array1, array2); 18219 ck_assert_ptr_ne(r, NULL); 18220 s = toStringO(r); 18221 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18222 free(s); 18223 disposeO(array1); 18224 r = zipO(self, array1, array2); 18225 ck_assert_ptr_ne(r, NULL); 18226 s = toStringO(r); 18227 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18228 free(s); 18229 // array1 and array2 same element count 18230 array1->f->pushS(array1, "aa"); 18231 array1->f->pushS(array1, "bb"); 18232 array2->f->pushInt(array2, 11); 18233 array2->f->pushInt(array2, 22); 18234 delElemO(array1, 1); 18235 r = zipO(self, array1, array2); 18236 delElemO(array2, 1); 18237 ck_assert_ptr_ne(r, NULL); 18238 // some elements were zipped 18239 s = toStringO(self); 18240 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18241 free(s); 18242 // but an element is NULL 18243 // non smallArray objects 18244 smashO(array1); 18245 array1 = (smallArrayt*) allocSmallInt(2); 18246 r = zipO(self, array1, array2); 18247 ck_assert_ptr_eq(r, NULL); 18248 terminateO(array1); 18249 array1 = allocSmallArray(); 18250 smashO(array2); 18251 array2 = (smallArrayt*) allocSmallInt(2); 18252 r = zipO(self, array1, array2); 18253 ck_assert_ptr_eq(r, NULL); 18254 terminateO(array2); 18255 array2 = allocSmallArray(); 18256 // NULL arrays 18257 r = zipO(self, NULL, array2); 18258 ck_assert_ptr_eq(r, NULL); 18259 r = zipO(self, array1, NULL); 18260 ck_assert_ptr_eq(r, NULL); 18261 terminateO(self); 18262 smashO(array1); 18263 smashO(array2); 18264 18265 END_TEST 18266 18267 18268 START_TEST(zipSmallJsonSmallArrayT) 18269 18270 smallArrayt* r; 18271 smallArrayt *self = allocG(rtSmallArrayt); 18272 smallArrayt *array1 = allocSmallArray(); 18273 smallJsont *array2 = allocSmallJson(); 18274 18275 // zip arrays 18276 // add an element to self 18277 // array1 has 2 elements 18278 // array2 has 3 elements 18279 // only 2 elements are zipped 18280 self->f->pushS(self, "qwe"); 18281 array1->f->pushS(array1, "a"); 18282 array1->f->pushS(array1, "b"); 18283 array2->f->pushInt(array2, 1); 18284 array2->f->pushInt(array2, 2); 18285 array2->f->pushInt(array2, 3); 18286 r = self->f->zipSmallJson(self, array1, array2); 18287 ck_assert_ptr_ne(r, NULL); 18288 char *s = toStringO(r); 18289 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18290 free(s); 18291 // delete the element not in self 18292 delElemIndexO(array2, 2); 18293 // empty arrays 18294 disposeO(array1); 18295 r = self->f->zipSmallJson(self, array1, array2); 18296 ck_assert_ptr_ne(r, NULL); 18297 s = toStringO(r); 18298 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18299 free(s); 18300 disposeO(array2); 18301 r = self->f->zipSmallJson(self, array1, array2); 18302 ck_assert_ptr_eq(r, NULL); 18303 // array1 and array2 same element count 18304 array1->f->pushS(array1, "aa"); 18305 array1->f->pushS(array1, "bb"); 18306 array2->f->pushInt(array2, 11); 18307 array2->f->pushInt(array2, 22); 18308 delElemO(array1, 1); 18309 r = self->f->zipSmallJson(self, array1, array2); 18310 delElemIndexO(array2, 1); 18311 ck_assert_ptr_ne(r, NULL); 18312 // some elements were zipped 18313 s = toStringO(self); 18314 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18315 free(s); 18316 // but an element is NULL 18317 // non smallArray objects 18318 smashO(array1); 18319 array1 = (smallArrayt*) allocSmallInt(2); 18320 r = self->f->zipSmallJson(self, array1, array2); 18321 ck_assert_ptr_eq(r, NULL); 18322 terminateO(array1); 18323 array1 = allocSmallArray(); 18324 smashO(array2); 18325 array2 = (smallJsont*) allocSmallInt(2); 18326 r = self->f->zipSmallJson(self, array1, array2); 18327 ck_assert_ptr_eq(r, NULL); 18328 terminateO(array2); 18329 array2 = allocSmallJson(); 18330 // NULL arrays 18331 r = self->f->zipSmallJson(self, NULL, array2); 18332 ck_assert_ptr_eq(r, NULL); 18333 r = self->f->zipSmallJson(self, array1, NULL); 18334 ck_assert_ptr_eq(r, NULL); 18335 terminateO(self); 18336 smashO(array1); 18337 smashO(array2); 18338 18339 END_TEST 18340 18341 18342 START_TEST(zipSmallJsonSmallArraySmallArrayT) 18343 18344 smallArrayt* r; 18345 smallArrayt *self = allocG(rtSmallArrayt); 18346 smallJsont *array1 = allocSmallJson(); 18347 smallArrayt *array2 = allocSmallArray(); 18348 18349 // zip arrays 18350 // add an element to self 18351 // array1 has 2 elements 18352 // array2 has 3 elements 18353 // only 2 elements are zipped 18354 self->f->pushS(self, "qwe"); 18355 array1->f->pushS(array1, "a"); 18356 array1->f->pushS(array1, "b"); 18357 array2->f->pushInt(array2, 1); 18358 array2->f->pushInt(array2, 2); 18359 array2->f->pushInt(array2, 3); 18360 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18361 ck_assert_ptr_ne(r, NULL); 18362 char *s = toStringO(r); 18363 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18364 free(s); 18365 // delete the element not in self 18366 delElemO(array2, 2); 18367 // empty arrays 18368 disposeO(array2); 18369 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18370 ck_assert_ptr_ne(r, NULL); 18371 s = toStringO(r); 18372 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18373 free(s); 18374 disposeO(array1); 18375 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18376 ck_assert_ptr_eq(r, NULL); 18377 // array1 and array2 same element count 18378 array1->f->pushS(array1, "aa"); 18379 array1->f->pushS(array1, "bb"); 18380 array2->f->pushInt(array2, 11); 18381 array2->f->pushInt(array2, 22); 18382 delElemIndexO(array1, 1); 18383 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18384 delElemO(array2, 1); 18385 ck_assert_ptr_ne(r, NULL); 18386 // some elements were zipped 18387 s = toStringO(self); 18388 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18389 free(s); 18390 // but an element is NULL 18391 // non smallArray objects 18392 smashO(array1); 18393 array1 = (smallJsont*) allocSmallInt(2); 18394 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18395 ck_assert_ptr_eq(r, NULL); 18396 terminateO(array1); 18397 array1 = allocSmallJson(); 18398 smashO(array2); 18399 array2 = (smallArrayt*) allocSmallInt(2); 18400 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18401 ck_assert_ptr_eq(r, NULL); 18402 terminateO(array2); 18403 array2 = allocSmallArray(); 18404 // NULL arrays 18405 r = self->f->zipSmallJsonSmallArray(self, NULL, array2); 18406 ck_assert_ptr_eq(r, NULL); 18407 r = self->f->zipSmallJsonSmallArray(self, array1, NULL); 18408 ck_assert_ptr_eq(r, NULL); 18409 terminateO(self); 18410 smashO(array1); 18411 smashO(array2); 18412 18413 END_TEST 18414 18415 18416 START_TEST(zipSmallJsonSmallJsonSmallArrayT) 18417 18418 smallArrayt* r; 18419 smallArrayt *self = allocG(rtSmallArrayt); 18420 smallJsont *array1 = allocSmallJson(); 18421 smallJsont *array2 = allocSmallJson(); 18422 18423 // zip arrays 18424 // add an element to self 18425 // array1 has 2 elements 18426 // array2 has 3 elements 18427 // only 2 elements are zipped 18428 self->f->pushS(self, "qwe"); 18429 array1->f->pushS(array1, "a"); 18430 array1->f->pushS(array1, "b"); 18431 array2->f->pushInt(array2, 1); 18432 array2->f->pushInt(array2, 2); 18433 array2->f->pushInt(array2, 3); 18434 r = zipSmallJsonSmallJsonO(self, array1, array2); 18435 ck_assert_ptr_ne(r, NULL); 18436 char *s = toStringO(r); 18437 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18438 free(s); 18439 // delete the element not in self 18440 delElemIndexO(array2, 2); 18441 // empty arrays 18442 disposeO(array1); 18443 r = zipSmallJsonSmallJsonO(self, array1, array2); 18444 ck_assert_ptr_eq(r, NULL); 18445 disposeO(array2); 18446 array1->f->pushS(array1, "a"); 18447 r = zipSmallJsonSmallJsonO(self, array1, array2); 18448 ck_assert_ptr_eq(r, NULL); 18449 array2->f->pushInt(array2, 1); 18450 delElemIndexO(array2, 0); 18451 r = zipSmallJsonSmallJsonO(self, array1, array2); 18452 ck_assert_ptr_ne(r, NULL); 18453 s = toStringO(r); 18454 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"a\"]]"); 18455 free(s); 18456 disposeO(array1); 18457 trimO(array2); 18458 // array1 and array2 same element count 18459 array1->f->pushS(array1, "aa"); 18460 array1->f->pushS(array1, "bb"); 18461 array2->f->pushInt(array2, 11); 18462 array2->f->pushInt(array2, 22); 18463 delElemIndexO(array1, 1); 18464 r = zipSmallJsonSmallJsonO(self, array1, array2); 18465 delElemIndexO(array2, 1); 18466 ck_assert_ptr_ne(r, NULL); 18467 // some elements were zipped 18468 s = toStringO(self); 18469 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"a\"],[\"aa\",11]]"); 18470 free(s); 18471 // but an element is NULL 18472 // non smallJson objects 18473 smashO(array1); 18474 array1 = (smallJsont*) allocSmallInt(2); 18475 r = zipSmallJsonSmallJsonO(self, array1, array2); 18476 ck_assert_ptr_eq(r, NULL); 18477 terminateO(array1); 18478 array1 = allocSmallJson(); 18479 smashO(array2); 18480 array2 = (smallJsont*) allocSmallInt(2); 18481 r = zipSmallJsonSmallJsonO(self, array1, array2); 18482 ck_assert_ptr_eq(r, NULL); 18483 terminateO(array2); 18484 array2 = allocSmallJson(); 18485 // NULL arrays 18486 r = zipSmallJsonSmallJsonO(self, NULL, array2); 18487 ck_assert_ptr_eq(r, NULL); 18488 r = zipSmallJsonSmallJsonO(self, array1, NULL); 18489 ck_assert_ptr_eq(r, NULL); 18490 terminateO(self); 18491 smashO(array1); 18492 smashO(array2); 18493 18494 END_TEST 18495 18496 18497 START_TEST(zipSmallJsonCharSmallArrayT) 18498 18499 smallArrayt* r; 18500 smallArrayt *self = allocG(rtSmallArrayt); 18501 smallJsont *array1 = allocSmallJson(); 18502 char **array2; 18503 18504 // zip arrays 18505 // add an element to self 18506 // array1 has 2 elements 18507 // array2 has 3 elements 18508 // only 2 elements are zipped 18509 self->f->pushS(self, "qwe"); 18510 array1->f->pushS(array1, "a"); 18511 array1->f->pushS(array1, "b"); 18512 array2 = listCreateS("1", "2", "3"); 18513 r = zipSmallJsonCharO(self, array1, array2); 18514 ck_assert_ptr_ne(r, NULL); 18515 char *s = toStringO(r); 18516 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18517 free(s); 18518 // delete the element not in self 18519 iListDelElemS(&array2, 2); 18520 // empty arrays 18521 iListRemoveS(&array2, 0, 2); 18522 r = zipSmallJsonCharO(self, array1, array2); 18523 ck_assert_ptr_ne(r, NULL); 18524 s = toStringO(r); 18525 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18526 free(s); 18527 disposeO(array1); 18528 r = zipSmallJsonCharO(self, array1, array2); 18529 ck_assert_ptr_eq(r, NULL); 18530 free(array2); 18531 // array1 and array2 same element count 18532 array1->f->pushS(array1, "aa"); 18533 array1->f->pushS(array1, "bb"); 18534 array2 = listCreateS("11", "22"); 18535 delElemIndexO(array1, 1); 18536 r = zipSmallJsonCharO(self, array1, array2); 18537 iListDelElemS(&array2, 1); 18538 ck_assert_ptr_ne(r, NULL); 18539 // some elements were zipped 18540 s = toStringO(self); 18541 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 18542 free(s); 18543 // but an element is NULL 18544 // non smallJson objects 18545 smashO(array1); 18546 array1 = (smallJsont*) allocSmallInt(2); 18547 r = zipSmallJsonCharO(self, array1, array2); 18548 ck_assert_ptr_eq(r, NULL); 18549 terminateO(array1); 18550 array1 = allocSmallJson(); 18551 // NULL arrays 18552 r = zipSmallJsonCharO(self, NULL, array2); 18553 ck_assert_ptr_eq(r, NULL); 18554 r = zipSmallJsonCharO(self, array1, NULL); 18555 ck_assert_ptr_eq(r, NULL); 18556 terminateO(self); 18557 smashO(array1); 18558 free(array2); 18559 18560 END_TEST 18561 18562 18563 START_TEST(zipSmallJsonCCharSmallArrayT) 18564 18565 smallArrayt* r; 18566 smallArrayt *self = allocG(rtSmallArrayt); 18567 smallJsont *array1 = allocSmallJson(); 18568 const char* array2[] = {"1", "2", "3", null}; 18569 18570 // zip arrays 18571 // add an element to self 18572 // array1 has 2 elements 18573 // array2 has 3 elements 18574 // only 2 elements are zipped 18575 self->f->pushS(self, "qwe"); 18576 array1->f->pushS(array1, "a"); 18577 array1->f->pushS(array1, "b"); 18578 r = self->f->zipSmallJsonCChar(self, array1, array2); 18579 ck_assert_ptr_ne(r, NULL); 18580 char *s = toStringO(r); 18581 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18582 free(s); 18583 // empty arrays 18584 const char* array22[] = {null}; 18585 r = self->f->zipSmallJsonCChar(self, array1, array22); 18586 ck_assert_ptr_ne(r, NULL); 18587 s = toStringO(r); 18588 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18589 free(s); 18590 disposeO(array1); 18591 r = self->f->zipSmallJsonCChar(self, array1, array2); 18592 ck_assert_ptr_eq(r, NULL); 18593 // array1 and array2 same element count 18594 array1->f->pushS(array1, "aa"); 18595 array1->f->pushS(array1, "bb"); 18596 const char* array222[] = {"11", "22", null}; 18597 delElemIndexO(array1, 1); 18598 r = self->f->zipSmallJsonCChar(self, array1, array222); 18599 ck_assert_ptr_ne(r, NULL); 18600 // some elements were zipped 18601 s = toStringO(self); 18602 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 18603 free(s); 18604 // but an element is NULL 18605 // non smallJson objects 18606 smashO(array1); 18607 array1 = (smallJsont*) allocSmallInt(2); 18608 r = zipSmallJsonCCharO(self, array1, array2); 18609 ck_assert_ptr_eq(r, NULL); 18610 terminateO(array1); 18611 array1 = allocSmallJson(); 18612 // NULL arrays 18613 r = self->f->zipSmallJsonCChar(self, NULL, array2); 18614 ck_assert_ptr_eq(r, NULL); 18615 r = self->f->zipSmallJsonCChar(self, array1, NULL); 18616 ck_assert_ptr_eq(r, NULL); 18617 terminateO(self); 18618 smashO(array1); 18619 18620 END_TEST 18621 18622 18623 START_TEST(zipArraySmallArrayT) 18624 18625 smallArrayt* r; 18626 smallArrayt *self = allocG(rtSmallArrayt); 18627 char** array1; 18628 smallArrayt *array2 = allocSmallArray(); 18629 18630 // zip arrays 18631 // add an element to self 18632 // array1 has 2 elements 18633 // array2 has 3 elements 18634 // only 2 elements are zipped 18635 self->f->pushS(self, "qwe"); 18636 array1 = listCreateS("a", "b"); 18637 array2->f->pushInt(array2, 1); 18638 array2->f->pushInt(array2, 2); 18639 array2->f->pushInt(array2, 3); 18640 r = zipArrayO(self, array1, array2); 18641 ck_assert_ptr_ne(r, NULL); 18642 char *s = toStringO(r); 18643 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18644 free(s); 18645 // delete the element not in self 18646 delElemO(array2, 2); 18647 // empty arrays 18648 disposeO(array2); 18649 r = zipArrayO(self, array1, array2); 18650 ck_assert_ptr_ne(r, NULL); 18651 s = toStringO(r); 18652 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18653 free(s); 18654 iListRemoveS(&array1, 0, 2); 18655 r = zipArrayO(self, array1, array2); 18656 free(array1); 18657 ck_assert_ptr_ne(r, NULL); 18658 s = toStringO(r); 18659 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18660 free(s); 18661 // array1 and array2 same element count 18662 array1 = listCreateS("aa", "bb"); 18663 array2->f->pushInt(array2, 11); 18664 array2->f->pushInt(array2, 22); 18665 iListDelElemS(&array1, 1); 18666 r = zipArrayO(self, array1, array2); 18667 delElemO(array2, 1); 18668 ck_assert_ptr_ne(r, NULL); 18669 // some elements were zipped 18670 s = toStringO(self); 18671 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18672 free(s); 18673 // but an element is NULL 18674 // non smallArray objects 18675 smashO(array2); 18676 array2 = (smallArrayt*) allocSmallInt(2); 18677 r = zipArrayO(self, array1, array2); 18678 ck_assert_ptr_eq(r, NULL); 18679 terminateO(array2); 18680 array2 = allocSmallArray(); 18681 // NULL arrays 18682 r = zipArrayO(self, NULL, array2); 18683 ck_assert_ptr_eq(r, NULL); 18684 r = zipArrayO(self, array1, NULL); 18685 ck_assert_ptr_eq(r, NULL); 18686 terminateO(self); 18687 free(array1); 18688 smashO(array2); 18689 18690 END_TEST 18691 18692 18693 START_TEST(zipCArraySmallArrayT) 18694 18695 smallArrayt* r; 18696 smallArrayt *self = allocG(rtSmallArrayt); 18697 const char* array1[] = {"a", "b", null}; 18698 smallArrayt *array2 = allocSmallArray(); 18699 18700 // zip arrays 18701 // add an element to self 18702 // array1 has 2 elements 18703 // array2 has 3 elements 18704 // only 2 elements are zipped 18705 self->f->pushS(self, "qwe"); 18706 array2->f->pushInt(array2, 1); 18707 array2->f->pushInt(array2, 2); 18708 array2->f->pushInt(array2, 3); 18709 r = self->f->zipCArray(self, array1, array2); 18710 ck_assert_ptr_ne(r, NULL); 18711 char *s = toStringO(r); 18712 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18713 free(s); 18714 // delete the element not in self 18715 delElemO(array2, 2); 18716 // empty arrays 18717 disposeO(array2); 18718 r = self->f->zipCArray(self, array1, array2); 18719 ck_assert_ptr_ne(r, NULL); 18720 s = toStringO(r); 18721 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18722 free(s); 18723 const char* array11[] = {null}; 18724 r = self->f->zipCArray(self, array11, array2); 18725 ck_assert_ptr_ne(r, NULL); 18726 s = toStringO(r); 18727 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18728 free(s); 18729 // array1 and array2 same element count 18730 const char* array111[] = {"aa", null}; 18731 array2->f->pushInt(array2, 11); 18732 array2->f->pushInt(array2, 22); 18733 r = self->f->zipCArray(self, array111, array2); 18734 delElemO(array2, 1); 18735 ck_assert_ptr_ne(r, NULL); 18736 // some elements were zipped 18737 s = toStringO(self); 18738 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18739 free(s); 18740 // but an element is NULL 18741 // non smallArray objects 18742 smashO(array2); 18743 array2 = (smallArrayt*) allocSmallInt(2); 18744 r = self->f->zipCArray(self, array1, array2); 18745 ck_assert_ptr_eq(r, NULL); 18746 terminateO(array2); 18747 array2 = allocSmallArray(); 18748 // NULL arrays 18749 r = self->f->zipCArray(self, NULL, array2); 18750 ck_assert_ptr_eq(r, NULL); 18751 r = self->f->zipCArray(self, array1, NULL); 18752 ck_assert_ptr_eq(r, NULL); 18753 terminateO(self); 18754 smashO(array2); 18755 18756 END_TEST 18757 18758 18759 START_TEST(zipArraySmallJsonSmallArrayT) 18760 18761 smallArrayt* r; 18762 smallArrayt *self = allocG(rtSmallArrayt); 18763 char** array1; 18764 smallJsont *array2 = allocSmallJson(); 18765 18766 // zip arrays 18767 // add an element to self 18768 // array1 has 2 elements 18769 // array2 has 3 elements 18770 // only 2 elements are zipped 18771 self->f->pushS(self, "qwe"); 18772 array1 = listCreateS("a", "b"); 18773 array2->f->pushInt(array2, 1); 18774 array2->f->pushInt(array2, 2); 18775 array2->f->pushInt(array2, 3); 18776 r = self->f->zipArraySmallJson(self, array1, array2); 18777 ck_assert_ptr_ne(r, NULL); 18778 char *s = toStringO(r); 18779 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18780 free(s); 18781 // delete the element not in self 18782 delElemIndexO(array2, 2); 18783 // empty arrays 18784 iListRemoveS(&array1, 0, 2); 18785 r = self->f->zipArraySmallJson(self, array1, array2); 18786 ck_assert_ptr_ne(r, NULL); 18787 s = toStringO(r); 18788 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18789 free(s); 18790 disposeO(array2); 18791 r = self->f->zipArraySmallJson(self, array1, array2); 18792 free(array1); 18793 ck_assert_ptr_eq(r, NULL); 18794 // array1 and array2 same element count 18795 array1 = listCreateS("aa", "bb"); 18796 array2->f->pushInt(array2, 11); 18797 array2->f->pushInt(array2, 22); 18798 iListDelElemS(&array1, 1); 18799 r = self->f->zipArraySmallJson(self, array1, array2); 18800 delElemIndexO(array2, 1); 18801 ck_assert_ptr_ne(r, NULL); 18802 // some elements were zipped 18803 s = toStringO(self); 18804 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18805 free(s); 18806 // but an element is NULL 18807 // non smallJson object 18808 smashO(array2); 18809 array2 = (smallJsont*) allocSmallInt(2); 18810 r = self->f->zipArraySmallJson(self, array1, array2); 18811 ck_assert_ptr_eq(r, NULL); 18812 terminateO(array2); 18813 array2 = allocSmallJson(); 18814 // NULL arrays 18815 r = self->f->zipArraySmallJson(self, NULL, array2); 18816 ck_assert_ptr_eq(r, NULL); 18817 r = self->f->zipArraySmallJson(self, array1, NULL); 18818 ck_assert_ptr_eq(r, NULL); 18819 terminateO(self); 18820 free(array1); 18821 smashO(array2); 18822 18823 END_TEST 18824 18825 18826 START_TEST(zipCArraySmallJsonSmallArrayT) 18827 18828 smallArrayt* r; 18829 smallArrayt *self = allocG(rtSmallArrayt); 18830 const char* array1[] = {"a", "b", null}; 18831 smallJsont *array2 = allocSmallJson(); 18832 18833 // zip arrays 18834 // add an element to self 18835 // array1 has 2 elements 18836 // array2 has 3 elements 18837 // only 2 elements are zipped 18838 self->f->pushS(self, "qwe"); 18839 array2->f->pushInt(array2, 1); 18840 array2->f->pushInt(array2, 2); 18841 array2->f->pushInt(array2, 3); 18842 r = self->f->zipCArraySmallJson(self, array1, array2); 18843 ck_assert_ptr_ne(r, NULL); 18844 char *s = toStringO(r); 18845 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18846 free(s); 18847 // delete the element not in self 18848 delElemIndexO(array2, 2); 18849 // empty arrays 18850 const char* array11[] = {null}; 18851 r = self->f->zipCArraySmallJson(self, array11, array2); 18852 ck_assert_ptr_ne(r, NULL); 18853 s = toStringO(r); 18854 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18855 free(s); 18856 disposeO(array2); 18857 r = self->f->zipCArraySmallJson(self, array1, array2); 18858 ck_assert_ptr_eq(r, NULL); 18859 // array1 and array2 same element count 18860 const char *array111[] = {"aa", null}; 18861 array2->f->pushInt(array2, 11); 18862 array2->f->pushInt(array2, 22); 18863 r = self->f->zipCArraySmallJson(self, array111, array2); 18864 delElemIndexO(array2, 1); 18865 ck_assert_ptr_ne(r, NULL); 18866 // some elements were zipped 18867 s = toStringO(self); 18868 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18869 free(s); 18870 // but an element is NULL 18871 // non smallJson object 18872 smashO(array2); 18873 array2 = (smallJsont*) allocSmallInt(2); 18874 r = self->f->zipCArraySmallJson(self, array1, array2); 18875 ck_assert_ptr_eq(r, NULL); 18876 terminateO(array2); 18877 array2 = allocSmallJson(); 18878 // NULL arrays 18879 r = self->f->zipCArraySmallJson(self, NULL, array2); 18880 ck_assert_ptr_eq(r, NULL); 18881 r = self->f->zipCArraySmallJson(self, array1, NULL); 18882 ck_assert_ptr_eq(r, NULL); 18883 terminateO(self); 18884 smashO(array2); 18885 18886 END_TEST 18887 18888 18889 START_TEST(zipCharSmallArrayT) 18890 18891 smallArrayt* r; 18892 smallArrayt *self = allocG(rtSmallArrayt); 18893 smallArrayt *array1 = allocSmallArray(); 18894 char** array2; 18895 18896 // zip arrays 18897 // add an element to self 18898 // array1 has 2 elements 18899 // array2 has 3 elements 18900 // only 2 elements are zipped 18901 self->f->pushS(self, "qwe"); 18902 array1->f->pushS(array1, "a"); 18903 array1->f->pushS(array1, "b"); 18904 array2 = listCreateS("1", "2", "3"); 18905 r = zipCharO(self, array1, array2); 18906 ck_assert_ptr_ne(r, NULL); 18907 char *s = toStringO(r); 18908 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18909 free(s); 18910 // delete the element not in self 18911 iListDelElemS(&array2, 2); 18912 // empty arrays 18913 iListRemoveS(&array2, 0, 2); 18914 r = zipCharO(self, array1, array2); 18915 ck_assert_ptr_ne(r, NULL); 18916 s = toStringO(r); 18917 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18918 free(s); 18919 disposeO(array1); 18920 r = zipCharO(self, array1, array2); 18921 ck_assert_ptr_ne(r, NULL); 18922 s = toStringO(r); 18923 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18924 free(s); 18925 free(array2); 18926 // array1 and array2 same element count 18927 array1->f->pushS(array1, "aa"); 18928 array1->f->pushS(array1, "bb"); 18929 array2 = listCreateS("11", "22"); 18930 delElemO(array1, 1); 18931 r = zipCharO(self, array1, array2); 18932 iListDelElemS(&array2, 1); 18933 ck_assert_ptr_ne(r, NULL); 18934 // some elements were zipped 18935 s = toStringO(self); 18936 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 18937 free(s); 18938 // but an element is NULL 18939 // non smallJson objects 18940 smashO(array1); 18941 array1 = (smallArrayt*) allocSmallInt(2); 18942 r = zipCharO(self, array1, array2); 18943 ck_assert_ptr_eq(r, NULL); 18944 terminateO(array1); 18945 array1 = allocSmallArray(); 18946 // NULL arrays 18947 r = zipCharO(self, NULL, array2); 18948 ck_assert_ptr_eq(r, NULL); 18949 r = zipCharO(self, array1, NULL); 18950 ck_assert_ptr_eq(r, NULL); 18951 terminateO(self); 18952 smashO(array1); 18953 free(array2); 18954 18955 END_TEST 18956 18957 18958 START_TEST(zipCCharSmallArrayT) 18959 18960 smallArrayt* r; 18961 smallArrayt *self = allocG(rtSmallArrayt); 18962 smallArrayt *array1 = allocSmallArray(); 18963 const char* array2[] = {"1", "2", "3", null}; 18964 18965 // zip arrays 18966 // add an element to self 18967 // array1 has 2 elements 18968 // array2 has 3 elements 18969 // only 2 elements are zipped 18970 self->f->pushS(self, "qwe"); 18971 array1->f->pushS(array1, "a"); 18972 array1->f->pushS(array1, "b"); 18973 r = self->f->zipCChar(self, array1, array2); 18974 ck_assert_ptr_ne(r, NULL); 18975 char *s = toStringO(r); 18976 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18977 free(s); 18978 // delete the element not in self 18979 // empty arrays 18980 const char* array22[] = {null}; 18981 r = self->f->zipCChar(self, array1, array22); 18982 ck_assert_ptr_ne(r, NULL); 18983 s = toStringO(r); 18984 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18985 free(s); 18986 disposeO(array1); 18987 r = self->f->zipCChar(self, array1, array2); 18988 ck_assert_ptr_ne(r, NULL); 18989 s = toStringO(r); 18990 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18991 free(s); 18992 // array1 and array2 same element count 18993 array1->f->pushS(array1, "aa"); 18994 array1->f->pushS(array1, "bb"); 18995 const char* array222[] = {"11", "22", null}; 18996 delElemO(array1, 1); 18997 r = self->f->zipCChar(self, array1, array222); 18998 ck_assert_ptr_ne(r, NULL); 18999 // some elements were zipped 19000 s = toStringO(self); 19001 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19002 free(s); 19003 // but an element is NULL 19004 // non smallJson objects 19005 smashO(array1); 19006 array1 = (smallArrayt*) allocSmallInt(2); 19007 r = self->f->zipCChar(self, array1, array2); 19008 ck_assert_ptr_eq(r, NULL); 19009 terminateO(array1); 19010 array1 = allocSmallArray(); 19011 // NULL arrays 19012 r = self->f->zipCChar(self, NULL, array2); 19013 ck_assert_ptr_eq(r, NULL); 19014 r = self->f->zipCChar(self, array1, NULL); 19015 ck_assert_ptr_eq(r, NULL); 19016 terminateO(self); 19017 smashO(array1); 19018 19019 END_TEST 19020 19021 19022 START_TEST(zipArrayCharSmallArrayT) 19023 19024 smallArrayt* r; 19025 smallArrayt *self = allocG(rtSmallArrayt); 19026 char** array1; 19027 char** array2; 19028 19029 // zip arrays 19030 // add an element to self 19031 // array1 has 2 elements 19032 // array2 has 3 elements 19033 // only 2 elements are zipped 19034 self->f->pushS(self, "qwe"); 19035 array1 = listCreateS("a", "b"); 19036 array2 = listCreateS("1", "2", "3"); 19037 r = zipArrayCharO(self, array1, array2); 19038 ck_assert_ptr_ne(r, NULL); 19039 char *s = toStringO(r); 19040 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19041 free(s); 19042 // delete the element not in self 19043 iListDelElemS(&array2, 2); 19044 // empty arrays 19045 iListRemoveS(&array2, 0, 2); 19046 r = zipArrayCharO(self, array1, array2); 19047 ck_assert_ptr_ne(r, NULL); 19048 s = toStringO(r); 19049 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19050 free(s); 19051 iListRemoveS(&array1, 0, 2); 19052 r = zipArrayCharO(self, array1, array2); 19053 ck_assert_ptr_ne(r, NULL); 19054 s = toStringO(r); 19055 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19056 free(s); 19057 free(array1); 19058 free(array2); 19059 // array1 and array2 same element count 19060 array1 = listCreateS("aa", "bb"); 19061 array2 = listCreateS("11", "22"); 19062 iListDelElemS(&array1, 1); 19063 r = zipArrayCharO(self, array1, array2); 19064 iListDelElemS(&array2, 1); 19065 ck_assert_ptr_ne(r, NULL); 19066 // some elements were zipped 19067 s = toStringO(self); 19068 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19069 free(s); 19070 // but an element is NULL 19071 // NULL arrays 19072 r = zipArrayCharO(self, NULL, array2); 19073 ck_assert_ptr_eq(r, NULL); 19074 r = zipArrayCharO(self, array1, NULL); 19075 ck_assert_ptr_eq(r, NULL); 19076 terminateO(self); 19077 free(array1); 19078 free(array2); 19079 19080 END_TEST 19081 19082 19083 START_TEST(zipCArrayCharSmallArrayT) 19084 19085 smallArrayt* r; 19086 smallArrayt *self = allocG(rtSmallArrayt); 19087 const char* array1[] = {"a", "b", null}; 19088 char** array2; 19089 19090 // zip arrays 19091 // add an element to self 19092 // array1 has 2 elements 19093 // array2 has 3 elements 19094 // only 2 elements are zipped 19095 self->f->pushS(self, "qwe"); 19096 array2 = listCreateS("1", "2", "3"); 19097 r = self->f->zipCArrayChar(self, array1, array2); 19098 ck_assert_ptr_ne(r, NULL); 19099 char *s = toStringO(r); 19100 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19101 free(s); 19102 // delete the element not in self 19103 iListDelElemS(&array2, 2); 19104 // empty arrays 19105 iListRemoveS(&array2, 0, 2); 19106 r = self->f->zipCArrayChar(self, array1, array2); 19107 ck_assert_ptr_ne(r, NULL); 19108 s = toStringO(r); 19109 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19110 free(s); 19111 const char* array11[] = {null}; 19112 r = self->f->zipCArrayChar(self, array11, array2); 19113 ck_assert_ptr_ne(r, NULL); 19114 s = toStringO(r); 19115 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19116 free(s); 19117 free(array2); 19118 // array1 and array2 same element count 19119 const char *array111[] = {"aa", null}; 19120 array2 = listCreateS("11", "22"); 19121 r = self->f->zipCArrayChar(self, array111, array2); 19122 iListDelElemS(&array2, 1); 19123 ck_assert_ptr_ne(r, NULL); 19124 // some elements were zipped 19125 s = toStringO(self); 19126 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19127 free(s); 19128 // but an element is NULL 19129 // NULL arrays 19130 r = self->f->zipCArrayChar(self, NULL, array2); 19131 ck_assert_ptr_eq(r, NULL); 19132 r = self->f->zipCArrayChar(self, array1, NULL); 19133 ck_assert_ptr_eq(r, NULL); 19134 terminateO(self); 19135 free(array2); 19136 19137 END_TEST 19138 19139 19140 START_TEST(zipArrayCCharSmallArrayT) 19141 19142 smallArrayt* r; 19143 smallArrayt *self = allocG(rtSmallArrayt); 19144 char** array1; 19145 const char* array2[] = {"1", "2", "3", null}; 19146 19147 // zip arrays 19148 // add an element to self 19149 // array1 has 2 elements 19150 // array2 has 3 elements 19151 // only 2 elements are zipped 19152 self->f->pushS(self, "qwe"); 19153 array1 = listCreateS("a", "b"); 19154 r = self->f->zipArrayCChar(self, array1, array2); 19155 ck_assert_ptr_ne(r, NULL); 19156 char *s = toStringO(r); 19157 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19158 free(s); 19159 // empty arrays 19160 const char* array22[] = {null}; 19161 r = self->f->zipArrayCChar(self, array1, array22); 19162 ck_assert_ptr_ne(r, NULL); 19163 s = toStringO(r); 19164 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19165 free(s); 19166 iListRemoveS(&array1, 0, 2); 19167 r = self->f->zipArrayCChar(self, array1, array2); 19168 ck_assert_ptr_ne(r, NULL); 19169 s = toStringO(r); 19170 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19171 free(s); 19172 free(array1); 19173 // array1 and array2 same element count 19174 array1 = listCreateS("aa", "bb"); 19175 const char* array222[] = {"11", "22", null}; 19176 iListDelElemS(&array1, 1); 19177 r = self->f->zipArrayCChar(self, array1, array222); 19178 ck_assert_ptr_ne(r, NULL); 19179 // some elements were zipped 19180 s = toStringO(self); 19181 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19182 free(s); 19183 // but an element is NULL 19184 // NULL arrays 19185 r = self->f->zipArrayCChar(self, NULL, array2); 19186 ck_assert_ptr_eq(r, NULL); 19187 r = self->f->zipArrayCChar(self, array1, NULL); 19188 ck_assert_ptr_eq(r, NULL); 19189 terminateO(self); 19190 free(array1); 19191 19192 END_TEST 19193 19194 19195 START_TEST(zipCArrayCCharSmallArrayT) 19196 19197 smallArrayt* r; 19198 smallArrayt *self = allocG(rtSmallArrayt); 19199 const char* array1[] = {"a", "b", null}; 19200 const char* array2[] = {"1", "2", "3", null}; 19201 19202 // zip arrays 19203 // add an element to self 19204 // array1 has 2 elements 19205 // array2 has 3 elements 19206 // only 2 elements are zipped 19207 self->f->pushS(self, "qwe"); 19208 r = self->f->zipCArrayCChar(self, array1, array2); 19209 ck_assert_ptr_ne(r, NULL); 19210 char *s = toStringO(r); 19211 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19212 free(s); 19213 // delete the element not in self 19214 // empty arrays 19215 const char* array22[] = {null}; 19216 r = self->f->zipCArrayCChar(self, array1, array22); 19217 ck_assert_ptr_ne(r, NULL); 19218 s = toStringO(r); 19219 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19220 free(s); 19221 const char* array11[] = {null}; 19222 r = self->f->zipCArrayCChar(self, array11, array2); 19223 ck_assert_ptr_ne(r, NULL); 19224 s = toStringO(r); 19225 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19226 free(s); 19227 // array1 and array2 same element count 19228 const char *array111[] = {"aa", null}; 19229 const char *array222[] = {"11", "22", null}; 19230 r = self->f->zipCArrayCChar(self, array111, array222); 19231 ck_assert_ptr_ne(r, NULL); 19232 // some elements were zipped 19233 s = toStringO(self); 19234 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19235 free(s); 19236 // but an element is NULL 19237 // NULL arrays 19238 r = self->f->zipCArrayCChar(self, NULL, array2); 19239 ck_assert_ptr_eq(r, NULL); 19240 r = self->f->zipCArrayCChar(self, array1, NULL); 19241 ck_assert_ptr_eq(r, NULL); 19242 terminateO(self); 19243 19244 END_TEST 19245 19246 19247 START_TEST(logSmallArrayT) 19248 19249 smallArrayt *self = allocG(rtSmallArrayt); 19250 19251 // only prints to stdout 19252 logO(self); 19253 terminateO(self); 19254 19255 END_TEST 19256 19257 19258 START_TEST(readTextSmallArrayT) 19259 19260 smallArrayt* r; 19261 smallArrayt *self = allocG(rtSmallArrayt); 19262 19263 // text 19264 r = readTextO(self, "../textTest.null"); 19265 ck_assert_ptr_ne(r, NULL); 19266 char *s = toStringO(r); 19267 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19268 free(s); 19269 // empty text 19270 emptyO(self); 19271 r = readTextO(self, "../chmodTest.null"); 19272 ck_assert_ptr_ne(r, NULL); 19273 ck_assert(isEmptyO(self)); 19274 // NULL path 19275 r = readTextO(self, NULL); 19276 ck_assert_ptr_eq(r, NULL); 19277 // non existing path 19278 if (fileExists("../nonExistingFile")) 19279 rmAll("../nonExistingFile"); 19280 r = readTextO(self, "../nonExistingFile"); 19281 ck_assert_ptr_eq(r, NULL); 19282 terminateO(self); 19283 19284 END_TEST 19285 19286 19287 START_TEST(readTextSmallJsonSmallArrayT) 19288 19289 smallArrayt* r; 19290 smallArrayt *self = allocG(rtSmallArrayt); 19291 smallJsont *filePath = allocSmallJson(); 19292 19293 // text 19294 setTopSO(filePath, "../textTest.null"); 19295 r = self->f->readTextSmallJson(self, filePath); 19296 ck_assert_ptr_ne(r, NULL); 19297 char *s = toStringO(r); 19298 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19299 free(s); 19300 // empty text 19301 emptyO(self); 19302 freeO(filePath); 19303 setTopSO(filePath, "../chmodTest.null"); 19304 r = self->f->readTextSmallJson(self, filePath); 19305 ck_assert_ptr_ne(r, NULL); 19306 ck_assert(isEmptyO(self)); 19307 // NULL path 19308 r = self->f->readTextSmallJson(self, NULL); 19309 ck_assert_ptr_eq(r, NULL); 19310 // non existing path 19311 if (fileExists("../nonExistingFile")) 19312 rmAll("../nonExistingFile"); 19313 freeO(filePath); 19314 setTopSO(filePath, "../nonExistingFile"); 19315 r = self->f->readTextSmallJson(self, filePath); 19316 ck_assert_ptr_eq(r, NULL); 19317 // filePath not a string 19318 freeO(filePath); 19319 setTopIntO(filePath, 0); 19320 r = self->f->readTextSmallJson(self, filePath); 19321 ck_assert_ptr_eq(r, NULL); 19322 // non smallJson object 19323 terminateO(filePath); 19324 filePath = (smallJsont*) allocSmallInt(2); 19325 r = self->f->readTextSmallJson(self, filePath); 19326 ck_assert_ptr_eq(r, NULL); 19327 terminateO(self); 19328 terminateO(filePath); 19329 19330 END_TEST 19331 19332 19333 START_TEST(readTextSmallStringSmallArrayT) 19334 19335 smallArrayt* r; 19336 smallArrayt *self = allocG(rtSmallArrayt); 19337 smallStringt *filePath = allocSmallString(""); 19338 19339 // text 19340 setValO(filePath, "../textTest.null"); 19341 r = readTextSmallStringO(self, filePath); 19342 ck_assert_ptr_ne(r, NULL); 19343 char *s = toStringO(r); 19344 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19345 free(s); 19346 // empty text 19347 emptyO(self); 19348 setValO(filePath, "../chmodTest.null"); 19349 r = readTextSmallStringO(self, filePath); 19350 ck_assert_ptr_ne(r, NULL); 19351 ck_assert(isEmptyO(self)); 19352 // NULL path 19353 r = readTextSmallStringO(self, NULL); 19354 ck_assert_ptr_eq(r, NULL); 19355 // non existing path 19356 if (fileExists("../nonExistingFile")) 19357 rmAll("../nonExistingFile"); 19358 setValO(filePath, "../nonExistingFile"); 19359 r = readTextSmallStringO(self, filePath); 19360 ck_assert_ptr_eq(r, NULL); 19361 // blank file path 19362 setValO(filePath, " "); 19363 r = readTextSmallStringO(self, filePath); 19364 ck_assert_ptr_eq(r, NULL); 19365 // non smallString object 19366 terminateO(filePath); 19367 filePath = (smallStringt*) allocSmallInt(2); 19368 r = readTextSmallStringO(self, filePath); 19369 ck_assert_ptr_eq(r, NULL); 19370 terminateO(self); 19371 terminateO(filePath); 19372 19373 END_TEST 19374 19375 19376 START_TEST(readStreamSmallArrayT) 19377 19378 smallArrayt* r; 19379 smallArrayt *self = allocG(rtSmallArrayt); 19380 FILE *fp; 19381 19382 // stream 19383 fp = fopen("../textTest.null", "r"); 19384 r = readStreamO(self, fp); 19385 fclose(fp); 19386 ck_assert_ptr_ne(r, NULL); 19387 char *s = toStringO(r); 19388 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19389 free(s); 19390 // empty stream 19391 emptyO(self); 19392 fp = fopen("../chmodTest.null", "r"); 19393 r = readStreamO(self, fp); 19394 fclose(fp); 19395 ck_assert_ptr_ne(r, NULL); 19396 ck_assert(isEmptyO(self)); 19397 // NULL stream 19398 ck_assert_ptr_eq(readStreamO(self, NULL), NULL); 19399 terminateO(self); 19400 19401 END_TEST 19402 19403 19404 START_TEST(writeTextSmallArrayT) 19405 19406 bool r; 19407 smallArrayt *self = allocG(rtSmallArrayt); 19408 19409 // write textOutTest.null 19410 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19411 ck_assert_ptr_ne(r2, NULL); 19412 r = writeTextO(self, "../textOutTest.null"); 19413 ck_assert(r); 19414 // check textOutTest.null 19415 emptyO(self); 19416 r2 = readTextO(self, "../textOutTest.null"); 19417 ck_assert_ptr_ne(r2, NULL); 19418 char *s = toStringO(r2); 19419 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19420 free(s); 19421 // empty array 19422 emptyO(self); 19423 r = writeTextO(self, "../textOutTest.null"); 19424 ck_assert(!r); 19425 r2 = readTextO(self, "../textOutTest.null"); 19426 ck_assert_ptr_ne(r2, NULL); 19427 s = toStringO(r2); 19428 ck_assert_str_eq(s, "[]"); 19429 free(s); 19430 // non existing file 19431 // make sure the file doesnt exist 19432 if (fileExists("../nonExistingFile")) 19433 rmAll("../nonExistingFile"); 19434 self->f->pushS(self, "qwe"); 19435 ck_assert(writeTextO(self, "../nonExistingFile")); 19436 if (fileExists("../nonExistingFile")) 19437 rmAll("../nonExistingFile"); 19438 // write readonly path 19439 ck_assert(!writeTextO(self, "/readOnlyFileTest")); 19440 // NULL path 19441 ck_assert(!writeTextO(self, NULL)); 19442 terminateO(self); 19443 19444 END_TEST 19445 19446 19447 START_TEST(writeTextSmallJsonSmallArrayT) 19448 19449 bool r; 19450 smallArrayt *self = allocG(rtSmallArrayt); 19451 smallJsont *filePath = allocSmallJson(); 19452 19453 // write textOutTest.null 19454 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19455 ck_assert_ptr_ne(r2, NULL); 19456 setTopSO(filePath, "../textOutTest.null"); 19457 r = self->f->writeTextSmallJson(self, filePath); 19458 ck_assert(r); 19459 // check textOutTest.null 19460 emptyO(self); 19461 r2 = readTextO(self, "../textOutTest.null"); 19462 ck_assert_ptr_ne(r2, NULL); 19463 char *s = toStringO(r2); 19464 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19465 free(s); 19466 // empty array 19467 emptyO(self); 19468 freeO(filePath); 19469 setTopSO(filePath, "../textOutTest.null"); 19470 r = self->f->writeTextSmallJson(self, filePath); 19471 ck_assert(!r); 19472 r2 = readTextO(self, "../textOutTest.null"); 19473 ck_assert_ptr_ne(r2, NULL); 19474 s = toStringO(r2); 19475 ck_assert_str_eq(s, "[]"); 19476 free(s); 19477 // non existing file 19478 // make sure the file doesnt exist 19479 if (fileExists("../nonExistingFile")) 19480 rmAll("../nonExistingFile"); 19481 self->f->pushS(self, "qwe"); 19482 freeO(filePath); 19483 setTopSO(filePath, "../nonExistingFile"); 19484 ck_assert(self->f->writeTextSmallJson(self, filePath)); 19485 if (fileExists("../nonExistingFile")) 19486 rmAll("../nonExistingFile"); 19487 // filePath not a string 19488 freeO(filePath); 19489 setTopIntO(filePath, 0); 19490 r = self->f->writeTextSmallJson(self, filePath); 19491 ck_assert(!r); 19492 // non smallJson object 19493 terminateO(filePath); 19494 filePath = (smallJsont*) allocSmallInt(2); 19495 r = self->f->writeTextSmallJson(self, filePath); 19496 ck_assert(!r); 19497 // NULL path 19498 ck_assert(!self->f->writeTextSmallJson(self, NULL)); 19499 terminateO(self); 19500 terminateO(filePath); 19501 19502 END_TEST 19503 19504 19505 START_TEST(writeTextSmallStringSmallArrayT) 19506 19507 bool r; 19508 smallArrayt *self = allocG(rtSmallArrayt); 19509 smallStringt *filePath = allocSmallString(""); 19510 19511 // write textOutTest.null 19512 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19513 ck_assert_ptr_ne(r2, NULL); 19514 setValO(filePath, "../textOutTest.null"); 19515 r = writeTextSmallStringO(self, filePath); 19516 ck_assert(r); 19517 // check textOutTest.null 19518 emptyO(self); 19519 r2 = readTextO(self, "../textOutTest.null"); 19520 ck_assert_ptr_ne(r2, NULL); 19521 char *s = toStringO(r2); 19522 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19523 free(s); 19524 // empty array 19525 emptyO(self); 19526 setValO(filePath, "../textOutTest.null"); 19527 r = writeTextSmallStringO(self, filePath); 19528 ck_assert(!r); 19529 r2 = readTextO(self, "../textOutTest.null"); 19530 ck_assert_ptr_ne(r2, NULL); 19531 s = toStringO(r2); 19532 ck_assert_str_eq(s, "[]"); 19533 free(s); 19534 // non existing file 19535 // make sure the file doesnt exist 19536 if (fileExists("../nonExistingFile")) 19537 rmAll("../nonExistingFile"); 19538 self->f->pushS(self, "qwe"); 19539 setValO(filePath, "../nonExistingFile"); 19540 ck_assert(writeTextSmallStringO(self, filePath)); 19541 if (fileExists("../nonExistingFile")) 19542 rmAll("../nonExistingFile"); 19543 // non smallJson object 19544 terminateO(filePath); 19545 filePath = (smallStringt*) allocSmallInt(2); 19546 r = writeTextSmallStringO(self, filePath); 19547 ck_assert(!r); 19548 // NULL path 19549 ck_assert(!writeTextSmallStringO(self, NULL)); 19550 terminateO(self); 19551 terminateO(filePath); 19552 19553 END_TEST 19554 19555 19556 START_TEST(writeStreamSmallArrayT) 19557 19558 bool r; 19559 smallArrayt *self = allocG(rtSmallArrayt); 19560 FILE *fp; 19561 19562 // write textOutTest.null 19563 fp = fopen("../textTest.null", "r"); 19564 smallArrayt *r2 = readStreamO(self, fp); 19565 fclose(fp); 19566 ck_assert_ptr_ne(r2, NULL); 19567 fp = fopen("../textOutTest.null", "w"); 19568 r = writeStreamO(self, fp); 19569 ck_assert(r); 19570 // empty array 19571 emptyO(self); 19572 ck_assert(!writeStreamO(self, fp)); 19573 fclose(fp); 19574 // check textOutTest.null 19575 fp = fopen("../textOutTest.null", "r"); 19576 r2 = readStreamO(self, fp); 19577 fclose(fp); 19578 ck_assert_ptr_ne(r2, NULL); 19579 char *s = toStringO(r2); 19580 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19581 free(s); 19582 terminateO(self); 19583 19584 END_TEST 19585 19586 19587 START_TEST(appendTextSmallArrayT) 19588 19589 bool r; 19590 smallArrayt *self = allocG(rtSmallArrayt); 19591 19592 // append to textOutTest.null 19593 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19594 ck_assert_ptr_ne(r2, NULL); 19595 r = writeTextO(self, "../textOutTest.null"); 19596 ck_assert(r); 19597 emptyO(self); 19598 self->f->pushS(self, "A"); 19599 self->f->pushS(self, "B"); 19600 r = appendTextO(self, "../textOutTest.null"); 19601 // check textOutTest.null 19602 emptyO(self); 19603 r2 = readTextO(self, "../textOutTest.null"); 19604 ck_assert_ptr_ne(r2, NULL); 19605 char *s = toStringO(r2); 19606 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 19607 free(s); 19608 // non existing file 19609 // make sure the file doesnt exist 19610 if (fileExists("../nonExistingFile")) 19611 rmAll("../nonExistingFile"); 19612 ck_assert(appendTextO(self, "../nonExistingFile")); 19613 if (fileExists("../nonExistingFile")) 19614 rmAll("../nonExistingFile"); 19615 // empty array 19616 emptyO(self); 19617 r = appendTextO(self, "../textOutTest.null"); 19618 ck_assert(!r); 19619 // check textOutTest.null 19620 emptyO(self); 19621 r2 = readTextO(self, "../textOutTest.null"); 19622 ck_assert_ptr_ne(r2, NULL); 19623 s = toStringO(r2); 19624 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 19625 free(s); 19626 // blank path 19627 ck_assert(!appendTextO(self, " ")); 19628 // append readonly path 19629 ck_assert(!appendTextO(self, "/readOnlyFileTest")); 19630 // NULL path 19631 ck_assert(!appendTextO(self, NULL)); 19632 terminateO(self); 19633 19634 END_TEST 19635 19636 19637 START_TEST(appendTextSmallStringSmallArrayT) 19638 19639 bool r; 19640 smallArrayt *self = allocG(rtSmallArrayt); 19641 smallStringt *filePath = allocSmallString(""); 19642 19643 // append to textOutTest.null 19644 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19645 ck_assert_ptr_ne(r2, NULL); 19646 r = writeTextO(self, "../textOutTest.null"); 19647 ck_assert(r); 19648 emptyO(self); 19649 self->f->pushS(self, "A"); 19650 self->f->pushS(self, "B"); 19651 setValO(filePath, "../textOutTest.null"); 19652 r = appendTextSmallStringO(self, filePath); 19653 // check textOutTest.null 19654 emptyO(self); 19655 r2 = readTextO(self, "../textOutTest.null"); 19656 ck_assert_ptr_ne(r2, NULL); 19657 char *s = toStringO(r2); 19658 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 19659 free(s); 19660 // non existing file 19661 // make sure the file doesnt exist 19662 if (fileExists("../nonExistingFile")) 19663 rmAll("../nonExistingFile"); 19664 setValO(filePath, "../nonExistingFile"); 19665 ck_assert(appendTextSmallStringO(self, filePath)); 19666 if (fileExists("../nonExistingFile")) 19667 rmAll("../nonExistingFile"); 19668 // empty array 19669 emptyO(self); 19670 r = appendTextSmallStringO(self, filePath); 19671 ck_assert(!r); 19672 // check textOutTest.null 19673 emptyO(self); 19674 r2 = readTextO(self, "../textOutTest.null"); 19675 ck_assert_ptr_ne(r2, NULL); 19676 s = toStringO(r2); 19677 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 19678 free(s); 19679 // blank path 19680 setValO(filePath, " "); 19681 ck_assert(!appendTextSmallStringO(self, filePath)); 19682 // non smallString object 19683 terminateO(filePath); 19684 filePath = (smallStringt*) allocSmallInt(2); 19685 r = appendTextSmallStringO(self, filePath); 19686 ck_assert(!r); 19687 // NULL path 19688 ck_assert(!appendTextSmallStringO(self, NULL)); 19689 terminateO(self); 19690 terminateO(filePath); 19691 19692 END_TEST 19693 19694 19695 START_TEST(typeSmallStringSmallArrayT) 19696 19697 smallStringt* r; 19698 smallArrayt *self = allocG(rtSmallArrayt); 19699 19700 // empty array 19701 r = typeSmallStringO(self, 0); 19702 ck_assert_ptr_ne(r, NULL); 19703 char *s = toStringO(r); 19704 ck_assert_str_eq(s, "not a sheepy object"); 19705 free(s); 19706 terminateO(self); 19707 terminateO(r); 19708 19709 END_TEST 19710 19711 19712 START_TEST(typeSmallStringsSmallArrayT) 19713 19714 smallArrayt* r; 19715 smallArrayt *self = allocG(rtSmallArrayt); 19716 19717 // empty array 19718 r = typeSmallStringsO(self); 19719 ck_assert_ptr_eq(r, NULL); 19720 // array 19721 self->f->pushS(self, "qwe"); 19722 self->f->pushBool(self, true); 19723 self->f->pushDouble(self, 1); 19724 r = typeSmallStringsO(self); 19725 ck_assert_ptr_ne(r, NULL); 19726 char *s = toStringO(r); 19727 ck_assert_str_eq(s, "[\"string\",\"bool\",\"double\"]"); 19728 free(s); 19729 terminateO(self); 19730 terminateO(r); 19731 19732 END_TEST 19733 19734 19735 START_TEST(isETypeSmallArrayT) 19736 19737 bool r; 19738 smallArrayt *self = allocG(rtSmallArrayt); 19739 19740 self->f->pushUndefined(self); 19741 r = isETypeO(self, 0, "undefined"); 19742 ck_assert(r); 19743 // NULL type 19744 emptyO(self); 19745 r = isETypeO(self, 0, NULL); 19746 ck_assert(!r); 19747 terminateO(self); 19748 19749 END_TEST 19750 19751 19752 START_TEST(isEUndefinedSmallArrayT) 19753 19754 bool r; 19755 smallArrayt *self = allocG(rtSmallArrayt); 19756 19757 // array 19758 self->f->pushUndefined(self); 19759 self->f->pushS(self, ""); 19760 r = isEUndefinedO(self, 0); 19761 ck_assert(r); 19762 r = isEUndefinedO(self, -1); 19763 ck_assert(!r); 19764 terminateO(self); 19765 19766 END_TEST 19767 19768 19769 START_TEST(isEBoolSmallArrayT) 19770 19771 bool r; 19772 smallArrayt *self = allocG(rtSmallArrayt); 19773 19774 // array 19775 self->f->pushBool(self, true); 19776 self->f->pushS(self, ""); 19777 r = isEBoolO(self, 0); 19778 ck_assert(r); 19779 r = isEBoolO(self, -1); 19780 ck_assert(!r); 19781 terminateO(self); 19782 19783 END_TEST 19784 19785 19786 START_TEST(isEContainerSmallArrayT) 19787 19788 bool r; 19789 smallArrayt *self = allocG(rtSmallArrayt); 19790 19791 // array 19792 createSmallContainer(c); 19793 self->f->pushSmallContainer(self, &c); 19794 self->f->pushS(self, ""); 19795 r = isEContainerO(self, 0); 19796 ck_assert(r); 19797 r = isEContainerO(self, -1); 19798 ck_assert(!r); 19799 terminateO(self); 19800 19801 END_TEST 19802 19803 19804 START_TEST(isEDictSmallArrayT) 19805 19806 bool r; 19807 smallArrayt *self = allocG(rtSmallArrayt); 19808 19809 // array 19810 createSmallDict(d); 19811 self->f->pushDict(self, &d); 19812 self->f->pushS(self, ""); 19813 r = isEDictO(self, 0); 19814 ck_assert(r); 19815 r = isEDictO(self, -1); 19816 ck_assert(!r); 19817 terminateO(self); 19818 19819 END_TEST 19820 19821 19822 START_TEST(isEDoubleSmallArrayT) 19823 19824 bool r; 19825 smallArrayt *self = allocG(rtSmallArrayt); 19826 19827 // array 19828 self->f->pushDouble(self, 1); 19829 self->f->pushS(self, ""); 19830 r = isEDoubleO(self, 0); 19831 ck_assert(r); 19832 r = isEDoubleO(self, -1); 19833 ck_assert(!r); 19834 terminateO(self); 19835 19836 END_TEST 19837 19838 19839 START_TEST(isEIntSmallArrayT) 19840 19841 bool r; 19842 smallArrayt *self = allocG(rtSmallArrayt); 19843 19844 // array 19845 self->f->pushInt(self, 1); 19846 self->f->pushS(self, ""); 19847 r = isEIntO(self, 0); 19848 ck_assert(r); 19849 r = isEIntO(self, -1); 19850 ck_assert(!r); 19851 terminateO(self); 19852 19853 END_TEST 19854 19855 19856 START_TEST(isEStringSmallArrayT) 19857 19858 bool r; 19859 smallArrayt *self = allocG(rtSmallArrayt); 19860 19861 // array 19862 self->f->pushUndefined(self); 19863 self->f->pushS(self, ""); 19864 r = isEStringO(self, -1); 19865 ck_assert(r); 19866 r = isEStringO(self, 0); 19867 ck_assert(!r); 19868 terminateO(self); 19869 19870 END_TEST 19871 19872 19873 START_TEST(isEFaststringSmallArrayT) 19874 19875 bool r; 19876 smallArrayt *self = allocG(rtSmallArrayt); 19877 19878 r = isEFaststringO(self, 0); 19879 ck_assert(!r); 19880 terminateO(self); 19881 19882 END_TEST 19883 19884 19885 START_TEST(isEArraySmallArrayT) 19886 19887 bool r; 19888 smallArrayt *self = allocG(rtSmallArrayt); 19889 19890 // array 19891 createSmallArray(a); 19892 self->f->pushArray(self, &a); 19893 self->f->pushS(self, ""); 19894 r = isEArrayO(self, 0); 19895 ck_assert(r); 19896 r = isEArrayO(self, -1); 19897 ck_assert(!r); 19898 terminateO(self); 19899 19900 END_TEST 19901 19902 19903 START_TEST(isEBytesSmallArrayT) 19904 19905 bool r; 19906 smallArrayt *self = allocG(rtSmallArrayt); 19907 19908 // array 19909 createSmallBytes(b); 19910 self->f->pushSmallBytes(self, &b); 19911 self->f->pushS(self, ""); 19912 r = isEBytesO(self, 0); 19913 ck_assert(r); 19914 r = isEBytesO(self, -1); 19915 ck_assert(!r); 19916 terminateO(self); 19917 19918 END_TEST 19919 19920 19921 START_TEST(areAllETypeSmallArrayT) 19922 19923 bool r; 19924 smallArrayt *self = allocG(rtSmallArrayt); 19925 19926 // empty array 19927 r = areAllETypeO(self, "undefined"); 19928 ck_assert(!r); 19929 // array 19930 self->f->pushUndefined(self); 19931 self->f->pushUndefined(self); 19932 self->f->pushUndefined(self); 19933 delElemO(self, 1); 19934 r = areAllETypeO(self, "undefined"); 19935 ck_assert(!r); 19936 trimO(self); 19937 r = areAllETypeO(self, "undefined"); 19938 ck_assert(r); 19939 // NULL type 19940 r = areAllETypeO(self, NULL); 19941 ck_assert(!r); 19942 terminateO(self); 19943 19944 END_TEST 19945 19946 19947 START_TEST(areAllEUndefinedSmallArrayT) 19948 19949 bool r; 19950 smallArrayt *self = allocG(rtSmallArrayt); 19951 19952 // array 19953 self->f->pushUndefined(self); 19954 self->f->pushUndefined(self); 19955 self->f->pushUndefined(self); 19956 r = areAllEUndefinedO(self); 19957 ck_assert(r); 19958 terminateO(self); 19959 19960 END_TEST 19961 19962 19963 START_TEST(areAllEBoolSmallArrayT) 19964 19965 bool r; 19966 smallArrayt *self = allocG(rtSmallArrayt); 19967 19968 // array 19969 self->f->pushBool(self, true); 19970 self->f->pushBool(self, true); 19971 self->f->pushBool(self, true); 19972 r = areAllEBoolO(self); 19973 ck_assert(r); 19974 terminateO(self); 19975 19976 END_TEST 19977 19978 19979 START_TEST(areAllEContainerSmallArrayT) 19980 19981 bool r; 19982 smallArrayt *self = allocG(rtSmallArrayt); 19983 19984 createSmallContainer(c); 19985 self->f->pushSmallContainer(self, &c); 19986 r = areAllEContainerO(self); 19987 ck_assert(r); 19988 terminateO(self); 19989 19990 END_TEST 19991 19992 19993 START_TEST(areAllEDictSmallArrayT) 19994 19995 bool r; 19996 smallArrayt *self = allocG(rtSmallArrayt); 19997 19998 createSmallDict(d); 19999 self->f->pushDict(self, &d); 20000 r = areAllEDictO(self); 20001 ck_assert(r); 20002 terminateO(self); 20003 20004 END_TEST 20005 20006 20007 START_TEST(areAllEDoubleSmallArrayT) 20008 20009 bool r; 20010 smallArrayt *self = allocG(rtSmallArrayt); 20011 20012 self->f->pushDouble(self, 1); 20013 r = areAllEDoubleO(self); 20014 ck_assert(r); 20015 terminateO(self); 20016 20017 END_TEST 20018 20019 20020 START_TEST(areAllEIntSmallArrayT) 20021 20022 bool r; 20023 smallArrayt *self = allocG(rtSmallArrayt); 20024 20025 self->f->pushInt(self, 1); 20026 r = areAllEIntO(self); 20027 ck_assert(r); 20028 terminateO(self); 20029 20030 END_TEST 20031 20032 20033 START_TEST(areAllEStringSmallArrayT) 20034 20035 bool r; 20036 smallArrayt *self = allocG(rtSmallArrayt); 20037 20038 self->f->pushS(self, ""); 20039 r = areAllEStringO(self); 20040 ck_assert(r); 20041 terminateO(self); 20042 20043 END_TEST 20044 20045 20046 START_TEST(areAllEFaststringSmallArrayT) 20047 20048 bool r; 20049 smallArrayt *self = allocG(rtSmallArrayt); 20050 20051 self->f->pushS(self, ""); 20052 r = areAllEFaststringO(self); 20053 ck_assert(!r); 20054 terminateO(self); 20055 20056 END_TEST 20057 20058 20059 START_TEST(areAllEArraySmallArrayT) 20060 20061 bool r; 20062 smallArrayt *self = allocG(rtSmallArrayt); 20063 20064 createSmallArray(a); 20065 self->f->pushArray(self, &a); 20066 r = areAllEArrayO(self); 20067 ck_assert(r); 20068 terminateO(self); 20069 20070 END_TEST 20071 20072 20073 START_TEST(areAllEBytesSmallArrayT) 20074 20075 bool r; 20076 smallArrayt *self = allocG(rtSmallArrayt); 20077 20078 createSmallBytes(b); 20079 self->f->pushSmallBytes(self, &b); 20080 r = areAllEBytesO(self); 20081 ck_assert(r); 20082 terminateO(self); 20083 20084 END_TEST 20085 20086 20087 START_TEST(allocSmallArrayGT) 20088 20089 smallArrayt *self = allocSmallArrayG(self); 20090 20091 ck_assert_ptr_ne(self, NULL); 20092 char *s = toStringO(self); 20093 ck_assert_str_eq(s, "[]"); 20094 free(s); 20095 terminateO(self); 20096 20097 END_TEST 20098 20099 20100 START_TEST(duplicateSmallArrayGT) 20101 20102 smallArrayt* r; 20103 smallArrayt *self = allocG(rtSmallArrayt); 20104 20105 self->f->pushInt(self, 1); 20106 r = duplicateSmallArrayG(self); 20107 char *s = toStringO(r); 20108 terminateO(r); 20109 ck_assert_str_eq(s, "[1]"); 20110 free(s); 20111 terminateO(self); 20112 20113 END_TEST 20114 20115 20116 START_TEST(freeSmallArrayGT) 20117 20118 smallArrayt *self = allocG(rtSmallArrayt); 20119 20120 self->f->pushInt(self, 1); 20121 freeSmallArrayG(self); 20122 char *s = toStringO(self); 20123 ck_assert_str_eq(s, "[]"); 20124 free(s); 20125 terminateO(self); 20126 20127 END_TEST 20128 20129 20130 START_TEST(fromArraySmallArrayGT) 20131 20132 smallArrayt* r; 20133 smallArrayt *self = allocG(rtSmallArrayt); 20134 20135 char *array[] = {"1", "22", "333"}; 20136 r = fromArraySmallArrayG(self, array, 3); 20137 ck_assert_ptr_ne(r, NULL); 20138 char *s = toStringO(r); 20139 ck_assert_str_eq(s, "[\"1\",\"22\",\"333\"]"); 20140 free(s); 20141 terminateO(self); 20142 20143 END_TEST 20144 20145 20146 START_TEST(fromCArraySmallArrayGT) 20147 20148 smallArrayt* r; 20149 smallArrayt *self = allocG(rtSmallArrayt); 20150 20151 const char *array[] = {"1", "22", "333"}; 20152 r = fromCArraySmallArrayG(self, array, 3); 20153 ck_assert_ptr_ne(r, NULL); 20154 char *s = toStringO(r); 20155 ck_assert_str_eq(s, "[\"1\",\"22\",\"333\"]"); 20156 free(s); 20157 terminateO(self); 20158 20159 END_TEST 20160 20161 20162 START_TEST(setFromSmallArrayGT) 20163 20164 smallArrayt* r; 20165 smallArrayt *self = allocG(rtSmallArrayt); 20166 20167 char *array[] = {"1", "22", "333", NULL}; 20168 r = setFromSmallArrayG(self, array); 20169 ck_assert_ptr_ne(r, NULL); 20170 char *s = toStringO(r); 20171 ck_assert_str_eq(s, "[\"1\",\"22\",\"333\"]"); 20172 free(s); 20173 terminateO(self); 20174 20175 END_TEST 20176 20177 20178 START_TEST(setFromCSmallArrayGT) 20179 20180 smallArrayt *r; 20181 smallArrayt *self = allocG(rtSmallArrayt); 20182 20183 const char *array[] = {"1", "22", "333", NULL}; 20184 r = setFromCSmallArrayG(self, array); 20185 ck_assert_ptr_ne(r, NULL); 20186 char *s = toStringO(r); 20187 ck_assert_str_eq(s, "[\"1\",\"22\",\"333\"]"); 20188 free(s); 20189 terminateO(self); 20190 20191 END_TEST 20192 20193 20194 START_TEST(pushSmallArrayGT) 20195 20196 smallArrayt* r; 20197 smallArrayt *self = allocG(rtSmallArrayt); 20198 baset *value = (baset*) allocSmallInt(1); 20199 20200 r = pushSmallArrayG(self, value); 20201 ck_assert_ptr_ne(r, null); 20202 finishO(value); 20203 char *s = toStringO(r); 20204 ck_assert_str_eq(s, "[1]"); 20205 free(s); 20206 terminateO(self); 20207 20208 END_TEST 20209 20210 20211 START_TEST(pushUndefinedSmallArrayGT) 20212 20213 smallArrayt* r; 20214 smallArrayt *self = allocG(rtSmallArrayt); 20215 20216 r = pushUndefinedSmallArrayG(self, NULL); 20217 ck_assert_ptr_ne(r, null); 20218 char *s = toStringO(r); 20219 ck_assert_str_eq(s, "[null]"); 20220 free(s); 20221 terminateO(self); 20222 20223 END_TEST 20224 20225 20226 START_TEST(pushBoolSmallArrayGT) 20227 20228 smallArrayt* r; 20229 smallArrayt *self = allocG(rtSmallArrayt); 20230 20231 r = pushBoolSmallArrayG(self, true); 20232 ck_assert_ptr_ne(r, null); 20233 char *s = toStringO(r); 20234 ck_assert_str_eq(s, "[true]"); 20235 free(s); 20236 terminateO(self); 20237 20238 END_TEST 20239 20240 20241 START_TEST(pushDoubleSmallArrayGT) 20242 20243 smallArrayt* r; 20244 smallArrayt *self = allocG(rtSmallArrayt); 20245 20246 r = pushDoubleSmallArrayG(self, 1); 20247 ck_assert_ptr_ne(r, null); 20248 char *s = toStringO(r); 20249 ck_assert_str_eq(s, "[1.000000e+00]"); 20250 free(s); 20251 terminateO(self); 20252 20253 END_TEST 20254 20255 20256 START_TEST(pushIntSmallArrayGT) 20257 20258 smallArrayt* r; 20259 smallArrayt *self = allocG(rtSmallArrayt); 20260 20261 r = pushIntSmallArrayG(self, 1); 20262 ck_assert_ptr_ne(r, null); 20263 char *s = toStringO(r); 20264 ck_assert_str_eq(s, "[1]"); 20265 free(s); 20266 terminateO(self); 20267 20268 END_TEST 20269 20270 20271 START_TEST(pushSSmallArrayGT) 20272 20273 smallArrayt* r; 20274 smallArrayt *self = allocG(rtSmallArrayt); 20275 20276 r = pushSSmallArrayG(self, "qwe"); 20277 ck_assert_ptr_ne(r, null); 20278 char *s = toStringO(r); 20279 ck_assert_str_eq(s, "[\"qwe\"]"); 20280 free(s); 20281 terminateO(self); 20282 20283 END_TEST 20284 20285 20286 START_TEST(pushCharSmallArrayGT) 20287 20288 smallArrayt* r; 20289 smallArrayt *self = allocG(rtSmallArrayt); 20290 20291 r = pushCharSmallArrayG(self, 'Q'); 20292 ck_assert_ptr_ne(r, null); 20293 char *s = toStringO(r); 20294 ck_assert_str_eq(s, "[\"Q\"]"); 20295 free(s); 20296 terminateO(self); 20297 20298 END_TEST 20299 20300 20301 START_TEST(pushDictSmallArrayGT) 20302 20303 smallArrayt* r; 20304 smallArrayt *self = allocG(rtSmallArrayt); 20305 smallDictt *dict = allocSmallDict(); 20306 20307 r = pushDictSmallArrayG(self, dict); 20308 ck_assert_ptr_ne(r, null); 20309 finishO(dict); 20310 char *s = toStringO(r); 20311 ck_assert_str_eq(s, "[{}]"); 20312 free(s); 20313 terminateO(self); 20314 20315 END_TEST 20316 20317 20318 START_TEST(pushArraySmallArrayGT) 20319 20320 smallArrayt* r; 20321 smallArrayt *self = allocG(rtSmallArrayt); 20322 smallArrayt *array = allocSmallArray(); 20323 20324 r = pushArraySmallArrayG(self, array); 20325 ck_assert_ptr_ne(r, null); 20326 finishO(array); 20327 char *s = toStringO(r); 20328 ck_assert_str_eq(s, "[[]]"); 20329 free(s); 20330 terminateO(self); 20331 20332 END_TEST 20333 20334 20335 START_TEST(pushArraycSmallArrayGT) 20336 20337 smallArrayt* r; 20338 smallArrayt *self = allocG(rtSmallArrayt); 20339 char **array = listCreateS("a","bb"); 20340 20341 r = pushArraycSmallArrayG(self, array); 20342 ck_assert_ptr_ne(r, null); 20343 ck_assert_int_eq(lenO(r), 1); 20344 listFreeS(array); 20345 char *s = toStringO(r); 20346 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 20347 free(s); 20348 terminateO(self); 20349 20350 END_TEST 20351 20352 20353 START_TEST(pushCArraycSmallArrayGT) 20354 20355 smallArrayt* r; 20356 smallArrayt *self = allocG(rtSmallArrayt); 20357 const char *array[] = {"a", "bb", NULL}; 20358 20359 r = pushCArraycSmallArrayG(self, array); 20360 ck_assert_ptr_ne(r, null); 20361 ck_assert_int_eq(lenO(r), 1); 20362 char *s = toStringO(r); 20363 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 20364 free(s); 20365 terminateO(self); 20366 20367 END_TEST 20368 20369 20370 START_TEST(pushVoidSmallArrayGT) 20371 20372 smallArrayt* r; 20373 smallArrayt *self = allocG(rtSmallArrayt); 20374 20375 // NULL value 20376 r = pushVoidSmallArrayG(self, NULL); 20377 ck_assert_ptr_ne(r, null); 20378 char *s = toStringO(r); 20379 ck_assert_str_eq(s, "[null]"); 20380 free(s); 20381 // value 20382 r = pushVoidSmallArrayG(self, r); 20383 s = toStringO(r); 20384 ck_assert_str_eq(s, "[null,\"<data container>\"]"); 20385 free(s); 20386 terminateO(self); 20387 20388 END_TEST 20389 20390 20391 START_TEST(pushSmallBoolSmallArrayGT) 20392 20393 smallArrayt* r; 20394 smallArrayt *self = allocG(rtSmallArrayt); 20395 smallBoolt *value = allocSmallBool(true); 20396 20397 r = pushSmallBoolSmallArrayG(self, value); 20398 ck_assert_ptr_ne(r, null); 20399 finishO(value); 20400 char *s = toStringO(r); 20401 ck_assert_str_eq(s, "[true]"); 20402 free(s); 20403 terminateO(self); 20404 20405 END_TEST 20406 20407 20408 START_TEST(pushSmallBytesSmallArrayGT) 20409 20410 smallArrayt* r; 20411 smallArrayt *self = allocG(rtSmallArrayt); 20412 smallBytest *value = allocSmallBytes("qwe", 3); 20413 20414 r = pushSmallBytesSmallArrayG(self, value); 20415 ck_assert_ptr_ne(r, null); 20416 finishO(value); 20417 char *s = toStringO(r); 20418 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 20419 free(s); 20420 terminateO(self); 20421 20422 END_TEST 20423 20424 20425 START_TEST(pushSmallDoubleSmallArrayGT) 20426 20427 smallArrayt* r; 20428 smallArrayt *self = allocG(rtSmallArrayt); 20429 smallDoublet *value = allocSmallDouble(1); 20430 20431 r = pushSmallDoubleSmallArrayG(self, value); 20432 ck_assert_ptr_ne(r, null); 20433 finishO(value); 20434 char *s = toStringO(r); 20435 ck_assert_str_eq(s, "[1.000000e+00]"); 20436 free(s); 20437 terminateO(self); 20438 20439 END_TEST 20440 20441 20442 START_TEST(pushSmallIntSmallArrayGT) 20443 20444 smallArrayt* r; 20445 smallArrayt *self = allocG(rtSmallArrayt); 20446 smallIntt *value = allocSmallInt(1); 20447 20448 r = pushSmallIntSmallArrayG(self, value); 20449 ck_assert_ptr_ne(r, null); 20450 finishO(value); 20451 char *s = toStringO(r); 20452 ck_assert_str_eq(s, "[1]"); 20453 free(s); 20454 terminateO(self); 20455 20456 END_TEST 20457 20458 20459 START_TEST(pushSmallJsonSmallArrayGT) 20460 20461 smallArrayt* r; 20462 smallArrayt *self = allocG(rtSmallArrayt); 20463 smallJsont *value = allocSmallJson(); 20464 20465 r = pushSmallJsonSmallArrayG(self, value); 20466 ck_assert_ptr_ne(r, null); 20467 finishO(value); 20468 char *s = toStringO(r); 20469 ck_assert_str_eq(s, "[{}]"); 20470 free(s); 20471 terminateO(self); 20472 20473 END_TEST 20474 20475 20476 START_TEST(pushSmallStringSmallArrayGT) 20477 20478 smallArrayt* r; 20479 smallArrayt *self = allocG(rtSmallArrayt); 20480 smallStringt *string = allocSmallString("qwe"); 20481 20482 r = pushSmallStringSmallArrayG(self, string); 20483 ck_assert_ptr_ne(r, null); 20484 finishO(string); 20485 char *s = toStringO(r); 20486 ck_assert_str_eq(s, "[\"qwe\"]"); 20487 free(s); 20488 terminateO(self); 20489 20490 END_TEST 20491 20492 20493 START_TEST(pushSmallContainerSmallArrayGT) 20494 20495 smallArrayt* r; 20496 smallArrayt *self = allocG(rtSmallArrayt); 20497 20498 createSmallContainer(c); 20499 r = pushSmallContainerSmallArrayG(self, &c); 20500 ck_assert_ptr_ne(r, null); 20501 char *s = toStringO(r); 20502 ck_assert_str_eq(s, "[\"<data container>\"]"); 20503 free(s); 20504 terminateO(self); 20505 20506 END_TEST 20507 20508 20509 START_TEST(pushNFreeSmallArrayGT) 20510 20511 smallArrayt* r; 20512 smallArrayt *self = allocG(rtSmallArrayt); 20513 baset *value = (baset*) allocSmallInt(1); 20514 20515 r = pushNFreeSmallArrayG(self, value); 20516 ck_assert_ptr_ne(r, null); 20517 char *s = toStringO(r); 20518 ck_assert_str_eq(s, "[1]"); 20519 free(s); 20520 terminateO(self); 20521 20522 END_TEST 20523 20524 20525 START_TEST(pushNFreeUndefinedSmallArrayGT) 20526 20527 smallArrayt* r; 20528 smallArrayt *self = allocG(rtSmallArrayt); 20529 undefinedt *value = allocUndefined(); 20530 20531 r = pushNFreeUndefinedSmallArrayG(self, value); 20532 ck_assert_ptr_ne(r, null); 20533 char *s = toStringO(r); 20534 ck_assert_str_eq(s, "[null]"); 20535 free(s); 20536 terminateO(self); 20537 20538 END_TEST 20539 20540 20541 START_TEST(pushNFreeSSmallArrayGT) 20542 20543 smallArrayt* r; 20544 smallArrayt *self = allocG(rtSmallArrayt); 20545 20546 r = pushNFreeSSmallArrayG(self, strdup("qwe")); 20547 ck_assert_ptr_ne(r, null); 20548 char *s = toStringO(r); 20549 ck_assert_str_eq(s, "[\"qwe\"]"); 20550 free(s); 20551 terminateO(self); 20552 20553 END_TEST 20554 20555 20556 START_TEST(pushNFreeDictSmallArrayGT) 20557 20558 smallArrayt* r; 20559 smallArrayt *self = allocG(rtSmallArrayt); 20560 smallDictt *dict = allocSmallDict(); 20561 20562 r = pushNFreeDictSmallArrayG(self, dict); 20563 ck_assert_ptr_ne(r, null); 20564 char *s = toStringO(r); 20565 ck_assert_str_eq(s, "[{}]"); 20566 free(s); 20567 terminateO(self); 20568 20569 END_TEST 20570 20571 20572 START_TEST(pushNFreeArraySmallArrayGT) 20573 20574 smallArrayt* r; 20575 smallArrayt *self = allocG(rtSmallArrayt); 20576 smallArrayt *array = allocSmallArray(); 20577 20578 r = pushNFreeArraySmallArrayG(self, array); 20579 ck_assert_ptr_ne(r, null); 20580 char *s = toStringO(r); 20581 ck_assert_str_eq(s, "[[]]"); 20582 free(s); 20583 terminateO(self); 20584 20585 END_TEST 20586 20587 20588 START_TEST(pushNFreeArraycSmallArrayGT) 20589 20590 smallArrayt* r; 20591 smallArrayt *self = allocG(rtSmallArrayt); 20592 char **array = listCreateS("a","bb"); 20593 20594 r = pushNFreeArraycSmallArrayG(self, array); 20595 ck_assert_ptr_ne(r, null); 20596 ck_assert_int_eq(lenO(r), 1); 20597 char *s = toStringO(r); 20598 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 20599 free(s); 20600 terminateO(self); 20601 20602 END_TEST 20603 20604 20605 START_TEST(pushNFreeSmallBoolSmallArrayGT) 20606 20607 smallArrayt* r; 20608 smallArrayt *self = allocG(rtSmallArrayt); 20609 smallBoolt *value = allocSmallBool(true); 20610 20611 r = pushNFreeSmallBoolSmallArrayG(self, value); 20612 ck_assert_ptr_ne(r, null); 20613 char *s = toStringO(r); 20614 ck_assert_str_eq(s, "[true]"); 20615 free(s); 20616 terminateO(self); 20617 20618 END_TEST 20619 20620 20621 START_TEST(pushNFreeSmallBytesSmallArrayGT) 20622 20623 smallArrayt* r; 20624 smallArrayt *self = allocG(rtSmallArrayt); 20625 smallBytest *value = allocSmallBytes("qwe", 3); 20626 20627 r = pushNFreeSmallBytesSmallArrayG(self, value); 20628 ck_assert_ptr_ne(r, null); 20629 char *s = toStringO(r); 20630 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 20631 free(s); 20632 terminateO(self); 20633 20634 END_TEST 20635 20636 20637 START_TEST(pushNFreeSmallDoubleSmallArrayGT) 20638 20639 smallArrayt* r; 20640 smallArrayt *self = allocG(rtSmallArrayt); 20641 smallDoublet *value = allocSmallDouble(1); 20642 20643 r = pushNFreeSmallDoubleSmallArrayG(self, value); 20644 ck_assert_ptr_ne(r, null); 20645 char *s = toStringO(r); 20646 ck_assert_str_eq(s, "[1.000000e+00]"); 20647 free(s); 20648 terminateO(self); 20649 20650 END_TEST 20651 20652 20653 START_TEST(pushNFreeSmallIntSmallArrayGT) 20654 20655 smallArrayt* r; 20656 smallArrayt *self = allocG(rtSmallArrayt); 20657 smallIntt *value = allocSmallInt(1); 20658 20659 r = pushNFreeSmallIntSmallArrayG(self, value); 20660 ck_assert_ptr_ne(r, null); 20661 char *s = toStringO(r); 20662 ck_assert_str_eq(s, "[1]"); 20663 free(s); 20664 terminateO(self); 20665 20666 END_TEST 20667 20668 20669 START_TEST(pushNFreeSmallJsonSmallArrayGT) 20670 20671 smallArrayt* r; 20672 smallArrayt *self = allocG(rtSmallArrayt); 20673 smallJsont *value = allocSmallJson(); 20674 20675 r = pushNFreeSmallJsonSmallArrayG(self, value); 20676 ck_assert_ptr_ne(r, null); 20677 char *s = toStringO(r); 20678 ck_assert_str_eq(s, "[{}]"); 20679 free(s); 20680 terminateO(self); 20681 20682 END_TEST 20683 20684 20685 START_TEST(pushNFreeSmallStringSmallArrayGT) 20686 20687 smallArrayt* r; 20688 smallArrayt *self = allocG(rtSmallArrayt); 20689 smallStringt *string = allocSmallString("qwe"); 20690 20691 r = pushNFreeSmallStringSmallArrayG(self, string); 20692 ck_assert_ptr_ne(r, null); 20693 char *s = toStringO(r); 20694 ck_assert_str_eq(s, "[\"qwe\"]"); 20695 free(s); 20696 terminateO(self); 20697 20698 END_TEST 20699 20700 20701 START_TEST(pushNFreeSmallContainerSmallArrayGT) 20702 20703 smallArrayt* r; 20704 smallArrayt *self = allocG(rtSmallArrayt); 20705 20706 createAllocateSmallContainer(c); 20707 r = pushNFreeSmallContainerSmallArrayG(self, c); 20708 ck_assert_ptr_ne(r, null); 20709 char *s = toStringO(r); 20710 ck_assert_str_eq(s, "[\"<data container>\"]"); 20711 free(s); 20712 terminateO(self); 20713 20714 END_TEST 20715 20716 20717 START_TEST(popSmallArrayGT) 20718 20719 baset* r; 20720 smallArrayt *self = allocG(rtSmallArrayt); 20721 20722 smallArrayt *r2 = self->f->pushInt(self, 1); 20723 ck_assert_ptr_ne(r2, null); 20724 r = popSmallArrayG(self, NULL); 20725 ck_assert_ptr_ne(r, null); 20726 char *s = toStringO(r); 20727 terminateO(r); 20728 ck_assert_str_eq(s, "1"); 20729 free(s); 20730 // empty array 20731 self->f->pushUndefined(self); 20732 delElemO(self, -1); 20733 r = popSmallArrayG(self, NULL); 20734 ck_assert_ptr_eq(r, null); 20735 terminateO(self); 20736 20737 END_TEST 20738 20739 20740 START_TEST(popUndefinedSmallArrayGT) 20741 20742 undefinedt* r; 20743 smallArrayt *self = allocG(rtSmallArrayt); 20744 20745 smallArrayt *r2 = self->f->pushUndefined(self); 20746 ck_assert_ptr_ne(r2, null); 20747 r = popUndefinedSmallArrayG(self, null); 20748 ck_assert_ptr_ne(r, null); 20749 char *s = toStringO(r); 20750 terminateO(r); 20751 ck_assert_str_eq(s, "null"); 20752 free(s); 20753 terminateO(self); 20754 20755 END_TEST 20756 20757 20758 START_TEST(popBoolSmallArrayGT) 20759 20760 bool r; 20761 smallArrayt *self = allocG(rtSmallArrayt); 20762 20763 smallArrayt *r2 = self->f->pushBool(self, TRUE); 20764 ck_assert_ptr_ne(r2, null); 20765 r = popBoolSmallArrayG(self, null); 20766 ck_assert(r); 20767 terminateO(self); 20768 20769 END_TEST 20770 20771 20772 START_TEST(popDoubleSmallArrayGT) 20773 20774 double r; 20775 smallArrayt *self = allocG(rtSmallArrayt); 20776 20777 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 20778 ck_assert_ptr_ne(r2, null); 20779 r = popDoubleSmallArrayG(self, 0); 20780 ck_assert(r==2.0); 20781 terminateO(self); 20782 20783 END_TEST 20784 20785 20786 START_TEST(popIntSmallArrayGT) 20787 20788 int64_t r; 20789 smallArrayt *self = allocG(rtSmallArrayt); 20790 20791 smallArrayt *r2 = self->f->pushInt(self, 2); 20792 ck_assert_ptr_ne(r2, null); 20793 r = popIntSmallArrayG(self, 0); 20794 ck_assert_int_eq(r, 2); 20795 terminateO(self); 20796 20797 END_TEST 20798 20799 20800 START_TEST(popInt32SmallArrayGT) 20801 20802 int32_t r; 20803 smallArrayt *self = allocG(rtSmallArrayt); 20804 20805 smallArrayt *r2 = self->f->pushInt(self, 2); 20806 ck_assert_ptr_ne(r2, null); 20807 r = popInt32SmallArrayG(self, 0); 20808 ck_assert_int_eq(r, 2); 20809 terminateO(self); 20810 20811 END_TEST 20812 20813 20814 START_TEST(popUintSmallArrayGT) 20815 20816 uint64_t r; 20817 smallArrayt *self = allocG(rtSmallArrayt); 20818 20819 smallArrayt *r2 = self->f->pushInt(self, 2); 20820 ck_assert_ptr_ne(r2, null); 20821 r = popUintSmallArrayG(self, 0); 20822 ck_assert_int_eq(r, 2); 20823 terminateO(self); 20824 20825 END_TEST 20826 20827 20828 START_TEST(popUint32SmallArrayGT) 20829 20830 uint32_t r; 20831 smallArrayt *self = allocG(rtSmallArrayt); 20832 20833 smallArrayt *r2 = self->f->pushInt(self, 2); 20834 ck_assert_ptr_ne(r2, null); 20835 r = popUint32SmallArrayG(self, 0); 20836 ck_assert_int_eq(r, 2); 20837 terminateO(self); 20838 20839 END_TEST 20840 20841 20842 START_TEST(popSSmallArrayGT) 20843 20844 char* r; 20845 smallArrayt *self = allocG(rtSmallArrayt); 20846 20847 smallArrayt *r2 = self->f->pushS(self, "2"); 20848 ck_assert_ptr_ne(r2, null); 20849 r = popSSmallArrayG(self, null); 20850 ck_assert_str_eq(r, "2"); 20851 free(r); 20852 terminateO(self); 20853 20854 END_TEST 20855 20856 20857 START_TEST(popDictSmallArrayGT) 20858 20859 smallDictt* r; 20860 smallArrayt *self = allocG(rtSmallArrayt); 20861 20862 createSmallDict(d); 20863 smallArrayt *r2 = self->f->pushDict(self, &d); 20864 ck_assert_ptr_ne(r2, null); 20865 r = popDictSmallArrayG(self, null); 20866 ck_assert_ptr_ne(r, null); 20867 char *s = toStringO(r); 20868 ck_assert_str_eq(s, "{}"); 20869 free(s); 20870 terminateO(r); 20871 terminateO(self); 20872 20873 END_TEST 20874 20875 20876 START_TEST(popArraySmallArrayGT) 20877 20878 smallArrayt* r; 20879 smallArrayt *self = allocG(rtSmallArrayt); 20880 20881 createSmallArray(a); 20882 smallArrayt *r2 = self->f->pushArray(self, &a); 20883 ck_assert_ptr_ne(r2, null); 20884 r = popArraySmallArrayG(self, null); 20885 ck_assert_ptr_ne(r, null); 20886 char *s = toStringO(r); 20887 ck_assert_str_eq(s, "[]"); 20888 free(s); 20889 terminateO(r); 20890 terminateO(self); 20891 20892 END_TEST 20893 20894 20895 START_TEST(popSmallBoolSmallArrayGT) 20896 20897 smallBoolt* r; 20898 smallArrayt *self = allocG(rtSmallArrayt); 20899 20900 smallArrayt *r2 = self->f->pushBool(self, true); 20901 ck_assert_ptr_ne(r2, null); 20902 r = popSmallBoolSmallArrayG(self, null); 20903 ck_assert_ptr_ne(r, null); 20904 char *s = toStringO(r); 20905 ck_assert_str_eq(s, "true"); 20906 free(s); 20907 terminateO(r); 20908 terminateO(self); 20909 20910 END_TEST 20911 20912 20913 START_TEST(popSmallBytesSmallArrayGT) 20914 20915 smallBytest* r; 20916 smallArrayt *self = allocG(rtSmallArrayt); 20917 20918 createSmallBytes(b); 20919 smallArrayt *r2 = self->f->pushSmallBytes(self, &b); 20920 ck_assert_ptr_ne(r2, null); 20921 r = popSmallBytesSmallArrayG(self, null); 20922 ck_assert_ptr_ne(r, null); 20923 char *s = toStringO(r); 20924 ck_assert_str_eq(s, "[]"); 20925 free(s); 20926 terminateO(r); 20927 terminateO(self); 20928 20929 END_TEST 20930 20931 20932 START_TEST(popSmallDoubleSmallArrayGT) 20933 20934 smallDoublet* r; 20935 smallArrayt *self = allocG(rtSmallArrayt); 20936 20937 smallArrayt *r2 = self->f->pushDouble(self, 1); 20938 ck_assert_ptr_ne(r2, null); 20939 r = popSmallDoubleSmallArrayG(self, null); 20940 ck_assert_ptr_ne(r, null); 20941 char *s = toStringO(r); 20942 ck_assert_str_eq(s, "1.000000e+00"); 20943 free(s); 20944 terminateO(r); 20945 terminateO(self); 20946 20947 END_TEST 20948 20949 20950 START_TEST(popSmallIntSmallArrayGT) 20951 20952 smallIntt* r; 20953 smallArrayt *self = allocG(rtSmallArrayt); 20954 20955 smallArrayt *r2 = self->f->pushInt(self, 1); 20956 ck_assert_ptr_ne(r2, null); 20957 r = popSmallIntSmallArrayG(self, null); 20958 ck_assert_ptr_ne(r, null); 20959 char *s = toStringO(r); 20960 ck_assert_str_eq(s, "1"); 20961 free(s); 20962 terminateO(r); 20963 terminateO(self); 20964 20965 END_TEST 20966 20967 20968 START_TEST(popSmallJsonSmallArrayGT) 20969 20970 smallJsont* r; 20971 smallArrayt *self = allocG(rtSmallArrayt); 20972 20973 createSmallJson(j); 20974 smallArrayt *r2 = self->f->pushSmallJson(self, &j); 20975 ck_assert_ptr_ne(r2, null); 20976 r = popSmallJsonSmallArrayG(self, null); 20977 ck_assert_ptr_ne(r, null); 20978 char *s = toStringO(r); 20979 ck_assert_str_eq(s, "{}"); 20980 free(s); 20981 terminateO(r); 20982 terminateO(self); 20983 20984 END_TEST 20985 20986 20987 START_TEST(popSmallStringSmallArrayGT) 20988 20989 smallStringt* r; 20990 smallArrayt *self = allocG(rtSmallArrayt); 20991 20992 createSmallString(S); 20993 smallArrayt *r2 = self->f->pushSmallString(self, &S); 20994 ck_assert_ptr_ne(r2, null); 20995 r = popSmallStringSmallArrayG(self, null); 20996 ck_assert_ptr_ne(r, null); 20997 char *s = toStringO(r); 20998 ck_assert_str_eq(s, ""); 20999 free(s); 21000 terminateO(r); 21001 terminateO(self); 21002 21003 END_TEST 21004 21005 21006 START_TEST(popVoidSmallArrayGT) 21007 21008 void* r; 21009 smallArrayt *self = allocG(rtSmallArrayt); 21010 21011 createSmallContainer(c); 21012 setValO(&c, &r); 21013 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 21014 ck_assert_ptr_ne(r2, null); 21015 r = popVoidSmallArrayG(self, null); 21016 ck_assert_ptr_eq(r, &r); 21017 terminateO(self); 21018 21019 END_TEST 21020 21021 21022 START_TEST(popSmallContainerSmallArrayGT) 21023 21024 smallContainert* r; 21025 smallArrayt *self = allocG(rtSmallArrayt); 21026 21027 createSmallContainer(c); 21028 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 21029 ck_assert_ptr_ne(r2, null); 21030 r = popSmallContainerSmallArrayG(self, null); 21031 ck_assert_ptr_ne(r, null); 21032 char *s = toStringO(r); 21033 ck_assert_str_eq(s, "<data smallContainer>"); 21034 free(s); 21035 terminateO(r); 21036 terminateO(self); 21037 21038 END_TEST 21039 21040 21041 START_TEST(prependSmallArrayGT) 21042 21043 smallArrayt* r; 21044 smallArrayt *self = allocG(rtSmallArrayt); 21045 baset *value = (baset*) allocSmallInt(1); 21046 21047 r = prependSmallArrayG(self, value); 21048 ck_assert_ptr_ne(r, null); 21049 finishO(value); 21050 char *s = toStringO(r); 21051 ck_assert_str_eq(s, "[1]"); 21052 free(s); 21053 terminateO(self); 21054 21055 END_TEST 21056 21057 21058 START_TEST(prependUndefinedSmallArrayGT) 21059 21060 smallArrayt* r; 21061 smallArrayt *self = allocG(rtSmallArrayt); 21062 21063 r = prependUndefinedSmallArrayG(self, NULL); 21064 ck_assert_ptr_ne(r, null); 21065 char *s = toStringO(r); 21066 ck_assert_str_eq(s, "[null]"); 21067 free(s); 21068 terminateO(self); 21069 21070 END_TEST 21071 21072 21073 START_TEST(prependBoolSmallArrayGT) 21074 21075 smallArrayt* r; 21076 smallArrayt *self = allocG(rtSmallArrayt); 21077 21078 r = prependBoolSmallArrayG(self, true); 21079 ck_assert_ptr_ne(r, null); 21080 char *s = toStringO(r); 21081 ck_assert_str_eq(s, "[true]"); 21082 free(s); 21083 terminateO(self); 21084 21085 END_TEST 21086 21087 21088 START_TEST(prependDoubleSmallArrayGT) 21089 21090 smallArrayt* r; 21091 smallArrayt *self = allocG(rtSmallArrayt); 21092 21093 r = prependDoubleSmallArrayG(self, 1); 21094 ck_assert_ptr_ne(r, null); 21095 char *s = toStringO(r); 21096 ck_assert_str_eq(s, "[1.000000e+00]"); 21097 free(s); 21098 terminateO(self); 21099 21100 END_TEST 21101 21102 21103 START_TEST(prependIntSmallArrayGT) 21104 21105 smallArrayt* r; 21106 smallArrayt *self = allocG(rtSmallArrayt); 21107 21108 r = prependIntSmallArrayG(self, 1); 21109 ck_assert_ptr_ne(r, null); 21110 char *s = toStringO(r); 21111 ck_assert_str_eq(s, "[1]"); 21112 free(s); 21113 terminateO(self); 21114 21115 END_TEST 21116 21117 21118 START_TEST(prependSSmallArrayGT) 21119 21120 smallArrayt* r; 21121 smallArrayt *self = allocG(rtSmallArrayt); 21122 21123 r = prependSSmallArrayG(self, "qwe"); 21124 ck_assert_ptr_ne(r, null); 21125 char *s = toStringO(r); 21126 ck_assert_str_eq(s, "[\"qwe\"]"); 21127 free(s); 21128 terminateO(self); 21129 21130 END_TEST 21131 21132 21133 START_TEST(prependCharSmallArrayGT) 21134 21135 smallArrayt* r; 21136 smallArrayt *self = allocG(rtSmallArrayt); 21137 21138 r = prependCharSmallArrayG(self, 'Q'); 21139 ck_assert_ptr_ne(r, null); 21140 char *s = toStringO(r); 21141 ck_assert_str_eq(s, "[\"Q\"]"); 21142 free(s); 21143 terminateO(self); 21144 21145 END_TEST 21146 21147 21148 START_TEST(prependDictSmallArrayGT) 21149 21150 smallArrayt* r; 21151 smallArrayt *self = allocG(rtSmallArrayt); 21152 smallDictt *dict = allocSmallDict(); 21153 21154 r = prependDictSmallArrayG(self, dict); 21155 ck_assert_ptr_ne(r, null); 21156 finishO(dict); 21157 char *s = toStringO(r); 21158 ck_assert_str_eq(s, "[{}]"); 21159 free(s); 21160 terminateO(self); 21161 21162 END_TEST 21163 21164 21165 START_TEST(prependArraySmallArrayGT) 21166 21167 smallArrayt* r; 21168 smallArrayt *self = allocG(rtSmallArrayt); 21169 smallArrayt *array = allocSmallArray(); 21170 21171 r = prependArraySmallArrayG(self, array); 21172 ck_assert_ptr_ne(r, null); 21173 finishO(array); 21174 char *s = toStringO(r); 21175 ck_assert_str_eq(s, "[[]]"); 21176 free(s); 21177 terminateO(self); 21178 21179 END_TEST 21180 21181 21182 START_TEST(prependArraycSmallArrayGT) 21183 21184 smallArrayt* r; 21185 smallArrayt *self = allocG(rtSmallArrayt); 21186 char **array = listCreateS("a","bb"); 21187 21188 r = prependArraycSmallArrayG(self, array); 21189 ck_assert_ptr_ne(r, null); 21190 ck_assert_int_eq(lenO(r), 1); 21191 listFreeS(array); 21192 char *s = toStringO(r); 21193 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 21194 free(s); 21195 terminateO(self); 21196 21197 END_TEST 21198 21199 21200 START_TEST(prependCArraycSmallArrayGT) 21201 21202 smallArrayt* r; 21203 smallArrayt *self = allocG(rtSmallArrayt); 21204 const char *array[] = {"a", "bb", NULL}; 21205 21206 r = prependCArraycSmallArrayG(self, array); 21207 ck_assert_ptr_ne(r, null); 21208 ck_assert_int_eq(lenO(r), 1); 21209 char *s = toStringO(r); 21210 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 21211 free(s); 21212 terminateO(self); 21213 21214 END_TEST 21215 21216 21217 START_TEST(prependVoidSmallArrayGT) 21218 21219 smallArrayt* r; 21220 smallArrayt *self = allocG(rtSmallArrayt); 21221 21222 // NULL value 21223 r = prependVoidSmallArrayG(self, NULL); 21224 ck_assert_ptr_ne(r, null); 21225 char *s = toStringO(r); 21226 ck_assert_str_eq(s, "[null]"); 21227 free(s); 21228 // value 21229 r = prependVoidSmallArrayG(self, r); 21230 s = toStringO(r); 21231 ck_assert_str_eq(s, "[\"<data container>\",null]"); 21232 free(s); 21233 terminateO(self); 21234 21235 END_TEST 21236 21237 21238 START_TEST(prependSmallBoolSmallArrayGT) 21239 21240 smallArrayt* r; 21241 smallArrayt *self = allocG(rtSmallArrayt); 21242 smallBoolt *value = allocSmallBool(true); 21243 21244 r = prependSmallBoolSmallArrayG(self, value); 21245 ck_assert_ptr_ne(r, null); 21246 finishO(value); 21247 char *s = toStringO(r); 21248 ck_assert_str_eq(s, "[true]"); 21249 free(s); 21250 terminateO(self); 21251 21252 END_TEST 21253 21254 21255 START_TEST(prependSmallBytesSmallArrayGT) 21256 21257 smallArrayt* r; 21258 smallArrayt *self = allocG(rtSmallArrayt); 21259 smallBytest *value = allocSmallBytes("qwe", 3); 21260 21261 r = prependSmallBytesSmallArrayG(self, value); 21262 ck_assert_ptr_ne(r, null); 21263 finishO(value); 21264 char *s = toStringO(r); 21265 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 21266 free(s); 21267 terminateO(self); 21268 21269 END_TEST 21270 21271 21272 START_TEST(prependSmallDoubleSmallArrayGT) 21273 21274 smallArrayt* r; 21275 smallArrayt *self = allocG(rtSmallArrayt); 21276 smallDoublet *value = allocSmallDouble(1); 21277 21278 r = prependSmallDoubleSmallArrayG(self, value); 21279 ck_assert_ptr_ne(r, null); 21280 finishO(value); 21281 char *s = toStringO(r); 21282 ck_assert_str_eq(s, "[1.000000e+00]"); 21283 free(s); 21284 terminateO(self); 21285 21286 END_TEST 21287 21288 21289 START_TEST(prependSmallIntSmallArrayGT) 21290 21291 smallArrayt* r; 21292 smallArrayt *self = allocG(rtSmallArrayt); 21293 smallIntt *value = allocSmallInt(1); 21294 21295 r = prependSmallIntSmallArrayG(self, value); 21296 ck_assert_ptr_ne(r, null); 21297 finishO(value); 21298 char *s = toStringO(r); 21299 ck_assert_str_eq(s, "[1]"); 21300 free(s); 21301 terminateO(self); 21302 21303 END_TEST 21304 21305 21306 START_TEST(prependSmallJsonSmallArrayGT) 21307 21308 smallArrayt* r; 21309 smallArrayt *self = allocG(rtSmallArrayt); 21310 smallJsont *value = allocSmallJson(); 21311 21312 r = prependSmallJsonSmallArrayG(self, value); 21313 ck_assert_ptr_ne(r, null); 21314 finishO(value); 21315 char *s = toStringO(r); 21316 ck_assert_str_eq(s, "[{}]"); 21317 free(s); 21318 terminateO(self); 21319 21320 END_TEST 21321 21322 21323 START_TEST(prependSmallStringSmallArrayGT) 21324 21325 smallArrayt* r; 21326 smallArrayt *self = allocG(rtSmallArrayt); 21327 smallStringt *string = allocSmallString("qwe"); 21328 21329 r = prependSmallStringSmallArrayG(self, string); 21330 ck_assert_ptr_ne(r, null); 21331 finishO(string); 21332 char *s = toStringO(r); 21333 ck_assert_str_eq(s, "[\"qwe\"]"); 21334 free(s); 21335 terminateO(self); 21336 21337 END_TEST 21338 21339 21340 START_TEST(prependSmallContainerSmallArrayGT) 21341 21342 smallArrayt* r; 21343 smallArrayt *self = allocG(rtSmallArrayt); 21344 21345 createSmallContainer(c); 21346 r = prependSmallContainerSmallArrayG(self, &c); 21347 ck_assert_ptr_ne(r, null); 21348 char *s = toStringO(r); 21349 ck_assert_str_eq(s, "[\"<data container>\"]"); 21350 free(s); 21351 terminateO(self); 21352 21353 END_TEST 21354 21355 21356 START_TEST(prependNFreeSmallArrayGT) 21357 21358 smallArrayt* r; 21359 smallArrayt *self = allocG(rtSmallArrayt); 21360 baset *value = (baset*) allocSmallInt(1); 21361 21362 r = prependNFreeSmallArrayG(self, value); 21363 ck_assert_ptr_ne(r, null); 21364 char *s = toStringO(r); 21365 ck_assert_str_eq(s, "[1]"); 21366 free(s); 21367 terminateO(self); 21368 21369 END_TEST 21370 21371 21372 START_TEST(prependNFreeUndefinedSmallArrayGT) 21373 21374 smallArrayt* r; 21375 smallArrayt *self = allocG(rtSmallArrayt); 21376 undefinedt *value = allocUndefined(); 21377 21378 r = prependNFreeUndefinedSmallArrayG(self, value); 21379 ck_assert_ptr_ne(r, null); 21380 char *s = toStringO(r); 21381 ck_assert_str_eq(s, "[null]"); 21382 free(s); 21383 terminateO(self); 21384 21385 END_TEST 21386 21387 21388 START_TEST(prependNFreeSSmallArrayGT) 21389 21390 smallArrayt* r; 21391 smallArrayt *self = allocG(rtSmallArrayt); 21392 21393 r = prependNFreeSSmallArrayG(self, strdup("qwe")); 21394 ck_assert_ptr_ne(r, null); 21395 char *s = toStringO(r); 21396 ck_assert_str_eq(s, "[\"qwe\"]"); 21397 free(s); 21398 terminateO(self); 21399 21400 END_TEST 21401 21402 21403 START_TEST(prependNFreeDictSmallArrayGT) 21404 21405 smallArrayt* r; 21406 smallArrayt *self = allocG(rtSmallArrayt); 21407 smallDictt *dict = allocSmallDict(); 21408 21409 r = prependNFreeDictSmallArrayG(self, dict); 21410 ck_assert_ptr_ne(r, null); 21411 char *s = toStringO(r); 21412 ck_assert_str_eq(s, "[{}]"); 21413 free(s); 21414 terminateO(self); 21415 21416 END_TEST 21417 21418 21419 START_TEST(prependNFreeArraySmallArrayGT) 21420 21421 smallArrayt* r; 21422 smallArrayt *self = allocG(rtSmallArrayt); 21423 smallArrayt *array = allocSmallArray(); 21424 21425 r = prependNFreeArraySmallArrayG(self, array); 21426 ck_assert_ptr_ne(r, null); 21427 char *s = toStringO(r); 21428 ck_assert_str_eq(s, "[[]]"); 21429 free(s); 21430 terminateO(self); 21431 21432 END_TEST 21433 21434 21435 START_TEST(prependNFreeArraycSmallArrayGT) 21436 21437 smallArrayt* r; 21438 smallArrayt *self = allocG(rtSmallArrayt); 21439 char **array = listCreateS("a","bb"); 21440 21441 r = prependNFreeArraycSmallArrayG(self, array); 21442 ck_assert_ptr_ne(r, null); 21443 ck_assert_int_eq(lenO(r), 1); 21444 char *s = toStringO(r); 21445 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 21446 free(s); 21447 terminateO(self); 21448 21449 END_TEST 21450 21451 21452 START_TEST(prependNFreeSmallBoolSmallArrayGT) 21453 21454 smallArrayt* r; 21455 smallArrayt *self = allocG(rtSmallArrayt); 21456 smallBoolt *value = allocSmallBool(true); 21457 21458 r = prependNFreeSmallBoolSmallArrayG(self, value); 21459 ck_assert_ptr_ne(r, null); 21460 char *s = toStringO(r); 21461 ck_assert_str_eq(s, "[true]"); 21462 free(s); 21463 terminateO(self); 21464 21465 END_TEST 21466 21467 21468 START_TEST(prependNFreeSmallBytesSmallArrayGT) 21469 21470 smallArrayt* r; 21471 smallArrayt *self = allocG(rtSmallArrayt); 21472 smallBytest *value = allocSmallBytes("qwe", 3); 21473 21474 r = prependNFreeSmallBytesSmallArrayG(self, value); 21475 ck_assert_ptr_ne(r, null); 21476 char *s = toStringO(r); 21477 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 21478 free(s); 21479 terminateO(self); 21480 21481 END_TEST 21482 21483 21484 START_TEST(prependNFreeSmallDoubleSmallArrayGT) 21485 21486 smallArrayt* r; 21487 smallArrayt *self = allocG(rtSmallArrayt); 21488 smallDoublet *value = allocSmallDouble(1); 21489 21490 r = prependNFreeSmallDoubleSmallArrayG(self, value); 21491 ck_assert_ptr_ne(r, null); 21492 char *s = toStringO(r); 21493 ck_assert_str_eq(s, "[1.000000e+00]"); 21494 free(s); 21495 terminateO(self); 21496 21497 END_TEST 21498 21499 21500 START_TEST(prependNFreeSmallIntSmallArrayGT) 21501 21502 smallArrayt* r; 21503 smallArrayt *self = allocG(rtSmallArrayt); 21504 smallIntt *value = allocSmallInt(1); 21505 21506 r = prependNFreeSmallIntSmallArrayG(self, value); 21507 ck_assert_ptr_ne(r, null); 21508 char *s = toStringO(r); 21509 ck_assert_str_eq(s, "[1]"); 21510 free(s); 21511 terminateO(self); 21512 21513 END_TEST 21514 21515 21516 START_TEST(prependNFreeSmallJsonSmallArrayGT) 21517 21518 smallArrayt* r; 21519 smallArrayt *self = allocG(rtSmallArrayt); 21520 smallJsont *value = allocSmallJson(); 21521 21522 r = prependNFreeSmallJsonSmallArrayG(self, value); 21523 ck_assert_ptr_ne(r, null); 21524 char *s = toStringO(r); 21525 ck_assert_str_eq(s, "[{}]"); 21526 free(s); 21527 terminateO(self); 21528 21529 END_TEST 21530 21531 21532 START_TEST(prependNFreeSmallStringSmallArrayGT) 21533 21534 smallArrayt* r; 21535 smallArrayt *self = allocG(rtSmallArrayt); 21536 smallStringt *string = allocSmallString("qwe"); 21537 21538 r = prependNFreeSmallStringSmallArrayG(self, string); 21539 ck_assert_ptr_ne(r, null); 21540 char *s = toStringO(r); 21541 ck_assert_str_eq(s, "[\"qwe\"]"); 21542 free(s); 21543 terminateO(self); 21544 21545 END_TEST 21546 21547 21548 START_TEST(prependNFreeSmallContainerSmallArrayGT) 21549 21550 smallArrayt* r; 21551 smallArrayt *self = allocG(rtSmallArrayt); 21552 21553 createAllocateSmallContainer(c); 21554 r = prependNFreeSmallContainerSmallArrayG(self, c); 21555 ck_assert_ptr_ne(r, null); 21556 char *s = toStringO(r); 21557 ck_assert_str_eq(s, "[\"<data container>\"]"); 21558 free(s); 21559 terminateO(self); 21560 21561 END_TEST 21562 21563 21564 START_TEST(dequeueSmallArrayGT) 21565 21566 baset* r; 21567 smallArrayt *self = allocG(rtSmallArrayt); 21568 21569 smallArrayt *r2 = self->f->pushInt(self, 1); 21570 ck_assert_ptr_ne(r2, null); 21571 r = dequeueSmallArrayG(self, NULL); 21572 ck_assert_ptr_ne(r, null); 21573 char *s = toStringO(r); 21574 terminateO(r); 21575 ck_assert_str_eq(s, "1"); 21576 free(s); 21577 terminateO(self); 21578 21579 END_TEST 21580 21581 21582 START_TEST(dequeueUndefinedSmallArrayGT) 21583 21584 undefinedt* r; 21585 smallArrayt *self = allocG(rtSmallArrayt); 21586 21587 smallArrayt *r2 = self->f->pushUndefined(self); 21588 ck_assert_ptr_ne(r2, null); 21589 r = dequeueUndefinedSmallArrayG(self, null); 21590 ck_assert_ptr_ne(r, null); 21591 char *s = toStringO(r); 21592 terminateO(r); 21593 ck_assert_str_eq(s, "null"); 21594 free(s); 21595 terminateO(self); 21596 21597 END_TEST 21598 21599 21600 START_TEST(dequeueBoolSmallArrayGT) 21601 21602 bool r; 21603 smallArrayt *self = allocG(rtSmallArrayt); 21604 21605 smallArrayt *r2 = self->f->pushBool(self, TRUE); 21606 ck_assert_ptr_ne(r2, null); 21607 r = dequeueBoolSmallArrayG(self, null); 21608 ck_assert(r); 21609 terminateO(self); 21610 21611 END_TEST 21612 21613 21614 START_TEST(dequeueDoubleSmallArrayGT) 21615 21616 double r; 21617 smallArrayt *self = allocG(rtSmallArrayt); 21618 21619 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 21620 ck_assert_ptr_ne(r2, null); 21621 r = dequeueDoubleSmallArrayG(self, 0); 21622 ck_assert(r==2.0); 21623 terminateO(self); 21624 21625 END_TEST 21626 21627 21628 START_TEST(dequeueIntSmallArrayGT) 21629 21630 int64_t r; 21631 smallArrayt *self = allocG(rtSmallArrayt); 21632 21633 smallArrayt *r2 = self->f->pushInt(self, 2); 21634 ck_assert_ptr_ne(r2, null); 21635 r = dequeueIntSmallArrayG(self, 0); 21636 ck_assert_int_eq(r, 2); 21637 terminateO(self); 21638 21639 END_TEST 21640 21641 21642 START_TEST(dequeueInt32SmallArrayGT) 21643 21644 int32_t r; 21645 smallArrayt *self = allocG(rtSmallArrayt); 21646 21647 smallArrayt *r2 = self->f->pushInt(self, 2); 21648 ck_assert_ptr_ne(r2, null); 21649 r = dequeueInt32SmallArrayG(self, 0); 21650 ck_assert_int_eq(r, 2); 21651 terminateO(self); 21652 21653 END_TEST 21654 21655 21656 START_TEST(dequeueUintSmallArrayGT) 21657 21658 uint64_t r; 21659 smallArrayt *self = allocG(rtSmallArrayt); 21660 21661 smallArrayt *r2 = self->f->pushInt(self, 2); 21662 ck_assert_ptr_ne(r2, null); 21663 r = dequeueUintSmallArrayG(self, 0); 21664 ck_assert_int_eq(r, 2); 21665 terminateO(self); 21666 21667 END_TEST 21668 21669 21670 START_TEST(dequeueUint32SmallArrayGT) 21671 21672 uint32_t r; 21673 smallArrayt *self = allocG(rtSmallArrayt); 21674 21675 smallArrayt *r2 = self->f->pushInt(self, 2); 21676 ck_assert_ptr_ne(r2, null); 21677 r = dequeueUint32SmallArrayG(self, 0); 21678 ck_assert_int_eq(r, 2); 21679 terminateO(self); 21680 21681 END_TEST 21682 21683 21684 START_TEST(dequeueSSmallArrayGT) 21685 21686 char* r; 21687 smallArrayt *self = allocG(rtSmallArrayt); 21688 21689 smallArrayt *r2 = self->f->pushS(self, "2"); 21690 ck_assert_ptr_ne(r2, null); 21691 r = dequeueSSmallArrayG(self, null); 21692 ck_assert_str_eq(r, "2"); 21693 free(r); 21694 terminateO(self); 21695 21696 END_TEST 21697 21698 21699 START_TEST(dequeueDictSmallArrayGT) 21700 21701 smallDictt* r; 21702 smallArrayt *self = allocG(rtSmallArrayt); 21703 21704 createSmallDict(d); 21705 smallArrayt *r2 = self->f->pushDict(self, &d); 21706 ck_assert_ptr_ne(r2, null); 21707 r = dequeueDictSmallArrayG(self, null); 21708 ck_assert_ptr_ne(r, null); 21709 char *s = toStringO(r); 21710 ck_assert_str_eq(s, "{}"); 21711 free(s); 21712 terminateO(r); 21713 terminateO(self); 21714 21715 END_TEST 21716 21717 21718 START_TEST(dequeueArraySmallArrayGT) 21719 21720 smallArrayt* r; 21721 smallArrayt *self = allocG(rtSmallArrayt); 21722 21723 createSmallArray(a); 21724 smallArrayt *r2 = self->f->pushArray(self, &a); 21725 ck_assert_ptr_ne(r2, null); 21726 r = dequeueArraySmallArrayG(self, null); 21727 ck_assert_ptr_ne(r, null); 21728 char *s = toStringO(r); 21729 ck_assert_str_eq(s, "[]"); 21730 free(s); 21731 terminateO(r); 21732 terminateO(self); 21733 21734 END_TEST 21735 21736 21737 START_TEST(dequeueSmallBoolSmallArrayGT) 21738 21739 smallBoolt* r; 21740 smallArrayt *self = allocG(rtSmallArrayt); 21741 21742 smallArrayt *r2 = self->f->pushBool(self, true); 21743 ck_assert_ptr_ne(r2, null); 21744 r = dequeueSmallBoolSmallArrayG(self, null); 21745 ck_assert_ptr_ne(r, null); 21746 char *s = toStringO(r); 21747 ck_assert_str_eq(s, "true"); 21748 free(s); 21749 terminateO(r); 21750 terminateO(self); 21751 21752 END_TEST 21753 21754 21755 START_TEST(dequeueSmallBytesSmallArrayGT) 21756 21757 smallBytest* r; 21758 smallArrayt *self = allocG(rtSmallArrayt); 21759 21760 createSmallBytes(b); 21761 smallArrayt *r2 = self->f->pushSmallBytes(self, &b); 21762 ck_assert_ptr_ne(r2, null); 21763 r = dequeueSmallBytesSmallArrayG(self, null); 21764 ck_assert_ptr_ne(r, null); 21765 char *s = toStringO(r); 21766 ck_assert_str_eq(s, "[]"); 21767 free(s); 21768 terminateO(r); 21769 terminateO(self); 21770 21771 END_TEST 21772 21773 21774 START_TEST(dequeueSmallDoubleSmallArrayGT) 21775 21776 smallDoublet* r; 21777 smallArrayt *self = allocG(rtSmallArrayt); 21778 21779 smallArrayt *r2 = self->f->pushDouble(self, 1); 21780 ck_assert_ptr_ne(r2, null); 21781 r = dequeueSmallDoubleSmallArrayG(self, null); 21782 ck_assert_ptr_ne(r, null); 21783 char *s = toStringO(r); 21784 ck_assert_str_eq(s, "1.000000e+00"); 21785 free(s); 21786 terminateO(r); 21787 terminateO(self); 21788 21789 END_TEST 21790 21791 21792 START_TEST(dequeueSmallIntSmallArrayGT) 21793 21794 smallIntt* r; 21795 smallArrayt *self = allocG(rtSmallArrayt); 21796 21797 smallArrayt *r2 = self->f->pushInt(self, 1); 21798 ck_assert_ptr_ne(r2, null); 21799 r = dequeueSmallIntSmallArrayG(self, null); 21800 ck_assert_ptr_ne(r, null); 21801 char *s = toStringO(r); 21802 ck_assert_str_eq(s, "1"); 21803 free(s); 21804 terminateO(r); 21805 terminateO(self); 21806 21807 END_TEST 21808 21809 21810 START_TEST(dequeueSmallJsonSmallArrayGT) 21811 21812 smallJsont* r; 21813 smallArrayt *self = allocG(rtSmallArrayt); 21814 21815 createSmallJson(j); 21816 smallArrayt *r2 = self->f->pushSmallJson(self, &j); 21817 ck_assert_ptr_ne(r2, null); 21818 r = dequeueSmallJsonSmallArrayG(self, null); 21819 ck_assert_ptr_ne(r, null); 21820 char *s = toStringO(r); 21821 ck_assert_str_eq(s, "{}"); 21822 free(s); 21823 terminateO(r); 21824 terminateO(self); 21825 21826 END_TEST 21827 21828 21829 START_TEST(dequeueSmallStringSmallArrayGT) 21830 21831 smallStringt* r; 21832 smallArrayt *self = allocG(rtSmallArrayt); 21833 21834 createSmallString(S); 21835 smallArrayt *r2 = self->f->pushSmallString(self, &S); 21836 ck_assert_ptr_ne(r2, null); 21837 r = dequeueSmallStringSmallArrayG(self, null); 21838 ck_assert_ptr_ne(r, null); 21839 char *s = toStringO(r); 21840 ck_assert_str_eq(s, ""); 21841 free(s); 21842 terminateO(r); 21843 terminateO(self); 21844 21845 END_TEST 21846 21847 21848 START_TEST(dequeueVoidSmallArrayGT) 21849 21850 void* r; 21851 smallArrayt *self = allocG(rtSmallArrayt); 21852 21853 createSmallContainer(c); 21854 setValO(&c, &r); 21855 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 21856 ck_assert_ptr_ne(r2, null); 21857 r = dequeueVoidSmallArrayG(self, null); 21858 ck_assert_ptr_eq(r, &r); 21859 terminateO(self); 21860 21861 END_TEST 21862 21863 21864 START_TEST(dequeueSmallContainerSmallArrayGT) 21865 21866 smallContainert* r; 21867 smallArrayt *self = allocG(rtSmallArrayt); 21868 21869 createSmallContainer(c); 21870 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 21871 ck_assert_ptr_ne(r2, null); 21872 r = dequeueSmallContainerSmallArrayG(self, null); 21873 ck_assert_ptr_ne(r, null); 21874 char *s = toStringO(r); 21875 ck_assert_str_eq(s, "<data smallContainer>"); 21876 free(s); 21877 terminateO(r); 21878 terminateO(self); 21879 21880 END_TEST 21881 21882 21883 21884 START_TEST(getAtSmallArrayGT) 21885 21886 baset* r; 21887 smallArrayt *self = allocG(rtSmallArrayt); 21888 21889 smallArrayt *r2 = self->f->pushInt(self, 1); 21890 ck_assert_ptr_ne(r2, null); 21891 r = getAtSmallArrayG(self, NULL, 0); 21892 ck_assert_ptr_ne(r, null); 21893 char *s = toStringO(r); 21894 finishO(r); 21895 ck_assert_str_eq(s, "1"); 21896 free(s); 21897 terminateO(self); 21898 21899 END_TEST 21900 21901 21902 START_TEST(getAtUndefinedSmallArrayGT) 21903 21904 undefinedt* r; 21905 smallArrayt *self = allocG(rtSmallArrayt); 21906 21907 smallArrayt *r2 = self->f->pushUndefined(self); 21908 ck_assert_ptr_ne(r2, null); 21909 r = getAtUndefinedSmallArrayG(self, null, 0); 21910 ck_assert_ptr_ne(r, null); 21911 char *s = toStringO(r); 21912 finishO(r); 21913 ck_assert_str_eq(s, "null"); 21914 free(s); 21915 terminateO(self); 21916 21917 END_TEST 21918 21919 21920 START_TEST(getAtBoolSmallArrayGT) 21921 21922 bool r; 21923 smallArrayt *self = allocG(rtSmallArrayt); 21924 21925 smallArrayt *r2 = self->f->pushBool(self, TRUE); 21926 ck_assert_ptr_ne(r2, null); 21927 r = getAtBoolSmallArrayG(self, null, 0); 21928 ck_assert(r); 21929 terminateO(self); 21930 21931 END_TEST 21932 21933 21934 START_TEST(getAtBoolPSmallArrayGT) 21935 21936 bool* r; 21937 smallArrayt *self = allocG(rtSmallArrayt); 21938 21939 smallArrayt *r2 = self->f->pushBool(self, TRUE); 21940 ck_assert_ptr_ne(r2, null); 21941 r = getAtBoolPSmallArrayG(self, null, 0); 21942 ck_assert_ptr_ne(r, null); 21943 ck_assert(*r); 21944 terminateO(self); 21945 21946 END_TEST 21947 21948 21949 START_TEST(getAtDoubleSmallArrayGT) 21950 21951 double r; 21952 smallArrayt *self = allocG(rtSmallArrayt); 21953 21954 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 21955 ck_assert_ptr_ne(r2, null); 21956 r = getAtDoubleSmallArrayG(self, 0, 0); 21957 ck_assert(r==2.0); 21958 terminateO(self); 21959 21960 END_TEST 21961 21962 21963 START_TEST(getAtDoublePSmallArrayGT) 21964 21965 double* r; 21966 smallArrayt *self = allocG(rtSmallArrayt); 21967 21968 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 21969 ck_assert_ptr_ne(r2, null); 21970 r = getAtDoublePSmallArrayG(self, 0, 0); 21971 ck_assert_ptr_ne(r, null); 21972 ck_assert(*r==2.0); 21973 terminateO(self); 21974 21975 END_TEST 21976 21977 21978 START_TEST(getAtIntSmallArrayGT) 21979 21980 int64_t r; 21981 smallArrayt *self = allocG(rtSmallArrayt); 21982 21983 smallArrayt *r2 = self->f->pushInt(self, 2); 21984 ck_assert_ptr_ne(r2, null); 21985 r = getAtIntSmallArrayG(self, 0, 0); 21986 ck_assert_int_eq(r, 2); 21987 terminateO(self); 21988 21989 END_TEST 21990 21991 21992 START_TEST(getAtIntPSmallArrayGT) 21993 21994 int64_t* r; 21995 smallArrayt *self = allocG(rtSmallArrayt); 21996 21997 smallArrayt *r2 = self->f->pushInt(self, 2); 21998 ck_assert_ptr_ne(r2, null); 21999 r = getAtIntPSmallArrayG(self, 0, 0); 22000 ck_assert_ptr_ne(r, null); 22001 ck_assert_int_eq(*r, 2); 22002 terminateO(self); 22003 22004 END_TEST 22005 22006 22007 START_TEST(getAtInt32SmallArrayGT) 22008 22009 int32_t r; 22010 smallArrayt *self = allocG(rtSmallArrayt); 22011 22012 smallArrayt *r2 = self->f->pushInt(self, 2); 22013 ck_assert_ptr_ne(r2, null); 22014 r = getAtInt32SmallArrayG(self, 0, 0); 22015 ck_assert_int_eq(r, 2); 22016 terminateO(self); 22017 22018 END_TEST 22019 22020 22021 START_TEST(getAtInt32PSmallArrayGT) 22022 22023 int32_t* r; 22024 smallArrayt *self = allocG(rtSmallArrayt); 22025 22026 smallArrayt *r2 = self->f->pushInt(self, 2); 22027 ck_assert_ptr_ne(r2, null); 22028 r = getAtInt32PSmallArrayG(self, 0, 0); 22029 ck_assert_ptr_ne(r, null); 22030 ck_assert_int_eq(*r, 2); 22031 terminateO(self); 22032 22033 END_TEST 22034 22035 22036 START_TEST(getAtUintSmallArrayGT) 22037 22038 uint64_t r; 22039 smallArrayt *self = allocG(rtSmallArrayt); 22040 22041 smallArrayt *r2 = self->f->pushInt(self, 2); 22042 ck_assert_ptr_ne(r2, null); 22043 r = getAtUintSmallArrayG(self, 0, 0); 22044 ck_assert_int_eq(r, 2); 22045 terminateO(self); 22046 22047 END_TEST 22048 22049 22050 START_TEST(getAtUintPSmallArrayGT) 22051 22052 uint64_t* r; 22053 smallArrayt *self = allocG(rtSmallArrayt); 22054 22055 smallArrayt *r2 = self->f->pushInt(self, 2); 22056 ck_assert_ptr_ne(r2, null); 22057 r = getAtUintPSmallArrayG(self, 0, 0); 22058 ck_assert_ptr_ne(r, null); 22059 ck_assert_int_eq(*r, 2); 22060 terminateO(self); 22061 22062 END_TEST 22063 22064 22065 START_TEST(getAtUint32SmallArrayGT) 22066 22067 uint32_t r; 22068 smallArrayt *self = allocG(rtSmallArrayt); 22069 22070 smallArrayt *r2 = self->f->pushInt(self, 2); 22071 ck_assert_ptr_ne(r2, null); 22072 r = getAtUint32SmallArrayG(self, 0, 0); 22073 ck_assert_int_eq(r, 2); 22074 terminateO(self); 22075 22076 END_TEST 22077 22078 22079 START_TEST(getAtUint32PSmallArrayGT) 22080 22081 uint32_t* r; 22082 smallArrayt *self = allocG(rtSmallArrayt); 22083 22084 smallArrayt *r2 = self->f->pushInt(self, 2); 22085 ck_assert_ptr_ne(r2, null); 22086 r = getAtUint32PSmallArrayG(self, 0, 0); 22087 ck_assert_ptr_ne(r, null); 22088 ck_assert_int_eq(*r, 2); 22089 terminateO(self); 22090 22091 END_TEST 22092 22093 22094 START_TEST(getAtSSmallArrayGT) 22095 22096 char* r; 22097 smallArrayt *self = allocG(rtSmallArrayt); 22098 22099 smallArrayt *r2 = self->f->pushS(self, "2"); 22100 ck_assert_ptr_ne(r2, null); 22101 r = getAtSSmallArrayG(self, null, 0); 22102 ck_assert_str_eq(r, "2"); 22103 terminateO(self); 22104 22105 END_TEST 22106 22107 22108 START_TEST(getAtDictSmallArrayGT) 22109 22110 smallDictt* r; 22111 smallArrayt *self = allocG(rtSmallArrayt); 22112 22113 createSmallDict(d); 22114 smallArrayt *r2 = self->f->pushDict(self, &d); 22115 ck_assert_ptr_ne(r2, null); 22116 r = getAtDictSmallArrayG(self, null, 0); 22117 ck_assert_ptr_ne(r, null); 22118 char *s = toStringO(r); 22119 ck_assert_str_eq(s, "{}"); 22120 free(s); 22121 finishO(r); 22122 terminateO(self); 22123 22124 END_TEST 22125 22126 22127 START_TEST(getAtArraySmallArrayGT) 22128 22129 smallArrayt* r; 22130 smallArrayt *self = allocG(rtSmallArrayt); 22131 22132 createSmallArray(a); 22133 smallArrayt *r2 = self->f->pushArray(self, &a); 22134 ck_assert_ptr_ne(r2, null); 22135 r = getAtArraySmallArrayG(self, null, 0); 22136 ck_assert_ptr_ne(r, null); 22137 char *s = toStringO(r); 22138 ck_assert_str_eq(s, "[]"); 22139 free(s); 22140 finishO(r); 22141 terminateO(self); 22142 22143 END_TEST 22144 22145 22146 START_TEST(getAtSmallBoolSmallArrayGT) 22147 22148 smallBoolt* r; 22149 smallArrayt *self = allocG(rtSmallArrayt); 22150 22151 smallArrayt *r2 = self->f->pushBool(self, true); 22152 ck_assert_ptr_ne(r2, null); 22153 r = getAtSmallBoolSmallArrayG(self, null, 0); 22154 ck_assert_ptr_ne(r, null); 22155 char *s = toStringO(r); 22156 ck_assert_str_eq(s, "true"); 22157 free(s); 22158 finishO(r); 22159 terminateO(self); 22160 22161 END_TEST 22162 22163 22164 START_TEST(getAtSmallBytesSmallArrayGT) 22165 22166 smallBytest* r; 22167 smallArrayt *self = allocG(rtSmallArrayt); 22168 22169 createSmallBytes(b); 22170 smallArrayt *r2 = self->f->pushSmallBytes(self, &b); 22171 ck_assert_ptr_ne(r2, null); 22172 r = getAtSmallBytesSmallArrayG(self, null, 0); 22173 ck_assert_ptr_ne(r, null); 22174 char *s = toStringO(r); 22175 ck_assert_str_eq(s, "[]"); 22176 free(s); 22177 finishO(r); 22178 terminateO(self); 22179 22180 END_TEST 22181 22182 22183 START_TEST(getAtSmallDoubleSmallArrayGT) 22184 22185 smallDoublet* r; 22186 smallArrayt *self = allocG(rtSmallArrayt); 22187 22188 smallArrayt *r2 = self->f->pushDouble(self, 1); 22189 ck_assert_ptr_ne(r2, null); 22190 r = getAtSmallDoubleSmallArrayG(self, null, 0); 22191 ck_assert_ptr_ne(r, null); 22192 char *s = toStringO(r); 22193 ck_assert_str_eq(s, "1.000000e+00"); 22194 free(s); 22195 finishO(r); 22196 terminateO(self); 22197 22198 END_TEST 22199 22200 22201 START_TEST(getAtSmallIntSmallArrayGT) 22202 22203 smallIntt* r; 22204 smallArrayt *self = allocG(rtSmallArrayt); 22205 22206 smallArrayt *r2 = self->f->pushInt(self, 1); 22207 ck_assert_ptr_ne(r2, null); 22208 r = getAtSmallIntSmallArrayG(self, null, 0); 22209 ck_assert_ptr_ne(r, null); 22210 char *s = toStringO(r); 22211 ck_assert_str_eq(s, "1"); 22212 free(s); 22213 finishO(r); 22214 terminateO(self); 22215 22216 END_TEST 22217 22218 22219 START_TEST(getAtSmallJsonSmallArrayGT) 22220 22221 smallJsont* r; 22222 smallArrayt *self = allocG(rtSmallArrayt); 22223 22224 createSmallJson(j); 22225 smallArrayt *r2 = self->f->pushSmallJson(self, &j); 22226 ck_assert_ptr_ne(r2, null); 22227 r = getAtSmallJsonSmallArrayG(self, null, 0); 22228 ck_assert_ptr_ne(r, null); 22229 char *s = toStringO(r); 22230 ck_assert_str_eq(s, "{}"); 22231 free(s); 22232 finishO(r); 22233 terminateO(self); 22234 22235 END_TEST 22236 22237 22238 START_TEST(getAtSmallStringSmallArrayGT) 22239 22240 smallStringt* r; 22241 smallArrayt *self = allocG(rtSmallArrayt); 22242 22243 createSmallString(S); 22244 smallArrayt *r2 = self->f->pushSmallString(self, &S); 22245 ck_assert_ptr_ne(r2, null); 22246 r = getAtSmallStringSmallArrayG(self, null, 0); 22247 ck_assert_ptr_ne(r, null); 22248 char *s = toStringO(r); 22249 ck_assert_str_eq(s, ""); 22250 free(s); 22251 finishO(r); 22252 terminateO(self); 22253 22254 END_TEST 22255 22256 22257 START_TEST(getAtVoidSmallArrayGT) 22258 22259 void* r; 22260 smallArrayt *self = allocG(rtSmallArrayt); 22261 22262 createSmallContainer(c); 22263 setValO(&c, &r); 22264 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 22265 ck_assert_ptr_ne(r2, null); 22266 r = getAtVoidSmallArrayG(self, null, 0); 22267 ck_assert_ptr_eq(r, &r); 22268 terminateO(self); 22269 22270 END_TEST 22271 22272 22273 START_TEST(getAtSmallContainerSmallArrayGT) 22274 22275 smallContainert* r; 22276 smallArrayt *self = allocG(rtSmallArrayt); 22277 22278 createSmallContainer(c); 22279 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 22280 ck_assert_ptr_ne(r2, null); 22281 r = getAtSmallContainerSmallArrayG(self, null, 0); 22282 ck_assert_ptr_ne(r, null); 22283 char *s = toStringO(r); 22284 ck_assert_str_eq(s, "<data smallContainer>"); 22285 free(s); 22286 finishO(r); 22287 terminateO(self); 22288 22289 END_TEST 22290 22291 22292 START_TEST(getAtNDupSmallArrayGT) 22293 22294 baset* r; 22295 smallArrayt *self = allocG(rtSmallArrayt); 22296 22297 smallArrayt *r2 = self->f->pushInt(self, 1); 22298 ck_assert_ptr_ne(r2, null); 22299 r = getAtNDupSmallArrayG(self, NULL, 0); 22300 ck_assert_ptr_ne(r, null); 22301 char *s = toStringO(r); 22302 terminateO(r); 22303 ck_assert_str_eq(s, "1"); 22304 free(s); 22305 terminateO(self); 22306 22307 END_TEST 22308 22309 22310 START_TEST(getAtNDupUndefinedSmallArrayGT) 22311 22312 undefinedt* r; 22313 smallArrayt *self = allocG(rtSmallArrayt); 22314 22315 smallArrayt *r2 = self->f->pushUndefined(self); 22316 ck_assert_ptr_ne(r2, null); 22317 r = getAtNDupUndefinedSmallArrayG(self, null, 0); 22318 ck_assert_ptr_ne(r, null); 22319 char *s = toStringO(r); 22320 terminateO(r); 22321 ck_assert_str_eq(s, "null"); 22322 free(s); 22323 terminateO(self); 22324 22325 END_TEST 22326 22327 22328 START_TEST(getAtNDupBoolSmallArrayGT) 22329 22330 bool r; 22331 smallArrayt *self = allocG(rtSmallArrayt); 22332 22333 smallArrayt *r2 = self->f->pushBool(self, TRUE); 22334 ck_assert_ptr_ne(r2, null); 22335 r = getAtNDupBoolSmallArrayG(self, null, 0); 22336 ck_assert(r); 22337 terminateO(self); 22338 22339 END_TEST 22340 22341 22342 START_TEST(getAtNDupDoubleSmallArrayGT) 22343 22344 double r; 22345 smallArrayt *self = allocG(rtSmallArrayt); 22346 22347 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 22348 ck_assert_ptr_ne(r2, null); 22349 r = getAtNDupDoubleSmallArrayG(self, 0, 0); 22350 ck_assert(r==2.0); 22351 terminateO(self); 22352 22353 END_TEST 22354 22355 22356 START_TEST(getAtNDupIntSmallArrayGT) 22357 22358 int64_t r; 22359 smallArrayt *self = allocG(rtSmallArrayt); 22360 22361 smallArrayt *r2 = self->f->pushInt(self, 2); 22362 ck_assert_ptr_ne(r2, null); 22363 r = getAtNDupIntSmallArrayG(self, 0, 0); 22364 ck_assert_int_eq(r, 2); 22365 terminateO(self); 22366 22367 END_TEST 22368 22369 22370 START_TEST(getAtNDupInt32SmallArrayGT) 22371 22372 int32_t r; 22373 smallArrayt *self = allocG(rtSmallArrayt); 22374 22375 smallArrayt *r2 = self->f->pushInt(self, 2); 22376 ck_assert_ptr_ne(r2, null); 22377 r = getAtNDupInt32SmallArrayG(self, 0, 0); 22378 ck_assert_int_eq(r, 2); 22379 terminateO(self); 22380 22381 END_TEST 22382 22383 22384 START_TEST(getAtNDupUintSmallArrayGT) 22385 22386 uint64_t r; 22387 smallArrayt *self = allocG(rtSmallArrayt); 22388 22389 smallArrayt *r2 = self->f->pushInt(self, 2); 22390 ck_assert_ptr_ne(r2, null); 22391 r = getAtNDupUintSmallArrayG(self, 0, 0); 22392 ck_assert_int_eq(r, 2); 22393 terminateO(self); 22394 22395 END_TEST 22396 22397 22398 START_TEST(getAtNDupUint32SmallArrayGT) 22399 22400 uint32_t r; 22401 smallArrayt *self = allocG(rtSmallArrayt); 22402 22403 smallArrayt *r2 = self->f->pushInt(self, 2); 22404 ck_assert_ptr_ne(r2, null); 22405 r = getAtNDupUint32SmallArrayG(self, 0, 0); 22406 ck_assert_int_eq(r, 2); 22407 terminateO(self); 22408 22409 END_TEST 22410 22411 22412 START_TEST(getAtNDupSSmallArrayGT) 22413 22414 char* r; 22415 smallArrayt *self = allocG(rtSmallArrayt); 22416 22417 smallArrayt *r2 = self->f->pushS(self, "2"); 22418 ck_assert_ptr_ne(r2, null); 22419 r = getAtNDupSSmallArrayG(self, null, 0); 22420 ck_assert_str_eq(r, "2"); 22421 free(r); 22422 terminateO(self); 22423 22424 END_TEST 22425 22426 22427 START_TEST(getAtNDupDictSmallArrayGT) 22428 22429 smallDictt* r; 22430 smallArrayt *self = allocG(rtSmallArrayt); 22431 22432 createSmallDict(d); 22433 smallArrayt *r2 = self->f->pushDict(self, &d); 22434 ck_assert_ptr_ne(r2, null); 22435 r = getAtNDupDictSmallArrayG(self, null, 0); 22436 ck_assert_ptr_ne(r, null); 22437 char *s = toStringO(r); 22438 ck_assert_str_eq(s, "{}"); 22439 free(s); 22440 terminateO(r); 22441 terminateO(self); 22442 22443 END_TEST 22444 22445 22446 START_TEST(getAtNDupArraySmallArrayGT) 22447 22448 smallArrayt* r; 22449 smallArrayt *self = allocG(rtSmallArrayt); 22450 22451 createSmallArray(a); 22452 smallArrayt *r2 = self->f->pushArray(self, &a); 22453 ck_assert_ptr_ne(r2, null); 22454 r = getAtNDupArraySmallArrayG(self, null, 0); 22455 ck_assert_ptr_ne(r, null); 22456 char *s = toStringO(r); 22457 ck_assert_str_eq(s, "[]"); 22458 free(s); 22459 terminateO(r); 22460 terminateO(self); 22461 22462 END_TEST 22463 22464 22465 START_TEST(getAtNDupSmallBoolSmallArrayGT) 22466 22467 smallBoolt* r; 22468 smallArrayt *self = allocG(rtSmallArrayt); 22469 22470 smallArrayt *r2 = self->f->pushBool(self, true); 22471 ck_assert_ptr_ne(r2, null); 22472 r = getAtNDupSmallBoolSmallArrayG(self, null, 0); 22473 ck_assert_ptr_ne(r, null); 22474 char *s = toStringO(r); 22475 ck_assert_str_eq(s, "true"); 22476 free(s); 22477 terminateO(r); 22478 terminateO(self); 22479 22480 END_TEST 22481 22482 22483 START_TEST(getAtNDupSmallBytesSmallArrayGT) 22484 22485 smallBytest* r; 22486 smallArrayt *self = allocG(rtSmallArrayt); 22487 22488 createSmallBytes(b); 22489 smallArrayt *r2 = self->f->pushSmallBytes(self, &b); 22490 ck_assert_ptr_ne(r2, null); 22491 r = getAtNDupSmallBytesSmallArrayG(self, null, 0); 22492 ck_assert_ptr_ne(r, null); 22493 char *s = toStringO(r); 22494 ck_assert_str_eq(s, "[]"); 22495 free(s); 22496 terminateO(r); 22497 terminateO(self); 22498 22499 END_TEST 22500 22501 22502 START_TEST(getAtNDupSmallDoubleSmallArrayGT) 22503 22504 smallDoublet* r; 22505 smallArrayt *self = allocG(rtSmallArrayt); 22506 22507 smallArrayt *r2 = self->f->pushDouble(self, 1); 22508 ck_assert_ptr_ne(r2, null); 22509 r = getAtNDupSmallDoubleSmallArrayG(self, null, 0); 22510 ck_assert_ptr_ne(r, null); 22511 char *s = toStringO(r); 22512 ck_assert_str_eq(s, "1.000000e+00"); 22513 free(s); 22514 terminateO(r); 22515 terminateO(self); 22516 22517 END_TEST 22518 22519 22520 START_TEST(getAtNDupSmallIntSmallArrayGT) 22521 22522 smallIntt* r; 22523 smallArrayt *self = allocG(rtSmallArrayt); 22524 22525 smallArrayt *r2 = self->f->pushInt(self, 1); 22526 ck_assert_ptr_ne(r2, null); 22527 r = getAtNDupSmallIntSmallArrayG(self, null, 0); 22528 ck_assert_ptr_ne(r, null); 22529 char *s = toStringO(r); 22530 ck_assert_str_eq(s, "1"); 22531 free(s); 22532 terminateO(r); 22533 terminateO(self); 22534 22535 END_TEST 22536 22537 22538 START_TEST(getAtNDupSmallJsonSmallArrayGT) 22539 22540 smallJsont* r; 22541 smallArrayt *self = allocG(rtSmallArrayt); 22542 22543 createSmallJson(j); 22544 smallArrayt *r2 = self->f->pushSmallJson(self, &j); 22545 ck_assert_ptr_ne(r2, null); 22546 r = getAtNDupSmallJsonSmallArrayG(self, null, 0); 22547 ck_assert_ptr_ne(r, null); 22548 char *s = toStringO(r); 22549 ck_assert_str_eq(s, "{}"); 22550 free(s); 22551 terminateO(r); 22552 terminateO(self); 22553 22554 END_TEST 22555 22556 22557 START_TEST(getAtNDupSmallStringSmallArrayGT) 22558 22559 smallStringt* r; 22560 smallArrayt *self = allocG(rtSmallArrayt); 22561 22562 createSmallString(S); 22563 smallArrayt *r2 = self->f->pushSmallString(self, &S); 22564 ck_assert_ptr_ne(r2, null); 22565 r = getAtNDupSmallStringSmallArrayG(self, null, 0); 22566 ck_assert_ptr_ne(r, null); 22567 char *s = toStringO(r); 22568 ck_assert_str_eq(s, ""); 22569 free(s); 22570 terminateO(r); 22571 terminateO(self); 22572 22573 END_TEST 22574 22575 22576 START_TEST(getAtNDupVoidSmallArrayGT) 22577 22578 void* r; 22579 smallArrayt *self = allocG(rtSmallArrayt); 22580 22581 createSmallContainer(c); 22582 setValO(&c, &r); 22583 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 22584 ck_assert_ptr_ne(r2, null); 22585 r = getAtNDupVoidSmallArrayG(self, null, 0); 22586 ck_assert_ptr_eq(r, NULL); 22587 terminateO(self); 22588 22589 END_TEST 22590 22591 22592 START_TEST(getAtNDupSmallContainerSmallArrayGT) 22593 22594 smallContainert* r; 22595 smallArrayt *self = allocG(rtSmallArrayt); 22596 22597 createSmallContainer(c); 22598 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 22599 ck_assert_ptr_ne(r2, null); 22600 r = getAtNDupSmallContainerSmallArrayG(self, null, 0); 22601 ck_assert_ptr_ne(r, null); 22602 char *s = toStringO(r); 22603 ck_assert_str_eq(s, "<data smallContainer>"); 22604 free(s); 22605 terminateO(r); 22606 terminateO(self); 22607 22608 END_TEST 22609 22610 22611 START_TEST(setAtSmallArrayGT) 22612 22613 smallArrayt* r; 22614 smallArrayt *self = allocG(rtSmallArrayt); 22615 baset *value = (baset*) allocSmallInt(1); 22616 22617 r = pushSmallArrayG(self, value); 22618 ck_assert_ptr_ne(r, null); 22619 finishO(value); 22620 value = (baset*) allocSmallInt(2); 22621 r = setAtSmallArrayG(self, 0, value); 22622 ck_assert_ptr_ne(r, null); 22623 finishO(value); 22624 char *s = toStringO(r); 22625 ck_assert_str_eq(s, "[2]"); 22626 free(s); 22627 terminateO(self); 22628 22629 END_TEST 22630 22631 22632 START_TEST(setAtUndefinedSmallArrayGT) 22633 22634 smallArrayt* r; 22635 smallArrayt *self = allocG(rtSmallArrayt); 22636 baset *value = (baset*) allocSmallInt(1); 22637 22638 r = pushSmallArrayG(self, value); 22639 ck_assert_ptr_ne(r, null); 22640 finishO(value); 22641 r = setAtUndefinedSmallArrayG(self, 0, null); 22642 ck_assert_ptr_ne(r, null); 22643 char *s = toStringO(r); 22644 ck_assert_str_eq(s, "[null]"); 22645 free(s); 22646 terminateO(self); 22647 22648 END_TEST 22649 22650 22651 START_TEST(setAtBoolSmallArrayGT) 22652 22653 smallArrayt* r; 22654 smallArrayt *self = allocG(rtSmallArrayt); 22655 22656 r = pushBoolSmallArrayG(self, true); 22657 ck_assert_ptr_ne(r, null); 22658 r = setAtBoolSmallArrayG(self, 0, false); 22659 ck_assert_ptr_ne(r, null); 22660 char *s = toStringO(r); 22661 ck_assert_str_eq(s, "[false]"); 22662 free(s); 22663 terminateO(self); 22664 22665 END_TEST 22666 22667 22668 START_TEST(setAtDoubleSmallArrayGT) 22669 22670 smallArrayt* r; 22671 smallArrayt *self = allocG(rtSmallArrayt); 22672 22673 r = pushDoubleSmallArrayG(self, 1); 22674 ck_assert_ptr_ne(r, null); 22675 r = setAtDoubleSmallArrayG(self, 0, 2); 22676 ck_assert_ptr_ne(r, null); 22677 char *s = toStringO(r); 22678 ck_assert_str_eq(s, "[2.000000e+00]"); 22679 free(s); 22680 terminateO(self); 22681 22682 END_TEST 22683 22684 22685 START_TEST(setAtIntSmallArrayGT) 22686 22687 smallArrayt* r; 22688 smallArrayt *self = allocG(rtSmallArrayt); 22689 22690 r = pushIntSmallArrayG(self, 1); 22691 ck_assert_ptr_ne(r, null); 22692 r = setAtIntSmallArrayG(self, 0, 2); 22693 ck_assert_ptr_ne(r, null); 22694 char *s = toStringO(r); 22695 ck_assert_str_eq(s, "[2]"); 22696 free(s); 22697 terminateO(self); 22698 22699 END_TEST 22700 22701 22702 START_TEST(setAtSSmallArrayGT) 22703 22704 smallArrayt* r; 22705 smallArrayt *self = allocG(rtSmallArrayt); 22706 22707 r = pushSSmallArrayG(self, "qwe"); 22708 ck_assert_ptr_ne(r, null); 22709 r = setAtSSmallArrayG(self, 0, "asd"); 22710 ck_assert_ptr_ne(r, null); 22711 char *s = toStringO(r); 22712 ck_assert_str_eq(s, "[\"asd\"]"); 22713 free(s); 22714 terminateO(self); 22715 22716 END_TEST 22717 22718 22719 START_TEST(setAtCharSmallArrayGT) 22720 22721 smallArrayt* r; 22722 smallArrayt *self = allocG(rtSmallArrayt); 22723 22724 r = pushCharSmallArrayG(self, 'Q'); 22725 ck_assert_ptr_ne(r, null); 22726 r = setAtCharSmallArrayG(self, 0, 'x'); 22727 ck_assert_ptr_ne(r, null); 22728 char *s = toStringO(r); 22729 ck_assert_str_eq(s, "[\"x\"]"); 22730 free(s); 22731 terminateO(self); 22732 22733 END_TEST 22734 22735 22736 START_TEST(setAtDictSmallArrayGT) 22737 22738 smallArrayt* r; 22739 smallArrayt *self = allocG(rtSmallArrayt); 22740 smallDictt *dict = allocSmallDict(); 22741 22742 r = pushDictSmallArrayG(self, dict); 22743 ck_assert_ptr_ne(r, null); 22744 resetO(dict); 22745 dict->f->setInt(dict, "a", 1); 22746 r = setAtDictSmallArrayG(self, 0, dict); 22747 ck_assert_ptr_ne(r, null); 22748 finishO(dict); 22749 char *s = toStringO(r); 22750 ck_assert_str_eq(s, "[{\"a\":1}]"); 22751 free(s); 22752 terminateO(self); 22753 22754 END_TEST 22755 22756 22757 START_TEST(setAtArraySmallArrayGT) 22758 22759 smallArrayt* r; 22760 smallArrayt *self = allocG(rtSmallArrayt); 22761 smallArrayt *array = allocSmallArray(); 22762 22763 r = pushArraySmallArrayG(self, array); 22764 ck_assert_ptr_ne(r, null); 22765 resetO(array); 22766 array->f->pushInt(array, 1); 22767 r = setAtArraySmallArrayG(self, 0, array); 22768 ck_assert_ptr_ne(r, null); 22769 finishO(array); 22770 char *s = toStringO(r); 22771 ck_assert_str_eq(s, "[[1]]"); 22772 free(s); 22773 terminateO(self); 22774 22775 END_TEST 22776 22777 22778 START_TEST(setAtArraycSmallArrayGT) 22779 22780 smallArrayt* r; 22781 smallArrayt *self = allocG(rtSmallArrayt); 22782 char **array = listCreateS("a","bb"); 22783 22784 r = pushArraycSmallArrayG(self, array); 22785 ck_assert_ptr_ne(r, null); 22786 listFreeS(array); 22787 array = listCreateS("1","22"); 22788 r = setAtArraycSmallArrayG(self, 0, array); 22789 ck_assert_ptr_ne(r, null); 22790 ck_assert_int_eq(lenO(r), 1); 22791 listFreeS(array); 22792 char *s = toStringO(r); 22793 ck_assert_str_eq(s, "[[\"1\",\"22\"]]"); 22794 free(s); 22795 terminateO(self); 22796 22797 END_TEST 22798 22799 22800 START_TEST(setAtCArraycSmallArrayGT) 22801 22802 smallArrayt* r; 22803 smallArrayt *self = allocG(rtSmallArrayt); 22804 const char *array[] = {"a", "bb", NULL}; 22805 22806 r = pushCArraycSmallArrayG(self, array); 22807 ck_assert_ptr_ne(r, null); 22808 const char *array2[] = {"1", "22", NULL}; 22809 r = setAtCArraycSmallArrayG(self, 0, array2); 22810 ck_assert_ptr_ne(r, null); 22811 ck_assert_int_eq(lenO(r), 1); 22812 char *s = toStringO(r); 22813 ck_assert_str_eq(s, "[[\"1\",\"22\"]]"); 22814 free(s); 22815 terminateO(self); 22816 22817 END_TEST 22818 22819 22820 START_TEST(setAtVoidSmallArrayGT) 22821 22822 smallArrayt* r; 22823 smallArrayt *self = allocG(rtSmallArrayt); 22824 22825 // NULL value 22826 r = pushVoidSmallArrayG(self, NULL); 22827 ck_assert_ptr_ne(r, null); 22828 r = setAtVoidSmallArrayG(self, 0, null); 22829 ck_assert_ptr_ne(r, null); 22830 r = setAtVoidSmallArrayG(self, 0, r); 22831 ck_assert_ptr_ne(r, null); 22832 char *s = toStringO(r); 22833 ck_assert_str_eq(s, "[\"<data container>\"]"); 22834 free(s); 22835 terminateO(self); 22836 22837 END_TEST 22838 22839 22840 START_TEST(setAtSmallBoolSmallArrayGT) 22841 22842 smallArrayt* r; 22843 smallArrayt *self = allocG(rtSmallArrayt); 22844 smallBoolt *value = allocSmallBool(true); 22845 22846 r = pushBoolSmallArrayG(self, false); 22847 ck_assert_ptr_ne(r, null); 22848 r = setAtSmallBoolSmallArrayG(self, 0, value); 22849 ck_assert_ptr_ne(r, null); 22850 finishO(value); 22851 char *s = toStringO(r); 22852 ck_assert_str_eq(s, "[true]"); 22853 free(s); 22854 terminateO(self); 22855 22856 END_TEST 22857 22858 22859 START_TEST(setAtSmallBytesSmallArrayGT) 22860 22861 smallArrayt* r; 22862 smallArrayt *self = allocG(rtSmallArrayt); 22863 smallBytest *value = allocSmallBytes("qwe", 3); 22864 22865 r = pushSmallBytesSmallArrayG(self, value); 22866 ck_assert_ptr_ne(r, null); 22867 finishO(value); 22868 value = allocSmallBytes("asd", 3); 22869 r = setAtSmallBytesSmallArrayG(self, 0, value); 22870 ck_assert_ptr_ne(r, null); 22871 finishO(value); 22872 char *s = toStringO(r); 22873 ck_assert_str_eq(s, "[[0x61,0x73,0x64]]"); 22874 free(s); 22875 terminateO(self); 22876 22877 END_TEST 22878 22879 22880 START_TEST(setAtSmallDoubleSmallArrayGT) 22881 22882 smallArrayt* r; 22883 smallArrayt *self = allocG(rtSmallArrayt); 22884 smallDoublet *value = allocSmallDouble(1); 22885 22886 r = pushDoubleSmallArrayG(self, 2); 22887 ck_assert_ptr_ne(r, null); 22888 r = setAtSmallDoubleSmallArrayG(self, 0, value); 22889 ck_assert_ptr_ne(r, null); 22890 finishO(value); 22891 char *s = toStringO(r); 22892 ck_assert_str_eq(s, "[1.000000e+00]"); 22893 free(s); 22894 22895 terminateO(self); 22896 22897 END_TEST 22898 22899 22900 START_TEST(setAtSmallIntSmallArrayGT) 22901 22902 smallArrayt* r; 22903 smallArrayt *self = allocG(rtSmallArrayt); 22904 smallIntt *value = allocSmallInt(1); 22905 22906 r = pushIntSmallArrayG(self, 2); 22907 ck_assert_ptr_ne(r, null); 22908 r = setAtSmallIntSmallArrayG(self, 0, value); 22909 ck_assert_ptr_ne(r, null); 22910 finishO(value); 22911 char *s = toStringO(r); 22912 ck_assert_str_eq(s, "[1]"); 22913 free(s); 22914 terminateO(self); 22915 22916 END_TEST 22917 22918 22919 START_TEST(setAtSmallJsonSmallArrayGT) 22920 22921 smallArrayt* r; 22922 smallArrayt *self = allocG(rtSmallArrayt); 22923 smallJsont *value = allocSmallJson(); 22924 22925 r = pushSmallJsonSmallArrayG(self, value); 22926 ck_assert_ptr_ne(r, null); 22927 finishO(value); 22928 value = allocSmallJson(); 22929 value->f->setInt(value, "a", 1); 22930 r = setAtSmallJsonSmallArrayG(self, 0, value); 22931 ck_assert_ptr_ne(r, null); 22932 finishO(value); 22933 char *s = toStringO(r); 22934 ck_assert_str_eq(s, "[{\"a\":1}]"); 22935 free(s); 22936 terminateO(self); 22937 22938 END_TEST 22939 22940 22941 START_TEST(setAtSmallStringSmallArrayGT) 22942 22943 smallArrayt* r; 22944 smallArrayt *self = allocG(rtSmallArrayt); 22945 smallStringt *string = allocSmallString("qwe"); 22946 22947 r = pushSSmallArrayG(self, "asd"); 22948 ck_assert_ptr_ne(r, null); 22949 r = setAtSmallStringSmallArrayG(self, 0, string); 22950 ck_assert_ptr_ne(r, null); 22951 finishO(string); 22952 char *s = toStringO(r); 22953 ck_assert_str_eq(s, "[\"qwe\"]"); 22954 free(s); 22955 terminateO(self); 22956 22957 END_TEST 22958 22959 22960 START_TEST(setAtSmallContainerSmallArrayGT) 22961 22962 smallArrayt* r; 22963 smallArrayt *self = allocG(rtSmallArrayt); 22964 22965 createSmallContainer(c); 22966 r = pushSmallContainerSmallArrayG(self, &c); 22967 ck_assert_ptr_ne(r, null); 22968 createSmallContainer(c2); 22969 r = setAtSmallContainerSmallArrayG(self, 0, &c2); 22970 ck_assert_ptr_ne(r, null); 22971 char *s = toStringO(r); 22972 ck_assert_str_eq(s, "[\"<data container>\"]"); 22973 free(s); 22974 terminateO(self); 22975 22976 END_TEST 22977 22978 22979 START_TEST(setAtNFreeSmallArrayGT) 22980 22981 smallArrayt* r; 22982 smallArrayt *self = allocG(rtSmallArrayt); 22983 baset *value = (baset*) allocSmallInt(1); 22984 22985 r = pushSmallArrayG(self, value); 22986 ck_assert_ptr_ne(r, null); 22987 finishO(value); 22988 value = (baset*) allocSmallInt(2); 22989 r = setAtNFreeSmallArrayG(self, 0, value); 22990 ck_assert_ptr_ne(r, null); 22991 char *s = toStringO(r); 22992 ck_assert_str_eq(s, "[2]"); 22993 free(s); 22994 terminateO(self); 22995 22996 END_TEST 22997 22998 22999 START_TEST(setAtNFreeUndefinedSmallArrayGT) 23000 23001 smallArrayt* r; 23002 smallArrayt *self = allocG(rtSmallArrayt); 23003 baset *value = (baset*) allocSmallInt(1); 23004 23005 r = pushSmallArrayG(self, value); 23006 ck_assert_ptr_ne(r, null); 23007 finishO(value); 23008 r = setAtNFreeUndefinedSmallArrayG(self, 0, null); 23009 ck_assert_ptr_ne(r, null); 23010 char *s = toStringO(r); 23011 ck_assert_str_eq(s, "[null]"); 23012 free(s); 23013 terminateO(self); 23014 23015 END_TEST 23016 23017 23018 START_TEST(setAtNFreeSSmallArrayGT) 23019 23020 smallArrayt* r; 23021 smallArrayt *self = allocG(rtSmallArrayt); 23022 23023 r = pushSSmallArrayG(self, "qwe"); 23024 ck_assert_ptr_ne(r, null); 23025 r = setAtNFreeSSmallArrayG(self, 0, strdup("asd")); 23026 ck_assert_ptr_ne(r, null); 23027 char *s = toStringO(r); 23028 ck_assert_str_eq(s, "[\"asd\"]"); 23029 free(s); 23030 terminateO(self); 23031 23032 END_TEST 23033 23034 23035 START_TEST(setAtNFreeDictSmallArrayGT) 23036 23037 smallArrayt* r; 23038 smallArrayt *self = allocG(rtSmallArrayt); 23039 smallDictt *dict = allocSmallDict(); 23040 23041 r = pushDictSmallArrayG(self, dict); 23042 ck_assert_ptr_ne(r, null); 23043 resetO(dict); 23044 dict->f->setInt(dict, "a", 1); 23045 r = setAtNFreeDictSmallArrayG(self, 0, dict); 23046 ck_assert_ptr_ne(r, null); 23047 char *s = toStringO(r); 23048 ck_assert_str_eq(s, "[{\"a\":1}]"); 23049 free(s); 23050 terminateO(self); 23051 23052 END_TEST 23053 23054 23055 START_TEST(setAtNFreeArraySmallArrayGT) 23056 23057 smallArrayt* r; 23058 smallArrayt *self = allocG(rtSmallArrayt); 23059 smallArrayt *array = allocSmallArray(); 23060 23061 r = pushArraySmallArrayG(self, array); 23062 ck_assert_ptr_ne(r, null); 23063 resetO(array); 23064 array->f->pushInt(array, 1); 23065 r = setAtNFreeArraySmallArrayG(self, 0, array); 23066 ck_assert_ptr_ne(r, null); 23067 char *s = toStringO(r); 23068 ck_assert_str_eq(s, "[[1]]"); 23069 free(s); 23070 terminateO(self); 23071 23072 END_TEST 23073 23074 23075 START_TEST(setAtNFreeArraycSmallArrayGT) 23076 23077 smallArrayt* r; 23078 smallArrayt *self = allocG(rtSmallArrayt); 23079 char **array = listCreateS("a","bb"); 23080 23081 r = pushArraycSmallArrayG(self, array); 23082 ck_assert_ptr_ne(r, null); 23083 listFreeS(array); 23084 array = listCreateS("1","22"); 23085 r = setAtNFreeArraycSmallArrayG(self, 0, array); 23086 ck_assert_ptr_ne(r, null); 23087 ck_assert_int_eq(lenO(r), 1); 23088 char *s = toStringO(r); 23089 ck_assert_str_eq(s, "[[\"1\",\"22\"]]"); 23090 free(s); 23091 terminateO(self); 23092 23093 END_TEST 23094 23095 23096 START_TEST(setAtNFreeSmallBoolSmallArrayGT) 23097 23098 smallArrayt* r; 23099 smallArrayt *self = allocG(rtSmallArrayt); 23100 smallBoolt *value = allocSmallBool(true); 23101 23102 r = pushBoolSmallArrayG(self, false); 23103 ck_assert_ptr_ne(r, null); 23104 r = setAtNFreeSmallBoolSmallArrayG(self, 0, value); 23105 ck_assert_ptr_ne(r, null); 23106 char *s = toStringO(r); 23107 ck_assert_str_eq(s, "[true]"); 23108 free(s); 23109 terminateO(self); 23110 23111 END_TEST 23112 23113 23114 START_TEST(setAtNFreeSmallBytesSmallArrayGT) 23115 23116 smallArrayt* r; 23117 smallArrayt *self = allocG(rtSmallArrayt); 23118 smallBytest *value = allocSmallBytes("qwe", 3); 23119 23120 r = pushSmallBytesSmallArrayG(self, value); 23121 ck_assert_ptr_ne(r, null); 23122 finishO(value); 23123 value = allocSmallBytes("asd", 3); 23124 r = setAtNFreeSmallBytesSmallArrayG(self, 0, value); 23125 ck_assert_ptr_ne(r, null); 23126 char *s = toStringO(r); 23127 ck_assert_str_eq(s, "[[0x61,0x73,0x64]]"); 23128 free(s); 23129 terminateO(self); 23130 23131 END_TEST 23132 23133 23134 START_TEST(setAtNFreeSmallDoubleSmallArrayGT) 23135 23136 smallArrayt* r; 23137 smallArrayt *self = allocG(rtSmallArrayt); 23138 smallDoublet *value = allocSmallDouble(1); 23139 23140 r = pushDoubleSmallArrayG(self, 2); 23141 ck_assert_ptr_ne(r, null); 23142 r = setAtNFreeSmallDoubleSmallArrayG(self, 0, value); 23143 ck_assert_ptr_ne(r, null); 23144 char *s = toStringO(r); 23145 ck_assert_str_eq(s, "[1.000000e+00]"); 23146 free(s); 23147 terminateO(self); 23148 23149 END_TEST 23150 23151 23152 START_TEST(setAtNFreeSmallIntSmallArrayGT) 23153 23154 smallArrayt* r; 23155 smallArrayt *self = allocG(rtSmallArrayt); 23156 smallIntt *value = allocSmallInt(1); 23157 23158 r = pushIntSmallArrayG(self, 2); 23159 ck_assert_ptr_ne(r, null); 23160 r = setAtNFreeSmallIntSmallArrayG(self, 0, value); 23161 ck_assert_ptr_ne(r, null); 23162 char *s = toStringO(r); 23163 ck_assert_str_eq(s, "[1]"); 23164 free(s); 23165 terminateO(self); 23166 23167 END_TEST 23168 23169 23170 START_TEST(setAtNFreeSmallJsonSmallArrayGT) 23171 23172 smallArrayt* r; 23173 smallArrayt *self = allocG(rtSmallArrayt); 23174 smallJsont *value = allocSmallJson(); 23175 23176 r = pushSmallJsonSmallArrayG(self, value); 23177 ck_assert_ptr_ne(r, null); 23178 finishO(value); 23179 value = allocSmallJson(); 23180 value->f->setInt(value, "a", 1); 23181 r = setAtNFreeSmallJsonSmallArrayG(self, 0, value); 23182 ck_assert_ptr_ne(r, null); 23183 char *s = toStringO(r); 23184 ck_assert_str_eq(s, "[{\"a\":1}]"); 23185 free(s); 23186 terminateO(self); 23187 23188 END_TEST 23189 23190 23191 START_TEST(setAtNFreeSmallStringSmallArrayGT) 23192 23193 smallArrayt* r; 23194 smallArrayt *self = allocG(rtSmallArrayt); 23195 smallStringt *string = allocSmallString("qwe"); 23196 23197 r = pushSSmallArrayG(self, "asd"); 23198 ck_assert_ptr_ne(r, null); 23199 r = setAtNFreeSmallStringSmallArrayG(self, 0, string); 23200 ck_assert_ptr_ne(r, null); 23201 char *s = toStringO(r); 23202 ck_assert_str_eq(s, "[\"qwe\"]"); 23203 free(s); 23204 terminateO(self); 23205 23206 END_TEST 23207 23208 23209 START_TEST(setAtNFreeSmallContainerSmallArrayGT) 23210 23211 smallArrayt* r; 23212 smallArrayt *self = allocG(rtSmallArrayt); 23213 23214 createSmallContainer(c); 23215 r = pushSmallContainerSmallArrayG(self, &c); 23216 ck_assert_ptr_ne(r, null); 23217 createAllocateSmallContainer(c2); 23218 r = setAtNFreeSmallContainerSmallArrayG(self, 0, c2); 23219 ck_assert_ptr_ne(r, null); 23220 char *s = toStringO(r); 23221 ck_assert_str_eq(s, "[\"<data container>\"]"); 23222 free(s); 23223 terminateO(self); 23224 23225 END_TEST 23226 23227 23228 START_TEST(setPAtDictSmallArrayGT) 23229 23230 smallArrayt* r; 23231 smallArrayt *self = allocG(rtSmallArrayt); 23232 smallDictt *dict = allocSmallDict(); 23233 23234 r = pushDictSmallArrayG(self, dict); 23235 ck_assert_ptr_ne(r, null); 23236 finishO(dict); 23237 dict = getAtDictSmallArrayG(self, null, 0); 23238 ck_assert_ptr_ne(dict, null); 23239 dict->f->setInt(dict, "a", 1); 23240 r = setPAtDictSmallArrayG(self, 0, dict); 23241 ck_assert_ptr_ne(r, null); 23242 finishO(dict); 23243 char *s = toStringO(r); 23244 ck_assert_str_eq(s, "[{\"a\":1}]"); 23245 free(s); 23246 terminateO(self); 23247 23248 END_TEST 23249 23250 23251 START_TEST(setPAtArraySmallArrayGT) 23252 23253 smallArrayt* r; 23254 smallArrayt *self = allocG(rtSmallArrayt); 23255 smallArrayt *array = allocSmallArray(); 23256 23257 r = pushArraySmallArrayG(self, array); 23258 ck_assert_ptr_ne(r, null); 23259 finishO(array); 23260 array = getAtArraySmallArrayG(self, null, 0); 23261 ck_assert_ptr_ne(array, null); 23262 array->f->pushInt(array, 1); 23263 r = setPAtArraySmallArrayG(self, 0, array); 23264 ck_assert_ptr_ne(r, null); 23265 finishO(array); 23266 char *s = toStringO(r); 23267 ck_assert_str_eq(s, "[[1]]"); 23268 free(s); 23269 terminateO(self); 23270 23271 END_TEST 23272 23273 23274 START_TEST(setPAtSmallJsonSmallArrayGT) 23275 23276 smallArrayt* r; 23277 smallArrayt *self = allocG(rtSmallArrayt); 23278 smallJsont *value = allocSmallJson(); 23279 23280 r = pushSmallJsonSmallArrayG(self, value); 23281 ck_assert_ptr_ne(r, null); 23282 finishO(value); 23283 value = getAtSmallJsonSmallArrayG(self, null, 0); 23284 value->f->setInt(value, "a", 1); 23285 r = setPAtSmallJsonSmallArrayG(self, 0, value); 23286 ck_assert_ptr_ne(r, null); 23287 finishO(value); 23288 char *s = toStringO(r); 23289 ck_assert_str_eq(s, "[{\"a\":1}]"); 23290 free(s); 23291 terminateO(self); 23292 23293 END_TEST 23294 23295 23296 START_TEST(setPAtSmallStringSmallArrayGT) 23297 23298 smallArrayt* r; 23299 smallArrayt *self = allocG(rtSmallArrayt); 23300 smallStringt *string; 23301 23302 r = pushSSmallArrayG(self, "asd"); 23303 ck_assert_ptr_ne(r, null); 23304 string = getAtSmallStringSmallArrayG(self, null, 0); 23305 setValO(string, "qwe"); 23306 r = setPAtSmallStringSmallArrayG(self, 0, string); 23307 ck_assert_ptr_ne(r, null); 23308 finishO(string); 23309 char *s = toStringO(r); 23310 ck_assert_str_eq(s, "[\"qwe\"]"); 23311 free(s); 23312 terminateO(self); 23313 23314 END_TEST 23315 23316 23317 START_TEST(setPAtNFreeDictSmallArrayGT) 23318 23319 smallArrayt* r; 23320 smallArrayt *self = allocG(rtSmallArrayt); 23321 smallDictt *dict = allocSmallDict(); 23322 23323 r = pushDictSmallArrayG(self, dict); 23324 ck_assert_ptr_ne(r, null); 23325 finishO(dict); 23326 dict = getAtDictSmallArrayG(self, null, 0); 23327 ck_assert_ptr_ne(dict, null); 23328 dict->f->setInt(dict, "a", 1); 23329 r = setPAtNFreeDictSmallArrayG(self, 0, dict); 23330 ck_assert_ptr_ne(r, null); 23331 char *s = toStringO(r); 23332 ck_assert_str_eq(s, "[{\"a\":1}]"); 23333 free(s); 23334 terminateO(self); 23335 23336 END_TEST 23337 23338 23339 START_TEST(setPAtNFreeArraySmallArrayGT) 23340 23341 smallArrayt* r; 23342 smallArrayt *self = allocG(rtSmallArrayt); 23343 smallArrayt *array = allocSmallArray(); 23344 23345 r = pushArraySmallArrayG(self, array); 23346 ck_assert_ptr_ne(r, null); 23347 finishO(array); 23348 array = getAtArraySmallArrayG(self, null, 0); 23349 ck_assert_ptr_ne(array, null); 23350 array->f->pushInt(array, 1); 23351 r = setPAtNFreeArraySmallArrayG(self, 0, array); 23352 ck_assert_ptr_ne(r, null); 23353 char *s = toStringO(r); 23354 ck_assert_str_eq(s, "[[1]]"); 23355 free(s); 23356 terminateO(self); 23357 23358 END_TEST 23359 23360 23361 START_TEST(setPAtNFreeSmallJsonSmallArrayGT) 23362 23363 smallArrayt* r; 23364 smallArrayt *self = allocG(rtSmallArrayt); 23365 smallJsont *value = allocSmallJson(); 23366 23367 r = pushSmallJsonSmallArrayG(self, value); 23368 ck_assert_ptr_ne(r, null); 23369 finishO(value); 23370 value = getAtSmallJsonSmallArrayG(self, null, 0); 23371 value->f->setInt(value, "a", 1); 23372 r = setPAtNFreeSmallJsonSmallArrayG(self, 0, value); 23373 ck_assert_ptr_ne(r, null); 23374 char *s = toStringO(r); 23375 ck_assert_str_eq(s, "[{\"a\":1}]"); 23376 free(s); 23377 terminateO(self); 23378 23379 END_TEST 23380 23381 23382 START_TEST(setPAtNFreeSmallStringSmallArrayGT) 23383 23384 smallArrayt* r; 23385 smallArrayt *self = allocG(rtSmallArrayt); 23386 smallStringt *string; 23387 23388 r = pushSSmallArrayG(self, "asd"); 23389 ck_assert_ptr_ne(r, null); 23390 string = getAtSmallStringSmallArrayG(self, null, 0); 23391 setValO(string, "qwe"); 23392 r = setPAtNFreeSmallStringSmallArrayG(self, 0, string); 23393 ck_assert_ptr_ne(r, null); 23394 char *s = toStringO(r); 23395 ck_assert_str_eq(s, "[\"qwe\"]"); 23396 free(s); 23397 terminateO(self); 23398 23399 END_TEST 23400 23401 23402 START_TEST(getNumSmallArrayGT) 23403 23404 double r; 23405 smallArrayt *self = allocG(rtSmallArrayt); 23406 smallArrayt *r2; 23407 23408 r2 = self->f->pushDouble(self, 1); 23409 ck_assert_ptr_ne(r2, NULL); 23410 r = getNumSmallArrayG(self, 0); 23411 ck_assert(r==1); 23412 terminateO(self); 23413 23414 END_TEST 23415 23416 23417 START_TEST(reverseSmallArrayGT) 23418 23419 smallArrayt* r; 23420 smallArrayt *self = allocG(rtSmallArrayt); 23421 23422 self->f->pushInt(self, 1); 23423 self->f->pushInt(self, 2); 23424 r = reverseSmallArrayG(self); 23425 ck_assert_ptr_ne(r, NULL); 23426 char *s = toStringO(r); 23427 ck_assert_str_eq(s, "[2,1]"); 23428 free(s); 23429 terminateO(self); 23430 23431 END_TEST 23432 23433 23434 START_TEST(appendSmallArrayGT) 23435 23436 smallArrayt* r; 23437 smallArrayt *self = allocG(rtSmallArrayt); 23438 smallArrayt *array = allocSmallArray(); 23439 23440 r = self->f->pushInt(self, 1); 23441 ck_assert_ptr_ne(r, null); 23442 array->f->pushInt(array, 1); 23443 array->f->pushInt(array, 2); 23444 r = appendSmallArrayG(self, array); 23445 ck_assert_ptr_ne(r, NULL); 23446 smashO(array); 23447 char *s = toStringO(r); 23448 ck_assert_str_eq(s, "[1,1,2]"); 23449 free(s); 23450 // non smallArray object 23451 array = (smallArrayt*) allocSmallInt(0); 23452 r = appendSmallArrayG(self, array); 23453 ck_assert_ptr_eq(r, NULL); 23454 terminateO(array); 23455 terminateO(self); 23456 23457 END_TEST 23458 23459 23460 START_TEST(appendSmallJsonSmallArrayGT) 23461 23462 smallArrayt* r; 23463 smallArrayt *self = allocG(rtSmallArrayt); 23464 smallJsont *json = allocSmallJson(); 23465 23466 r = self->f->pushInt(self, 1); 23467 ck_assert_ptr_ne(r, null); 23468 json->f->pushInt(json, 1); 23469 json->f->pushInt(json, 2); 23470 r = appendSmallJsonSmallArrayG(self, json); 23471 ck_assert_ptr_ne(r, NULL); 23472 smashO(json); 23473 char *s = toStringO(r); 23474 ck_assert_str_eq(s, "[1,1,2]"); 23475 free(s); 23476 terminateO(self); 23477 23478 END_TEST 23479 23480 23481 START_TEST(appendNSmashSmallArrayGT) 23482 23483 smallArrayt* r; 23484 smallArrayt *self = allocG(rtSmallArrayt); 23485 smallArrayt *array = allocSmallArray(); 23486 23487 r = self->f->pushInt(self, 1); 23488 ck_assert_ptr_ne(r, null); 23489 array->f->pushInt(array, 1); 23490 array->f->pushInt(array, 2); 23491 r = appendNSmashSmallArrayG(self, array); 23492 ck_assert_ptr_ne(r, NULL); 23493 char *s = toStringO(r); 23494 ck_assert_str_eq(s, "[1,1,2]"); 23495 free(s); 23496 terminateO(self); 23497 23498 END_TEST 23499 23500 23501 START_TEST(appendNSmashSmallJsonSmallArrayGT) 23502 23503 smallArrayt* r; 23504 smallArrayt *self = allocG(rtSmallArrayt); 23505 smallJsont *json = allocSmallJson(); 23506 23507 r = self->f->pushInt(self, 1); 23508 ck_assert_ptr_ne(r, null); 23509 json->f->pushInt(json, 1); 23510 json->f->pushInt(json, 2); 23511 r = appendNSmashSmallJsonSmallArrayG(self, json); 23512 ck_assert_ptr_ne(r, NULL); 23513 char *s = toStringO(r); 23514 ck_assert_str_eq(s, "[1,1,2]"); 23515 free(s); 23516 terminateO(self); 23517 23518 END_TEST 23519 23520 23521 START_TEST(appendArraySmallArrayGT) 23522 23523 smallArrayt* r; 23524 smallArrayt *self = allocG(rtSmallArrayt); 23525 char **array = listCreateS("1", "2"); 23526 23527 r = self->f->pushInt(self, 1); 23528 ck_assert_ptr_ne(r, null); 23529 r = appendArraySmallArrayG(self, array); 23530 ck_assert_ptr_ne(r, NULL); 23531 listFreeS(array); 23532 char *s = toStringO(r); 23533 ck_assert_str_eq(s, "[1,\"1\",\"2\"]"); 23534 free(s); 23535 terminateO(self); 23536 23537 END_TEST 23538 23539 23540 START_TEST(appendNSmashArraySmallArrayGT) 23541 23542 smallArrayt* r; 23543 smallArrayt *self = allocG(rtSmallArrayt); 23544 char **array = listCreateS("1", "2"); 23545 23546 r = self->f->pushInt(self, 1); 23547 ck_assert_ptr_ne(r, null); 23548 r = appendNSmashArraySmallArrayG(self, array); 23549 ck_assert_ptr_ne(r, NULL); 23550 char *s = toStringO(r); 23551 ck_assert_str_eq(s, "[1,\"1\",\"2\"]"); 23552 free(s); 23553 terminateO(self); 23554 23555 END_TEST 23556 23557 23558 START_TEST(appendCArraySmallArrayGT) 23559 23560 smallArrayt* r; 23561 smallArrayt *self = allocG(rtSmallArrayt); 23562 const char *array[] = {"1", "2", null}; 23563 23564 r = self->f->pushInt(self, 1); 23565 ck_assert_ptr_ne(r, null); 23566 r = appendCArraySmallArrayG(self, array); 23567 ck_assert_ptr_ne(r, NULL); 23568 char *s = toStringO(r); 23569 ck_assert_str_eq(s, "[1,\"1\",\"2\"]"); 23570 free(s); 23571 terminateO(self); 23572 23573 END_TEST 23574 23575 23576 START_TEST(shiftSmallArrayGT) 23577 23578 smallArrayt* r; 23579 smallArrayt *self = allocG(rtSmallArrayt); 23580 smallArrayt *array = allocSmallArray(); 23581 23582 r = self->f->pushInt(self, 1); 23583 ck_assert_ptr_ne(r, null); 23584 array->f->pushInt(array, 1); 23585 array->f->pushInt(array, 2); 23586 r = shiftSmallArrayG(self, array); 23587 ck_assert_ptr_ne(r, NULL); 23588 smashO(array); 23589 char *s = toStringO(r); 23590 ck_assert_str_eq(s, "[1,2,1]"); 23591 free(s); 23592 terminateO(self); 23593 23594 END_TEST 23595 23596 23597 START_TEST(shiftSmallJsonSmallArrayGT) 23598 23599 smallArrayt* r; 23600 smallArrayt *self = allocG(rtSmallArrayt); 23601 smallJsont *json = allocSmallJson(); 23602 23603 r = self->f->pushInt(self, 1); 23604 ck_assert_ptr_ne(r, null); 23605 json->f->pushInt(json, 1); 23606 json->f->pushInt(json, 2); 23607 r = shiftSmallJsonSmallArrayG(self, json); 23608 ck_assert_ptr_ne(r, NULL); 23609 smashO(json); 23610 char *s = toStringO(r); 23611 ck_assert_str_eq(s, "[1,2,1]"); 23612 free(s); 23613 terminateO(self); 23614 23615 END_TEST 23616 23617 23618 START_TEST(shiftNSmashSmallArrayGT) 23619 23620 smallArrayt* r; 23621 smallArrayt *self = allocG(rtSmallArrayt); 23622 smallArrayt *array = allocSmallArray(); 23623 23624 r = self->f->pushInt(self, 1); 23625 ck_assert_ptr_ne(r, null); 23626 array->f->pushInt(array, 1); 23627 array->f->pushInt(array, 2); 23628 r = shiftNSmashSmallArrayG(self, array); 23629 ck_assert_ptr_ne(r, NULL); 23630 char *s = toStringO(r); 23631 ck_assert_str_eq(s, "[1,2,1]"); 23632 free(s); 23633 terminateO(self); 23634 23635 END_TEST 23636 23637 23638 START_TEST(shiftNSmashSmallJsonSmallArrayGT) 23639 23640 smallArrayt* r; 23641 smallArrayt *self = allocG(rtSmallArrayt); 23642 smallJsont *json = allocSmallJson(); 23643 23644 r = self->f->pushInt(self, 1); 23645 ck_assert_ptr_ne(r, null); 23646 json->f->pushInt(json, 1); 23647 json->f->pushInt(json, 2); 23648 r = shiftNSmashSmallJsonSmallArrayG(self, json); 23649 ck_assert_ptr_ne(r, NULL); 23650 char *s = toStringO(r); 23651 ck_assert_str_eq(s, "[1,2,1]"); 23652 free(s); 23653 terminateO(self); 23654 23655 END_TEST 23656 23657 23658 START_TEST(addSmallArrayGT) 23659 23660 smallArrayt* r; 23661 smallArrayt *self = allocG(rtSmallArrayt); 23662 createAllocateSmallArray(a); 23663 23664 // add an element to check that the second array is added 23665 // at the end 23666 r = self->f->pushInt(self, 1); 23667 ck_assert_ptr_ne(r, null); 23668 23669 // add array 23670 a->f->pushInt(a, 2); 23671 r = addSmallArrayG(self, a); 23672 smashO(a); 23673 ck_assert_ptr_ne(r, null); 23674 char *s = toStringO(r); 23675 terminateO(r); 23676 ck_assert_str_eq(s, "[1,2]"); 23677 free(s); 23678 // empty array 23679 initiateAllocateSmallArray(&a); 23680 r = addSmallArrayG(self, a); 23681 smashO(a); 23682 ck_assert_ptr_ne(r, null); 23683 s = toStringO(r); 23684 terminateO(r); 23685 ck_assert_str_eq(s, "[1]"); 23686 free(s); 23687 // non smallArray object 23688 a = (smallArrayt*) allocSmallInt(0); 23689 r = addSmallArrayG(self, a); 23690 ck_assert_ptr_eq(r, NULL); 23691 terminateO(a); 23692 terminateO(self); 23693 23694 END_TEST 23695 23696 23697 START_TEST(sliceSmallArrayGT) 23698 23699 smallArrayt* r; 23700 smallArrayt *self = allocG(rtSmallArrayt); 23701 23702 r = self->f->pushInt(self, 1); 23703 ck_assert_ptr_ne(r, null); 23704 r = self->f->pushInt(self, 2); 23705 ck_assert_ptr_ne(r, null); 23706 r = self->f->pushInt(self, 3); 23707 ck_assert_ptr_ne(r, null); 23708 r = self->f->pushInt(self, 4); 23709 ck_assert_ptr_ne(r, null); 23710 r = sliceSmallArrayG(self, 1, -1); 23711 ck_assert_ptr_ne(r, null); 23712 char *s = toStringO(r); 23713 ck_assert_str_eq(s, "[2,3]"); 23714 free(s); 23715 terminateO(self); 23716 23717 END_TEST 23718 23719 23720 START_TEST(cropSmallArrayGT) 23721 23722 smallArrayt* r; 23723 smallArrayt *self = allocG(rtSmallArrayt); 23724 23725 r = self->f->pushInt(self, 1); 23726 ck_assert_ptr_ne(r, null); 23727 r = self->f->pushInt(self, 2); 23728 ck_assert_ptr_ne(r, null); 23729 r = self->f->pushInt(self, 3); 23730 ck_assert_ptr_ne(r, null); 23731 r = self->f->pushInt(self, 4); 23732 ck_assert_ptr_ne(r, null); 23733 r = cropSmallArrayG(self, 1, -1); 23734 ck_assert_ptr_ne(r, null); 23735 char *s = toStringO(r); 23736 terminateO(r); 23737 ck_assert_str_eq(s, "[2,3]"); 23738 free(s); 23739 s = toStringO(self); 23740 ck_assert_str_eq(s, "[1,4]"); 23741 free(s); 23742 terminateO(self); 23743 23744 END_TEST 23745 23746 23747 START_TEST(cropElemSmallArrayGT) 23748 23749 baset* r; 23750 smallArrayt *self = allocG(rtSmallArrayt); 23751 23752 smallArrayt *r2 = self->f->pushInt(self, 1); 23753 ck_assert_ptr_ne(r2, null); 23754 r = cropElemSmallArrayG(self, 0); 23755 ck_assert_ptr_ne(r, null); 23756 char *s = toStringO(r); 23757 terminateO(r); 23758 ck_assert_str_eq(s, "1"); 23759 free(s); 23760 terminateO(self); 23761 23762 END_TEST 23763 23764 23765 START_TEST(cropElemUndefinedSmallArrayGT) 23766 23767 undefinedt* r; 23768 smallArrayt *self = allocG(rtSmallArrayt); 23769 23770 smallArrayt *r2 = self->f->pushUndefined(self); 23771 ck_assert_ptr_ne(r2, null); 23772 r = cropElemUndefinedSmallArrayG(self, 0); 23773 ck_assert_ptr_ne(r, null); 23774 char *s = toStringO(r); 23775 terminateO(r); 23776 ck_assert_str_eq(s, "null"); 23777 free(s); 23778 terminateO(self); 23779 23780 END_TEST 23781 23782 23783 START_TEST(cropElemBoolSmallArrayGT) 23784 23785 bool r; 23786 smallArrayt *self = allocG(rtSmallArrayt); 23787 23788 smallArrayt *r2 = self->f->pushBool(self, true); 23789 ck_assert_ptr_ne(r2, null); 23790 r = cropElemBoolSmallArrayG(self, 0); 23791 ck_assert(r); 23792 terminateO(self); 23793 23794 END_TEST 23795 23796 23797 START_TEST(cropElemDoubleSmallArrayGT) 23798 23799 double r; 23800 smallArrayt *self = allocG(rtSmallArrayt); 23801 23802 smallArrayt *r2 = self->f->pushDouble(self, 1); 23803 ck_assert_ptr_ne(r2, null); 23804 r = cropElemDoubleSmallArrayG(self, 0); 23805 ck_assert(r==1); 23806 terminateO(self); 23807 23808 END_TEST 23809 23810 23811 START_TEST(cropElemIntSmallArrayGT) 23812 23813 int64_t r; 23814 smallArrayt *self = allocG(rtSmallArrayt); 23815 23816 smallArrayt *r2 = self->f->pushInt(self, 2); 23817 ck_assert_ptr_ne(r2, null); 23818 r = cropElemIntSmallArrayG(self, 0); 23819 ck_assert_int_eq(r, 2); 23820 terminateO(self); 23821 23822 END_TEST 23823 23824 23825 START_TEST(cropElemInt32SmallArrayGT) 23826 23827 int32_t r; 23828 smallArrayt *self = allocG(rtSmallArrayt); 23829 23830 smallArrayt *r2 = self->f->pushInt(self, 2); 23831 ck_assert_ptr_ne(r2, null); 23832 r = cropElemInt32SmallArrayG(self, 0); 23833 ck_assert_int_eq(r, 2); 23834 terminateO(self); 23835 23836 END_TEST 23837 23838 23839 START_TEST(cropElemUintSmallArrayGT) 23840 23841 uint64_t r; 23842 smallArrayt *self = allocG(rtSmallArrayt); 23843 23844 smallArrayt *r2 = self->f->pushInt(self, 2); 23845 ck_assert_ptr_ne(r2, null); 23846 r = cropElemUintSmallArrayG(self, 0); 23847 ck_assert_int_eq(r, 2); 23848 terminateO(self); 23849 23850 END_TEST 23851 23852 23853 START_TEST(cropElemUint32SmallArrayGT) 23854 23855 uint32_t r; 23856 smallArrayt *self = allocG(rtSmallArrayt); 23857 23858 smallArrayt *r2 = self->f->pushInt(self, 2); 23859 ck_assert_ptr_ne(r2, null); 23860 r = cropElemUint32SmallArrayG(self, 0); 23861 ck_assert_int_eq(r, 2); 23862 terminateO(self); 23863 23864 END_TEST 23865 23866 23867 START_TEST(cropElemSSmallArrayGT) 23868 23869 char* r; 23870 smallArrayt *self = allocG(rtSmallArrayt); 23871 23872 smallArrayt *r2 = self->f->pushS(self, "qwe"); 23873 ck_assert_ptr_ne(r2, null); 23874 r = cropElemSSmallArrayG(self, 0); 23875 ck_assert_str_eq(r, "qwe"); 23876 free(r); 23877 terminateO(self); 23878 23879 END_TEST 23880 23881 23882 START_TEST(cropElemDictSmallArrayGT) 23883 23884 smallDictt* r; 23885 smallArrayt *self = allocG(rtSmallArrayt); 23886 23887 createSmallDict(d); 23888 (&d)->f->setInt(&d, "a", 1); 23889 smallArrayt *r2 = self->f->pushDict(self, &d); 23890 ck_assert_ptr_ne(r2, null); 23891 r = cropElemDictSmallArrayG(self, 0); 23892 ck_assert_ptr_ne(r, null); 23893 char *s = toStringO(r); 23894 terminateO(r); 23895 ck_assert_str_eq(s, "{\"a\":1}"); 23896 free(s); 23897 terminateO(self); 23898 23899 END_TEST 23900 23901 23902 START_TEST(cropElemArraySmallArrayGT) 23903 23904 smallArrayt* r; 23905 smallArrayt *self = allocG(rtSmallArrayt); 23906 23907 r = allocSmallArray(); 23908 r->f->pushInt(r, 1); 23909 smallArrayt *r2 = self->f->pushNFreeArray(self, r); 23910 ck_assert_ptr_ne(r2, null); 23911 r = cropElemArraySmallArrayG(self, 0); 23912 ck_assert_ptr_ne(r, null); 23913 char *s = toStringO(r); 23914 terminateO(r); 23915 ck_assert_str_eq(s, "[1]"); 23916 free(s); 23917 terminateO(self); 23918 23919 END_TEST 23920 23921 23922 START_TEST(cropElemSmallBoolSmallArrayGT) 23923 23924 smallBoolt* r; 23925 smallArrayt *self = allocG(rtSmallArrayt); 23926 23927 smallArrayt *r2 = self->f->pushBool(self, true); 23928 ck_assert_ptr_ne(r2, null); 23929 r = cropElemSmallBoolSmallArrayG(self, 0); 23930 ck_assert_ptr_ne(r, null); 23931 char *s = toStringO(r); 23932 terminateO(r); 23933 ck_assert_str_eq(s, "true"); 23934 free(s); 23935 terminateO(self); 23936 23937 END_TEST 23938 23939 23940 START_TEST(cropElemSmallBytesSmallArrayGT) 23941 23942 smallBytest* r; 23943 smallArrayt *self = allocG(rtSmallArrayt); 23944 23945 r = allocSmallBytes("qwe", 3); 23946 smallArrayt *r2 = self->f->pushNFreeSmallBytes(self, r); 23947 ck_assert_ptr_ne(r2, null); 23948 r = cropElemSmallBytesSmallArrayG(self, 0); 23949 ck_assert_ptr_ne(r, null); 23950 char *s = toStringO(r); 23951 terminateO(r); 23952 ck_assert_str_eq(s, "[0x71,0x77,0x65]"); 23953 free(s); 23954 terminateO(self); 23955 23956 END_TEST 23957 23958 23959 START_TEST(cropElemSmallDoubleSmallArrayGT) 23960 23961 smallDoublet* r; 23962 smallArrayt *self = allocG(rtSmallArrayt); 23963 23964 smallArrayt *r2 = self->f->pushDouble(self, 1); 23965 ck_assert_ptr_ne(r2, null); 23966 r = cropElemSmallDoubleSmallArrayG(self, 0); 23967 ck_assert_ptr_ne(r, null); 23968 char *s = toStringO(r); 23969 terminateO(r); 23970 ck_assert_str_eq(s, "1.000000e+00"); 23971 free(s); 23972 terminateO(self); 23973 23974 END_TEST 23975 23976 23977 START_TEST(cropElemSmallIntSmallArrayGT) 23978 23979 smallIntt* r; 23980 smallArrayt *self = allocG(rtSmallArrayt); 23981 23982 smallArrayt *r2 = self->f->pushInt(self, 1); 23983 ck_assert_ptr_ne(r2, null); 23984 r = cropElemSmallIntSmallArrayG(self, 0); 23985 ck_assert_ptr_ne(r, null); 23986 char *s = toStringO(r); 23987 terminateO(r); 23988 ck_assert_str_eq(s, "1"); 23989 free(s); 23990 terminateO(self); 23991 23992 END_TEST 23993 23994 23995 START_TEST(cropElemSmallJsonSmallArrayGT) 23996 23997 smallJsont* r; 23998 smallArrayt *self = allocG(rtSmallArrayt); 23999 24000 r = allocSmallJson(); 24001 r->f->setInt(r, "a", 1); 24002 smallArrayt *r2 = self->f->pushNFreeSmallJson(self, r); 24003 ck_assert_ptr_ne(r2, null); 24004 r = cropElemSmallJsonSmallArrayG(self, 0); 24005 ck_assert_ptr_ne(r, null); 24006 char *s = toStringO(r); 24007 terminateO(r); 24008 ck_assert_str_eq(s, "{\"a\":1}"); 24009 free(s); 24010 terminateO(self); 24011 24012 END_TEST 24013 24014 24015 START_TEST(cropElemSmallStringSmallArrayGT) 24016 24017 smallStringt* r; 24018 smallArrayt *self = allocG(rtSmallArrayt); 24019 24020 smallArrayt *r2 = self->f->pushS(self, "qwe"); 24021 ck_assert_ptr_ne(r2, null); 24022 r = cropElemSmallStringSmallArrayG(self, 0); 24023 ck_assert_ptr_ne(r, null); 24024 char *s = toStringO(r); 24025 terminateO(r); 24026 ck_assert_str_eq(s, "qwe"); 24027 free(s); 24028 terminateO(self); 24029 24030 END_TEST 24031 24032 24033 START_TEST(cropElemVoidSmallArrayGT) 24034 24035 void* r; 24036 smallArrayt *self = allocG(rtSmallArrayt); 24037 24038 smallArrayt *r2 = pushVoidSmallArrayG(self, &r); 24039 ck_assert_ptr_ne(r2, null); 24040 r = cropElemVoidSmallArrayG(self, 0); 24041 ck_assert_ptr_eq(r, &r); 24042 terminateO(self); 24043 24044 END_TEST 24045 24046 24047 START_TEST(cropElemSmallContainerSmallArrayGT) 24048 24049 smallContainert* r; 24050 smallArrayt *self = allocG(rtSmallArrayt); 24051 24052 createSmallContainer(e2); 24053 smallArrayt *r2 = self->f->pushSmallContainer(self, &e2); 24054 ck_assert_ptr_ne(r2, null); 24055 r = cropElemSmallContainerSmallArrayG(self, 0); 24056 ck_assert_ptr_ne(r, null); 24057 char *s = toStringO(r); 24058 terminateO(r); 24059 ck_assert_str_eq(s, "<data smallContainer>"); 24060 free(s); 24061 terminateO(self); 24062 24063 END_TEST 24064 24065 24066 START_TEST(copySmallArrayGT) 24067 24068 smallArrayt* r; 24069 smallArrayt *self = allocG(rtSmallArrayt); 24070 24071 // add elements to self 24072 r = self->f->pushInt(self, 1); 24073 ck_assert_ptr_ne(r, null); 24074 r = self->f->pushInt(self, 2); 24075 ck_assert_ptr_ne(r, null); 24076 r = self->f->pushInt(self, 3); 24077 ck_assert_ptr_ne(r, null); 24078 r = self->f->pushInt(self, 4); 24079 ck_assert_ptr_ne(r, null); 24080 r = copySmallArrayG(self, 1, -1); 24081 ck_assert_ptr_ne(r, null); 24082 ck_assert_int_eq(lenO(r), 2); 24083 char *s = toStringO(r); 24084 terminateO(r); 24085 ck_assert_str_eq(s, "[2,3]"); 24086 free(s); 24087 s = toStringO(self); 24088 ck_assert_str_eq(s, "[1,2,3,4]"); 24089 free(s); 24090 terminateO(self); 24091 24092 END_TEST 24093 24094 24095 START_TEST(insertSmallArrayGT) 24096 24097 smallArrayt* r; 24098 smallArrayt *self = allocG(rtSmallArrayt); 24099 smallArrayt *toInsert = allocSmallArray(); 24100 24101 toInsert->f->pushInt(toInsert, 3); 24102 r = insertSmallArrayG(self, 0, toInsert); 24103 smashO(toInsert); 24104 ck_assert_ptr_ne(r, null); 24105 char *s = toStringO(r); 24106 ck_assert_str_eq(s, "[3]"); 24107 free(s); 24108 terminateO(self); 24109 24110 END_TEST 24111 24112 24113 START_TEST(insertSmallJsonSmallArrayGT) 24114 24115 smallArrayt* r; 24116 smallArrayt *self = allocG(rtSmallArrayt); 24117 smallJsont *toInsert = allocSmallJson(); 24118 24119 toInsert->f->pushInt(toInsert, 3); 24120 r = insertSmallJsonSmallArrayG(self, 0, toInsert); 24121 smashO(toInsert); 24122 ck_assert_ptr_ne(r, null); 24123 char *s = toStringO(r); 24124 ck_assert_str_eq(s, "[3]"); 24125 free(s); 24126 terminateO(self); 24127 24128 END_TEST 24129 24130 24131 START_TEST(insertNSmashSmallArrayGT) 24132 24133 smallArrayt* r; 24134 smallArrayt *self = allocG(rtSmallArrayt); 24135 smallArrayt *toInsert = allocSmallArray(); 24136 24137 toInsert->f->pushInt(toInsert, 3); 24138 r = insertNSmashSmallArrayG(self, 0, toInsert); 24139 ck_assert_ptr_ne(r, null); 24140 char *s = toStringO(r); 24141 ck_assert_str_eq(s, "[3]"); 24142 free(s); 24143 terminateO(self); 24144 24145 END_TEST 24146 24147 24148 START_TEST(insertNSmashSmallJsonSmallArrayGT) 24149 24150 smallArrayt* r; 24151 smallArrayt *self = allocG(rtSmallArrayt); 24152 smallJsont *toInsert = allocSmallJson(); 24153 24154 toInsert->f->pushInt(toInsert, 3); 24155 r = insertNSmashSmallJsonSmallArrayG(self, 0, toInsert); 24156 ck_assert_ptr_ne(r, null); 24157 char *s = toStringO(r); 24158 ck_assert_str_eq(s, "[3]"); 24159 free(s); 24160 terminateO(self); 24161 24162 END_TEST 24163 24164 24165 START_TEST(injectSmallArrayGT) 24166 24167 smallArrayt* r; 24168 smallArrayt *self = allocG(rtSmallArrayt); 24169 baset *value = (baset*) allocSmallInt(8); 24170 24171 r = injectSmallArrayG(self, 0, value); 24172 ck_assert_ptr_ne(r, null); 24173 finishO(value); 24174 char *s = toStringO(r); 24175 ck_assert_str_eq(s, "[8]"); 24176 free(s); 24177 terminateO(self); 24178 24179 END_TEST 24180 24181 24182 START_TEST(injectUndefinedSmallArrayGT) 24183 24184 smallArrayt* r; 24185 smallArrayt *self = allocG(rtSmallArrayt); 24186 24187 r = injectUndefinedSmallArrayG(self, 0, null); 24188 ck_assert_ptr_ne(r, null); 24189 char *s = toStringO(r); 24190 ck_assert_str_eq(s, "[null]"); 24191 free(s); 24192 terminateO(self); 24193 24194 END_TEST 24195 24196 24197 START_TEST(injectBoolSmallArrayGT) 24198 24199 smallArrayt* r; 24200 smallArrayt *self = allocG(rtSmallArrayt); 24201 24202 r = injectBoolSmallArrayG(self, 0, true); 24203 ck_assert_ptr_ne(r, null); 24204 char *s = toStringO(r); 24205 ck_assert_str_eq(s, "[true]"); 24206 free(s); 24207 terminateO(self); 24208 24209 END_TEST 24210 24211 24212 START_TEST(injectDoubleSmallArrayGT) 24213 24214 smallArrayt* r; 24215 smallArrayt *self = allocG(rtSmallArrayt); 24216 24217 r = injectDoubleSmallArrayG(self, 0, 1); 24218 ck_assert_ptr_ne(r, null); 24219 char *s = toStringO(r); 24220 ck_assert_str_eq(s, "[1.000000e+00]"); 24221 free(s); 24222 terminateO(self); 24223 24224 END_TEST 24225 24226 24227 START_TEST(injectIntSmallArrayGT) 24228 24229 smallArrayt* r; 24230 smallArrayt *self = allocG(rtSmallArrayt); 24231 24232 r = injectIntSmallArrayG(self, 0, 2); 24233 ck_assert_ptr_ne(r, null); 24234 char *s = toStringO(r); 24235 ck_assert_str_eq(s, "[2]"); 24236 free(s); 24237 terminateO(self); 24238 24239 END_TEST 24240 24241 24242 START_TEST(injectSSmallArrayGT) 24243 24244 smallArrayt* r; 24245 smallArrayt *self = allocG(rtSmallArrayt); 24246 24247 r = injectSSmallArrayG(self, 0, "qwe"); 24248 ck_assert_ptr_ne(r, null); 24249 char *s = toStringO(r); 24250 ck_assert_str_eq(s, "[\"qwe\"]"); 24251 free(s); 24252 terminateO(self); 24253 24254 END_TEST 24255 24256 24257 START_TEST(injectCharSmallArrayGT) 24258 24259 smallArrayt* r; 24260 smallArrayt *self = allocG(rtSmallArrayt); 24261 24262 r = injectCharSmallArrayG(self, 0, 'a'); 24263 ck_assert_ptr_ne(r, null); 24264 char *s = toStringO(r); 24265 ck_assert_str_eq(s, "[\"a\"]"); 24266 free(s); 24267 terminateO(self); 24268 24269 END_TEST 24270 24271 24272 START_TEST(injectDictSmallArrayGT) 24273 24274 smallArrayt* r; 24275 smallArrayt *self = allocG(rtSmallArrayt); 24276 24277 createSmallDict(d); 24278 r = injectDictSmallArrayG(self, 0, &d); 24279 ck_assert_ptr_ne(r, null); 24280 char *s = toStringO(r); 24281 ck_assert_str_eq(s, "[{}]"); 24282 free(s); 24283 terminateO(self); 24284 24285 END_TEST 24286 24287 24288 START_TEST(injectArraySmallArrayGT) 24289 24290 smallArrayt* r; 24291 smallArrayt *self = allocG(rtSmallArrayt); 24292 24293 createSmallArray(a); 24294 r = injectArraySmallArrayG(self, 0, &a); 24295 ck_assert_ptr_ne(r, null); 24296 char *s = toStringO(r); 24297 ck_assert_str_eq(s, "[[]]"); 24298 free(s); 24299 terminateO(self); 24300 24301 END_TEST 24302 24303 24304 START_TEST(injectArraycSmallArrayGT) 24305 24306 smallArrayt* r; 24307 smallArrayt *self = allocG(rtSmallArrayt); 24308 char **array = listCreateS("a","b"); 24309 24310 r = injectArraycSmallArrayG(self, 0, array); 24311 ck_assert_ptr_ne(r, null); 24312 listFreeS(array); 24313 char *s = toStringO(r); 24314 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 24315 free(s); 24316 terminateO(self); 24317 24318 END_TEST 24319 24320 24321 START_TEST(injectCArraycSmallArrayGT) 24322 24323 smallArrayt* r; 24324 smallArrayt *self = allocG(rtSmallArrayt); 24325 const char *array[] = {"a","b",null}; 24326 24327 r = injectCArraycSmallArrayG(self, 0, array); 24328 ck_assert_ptr_ne(r, null); 24329 char *s = toStringO(r); 24330 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 24331 free(s); 24332 terminateO(self); 24333 24334 END_TEST 24335 24336 24337 START_TEST(injectVoidSmallArrayGT) 24338 24339 smallArrayt* r; 24340 smallArrayt *self = allocG(rtSmallArrayt); 24341 24342 r = injectVoidSmallArrayG(self, 0, null); 24343 ck_assert_ptr_ne(r, null); 24344 char *s = toStringO(r); 24345 ck_assert_str_eq(s, "[null]"); 24346 free(s); 24347 r = injectVoidSmallArrayG(self, 0, &r); 24348 ck_assert_ptr_ne(r, null); 24349 s = toStringO(r); 24350 ck_assert_str_eq(s, "[\"<data container>\",null]"); 24351 free(s); 24352 terminateO(self); 24353 24354 END_TEST 24355 24356 24357 START_TEST(injectSmallBoolSmallArrayGT) 24358 24359 smallArrayt* r; 24360 smallArrayt *self = allocG(rtSmallArrayt); 24361 24362 smallBoolt *b = allocSmallBool(true); 24363 r = injectSmallBoolSmallArrayG(self, 0, b); 24364 ck_assert_ptr_ne(r, null); 24365 finishO(b); 24366 char *s = toStringO(r); 24367 ck_assert_str_eq(s, "[true]"); 24368 free(s); 24369 terminateO(self); 24370 24371 END_TEST 24372 24373 24374 START_TEST(injectSmallBytesSmallArrayGT) 24375 24376 smallArrayt* r; 24377 smallArrayt *self = allocG(rtSmallArrayt); 24378 smallBytest *b = allocSmallBytes("qwe", 3); 24379 24380 r = injectSmallBytesSmallArrayG(self, 0, b); 24381 ck_assert_ptr_ne(r, null); 24382 finishO(b); 24383 char *s = toStringO(r); 24384 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 24385 free(s); 24386 terminateO(self); 24387 24388 END_TEST 24389 24390 24391 START_TEST(injectSmallDoubleSmallArrayGT) 24392 24393 smallArrayt* r; 24394 smallArrayt *self = allocG(rtSmallArrayt); 24395 smallDoublet *value = allocSmallDouble(1); 24396 24397 r = injectSmallDoubleSmallArrayG(self, 0, value); 24398 ck_assert_ptr_ne(r, null); 24399 finishO(value); 24400 char *s = toStringO(r); 24401 ck_assert_str_eq(s, "[1.000000e+00]"); 24402 free(s); 24403 terminateO(self); 24404 24405 END_TEST 24406 24407 24408 START_TEST(injectSmallIntSmallArrayGT) 24409 24410 smallArrayt* r; 24411 smallArrayt *self = allocG(rtSmallArrayt); 24412 smallIntt *value = allocSmallInt(1); 24413 24414 r = injectSmallIntSmallArrayG(self, 0, value); 24415 ck_assert_ptr_ne(r, null); 24416 finishO(value); 24417 char *s = toStringO(r); 24418 ck_assert_str_eq(s, "[1]"); 24419 free(s); 24420 terminateO(self); 24421 24422 END_TEST 24423 24424 24425 START_TEST(injectSmallJsonSmallArrayGT) 24426 24427 smallArrayt* r; 24428 smallArrayt *self = allocG(rtSmallArrayt); 24429 smallJsont *string = allocSmallJson(); 24430 24431 r = injectSmallJsonSmallArrayG(self, 0, string); 24432 ck_assert_ptr_ne(r, null); 24433 finishO(string); 24434 char *s = toStringO(r); 24435 ck_assert_str_eq(s, "[{}]"); 24436 free(s); 24437 terminateO(self); 24438 24439 END_TEST 24440 24441 24442 START_TEST(injectSmallStringSmallArrayGT) 24443 24444 smallArrayt* r; 24445 smallArrayt *self = allocG(rtSmallArrayt); 24446 smallStringt *string = allocSmallString("qwe"); 24447 24448 r = injectSmallStringSmallArrayG(self, 0, string); 24449 ck_assert_ptr_ne(r, null); 24450 finishO(string); 24451 char *s = toStringO(r); 24452 ck_assert_str_eq(s, "[\"qwe\"]"); 24453 free(s); 24454 terminateO(self); 24455 24456 END_TEST 24457 24458 24459 START_TEST(injectSmallContainerSmallArrayGT) 24460 24461 smallArrayt* r; 24462 smallArrayt *self = allocG(rtSmallArrayt); 24463 smallContainert *value = allocSmallContainer(null); 24464 24465 r = injectSmallContainerSmallArrayG(self, 0, value); 24466 ck_assert_ptr_ne(r, null); 24467 finishO(value); 24468 char *s = toStringO(r); 24469 ck_assert_str_eq(s, "[\"<data container>\"]"); 24470 free(s); 24471 terminateO(self); 24472 24473 END_TEST 24474 24475 24476 START_TEST(injectNFreeSmallArrayGT) 24477 24478 smallArrayt* r; 24479 smallArrayt *self = allocG(rtSmallArrayt); 24480 baset *value = (baset*) allocSmallInt(8); 24481 24482 r = injectNFreeSmallArrayG(self, 0, value); 24483 ck_assert_ptr_ne(r, null); 24484 char *s = toStringO(r); 24485 ck_assert_str_eq(s, "[8]"); 24486 free(s); 24487 terminateO(self); 24488 24489 END_TEST 24490 24491 24492 START_TEST(injectNFreeUndefinedSmallArrayGT) 24493 24494 smallArrayt* r; 24495 smallArrayt *self = allocG(rtSmallArrayt); 24496 24497 createAllocateUndefined(u); 24498 r = injectNFreeUndefinedSmallArrayG(self, 0, u); 24499 ck_assert_ptr_ne(r, null); 24500 char *s = toStringO(r); 24501 ck_assert_str_eq(s, "[null]"); 24502 free(s); 24503 terminateO(self); 24504 24505 END_TEST 24506 24507 24508 START_TEST(injectNFreeSSmallArrayGT) 24509 24510 smallArrayt* r; 24511 smallArrayt *self = allocG(rtSmallArrayt); 24512 char *string = strdup("qwe"); 24513 24514 r = injectNFreeSSmallArrayG(self, 0, string); 24515 ck_assert_ptr_ne(r, null); 24516 char *s = toStringO(r); 24517 ck_assert_str_eq(s, "[\"qwe\"]"); 24518 free(s); 24519 terminateO(self); 24520 24521 END_TEST 24522 24523 24524 START_TEST(injectNFreeDictSmallArrayGT) 24525 24526 smallArrayt* r; 24527 smallArrayt *self = allocG(rtSmallArrayt); 24528 24529 createAllocateSmallDict(d); 24530 r = injectNFreeDictSmallArrayG(self, 0, d); 24531 ck_assert_ptr_ne(r, null); 24532 char *s = toStringO(r); 24533 ck_assert_str_eq(s, "[{}]"); 24534 free(s); 24535 terminateO(self); 24536 24537 END_TEST 24538 24539 24540 START_TEST(injectNFreeArraySmallArrayGT) 24541 24542 smallArrayt* r; 24543 smallArrayt *self = allocG(rtSmallArrayt); 24544 24545 createAllocateSmallArray(a); 24546 r = injectNFreeArraySmallArrayG(self, 0, a); 24547 ck_assert_ptr_ne(r, null); 24548 char *s = toStringO(r); 24549 ck_assert_str_eq(s, "[[]]"); 24550 free(s); 24551 terminateO(self); 24552 24553 END_TEST 24554 24555 24556 START_TEST(injectNFreeArraycSmallArrayGT) 24557 24558 smallArrayt* r; 24559 smallArrayt *self = allocG(rtSmallArrayt); 24560 char **array = listCreateS("a","b"); 24561 24562 r = injectNFreeArraycSmallArrayG(self, 0, array); 24563 ck_assert_ptr_ne(r, null); 24564 char *s = toStringO(r); 24565 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 24566 free(s); 24567 terminateO(self); 24568 24569 END_TEST 24570 24571 24572 START_TEST(injectNFreeSmallBoolSmallArrayGT) 24573 24574 smallArrayt* r; 24575 smallArrayt *self = allocG(rtSmallArrayt); 24576 24577 smallBoolt *b = allocSmallBool(true); 24578 r = injectNFreeSmallBoolSmallArrayG(self, 0, b); 24579 ck_assert_ptr_ne(r, null); 24580 char *s = toStringO(r); 24581 ck_assert_str_eq(s, "[true]"); 24582 free(s); 24583 terminateO(self); 24584 24585 END_TEST 24586 24587 24588 START_TEST(injectNFreeSmallBytesSmallArrayGT) 24589 24590 smallArrayt* r; 24591 smallArrayt *self = allocG(rtSmallArrayt); 24592 smallBytest *b = allocSmallBytes("qwe", 3); 24593 24594 r = injectNFreeSmallBytesSmallArrayG(self, 0, b); 24595 ck_assert_ptr_ne(r, null); 24596 char *s = toStringO(r); 24597 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 24598 free(s); 24599 terminateO(self); 24600 24601 END_TEST 24602 24603 24604 START_TEST(injectNFreeSmallDoubleSmallArrayGT) 24605 24606 smallArrayt* r; 24607 smallArrayt *self = allocG(rtSmallArrayt); 24608 smallDoublet *value = allocSmallDouble(1); 24609 24610 r = injectNFreeSmallDoubleSmallArrayG(self, 0, value); 24611 ck_assert_ptr_ne(r, null); 24612 char *s = toStringO(r); 24613 ck_assert_str_eq(s, "[1.000000e+00]"); 24614 free(s); 24615 terminateO(self); 24616 24617 END_TEST 24618 24619 24620 START_TEST(injectNFreeSmallIntSmallArrayGT) 24621 24622 smallArrayt* r; 24623 smallArrayt *self = allocG(rtSmallArrayt); 24624 smallIntt *value = allocSmallInt(1); 24625 24626 r = injectNFreeSmallIntSmallArrayG(self, 0, value); 24627 ck_assert_ptr_ne(r, null); 24628 char *s = toStringO(r); 24629 ck_assert_str_eq(s, "[1]"); 24630 free(s); 24631 terminateO(self); 24632 24633 END_TEST 24634 24635 24636 START_TEST(injectNFreeSmallJsonSmallArrayGT) 24637 24638 smallArrayt* r; 24639 smallArrayt *self = allocG(rtSmallArrayt); 24640 smallJsont *string = allocSmallJson(); 24641 24642 r = injectNFreeSmallJsonSmallArrayG(self, 0, string); 24643 ck_assert_ptr_ne(r, null); 24644 char *s = toStringO(r); 24645 ck_assert_str_eq(s, "[{}]"); 24646 free(s); 24647 terminateO(self); 24648 24649 END_TEST 24650 24651 24652 START_TEST(injectNFreeSmallStringSmallArrayGT) 24653 24654 smallArrayt* r; 24655 smallArrayt *self = allocG(rtSmallArrayt); 24656 smallStringt *string = allocSmallString("qwe"); 24657 24658 r = injectNFreeSmallStringSmallArrayG(self, 0, string); 24659 ck_assert_ptr_ne(r, null); 24660 char *s = toStringO(r); 24661 ck_assert_str_eq(s, "[\"qwe\"]"); 24662 free(s); 24663 terminateO(self); 24664 24665 END_TEST 24666 24667 24668 START_TEST(injectNFreeSmallContainerSmallArrayGT) 24669 24670 smallArrayt* r; 24671 smallArrayt *self = allocG(rtSmallArrayt); 24672 smallContainert *value = allocSmallContainer(null); 24673 24674 r = injectNFreeSmallContainerSmallArrayG(self, 0, value); 24675 ck_assert_ptr_ne(r, null); 24676 char *s = toStringO(r); 24677 ck_assert_str_eq(s, "[\"<data container>\"]"); 24678 free(s); 24679 terminateO(self); 24680 24681 END_TEST 24682 24683 24684 START_TEST(delSmallArrayGT) 24685 24686 smallArrayt* r; 24687 smallArrayt *self = allocG(rtSmallArrayt); 24688 24689 r = self->f->pushInt(self, 1); 24690 ck_assert_ptr_ne(r, null); 24691 r = self->f->pushInt(self, 2); 24692 ck_assert_ptr_ne(r, null); 24693 r = self->f->pushInt(self, 3); 24694 ck_assert_ptr_ne(r, null); 24695 r = self->f->pushInt(self, 4); 24696 ck_assert_ptr_ne(r, null); 24697 r = delSmallArrayG(self, 1, -1); 24698 ck_assert_ptr_ne(r, null); 24699 char *s = toStringO(r); 24700 ck_assert_str_eq(s, "[1,4]"); 24701 free(s); 24702 terminateO(self); 24703 24704 END_TEST 24705 24706 24707 START_TEST(delElemSmallArrayGT) 24708 24709 smallArrayt* r; 24710 smallArrayt *self = allocG(rtSmallArrayt); 24711 24712 r = self->f->pushInt(self, 1); 24713 ck_assert_ptr_ne(r, null); 24714 r = self->f->pushInt(self, 2); 24715 ck_assert_ptr_ne(r, null); 24716 r = self->f->pushInt(self, 3); 24717 ck_assert_ptr_ne(r, null); 24718 r = self->f->pushInt(self, 4); 24719 ck_assert_ptr_ne(r, null); 24720 r = delElemSmallArrayG(self, 0); 24721 ck_assert_ptr_ne(r, null); 24722 char *s = toStringO(r); 24723 ck_assert_str_eq(s, "[2,3,4]"); 24724 free(s); 24725 r = delElemSmallArrayG(self, -1); 24726 ck_assert_ptr_ne(r, null); 24727 s = toStringO(r); 24728 ck_assert_str_eq(s, "[2,3]"); 24729 free(s); 24730 r = delElemSmallArrayG(self, 5); 24731 ck_assert_ptr_eq(r, null); 24732 r = delElemSmallArrayG(self, -5); 24733 ck_assert_ptr_eq(r, null); 24734 terminateO(self); 24735 24736 END_TEST 24737 24738 24739 START_TEST(removeSmallArrayGT) 24740 24741 smallArrayt* r; 24742 smallArrayt *self = allocG(rtSmallArrayt); 24743 24744 r = self->f->pushInt(self, 1); 24745 ck_assert_ptr_ne(r, null); 24746 r = self->f->pushInt(self, 2); 24747 ck_assert_ptr_ne(r, null); 24748 r = self->f->pushInt(self, 3); 24749 ck_assert_ptr_ne(r, null); 24750 r = self->f->pushInt(self, 4); 24751 ck_assert_ptr_ne(r, null); 24752 24753 smallIntt *e[4]; 24754 arange(i,e) { 24755 e[i] = self->f->getAtSmallInt(self, i); 24756 } 24757 24758 // negative index 24759 r = removeSmallArrayG(self, 1, -1); 24760 ck_assert_ptr_ne(r, null); 24761 char *s = toStringO(self); 24762 ck_assert_str_eq(s, "[1,4]"); 24763 free(s); 24764 r = removeSmallArrayG(self, 0, 40); 24765 ck_assert_ptr_ne(r, null); 24766 s = toStringO(self); 24767 ck_assert_str_eq(s, "[]"); 24768 free(s); 24769 arange(i,e) { 24770 terminateO(e[i]); 24771 } 24772 terminateO(self); 24773 24774 END_TEST 24775 24776 24777 START_TEST(removeElemSmallArrayGT) 24778 24779 smallArrayt* r; 24780 smallArrayt *self = allocG(rtSmallArrayt); 24781 24782 r = self->f->pushInt(self, 1); 24783 ck_assert_ptr_ne(r, null); 24784 r = self->f->pushInt(self, 2); 24785 ck_assert_ptr_ne(r, null); 24786 r = self->f->pushInt(self, 3); 24787 ck_assert_ptr_ne(r, null); 24788 r = self->f->pushInt(self, 4); 24789 ck_assert_ptr_ne(r, null); 24790 smallIntt *e = self->f->getAtSmallInt(self, 1);; 24791 r = removeElemSmallArrayG(self, 1); 24792 ck_assert_ptr_ne(r, null); 24793 terminateO(e); 24794 char *s = toStringO(self); 24795 ck_assert_str_eq(s, "[1,3,4]"); 24796 free(s); 24797 terminateO(self); 24798 24799 END_TEST 24800 24801 24802 START_TEST(sortSmallArrayGT) 24803 24804 smallArrayt* r; 24805 smallArrayt *self = allocG(rtSmallArrayt); 24806 24807 self->f->pushS(self, "bb"); 24808 self->f->pushS(self, "a"); 24809 r = sortSmallArrayG(self); 24810 ck_assert_ptr_ne(r, null); 24811 char *s = toStringO(r); 24812 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 24813 free(s); 24814 terminateO(self); 24815 24816 END_TEST 24817 24818 24819 START_TEST(sortFSmallArrayGT) 24820 24821 smallArrayt* r; 24822 smallArrayt *self = allocG(rtSmallArrayt); 24823 24824 // sort dict 24825 smallDictt *d[4]; 24826 arange(i,d) d[i] = allocSmallDict(); 24827 d[0]->f->setInt(d[0], "a", 1); 24828 d[1]->f->setInt(d[1], "a", 0); 24829 d[3]->f->setInt(d[3], "a", 0); 24830 d[3]->f->setInt(d[3], "b", 0); 24831 arange(i,d) self->f->pushNFreeDict(self, d[i]); 24832 r = sortFSmallArrayG(self, sortFOCmp); 24833 ck_assert_ptr_ne(r, null); 24834 char *s = toStringO(r); 24835 ck_assert_str_eq(s, "[{},{\"a\":0},{\"a\":1},{\"a\":0,\"b\":0}]"); 24836 free(s); 24837 terminateO(self); 24838 24839 END_TEST 24840 24841 24842 START_TEST(icSortSmallArrayGT) 24843 24844 smallArrayt* r; 24845 smallArrayt *self = allocG(rtSmallArrayt); 24846 24847 self->f->pushS(self, "bb"); 24848 self->f->pushS(self, "A"); 24849 r = icSortSmallArrayG(self); 24850 ck_assert_ptr_ne(r, null); 24851 char *s = toStringO(r); 24852 ck_assert_str_eq(s, "[\"A\",\"bb\"]"); 24853 free(s); 24854 terminateO(self); 24855 24856 END_TEST 24857 24858 24859 START_TEST(equalSmallArrayGT) 24860 24861 bool r; 24862 smallArrayt *self = allocG(rtSmallArrayt); 24863 smallArrayt *array = allocSmallArray(); 24864 24865 r = equalSmallArrayG(self, array); 24866 ck_assert(r); 24867 terminateO(array); 24868 terminateO(self); 24869 24870 END_TEST 24871 24872 24873 START_TEST(equalSmallArraySmallJsonGT) 24874 24875 bool r; 24876 smallArrayt *self = allocG(rtSmallArrayt); 24877 smallJsont *array = allocSmallJson(); 24878 24879 r = equalSmallArraySmallJsonG(self, array); 24880 // the smallJson is empty, so the result is false 24881 ck_assert(!r); 24882 terminateO(self); 24883 terminateO(array); 24884 24885 END_TEST 24886 24887 24888 START_TEST(equalSmallArrayArrayGT) 24889 24890 bool r; 24891 smallArrayt* self = allocG(rtSmallArrayt); 24892 24893 r = equalSmallArrayArrayG(self, null); 24894 ck_assert(r); 24895 terminateO(self); 24896 24897 END_TEST 24898 24899 24900 START_TEST(equalSmallArrayCArrayGT) 24901 24902 bool r; 24903 smallArrayt* self = allocG(rtSmallArrayt); 24904 24905 r = equalSmallArrayCArrayG(self, null); 24906 ck_assert(r); 24907 terminateO(self); 24908 24909 END_TEST 24910 24911 24912 START_TEST(equalSmallArrayBaseGT) 24913 24914 bool r; 24915 smallArrayt* self = allocG(rtSmallArrayt); 24916 baset* p2 = (baset*) allocG(1); 24917 24918 r = equalSmallArrayBaseG(self, p2); 24919 ck_assert(!r); 24920 terminateO(p2); 24921 terminateO(self); 24922 24923 END_TEST 24924 24925 24926 START_TEST(icEqualSmallArrayGT) 24927 24928 bool r; 24929 smallArrayt *self = allocG(rtSmallArrayt); 24930 smallArrayt *array = allocG(rtSmallArrayt); 24931 24932 self->f->pushS(self, "a"); 24933 array->f->pushS(array, "A"); 24934 r = icEqualSmallArrayG(self, array); 24935 ck_assert(r); 24936 terminateO(array); 24937 terminateO(self); 24938 24939 END_TEST 24940 24941 24942 START_TEST(icEqualSmallArraySmallJsonGT) 24943 24944 bool r; 24945 smallArrayt *self = allocG(rtSmallArrayt); 24946 smallJsont *array = allocSmallJson(); 24947 24948 r = icEqualSmallArraySmallJsonG(self, array); 24949 ck_assert(!r); 24950 terminateO(array); 24951 terminateO(self); 24952 24953 END_TEST 24954 24955 24956 START_TEST(icEqualSmallArrayArrayGT) 24957 24958 bool r; 24959 smallArrayt* self = allocG(rtSmallArrayt); 24960 24961 r = icEqualSmallArrayArrayG(self, null); 24962 ck_assert(r); 24963 terminateO(self); 24964 24965 END_TEST 24966 24967 24968 START_TEST(icEqualSmallArrayCArrayGT) 24969 24970 bool r; 24971 smallArrayt* self = allocG(rtSmallArrayt); 24972 24973 r = icEqualSmallArrayCArrayG(self, null); 24974 ck_assert(r); 24975 terminateO(self); 24976 24977 END_TEST 24978 24979 24980 START_TEST(icEqualSmallArrayBaseGT) 24981 24982 bool r; 24983 smallArrayt* self = allocG(rtSmallArrayt); 24984 24985 r = icEqualSmallArrayBaseG(self, null); 24986 ck_assert(!r); 24987 terminateO(self); 24988 24989 END_TEST 24990 24991 24992 START_TEST(lenSmallArrayGT) 24993 24994 size_t r; 24995 smallArrayt *self = allocG(rtSmallArrayt); 24996 24997 self->f->pushInt(self, 1); 24998 r = lenSmallArrayG(self); 24999 ck_assert_int_eq(r, 1); 25000 terminateO(self); 25001 25002 END_TEST 25003 25004 25005 START_TEST(trimSmallArrayGT) 25006 25007 smallArrayt* r; 25008 smallArrayt *self = allocG(rtSmallArrayt); 25009 25010 self->f->pushInt(self, 1); 25011 delElemO(self, 0); 25012 r = trimSmallArrayG(self); 25013 ck_assert_ptr_ne(r, null); 25014 ck_assert_int_eq(lenSmallArrayG(self), 0); 25015 terminateO(self); 25016 25017 END_TEST 25018 25019 25020 START_TEST(hasSmallArrayGT) 25021 25022 bool r; 25023 smallArrayt *self = allocG(rtSmallArrayt); 25024 25025 r = hasSmallArrayG(self, null); 25026 ck_assert(!r); 25027 terminateO(self); 25028 25029 END_TEST 25030 25031 25032 START_TEST(hasUndefinedSmallArrayGT) 25033 25034 bool r; 25035 smallArrayt *self = allocG(rtSmallArrayt); 25036 25037 r = hasUndefinedSmallArrayG(self, null); 25038 ck_assert(!r); 25039 terminateO(self); 25040 25041 END_TEST 25042 25043 25044 START_TEST(hasBoolSmallArrayGT) 25045 25046 bool r; 25047 smallArrayt *self = allocG(rtSmallArrayt); 25048 25049 r = hasBoolSmallArrayG(self, true); 25050 ck_assert(!r); 25051 terminateO(self); 25052 25053 END_TEST 25054 25055 25056 START_TEST(hasDoubleSmallArrayGT) 25057 25058 bool r; 25059 smallArrayt *self = allocG(rtSmallArrayt); 25060 25061 r = hasDoubleSmallArrayG(self, 1); 25062 ck_assert(!r); 25063 terminateO(self); 25064 25065 END_TEST 25066 25067 25068 START_TEST(hasIntSmallArrayGT) 25069 25070 bool r; 25071 smallArrayt *self = allocG(rtSmallArrayt); 25072 25073 r = hasIntSmallArrayG(self, 1); 25074 ck_assert(!r); 25075 terminateO(self); 25076 25077 END_TEST 25078 25079 25080 START_TEST(hasSSmallArrayGT) 25081 25082 bool r; 25083 smallArrayt *self = allocG(rtSmallArrayt); 25084 25085 r = hasSSmallArrayG(self, null); 25086 ck_assert(!r); 25087 terminateO(self); 25088 25089 END_TEST 25090 25091 25092 START_TEST(hasCharSmallArrayGT) 25093 25094 bool r; 25095 smallArrayt *self = allocG(rtSmallArrayt); 25096 25097 r = hasCharSmallArrayG(self, ' '); 25098 ck_assert(!r); 25099 terminateO(self); 25100 25101 END_TEST 25102 25103 25104 START_TEST(hasDictSmallArrayGT) 25105 25106 bool r; 25107 smallArrayt *self = allocG(rtSmallArrayt); 25108 25109 r = hasDictSmallArrayG(self, null); 25110 ck_assert(!r); 25111 terminateO(self); 25112 25113 END_TEST 25114 25115 25116 START_TEST(hasArraySmallArrayGT) 25117 25118 bool r; 25119 smallArrayt *self = allocG(rtSmallArrayt); 25120 25121 r = hasArraySmallArrayG(self, null); 25122 ck_assert(!r); 25123 terminateO(self); 25124 25125 END_TEST 25126 25127 25128 START_TEST(hasArraycSmallArrayGT) 25129 25130 bool r; 25131 smallArrayt *self = allocG(rtSmallArrayt); 25132 25133 r = hasArraycSmallArrayG(self, null); 25134 ck_assert(!r); 25135 terminateO(self); 25136 25137 END_TEST 25138 25139 25140 START_TEST(hasCArraycSmallArrayGT) 25141 25142 bool r; 25143 smallArrayt *self = allocG(rtSmallArrayt); 25144 25145 r = hasCArraycSmallArrayG(self, null); 25146 ck_assert(!r); 25147 terminateO(self); 25148 25149 END_TEST 25150 25151 25152 START_TEST(hasSmallBoolSmallArrayGT) 25153 25154 bool r; 25155 smallArrayt *self = allocG(rtSmallArrayt); 25156 25157 r = hasSmallBoolSmallArrayG(self, null); 25158 ck_assert(!r); 25159 terminateO(self); 25160 25161 END_TEST 25162 25163 25164 START_TEST(hasSmallBytesSmallArrayGT) 25165 25166 bool r; 25167 smallArrayt *self = allocG(rtSmallArrayt); 25168 25169 r = hasSmallBytesSmallArrayG(self, null); 25170 ck_assert(!r); 25171 terminateO(self); 25172 25173 END_TEST 25174 25175 25176 START_TEST(hasSmallDoubleSmallArrayGT) 25177 25178 bool r; 25179 smallArrayt *self = allocG(rtSmallArrayt); 25180 25181 r = hasSmallDoubleSmallArrayG(self, null); 25182 ck_assert(!r); 25183 terminateO(self); 25184 25185 END_TEST 25186 25187 25188 START_TEST(hasSmallIntSmallArrayGT) 25189 25190 bool r; 25191 smallArrayt *self = allocG(rtSmallArrayt); 25192 25193 r = hasSmallIntSmallArrayG(self, null); 25194 ck_assert(!r); 25195 terminateO(self); 25196 25197 END_TEST 25198 25199 25200 START_TEST(hasSmallJsonSmallArrayGT) 25201 25202 bool r; 25203 smallArrayt *self = allocG(rtSmallArrayt); 25204 25205 r = hasSmallJsonSmallArrayG(self, null); 25206 ck_assert(!r); 25207 terminateO(self); 25208 25209 END_TEST 25210 25211 25212 START_TEST(hasSmallStringSmallArrayGT) 25213 25214 bool r; 25215 smallArrayt *self = allocG(rtSmallArrayt); 25216 25217 r = hasSmallStringSmallArrayG(self, null); 25218 ck_assert(!r); 25219 terminateO(self); 25220 25221 END_TEST 25222 25223 25224 START_TEST(hasSmallContainerSmallArrayGT) 25225 25226 bool r; 25227 smallArrayt *self = allocG(rtSmallArrayt); 25228 25229 r = hasSmallContainerSmallArrayG(self, null); 25230 ck_assert(!r); 25231 terminateO(self); 25232 25233 END_TEST 25234 25235 25236 START_TEST(indexOfSmallArrayGT) 25237 25238 ssize_t r; 25239 smallArrayt *self = allocG(rtSmallArrayt); 25240 25241 r = indexOfSmallArrayG(self, null); 25242 ck_assert_int_eq(r, -1); 25243 terminateO(self); 25244 25245 END_TEST 25246 25247 25248 START_TEST(indexOfUndefinedSmallArrayGT) 25249 25250 ssize_t r; 25251 smallArrayt *self = allocG(rtSmallArrayt); 25252 25253 r = indexOfUndefinedSmallArrayG(self, null); 25254 ck_assert_int_eq(r, -1); 25255 terminateO(self); 25256 25257 END_TEST 25258 25259 25260 START_TEST(indexOfBoolSmallArrayGT) 25261 25262 ssize_t r; 25263 smallArrayt *self = allocG(rtSmallArrayt); 25264 25265 r = indexOfBoolSmallArrayG(self, false); 25266 ck_assert_int_eq(r, -1); 25267 terminateO(self); 25268 25269 END_TEST 25270 25271 25272 START_TEST(indexOfDoubleSmallArrayGT) 25273 25274 ssize_t r; 25275 smallArrayt *self = allocG(rtSmallArrayt); 25276 25277 r = indexOfDoubleSmallArrayG(self, 0); 25278 ck_assert_int_eq(r, -1); 25279 terminateO(self); 25280 25281 END_TEST 25282 25283 25284 START_TEST(indexOfIntSmallArrayGT) 25285 25286 ssize_t r; 25287 smallArrayt *self = allocG(rtSmallArrayt); 25288 25289 r = indexOfIntSmallArrayG(self, 0); 25290 ck_assert_int_eq(r, -1); 25291 terminateO(self); 25292 25293 END_TEST 25294 25295 25296 START_TEST(indexOfSSmallArrayGT) 25297 25298 ssize_t r; 25299 smallArrayt *self = allocG(rtSmallArrayt); 25300 25301 r = indexOfSSmallArrayG(self, null); 25302 ck_assert_int_eq(r, -1); 25303 terminateO(self); 25304 25305 END_TEST 25306 25307 25308 START_TEST(indexOfCharSmallArrayGT) 25309 25310 ssize_t r; 25311 smallArrayt *self = allocG(rtSmallArrayt); 25312 25313 r = indexOfCharSmallArrayG(self, ' '); 25314 ck_assert_int_eq(r, -1); 25315 terminateO(self); 25316 25317 END_TEST 25318 25319 25320 START_TEST(indexOfDictSmallArrayGT) 25321 25322 ssize_t r; 25323 smallArrayt *self = allocG(rtSmallArrayt); 25324 25325 r = indexOfDictSmallArrayG(self, null); 25326 ck_assert_int_eq(r, -1); 25327 terminateO(self); 25328 25329 END_TEST 25330 25331 25332 START_TEST(indexOfArraySmallArrayGT) 25333 25334 ssize_t r; 25335 smallArrayt *self = allocG(rtSmallArrayt); 25336 25337 r = indexOfArraySmallArrayG(self, null); 25338 ck_assert_int_eq(r, -1); 25339 terminateO(self); 25340 25341 END_TEST 25342 25343 25344 START_TEST(indexOfArraycSmallArrayGT) 25345 25346 ssize_t r; 25347 smallArrayt *self = allocG(rtSmallArrayt); 25348 25349 r = indexOfArraycSmallArrayG(self, null); 25350 ck_assert_int_eq(r, -1); 25351 terminateO(self); 25352 25353 END_TEST 25354 25355 25356 START_TEST(indexOfCArraycSmallArrayGT) 25357 25358 ssize_t r; 25359 smallArrayt *self = allocG(rtSmallArrayt); 25360 25361 r = indexOfCArraycSmallArrayG(self, null); 25362 ck_assert_int_eq(r, -1); 25363 terminateO(self); 25364 25365 END_TEST 25366 25367 25368 START_TEST(indexOfSmallBoolSmallArrayGT) 25369 25370 ssize_t r; 25371 smallArrayt *self = allocG(rtSmallArrayt); 25372 25373 r = indexOfSmallBoolSmallArrayG(self, null); 25374 ck_assert_int_eq(r, -1); 25375 terminateO(self); 25376 25377 END_TEST 25378 25379 25380 START_TEST(indexOfSmallBytesSmallArrayGT) 25381 25382 ssize_t r; 25383 smallArrayt *self = allocG(rtSmallArrayt); 25384 25385 r = indexOfSmallBytesSmallArrayG(self, null); 25386 ck_assert_int_eq(r, -1); 25387 terminateO(self); 25388 25389 END_TEST 25390 25391 25392 START_TEST(indexOfSmallDoubleSmallArrayGT) 25393 25394 ssize_t r; 25395 smallArrayt *self = allocG(rtSmallArrayt); 25396 25397 r = indexOfSmallDoubleSmallArrayG(self, null); 25398 ck_assert_int_eq(r, -1); 25399 terminateO(self); 25400 25401 END_TEST 25402 25403 25404 START_TEST(indexOfSmallIntSmallArrayGT) 25405 25406 ssize_t r; 25407 smallArrayt *self = allocG(rtSmallArrayt); 25408 25409 r = indexOfSmallIntSmallArrayG(self, null); 25410 ck_assert_int_eq(r, -1); 25411 terminateO(self); 25412 25413 END_TEST 25414 25415 25416 START_TEST(indexOfSmallJsonSmallArrayGT) 25417 25418 ssize_t r; 25419 smallArrayt *self = allocG(rtSmallArrayt); 25420 25421 r = indexOfSmallJsonSmallArrayG(self, null); 25422 ck_assert_int_eq(r, -1); 25423 terminateO(self); 25424 25425 END_TEST 25426 25427 25428 START_TEST(indexOfSmallStringSmallArrayGT) 25429 25430 ssize_t r; 25431 smallArrayt *self = allocG(rtSmallArrayt); 25432 25433 r = indexOfSmallStringSmallArrayG(self, null); 25434 ck_assert_int_eq(r, -1); 25435 terminateO(self); 25436 25437 END_TEST 25438 25439 25440 START_TEST(indexOfSmallContainerSmallArrayGT) 25441 25442 ssize_t r; 25443 smallArrayt *self = allocG(rtSmallArrayt); 25444 25445 r = indexOfSmallContainerSmallArrayG(self, null); 25446 ck_assert_int_eq(r, -1); 25447 terminateO(self); 25448 25449 END_TEST 25450 25451 25452 START_TEST(binarySearchSmallArrayGT) 25453 25454 ssize_t r; 25455 smallArrayt *self = allocG(rtSmallArrayt); 25456 25457 r = binarySearchSmallArrayG(self, null); 25458 ck_assert_int_eq(r, -1); 25459 terminateO(self); 25460 25461 END_TEST 25462 25463 25464 START_TEST(binarySearchUndefinedSmallArrayGT) 25465 25466 ssize_t r; 25467 smallArrayt *self = allocG(rtSmallArrayt); 25468 25469 r = binarySearchUndefinedSmallArrayG(self, null); 25470 ck_assert_int_eq(r, -1); 25471 terminateO(self); 25472 25473 END_TEST 25474 25475 25476 START_TEST(binarySearchBoolSmallArrayGT) 25477 25478 ssize_t r; 25479 smallArrayt *self = allocG(rtSmallArrayt); 25480 25481 r = binarySearchBoolSmallArrayG(self, false); 25482 ck_assert_int_eq(r, -1); 25483 terminateO(self); 25484 25485 END_TEST 25486 25487 25488 START_TEST(binarySearchDoubleSmallArrayGT) 25489 25490 ssize_t r; 25491 smallArrayt *self = allocG(rtSmallArrayt); 25492 25493 r = binarySearchDoubleSmallArrayG(self, 0); 25494 ck_assert_int_eq(r, -1); 25495 terminateO(self); 25496 25497 END_TEST 25498 25499 25500 START_TEST(binarySearchIntSmallArrayGT) 25501 25502 ssize_t r; 25503 smallArrayt *self = allocG(rtSmallArrayt); 25504 25505 r = binarySearchIntSmallArrayG(self, 0); 25506 ck_assert_int_eq(r, -1); 25507 terminateO(self); 25508 25509 END_TEST 25510 25511 25512 START_TEST(binarySearchSSmallArrayGT) 25513 25514 ssize_t r; 25515 smallArrayt *self = allocG(rtSmallArrayt); 25516 25517 r = binarySearchSSmallArrayG(self, null); 25518 ck_assert_int_eq(r, -1); 25519 terminateO(self); 25520 25521 END_TEST 25522 25523 25524 START_TEST(binarySearchCharSmallArrayGT) 25525 25526 ssize_t r; 25527 smallArrayt *self = allocG(rtSmallArrayt); 25528 25529 r = binarySearchCharSmallArrayG(self, ' '); 25530 ck_assert_int_eq(r, -1); 25531 terminateO(self); 25532 25533 END_TEST 25534 25535 25536 START_TEST(binarySearchDictSmallArrayGT) 25537 25538 ssize_t r; 25539 smallArrayt *self = allocG(rtSmallArrayt); 25540 25541 r = binarySearchDictSmallArrayG(self, null); 25542 ck_assert_int_eq(r, -1); 25543 terminateO(self); 25544 25545 END_TEST 25546 25547 25548 START_TEST(binarySearchArraySmallArrayGT) 25549 25550 ssize_t r; 25551 smallArrayt *self = allocG(rtSmallArrayt); 25552 25553 r = binarySearchArraySmallArrayG(self, null); 25554 ck_assert_int_eq(r, -1); 25555 terminateO(self); 25556 25557 END_TEST 25558 25559 25560 START_TEST(binarySearchArraycSmallArrayGT) 25561 25562 ssize_t r; 25563 smallArrayt *self = allocG(rtSmallArrayt); 25564 25565 r = binarySearchArraycSmallArrayG(self, null); 25566 ck_assert_int_eq(r, -1); 25567 terminateO(self); 25568 25569 END_TEST 25570 25571 25572 START_TEST(binarySearchCArraycSmallArrayGT) 25573 25574 ssize_t r; 25575 smallArrayt *self = allocG(rtSmallArrayt); 25576 25577 r = binarySearchCArraycSmallArrayG(self, null); 25578 ck_assert_int_eq(r, -1); 25579 terminateO(self); 25580 25581 END_TEST 25582 25583 25584 START_TEST(binarySearchSmallBoolSmallArrayGT) 25585 25586 ssize_t r; 25587 smallArrayt *self = allocG(rtSmallArrayt); 25588 25589 r = binarySearchSmallBoolSmallArrayG(self, null); 25590 ck_assert_int_eq(r, -1); 25591 terminateO(self); 25592 25593 END_TEST 25594 25595 25596 START_TEST(binarySearchSmallBytesSmallArrayGT) 25597 25598 ssize_t r; 25599 smallArrayt *self = allocG(rtSmallArrayt); 25600 25601 r = binarySearchSmallBytesSmallArrayG(self, null); 25602 ck_assert_int_eq(r, -1); 25603 terminateO(self); 25604 25605 END_TEST 25606 25607 25608 START_TEST(binarySearchSmallDoubleSmallArrayGT) 25609 25610 ssize_t r; 25611 smallArrayt *self = allocG(rtSmallArrayt); 25612 25613 r = binarySearchSmallDoubleSmallArrayG(self, null); 25614 ck_assert_int_eq(r, -1); 25615 terminateO(self); 25616 25617 END_TEST 25618 25619 25620 START_TEST(binarySearchSmallIntSmallArrayGT) 25621 25622 ssize_t r; 25623 smallArrayt *self = allocG(rtSmallArrayt); 25624 25625 r = binarySearchSmallIntSmallArrayG(self, null); 25626 ck_assert_int_eq(r, -1); 25627 terminateO(self); 25628 25629 END_TEST 25630 25631 25632 START_TEST(binarySearchSmallJsonSmallArrayGT) 25633 25634 ssize_t r; 25635 smallArrayt *self = allocG(rtSmallArrayt); 25636 25637 r = binarySearchSmallJsonSmallArrayG(self, null); 25638 ck_assert_int_eq(r, -1); 25639 terminateO(self); 25640 25641 END_TEST 25642 25643 25644 START_TEST(binarySearchSmallStringSmallArrayGT) 25645 25646 ssize_t r; 25647 smallArrayt *self = allocG(rtSmallArrayt); 25648 25649 r = binarySearchSmallStringSmallArrayG(self, null); 25650 ck_assert_int_eq(r, -1); 25651 terminateO(self); 25652 25653 END_TEST 25654 25655 25656 START_TEST(binarySearchSmallContainerSmallArrayGT) 25657 25658 ssize_t r; 25659 smallArrayt *self = allocG(rtSmallArrayt); 25660 25661 r = binarySearchSmallContainerSmallArrayG(self, null); 25662 ck_assert_int_eq(r, -1); 25663 terminateO(self); 25664 25665 END_TEST 25666 25667 25668 START_TEST(uniqSmallArrayGT) 25669 25670 smallArrayt* r; 25671 smallArrayt *self = allocG(rtSmallArrayt); 25672 25673 self->f->pushUndefined(self); 25674 self->f->pushBool(self, true); 25675 self->f->pushNFreeDict(self, allocSmallDict()); 25676 self->f->pushDouble(self, 1); 25677 self->f->pushInt(self, 2); 25678 self->f->pushS(self, ""); 25679 self->f->pushNFreeArray(self, allocSmallArray()); 25680 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 25681 self->f->pushUndefined(self); 25682 self->f->pushBool(self, true); 25683 self->f->pushNFreeDict(self, allocSmallDict()); 25684 self->f->pushDouble(self, 1); 25685 self->f->pushInt(self, 2); 25686 self->f->pushS(self, ""); 25687 self->f->pushNFreeArray(self, allocSmallArray()); 25688 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 25689 r = uniqSmallArrayG(self, 0); 25690 ck_assert_ptr_ne(r, NULL); 25691 char *s = toStringO(r); 25692 ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"\",[],[0x71,0x77,0x65,0x00]]"); 25693 free(s); 25694 terminateO(self); 25695 25696 END_TEST 25697 25698 25699 START_TEST(icHasSmallArrayGT) 25700 25701 bool r; 25702 smallArrayt *self = allocG(rtSmallArrayt); 25703 25704 r = icHasSmallArrayG(self, null); 25705 ck_assert(!r); 25706 terminateO(self); 25707 25708 END_TEST 25709 25710 25711 START_TEST(icHasSSmallArrayGT) 25712 25713 bool r; 25714 smallArrayt *self = allocG(rtSmallArrayt); 25715 25716 r = icHasSSmallArrayG(self, null); 25717 ck_assert(!r); 25718 terminateO(self); 25719 25720 END_TEST 25721 25722 25723 START_TEST(icHasCharSmallArrayGT) 25724 25725 bool r; 25726 smallArrayt *self = allocG(rtSmallArrayt); 25727 25728 r = icHasCharSmallArrayG(self, 'a'); 25729 ck_assert(!r); 25730 terminateO(self); 25731 25732 END_TEST 25733 25734 25735 START_TEST(icHasDictSmallArrayGT) 25736 25737 bool r; 25738 smallArrayt *self = allocG(rtSmallArrayt); 25739 25740 r = icHasDictSmallArrayG(self, null); 25741 ck_assert(!r); 25742 terminateO(self); 25743 25744 END_TEST 25745 25746 25747 START_TEST(icHasArraySmallArrayGT) 25748 25749 bool r; 25750 smallArrayt *self = allocG(rtSmallArrayt); 25751 25752 r = icHasArraySmallArrayG(self, null); 25753 ck_assert(!r); 25754 terminateO(self); 25755 25756 END_TEST 25757 25758 25759 START_TEST(icHasArraycSmallArrayGT) 25760 25761 bool r; 25762 smallArrayt *self = allocG(rtSmallArrayt); 25763 25764 r = icHasArraycSmallArrayG(self, null); 25765 ck_assert(!r); 25766 terminateO(self); 25767 25768 END_TEST 25769 25770 25771 START_TEST(icHasCArraycSmallArrayGT) 25772 25773 bool r; 25774 smallArrayt *self = allocG(rtSmallArrayt); 25775 25776 r = icHasCArraycSmallArrayG(self, null); 25777 ck_assert(!r); 25778 terminateO(self); 25779 25780 END_TEST 25781 25782 25783 START_TEST(icHasSmallJsonSmallArrayGT) 25784 25785 bool r; 25786 smallArrayt *self = allocG(rtSmallArrayt); 25787 25788 r = icHasSmallJsonSmallArrayG(self, null); 25789 ck_assert(!r); 25790 terminateO(self); 25791 25792 END_TEST 25793 25794 25795 START_TEST(icHasSmallStringSmallArrayGT) 25796 25797 bool r; 25798 smallArrayt *self = allocG(rtSmallArrayt); 25799 25800 r = icHasSmallStringSmallArrayG(self, null); 25801 ck_assert(!r); 25802 terminateO(self); 25803 25804 END_TEST 25805 25806 25807 START_TEST(icIndexOfSmallArrayGT) 25808 25809 ssize_t r; 25810 smallArrayt *self = allocG(rtSmallArrayt); 25811 25812 r = icIndexOfSmallArrayG(self, null); 25813 ck_assert_int_eq(r, -1); 25814 terminateO(self); 25815 25816 END_TEST 25817 25818 25819 START_TEST(icIndexOfSSmallArrayGT) 25820 25821 ssize_t r; 25822 smallArrayt *self = allocG(rtSmallArrayt); 25823 25824 r = icIndexOfSSmallArrayG(self, null); 25825 ck_assert_int_eq(r, -1); 25826 terminateO(self); 25827 25828 END_TEST 25829 25830 25831 START_TEST(icIndexOfCharSmallArrayGT) 25832 25833 ssize_t r; 25834 smallArrayt *self = allocG(rtSmallArrayt); 25835 25836 r = icIndexOfCharSmallArrayG(self, 'A'); 25837 ck_assert_int_eq(r, -1); 25838 terminateO(self); 25839 25840 END_TEST 25841 25842 25843 START_TEST(icIndexOfDictSmallArrayGT) 25844 25845 ssize_t r; 25846 smallArrayt *self = allocG(rtSmallArrayt); 25847 25848 r = icIndexOfDictSmallArrayG(self, null); 25849 ck_assert_int_eq(r, -1); 25850 terminateO(self); 25851 25852 END_TEST 25853 25854 25855 START_TEST(icIndexOfArraySmallArrayGT) 25856 25857 ssize_t r; 25858 smallArrayt *self = allocG(rtSmallArrayt); 25859 25860 r = icIndexOfArraySmallArrayG(self, null); 25861 ck_assert_int_eq(r, -1); 25862 terminateO(self); 25863 25864 END_TEST 25865 25866 25867 START_TEST(icIndexOfArraycSmallArrayGT) 25868 25869 ssize_t r; 25870 smallArrayt *self = allocG(rtSmallArrayt); 25871 25872 r = icIndexOfArraycSmallArrayG(self, null); 25873 ck_assert_int_eq(r, -1); 25874 terminateO(self); 25875 25876 END_TEST 25877 25878 25879 START_TEST(icIndexOfCArraycSmallArrayGT) 25880 25881 ssize_t r; 25882 smallArrayt *self = allocG(rtSmallArrayt); 25883 25884 r = icIndexOfCArraycSmallArrayG(self, null); 25885 ck_assert_int_eq(r, -1); 25886 terminateO(self); 25887 25888 END_TEST 25889 25890 25891 START_TEST(icIndexOfSmallJsonSmallArrayGT) 25892 25893 ssize_t r; 25894 smallArrayt *self = allocG(rtSmallArrayt); 25895 25896 r = icIndexOfSmallJsonSmallArrayG(self, null); 25897 ck_assert_int_eq(r, -1); 25898 terminateO(self); 25899 25900 END_TEST 25901 25902 25903 START_TEST(icIndexOfSmallStringSmallArrayGT) 25904 25905 ssize_t r; 25906 smallArrayt *self = allocG(rtSmallArrayt); 25907 25908 r = icIndexOfSmallStringSmallArrayG(self, null); 25909 ck_assert_int_eq(r, -1); 25910 terminateO(self); 25911 25912 END_TEST 25913 25914 25915 START_TEST(icBinarySearchSmallArrayGT) 25916 25917 ssize_t r; 25918 smallArrayt *self = allocG(rtSmallArrayt); 25919 25920 r = icBinarySearchSmallArrayG(self, null); 25921 ck_assert_int_eq(r, -1); 25922 terminateO(self); 25923 25924 END_TEST 25925 25926 25927 START_TEST(icBinarySearchSSmallArrayGT) 25928 25929 ssize_t r; 25930 smallArrayt *self = allocG(rtSmallArrayt); 25931 25932 r = icBinarySearchSSmallArrayG(self, null); 25933 ck_assert_int_eq(r, -1); 25934 terminateO(self); 25935 25936 END_TEST 25937 25938 25939 START_TEST(icBinarySearchCharSmallArrayGT) 25940 25941 ssize_t r; 25942 smallArrayt *self = allocG(rtSmallArrayt); 25943 25944 r = icBinarySearchCharSmallArrayG(self, 'a'); 25945 ck_assert_int_eq(r, -1); 25946 terminateO(self); 25947 25948 END_TEST 25949 25950 25951 START_TEST(icBinarySearchDictSmallArrayGT) 25952 25953 ssize_t r; 25954 smallArrayt *self = allocG(rtSmallArrayt); 25955 25956 r = icBinarySearchDictSmallArrayG(self, null); 25957 ck_assert_int_eq(r, -1); 25958 terminateO(self); 25959 25960 END_TEST 25961 25962 25963 START_TEST(icBinarySearchArraySmallArrayGT) 25964 25965 ssize_t r; 25966 smallArrayt *self = allocG(rtSmallArrayt); 25967 25968 r = icBinarySearchArraySmallArrayG(self, null); 25969 ck_assert_int_eq(r, -1); 25970 terminateO(self); 25971 25972 END_TEST 25973 25974 25975 START_TEST(icBinarySearchArraycSmallArrayGT) 25976 25977 ssize_t r; 25978 smallArrayt *self = allocG(rtSmallArrayt); 25979 25980 r = icBinarySearchArraycSmallArrayG(self, null); 25981 ck_assert_int_eq(r, -1); 25982 terminateO(self); 25983 25984 END_TEST 25985 25986 25987 START_TEST(icBinarySearchCArraycSmallArrayGT) 25988 25989 ssize_t r; 25990 smallArrayt *self = allocG(rtSmallArrayt); 25991 25992 r = icBinarySearchCArraycSmallArrayG(self, null); 25993 ck_assert_int_eq(r, -1); 25994 terminateO(self); 25995 25996 END_TEST 25997 25998 25999 START_TEST(icBinarySearchSmallJsonSmallArrayGT) 26000 26001 ssize_t r; 26002 smallArrayt *self = allocG(rtSmallArrayt); 26003 26004 r = icBinarySearchSmallJsonSmallArrayG(self, null); 26005 ck_assert_int_eq(r, -1); 26006 terminateO(self); 26007 26008 END_TEST 26009 26010 26011 START_TEST(icBinarySearchSmallStringSmallArrayGT) 26012 26013 ssize_t r; 26014 smallArrayt *self = allocG(rtSmallArrayt); 26015 26016 r = icBinarySearchSmallStringSmallArrayG(self, null); 26017 ck_assert_int_eq(r, -1); 26018 terminateO(self); 26019 26020 END_TEST 26021 26022 26023 START_TEST(icUniqSmallArrayGT) 26024 26025 smallArrayt* r; 26026 smallArrayt *self = allocG(rtSmallArrayt); 26027 26028 self->f->pushUndefined(self); 26029 self->f->pushBool(self, true); 26030 self->f->pushNFreeDict(self, allocSmallDict()); 26031 self->f->pushDouble(self, 1); 26032 self->f->pushInt(self, 2); 26033 self->f->pushS(self, "ASD"); 26034 self->f->pushNFreeArray(self, allocSmallArray()); 26035 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 26036 self->f->pushUndefined(self); 26037 self->f->pushBool(self, true); 26038 self->f->pushNFreeDict(self, allocSmallDict()); 26039 self->f->pushDouble(self, 1); 26040 self->f->pushInt(self, 2); 26041 self->f->pushS(self, "asd"); 26042 self->f->pushNFreeArray(self, allocSmallArray()); 26043 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 26044 r = icUniqSmallArrayG(self, 0); 26045 ck_assert_ptr_ne(r, NULL); 26046 char *s = toStringO(r); 26047 ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"ASD\",[],[0x71,0x77,0x65,0x00]]"); 26048 free(s); 26049 terminateO(self); 26050 26051 END_TEST 26052 26053 26054 START_TEST(compactSmallArrayGT) 26055 26056 smallArrayt* r; 26057 smallArrayt *self = allocG(rtSmallArrayt); 26058 26059 self->f->pushUndefined(self); 26060 // null element 26061 self->f->pushUndefined(self); 26062 delElemO(self, 1); 26063 self->f->pushBool(self, true); 26064 createSmallContainer(c); 26065 self->f->pushSmallContainer(self, &c); 26066 // empty dict 26067 createSmallDict(d); 26068 self->f->pushDict(self, &d); 26069 resetO(&d); 26070 (&d)->f->setInt(&d, "a", 1); 26071 self->f->pushDict(self, &d); 26072 self->f->pushDouble(self, 2); 26073 self->f->pushInt(self, 5); 26074 self->f->pushS(self, " "); 26075 self->f->pushS(self, "asd"); 26076 // empty Array 26077 createSmallArray(a); 26078 self->f->pushArray(self, &a); 26079 resetO(&a); 26080 (&a)->f->pushInt(&a, 1); 26081 self->f->pushArray(self, &a); 26082 // empty bytes 26083 createSmallBytes(b); 26084 self->f->pushSmallBytes(self, &b); 26085 smallBytest *B = allocSmallBytes("asd", 4); 26086 self->f->pushNFreeSmallBytes(self, B); 26087 r = compactSmallArrayG(self); 26088 ck_assert_ptr_ne(r, NULL); 26089 ck_assert_int_eq(lenO(r), 8); 26090 char *s = toStringO(r); 26091 ck_assert_str_eq(s, "[true,\"<data container>\",{\"a\":1},2.000000e+00,5,\"asd\",[1],[0x61,0x73,0x64,0x00]]"); 26092 free(s); 26093 terminateO(self); 26094 26095 END_TEST 26096 26097 26098 START_TEST(emptySmallArrayGT) 26099 26100 smallArrayt* r; 26101 smallArrayt *self = allocG(rtSmallArrayt); 26102 26103 self->f->pushInt(self, 1); 26104 r = emptySmallArrayG(self); 26105 ck_assert_ptr_ne(r, null); 26106 char *s = toStringO(r); 26107 ck_assert_str_eq(s, "[]"); 26108 free(s); 26109 terminateO(self); 26110 26111 END_TEST 26112 26113 26114 START_TEST(isEmptySmallArrayGT) 26115 26116 bool r; 26117 smallArrayt *self = allocG(rtSmallArrayt); 26118 26119 r = isEmptySmallArrayG(self); 26120 ck_assert(r); 26121 terminateO(self); 26122 26123 END_TEST 26124 26125 26126 START_TEST(isBlankSmallArrayGT) 26127 26128 bool r; 26129 smallArrayt *self = allocG(rtSmallArrayt); 26130 26131 r = isBlankSmallArrayG(self); 26132 ck_assert(r); 26133 terminateO(self); 26134 26135 END_TEST 26136 26137 26138 START_TEST(joinSmallArrayGT) 26139 26140 smallStringt* r; 26141 smallArrayt *self = allocG(rtSmallArrayt); 26142 26143 self->f->pushS(self, "a"); 26144 self->f->pushS(self, "b"); 26145 r = joinSmallArrayG(self, "|"); 26146 ck_assert_ptr_ne(r, null); 26147 char *s = toStringO(r); 26148 ck_assert_str_eq(s, "a|b"); 26149 free(s); 26150 terminateO(r); 26151 terminateO(self); 26152 26153 END_TEST 26154 26155 26156 START_TEST(joinCharSmallArrayGT) 26157 26158 smallStringt* r; 26159 smallArrayt *self = allocG(rtSmallArrayt); 26160 26161 self->f->pushS(self, "a"); 26162 self->f->pushS(self, "b"); 26163 r = joinCharSmallArrayG(self, '|'); 26164 ck_assert_ptr_ne(r, null); 26165 char *s = toStringO(r); 26166 ck_assert_str_eq(s, "a|b"); 26167 free(s); 26168 terminateO(r); 26169 terminateO(self); 26170 26171 END_TEST 26172 26173 26174 START_TEST(joinSmallJsonSmallArrayGT) 26175 26176 smallStringt* r; 26177 smallArrayt *self = allocG(rtSmallArrayt); 26178 26179 r = joinSmallJsonSmallArrayG(self, null); 26180 ck_assert_ptr_eq(r, null); 26181 terminateO(self); 26182 26183 END_TEST 26184 26185 26186 START_TEST(joinSmallStringSmallArrayGT) 26187 26188 smallStringt* r; 26189 smallArrayt *self = allocG(rtSmallArrayt); 26190 26191 r = joinSmallStringSmallArrayG(self, null); 26192 ck_assert_ptr_eq(r, null); 26193 terminateO(self); 26194 26195 END_TEST 26196 26197 26198 START_TEST(joinSSmallArrayGT) 26199 26200 char* r; 26201 smallArrayt *self = allocG(rtSmallArrayt); 26202 26203 r = joinSSmallArrayG(self, null); 26204 ck_assert_ptr_eq(r, null); 26205 terminateO(self); 26206 26207 END_TEST 26208 26209 26210 START_TEST(joinCharSSmallArrayGT) 26211 26212 char* r; 26213 smallArrayt *self = allocG(rtSmallArrayt); 26214 26215 r = joinCharSSmallArrayG(self, '#'); 26216 ck_assert_ptr_eq(r, null); 26217 terminateO(self); 26218 26219 END_TEST 26220 26221 26222 START_TEST(joinSmallJsonSSmallArrayGT) 26223 26224 char* r; 26225 smallArrayt *self = allocG(rtSmallArrayt); 26226 26227 r = joinSmallJsonSSmallArrayG(self, null); 26228 ck_assert_ptr_eq(r, null); 26229 terminateO(self); 26230 26231 END_TEST 26232 26233 26234 START_TEST(joinSmallStringSSmallArrayGT) 26235 26236 char* r; 26237 smallArrayt *self = allocG(rtSmallArrayt); 26238 26239 r = joinSmallStringSSmallArrayG(self, null); 26240 ck_assert_ptr_eq(r, null); 26241 terminateO(self); 26242 26243 END_TEST 26244 26245 26246 START_TEST(zipSmallArrayGT) 26247 26248 smallArrayt* r; 26249 smallArrayt *self = allocG(rtSmallArrayt); 26250 smallArrayt *array1 = allocSmallArray(); 26251 smallArrayt *array2 = allocSmallArray(); 26252 26253 // zip arrays 26254 // add an element to self 26255 // array1 has 2 elements 26256 // array2 has 3 elements 26257 // only 2 elements are zipped 26258 self->f->pushS(self, "qwe"); 26259 array1->f->pushS(array1, "a"); 26260 array1->f->pushS(array1, "b"); 26261 array2->f->pushInt(array2, 1); 26262 array2->f->pushInt(array2, 2); 26263 array2->f->pushInt(array2, 3); 26264 r = zipSmallArrayG(self, array1, array2); 26265 ck_assert_ptr_ne(r, NULL); 26266 char *s = toStringO(r); 26267 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 26268 free(s); 26269 // delete the element not in self 26270 delElemO(array2, 2); 26271 terminateO(self); 26272 smashO(array1); 26273 smashO(array2); 26274 26275 END_TEST 26276 26277 26278 START_TEST(zipSmallJsonSmallArrayGT) 26279 26280 smallArrayt* r; 26281 smallArrayt *self = allocG(rtSmallArrayt); 26282 smallArrayt *array1 = allocSmallArray(); 26283 smallJsont *array2 = allocSmallJson(); 26284 26285 // zip arrays 26286 // add an element to self 26287 // array1 has 2 elements 26288 // array2 has 3 elements 26289 // only 2 elements are zipped 26290 self->f->pushS(self, "qwe"); 26291 array1->f->pushS(array1, "a"); 26292 array1->f->pushS(array1, "b"); 26293 array2->f->pushInt(array2, 1); 26294 array2->f->pushInt(array2, 2); 26295 array2->f->pushInt(array2, 3); 26296 r = zipSmallJsonSmallArrayG(self, array1, array2); 26297 ck_assert_ptr_ne(r, NULL); 26298 char *s = toStringO(r); 26299 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 26300 free(s); 26301 // delete the element not in self 26302 delElemIndexO(array2, 2); 26303 terminateO(self); 26304 smashO(array1); 26305 smashO(array2); 26306 26307 END_TEST 26308 26309 26310 START_TEST(zipSmallJsonSmallArraySmallArrayGT) 26311 26312 smallArrayt* r; 26313 smallArrayt *self = allocG(rtSmallArrayt); 26314 smallJsont *array1 = allocSmallJson(); 26315 smallArrayt *array2 = allocSmallArray(); 26316 26317 // zip arrays 26318 // add an element to self 26319 // array1 has 2 elements 26320 // array2 has 3 elements 26321 // only 2 elements are zipped 26322 self->f->pushS(self, "qwe"); 26323 array1->f->pushS(array1, "a"); 26324 array1->f->pushS(array1, "b"); 26325 array2->f->pushInt(array2, 1); 26326 array2->f->pushInt(array2, 2); 26327 array2->f->pushInt(array2, 3); 26328 r = zipSmallJsonSmallArraySmallArrayG(self, array1, array2); 26329 ck_assert_ptr_ne(r, NULL); 26330 char *s = toStringO(r); 26331 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 26332 free(s); 26333 // delete the element not in self 26334 delElemO(array2, 2); 26335 terminateO(self); 26336 smashO(array1); 26337 smashO(array2); 26338 26339 END_TEST 26340 26341 26342 START_TEST(zipSmallJsonSmallJsonSmallArrayGT) 26343 26344 smallArrayt* r; 26345 smallArrayt *self = allocG(rtSmallArrayt); 26346 smallJsont *array1 = allocSmallJson(); 26347 smallJsont *array2 = allocSmallJson(); 26348 26349 // zip arrays 26350 // add an element to self 26351 // array1 has 2 elements 26352 // array2 has 3 elements 26353 // only 2 elements are zipped 26354 self->f->pushS(self, "qwe"); 26355 array1->f->pushS(array1, "a"); 26356 array1->f->pushS(array1, "b"); 26357 array2->f->pushInt(array2, 1); 26358 array2->f->pushInt(array2, 2); 26359 array2->f->pushInt(array2, 3); 26360 r = zipSmallJsonSmallJsonSmallArrayG(self, array1, array2); 26361 ck_assert_ptr_ne(r, NULL); 26362 char *s = toStringO(r); 26363 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 26364 free(s); 26365 // delete the element not in self 26366 delElemIndexO(array2, 2); 26367 terminateO(self); 26368 smashO(array1); 26369 smashO(array2); 26370 26371 END_TEST 26372 26373 26374 START_TEST(zipSmallJsonCharSmallArrayGT) 26375 26376 smallArrayt* r; 26377 smallArrayt *self = allocG(rtSmallArrayt); 26378 smallJsont *array1 = allocSmallJson(); 26379 char **array2; 26380 26381 // zip arrays 26382 // add an element to self 26383 // array1 has 2 elements 26384 // array2 has 3 elements 26385 // only 2 elements are zipped 26386 self->f->pushS(self, "qwe"); 26387 array1->f->pushS(array1, "a"); 26388 array1->f->pushS(array1, "b"); 26389 array2 = listCreateS("1", "2", "3"); 26390 r = zipSmallJsonCharSmallArrayG(self, array1, array2); 26391 ck_assert_ptr_ne(r, NULL); 26392 char *s = toStringO(r); 26393 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26394 free(s); 26395 // delete the element not in self 26396 iListDelElemS(&array2, 2); 26397 terminateO(self); 26398 smashO(array1); 26399 free(array2); 26400 26401 END_TEST 26402 26403 26404 START_TEST(zipSmallJsonCCharSmallArrayGT) 26405 26406 smallArrayt* r; 26407 smallArrayt *self = allocG(rtSmallArrayt); 26408 smallJsont *array1 = allocSmallJson(); 26409 26410 // zip arrays 26411 // add an element to self 26412 // array1 has 2 elements 26413 // array2 has 3 elements 26414 // only 2 elements are zipped 26415 self->f->pushS(self, "qwe"); 26416 array1->f->pushS(array1, "a"); 26417 array1->f->pushS(array1, "b"); 26418 const char *array2[] = {"1", "2", "3", null}; 26419 r = zipSmallJsonCCharSmallArrayG(self, array1, array2); 26420 ck_assert_ptr_ne(r, NULL); 26421 char *s = toStringO(r); 26422 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26423 free(s); 26424 terminateO(self); 26425 smashO(array1); 26426 26427 END_TEST 26428 26429 26430 START_TEST(zipArraySmallArrayGT) 26431 26432 smallArrayt* r; 26433 smallArrayt *self = allocG(rtSmallArrayt); 26434 char** array1; 26435 smallArrayt *array2 = allocSmallArray(); 26436 26437 self->f->pushS(self, "qwe"); 26438 array1 = listCreateS("a", "b"); 26439 array2->f->pushS(array2, "1"); 26440 array2->f->pushS(array2, "2"); 26441 r = zipArraySmallArrayG(self, array1, array2); 26442 ck_assert_ptr_ne(r, NULL); 26443 char *s = toStringO(r); 26444 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26445 free(s); 26446 terminateO(self); 26447 free(array1); 26448 smashO(array2); 26449 26450 END_TEST 26451 26452 26453 START_TEST(zipCArraySmallArrayGT) 26454 26455 smallArrayt* r; 26456 smallArrayt *self = allocG(rtSmallArrayt); 26457 const char* array1[] = {"a", "b", null}; 26458 smallArrayt *array2 = allocSmallArray(); 26459 26460 self->f->pushS(self, "qwe"); 26461 array2->f->pushS(array2, "1"); 26462 array2->f->pushS(array2, "2"); 26463 r = zipCArraySmallArrayG(self, array1, array2); 26464 ck_assert_ptr_ne(r, NULL); 26465 char *s = toStringO(r); 26466 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26467 free(s); 26468 terminateO(self); 26469 smashO(array2); 26470 26471 END_TEST 26472 26473 26474 START_TEST(zipArraySmallJsonSmallArrayGT) 26475 26476 smallArrayt* r; 26477 smallArrayt *self = allocG(rtSmallArrayt); 26478 char** array1; 26479 smallJsont *array2 = allocSmallJson(); 26480 26481 self->f->pushS(self, "qwe"); 26482 array1 = listCreateS("a", "b"); 26483 array2->f->pushS(array2, "1"); 26484 array2->f->pushS(array2, "2"); 26485 r = zipArraySmallJsonSmallArrayG(self, array1, array2); 26486 ck_assert_ptr_ne(r, NULL); 26487 char *s = toStringO(r); 26488 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26489 free(s); 26490 terminateO(self); 26491 free(array1); 26492 smashO(array2); 26493 26494 END_TEST 26495 26496 26497 START_TEST(zipCArraySmallJsonSmallArrayGT) 26498 26499 smallArrayt* r; 26500 smallArrayt *self = allocG(rtSmallArrayt); 26501 const char* array1[] = {"a", "b", null}; 26502 smallJsont *array2 = allocSmallJson(); 26503 26504 self->f->pushS(self, "qwe"); 26505 array2->f->pushS(array2, "1"); 26506 array2->f->pushS(array2, "2"); 26507 r = zipCArraySmallJsonSmallArrayG(self, array1, array2); 26508 ck_assert_ptr_ne(r, NULL); 26509 char *s = toStringO(r); 26510 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26511 free(s); 26512 terminateO(self); 26513 smashO(array2); 26514 26515 END_TEST 26516 26517 26518 START_TEST(zipCharSmallArrayGT) 26519 26520 smallArrayt* r; 26521 smallArrayt *self = allocG(rtSmallArrayt); 26522 smallArrayt *array1 = allocSmallArray(); 26523 char** array2; 26524 26525 self->f->pushS(self, "qwe"); 26526 array1->f->pushS(array1, "a"); 26527 array1->f->pushS(array1, "b"); 26528 array2 = listCreateS("1", "2"); 26529 r = zipCharSmallArrayG(self, array1, array2); 26530 ck_assert_ptr_ne(r, NULL); 26531 char *s = toStringO(r); 26532 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26533 free(s); 26534 terminateO(self); 26535 smashO(array1); 26536 free(array2); 26537 26538 END_TEST 26539 26540 26541 START_TEST(zipCCharSmallArrayGT) 26542 26543 smallArrayt* r; 26544 smallArrayt *self = allocG(rtSmallArrayt); 26545 smallArrayt *array1 = allocSmallArray(); 26546 const char* array2[] = {"1", "2", "3", null}; 26547 26548 self->f->pushS(self, "qwe"); 26549 array1->f->pushS(array1, "a"); 26550 array1->f->pushS(array1, "b"); 26551 r = zipCCharSmallArrayG(self, array1, array2); 26552 ck_assert_ptr_ne(r, NULL); 26553 char *s = toStringO(r); 26554 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26555 free(s); 26556 terminateO(self); 26557 smashO(array1); 26558 26559 END_TEST 26560 26561 26562 START_TEST(zipArrayCharSmallArrayGT) 26563 26564 smallArrayt* r; 26565 smallArrayt *self = allocG(rtSmallArrayt); 26566 char** array1; 26567 char** array2; 26568 26569 self->f->pushS(self, "qwe"); 26570 array1 = listCreateS("a", "b"); 26571 array2 = listCreateS("1", "2"); 26572 r = zipArrayCharSmallArrayG(self, array1, array2); 26573 ck_assert_ptr_ne(r, NULL); 26574 char *s = toStringO(r); 26575 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26576 free(s); 26577 terminateO(self); 26578 free(array1); 26579 free(array2); 26580 26581 END_TEST 26582 26583 26584 START_TEST(zipArrayCCharSmallArrayGT) 26585 26586 smallArrayt* r; 26587 smallArrayt *self = allocG(rtSmallArrayt); 26588 char** array1; 26589 const char* array2[] = {"1", "2", "3", null}; 26590 26591 self->f->pushS(self, "qwe"); 26592 array1 = listCreateS("a", "b"); 26593 r = zipArrayCCharSmallArrayG(self, array1, array2); 26594 ck_assert_ptr_ne(r, NULL); 26595 char *s = toStringO(r); 26596 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26597 free(s); 26598 terminateO(self); 26599 free(array1); 26600 26601 END_TEST 26602 26603 26604 START_TEST(zipCArrayCharSmallArrayGT) 26605 26606 smallArrayt* r; 26607 smallArrayt *self = allocG(rtSmallArrayt); 26608 const char* array1[] = {"a", "b", null}; 26609 char** array2; 26610 26611 self->f->pushS(self, "qwe"); 26612 array2 = listCreateS("1", "2"); 26613 r = zipCArrayCharSmallArrayG(self, array1, array2); 26614 ck_assert_ptr_ne(r, NULL); 26615 char *s = toStringO(r); 26616 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26617 free(s); 26618 terminateO(self); 26619 free(array2); 26620 26621 END_TEST 26622 26623 26624 START_TEST(zipCArrayCCharSmallArrayGT) 26625 26626 smallArrayt* r; 26627 smallArrayt *self = allocG(rtSmallArrayt); 26628 const char* array1[] = {"a", "b", null}; 26629 const char* array2[] = {"1", "2", "3", null}; 26630 26631 self->f->pushS(self, "qwe"); 26632 r = zipCArrayCCharSmallArrayG(self, array1, array2); 26633 ck_assert_ptr_ne(r, NULL); 26634 char *s = toStringO(r); 26635 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26636 free(s); 26637 terminateO(self); 26638 26639 END_TEST 26640 26641 26642 START_TEST(logSmallArrayGT) 26643 26644 smallArrayt *self = allocG(rtSmallArrayt); 26645 26646 self->f->pushS(self, "qwe"); 26647 self->f->pushS(self, "asd"); 26648 delElemO(self, 0); 26649 logSmallArrayG(self); 26650 terminateO(self); 26651 26652 END_TEST 26653 26654 26655 START_TEST(readTextSmallArrayGT) 26656 26657 smallArrayt* r; 26658 smallArrayt *self = allocG(rtSmallArrayt); 26659 26660 r = readTextSmallArrayG(self, "../textTest.null"); 26661 ck_assert_ptr_ne(r, NULL); 26662 char *s = toStringO(r); 26663 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26664 free(s); 26665 terminateO(self); 26666 26667 END_TEST 26668 26669 26670 START_TEST(readTextSmallJsonSmallArrayGT) 26671 26672 smallArrayt* r; 26673 smallArrayt *self = allocG(rtSmallArrayt); 26674 smallJsont *filePath = allocSmallJson(); 26675 26676 // text 26677 setTopSO(filePath, "../textTest.null"); 26678 r = readTextSmallJsonSmallArrayG(self, filePath); 26679 ck_assert_ptr_ne(r, NULL); 26680 char *s = toStringO(r); 26681 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26682 free(s); 26683 terminateO(self); 26684 terminateO(filePath); 26685 26686 END_TEST 26687 26688 26689 START_TEST(readTextSmallStringSmallArrayGT) 26690 26691 smallArrayt* r; 26692 smallArrayt *self = allocG(rtSmallArrayt); 26693 smallStringt *filePath = allocSmallString(""); 26694 26695 // text 26696 setValO(filePath, "../textTest.null"); 26697 r = readTextSmallStringSmallArrayG(self, filePath); 26698 ck_assert_ptr_ne(r, NULL); 26699 char *s = toStringO(r); 26700 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26701 free(s); 26702 terminateO(self); 26703 terminateO(filePath); 26704 26705 END_TEST 26706 26707 26708 START_TEST(readStreamSmallArrayGT) 26709 26710 smallArrayt* r; 26711 smallArrayt *self = allocG(rtSmallArrayt); 26712 FILE *fp; 26713 26714 fp = fopen("../textTest.null", "r"); 26715 r = readStreamSmallArrayG(self, fp); 26716 fclose(fp); 26717 ck_assert_ptr_ne(r, NULL); 26718 char *s = toStringO(r); 26719 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26720 free(s); 26721 terminateO(self); 26722 26723 END_TEST 26724 26725 26726 START_TEST(writeTextSmallArrayGT) 26727 26728 bool r; 26729 smallArrayt *self = allocG(rtSmallArrayt); 26730 26731 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26732 ck_assert_ptr_ne(r2, NULL); 26733 r = writeTextSmallArrayG(self, "../textOutTest.null"); 26734 ck_assert(r); 26735 // check textOutTest.null 26736 emptyO(self); 26737 r2 = readTextO(self, "../textOutTest.null"); 26738 ck_assert_ptr_ne(r2, NULL); 26739 char *s = toStringO(r2); 26740 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26741 free(s); 26742 terminateO(self); 26743 26744 END_TEST 26745 26746 26747 START_TEST(writeTextSmallJsonSmallArrayGT) 26748 26749 bool r; 26750 smallArrayt *self = allocG(rtSmallArrayt); 26751 smallJsont *filePath = allocSmallJson(); 26752 26753 // write textOutTest.null 26754 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26755 ck_assert_ptr_ne(r2, NULL); 26756 setTopSO(filePath, "../textOutTest.null"); 26757 r = writeTextSmallJsonSmallArrayG(self, filePath); 26758 ck_assert(r); 26759 // check textOutTest.null 26760 emptyO(self); 26761 r2 = readTextO(self, "../textOutTest.null"); 26762 ck_assert_ptr_ne(r2, NULL); 26763 char *s = toStringO(r2); 26764 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26765 free(s); 26766 terminateO(self); 26767 terminateO(filePath); 26768 26769 END_TEST 26770 26771 26772 START_TEST(writeTextSmallStringSmallArrayGT) 26773 26774 bool r; 26775 smallArrayt *self = allocG(rtSmallArrayt); 26776 smallStringt *filePath = allocSmallString(""); 26777 26778 // write textOutTest.null 26779 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26780 ck_assert_ptr_ne(r2, NULL); 26781 setValO(filePath, "../textOutTest.null"); 26782 r = writeTextSmallStringSmallArrayG(self, filePath); 26783 ck_assert(r); 26784 // check textOutTest.null 26785 emptyO(self); 26786 r2 = readTextO(self, "../textOutTest.null"); 26787 ck_assert_ptr_ne(r2, NULL); 26788 char *s = toStringO(r2); 26789 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26790 free(s); 26791 terminateO(self); 26792 terminateO(filePath); 26793 26794 END_TEST 26795 26796 26797 START_TEST(writeStreamSmallArrayGT) 26798 26799 bool r; 26800 smallArrayt *self = allocG(rtSmallArrayt); 26801 FILE *fp; 26802 26803 // write textOutTest.null 26804 fp = fopen("../textTest.null", "r"); 26805 smallArrayt *r2 = readStreamO(self, fp); 26806 fclose(fp); 26807 ck_assert_ptr_ne(r2, NULL); 26808 fp = fopen("../textOutTest.null", "w"); 26809 r = writeStreamSmallArrayG(self, fp); 26810 ck_assert(r); 26811 fclose(fp); 26812 terminateO(self); 26813 26814 END_TEST 26815 26816 26817 START_TEST(appendTextSmallArrayGT) 26818 26819 bool r; 26820 smallArrayt *self = allocG(rtSmallArrayt); 26821 26822 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26823 ck_assert_ptr_ne(r2, NULL); 26824 r = writeTextO(self, "../textOutTest.null"); 26825 ck_assert(r); 26826 emptyO(self); 26827 self->f->pushS(self, "A"); 26828 self->f->pushS(self, "B"); 26829 r = appendTextSmallArrayG(self, "../textOutTest.null"); 26830 // check textOutTest.null 26831 emptyO(self); 26832 r2 = readTextO(self, "../textOutTest.null"); 26833 char *s = toStringO(r2); 26834 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 26835 free(s); 26836 terminateO(self); 26837 26838 END_TEST 26839 26840 26841 START_TEST(appendTextSmallStringSmallArrayGT) 26842 26843 bool r; 26844 smallArrayt *self = allocG(rtSmallArrayt); 26845 smallStringt *filePath = allocSmallString(""); 26846 26847 // append to textOutTest.null 26848 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26849 ck_assert_ptr_ne(r2, NULL); 26850 r = writeTextO(self, "../textOutTest.null"); 26851 ck_assert(r); 26852 emptyO(self); 26853 self->f->pushS(self, "A"); 26854 self->f->pushS(self, "B"); 26855 setValO(filePath, "../textOutTest.null"); 26856 r = appendTextSmallStringSmallArrayG(self, filePath); 26857 // check textOutTest.null 26858 emptyO(self); 26859 r2 = readTextO(self, "../textOutTest.null"); 26860 char *s = toStringO(r2); 26861 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 26862 free(s); 26863 terminateO(self); 26864 terminateO(filePath); 26865 26866 END_TEST 26867 26868 26869 START_TEST(typeSmallStringSmallArrayGT) 26870 26871 smallStringt* r; 26872 smallArrayt *self = allocG(rtSmallArrayt); 26873 26874 r = typeSmallStringSmallArrayG(self, 0); 26875 char *s = toStringO(r); 26876 ck_assert_str_eq(s, "not a sheepy object"); 26877 free(s); 26878 terminateO(self); 26879 terminateO(r); 26880 26881 END_TEST 26882 26883 26884 START_TEST(typeSmallStringsSmallArrayGT) 26885 26886 smallArrayt* r; 26887 smallArrayt *self = allocG(rtSmallArrayt); 26888 26889 self->f->pushS(self, "qwe"); 26890 self->f->pushBool(self, true); 26891 self->f->pushDouble(self, 1); 26892 r = typeSmallStringsSmallArrayG(self); 26893 ck_assert_ptr_ne(r, NULL); 26894 char *s = toStringO(r); 26895 ck_assert_str_eq(s, "[\"string\",\"bool\",\"double\"]"); 26896 free(s); 26897 terminateO(self); 26898 terminateO(r); 26899 26900 END_TEST 26901 26902 26903 START_TEST(cSmallArrayT) 26904 26905 // local object 26906 createSmallArray(obj); 26907 ck_assert_str_eq(obj.type, "smallArray"); 26908 // object 26909 createAllocateSmallArray(obj2); 26910 ck_assert_str_eq(obj2->type, "smallArray"); 26911 // toString 26912 char *s = obj2->f->toString(obj2); 26913 ck_assert_str_eq(s, "[]"); 26914 free(s); 26915 createAllocateUndefined(oU); 26916 obj2->f->push(obj2, (baset *)oU); 26917 finishO(oU); 26918 createAllocateSmallInt(oInt); 26919 oInt->f->set(oInt, 123); 26920 obj2->f->push(obj2, (baset *)oInt); 26921 finishO(oInt); 26922 createAllocateSmallString(oStr); 26923 oStr->f->set(oStr, "sheepy"); 26924 obj2->f->push(obj2, (baset *)oStr); 26925 finishO(oStr); 26926 s = obj2->f->toString(obj2); 26927 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 26928 free(s); 26929 // delete an element 26930 smallArrayt *o2; 26931 o2 = obj2->f->duplicate(obj2); 26932 o2->f->delElem(o2, 0); 26933 s = o2->f->toString(o2); 26934 ck_assert_str_eq(s, "[123,\"sheepy\"]"); 26935 free(s); 26936 terminateO(o2); 26937 // duplicate 26938 smallArrayt *o; 26939 o = obj2->f->duplicate(obj2); 26940 undefinedt *u; 26941 u = (undefinedt *) o->f->getAt(o, 0); 26942 ck_assert(isOType(u, "undefined")); 26943 terminateO(u); 26944 smallIntt *in; 26945 in = (smallIntt *) o->f->getAt(o, 1); 26946 ck_assert(in->value->value == 123); 26947 smashO(in); 26948 smallStringt *st; 26949 st = (smallStringt *) o->f->getAt(o, 2); 26950 ck_assert(strEq(st->f->get(st), "sheepy")); 26951 smashO(st); 26952 terminateO(o); 26953 // delete an element 26954 o2 = obj2->f->duplicate(obj2); 26955 o2->f->delElem(o2, 0); 26956 o = o2->f->duplicate(o2); 26957 in = (smallIntt *) o->f->getAt(o, 0); 26958 ck_assert(in->value->value == 123); 26959 smashO(in); 26960 st = (smallStringt *) o->f->getAt(o, 1); 26961 ck_assert(strEq(st->f->get(st), "sheepy")); 26962 smashO(st); 26963 terminateO(o); 26964 terminateO(o2); 26965 // fromArray 26966 initiateAllocateSmallArray(&o); 26967 char *array[] = {"1", "22", "333"}; 26968 char *arrayNULL[] = {"1", NULL, "333"}; 26969 // copy array to list 26970 o->f->fromArray(o, (void *)array, 3); 26971 ck_assert_uint_eq(o->f->len(o),3); 26972 smallStringt *strFrom; 26973 strFrom = (smallStringt*) o->f->getAt(o,0); 26974 ck_assert_str_eq(strFrom->f->get(strFrom), "1"); 26975 smashO(strFrom); 26976 strFrom = (smallStringt*) o->f->getAt(o,1); 26977 ck_assert_str_eq(strFrom->f->get(strFrom), "22"); 26978 smashO(strFrom); 26979 strFrom = (smallStringt*) o->f->getAt(o,2); 26980 ck_assert_str_eq(strFrom->f->get(strFrom), "333"); 26981 smashO(strFrom); 26982 // array with NULL inside 26983 o->f->fromArray(o, (void *)arrayNULL, 3); 26984 ck_assert_uint_eq(o->f->len(o),3); 26985 strFrom = (smallStringt*) o->f->getAt(o,0); 26986 ck_assert_str_eq(strFrom->f->get(strFrom), "1"); 26987 smashO(strFrom); 26988 strFrom = (smallStringt*) o->f->getAt(o,1); 26989 ck_assert_ptr_eq(strFrom, NULL); 26990 strFrom = (smallStringt*) o->f->getAt(o,2); 26991 ck_assert_str_eq(strFrom->f->get(strFrom), "333"); 26992 smashO(strFrom); 26993 // char** list 26994 char **shpList = listCreateS("lib", "sheepy"); 26995 o->f->fromArray(o, shpList, 0); 26996 ck_assert_uint_eq(o->f->len(o),2); 26997 listFreeS(shpList); 26998 // NULL pointer to list - list not changed 26999 o->f->fromArray(o, (void *)arrayNULL, 3); 27000 o->f->fromArray(o, NULL, 3); 27001 ck_assert_uint_eq(o->f->len(o),3); 27002 strFrom = (smallStringt*) o->f->getAt(o,0); 27003 ck_assert_str_eq(strFrom->f->get(strFrom), "1"); 27004 smashO(strFrom); 27005 strFrom = (smallStringt*) o->f->getAt(o,1); 27006 ck_assert_ptr_eq(strFrom, NULL); 27007 strFrom = (smallStringt*) o->f->getAt(o,2); 27008 ck_assert_str_eq(strFrom->f->get(strFrom), "333"); 27009 smashO(strFrom); 27010 terminateO(o); 27011 // push 27012 o = obj2->f->duplicate(obj2); 27013 initiateAllocateSmallInt(&in); 27014 in->f->set(in, 654); 27015 o->f->push(o, (baset *)in); 27016 finishO(in); 27017 in = (smallIntt *) o->f->getAt(o, 3); 27018 ck_assert_uint_eq(o->f->len(o), 4); 27019 ck_assert_uint_eq(in->value->value, 654); 27020 smashO(in); 27021 // NULL 27022 o->f->push(o, NULL); 27023 ck_assert_uint_eq(o->f->len(o), 4); 27024 terminateO(o); 27025 // pop 27026 o = obj2->f->duplicate(obj2); 27027 ck_assert_uint_eq(o->f->len(o), 3); 27028 st = (smallStringt *) o->f->pop(o); 27029 ck_assert_uint_eq(o->f->len(o), 2); 27030 ck_assert_str_eq(st->f->get(st), "sheepy"); 27031 terminateO(st); 27032 in = (smallIntt *) o->f->pop(o); 27033 ck_assert_uint_eq(in->value->value, 123); 27034 terminateO(in); 27035 u = (undefinedt *) o->f->pop(o); 27036 ck_assert(isOType(u, "undefined")); 27037 terminateO(u); 27038 // empty list 27039 u = (undefinedt *) o->f->pop(o); 27040 ck_assert_ptr_eq(u,NULL); 27041 // after initialize 27042 o->f->free(o); 27043 ck_assert_uint_eq(o->f->len(o), 0); 27044 u = (undefinedt *) o->f->pop(o); 27045 ck_assert_uint_eq(o->f->len(o), 0); 27046 ck_assert_ptr_eq(u,NULL); 27047 terminateO(o); 27048 // append 27049 o = obj2->f->duplicate(obj2); 27050 o2 = obj2->f->duplicate(obj2); 27051 in = (smallIntt *) o2->f->getAt(o2, 1); 27052 in->value->value = 789; 27053 o2->f->setAt(o2, 1, (baset *)in); 27054 finishO(in); 27055 o->f->append(o, o2); 27056 s = toStringO(o); 27057 ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]"); 27058 free(s); 27059 // same list 27060 o->f->append(o, o); 27061 s = toStringO(o); 27062 ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]"); 27063 free(s); 27064 o->f->free(o); 27065 o2->f->smash(&o2); 27066 // empty list + list 27067 o2 = obj2->f->duplicate(obj2); 27068 in = (smallIntt *) o2->f->getAt(o2, 1); 27069 in->value->value = 789; 27070 o2->f->setAt(o2, 1, (baset *)in); 27071 finishO(in); 27072 o->f->append(o, o2); 27073 s = toStringO(o); 27074 ck_assert_str_eq(s, "[null,789,\"sheepy\"]"); 27075 free(s); 27076 // list + empty list 27077 o2->f->dispose(o2); 27078 o->f->append(o, o2); 27079 s = toStringO(o); 27080 ck_assert_str_eq(s, "[null,789,\"sheepy\"]"); 27081 free(s); 27082 // empty list + empty list 27083 o->f->free(o); 27084 o->f->append(o, o2); 27085 s = toStringO(o); 27086 ck_assert_str_eq(s, "[]"); 27087 free(s); 27088 terminateO(o2); 27089 // NULL list 27090 o->f->append(o, NULL); 27091 s = toStringO(o); 27092 ck_assert_str_eq(s, "[]"); 27093 free(s); 27094 terminateO(o); 27095 // slice 27096 o = obj2->f->duplicate(obj2); 27097 initiateAllocateSmallInt(&in); 27098 in->f->set(in, 5345); 27099 o->f->push(o, (baset *) in); 27100 finishO(in); 27101 o->f->slice(o,1,-1); 27102 s = toStringO(o); 27103 ck_assert_str_eq(s, "[123,\"sheepy\"]"); 27104 free(s); 27105 terminateO(o); 27106 // start outside 27107 o = obj2->f->duplicate(obj2); 27108 initiateAllocateSmallInt(&in); 27109 in->f->set(in, 5345); 27110 o->f->push(o, (baset *) in); 27111 finishO(in); 27112 o->f->slice(o,20,-1); 27113 s = toStringO(o); 27114 ck_assert_str_eq(s, "[]"); 27115 free(s); 27116 terminateO(o); 27117 // start negative and outside 27118 o = obj2->f->duplicate(obj2); 27119 initiateAllocateSmallInt(&in); 27120 in->f->set(in, 5345); 27121 o->f->push(o, (baset *) in); 27122 finishO(in); 27123 o->f->slice(o,-20,1); 27124 s = toStringO(o); 27125 ck_assert_str_eq(s, "[null]"); 27126 free(s); 27127 terminateO(o); 27128 // end outside 27129 o = obj2->f->duplicate(obj2); 27130 initiateAllocateSmallInt(&in); 27131 in->f->set(in, 5345); 27132 o->f->push(o, (baset *) in); 27133 finishO(in); 27134 o->f->slice(o,2,40); 27135 s = toStringO(o); 27136 ck_assert_str_eq(s, "[\"sheepy\",5345]"); 27137 free(s); 27138 terminateO(o); 27139 // end negative and outside 27140 o = obj2->f->duplicate(obj2); 27141 initiateAllocateSmallInt(&in); 27142 in->f->set(in, 5345); 27143 o->f->push(o, (baset *) in); 27144 finishO(in); 27145 o->f->slice(o,2,-40); 27146 s = toStringO(o); 27147 ck_assert_str_eq(s, "[]"); 27148 free(s); 27149 terminateO(o); 27150 // end before start 27151 o = obj2->f->duplicate(obj2); 27152 initiateAllocateSmallInt(&in); 27153 in->f->set(in, 5345); 27154 o->f->push(o, (baset *) in); 27155 finishO(in); 27156 o->f->slice(o,3,2); 27157 s = toStringO(o); 27158 ck_assert_str_eq(s, "[]"); 27159 free(s); 27160 terminateO(o); 27161 // negative start last element 27162 o = obj2->f->duplicate(obj2); 27163 initiateAllocateSmallInt(&in); 27164 in->f->set(in, 5345); 27165 o->f->push(o, (baset *) in); 27166 finishO(in); 27167 o->f->slice(o,-1,0); 27168 s = toStringO(o); 27169 ck_assert_str_eq(s, "[5345]"); 27170 free(s); 27171 terminateO(o); 27172 // start = end 27173 o = obj2->f->duplicate(obj2); 27174 initiateAllocateSmallInt(&in); 27175 in->f->set(in, 5345); 27176 o->f->push(o, (baset *) in); 27177 finishO(in); 27178 o->f->slice(o,1,1); 27179 s = toStringO(o); 27180 ck_assert_str_eq(s, "[]"); 27181 free(s); 27182 terminateO(o); 27183 // empty list 27184 initiateAllocateSmallArray(&o); 27185 o->f->slice(o,0,0); 27186 s = toStringO(o); 27187 ck_assert_str_eq(s, "[]"); 27188 free(s); 27189 terminateO(o); 27190 // insert 27191 o = obj2->f->duplicate(obj2); 27192 o2 = obj2->f->duplicate(obj2); 27193 in = (smallIntt *) o2->f->getAt(o2, 1); 27194 in->value->value = 789; 27195 o2->f->setAt(o2, 1, (baset *)in); 27196 finishO(in); 27197 o->f->insert(o, 0, o2); 27198 s = toStringO(o); 27199 ck_assert_str_eq(s, "[null,789,\"sheepy\",null,123,\"sheepy\"]"); 27200 free(s); 27201 terminateO(o); 27202 o2->f->smash(&o2); 27203 // negative index 27204 o = obj2->f->duplicate(obj2); 27205 o2 = obj2->f->duplicate(obj2); 27206 in = (smallIntt *) o2->f->getAt(o2, 1); 27207 in->value->value = 789; 27208 o2->f->setAt(o2, 1, (baset *)in); 27209 finishO(in); 27210 o->f->insert(o, -1, o2); 27211 s = toStringO(o); 27212 ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]"); 27213 free(s); 27214 terminateO(o); 27215 o2->f->smash(&o2); 27216 // edge 27217 o = obj2->f->duplicate(obj2); 27218 o2 = obj2->f->duplicate(obj2); 27219 in = (smallIntt *) o2->f->getAt(o2, 1); 27220 in->value->value = 789; 27221 o2->f->setAt(o2, 1, (baset *)in); 27222 finishO(in); 27223 o->f->insert(o, 3, o2); 27224 s = toStringO(o); 27225 ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]"); 27226 free(s); 27227 terminateO(o); 27228 o2->f->smash(&o2); 27229 // outside 27230 o = obj2->f->duplicate(obj2); 27231 o2 = obj2->f->duplicate(obj2); 27232 in = (smallIntt *) o2->f->getAt(o2, 1); 27233 in->value->value = 789; 27234 o2->f->setAt(o2, 1, (baset *)in); 27235 finishO(in); 27236 o->f->insert(o, 4, o2); 27237 s = toStringO(o); 27238 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27239 free(s); 27240 o->f->insert(o, -5, o2); 27241 s = toStringO(o); 27242 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27243 free(s); 27244 terminateO(o); 27245 terminateO(o2); 27246 // negative index in a one element list 27247 o = obj2->f->duplicate(obj2); 27248 o2 = obj2->f->duplicate(obj2); 27249 in = (smallIntt *) o2->f->getAt(o2, 1); 27250 in->value->value = 789; 27251 o2->f->setAt(o2, 1, (baset *)in); 27252 finishO(in); 27253 o->f->delElem(o, 1); 27254 o->f->delElem(o, 2); 27255 o->f->trim(o); 27256 o->f->insert(o, -1, o2); 27257 s = toStringO(o); 27258 ck_assert_str_eq(s, "[null,null,789,\"sheepy\"]"); 27259 free(s); 27260 terminateO(o); 27261 o2->f->smash(&o2); 27262 // empty list 27263 initiateAllocateSmallArray(&o); 27264 o2 = obj2->f->duplicate(obj2); 27265 in = (smallIntt *) o2->f->getAt(o2, 1); 27266 in->value->value = 789; 27267 o2->f->setAt(o2, 1, (baset *)in); 27268 finishO(in); 27269 o->f->insert(o, 0, o2); 27270 s = toStringO(o); 27271 ck_assert_str_eq(s, "[null,789,\"sheepy\"]"); 27272 free(s); 27273 terminateO(o); 27274 o2->f->dispose(o2); 27275 // empty insert list 27276 o = obj2->f->duplicate(obj2); 27277 o->f->insert(o, 0, o2); 27278 s = toStringO(o); 27279 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27280 free(s); 27281 terminateO(o); 27282 o2->f->smash(&o2); 27283 //NULL insert 27284 o = obj2->f->duplicate(obj2); 27285 o->f->insert(o, 0, NULL); 27286 s = toStringO(o); 27287 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27288 free(s); 27289 terminateO(o); 27290 // del 27291 o = obj2->f->duplicate(obj2); 27292 initiateAllocateSmallInt(&in); 27293 in->f->set(in, 5345); 27294 o->f->push(o, (baset *) in); 27295 finishO(in); 27296 o->f->del(o,1,-1); 27297 s = toStringO(o); 27298 ck_assert_str_eq(s, "[null,5345]"); 27299 free(s); 27300 terminateO(o); 27301 // start outside 27302 o = obj2->f->duplicate(obj2); 27303 initiateAllocateSmallInt(&in); 27304 in->f->set(in, 5345); 27305 o->f->push(o, (baset *) in); 27306 finishO(in); 27307 o->f->del(o,20,-1); 27308 s = toStringO(o); 27309 ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]"); 27310 free(s); 27311 terminateO(o); 27312 // start negative and outside 27313 o = obj2->f->duplicate(obj2); 27314 initiateAllocateSmallInt(&in); 27315 in->f->set(in, 5345); 27316 o->f->push(o, (baset *) in); 27317 finishO(in); 27318 o->f->del(o,-20,1); 27319 s = toStringO(o); 27320 ck_assert_str_eq(s, "[123,\"sheepy\",5345]"); 27321 free(s); 27322 terminateO(o); 27323 // end outside 27324 o = obj2->f->duplicate(obj2); 27325 initiateAllocateSmallInt(&in); 27326 in->f->set(in, 5345); 27327 o->f->push(o, (baset *) in); 27328 finishO(in); 27329 o->f->del(o,2,40); 27330 s = toStringO(o); 27331 ck_assert_str_eq(s, "[null,123]"); 27332 free(s); 27333 terminateO(o); 27334 // end negative and outside 27335 o = obj2->f->duplicate(obj2); 27336 initiateAllocateSmallInt(&in); 27337 in->f->set(in, 5345); 27338 o->f->push(o, (baset *) in); 27339 finishO(in); 27340 o->f->del(o,2,-40); 27341 s = toStringO(o); 27342 ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]"); 27343 free(s); 27344 terminateO(o); 27345 // end before start 27346 o = obj2->f->duplicate(obj2); 27347 initiateAllocateSmallInt(&in); 27348 in->f->set(in, 5345); 27349 o->f->push(o, (baset *) in); 27350 finishO(in); 27351 o->f->del(o,3,2); 27352 s = toStringO(o); 27353 ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]"); 27354 free(s); 27355 terminateO(o); 27356 // negative start last element 27357 o = obj2->f->duplicate(obj2); 27358 initiateAllocateSmallInt(&in); 27359 in->f->set(in, 5345); 27360 o->f->push(o, (baset *) in); 27361 finishO(in); 27362 o->f->del(o,-1,0); 27363 s = toStringO(o); 27364 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27365 free(s); 27366 terminateO(o); 27367 // start = end 27368 o = obj2->f->duplicate(obj2); 27369 initiateAllocateSmallInt(&in); 27370 in->f->set(in, 5345); 27371 o->f->push(o, (baset *) in); 27372 finishO(in); 27373 o->f->del(o,1,1); 27374 s = toStringO(o); 27375 ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]"); 27376 free(s); 27377 terminateO(o); 27378 // empty list 27379 initiateAllocateSmallArray(&o); 27380 o->f->del(o,0,0); 27381 s = toStringO(o); 27382 ck_assert_str_eq(s, "[]"); 27383 free(s); 27384 terminateO(o); 27385 // len 27386 ck_assert_uint_eq(obj2->f->len(obj2), 3); 27387 // trim 27388 o = obj2->f->duplicate(obj2); 27389 ck_assert_uint_eq(o->f->len(o), 3); 27390 st = (smallStringt *) o->f->pop(o); 27391 terminateO(st); 27392 o->f->delElem(o, 0); 27393 o->f->trim(o); 27394 ck_assert_uint_eq(o->f->len(o), 1); 27395 s = toStringO(o); 27396 ck_assert_str_eq(s, "[123]"); 27397 free(s); 27398 terminateO(o); 27399 // getAt 27400 o = obj2->f->duplicate(obj2); 27401 u = (undefinedt *) o->f->getAt(o, 0); 27402 ck_assert_str_eq(u->type, "undefined"); 27403 terminateO(u); 27404 st = (smallStringt *) o->f->getAt(o, -1); 27405 ck_assert_str_eq(st->type, "smallString"); 27406 smashO(st); 27407 // outside 27408 u = (undefinedt *) o->f->getAt(o, 4); 27409 ck_assert_ptr_eq(u, NULL); 27410 u = (undefinedt *) o->f->getAt(o, -4); 27411 ck_assert_ptr_eq(u, NULL); 27412 terminateO(o); 27413 // empty 27414 initiateAllocateSmallArray(&o); 27415 u = (undefinedt *) o->f->getAt(o, 0); 27416 ck_assert_ptr_eq(u, NULL); 27417 terminateO(o); 27418 // setAt 27419 o = obj2->f->duplicate(obj2); 27420 initiateAllocateSmallInt(&in); 27421 o->f->setAt(o, 0, (baset *) in); 27422 finishO(in); 27423 s = toStringO(o); 27424 ck_assert_str_eq(s, "[0,123,\"sheepy\"]"); 27425 free(s); 27426 initiateAllocateSmallInt(&in); 27427 o->f->setAt(o, -1, (baset *) in); 27428 finishO(in); 27429 s = toStringO(o); 27430 ck_assert_str_eq(s, "[0,123,0]"); 27431 free(s); 27432 // outside 27433 o->f->setAt(o, 4, (baset *) in); 27434 s = toStringO(o); 27435 ck_assert_str_eq(s, "[0,123,0]"); 27436 free(s); 27437 o->f->setAt(o, -4, (baset *) in); 27438 s = toStringO(o); 27439 ck_assert_str_eq(s, "[0,123,0]"); 27440 free(s); 27441 terminateO(o); 27442 // empty 27443 o = obj2->f->duplicate(obj2); 27444 o->f->empty(o); 27445 ck_assert(o->f->isEmpty(o)); 27446 terminateO(o); 27447 // isEmpty 27448 o = obj2->f->duplicate(obj2); 27449 ck_assert(!o->f->isEmpty(o)); 27450 terminateO(o); 27451 initiateAllocateSmallArray(&o); 27452 ck_assert(o->f->isEmpty(o)); 27453 terminateO(o); 27454 // typeString type typeStrings types 27455 initiateAllocateSmallArray(&o2); 27456 o = allocSmallArray(); 27457 oU = allocUndefined(); 27458 o->f->push(o, (baset *)oU); 27459 finishO(oU); 27460 oInt = allocSmallInt(123); 27461 o->f->push(o, (baset *)oInt); 27462 finishO(oInt); 27463 oStr = allocSmallString("sheepy"); 27464 o->f->push(o, (baset *)oStr); 27465 finishO(oStr); 27466 o->f->push(o, NULL); 27467 // typeString 27468 s = (char *)o->f->typeString(o, 0); 27469 ck_assert_str_eq(s, "undefined"); 27470 // type 27471 char c = o->f->type(o, 2); 27472 ck_assert_uint_eq(c, STRING); 27473 // negative index 27474 c = o->f->type(o, -2); 27475 ck_assert_uint_eq(c, INT); 27476 // outside 27477 ck_assert(!o->f->type(o, 10)); 27478 ck_assert(!o->f->type(o, -14)); 27479 // NULL element 27480 c = o->f->type(o, 0); 27481 ck_assert_uint_eq(c, UNDEFINED); 27482 // empty object 27483 ck_assert(!o2->f->type(o2, 0)); 27484 // typeStrings 27485 char **l = o->f->typeStrings(o); 27486 s = join(l, ","); 27487 ck_assert_str_eq(s, "undefined,int,string"); 27488 free(s); 27489 free(l); 27490 // empty object 27491 ck_assert_ptr_eq(o2->f->typeStrings(o2), NULL); 27492 // types 27493 smallBytest *B = o->f->types(o); 27494 s = sToStringTiny((smallt *)B->B); 27495 ck_assert_str_eq(s, "[0x01,0x07,0x08]"); 27496 free(s); 27497 // empty object 27498 ck_assert_ptr_eq(o2->f->types(o2), NULL); 27499 terminateO(B); 27500 terminateO(o); 27501 terminateO(o2); 27502 // free local object 27503 obj.f->free(&obj); 27504 ck_assert_str_eq(obj.type, "smallArray"); 27505 // free object 27506 obj2->f->terminate(&obj2); 27507 ck_assert_ptr_eq(obj2, NULL); 27508 // init NULL 27509 initiateAllocateSmallArray(NULL); 27510 27511 END_TEST 27512 27513 27514 27515 Suite * libsheepySuite(void) { 27516 Suite *s; 27517 TCase *tc_core; 27518 27519 s = suite_create("libsheepy"); 27520 27521 /* Core test case */ 27522 tc_core = tcase_create("Object"); 27523 27524 setLogMode(LOG_VERBOSE); 27525 27526 // disable btrace to make the test run faster 27527 btraceDisable(); 27528 27529 tcase_add_test(tc_core, allocArraySmallArrayT); 27530 tcase_add_test(tc_core, allocCArraySmallArrayT); 27531 tcase_add_test(tc_core, createSAFT); 27532 tcase_add_test(tc_core, getsoSmallArrayT); 27533 tcase_add_test(tc_core, setsoSmallArrayT); 27534 tcase_add_test(tc_core, mirrorSmallArrayT); 27535 tcase_add_test(tc_core, fromArrayNFreeSmallArrayT); 27536 tcase_add_test(tc_core, pushUndefinedSmallArrayT); 27537 tcase_add_test(tc_core, pushBoolSmallArrayT); 27538 tcase_add_test(tc_core, pushDoubleSmallArrayT); 27539 tcase_add_test(tc_core, pushIntSmallArrayT); 27540 tcase_add_test(tc_core, pushSSmallArrayT); 27541 tcase_add_test(tc_core, pushCharSmallArrayT); 27542 tcase_add_test(tc_core, pushDictSmallArrayT); 27543 tcase_add_test(tc_core, pushArraySmallArrayT); 27544 tcase_add_test(tc_core, pushArraycSmallArrayT); 27545 tcase_add_test(tc_core, pushSmallBoolSmallArrayT); 27546 tcase_add_test(tc_core, pushSmallBytesSmallArrayT); 27547 tcase_add_test(tc_core, pushSmallDoubleSmallArrayT); 27548 tcase_add_test(tc_core, pushSmallIntSmallArrayT); 27549 tcase_add_test(tc_core, pushSmallJsonSmallArrayT); 27550 tcase_add_test(tc_core, pushSmallStringSmallArrayT); 27551 tcase_add_test(tc_core, pushSmallContainerSmallArrayT); 27552 tcase_add_test(tc_core, pushNFreeSmallArrayT); 27553 tcase_add_test(tc_core, pushNFreeUndefinedSmallArrayT); 27554 tcase_add_test(tc_core, pushNFreeSSmallArrayT); 27555 tcase_add_test(tc_core, pushNFreeDictSmallArrayT); 27556 tcase_add_test(tc_core, pushNFreeArraySmallArrayT); 27557 tcase_add_test(tc_core, pushNFreeArraycSmallArrayT); 27558 tcase_add_test(tc_core, pushNFreeSmallBoolSmallArrayT); 27559 tcase_add_test(tc_core, pushNFreeSmallBytesSmallArrayT); 27560 tcase_add_test(tc_core, pushNFreeSmallDoubleSmallArrayT); 27561 tcase_add_test(tc_core, pushNFreeSmallIntSmallArrayT); 27562 tcase_add_test(tc_core, pushNFreeSmallJsonSmallArrayT); 27563 tcase_add_test(tc_core, pushNFreeSmallStringSmallArrayT); 27564 tcase_add_test(tc_core, pushNFreeSmallContainerSmallArrayT); 27565 tcase_add_test(tc_core, pushManySmallArrayT); 27566 tcase_add_test(tc_core, pushManySSmallArrayT); 27567 tcase_add_test(tc_core, pushNFreeManySmallArrayT); 27568 tcase_add_test(tc_core, pushNFreeManySSmallArrayT); 27569 tcase_add_test(tc_core, popSmallArrayT); 27570 tcase_add_test(tc_core, popUndefinedSmallArrayT); 27571 tcase_add_test(tc_core, popBoolSmallArrayT); 27572 tcase_add_test(tc_core, popDoubleSmallArrayT); 27573 tcase_add_test(tc_core, popIntSmallArrayT); 27574 tcase_add_test(tc_core, popInt32SmallArrayT); 27575 tcase_add_test(tc_core, popUintSmallArrayT); 27576 tcase_add_test(tc_core, popUint32SmallArrayT); 27577 tcase_add_test(tc_core, popSSmallArrayT); 27578 tcase_add_test(tc_core, popDictSmallArrayT); 27579 tcase_add_test(tc_core, popArraySmallArrayT); 27580 tcase_add_test(tc_core, popSmallBoolSmallArrayT); 27581 tcase_add_test(tc_core, popSmallBytesSmallArrayT); 27582 tcase_add_test(tc_core, popSmallDoubleSmallArrayT); 27583 tcase_add_test(tc_core, popSmallIntSmallArrayT); 27584 tcase_add_test(tc_core, popSmallJsonSmallArrayT); 27585 tcase_add_test(tc_core, popSmallStringSmallArrayT); 27586 tcase_add_test(tc_core, popVoidSmallArrayT); 27587 tcase_add_test(tc_core, popSmallContainerSmallArrayT); 27588 tcase_add_test(tc_core, popNumSmallArrayT); 27589 tcase_add_test(tc_core, prependSmallArrayT); 27590 tcase_add_test(tc_core, prependUndefinedSmallArrayT); 27591 tcase_add_test(tc_core, prependBoolSmallArrayT); 27592 tcase_add_test(tc_core, prependDoubleSmallArrayT); 27593 tcase_add_test(tc_core, prependIntSmallArrayT); 27594 tcase_add_test(tc_core, prependSSmallArrayT); 27595 tcase_add_test(tc_core, prependCharSmallArrayT); 27596 tcase_add_test(tc_core, prependDictSmallArrayT); 27597 tcase_add_test(tc_core, prependArraySmallArrayT); 27598 tcase_add_test(tc_core, prependArraycSmallArrayT); 27599 tcase_add_test(tc_core, prependSmallBoolSmallArrayT); 27600 tcase_add_test(tc_core, prependSmallBytesSmallArrayT); 27601 tcase_add_test(tc_core, prependSmallDoubleSmallArrayT); 27602 tcase_add_test(tc_core, prependSmallIntSmallArrayT); 27603 tcase_add_test(tc_core, prependSmallJsonSmallArrayT); 27604 tcase_add_test(tc_core, prependSmallStringSmallArrayT); 27605 tcase_add_test(tc_core, prependSmallContainerSmallArrayT); 27606 tcase_add_test(tc_core, prependNFreeSmallArrayT); 27607 tcase_add_test(tc_core, prependNFreeUndefinedSmallArrayT); 27608 tcase_add_test(tc_core, prependNFreeSSmallArrayT); 27609 tcase_add_test(tc_core, prependNFreeDictSmallArrayT); 27610 tcase_add_test(tc_core, prependNFreeArraySmallArrayT); 27611 tcase_add_test(tc_core, prependNFreeArraycSmallArrayT); 27612 tcase_add_test(tc_core, prependNFreeSmallBoolSmallArrayT); 27613 tcase_add_test(tc_core, prependNFreeSmallBytesSmallArrayT); 27614 tcase_add_test(tc_core, prependNFreeSmallDoubleSmallArrayT); 27615 tcase_add_test(tc_core, prependNFreeSmallIntSmallArrayT); 27616 tcase_add_test(tc_core, prependNFreeSmallJsonSmallArrayT); 27617 tcase_add_test(tc_core, prependNFreeSmallStringSmallArrayT); 27618 tcase_add_test(tc_core, prependNFreeSmallContainerSmallArrayT); 27619 tcase_add_test(tc_core, dequeueSmallArrayT); 27620 tcase_add_test(tc_core, dequeueUndefinedSmallArrayT); 27621 tcase_add_test(tc_core, dequeueBoolSmallArrayT); 27622 tcase_add_test(tc_core, dequeueDoubleSmallArrayT); 27623 tcase_add_test(tc_core, dequeueIntSmallArrayT); 27624 tcase_add_test(tc_core, dequeueInt32SmallArrayT); 27625 tcase_add_test(tc_core, dequeueUintSmallArrayT); 27626 tcase_add_test(tc_core, dequeueUint32SmallArrayT); 27627 tcase_add_test(tc_core, dequeueSSmallArrayT); 27628 tcase_add_test(tc_core, dequeueDictSmallArrayT); 27629 tcase_add_test(tc_core, dequeueArraySmallArrayT); 27630 tcase_add_test(tc_core, dequeueSmallBoolSmallArrayT); 27631 tcase_add_test(tc_core, dequeueSmallBytesSmallArrayT); 27632 tcase_add_test(tc_core, dequeueSmallDoubleSmallArrayT); 27633 tcase_add_test(tc_core, dequeueSmallIntSmallArrayT); 27634 tcase_add_test(tc_core, dequeueSmallJsonSmallArrayT); 27635 tcase_add_test(tc_core, dequeueSmallStringSmallArrayT); 27636 tcase_add_test(tc_core, dequeueVoidSmallArrayT); 27637 tcase_add_test(tc_core, dequeueSmallContainerSmallArrayT); 27638 tcase_add_test(tc_core, dequeueNumSmallArrayT); 27639 tcase_add_test(tc_core, reverseSmallArrayT); 27640 tcase_add_test(tc_core, catSmallArrayT); 27641 tcase_add_test(tc_core, appendSmallJsonSmallArrayT); 27642 tcase_add_test(tc_core, appendNSmashSmallArrayT); 27643 tcase_add_test(tc_core, appendNSmashSmallJsonSmallArrayT); 27644 tcase_add_test(tc_core, appendArraySmallArrayT); 27645 tcase_add_test(tc_core, appendNSmashArraySmallArrayT); 27646 tcase_add_test(tc_core, shiftSmallArrayT); 27647 tcase_add_test(tc_core, shiftSmallJsonSmallArrayT); 27648 tcase_add_test(tc_core, shiftNSmashSmallArrayT); 27649 tcase_add_test(tc_core, shiftNSmashSmallJsonSmallArrayT); 27650 tcase_add_test(tc_core, addSmallArrayT); 27651 tcase_add_test(tc_core, cropSmallArrayT); 27652 tcase_add_test(tc_core, cropElemSmallArrayT); 27653 tcase_add_test(tc_core, cropElemUndefinedSmallArrayT); 27654 tcase_add_test(tc_core, cropElemBoolSmallArrayT); 27655 tcase_add_test(tc_core, cropElemDoubleSmallArrayT); 27656 tcase_add_test(tc_core, cropElemIntSmallArrayT); 27657 tcase_add_test(tc_core, cropElemInt32SmallArrayT); 27658 tcase_add_test(tc_core, cropElemUintSmallArrayT); 27659 tcase_add_test(tc_core, cropElemUint32SmallArrayT); 27660 tcase_add_test(tc_core, cropElemSSmallArrayT); 27661 tcase_add_test(tc_core, cropElemDictSmallArrayT); 27662 tcase_add_test(tc_core, cropElemArraySmallArrayT); 27663 tcase_add_test(tc_core, cropElemSmallBoolSmallArrayT); 27664 tcase_add_test(tc_core, cropElemSmallBytesSmallArrayT); 27665 tcase_add_test(tc_core, cropElemSmallDoubleSmallArrayT); 27666 tcase_add_test(tc_core, cropElemSmallIntSmallArrayT); 27667 tcase_add_test(tc_core, cropElemSmallJsonSmallArrayT); 27668 tcase_add_test(tc_core, cropElemSmallStringSmallArrayT); 27669 tcase_add_test(tc_core, cropElemVoidSmallArrayT); 27670 tcase_add_test(tc_core, cropElemSmallContainerSmallArrayT); 27671 tcase_add_test(tc_core, copySmallArrayT); 27672 tcase_add_test(tc_core, insertSmallArrayT); 27673 tcase_add_test(tc_core, insertSmallJsonSmallArrayT); 27674 tcase_add_test(tc_core, insertNSmashSmallArrayT); 27675 tcase_add_test(tc_core, insertNSmashSmallJsonSmallArrayT); 27676 tcase_add_test(tc_core, injectSmallArrayT); 27677 tcase_add_test(tc_core, injectUndefinedSmallArrayT); 27678 tcase_add_test(tc_core, injectBoolSmallArrayT); 27679 tcase_add_test(tc_core, injectDoubleSmallArrayT); 27680 tcase_add_test(tc_core, injectIntSmallArrayT); 27681 tcase_add_test(tc_core, injectSSmallArrayT); 27682 tcase_add_test(tc_core, injectCharSmallArrayT); 27683 tcase_add_test(tc_core, injectDictSmallArrayT); 27684 tcase_add_test(tc_core, injectArraySmallArrayT); 27685 tcase_add_test(tc_core, injectArraycSmallArrayT); 27686 tcase_add_test(tc_core, injectSmallBoolSmallArrayT); 27687 tcase_add_test(tc_core, injectSmallBytesSmallArrayT); 27688 tcase_add_test(tc_core, injectSmallDoubleSmallArrayT); 27689 tcase_add_test(tc_core, injectSmallIntSmallArrayT); 27690 tcase_add_test(tc_core, injectSmallJsonSmallArrayT); 27691 tcase_add_test(tc_core, injectSmallStringSmallArrayT); 27692 tcase_add_test(tc_core, injectSmallContainerSmallArrayT); 27693 tcase_add_test(tc_core, injectNFreeSmallArrayT); 27694 tcase_add_test(tc_core, injectNFreeUndefinedSmallArrayT); 27695 tcase_add_test(tc_core, injectNFreeSSmallArrayT); 27696 tcase_add_test(tc_core, injectNFreeDictSmallArrayT); 27697 tcase_add_test(tc_core, injectNFreeArraySmallArrayT); 27698 tcase_add_test(tc_core, injectNFreeArraycSmallArrayT); 27699 tcase_add_test(tc_core, injectNFreeSmallBoolSmallArrayT); 27700 tcase_add_test(tc_core, injectNFreeSmallBytesSmallArrayT); 27701 tcase_add_test(tc_core, injectNFreeSmallDoubleSmallArrayT); 27702 tcase_add_test(tc_core, injectNFreeSmallIntSmallArrayT); 27703 tcase_add_test(tc_core, injectNFreeSmallJsonSmallArrayT); 27704 tcase_add_test(tc_core, injectNFreeSmallStringSmallArrayT); 27705 tcase_add_test(tc_core, injectNFreeSmallContainerSmallArrayT); 27706 tcase_add_test(tc_core, removeSmallArrayT); 27707 tcase_add_test(tc_core, removeElemSmallArrayT); 27708 tcase_add_test(tc_core, sortSmallArrayT); 27709 tcase_add_test(tc_core, icSortSmallArrayT); 27710 tcase_add_test(tc_core, sortFSmallArrayT); 27711 tcase_add_test(tc_core, equalSmallArrayT); 27712 tcase_add_test(tc_core, equalSmallArraySmallJsonT); 27713 tcase_add_test(tc_core, equalSmallArrayArrayT); 27714 tcase_add_test(tc_core, equalSmallArrayBaseT); 27715 tcase_add_test(tc_core, icEqualSmallArrayT); 27716 tcase_add_test(tc_core, icEqualSmallArraySmallJsonT); 27717 tcase_add_test(tc_core, icEqualSmallArrayArrayT); 27718 tcase_add_test(tc_core, icEqualSmallArrayBaseT); 27719 tcase_add_test(tc_core, getAtUndefinedSmallArrayT); 27720 tcase_add_test(tc_core, getAtBoolSmallArrayT); 27721 tcase_add_test(tc_core, getAtBoolPSmallArrayT); 27722 tcase_add_test(tc_core, getAtDoubleSmallArrayT); 27723 tcase_add_test(tc_core, getAtDoublePSmallArrayT); 27724 tcase_add_test(tc_core, getAtIntSmallArrayT); 27725 tcase_add_test(tc_core, getAtIntPSmallArrayT); 27726 tcase_add_test(tc_core, getAtInt32SmallArrayT); 27727 tcase_add_test(tc_core, getAtInt32PSmallArrayT); 27728 tcase_add_test(tc_core, getAtUintSmallArrayT); 27729 tcase_add_test(tc_core, getAtUintPSmallArrayT); 27730 tcase_add_test(tc_core, getAtUint32SmallArrayT); 27731 tcase_add_test(tc_core, getAtUint32PSmallArrayT); 27732 tcase_add_test(tc_core, getAtSSmallArrayT); 27733 tcase_add_test(tc_core, getAtDictSmallArrayT); 27734 tcase_add_test(tc_core, getAtArraySmallArrayT); 27735 tcase_add_test(tc_core, getAtSmallBoolSmallArrayT); 27736 tcase_add_test(tc_core, getAtSmallBytesSmallArrayT); 27737 tcase_add_test(tc_core, getAtSmallDoubleSmallArrayT); 27738 tcase_add_test(tc_core, getAtSmallIntSmallArrayT); 27739 tcase_add_test(tc_core, getAtSmallJsonSmallArrayT); 27740 tcase_add_test(tc_core, getAtSmallStringSmallArrayT); 27741 tcase_add_test(tc_core, getAtVoidSmallArrayT); 27742 tcase_add_test(tc_core, getAtSmallContainerSmallArrayT); 27743 tcase_add_test(tc_core, getAtNDupSmallArrayT); 27744 tcase_add_test(tc_core, getAtNDupUndefinedSmallArrayT); 27745 tcase_add_test(tc_core, getAtNDupBoolSmallArrayT); 27746 tcase_add_test(tc_core, getAtNDupDoubleSmallArrayT); 27747 tcase_add_test(tc_core, getAtNDupIntSmallArrayT); 27748 tcase_add_test(tc_core, getAtNDupInt32SmallArrayT); 27749 tcase_add_test(tc_core, getAtNDupUintSmallArrayT); 27750 tcase_add_test(tc_core, getAtNDupUint32SmallArrayT); 27751 tcase_add_test(tc_core, getAtNDupSSmallArrayT); 27752 tcase_add_test(tc_core, getAtNDupDictSmallArrayT); 27753 tcase_add_test(tc_core, getAtNDupArraySmallArrayT); 27754 tcase_add_test(tc_core, getAtNDupSmallBoolSmallArrayT); 27755 tcase_add_test(tc_core, getAtNDupSmallBytesSmallArrayT); 27756 tcase_add_test(tc_core, getAtNDupSmallDoubleSmallArrayT); 27757 tcase_add_test(tc_core, getAtNDupSmallIntSmallArrayT); 27758 tcase_add_test(tc_core, getAtNDupSmallJsonSmallArrayT); 27759 tcase_add_test(tc_core, getAtNDupSmallStringSmallArrayT); 27760 tcase_add_test(tc_core, getAtNDupVoidSmallArrayT); 27761 tcase_add_test(tc_core, getAtNDupSmallContainerSmallArrayT); 27762 tcase_add_test(tc_core, setAtSmallArrayT); 27763 tcase_add_test(tc_core, setAtUndefinedSmallArrayT); 27764 tcase_add_test(tc_core, setAtBoolSmallArrayT); 27765 tcase_add_test(tc_core, setAtDoubleSmallArrayT); 27766 tcase_add_test(tc_core, setAtIntSmallArrayT); 27767 tcase_add_test(tc_core, setAtSSmallArrayT); 27768 tcase_add_test(tc_core, setAtCharSmallArrayT); 27769 tcase_add_test(tc_core, setAtDictSmallArrayT); 27770 tcase_add_test(tc_core, setAtArraySmallArrayT); 27771 tcase_add_test(tc_core, setAtArraycSmallArrayT); 27772 tcase_add_test(tc_core, setAtSmallBoolSmallArrayT); 27773 tcase_add_test(tc_core, setAtSmallBytesSmallArrayT); 27774 tcase_add_test(tc_core, setAtSmallDoubleSmallArrayT); 27775 tcase_add_test(tc_core, setAtSmallIntSmallArrayT); 27776 tcase_add_test(tc_core, setAtSmallJsonSmallArrayT); 27777 tcase_add_test(tc_core, setAtSmallStringSmallArrayT); 27778 tcase_add_test(tc_core, setAtSmallContainerSmallArrayT); 27779 tcase_add_test(tc_core, setAtNFreeSmallArrayT); 27780 tcase_add_test(tc_core, setAtNFreeUndefinedSmallArrayT); 27781 tcase_add_test(tc_core, setAtNFreeSSmallArrayT); 27782 tcase_add_test(tc_core, setAtNFreeDictSmallArrayT); 27783 tcase_add_test(tc_core, setAtNFreeArraySmallArrayT); 27784 tcase_add_test(tc_core, setAtNFreeArraycSmallArrayT); 27785 tcase_add_test(tc_core, setAtNFreeSmallBoolSmallArrayT); 27786 tcase_add_test(tc_core, setAtNFreeSmallBytesSmallArrayT); 27787 tcase_add_test(tc_core, setAtNFreeSmallDoubleSmallArrayT); 27788 tcase_add_test(tc_core, setAtNFreeSmallIntSmallArrayT); 27789 tcase_add_test(tc_core, setAtNFreeSmallJsonSmallArrayT); 27790 tcase_add_test(tc_core, setAtNFreeSmallStringSmallArrayT); 27791 tcase_add_test(tc_core, setAtNFreeSmallContainerSmallArrayT); 27792 tcase_add_test(tc_core, setPAtDictSmallArrayT); 27793 tcase_add_test(tc_core, setPAtArraySmallArrayT); 27794 tcase_add_test(tc_core, setPAtSmallJsonSmallArrayT); 27795 tcase_add_test(tc_core, setPAtSmallStringSmallArrayT); 27796 tcase_add_test(tc_core, setPAtNFreeDictSmallArrayT); 27797 tcase_add_test(tc_core, setPAtNFreeArraySmallArrayT); 27798 tcase_add_test(tc_core, setPAtNFreeSmallJsonSmallArrayT); 27799 tcase_add_test(tc_core, setPAtNFreeSmallStringSmallArrayT); 27800 tcase_add_test(tc_core, getNumSmallArrayT); 27801 tcase_add_test(tc_core, hasSmallArrayT); 27802 tcase_add_test(tc_core, hasUndefinedSmallArrayT); 27803 tcase_add_test(tc_core, hasBoolSmallArrayT); 27804 tcase_add_test(tc_core, hasDoubleSmallArrayT); 27805 tcase_add_test(tc_core, hasIntSmallArrayT); 27806 tcase_add_test(tc_core, hasSSmallArrayT); 27807 tcase_add_test(tc_core, hasCharSmallArrayT); 27808 tcase_add_test(tc_core, hasDictSmallArrayT); 27809 tcase_add_test(tc_core, hasArraySmallArrayT); 27810 tcase_add_test(tc_core, hasArraycSmallArrayT); 27811 tcase_add_test(tc_core, hasSmallBoolSmallArrayT); 27812 tcase_add_test(tc_core, hasSmallBytesSmallArrayT); 27813 tcase_add_test(tc_core, hasSmallDoubleSmallArrayT); 27814 tcase_add_test(tc_core, hasSmallIntSmallArrayT); 27815 tcase_add_test(tc_core, hasSmallJsonSmallArrayT); 27816 tcase_add_test(tc_core, hasSmallStringSmallArrayT); 27817 tcase_add_test(tc_core, hasSmallContainerSmallArrayT); 27818 tcase_add_test(tc_core, indexOfSmallArrayT); 27819 tcase_add_test(tc_core, indexOfUndefinedSmallArrayT); 27820 tcase_add_test(tc_core, indexOfBoolSmallArrayT); 27821 tcase_add_test(tc_core, indexOfDoubleSmallArrayT); 27822 tcase_add_test(tc_core, indexOfIntSmallArrayT); 27823 tcase_add_test(tc_core, indexOfSSmallArrayT); 27824 tcase_add_test(tc_core, indexOfCharSmallArrayT); 27825 tcase_add_test(tc_core, indexOfDictSmallArrayT); 27826 tcase_add_test(tc_core, indexOfArraySmallArrayT); 27827 tcase_add_test(tc_core, indexOfArraycSmallArrayT); 27828 tcase_add_test(tc_core, indexOfSmallBoolSmallArrayT); 27829 tcase_add_test(tc_core, indexOfSmallBytesSmallArrayT); 27830 tcase_add_test(tc_core, indexOfSmallDoubleSmallArrayT); 27831 tcase_add_test(tc_core, indexOfSmallIntSmallArrayT); 27832 tcase_add_test(tc_core, indexOfSmallJsonSmallArrayT); 27833 tcase_add_test(tc_core, indexOfSmallStringSmallArrayT); 27834 tcase_add_test(tc_core, indexOfSmallContainerSmallArrayT); 27835 tcase_add_test(tc_core, binarySearchSmallArrayT); 27836 tcase_add_test(tc_core, binarySearchUndefinedSmallArrayT); 27837 tcase_add_test(tc_core, binarySearchBoolSmallArrayT); 27838 tcase_add_test(tc_core, binarySearchDoubleSmallArrayT); 27839 tcase_add_test(tc_core, binarySearchIntSmallArrayT); 27840 tcase_add_test(tc_core, binarySearchSSmallArrayT); 27841 tcase_add_test(tc_core, binarySearchCharSmallArrayT); 27842 tcase_add_test(tc_core, binarySearchDictSmallArrayT); 27843 tcase_add_test(tc_core, binarySearchArraySmallArrayT); 27844 tcase_add_test(tc_core, binarySearchArraycSmallArrayT); 27845 tcase_add_test(tc_core, binarySearchSmallBoolSmallArrayT); 27846 tcase_add_test(tc_core, binarySearchSmallBytesSmallArrayT); 27847 tcase_add_test(tc_core, binarySearchSmallDoubleSmallArrayT); 27848 tcase_add_test(tc_core, binarySearchSmallIntSmallArrayT); 27849 tcase_add_test(tc_core, binarySearchSmallJsonSmallArrayT); 27850 tcase_add_test(tc_core, binarySearchSmallStringSmallArrayT); 27851 tcase_add_test(tc_core, binarySearchSmallContainerSmallArrayT); 27852 tcase_add_test(tc_core, uniqSmallArrayT); 27853 tcase_add_test(tc_core, icHasSmallArrayT); 27854 tcase_add_test(tc_core, icHasSSmallArrayT); 27855 tcase_add_test(tc_core, icHasCharSmallArrayT); 27856 tcase_add_test(tc_core, icHasDictSmallArrayT); 27857 tcase_add_test(tc_core, icHasArraySmallArrayT); 27858 tcase_add_test(tc_core, icHasArraycSmallArrayT); 27859 tcase_add_test(tc_core, icHasSmallJsonSmallArrayT); 27860 tcase_add_test(tc_core, icHasSmallStringSmallArrayT); 27861 tcase_add_test(tc_core, icIndexOfSmallArrayT); 27862 tcase_add_test(tc_core, icIndexOfSSmallArrayT); 27863 tcase_add_test(tc_core, icIndexOfCharSmallArrayT); 27864 tcase_add_test(tc_core, icIndexOfDictSmallArrayT); 27865 tcase_add_test(tc_core, icIndexOfArraySmallArrayT); 27866 tcase_add_test(tc_core, icIndexOfArraycSmallArrayT); 27867 tcase_add_test(tc_core, icIndexOfSmallJsonSmallArrayT); 27868 tcase_add_test(tc_core, icIndexOfSmallStringSmallArrayT); 27869 tcase_add_test(tc_core, icBinarySearchSmallArrayT); 27870 tcase_add_test(tc_core, icBinarySearchSSmallArrayT); 27871 tcase_add_test(tc_core, icBinarySearchCharSmallArrayT); 27872 tcase_add_test(tc_core, icBinarySearchDictSmallArrayT); 27873 tcase_add_test(tc_core, icBinarySearchArraySmallArrayT); 27874 tcase_add_test(tc_core, icBinarySearchArraycSmallArrayT); 27875 tcase_add_test(tc_core, icBinarySearchSmallJsonSmallArrayT); 27876 tcase_add_test(tc_core, icBinarySearchSmallStringSmallArrayT); 27877 tcase_add_test(tc_core, icUniqSmallArrayT); 27878 tcase_add_test(tc_core, compactSmallArrayT); 27879 tcase_add_test(tc_core, isBlankSmallArrayT); 27880 tcase_add_test(tc_core, forEachSmallArrayFT); 27881 tcase_add_test(tc_core, enumerateSmallArrayFT); 27882 tcase_add_test(tc_core, iterStartSmallArrayT); 27883 tcase_add_test(tc_core, iterStartLastSmallArrayT); 27884 tcase_add_test(tc_core, iterStartFromSmallArrayT); 27885 tcase_add_test(tc_core, iterStartFromStepSmallArrayT); 27886 tcase_add_test(tc_core, iterNextSmallArrayT); 27887 tcase_add_test(tc_core, iterElementSmallArrayT); 27888 tcase_add_test(tc_core, iterIndexSmallArrayT); 27889 tcase_add_test(tc_core, iterStepSmallArrayT); 27890 tcase_add_test(tc_core, joinSmallArrayT); 27891 tcase_add_test(tc_core, joinCharSmallArrayT); 27892 tcase_add_test(tc_core, joinSmallJsonSmallArrayT); 27893 tcase_add_test(tc_core, joinSmallStringSmallArrayT); 27894 tcase_add_test(tc_core, joinSSmallArrayT); 27895 tcase_add_test(tc_core, joinCharSSmallArrayT); 27896 tcase_add_test(tc_core, joinSmallJsonSSmallArrayT); 27897 tcase_add_test(tc_core, joinSmallStringSSmallArrayT); 27898 tcase_add_test(tc_core, zipSmallArrayT); 27899 tcase_add_test(tc_core, zipSmallJsonSmallArrayT); 27900 tcase_add_test(tc_core, zipSmallJsonSmallArraySmallArrayT); 27901 tcase_add_test(tc_core, zipSmallJsonSmallJsonSmallArrayT); 27902 tcase_add_test(tc_core, zipSmallJsonCharSmallArrayT); 27903 tcase_add_test(tc_core, zipSmallJsonCCharSmallArrayT); 27904 tcase_add_test(tc_core, zipArraySmallArrayT); 27905 tcase_add_test(tc_core, zipCArraySmallArrayT); 27906 tcase_add_test(tc_core, zipArraySmallJsonSmallArrayT); 27907 tcase_add_test(tc_core, zipCArraySmallJsonSmallArrayT); 27908 tcase_add_test(tc_core, zipCharSmallArrayT); 27909 tcase_add_test(tc_core, zipCCharSmallArrayT); 27910 tcase_add_test(tc_core, zipArrayCharSmallArrayT); 27911 tcase_add_test(tc_core, zipCArrayCharSmallArrayT); 27912 tcase_add_test(tc_core, zipArrayCCharSmallArrayT); 27913 tcase_add_test(tc_core, zipCArrayCCharSmallArrayT); 27914 tcase_add_test(tc_core, logSmallArrayT); 27915 tcase_add_test(tc_core, readTextSmallArrayT); 27916 tcase_add_test(tc_core, readTextSmallJsonSmallArrayT); 27917 tcase_add_test(tc_core, readTextSmallStringSmallArrayT); 27918 tcase_add_test(tc_core, readStreamSmallArrayT); 27919 tcase_add_test(tc_core, writeTextSmallArrayT); 27920 tcase_add_test(tc_core, writeTextSmallJsonSmallArrayT); 27921 tcase_add_test(tc_core, writeTextSmallStringSmallArrayT); 27922 tcase_add_test(tc_core, writeStreamSmallArrayT); 27923 tcase_add_test(tc_core, appendTextSmallArrayT); 27924 tcase_add_test(tc_core, appendTextSmallStringSmallArrayT); 27925 tcase_add_test(tc_core, typeSmallStringSmallArrayT); 27926 tcase_add_test(tc_core, typeSmallStringsSmallArrayT); 27927 tcase_add_test(tc_core, isETypeSmallArrayT); 27928 tcase_add_test(tc_core, isEUndefinedSmallArrayT); 27929 tcase_add_test(tc_core, isEBoolSmallArrayT); 27930 tcase_add_test(tc_core, isEContainerSmallArrayT); 27931 tcase_add_test(tc_core, isEDictSmallArrayT); 27932 tcase_add_test(tc_core, isEDoubleSmallArrayT); 27933 tcase_add_test(tc_core, isEIntSmallArrayT); 27934 tcase_add_test(tc_core, isEStringSmallArrayT); 27935 tcase_add_test(tc_core, isEFaststringSmallArrayT); 27936 tcase_add_test(tc_core, isEArraySmallArrayT); 27937 tcase_add_test(tc_core, isEBytesSmallArrayT); 27938 tcase_add_test(tc_core, areAllETypeSmallArrayT); 27939 tcase_add_test(tc_core, areAllEUndefinedSmallArrayT); 27940 tcase_add_test(tc_core, areAllEBoolSmallArrayT); 27941 tcase_add_test(tc_core, areAllEContainerSmallArrayT); 27942 tcase_add_test(tc_core, areAllEDictSmallArrayT); 27943 tcase_add_test(tc_core, areAllEDoubleSmallArrayT); 27944 tcase_add_test(tc_core, areAllEIntSmallArrayT); 27945 tcase_add_test(tc_core, areAllEStringSmallArrayT); 27946 tcase_add_test(tc_core, areAllEFaststringSmallArrayT); 27947 tcase_add_test(tc_core, areAllEArraySmallArrayT); 27948 tcase_add_test(tc_core, areAllEBytesSmallArrayT); 27949 tcase_add_test(tc_core, allocSmallArrayGT); 27950 tcase_add_test(tc_core, duplicateSmallArrayGT); 27951 tcase_add_test(tc_core, freeSmallArrayGT); 27952 tcase_add_test(tc_core, fromArraySmallArrayGT); 27953 tcase_add_test(tc_core, fromCArraySmallArrayGT); 27954 tcase_add_test(tc_core, setFromSmallArrayGT); 27955 tcase_add_test(tc_core, setFromCSmallArrayGT); 27956 tcase_add_test(tc_core, pushSmallArrayGT); 27957 tcase_add_test(tc_core, pushUndefinedSmallArrayGT); 27958 tcase_add_test(tc_core, pushBoolSmallArrayGT); 27959 tcase_add_test(tc_core, pushDoubleSmallArrayGT); 27960 tcase_add_test(tc_core, pushIntSmallArrayGT); 27961 tcase_add_test(tc_core, pushSSmallArrayGT); 27962 tcase_add_test(tc_core, pushCharSmallArrayGT); 27963 tcase_add_test(tc_core, pushDictSmallArrayGT); 27964 tcase_add_test(tc_core, pushArraySmallArrayGT); 27965 tcase_add_test(tc_core, pushArraycSmallArrayGT); 27966 tcase_add_test(tc_core, pushCArraycSmallArrayGT); 27967 tcase_add_test(tc_core, pushVoidSmallArrayGT); 27968 tcase_add_test(tc_core, pushSmallBoolSmallArrayGT); 27969 tcase_add_test(tc_core, pushSmallBytesSmallArrayGT); 27970 tcase_add_test(tc_core, pushSmallDoubleSmallArrayGT); 27971 tcase_add_test(tc_core, pushSmallIntSmallArrayGT); 27972 tcase_add_test(tc_core, pushSmallJsonSmallArrayGT); 27973 tcase_add_test(tc_core, pushSmallStringSmallArrayGT); 27974 tcase_add_test(tc_core, pushSmallContainerSmallArrayGT); 27975 tcase_add_test(tc_core, pushNFreeSmallArrayGT); 27976 tcase_add_test(tc_core, pushNFreeUndefinedSmallArrayGT); 27977 tcase_add_test(tc_core, pushNFreeSSmallArrayGT); 27978 tcase_add_test(tc_core, pushNFreeDictSmallArrayGT); 27979 tcase_add_test(tc_core, pushNFreeArraySmallArrayGT); 27980 tcase_add_test(tc_core, pushNFreeArraycSmallArrayGT); 27981 tcase_add_test(tc_core, pushNFreeSmallBoolSmallArrayGT); 27982 tcase_add_test(tc_core, pushNFreeSmallBytesSmallArrayGT); 27983 tcase_add_test(tc_core, pushNFreeSmallDoubleSmallArrayGT); 27984 tcase_add_test(tc_core, pushNFreeSmallIntSmallArrayGT); 27985 tcase_add_test(tc_core, pushNFreeSmallJsonSmallArrayGT); 27986 tcase_add_test(tc_core, pushNFreeSmallStringSmallArrayGT); 27987 tcase_add_test(tc_core, pushNFreeSmallContainerSmallArrayGT); 27988 tcase_add_test(tc_core, popSmallArrayGT); 27989 tcase_add_test(tc_core, popUndefinedSmallArrayGT); 27990 tcase_add_test(tc_core, popBoolSmallArrayGT); 27991 tcase_add_test(tc_core, popDoubleSmallArrayGT); 27992 tcase_add_test(tc_core, popIntSmallArrayGT); 27993 tcase_add_test(tc_core, popInt32SmallArrayGT); 27994 tcase_add_test(tc_core, popUintSmallArrayGT); 27995 tcase_add_test(tc_core, popUint32SmallArrayGT); 27996 tcase_add_test(tc_core, popSSmallArrayGT); 27997 tcase_add_test(tc_core, popDictSmallArrayGT); 27998 tcase_add_test(tc_core, popArraySmallArrayGT); 27999 tcase_add_test(tc_core, popSmallBoolSmallArrayGT); 28000 tcase_add_test(tc_core, popSmallBytesSmallArrayGT); 28001 tcase_add_test(tc_core, popSmallDoubleSmallArrayGT); 28002 tcase_add_test(tc_core, popSmallIntSmallArrayGT); 28003 tcase_add_test(tc_core, popSmallJsonSmallArrayGT); 28004 tcase_add_test(tc_core, popSmallStringSmallArrayGT); 28005 tcase_add_test(tc_core, popVoidSmallArrayGT); 28006 tcase_add_test(tc_core, popSmallContainerSmallArrayGT); 28007 tcase_add_test(tc_core, prependSmallArrayGT); 28008 tcase_add_test(tc_core, prependUndefinedSmallArrayGT); 28009 tcase_add_test(tc_core, prependBoolSmallArrayGT); 28010 tcase_add_test(tc_core, prependDoubleSmallArrayGT); 28011 tcase_add_test(tc_core, prependIntSmallArrayGT); 28012 tcase_add_test(tc_core, prependSSmallArrayGT); 28013 tcase_add_test(tc_core, prependCharSmallArrayGT); 28014 tcase_add_test(tc_core, prependDictSmallArrayGT); 28015 tcase_add_test(tc_core, prependArraySmallArrayGT); 28016 tcase_add_test(tc_core, prependArraycSmallArrayGT); 28017 tcase_add_test(tc_core, prependCArraycSmallArrayGT); 28018 tcase_add_test(tc_core, prependVoidSmallArrayGT); 28019 tcase_add_test(tc_core, prependSmallBoolSmallArrayGT); 28020 tcase_add_test(tc_core, prependSmallBytesSmallArrayGT); 28021 tcase_add_test(tc_core, prependSmallDoubleSmallArrayGT); 28022 tcase_add_test(tc_core, prependSmallIntSmallArrayGT); 28023 tcase_add_test(tc_core, prependSmallJsonSmallArrayGT); 28024 tcase_add_test(tc_core, prependSmallStringSmallArrayGT); 28025 tcase_add_test(tc_core, prependSmallContainerSmallArrayGT); 28026 tcase_add_test(tc_core, prependNFreeSmallArrayGT); 28027 tcase_add_test(tc_core, prependNFreeUndefinedSmallArrayGT); 28028 tcase_add_test(tc_core, prependNFreeSSmallArrayGT); 28029 tcase_add_test(tc_core, prependNFreeDictSmallArrayGT); 28030 tcase_add_test(tc_core, prependNFreeArraySmallArrayGT); 28031 tcase_add_test(tc_core, prependNFreeArraycSmallArrayGT); 28032 tcase_add_test(tc_core, prependNFreeSmallBoolSmallArrayGT); 28033 tcase_add_test(tc_core, prependNFreeSmallBytesSmallArrayGT); 28034 tcase_add_test(tc_core, prependNFreeSmallDoubleSmallArrayGT); 28035 tcase_add_test(tc_core, prependNFreeSmallIntSmallArrayGT); 28036 tcase_add_test(tc_core, prependNFreeSmallJsonSmallArrayGT); 28037 tcase_add_test(tc_core, prependNFreeSmallStringSmallArrayGT); 28038 tcase_add_test(tc_core, prependNFreeSmallContainerSmallArrayGT); 28039 tcase_add_test(tc_core, dequeueSmallArrayGT); 28040 tcase_add_test(tc_core, dequeueUndefinedSmallArrayGT); 28041 tcase_add_test(tc_core, dequeueBoolSmallArrayGT); 28042 tcase_add_test(tc_core, dequeueDoubleSmallArrayGT); 28043 tcase_add_test(tc_core, dequeueIntSmallArrayGT); 28044 tcase_add_test(tc_core, dequeueInt32SmallArrayGT); 28045 tcase_add_test(tc_core, dequeueUintSmallArrayGT); 28046 tcase_add_test(tc_core, dequeueUint32SmallArrayGT); 28047 tcase_add_test(tc_core, dequeueSSmallArrayGT); 28048 tcase_add_test(tc_core, dequeueDictSmallArrayGT); 28049 tcase_add_test(tc_core, dequeueArraySmallArrayGT); 28050 tcase_add_test(tc_core, dequeueSmallBoolSmallArrayGT); 28051 tcase_add_test(tc_core, dequeueSmallBytesSmallArrayGT); 28052 tcase_add_test(tc_core, dequeueSmallDoubleSmallArrayGT); 28053 tcase_add_test(tc_core, dequeueSmallIntSmallArrayGT); 28054 tcase_add_test(tc_core, dequeueSmallJsonSmallArrayGT); 28055 tcase_add_test(tc_core, dequeueSmallStringSmallArrayGT); 28056 tcase_add_test(tc_core, dequeueVoidSmallArrayGT); 28057 tcase_add_test(tc_core, dequeueSmallContainerSmallArrayGT); 28058 tcase_add_test(tc_core, getAtSmallArrayGT); 28059 tcase_add_test(tc_core, getAtUndefinedSmallArrayGT); 28060 tcase_add_test(tc_core, getAtBoolSmallArrayGT); 28061 tcase_add_test(tc_core, getAtBoolPSmallArrayGT); 28062 tcase_add_test(tc_core, getAtDoubleSmallArrayGT); 28063 tcase_add_test(tc_core, getAtDoublePSmallArrayGT); 28064 tcase_add_test(tc_core, getAtIntSmallArrayGT); 28065 tcase_add_test(tc_core, getAtIntPSmallArrayGT); 28066 tcase_add_test(tc_core, getAtInt32SmallArrayGT); 28067 tcase_add_test(tc_core, getAtInt32PSmallArrayGT); 28068 tcase_add_test(tc_core, getAtUintSmallArrayGT); 28069 tcase_add_test(tc_core, getAtUintPSmallArrayGT); 28070 tcase_add_test(tc_core, getAtUint32SmallArrayGT); 28071 tcase_add_test(tc_core, getAtUint32PSmallArrayGT); 28072 tcase_add_test(tc_core, getAtSSmallArrayGT); 28073 tcase_add_test(tc_core, getAtDictSmallArrayGT); 28074 tcase_add_test(tc_core, getAtArraySmallArrayGT); 28075 tcase_add_test(tc_core, getAtSmallBoolSmallArrayGT); 28076 tcase_add_test(tc_core, getAtSmallBytesSmallArrayGT); 28077 tcase_add_test(tc_core, getAtSmallDoubleSmallArrayGT); 28078 tcase_add_test(tc_core, getAtSmallIntSmallArrayGT); 28079 tcase_add_test(tc_core, getAtSmallJsonSmallArrayGT); 28080 tcase_add_test(tc_core, getAtSmallStringSmallArrayGT); 28081 tcase_add_test(tc_core, getAtVoidSmallArrayGT); 28082 tcase_add_test(tc_core, getAtSmallContainerSmallArrayGT); 28083 tcase_add_test(tc_core, getAtNDupSmallArrayGT); 28084 tcase_add_test(tc_core, getAtNDupUndefinedSmallArrayGT); 28085 tcase_add_test(tc_core, getAtNDupBoolSmallArrayGT); 28086 tcase_add_test(tc_core, getAtNDupDoubleSmallArrayGT); 28087 tcase_add_test(tc_core, getAtNDupIntSmallArrayGT); 28088 tcase_add_test(tc_core, getAtNDupInt32SmallArrayGT); 28089 tcase_add_test(tc_core, getAtNDupUintSmallArrayGT); 28090 tcase_add_test(tc_core, getAtNDupUint32SmallArrayGT); 28091 tcase_add_test(tc_core, getAtNDupSSmallArrayGT); 28092 tcase_add_test(tc_core, getAtNDupDictSmallArrayGT); 28093 tcase_add_test(tc_core, getAtNDupArraySmallArrayGT); 28094 tcase_add_test(tc_core, getAtNDupSmallBoolSmallArrayGT); 28095 tcase_add_test(tc_core, getAtNDupSmallBytesSmallArrayGT); 28096 tcase_add_test(tc_core, getAtNDupSmallDoubleSmallArrayGT); 28097 tcase_add_test(tc_core, getAtNDupSmallIntSmallArrayGT); 28098 tcase_add_test(tc_core, getAtNDupSmallJsonSmallArrayGT); 28099 tcase_add_test(tc_core, getAtNDupSmallStringSmallArrayGT); 28100 tcase_add_test(tc_core, getAtNDupVoidSmallArrayGT); 28101 tcase_add_test(tc_core, getAtNDupSmallContainerSmallArrayGT); 28102 tcase_add_test(tc_core, setAtSmallArrayGT); 28103 tcase_add_test(tc_core, setAtUndefinedSmallArrayGT); 28104 tcase_add_test(tc_core, setAtBoolSmallArrayGT); 28105 tcase_add_test(tc_core, setAtDoubleSmallArrayGT); 28106 tcase_add_test(tc_core, setAtIntSmallArrayGT); 28107 tcase_add_test(tc_core, setAtSSmallArrayGT); 28108 tcase_add_test(tc_core, setAtCharSmallArrayGT); 28109 tcase_add_test(tc_core, setAtDictSmallArrayGT); 28110 tcase_add_test(tc_core, setAtArraySmallArrayGT); 28111 tcase_add_test(tc_core, setAtArraycSmallArrayGT); 28112 tcase_add_test(tc_core, setAtCArraycSmallArrayGT); 28113 tcase_add_test(tc_core, setAtVoidSmallArrayGT); 28114 tcase_add_test(tc_core, setAtSmallBoolSmallArrayGT); 28115 tcase_add_test(tc_core, setAtSmallBytesSmallArrayGT); 28116 tcase_add_test(tc_core, setAtSmallDoubleSmallArrayGT); 28117 tcase_add_test(tc_core, setAtSmallIntSmallArrayGT); 28118 tcase_add_test(tc_core, setAtSmallJsonSmallArrayGT); 28119 tcase_add_test(tc_core, setAtSmallStringSmallArrayGT); 28120 tcase_add_test(tc_core, setAtSmallContainerSmallArrayGT); 28121 tcase_add_test(tc_core, setAtNFreeSmallArrayGT); 28122 tcase_add_test(tc_core, setAtNFreeUndefinedSmallArrayGT); 28123 tcase_add_test(tc_core, setAtNFreeSSmallArrayGT); 28124 tcase_add_test(tc_core, setAtNFreeDictSmallArrayGT); 28125 tcase_add_test(tc_core, setAtNFreeArraySmallArrayGT); 28126 tcase_add_test(tc_core, setAtNFreeArraycSmallArrayGT); 28127 tcase_add_test(tc_core, setAtNFreeSmallBoolSmallArrayGT); 28128 tcase_add_test(tc_core, setAtNFreeSmallBytesSmallArrayGT); 28129 tcase_add_test(tc_core, setAtNFreeSmallDoubleSmallArrayGT); 28130 tcase_add_test(tc_core, setAtNFreeSmallIntSmallArrayGT); 28131 tcase_add_test(tc_core, setAtNFreeSmallJsonSmallArrayGT); 28132 tcase_add_test(tc_core, setAtNFreeSmallStringSmallArrayGT); 28133 tcase_add_test(tc_core, setAtNFreeSmallContainerSmallArrayGT); 28134 tcase_add_test(tc_core, setPAtDictSmallArrayGT); 28135 tcase_add_test(tc_core, setPAtArraySmallArrayGT); 28136 tcase_add_test(tc_core, setPAtSmallJsonSmallArrayGT); 28137 tcase_add_test(tc_core, setPAtSmallStringSmallArrayGT); 28138 tcase_add_test(tc_core, setPAtNFreeDictSmallArrayGT); 28139 tcase_add_test(tc_core, setPAtNFreeArraySmallArrayGT); 28140 tcase_add_test(tc_core, setPAtNFreeSmallJsonSmallArrayGT); 28141 tcase_add_test(tc_core, setPAtNFreeSmallStringSmallArrayGT); 28142 tcase_add_test(tc_core, getNumSmallArrayGT); 28143 tcase_add_test(tc_core, reverseSmallArrayGT); 28144 tcase_add_test(tc_core, appendSmallArrayGT); 28145 tcase_add_test(tc_core, appendSmallJsonSmallArrayGT); 28146 tcase_add_test(tc_core, appendNSmashSmallArrayGT); 28147 tcase_add_test(tc_core, appendNSmashSmallJsonSmallArrayGT); 28148 tcase_add_test(tc_core, appendArraySmallArrayGT); 28149 tcase_add_test(tc_core, appendNSmashArraySmallArrayGT); 28150 tcase_add_test(tc_core, appendCArraySmallArrayGT); 28151 tcase_add_test(tc_core, shiftSmallArrayGT); 28152 tcase_add_test(tc_core, shiftSmallJsonSmallArrayGT); 28153 tcase_add_test(tc_core, shiftNSmashSmallArrayGT); 28154 tcase_add_test(tc_core, shiftNSmashSmallJsonSmallArrayGT); 28155 tcase_add_test(tc_core, addSmallArrayGT); 28156 tcase_add_test(tc_core, sliceSmallArrayGT); 28157 tcase_add_test(tc_core, cropSmallArrayGT); 28158 tcase_add_test(tc_core, cropElemSmallArrayGT); 28159 tcase_add_test(tc_core, cropElemUndefinedSmallArrayGT); 28160 tcase_add_test(tc_core, cropElemBoolSmallArrayGT); 28161 tcase_add_test(tc_core, cropElemDoubleSmallArrayGT); 28162 tcase_add_test(tc_core, cropElemIntSmallArrayGT); 28163 tcase_add_test(tc_core, cropElemInt32SmallArrayGT); 28164 tcase_add_test(tc_core, cropElemUintSmallArrayGT); 28165 tcase_add_test(tc_core, cropElemUint32SmallArrayGT); 28166 tcase_add_test(tc_core, cropElemSSmallArrayGT); 28167 tcase_add_test(tc_core, cropElemDictSmallArrayGT); 28168 tcase_add_test(tc_core, cropElemArraySmallArrayGT); 28169 tcase_add_test(tc_core, cropElemSmallBoolSmallArrayGT); 28170 tcase_add_test(tc_core, cropElemSmallBytesSmallArrayGT); 28171 tcase_add_test(tc_core, cropElemSmallDoubleSmallArrayGT); 28172 tcase_add_test(tc_core, cropElemSmallIntSmallArrayGT); 28173 tcase_add_test(tc_core, cropElemSmallJsonSmallArrayGT); 28174 tcase_add_test(tc_core, cropElemSmallStringSmallArrayGT); 28175 tcase_add_test(tc_core, cropElemVoidSmallArrayGT); 28176 tcase_add_test(tc_core, cropElemSmallContainerSmallArrayGT); 28177 tcase_add_test(tc_core, copySmallArrayGT); 28178 tcase_add_test(tc_core, insertSmallArrayGT); 28179 tcase_add_test(tc_core, insertSmallJsonSmallArrayGT); 28180 tcase_add_test(tc_core, insertNSmashSmallArrayGT); 28181 tcase_add_test(tc_core, insertNSmashSmallJsonSmallArrayGT); 28182 tcase_add_test(tc_core, injectSmallArrayGT); 28183 tcase_add_test(tc_core, injectUndefinedSmallArrayGT); 28184 tcase_add_test(tc_core, injectBoolSmallArrayGT); 28185 tcase_add_test(tc_core, injectDoubleSmallArrayGT); 28186 tcase_add_test(tc_core, injectIntSmallArrayGT); 28187 tcase_add_test(tc_core, injectSSmallArrayGT); 28188 tcase_add_test(tc_core, injectCharSmallArrayGT); 28189 tcase_add_test(tc_core, injectDictSmallArrayGT); 28190 tcase_add_test(tc_core, injectArraySmallArrayGT); 28191 tcase_add_test(tc_core, injectArraycSmallArrayGT); 28192 tcase_add_test(tc_core, injectCArraycSmallArrayGT); 28193 tcase_add_test(tc_core, injectVoidSmallArrayGT); 28194 tcase_add_test(tc_core, injectSmallBoolSmallArrayGT); 28195 tcase_add_test(tc_core, injectSmallBytesSmallArrayGT); 28196 tcase_add_test(tc_core, injectSmallDoubleSmallArrayGT); 28197 tcase_add_test(tc_core, injectSmallIntSmallArrayGT); 28198 tcase_add_test(tc_core, injectSmallJsonSmallArrayGT); 28199 tcase_add_test(tc_core, injectSmallStringSmallArrayGT); 28200 tcase_add_test(tc_core, injectSmallContainerSmallArrayGT); 28201 tcase_add_test(tc_core, injectNFreeSmallArrayGT); 28202 tcase_add_test(tc_core, injectNFreeUndefinedSmallArrayGT); 28203 tcase_add_test(tc_core, injectNFreeSSmallArrayGT); 28204 tcase_add_test(tc_core, injectNFreeDictSmallArrayGT); 28205 tcase_add_test(tc_core, injectNFreeArraySmallArrayGT); 28206 tcase_add_test(tc_core, injectNFreeArraycSmallArrayGT); 28207 tcase_add_test(tc_core, injectNFreeSmallBoolSmallArrayGT); 28208 tcase_add_test(tc_core, injectNFreeSmallBytesSmallArrayGT); 28209 tcase_add_test(tc_core, injectNFreeSmallDoubleSmallArrayGT); 28210 tcase_add_test(tc_core, injectNFreeSmallIntSmallArrayGT); 28211 tcase_add_test(tc_core, injectNFreeSmallJsonSmallArrayGT); 28212 tcase_add_test(tc_core, injectNFreeSmallStringSmallArrayGT); 28213 tcase_add_test(tc_core, injectNFreeSmallContainerSmallArrayGT); 28214 tcase_add_test(tc_core, delSmallArrayGT); 28215 tcase_add_test(tc_core, delElemSmallArrayGT); 28216 tcase_add_test(tc_core, removeSmallArrayGT); 28217 tcase_add_test(tc_core, removeElemSmallArrayGT); 28218 tcase_add_test(tc_core, sortSmallArrayGT); 28219 tcase_add_test(tc_core, sortFSmallArrayGT); 28220 tcase_add_test(tc_core, icSortSmallArrayGT); 28221 tcase_add_test(tc_core, equalSmallArrayGT); 28222 tcase_add_test(tc_core, equalSmallArraySmallJsonGT); 28223 tcase_add_test(tc_core, equalSmallArrayArrayGT); 28224 tcase_add_test(tc_core, equalSmallArrayCArrayGT); 28225 tcase_add_test(tc_core, equalSmallArrayBaseGT); 28226 tcase_add_test(tc_core, icEqualSmallArrayGT); 28227 tcase_add_test(tc_core, icEqualSmallArraySmallJsonGT); 28228 tcase_add_test(tc_core, icEqualSmallArrayArrayGT); 28229 tcase_add_test(tc_core, icEqualSmallArrayCArrayGT); 28230 tcase_add_test(tc_core, icEqualSmallArrayBaseGT); 28231 tcase_add_test(tc_core, lenSmallArrayGT); 28232 tcase_add_test(tc_core, trimSmallArrayGT); 28233 tcase_add_test(tc_core, hasSmallArrayGT); 28234 tcase_add_test(tc_core, hasUndefinedSmallArrayGT); 28235 tcase_add_test(tc_core, hasBoolSmallArrayGT); 28236 tcase_add_test(tc_core, hasDoubleSmallArrayGT); 28237 tcase_add_test(tc_core, hasIntSmallArrayGT); 28238 tcase_add_test(tc_core, hasSSmallArrayGT); 28239 tcase_add_test(tc_core, hasCharSmallArrayGT); 28240 tcase_add_test(tc_core, hasDictSmallArrayGT); 28241 tcase_add_test(tc_core, hasArraySmallArrayGT); 28242 tcase_add_test(tc_core, hasArraycSmallArrayGT); 28243 tcase_add_test(tc_core, hasCArraycSmallArrayGT); 28244 tcase_add_test(tc_core, hasSmallBoolSmallArrayGT); 28245 tcase_add_test(tc_core, hasSmallBytesSmallArrayGT); 28246 tcase_add_test(tc_core, hasSmallDoubleSmallArrayGT); 28247 tcase_add_test(tc_core, hasSmallIntSmallArrayGT); 28248 tcase_add_test(tc_core, hasSmallJsonSmallArrayGT); 28249 tcase_add_test(tc_core, hasSmallStringSmallArrayGT); 28250 tcase_add_test(tc_core, hasSmallContainerSmallArrayGT); 28251 tcase_add_test(tc_core, indexOfSmallArrayGT); 28252 tcase_add_test(tc_core, indexOfUndefinedSmallArrayGT); 28253 tcase_add_test(tc_core, indexOfBoolSmallArrayGT); 28254 tcase_add_test(tc_core, indexOfDoubleSmallArrayGT); 28255 tcase_add_test(tc_core, indexOfIntSmallArrayGT); 28256 tcase_add_test(tc_core, indexOfSSmallArrayGT); 28257 tcase_add_test(tc_core, indexOfCharSmallArrayGT); 28258 tcase_add_test(tc_core, indexOfDictSmallArrayGT); 28259 tcase_add_test(tc_core, indexOfArraySmallArrayGT); 28260 tcase_add_test(tc_core, indexOfArraycSmallArrayGT); 28261 tcase_add_test(tc_core, indexOfCArraycSmallArrayGT); 28262 tcase_add_test(tc_core, indexOfSmallBoolSmallArrayGT); 28263 tcase_add_test(tc_core, indexOfSmallBytesSmallArrayGT); 28264 tcase_add_test(tc_core, indexOfSmallDoubleSmallArrayGT); 28265 tcase_add_test(tc_core, indexOfSmallIntSmallArrayGT); 28266 tcase_add_test(tc_core, indexOfSmallJsonSmallArrayGT); 28267 tcase_add_test(tc_core, indexOfSmallStringSmallArrayGT); 28268 tcase_add_test(tc_core, indexOfSmallContainerSmallArrayGT); 28269 tcase_add_test(tc_core, binarySearchSmallArrayGT); 28270 tcase_add_test(tc_core, binarySearchUndefinedSmallArrayGT); 28271 tcase_add_test(tc_core, binarySearchBoolSmallArrayGT); 28272 tcase_add_test(tc_core, binarySearchDoubleSmallArrayGT); 28273 tcase_add_test(tc_core, binarySearchIntSmallArrayGT); 28274 tcase_add_test(tc_core, binarySearchSSmallArrayGT); 28275 tcase_add_test(tc_core, binarySearchCharSmallArrayGT); 28276 tcase_add_test(tc_core, binarySearchDictSmallArrayGT); 28277 tcase_add_test(tc_core, binarySearchArraySmallArrayGT); 28278 tcase_add_test(tc_core, binarySearchArraycSmallArrayGT); 28279 tcase_add_test(tc_core, binarySearchCArraycSmallArrayGT); 28280 tcase_add_test(tc_core, binarySearchSmallBoolSmallArrayGT); 28281 tcase_add_test(tc_core, binarySearchSmallBytesSmallArrayGT); 28282 tcase_add_test(tc_core, binarySearchSmallDoubleSmallArrayGT); 28283 tcase_add_test(tc_core, binarySearchSmallIntSmallArrayGT); 28284 tcase_add_test(tc_core, binarySearchSmallJsonSmallArrayGT); 28285 tcase_add_test(tc_core, binarySearchSmallStringSmallArrayGT); 28286 tcase_add_test(tc_core, binarySearchSmallContainerSmallArrayGT); 28287 tcase_add_test(tc_core, uniqSmallArrayGT); 28288 tcase_add_test(tc_core, icHasSmallArrayGT); 28289 tcase_add_test(tc_core, icHasSSmallArrayGT); 28290 tcase_add_test(tc_core, icHasCharSmallArrayGT); 28291 tcase_add_test(tc_core, icHasDictSmallArrayGT); 28292 tcase_add_test(tc_core, icHasArraySmallArrayGT); 28293 tcase_add_test(tc_core, icHasArraycSmallArrayGT); 28294 tcase_add_test(tc_core, icHasCArraycSmallArrayGT); 28295 tcase_add_test(tc_core, icHasSmallJsonSmallArrayGT); 28296 tcase_add_test(tc_core, icHasSmallStringSmallArrayGT); 28297 tcase_add_test(tc_core, icIndexOfSmallArrayGT); 28298 tcase_add_test(tc_core, icIndexOfSSmallArrayGT); 28299 tcase_add_test(tc_core, icIndexOfCharSmallArrayGT); 28300 tcase_add_test(tc_core, icIndexOfDictSmallArrayGT); 28301 tcase_add_test(tc_core, icIndexOfArraySmallArrayGT); 28302 tcase_add_test(tc_core, icIndexOfArraycSmallArrayGT); 28303 tcase_add_test(tc_core, icIndexOfCArraycSmallArrayGT); 28304 tcase_add_test(tc_core, icIndexOfSmallJsonSmallArrayGT); 28305 tcase_add_test(tc_core, icIndexOfSmallStringSmallArrayGT); 28306 tcase_add_test(tc_core, icBinarySearchSmallArrayGT); 28307 tcase_add_test(tc_core, icBinarySearchSSmallArrayGT); 28308 tcase_add_test(tc_core, icBinarySearchCharSmallArrayGT); 28309 tcase_add_test(tc_core, icBinarySearchDictSmallArrayGT); 28310 tcase_add_test(tc_core, icBinarySearchArraySmallArrayGT); 28311 tcase_add_test(tc_core, icBinarySearchArraycSmallArrayGT); 28312 tcase_add_test(tc_core, icBinarySearchCArraycSmallArrayGT); 28313 tcase_add_test(tc_core, icBinarySearchSmallJsonSmallArrayGT); 28314 tcase_add_test(tc_core, icBinarySearchSmallStringSmallArrayGT); 28315 tcase_add_test(tc_core, icUniqSmallArrayGT); 28316 tcase_add_test(tc_core, compactSmallArrayGT); 28317 tcase_add_test(tc_core, emptySmallArrayGT); 28318 tcase_add_test(tc_core, isEmptySmallArrayGT); 28319 tcase_add_test(tc_core, isBlankSmallArrayGT); 28320 tcase_add_test(tc_core, joinSmallArrayGT); 28321 tcase_add_test(tc_core, joinCharSmallArrayGT); 28322 tcase_add_test(tc_core, joinSmallJsonSmallArrayGT); 28323 tcase_add_test(tc_core, joinSmallStringSmallArrayGT); 28324 tcase_add_test(tc_core, joinSSmallArrayGT); 28325 tcase_add_test(tc_core, joinCharSSmallArrayGT); 28326 tcase_add_test(tc_core, joinSmallJsonSSmallArrayGT); 28327 tcase_add_test(tc_core, joinSmallStringSSmallArrayGT); 28328 tcase_add_test(tc_core, zipSmallArrayGT); 28329 tcase_add_test(tc_core, zipSmallJsonSmallArrayGT); 28330 tcase_add_test(tc_core, zipSmallJsonSmallArraySmallArrayGT); 28331 tcase_add_test(tc_core, zipSmallJsonSmallJsonSmallArrayGT); 28332 tcase_add_test(tc_core, zipSmallJsonCharSmallArrayGT); 28333 tcase_add_test(tc_core, zipSmallJsonCCharSmallArrayGT); 28334 tcase_add_test(tc_core, zipArraySmallArrayGT); 28335 tcase_add_test(tc_core, zipCArraySmallArrayGT); 28336 tcase_add_test(tc_core, zipArraySmallJsonSmallArrayGT); 28337 tcase_add_test(tc_core, zipCArraySmallJsonSmallArrayGT); 28338 tcase_add_test(tc_core, zipCharSmallArrayGT); 28339 tcase_add_test(tc_core, zipCCharSmallArrayGT); 28340 tcase_add_test(tc_core, zipArrayCharSmallArrayGT); 28341 tcase_add_test(tc_core, zipArrayCCharSmallArrayGT); 28342 tcase_add_test(tc_core, zipCArrayCharSmallArrayGT); 28343 tcase_add_test(tc_core, zipCArrayCCharSmallArrayGT); 28344 tcase_add_test(tc_core, logSmallArrayGT); 28345 tcase_add_test(tc_core, readTextSmallArrayGT); 28346 tcase_add_test(tc_core, readTextSmallJsonSmallArrayGT); 28347 tcase_add_test(tc_core, readTextSmallStringSmallArrayGT); 28348 tcase_add_test(tc_core, readStreamSmallArrayGT); 28349 tcase_add_test(tc_core, writeTextSmallArrayGT); 28350 tcase_add_test(tc_core, writeTextSmallJsonSmallArrayGT); 28351 tcase_add_test(tc_core, writeTextSmallStringSmallArrayGT); 28352 tcase_add_test(tc_core, writeStreamSmallArrayGT); 28353 tcase_add_test(tc_core, appendTextSmallArrayGT); 28354 tcase_add_test(tc_core, appendTextSmallStringSmallArrayGT); 28355 tcase_add_test(tc_core, typeSmallStringSmallArrayGT); 28356 tcase_add_test(tc_core, typeSmallStringsSmallArrayGT); 28357 tcase_add_test(tc_core, cSmallArrayT); 28358 28359 suite_add_tcase(s, tc_core); 28360 28361 return s; 28362 } 28363 28364 int main(int ARGC UNUSED, char** ARGV UNUSED) { 28365 int number_failed; 28366 Suite *s; 28367 SRunner *sr; 28368 28369 s = libsheepySuite(); 28370 sr = srunner_create(s); 28371 28372 srunner_run_all(sr, CK_NORMAL); 28373 number_failed = srunner_ntests_failed(sr); 28374 srunner_free(sr); 28375 28376 exit((number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE); 28377 } 28378 // vim: set expandtab ts=2 sw=2: