libsheepyCSmallArrayTestMem.c (693352B)
1 #include <stdlib.h> 2 #include <stdio.h> 3 #include <string.h> 4 5 #define ck_assert_str_eq(a,b) a;b; 6 #define ck_assert_str_ne(a,b) a;b; 7 #define ck_assert_ptr_eq(a,b) a;b; 8 #define ck_assert_ptr_ne(a,b) a;b; 9 #define ck_assert_uint_eq(a,b) a;b; 10 #define ck_assert_uint_ne(a,b) a;b; 11 #define ck_assert_int_eq(a,b) a;b; 12 #define ck_assert_int_ne(a,b) a;b; 13 #define ck_assert(a) a; 14 15 16 #include "../libsheepy.h" 17 #include "../libsheepyObject.h" 18 19 #ifdef __GNUC__ 20 #define UNUSED __attribute__ ((unused)) 21 #else 22 #define UNUSED 23 #endif 24 25 // TODO redirect stderr 26 27 28 void allocArraySmallArrayT(void) { 29 30 smallArrayt* r; 31 char *array[] = {"a", "bb", NULL}; 32 33 r = allocArraySmallArray(array); 34 ck_assert_ptr_ne(r, NULL); 35 char *s = toStringO(r); 36 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 37 free(s); 38 39 terminateO(r); 40 41 } 42 43 44 void allocCArraySmallArrayT(void) { 45 46 smallArrayt* r; 47 const char *array[] = {"a", "bb", NULL}; 48 49 r = allocCArraySmallArray(array); 50 ck_assert_ptr_ne(r, NULL); 51 char *s = toStringO(r); 52 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 53 free(s); 54 55 terminateO(r); 56 57 } 58 59 60 void createSAFT(void) { 61 62 smallArrayt* r; 63 64 r = createSA("a", "bb"); 65 ck_assert_ptr_ne(r, NULL); 66 char *s = toStringO(r); 67 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 68 free(s); 69 70 terminateO(r); 71 72 73 } 74 75 76 void getsoSmallArrayT(void) { 77 78 sArrayt* r; 79 smallArrayt *self = allocG(rtSmallArrayt); 80 81 pushG(self, 1); 82 r = getsoO(self); 83 ck_assert_ptr_eq(r, self->a); 84 terminateO(self); 85 86 } 87 88 89 void setsoSmallArrayT(void) { 90 91 smallArrayt *self = allocG(rtSmallArrayt); 92 sArrayt *so; 93 94 createSmallArray(a); 95 96 pushG(&a, 1); 97 pushG(&a, 2); 98 99 char *as = null; 100 // reset test: free iterElement in a 101 iter(&a, E) { 102 as = toStringO(E); 103 break; 104 } 105 ck_assert_str_eq(as, "1"); 106 free(as); 107 108 so = getsoO(&a); 109 resetO(&a); 110 111 setsoO(self, so); 112 ck_assert_ptr_eq(so, self->a); 113 terminateO(self); 114 115 } 116 117 118 void mirrorSmallArrayT(void) { 119 120 smallArrayt* r; 121 smallArrayt *self = allocG(rtSmallArrayt); 122 123 // empty self 124 r = mirrorO(self); 125 ck_assert_ptr_eq(r->a, null); 126 finishO(r); 127 128 // non empty with iterator 129 pushG(self, 1); 130 pushG(self, 2); 131 char *as = null; 132 iter(self, E) { 133 as = toStringO(E); 134 break; 135 } 136 ck_assert_str_eq(as, "1"); 137 free(as); 138 r = mirrorO(self); 139 ck_assert_ptr_eq(r->a, self->a); 140 finishO(r); 141 142 terminateO(self); 143 144 } 145 146 147 void fromArrayNFreeSmallArrayT(void) { 148 149 smallArrayt* r; 150 smallArrayt *self = allocG(rtSmallArrayt); 151 char **array; 152 size_t size = 3; 153 154 // libsheepy list 155 array = listCreateS("a", "bb", "ccc"); 156 r = fromArrayNFreeO(self, array, 0); 157 ck_assert_ptr_eq(self, r); 158 char *s = toStringO(r); 159 ck_assert_str_eq(s, "[\"a\",\"bb\",\"ccc\"]"); 160 free(s); 161 162 // array with strings 163 array = allocArray(array, size); 164 array[0] = strdup("a1"); 165 array[1] = strdup("bb1"); 166 array[2] = strdup("ccc1"); 167 r = fromArrayNFreeO(self, array, size); 168 ck_assert_ptr_eq(self, r); 169 s = toStringO(r); 170 ck_assert_str_eq(s, "[\"a1\",\"bb1\",\"ccc1\"]"); 171 free(s); 172 173 // NULL array 174 r = fromArrayNFreeO(self, null, 1); 175 ck_assert_ptr_eq(r, null); 176 terminateO(self); 177 178 } 179 180 181 void pushUndefinedSmallArrayT(void) { 182 183 smallArrayt* r; 184 smallArrayt *self = allocG(rtSmallArrayt); 185 186 // add an element to check that push adds the second element 187 // at the end 188 r = self->f->pushInt(self, 1); 189 ck_assert_ptr_ne(r, null); 190 191 r = self->f->pushUndefined(self); 192 ck_assert_ptr_ne(r, null); 193 ck_assert_int_eq(lenO(r), 2); 194 char *s = toStringO(r); 195 ck_assert_str_eq(s, "[1,null]"); 196 free(s); 197 terminateO(self); 198 199 } 200 201 202 void pushBoolSmallArrayT(void) { 203 204 smallArrayt* r; 205 smallArrayt *self = allocG(rtSmallArrayt); 206 207 // add an element to check that push adds the second element 208 // at the end 209 r = self->f->pushInt(self, 1); 210 ck_assert_ptr_ne(r, null); 211 212 r = self->f->pushBool(self, TRUE); 213 ck_assert_ptr_ne(r, null); 214 ck_assert_int_eq(lenO(r), 2); 215 char *s = toStringO(r); 216 ck_assert_str_eq(s, "[1,true]"); 217 free(s); 218 terminateO(self); 219 220 } 221 222 223 void pushDoubleSmallArrayT(void) { 224 225 smallArrayt* r; 226 smallArrayt *self = allocG(rtSmallArrayt); 227 228 // add an element to check that push adds the second element 229 // at the end 230 r = self->f->pushInt(self, 1); 231 ck_assert_ptr_ne(r, null); 232 233 r = self->f->pushDouble(self, 1.0); 234 ck_assert_ptr_ne(r, null); 235 ck_assert_int_eq(lenO(r), 2); 236 char *s = toStringO(r); 237 ck_assert_str_eq(s, "[1,1.000000e+00]"); 238 free(s); 239 terminateO(self); 240 241 } 242 243 244 void pushIntSmallArrayT(void) { 245 246 smallArrayt* r; 247 smallArrayt *self = allocG(rtSmallArrayt); 248 249 // add an element to check that push adds the second element 250 // at the end 251 r = self->f->pushInt(self, 1); 252 ck_assert_ptr_ne(r, null); 253 254 r = self->f->pushInt(self, 1); 255 ck_assert_ptr_ne(r, null); 256 ck_assert_int_eq(lenO(r), 2); 257 char *s = toStringO(r); 258 ck_assert_str_eq(s, "[1,1]"); 259 free(s); 260 terminateO(self); 261 262 } 263 264 265 void pushSSmallArrayT(void) { 266 267 smallArrayt* r; 268 smallArrayt *self = allocG(rtSmallArrayt); 269 270 // add an element to check that push adds the second element 271 // at the end 272 r = self->f->pushInt(self, 1); 273 ck_assert_ptr_ne(r, null); 274 275 r = self->f->pushS(self, null); 276 ck_assert_ptr_eq(r, null); 277 ck_assert_int_eq(lenO(self), 1); 278 char *s = toStringO(self); 279 ck_assert_str_eq(s, "[1]"); 280 free(s); 281 282 char *str = "poi"; 283 r = self->f->pushS(self, str); 284 ck_assert_ptr_ne(r, null); 285 ck_assert_int_eq(lenO(self), 2); 286 s = toStringO(r); 287 ck_assert_str_eq(s, "[1,\"poi\"]"); 288 free(s); 289 290 terminateO(self); 291 292 } 293 294 295 void pushCharSmallArrayT(void) { 296 297 smallArrayt* r; 298 smallArrayt *self = allocG(rtSmallArrayt); 299 300 // add an element to check that push adds the second element 301 // at the end 302 r = self->f->pushInt(self, 1); 303 ck_assert_ptr_ne(r, null); 304 305 r = self->f->pushChar(self, 'a'); 306 ck_assert_ptr_ne(r, null); 307 ck_assert_int_eq(lenO(r), 2); 308 char *s = toStringO(r); 309 ck_assert_str_eq(s, "[1,\"a\"]"); 310 free(s); 311 terminateO(self); 312 313 } 314 315 316 void pushDictSmallArrayT(void) { 317 318 smallArrayt* r; 319 smallArrayt *self = allocG(rtSmallArrayt); 320 smallDictt *dict = allocG(rtSmallDictt); 321 322 // add an element to check that push adds the second element 323 // at the end 324 r = self->f->pushInt(self, 1); 325 ck_assert_ptr_ne(r, null); 326 327 // push dict 328 r = self->f->pushDict(self, dict); 329 ck_assert_ptr_ne(r, null); 330 ck_assert_int_eq(lenO(r), 2); 331 finishO(dict); 332 ck_assert_ptr_ne(r, null); 333 char *s = toStringO(r); 334 ck_assert_str_eq(s, "[1,{}]"); 335 free(s); 336 // non smallDict object 337 dict = (smallDictt*) allocSmallInt(2); 338 r = self->f->pushDict(self, dict); 339 ck_assert_ptr_eq(r, null); 340 terminateO(dict); 341 // null 342 r = self->f->pushDict(self, null); 343 ck_assert_ptr_eq(r, null); 344 ck_assert_int_eq(lenO(self), 2); 345 s = toStringO(self); 346 ck_assert_str_eq(s, "[1,{}]"); 347 free(s); 348 terminateO(self); 349 350 } 351 352 353 void pushArraySmallArrayT(void) { 354 355 smallArrayt* r; 356 smallArrayt *self = allocG(rtSmallArrayt); 357 smallArrayt *array = allocG(rtSmallArrayt); 358 359 // add an element to check that push adds the second element 360 // at the end 361 r = self->f->pushInt(self, 1); 362 ck_assert_ptr_ne(r, null); 363 364 r = self->f->pushArray(self, array); 365 ck_assert_ptr_ne(r, null); 366 ck_assert_int_eq(lenO(r), 2); 367 finishO(array); 368 char *s = toStringO(r); 369 ck_assert_str_eq(s, "[1,[]]"); 370 free(s); 371 // non smallArray object 372 array = (smallArrayt*) allocSmallInt(2); 373 r = self->f->pushArray(self, array); 374 ck_assert_ptr_eq(r, null); 375 terminateO(array); 376 // null 377 r = self->f->pushArray(self, null); 378 ck_assert_ptr_eq(r, null); 379 ck_assert_int_eq(lenO(self), 2); 380 s = toStringO(self); 381 ck_assert_str_eq(s, "[1,[]]"); 382 free(s); 383 terminateO(self); 384 385 } 386 387 388 void pushArraycSmallArrayT(void) { 389 390 smallArrayt* r; 391 smallArrayt *self = allocG(rtSmallArrayt); 392 char **array = listCreateS("a","bb"); 393 394 // add an element to check that push adds the second element 395 // at the end 396 r = self->f->pushInt(self, 1); 397 ck_assert_ptr_ne(r, null); 398 399 r = self->f->pushArrayc(self, array); 400 ck_assert_ptr_ne(r, null); 401 ck_assert_int_eq(lenO(r), 2); 402 listFreeS(array); 403 char *s = toStringO(r); 404 ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]"); 405 free(s); 406 // null 407 r = self->f->pushArrayc(self, null); 408 ck_assert_ptr_eq(r, null); 409 ck_assert_int_eq(lenO(self), 2); 410 s = toStringO(self); 411 ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]"); 412 free(s); 413 terminateO(self); 414 415 } 416 417 418 void pushSmallBoolSmallArrayT(void) { 419 420 smallArrayt* r; 421 smallArrayt *self = allocG(rtSmallArrayt); 422 smallBoolt *value = allocG(TRUE); 423 424 // add an element to check that push adds the second element 425 // at the end 426 r = self->f->pushInt(self, 1); 427 ck_assert_ptr_ne(r, null); 428 429 r = self->f->pushSmallBool(self, value); 430 ck_assert_ptr_ne(r, null); 431 ck_assert_int_eq(lenO(r), 2); 432 finishO(value); 433 char *s = toStringO(r); 434 ck_assert_str_eq(s, "[1,true]"); 435 free(s); 436 // non smallBool object 437 value = (smallBoolt*) allocSmallInt(2); 438 r = self->f->pushSmallBool(self, value); 439 ck_assert_ptr_eq(r, null); 440 terminateO(value); 441 // bool object with no data 442 createAllocateSmallBool(b); 443 r = self->f->pushSmallBool(self, b); 444 ck_assert_ptr_ne(r, null); 445 ck_assert_int_eq(lenO(r), 3); 446 finishO(b); 447 s = toStringO(r); 448 ck_assert_str_eq(s, "[1,true,false]"); 449 free(s); 450 // null 451 r = self->f->pushSmallBool(self, null); 452 ck_assert_ptr_eq(r, null); 453 ck_assert_int_eq(lenO(self), 3); 454 s = toStringO(self); 455 ck_assert_str_eq(s, "[1,true,false]"); 456 free(s); 457 terminateO(self); 458 459 } 460 461 462 void pushSmallBytesSmallArrayT(void) { 463 464 smallArrayt* r; 465 smallArrayt *self = allocG(rtSmallArrayt); 466 createAllocateSmallBytes(value); 467 468 // add an element to check that push adds the second element 469 // at the end 470 r = self->f->pushInt(self, 1); 471 ck_assert_ptr_ne(r, null); 472 // the smallBytes container is empty 473 r = self->f->pushSmallBytes(self, value); 474 ck_assert_ptr_ne(r, null); 475 ck_assert_int_eq(lenO(r), 2); 476 char *s = toStringO(r); 477 ck_assert_str_eq(s, "[1,[]]"); 478 free(s); 479 // reuse value 480 value->B = null; 481 char *buffer = "poi"; 482 pushBufferO(value, buffer, strlen(buffer)); 483 r = self->f->pushSmallBytes(self, value); 484 finishO(value); 485 ck_assert_ptr_ne(r, null); 486 ck_assert_int_eq(lenO(r), 3); 487 s = toStringO(r); 488 ck_assert_str_eq(s, "[1,[],[0x70,0x6f,0x69]]"); 489 free(s); 490 // non smallBytes object 491 value = (smallBytest*) allocSmallInt(2); 492 r = self->f->pushSmallBytes(self, value); 493 ck_assert_ptr_eq(r, null); 494 terminateO(value); 495 // null 496 r = self->f->pushSmallBytes(self, null); 497 ck_assert_ptr_eq(r, null); 498 ck_assert_int_eq(lenO(self), 3); 499 s = toStringO(self); 500 ck_assert_str_eq(s, "[1,[],[0x70,0x6f,0x69]]"); 501 free(s); 502 terminateO(self); 503 504 } 505 506 507 void pushSmallDoubleSmallArrayT(void) { 508 509 smallArrayt* r; 510 smallArrayt *self = allocG(rtSmallArrayt); 511 smallDoublet *value = allocG(1.0); 512 513 // add an element to check that push adds the second element 514 // at the end 515 r = self->f->pushInt(self, 1); 516 ck_assert_ptr_ne(r, null); 517 518 r = self->f->pushSmallDouble(self, value); 519 ck_assert_ptr_ne(r, null); 520 ck_assert_int_eq(lenO(r), 2); 521 finishO(value); 522 char *s = toStringO(r); 523 ck_assert_str_eq(s, "[1,1.000000e+00]"); 524 free(s); 525 // object with no data 526 createAllocateSmallDouble(b); 527 r = self->f->pushSmallDouble(self, b); 528 ck_assert_ptr_ne(r, null); 529 ck_assert_int_eq(lenO(r), 3); 530 finishO(b); 531 s = toStringO(r); 532 ck_assert_str_eq(s, "[1,1.000000e+00,0.000000e+00]"); 533 free(s); 534 // non smallDouble object 535 value = (smallDoublet*) allocSmallInt(2); 536 r = self->f->pushSmallDouble(self, value); 537 ck_assert_ptr_eq(r, null); 538 terminateO(value); 539 // null 540 r = self->f->pushSmallDouble(self, null); 541 ck_assert_ptr_eq(r, null); 542 ck_assert_int_eq(lenO(self), 3); 543 s = toStringO(self); 544 ck_assert_str_eq(s, "[1,1.000000e+00,0.000000e+00]"); 545 free(s); 546 terminateO(self); 547 548 } 549 550 551 void pushSmallIntSmallArrayT(void) { 552 553 smallArrayt* r; 554 smallArrayt *self = allocG(rtSmallArrayt); 555 smallIntt *value = allocG(1); 556 557 // add an element to check that push adds the second element 558 // at the end 559 r = self->f->pushInt(self, 1); 560 ck_assert_ptr_ne(r, null); 561 562 r = self->f->pushSmallInt(self, value); 563 ck_assert_ptr_ne(r, null); 564 ck_assert_int_eq(lenO(r), 2); 565 finishO(value); 566 char *s = toStringO(r); 567 ck_assert_str_eq(s, "[1,1]"); 568 free(s); 569 // int object with no data 570 createAllocateSmallInt(b); 571 r = self->f->pushSmallInt(self, b); 572 ck_assert_ptr_ne(r, null); 573 ck_assert_int_eq(lenO(r), 3); 574 finishO(b); 575 s = toStringO(r); 576 ck_assert_str_eq(s, "[1,1,0]"); 577 free(s); 578 // non smallInt object 579 value = (smallIntt*) allocSmallBool(true); 580 r = self->f->pushSmallInt(self, value); 581 ck_assert_ptr_eq(r, null); 582 terminateO(value); 583 // null 584 r = self->f->pushSmallInt(self, null); 585 ck_assert_ptr_eq(r, null); 586 ck_assert_int_eq(lenO(self), 3); 587 s = toStringO(self); 588 ck_assert_str_eq(s, "[1,1,0]"); 589 free(s); 590 terminateO(self); 591 592 } 593 594 595 void pushSmallJsonSmallArrayT(void) { 596 597 smallArrayt* r; 598 smallArrayt *self = allocG(rtSmallArrayt); 599 smallJsont *value = allocG(rtSmallJsont); 600 601 // add an element to check that push adds the second element 602 // at the end 603 r = self->f->pushInt(self, 1); 604 ck_assert_ptr_ne(r, null); 605 606 // the smallJson container is empty 607 r = self->f->pushSmallJson(self, value); 608 ck_assert_ptr_ne(r, null); 609 ck_assert_int_eq(lenO(r), 2); 610 char *s = toStringO(r); 611 ck_assert_str_eq(s, "[1,{}]"); 612 free(s); 613 resetO(value); 614 parseO(value, "{}"); 615 r = self->f->pushSmallJson(self, value); 616 finishO(value); 617 ck_assert_ptr_ne(r, null); 618 ck_assert_int_eq(lenO(r), 3); 619 s = toStringO(r); 620 ck_assert_str_eq(s, "[1,{},{}]"); 621 free(s); 622 // non smallJson object 623 value = (smallJsont*) allocSmallInt(2); 624 r = self->f->pushSmallJson(self, value); 625 ck_assert_ptr_eq(r, null); 626 terminateO(value); 627 // null 628 r = self->f->pushSmallJson(self, null); 629 ck_assert_ptr_eq(r, null); 630 ck_assert_int_eq(lenO(self), 3); 631 s = toStringO(self); 632 ck_assert_str_eq(s, "[1,{},{}]"); 633 free(s); 634 terminateO(self); 635 636 } 637 638 639 void pushSmallStringSmallArrayT(void) { 640 641 smallArrayt* r; 642 smallArrayt *self = allocG(rtSmallArrayt); 643 createAllocateSmallString(string); 644 645 // add an element to check that push adds the second element 646 // at the end 647 r = self->f->pushInt(self, 1); 648 ck_assert_ptr_ne(r, null); 649 650 r = self->f->pushSmallString(self, string); 651 ck_assert_ptr_ne(r, null); 652 ck_assert_int_eq(lenO(r), 2); 653 finishO(string); 654 char *s = toStringO(r); 655 ck_assert_str_eq(s, "[1,\"\"]"); 656 free(s); 657 // non smallString object 658 string = (smallStringt*) allocSmallInt(2); 659 r = self->f->pushSmallString(self, string); 660 ck_assert_ptr_eq(r, null); 661 terminateO(string); 662 // null 663 r = self->f->pushSmallString(self, null); 664 ck_assert_ptr_eq(r, null); 665 ck_assert_int_eq(lenO(self), 2); 666 s = toStringO(self); 667 ck_assert_str_eq(s, "[1,\"\"]"); 668 free(s); 669 terminateO(self); 670 671 } 672 673 674 void pushSmallContainerSmallArrayT(void) { 675 676 smallArrayt* r; 677 smallArrayt *self = allocG(rtSmallArrayt); 678 createAllocateSmallContainer(container); 679 680 // add an element to check that push adds the second element 681 // at the end 682 r = self->f->pushInt(self, 1); 683 ck_assert_ptr_ne(r, null); 684 685 r = self->f->pushSmallContainer(self, container); 686 ck_assert_ptr_ne(r, null); 687 ck_assert_int_eq(lenO(r), 2); 688 finishO(container); 689 char *s = toStringO(r); 690 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 691 free(s); 692 // non smallContainer object 693 container = (smallContainert*) allocSmallInt(2); 694 r = self->f->pushSmallContainer(self, container); 695 ck_assert_ptr_eq(r, null); 696 terminateO(container); 697 // null 698 r = self->f->pushSmallContainer(self, null); 699 ck_assert_ptr_eq(r, null); 700 ck_assert_int_eq(lenO(self), 2); 701 s = toStringO(self); 702 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 703 free(s); 704 terminateO(self); 705 706 } 707 708 709 void pushNFreeSmallArrayT(void) { 710 711 smallArrayt* r; 712 smallArrayt *self = allocG(rtSmallArrayt); 713 baset *value = (baset*) allocG(2); 714 715 // add an element to check that push adds the second element 716 // at the end 717 r = self->f->pushInt(self, 1); 718 ck_assert_ptr_ne(r, null); 719 720 r = self->f->pushNFree(self, value); 721 ck_assert_ptr_ne(r, null); 722 ck_assert_int_eq(lenO(r), 2); 723 char *s = toStringO(r); 724 ck_assert_str_eq(s, "[1,2]"); 725 free(s); 726 // null 727 r = self->f->pushNFree(self, null); 728 ck_assert_ptr_eq(r, null); 729 ck_assert_int_eq(lenO(self), 2); 730 s = toStringO(self); 731 ck_assert_str_eq(s, "[1,2]"); 732 free(s); 733 terminateO(self); 734 735 } 736 737 738 void pushNFreeUndefinedSmallArrayT(void) { 739 740 smallArrayt* r; 741 smallArrayt *self = allocG(rtSmallArrayt); 742 743 // add an element to check that push adds the second element 744 // at the end 745 r = self->f->pushInt(self, 1); 746 ck_assert_ptr_ne(r, null); 747 748 createAllocateUndefined(value); 749 r = self->f->pushNFreeUndefined(self, value); 750 ck_assert_ptr_ne(r, null); 751 ck_assert_int_eq(lenO(r), 2); 752 char *s = toStringO(r); 753 ck_assert_str_eq(s, "[1,null]"); 754 free(s); 755 terminateO(self); 756 757 } 758 759 760 void pushNFreeSSmallArrayT(void) { 761 762 smallArrayt* r; 763 smallArrayt *self = allocG(rtSmallArrayt); 764 765 // add an element to check that push adds the second element 766 // at the end 767 r = self->f->pushInt(self, 1); 768 ck_assert_ptr_ne(r, null); 769 770 r = self->f->pushNFreeS(self, null); 771 ck_assert_ptr_eq(r, null); 772 ck_assert_int_eq(lenO(self), 1); 773 char *s = toStringO(self); 774 ck_assert_str_eq(s, "[1]"); 775 free(s); 776 777 char *str = strdup("poi"); 778 r = self->f->pushNFreeS(self, str); 779 ck_assert_ptr_ne(r, null); 780 ck_assert_int_eq(lenO(self), 2); 781 s = toStringO(r); 782 ck_assert_str_eq(s, "[1,\"poi\"]"); 783 free(s); 784 785 terminateO(self); 786 787 } 788 789 790 void pushNFreeDictSmallArrayT(void) { 791 792 smallArrayt* r; 793 smallArrayt *self = allocG(rtSmallArrayt); 794 smallDictt *dict = allocG(rtSmallDictt); 795 796 // add an element to check that push adds the second element 797 // at the end 798 r = self->f->pushInt(self, 1); 799 ck_assert_ptr_ne(r, null); 800 801 // push dict 802 r = self->f->pushNFreeDict(self, dict); 803 ck_assert_ptr_ne(r, null); 804 ck_assert_int_eq(lenO(r), 2); 805 ck_assert_ptr_ne(r, null); 806 char *s = toStringO(r); 807 ck_assert_str_eq(s, "[1,{}]"); 808 free(s); 809 // null 810 r = self->f->pushNFreeDict(self, null); 811 ck_assert_ptr_eq(r, null); 812 ck_assert_int_eq(lenO(self), 2); 813 s = toStringO(self); 814 ck_assert_str_eq(s, "[1,{}]"); 815 free(s); 816 terminateO(self); 817 818 } 819 820 821 void pushNFreeArraySmallArrayT(void) { 822 823 smallArrayt* r; 824 smallArrayt *self = allocG(rtSmallArrayt); 825 smallArrayt *array = allocG(rtSmallArrayt); 826 827 // add an element to check that push adds the second element 828 // at the end 829 r = self->f->pushInt(self, 1); 830 ck_assert_ptr_ne(r, null); 831 832 r = self->f->pushNFreeArray(self, array); 833 ck_assert_ptr_ne(r, null); 834 ck_assert_int_eq(lenO(r), 2); 835 char *s = toStringO(r); 836 ck_assert_str_eq(s, "[1,[]]"); 837 free(s); 838 // null 839 r = self->f->pushNFreeArray(self, null); 840 ck_assert_ptr_eq(r, null); 841 ck_assert_int_eq(lenO(self), 2); 842 s = toStringO(self); 843 ck_assert_str_eq(s, "[1,[]]"); 844 free(s); 845 terminateO(self); 846 847 } 848 849 850 void pushNFreeArraycSmallArrayT(void) { 851 852 smallArrayt* r; 853 smallArrayt *self = allocG(rtSmallArrayt); 854 char **array = listCreateS("a","bb"); 855 856 // add an element to check that push adds the second element 857 // at the end 858 r = self->f->pushInt(self, 1); 859 ck_assert_ptr_ne(r, null); 860 861 r = self->f->pushNFreeArrayc(self, array); 862 ck_assert_ptr_ne(r, null); 863 ck_assert_int_eq(lenO(r), 2); 864 char *s = toStringO(r); 865 ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]"); 866 free(s); 867 // null 868 r = self->f->pushNFreeArrayc(self, null); 869 ck_assert_ptr_eq(r, null); 870 ck_assert_int_eq(lenO(self), 2); 871 s = toStringO(self); 872 ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]"); 873 free(s); 874 terminateO(self); 875 876 } 877 878 879 void pushNFreeSmallBoolSmallArrayT(void) { 880 881 smallArrayt* r; 882 smallArrayt *self = allocG(rtSmallArrayt); 883 smallBoolt *value = allocG(TRUE); 884 885 // add an element to check that push adds the second element 886 // at the end 887 r = self->f->pushInt(self, 1); 888 ck_assert_ptr_ne(r, null); 889 890 r = self->f->pushNFreeSmallBool(self, value); 891 ck_assert_ptr_ne(r, null); 892 ck_assert_int_eq(lenO(r), 2); 893 char *s = toStringO(r); 894 ck_assert_str_eq(s, "[1,true]"); 895 free(s); 896 // bool object with no data 897 createAllocateSmallBool(b); 898 r = self->f->pushNFreeSmallBool(self, b); 899 ck_assert_ptr_ne(r, null); 900 ck_assert_int_eq(lenO(r), 3); 901 s = toStringO(r); 902 ck_assert_str_eq(s, "[1,true,false]"); 903 free(s); 904 // null 905 r = self->f->pushNFreeSmallBool(self, null); 906 ck_assert_ptr_eq(r, null); 907 ck_assert_int_eq(lenO(self), 3); 908 s = toStringO(self); 909 ck_assert_str_eq(s, "[1,true,false]"); 910 free(s); 911 terminateO(self); 912 913 } 914 915 916 void pushNFreeSmallBytesSmallArrayT(void) { 917 918 smallArrayt* r; 919 smallArrayt *self = allocG(rtSmallArrayt); 920 createAllocateSmallBytes(value); 921 922 // add an element to check that push adds the second element 923 // at the end 924 r = self->f->pushInt(self, 1); 925 ck_assert_ptr_ne(r, null); 926 927 // the smallBytes container is empty 928 r = self->f->pushNFreeSmallBytes(self, value); 929 ck_assert_ptr_ne(r, null); 930 ck_assert_int_eq(lenO(r), 2); 931 char *s = toStringO(r); 932 ck_assert_str_eq(s, "[1,[]]"); 933 free(s); 934 935 char *buffer = "poi"; 936 value = allocSmallBytes(buffer, strlen(buffer)); 937 r = self->f->pushNFreeSmallBytes(self, value); 938 ck_assert_ptr_ne(r, null); 939 ck_assert_int_eq(lenO(r), 3); 940 s = toStringO(r); 941 ck_assert_str_eq(s, "[1,[],[0x70,0x6f,0x69]]"); 942 free(s); 943 // null 944 r = self->f->pushNFreeSmallBytes(self, null); 945 ck_assert_ptr_eq(r, null); 946 ck_assert_int_eq(lenO(self), 3); 947 s = toStringO(self); 948 ck_assert_str_eq(s, "[1,[],[0x70,0x6f,0x69]]"); 949 free(s); 950 terminateO(self); 951 952 } 953 954 955 void pushNFreeSmallDoubleSmallArrayT(void) { 956 957 smallArrayt* r; 958 smallArrayt *self = allocG(rtSmallArrayt); 959 smallDoublet *value = allocG(1.0); 960 961 // add an element to check that push adds the second element 962 // at the end 963 r = self->f->pushInt(self, 1); 964 ck_assert_ptr_ne(r, null); 965 966 r = self->f->pushNFreeSmallDouble(self, value); 967 ck_assert_ptr_ne(r, null); 968 ck_assert_int_eq(lenO(r), 2); 969 char *s = toStringO(r); 970 ck_assert_str_eq(s, "[1,1.000000e+00]"); 971 free(s); 972 // object with no data 973 createAllocateSmallDouble(b); 974 r = self->f->pushNFreeSmallDouble(self, b); 975 ck_assert_ptr_ne(r, null); 976 ck_assert_int_eq(lenO(r), 3); 977 s = toStringO(r); 978 ck_assert_str_eq(s, "[1,1.000000e+00,0.000000e+00]"); 979 free(s); 980 // null 981 r = self->f->pushNFreeSmallDouble(self, null); 982 ck_assert_ptr_eq(r, null); 983 ck_assert_int_eq(lenO(self), 3); 984 s = toStringO(self); 985 ck_assert_str_eq(s, "[1,1.000000e+00,0.000000e+00]"); 986 free(s); 987 terminateO(self); 988 989 } 990 991 992 void pushNFreeSmallIntSmallArrayT(void) { 993 994 smallArrayt* r; 995 smallArrayt *self = allocG(rtSmallArrayt); 996 smallIntt *value = allocG(1); 997 998 // add an element to check that push adds the second element 999 // at the end 1000 r = self->f->pushInt(self, 1); 1001 ck_assert_ptr_ne(r, null); 1002 1003 r = self->f->pushNFreeSmallInt(self, value); 1004 ck_assert_ptr_ne(r, null); 1005 ck_assert_int_eq(lenO(r), 2); 1006 char *s = toStringO(r); 1007 ck_assert_str_eq(s, "[1,1]"); 1008 free(s); 1009 // bool object with no data 1010 createAllocateSmallInt(b); 1011 r = self->f->pushNFreeSmallInt(self, b); 1012 ck_assert_ptr_ne(r, null); 1013 ck_assert_int_eq(lenO(r), 3); 1014 s = toStringO(r); 1015 ck_assert_str_eq(s, "[1,1,0]"); 1016 free(s); 1017 // null 1018 r = self->f->pushNFreeSmallInt(self, null); 1019 ck_assert_ptr_eq(r, null); 1020 ck_assert_int_eq(lenO(self), 3); 1021 s = toStringO(self); 1022 ck_assert_str_eq(s, "[1,1,0]"); 1023 free(s); 1024 terminateO(self); 1025 1026 } 1027 1028 1029 void pushNFreeSmallJsonSmallArrayT(void) { 1030 1031 smallArrayt* r; 1032 smallArrayt *self = allocG(rtSmallArrayt); 1033 smallJsont *value = allocG(rtSmallJsont); 1034 1035 // add an element to check that push adds the second element 1036 // at the end 1037 r = self->f->pushInt(self, 1); 1038 ck_assert_ptr_ne(r, null); 1039 1040 // the smallJson container is empty 1041 r = self->f->pushNFreeSmallJson(self, value); 1042 ck_assert_ptr_ne(r, null); 1043 ck_assert_int_eq(lenO(r), 2); 1044 char *s = toStringO(r); 1045 ck_assert_str_eq(s, "[1,{}]"); 1046 free(s); 1047 1048 value = allocG(rtSmallJsont); 1049 parseO(value, "{}"); 1050 r = self->f->pushNFreeSmallJson(self, value); 1051 ck_assert_ptr_ne(r, null); 1052 ck_assert_int_eq(lenO(r), 3); 1053 s = toStringO(r); 1054 ck_assert_str_eq(s, "[1,{},{}]"); 1055 free(s); 1056 // null 1057 r = self->f->pushNFreeSmallJson(self, null); 1058 ck_assert_ptr_eq(r, null); 1059 ck_assert_int_eq(lenO(self), 3); 1060 s = toStringO(self); 1061 ck_assert_str_eq(s, "[1,{},{}]"); 1062 free(s); 1063 terminateO(self); 1064 1065 } 1066 1067 1068 void pushNFreeSmallStringSmallArrayT(void) { 1069 1070 smallArrayt* r; 1071 smallArrayt *self = allocG(rtSmallArrayt); 1072 createAllocateSmallString(string); 1073 1074 // add an element to check that push adds the second element 1075 // at the end 1076 r = self->f->pushInt(self, 1); 1077 ck_assert_ptr_ne(r, null); 1078 1079 r = self->f->pushNFreeSmallString(self, string); 1080 ck_assert_ptr_ne(r, null); 1081 ck_assert_int_eq(lenO(r), 2); 1082 char *s = toStringO(r); 1083 ck_assert_str_eq(s, "[1,\"\"]"); 1084 free(s); 1085 // null 1086 r = self->f->pushNFreeSmallString(self, null); 1087 ck_assert_ptr_eq(r, null); 1088 ck_assert_int_eq(lenO(self), 2); 1089 s = toStringO(self); 1090 ck_assert_str_eq(s, "[1,\"\"]"); 1091 free(s); 1092 terminateO(self); 1093 1094 } 1095 1096 1097 void pushNFreeSmallContainerSmallArrayT(void) { 1098 1099 smallArrayt* r; 1100 smallArrayt *self = allocG(rtSmallArrayt); 1101 createAllocateSmallContainer(container); 1102 1103 // add an element to check that push adds the second element 1104 // at the end 1105 r = self->f->pushInt(self, 1); 1106 ck_assert_ptr_ne(r, null); 1107 1108 r = self->f->pushNFreeSmallContainer(self, container); 1109 ck_assert_ptr_ne(r, null); 1110 ck_assert_int_eq(lenO(r), 2); 1111 char *s = toStringO(r); 1112 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 1113 free(s); 1114 // null 1115 r = self->f->pushNFreeSmallContainer(self, null); 1116 ck_assert_ptr_eq(r, null); 1117 ck_assert_int_eq(lenO(self), 2); 1118 s = toStringO(self); 1119 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 1120 free(s); 1121 terminateO(self); 1122 1123 } 1124 1125 1126 void pushManySmallArrayT(void) { 1127 1128 smallArrayt* r; 1129 smallArrayt *self = allocG(rtSmallArrayt); 1130 smallIntt *v1 = allocG(1); 1131 smallIntt *v2 = allocG(2); 1132 1133 r = self->f->pushMany(self, v1, v2, null); 1134 finishO(v1); 1135 finishO(v2); 1136 ck_assert_ptr_ne(r, null); 1137 ck_assert_int_eq(lenO(r), 2); 1138 char *s = toStringO(r); 1139 ck_assert_str_eq(s, "[1,2]"); 1140 free(s); 1141 terminateO(self); 1142 1143 } 1144 1145 1146 void pushManySSmallArrayT(void) { 1147 1148 smallArrayt* r; 1149 smallArrayt *self = allocG(rtSmallArrayt); 1150 char *v1 = "a"; 1151 char *v2 = "bb"; 1152 1153 r = self->f->pushManyS(self, v1, v2, null); 1154 ck_assert_ptr_ne(r, null); 1155 ck_assert_int_eq(lenO(r), 2); 1156 char *s = toStringO(r); 1157 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 1158 free(s); 1159 terminateO(self); 1160 1161 } 1162 1163 1164 void pushNFreeManySmallArrayT(void) { 1165 1166 smallArrayt* r; 1167 smallArrayt *self = allocG(rtSmallArrayt); 1168 smallIntt *v1 = allocG(1); 1169 smallIntt *v2 = allocG(2); 1170 1171 r = self->f->pushNFreeMany(self, v1, v2, null); 1172 ck_assert_ptr_ne(r, null); 1173 ck_assert_int_eq(lenO(r), 2); 1174 char *s = toStringO(r); 1175 ck_assert_str_eq(s, "[1,2]"); 1176 free(s); 1177 terminateO(self); 1178 1179 } 1180 1181 1182 void pushNFreeManySSmallArrayT(void) { 1183 1184 smallArrayt* r; 1185 smallArrayt *self = allocG(rtSmallArrayt); 1186 char *v1 = strdup("a"); 1187 char *v2 = strdup("bb"); 1188 1189 r = self->f->pushNFreeManyS(self, v1, v2, null); 1190 ck_assert_ptr_ne(r, null); 1191 ck_assert_int_eq(lenO(r), 2); 1192 char *s = toStringO(r); 1193 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 1194 free(s); 1195 terminateO(self); 1196 1197 } 1198 1199 1200 void popSmallArrayT(void) { 1201 1202 baset* r; 1203 smallArrayt *self = allocG(rtSmallArrayt); 1204 smallArrayt *r2; 1205 1206 // add an element to check that the second element is poped 1207 // at the end 1208 r2 = self->f->pushInt(self, 1); 1209 ck_assert_ptr_ne(r2, null); 1210 1211 // push a base object of unknown type 1212 smallIntt *o = allocSmallInt(2); 1213 o->type = "newType"; 1214 r2 = self->f->pushNFree(self, (baset*)o); 1215 ck_assert_ptr_ne(r2, null); 1216 1217 r = self->f->pop(self); 1218 ck_assert_ptr_ne(r, null); 1219 ck_assert_str_eq(r->type, "newType"); 1220 char *s = toStringO(r); 1221 terminateO(r); 1222 ck_assert_str_eq(s, "2"); 1223 free(s); 1224 ck_assert_int_eq(lenO(self), 1); 1225 s = toStringO(self); 1226 ck_assert_str_eq(s, "[1]"); 1227 free(s); 1228 1229 // empty array 1230 r = self->f->pop(self); 1231 ck_assert_ptr_ne(r, null); 1232 terminateO(r); 1233 s = toStringO(self); 1234 ck_assert_str_eq(s, "[]"); 1235 free(s); 1236 r = self->f->pop(self); 1237 ck_assert_ptr_eq(r, null); 1238 s = toStringO(self); 1239 ck_assert_str_eq(s, "[]"); 1240 free(s); 1241 terminateO(self); 1242 1243 } 1244 1245 1246 void popUndefinedSmallArrayT(void) { 1247 1248 undefinedt* r; 1249 smallArrayt *self = allocG(rtSmallArrayt); 1250 smallArrayt *r2; 1251 baset *r3; 1252 1253 // add an element to check that the second element is poped 1254 // at the end 1255 r2 = self->f->pushInt(self, 1); 1256 ck_assert_ptr_ne(r2, null); 1257 // add second element 1258 r2 = self->f->pushUndefined(self); 1259 ck_assert_ptr_ne(r2, null); 1260 r2 = self->f->pushUndefined(self); 1261 ck_assert_ptr_ne(r2, null); 1262 delElemO(self, -1); 1263 // pop 1264 r = self->f->popUndefined(self); 1265 ck_assert_ptr_ne(r, null); 1266 char *s = toStringO(r); 1267 terminateO(r); 1268 ck_assert_str_eq(s, "null"); 1269 free(s); 1270 ck_assert_int_eq(lenO(self), 1); 1271 s = toStringO(self); 1272 ck_assert_str_eq(s, "[1]"); 1273 free(s); 1274 // pop element of unexpected type 1275 r = self->f->popUndefined(self); 1276 ck_assert_ptr_eq(r, null); 1277 ck_assert_int_eq(lenO(self), 1); 1278 s = toStringO(self); 1279 ck_assert_str_eq(s, "[1]"); 1280 free(s); 1281 // empty array 1282 r3 = self->f->pop(self); 1283 ck_assert_ptr_ne(r3, null); 1284 terminateO(r3); 1285 s = toStringO(self); 1286 ck_assert_str_eq(s, "[]"); 1287 free(s); 1288 r = self->f->popUndefined(self); 1289 ck_assert_ptr_eq(r, null); 1290 s = toStringO(self); 1291 ck_assert_str_eq(s, "[]"); 1292 free(s); 1293 r2 = self->f->pushUndefined(self); 1294 ck_assert_ptr_ne(r2, null); 1295 delElemO(self,-1); 1296 r = self->f->popUndefined(self); 1297 ck_assert_ptr_eq(r, null); 1298 terminateO(self); 1299 1300 } 1301 1302 1303 void popBoolSmallArrayT(void) { 1304 1305 bool r; 1306 smallArrayt *self = allocG(rtSmallArrayt); 1307 smallArrayt *r2; 1308 baset *r3; 1309 1310 // add an element to check that the second element is poped 1311 // at the end 1312 r2 = self->f->pushInt(self, 1); 1313 ck_assert_ptr_ne(r2, null); 1314 1315 // add second element 1316 r2 = self->f->pushBool(self, TRUE); 1317 ck_assert_ptr_ne(r2, null); 1318 1319 // pop 1320 r = self->f->popBool(self); 1321 ck_assert(r); 1322 ck_assert_int_eq(lenO(self), 1); 1323 char *s = toStringO(self); 1324 ck_assert_str_eq(s, "[1]"); 1325 free(s); 1326 1327 // pop element of unexpected type 1328 r = self->f->popBool(self); 1329 ck_assert(!r); 1330 ck_assert_int_eq(lenO(self), 1); 1331 s = toStringO(self); 1332 ck_assert_str_eq(s, "[1]"); 1333 free(s); 1334 1335 // empty array 1336 r3 = self->f->pop(self); 1337 ck_assert_ptr_ne(r3, null); 1338 terminateO(r3); 1339 s = toStringO(self); 1340 ck_assert_str_eq(s, "[]"); 1341 free(s); 1342 r = self->f->popBool(self); 1343 ck_assert(!r); 1344 s = toStringO(self); 1345 ck_assert_str_eq(s, "[]"); 1346 free(s); 1347 terminateO(self); 1348 1349 } 1350 1351 1352 void popDoubleSmallArrayT(void) { 1353 1354 double r; 1355 smallArrayt *self = allocG(rtSmallArrayt); 1356 smallArrayt *r2; 1357 baset *r3; 1358 1359 // add an element to check that the second element is poped 1360 // at the end 1361 r2 = self->f->pushInt(self, 1); 1362 ck_assert_ptr_ne(r2, null); 1363 1364 // add second element 1365 r2 = self->f->pushDouble(self, 2.0); 1366 ck_assert_ptr_ne(r2, null); 1367 1368 // pop 1369 r = self->f->popDouble(self); 1370 ck_assert(r==2.0); 1371 ck_assert_int_eq(lenO(self), 1); 1372 char *s = toStringO(self); 1373 ck_assert_str_eq(s, "[1]"); 1374 free(s); 1375 1376 // pop element of unexpected type 1377 r = self->f->popDouble(self); 1378 ck_assert(!r); 1379 ck_assert_int_eq(lenO(self), 1); 1380 s = toStringO(self); 1381 ck_assert_str_eq(s, "[1]"); 1382 free(s); 1383 1384 // empty array 1385 r3 = self->f->pop(self); 1386 ck_assert_ptr_ne(r3, null); 1387 terminateO(r3); 1388 s = toStringO(self); 1389 ck_assert_str_eq(s, "[]"); 1390 free(s); 1391 r = self->f->popDouble(self); 1392 ck_assert(!r); 1393 s = toStringO(self); 1394 ck_assert_str_eq(s, "[]"); 1395 free(s); 1396 terminateO(self); 1397 1398 } 1399 1400 1401 void popIntSmallArrayT(void) { 1402 1403 int64_t r; 1404 smallArrayt *self = allocG(rtSmallArrayt); 1405 smallArrayt *r2; 1406 baset *r3; 1407 1408 // add an element to check that the second element is poped 1409 // at the end 1410 r2 = self->f->pushBool(self, FALSE); 1411 ck_assert_ptr_ne(r2, null); 1412 1413 // add second element 1414 r2 = self->f->pushInt(self, 2); 1415 ck_assert_ptr_ne(r2, null); 1416 1417 // pop 1418 r = self->f->popInt(self); 1419 ck_assert_int_eq(r, 2); 1420 ck_assert_int_eq(lenO(self), 1); 1421 char *s = toStringO(self); 1422 ck_assert_str_eq(s, "[false]"); 1423 free(s); 1424 1425 // pop element of unexpected type 1426 r = self->f->popInt(self); 1427 ck_assert(!r); 1428 ck_assert_int_eq(lenO(self), 1); 1429 s = toStringO(self); 1430 ck_assert_str_eq(s, "[false]"); 1431 free(s); 1432 1433 // empty array 1434 r3 = self->f->pop(self); 1435 ck_assert_ptr_ne(r3, null); 1436 terminateO(r3); 1437 s = toStringO(self); 1438 ck_assert_str_eq(s, "[]"); 1439 free(s); 1440 r = self->f->popInt(self); 1441 ck_assert(!r); 1442 s = toStringO(self); 1443 ck_assert_str_eq(s, "[]"); 1444 free(s); 1445 terminateO(self); 1446 1447 } 1448 1449 1450 void popInt32SmallArrayT(void) { 1451 1452 int32_t r; 1453 smallArrayt *self = allocG(rtSmallArrayt); 1454 smallArrayt *r2; 1455 baset *r3; 1456 1457 // add an element to check that the second element is poped 1458 // at the end 1459 r2 = self->f->pushBool(self, FALSE); 1460 ck_assert_ptr_ne(r2, null); 1461 1462 // add second element 1463 r2 = self->f->pushInt(self, 2); 1464 ck_assert_ptr_ne(r2, null); 1465 1466 // pop 1467 r = self->f->popInt32(self); 1468 ck_assert_int_eq(r, 2); 1469 ck_assert_int_eq(lenO(self), 1); 1470 char *s = toStringO(self); 1471 ck_assert_str_eq(s, "[false]"); 1472 free(s); 1473 1474 // pop element of unexpected type 1475 r = self->f->popInt32(self); 1476 ck_assert(!r); 1477 ck_assert_int_eq(lenO(self), 1); 1478 s = toStringO(self); 1479 ck_assert_str_eq(s, "[false]"); 1480 free(s); 1481 1482 // empty array 1483 r3 = self->f->pop(self); 1484 ck_assert_ptr_ne(r3, null); 1485 terminateO(r3); 1486 s = toStringO(self); 1487 ck_assert_str_eq(s, "[]"); 1488 free(s); 1489 r = self->f->popInt32(self); 1490 ck_assert(!r); 1491 s = toStringO(self); 1492 ck_assert_str_eq(s, "[]"); 1493 free(s); 1494 terminateO(self); 1495 1496 } 1497 1498 1499 void popUintSmallArrayT(void) { 1500 1501 uint64_t r; 1502 smallArrayt *self = allocG(rtSmallArrayt); 1503 smallArrayt *r2; 1504 baset *r3; 1505 1506 // add an element to check that the second element is poped 1507 // at the end 1508 r2 = self->f->pushBool(self, FALSE); 1509 ck_assert_ptr_ne(r2, null); 1510 1511 // add second element 1512 r2 = self->f->pushInt(self, 2); 1513 ck_assert_ptr_ne(r2, null); 1514 1515 // pop 1516 r = self->f->popUint(self); 1517 ck_assert_int_eq(r, 2); 1518 ck_assert_int_eq(lenO(self), 1); 1519 char *s = toStringO(self); 1520 ck_assert_str_eq(s, "[false]"); 1521 free(s); 1522 1523 // pop element of unexpected type 1524 r = self->f->popUint(self); 1525 ck_assert(!r); 1526 ck_assert_int_eq(lenO(self), 1); 1527 s = toStringO(self); 1528 ck_assert_str_eq(s, "[false]"); 1529 free(s); 1530 1531 // empty array 1532 r3 = self->f->pop(self); 1533 ck_assert_ptr_ne(r3, null); 1534 terminateO(r3); 1535 s = toStringO(self); 1536 ck_assert_str_eq(s, "[]"); 1537 free(s); 1538 r = self->f->popUint(self); 1539 ck_assert(!r); 1540 s = toStringO(self); 1541 ck_assert_str_eq(s, "[]"); 1542 free(s); 1543 terminateO(self); 1544 1545 } 1546 1547 1548 void popUint32SmallArrayT(void) { 1549 1550 uint32_t r; 1551 smallArrayt *self = allocG(rtSmallArrayt); 1552 smallArrayt *r2; 1553 baset *r3; 1554 1555 // add an element to check that the second element is poped 1556 // at the end 1557 r2 = self->f->pushBool(self, FALSE); 1558 ck_assert_ptr_ne(r2, null); 1559 1560 // add second element 1561 r2 = self->f->pushInt(self, 2); 1562 ck_assert_ptr_ne(r2, null); 1563 1564 // pop 1565 r = self->f->popUint32(self); 1566 ck_assert_int_eq(r, 2); 1567 ck_assert_int_eq(lenO(self), 1); 1568 char *s = toStringO(self); 1569 ck_assert_str_eq(s, "[false]"); 1570 free(s); 1571 1572 // pop element of unexpected type 1573 r = self->f->popUint32(self); 1574 ck_assert(!r); 1575 ck_assert_int_eq(lenO(self), 1); 1576 s = toStringO(self); 1577 ck_assert_str_eq(s, "[false]"); 1578 free(s); 1579 1580 // empty array 1581 r3 = self->f->pop(self); 1582 ck_assert_ptr_ne(r3, null); 1583 terminateO(r3); 1584 s = toStringO(self); 1585 ck_assert_str_eq(s, "[]"); 1586 free(s); 1587 r = self->f->popUint32(self); 1588 ck_assert(!r); 1589 s = toStringO(self); 1590 ck_assert_str_eq(s, "[]"); 1591 free(s); 1592 terminateO(self); 1593 1594 } 1595 1596 1597 void popSSmallArrayT(void) { 1598 1599 char* r; 1600 smallArrayt *self = allocG(rtSmallArrayt); 1601 smallArrayt *r2; 1602 baset *r3; 1603 1604 // add an element to check that the second element is poped 1605 // at the end 1606 r2 = self->f->pushInt(self, 1); 1607 ck_assert_ptr_ne(r2, null); 1608 1609 // add second element 1610 r2 = self->f->pushS(self, "bb"); 1611 ck_assert_ptr_ne(r2, null); 1612 1613 // pop 1614 r = self->f->popS(self); 1615 ck_assert_str_eq(r, "bb"); 1616 free(r); 1617 ck_assert_int_eq(lenO(self), 1); 1618 char *s = toStringO(self); 1619 ck_assert_str_eq(s, "[1]"); 1620 free(s); 1621 1622 // pop element of unexpected type 1623 r = self->f->popS(self); 1624 ck_assert(!r); 1625 ck_assert_int_eq(lenO(self), 1); 1626 s = toStringO(self); 1627 ck_assert_str_eq(s, "[1]"); 1628 free(s); 1629 1630 // empty array 1631 r3 = self->f->pop(self); 1632 ck_assert_ptr_ne(r3, null); 1633 terminateO(r3); 1634 s = toStringO(self); 1635 ck_assert_str_eq(s, "[]"); 1636 free(s); 1637 r = self->f->popS(self); 1638 ck_assert(!r); 1639 s = toStringO(self); 1640 ck_assert_str_eq(s, "[]"); 1641 free(s); 1642 terminateO(self); 1643 1644 } 1645 1646 1647 void popDictSmallArrayT(void) { 1648 1649 smallDictt* r; 1650 smallArrayt *self = allocG(rtSmallArrayt); 1651 smallArrayt *r2; 1652 baset *r3; 1653 1654 // add an element to check that the second element is poped 1655 // at the end 1656 r2 = self->f->pushInt(self, 1); 1657 ck_assert_ptr_ne(r2, null); 1658 // add second element 1659 createSmallDict(e); 1660 r2 = self->f->pushDict(self, &e); 1661 ck_assert_ptr_ne(r2, null); 1662 r2 = self->f->pushUndefined(self); 1663 ck_assert_ptr_ne(r2, null); 1664 delElemO(self, -1); 1665 // pop 1666 r = self->f->popDict(self); 1667 ck_assert_ptr_ne(r, null); 1668 char *s = toStringO(r); 1669 terminateO(r); 1670 ck_assert_str_eq(s, "{}"); 1671 free(s); 1672 ck_assert_int_eq(lenO(self), 1); 1673 s = toStringO(self); 1674 ck_assert_str_eq(s, "[1]"); 1675 free(s); 1676 // pop element of unexpected type 1677 r = self->f->popDict(self); 1678 ck_assert(!r); 1679 ck_assert_int_eq(lenO(self), 1); 1680 s = toStringO(self); 1681 ck_assert_str_eq(s, "[1]"); 1682 free(s); 1683 // empty array 1684 r3 = self->f->pop(self); 1685 ck_assert_ptr_ne(r3, null); 1686 terminateO(r3); 1687 s = toStringO(self); 1688 ck_assert_str_eq(s, "[]"); 1689 free(s); 1690 r = self->f->popDict(self); 1691 ck_assert(!r); 1692 s = toStringO(self); 1693 ck_assert_str_eq(s, "[]"); 1694 free(s); 1695 r2 = self->f->pushUndefined(self); 1696 ck_assert_ptr_ne(r2, null); 1697 delElemO(self,-1); 1698 r = self->f->popDict(self); 1699 ck_assert_ptr_eq(r, null); 1700 terminateO(self); 1701 1702 } 1703 1704 1705 void popArraySmallArrayT(void) { 1706 1707 smallArrayt* r; 1708 smallArrayt *self = allocG(rtSmallArrayt); 1709 smallArrayt *r2; 1710 baset *r3; 1711 1712 // add an element to check that the second element is poped 1713 // at the end 1714 r2 = self->f->pushInt(self, 1); 1715 ck_assert_ptr_ne(r2, null); 1716 // add second element 1717 createSmallArray(e); 1718 r2 = self->f->pushArray(self, &e); 1719 ck_assert_ptr_ne(r2, null); 1720 r2 = self->f->pushUndefined(self); 1721 ck_assert_ptr_ne(r2, null); 1722 delElemO(self, -1); 1723 // pop 1724 r = self->f->popArray(self); 1725 ck_assert_ptr_ne(r, null); 1726 char *s = toStringO(r); 1727 terminateO(r); 1728 ck_assert_str_eq(s, "[]"); 1729 free(s); 1730 ck_assert_int_eq(lenO(self), 1); 1731 s = toStringO(self); 1732 ck_assert_str_eq(s, "[1]"); 1733 free(s); 1734 // pop element of unexpected type 1735 r = self->f->popArray(self); 1736 ck_assert(!r); 1737 ck_assert_int_eq(lenO(self), 1); 1738 s = toStringO(self); 1739 ck_assert_str_eq(s, "[1]"); 1740 free(s); 1741 // empty array 1742 r3 = self->f->pop(self); 1743 ck_assert_ptr_ne(r3, null); 1744 terminateO(r3); 1745 s = toStringO(self); 1746 ck_assert_str_eq(s, "[]"); 1747 free(s); 1748 r = self->f->popArray(self); 1749 ck_assert(!r); 1750 s = toStringO(self); 1751 ck_assert_str_eq(s, "[]"); 1752 free(s); 1753 r2 = self->f->pushUndefined(self); 1754 ck_assert_ptr_ne(r2, null); 1755 delElemO(self,-1); 1756 r = self->f->popArray(self); 1757 ck_assert_ptr_eq(r, null); 1758 terminateO(self); 1759 1760 } 1761 1762 1763 void popSmallBoolSmallArrayT(void) { 1764 1765 smallBoolt* r; 1766 smallArrayt *self = allocG(rtSmallArrayt); 1767 smallArrayt *r2; 1768 baset *r3; 1769 1770 // add an element to check that the second element is poped 1771 // at the end 1772 r2 = self->f->pushInt(self, 1); 1773 ck_assert_ptr_ne(r2, null); 1774 // add second element 1775 createSmallBool(e); 1776 r2 = self->f->pushSmallBool(self, &e); 1777 ck_assert_ptr_ne(r2, null); 1778 r2 = self->f->pushUndefined(self); 1779 ck_assert_ptr_ne(r2, null); 1780 delElemO(self, -1); 1781 // pop 1782 r = self->f->popSmallBool(self); 1783 ck_assert_ptr_ne(r, null); 1784 char *s = toStringO(r); 1785 terminateO(r); 1786 ck_assert_str_eq(s, "false"); 1787 free(s); 1788 ck_assert_int_eq(lenO(self), 1); 1789 s = toStringO(self); 1790 ck_assert_str_eq(s, "[1]"); 1791 free(s); 1792 // pop element of unexpected type 1793 r = self->f->popSmallBool(self); 1794 ck_assert(!r); 1795 ck_assert_int_eq(lenO(self), 1); 1796 s = toStringO(self); 1797 ck_assert_str_eq(s, "[1]"); 1798 free(s); 1799 // empty array 1800 r3 = self->f->pop(self); 1801 ck_assert_ptr_ne(r3, null); 1802 terminateO(r3); 1803 s = toStringO(self); 1804 ck_assert_str_eq(s, "[]"); 1805 free(s); 1806 r = self->f->popSmallBool(self); 1807 ck_assert(!r); 1808 s = toStringO(self); 1809 ck_assert_str_eq(s, "[]"); 1810 free(s); 1811 r2 = self->f->pushUndefined(self); 1812 ck_assert_ptr_ne(r2, null); 1813 delElemO(self,-1); 1814 r = self->f->popSmallBool(self); 1815 ck_assert_ptr_eq(r, null); 1816 terminateO(self); 1817 1818 } 1819 1820 1821 void popSmallBytesSmallArrayT(void) { 1822 1823 smallBytest* r; 1824 smallArrayt *self = allocG(rtSmallArrayt); 1825 smallArrayt *r2; 1826 baset *r3; 1827 1828 // add an element to check that the second element is poped 1829 // at the end 1830 r2 = self->f->pushInt(self, 1); 1831 ck_assert_ptr_ne(r2, null); 1832 // add second element 1833 createSmallBytes(e); 1834 r2 = self->f->pushSmallBytes(self, &e); 1835 ck_assert_ptr_ne(r2, null); 1836 r2 = self->f->pushUndefined(self); 1837 ck_assert_ptr_ne(r2, null); 1838 delElemO(self, -1); 1839 // pop 1840 r = self->f->popSmallBytes(self); 1841 ck_assert_ptr_ne(r, null); 1842 char *s = toStringO(r); 1843 terminateO(r); 1844 ck_assert_str_eq(s, "[]"); 1845 free(s); 1846 ck_assert_int_eq(lenO(self), 1); 1847 s = toStringO(self); 1848 ck_assert_str_eq(s, "[1]"); 1849 free(s); 1850 // pop element of unexpected type 1851 r = self->f->popSmallBytes(self); 1852 ck_assert(!r); 1853 ck_assert_int_eq(lenO(self), 1); 1854 s = toStringO(self); 1855 ck_assert_str_eq(s, "[1]"); 1856 free(s); 1857 // empty array 1858 r3 = self->f->pop(self); 1859 ck_assert_ptr_ne(r3, null); 1860 terminateO(r3); 1861 s = toStringO(self); 1862 ck_assert_str_eq(s, "[]"); 1863 free(s); 1864 r = self->f->popSmallBytes(self); 1865 ck_assert(!r); 1866 s = toStringO(self); 1867 ck_assert_str_eq(s, "[]"); 1868 free(s); 1869 r2 = self->f->pushUndefined(self); 1870 ck_assert_ptr_ne(r2, null); 1871 delElemO(self,-1); 1872 r = self->f->popSmallBytes(self); 1873 ck_assert_ptr_eq(r, null); 1874 terminateO(self); 1875 1876 } 1877 1878 1879 void popSmallDoubleSmallArrayT(void) { 1880 1881 smallDoublet* r; 1882 smallArrayt *self = allocG(rtSmallArrayt); 1883 smallArrayt *r2; 1884 baset *r3; 1885 1886 // add an element to check that the second element is poped 1887 // at the end 1888 r2 = self->f->pushInt(self, 1); 1889 ck_assert_ptr_ne(r2, null); 1890 // add second element 1891 createSmallDouble(e); 1892 r2 = self->f->pushSmallDouble(self, &e); 1893 ck_assert_ptr_ne(r2, null); 1894 r2 = self->f->pushUndefined(self); 1895 ck_assert_ptr_ne(r2, null); 1896 delElemO(self, -1); 1897 // pop 1898 r = self->f->popSmallDouble(self); 1899 ck_assert_ptr_ne(r, null); 1900 char *s = toStringO(r); 1901 terminateO(r); 1902 ck_assert_str_eq(s, "0.000000e+00"); 1903 free(s); 1904 ck_assert_int_eq(lenO(self), 1); 1905 s = toStringO(self); 1906 ck_assert_str_eq(s, "[1]"); 1907 free(s); 1908 // pop element of unexpected type 1909 r = self->f->popSmallDouble(self); 1910 ck_assert(!r); 1911 ck_assert_int_eq(lenO(self), 1); 1912 s = toStringO(self); 1913 ck_assert_str_eq(s, "[1]"); 1914 free(s); 1915 // empty array 1916 r3 = self->f->pop(self); 1917 ck_assert_ptr_ne(r3, null); 1918 terminateO(r3); 1919 s = toStringO(self); 1920 ck_assert_str_eq(s, "[]"); 1921 free(s); 1922 r = self->f->popSmallDouble(self); 1923 ck_assert(!r); 1924 s = toStringO(self); 1925 ck_assert_str_eq(s, "[]"); 1926 free(s); 1927 r2 = self->f->pushUndefined(self); 1928 ck_assert_ptr_ne(r2, null); 1929 delElemO(self,-1); 1930 r = self->f->popSmallDouble(self); 1931 ck_assert_ptr_eq(r, null); 1932 terminateO(self); 1933 1934 } 1935 1936 1937 void popSmallIntSmallArrayT(void) { 1938 1939 smallIntt* r; 1940 smallArrayt *self = allocG(rtSmallArrayt); 1941 smallArrayt *r2; 1942 baset *r3; 1943 1944 // add an element to check that the second element is poped 1945 // at the end 1946 r2 = self->f->pushBool(self, TRUE); 1947 ck_assert_ptr_ne(r2, null); 1948 // add second element 1949 createSmallInt(e); 1950 r2 = self->f->pushSmallInt(self, &e); 1951 ck_assert_ptr_ne(r2, null); 1952 r2 = self->f->pushUndefined(self); 1953 ck_assert_ptr_ne(r2, null); 1954 delElemO(self, -1); 1955 // pop 1956 r = self->f->popSmallInt(self); 1957 ck_assert_ptr_ne(r, null); 1958 char *s = toStringO(r); 1959 terminateO(r); 1960 ck_assert_str_eq(s, "0"); 1961 free(s); 1962 ck_assert_int_eq(lenO(self), 1); 1963 s = toStringO(self); 1964 ck_assert_str_eq(s, "[true]"); 1965 free(s); 1966 // pop element of unexpected type 1967 r = self->f->popSmallInt(self); 1968 ck_assert(!r); 1969 ck_assert_int_eq(lenO(self), 1); 1970 s = toStringO(self); 1971 ck_assert_str_eq(s, "[true]"); 1972 free(s); 1973 // empty array 1974 r3 = self->f->pop(self); 1975 ck_assert_ptr_ne(r3, null); 1976 terminateO(r3); 1977 s = toStringO(self); 1978 ck_assert_str_eq(s, "[]"); 1979 free(s); 1980 r = self->f->popSmallInt(self); 1981 ck_assert(!r); 1982 s = toStringO(self); 1983 ck_assert_str_eq(s, "[]"); 1984 free(s); 1985 r2 = self->f->pushUndefined(self); 1986 ck_assert_ptr_ne(r2, null); 1987 delElemO(self,-1); 1988 r = self->f->popSmallInt(self); 1989 ck_assert_ptr_eq(r, null); 1990 terminateO(self); 1991 1992 } 1993 1994 1995 void popSmallJsonSmallArrayT(void) { 1996 1997 smallJsont* r; 1998 smallArrayt *self = allocG(rtSmallArrayt); 1999 smallArrayt *r2; 2000 baset *r3; 2001 2002 // add an element to check that the second element is poped 2003 // at the end 2004 createSmallBytes(B); 2005 r2 = self->f->pushSmallBytes(self, &B); 2006 ck_assert_ptr_ne(r2, null); 2007 // add second element 2008 createSmallJson(e); 2009 r2 = self->f->pushSmallJson(self, &e); 2010 ck_assert_ptr_ne(r2, null); 2011 r2 = self->f->pushUndefined(self); 2012 ck_assert_ptr_ne(r2, null); 2013 delElemO(self, -1); 2014 // pop 2015 r = self->f->popSmallJson(self); 2016 ck_assert_ptr_ne(r, null); 2017 char *s = toStringO(r); 2018 terminateO(r); 2019 ck_assert_str_eq(s, "{}"); 2020 free(s); 2021 ck_assert_int_eq(lenO(self), 1); 2022 s = toStringO(self); 2023 ck_assert_str_eq(s, "[[]]"); 2024 free(s); 2025 // pop element of unexpected type 2026 r = self->f->popSmallJson(self); 2027 ck_assert(!r); 2028 ck_assert_int_eq(lenO(self), 1); 2029 s = toStringO(self); 2030 ck_assert_str_eq(s, "[[]]"); 2031 free(s); 2032 // empty array 2033 r3 = self->f->pop(self); 2034 ck_assert_ptr_ne(r3, null); 2035 terminateO(r3); 2036 s = toStringO(self); 2037 ck_assert_str_eq(s, "[]"); 2038 free(s); 2039 r = self->f->popSmallJson(self); 2040 ck_assert(!r); 2041 s = toStringO(self); 2042 ck_assert_str_eq(s, "[]"); 2043 free(s); 2044 r2 = self->f->pushUndefined(self); 2045 ck_assert_ptr_ne(r2, null); 2046 delElemO(self,-1); 2047 r = self->f->popSmallJson(self); 2048 ck_assert_ptr_eq(r, null); 2049 terminateO(self); 2050 2051 } 2052 2053 2054 void popSmallStringSmallArrayT(void) { 2055 2056 smallStringt* r; 2057 smallArrayt *self = allocG(rtSmallArrayt); 2058 smallArrayt *r2; 2059 baset *r3; 2060 2061 // add an element to check that the second element is poped 2062 // at the end 2063 r2 = self->f->pushInt(self, 1); 2064 ck_assert_ptr_ne(r2, null); 2065 // add second element 2066 createSmallString(e); 2067 r2 = self->f->pushSmallString(self, &e); 2068 ck_assert_ptr_ne(r2, null); 2069 r2 = self->f->pushUndefined(self); 2070 ck_assert_ptr_ne(r2, null); 2071 delElemO(self, -1); 2072 // pop 2073 r = self->f->popSmallString(self); 2074 ck_assert_ptr_ne(r, null); 2075 char *s = toStringO(r); 2076 terminateO(r); 2077 ck_assert_str_eq(s, ""); 2078 free(s); 2079 ck_assert_int_eq(lenO(self), 1); 2080 s = toStringO(self); 2081 ck_assert_str_eq(s, "[1]"); 2082 free(s); 2083 // pop element of unexpected type 2084 r = self->f->popSmallString(self); 2085 ck_assert(!r); 2086 ck_assert_int_eq(lenO(self), 1); 2087 s = toStringO(self); 2088 ck_assert_str_eq(s, "[1]"); 2089 free(s); 2090 // empty array 2091 r3 = self->f->pop(self); 2092 ck_assert_ptr_ne(r3, null); 2093 terminateO(r3); 2094 s = toStringO(self); 2095 ck_assert_str_eq(s, "[]"); 2096 free(s); 2097 r = self->f->popSmallString(self); 2098 ck_assert(!r); 2099 s = toStringO(self); 2100 ck_assert_str_eq(s, "[]"); 2101 free(s); 2102 r2 = self->f->pushUndefined(self); 2103 ck_assert_ptr_ne(r2, null); 2104 delElemO(self,-1); 2105 r = self->f->popSmallString(self); 2106 ck_assert_ptr_eq(r, null); 2107 terminateO(self); 2108 2109 } 2110 2111 2112 void popVoidSmallArrayT(void) { 2113 2114 void* r; 2115 smallArrayt *self = allocG(rtSmallArrayt); 2116 smallArrayt *r2; 2117 baset *r3; 2118 2119 // add an element to check that the second element is poped 2120 // at the end 2121 r2 = self->f->pushInt(self, 1); 2122 ck_assert_ptr_ne(r2, null); 2123 // add second element 2124 createSmallContainer(e); 2125 setValO(&e, &r); 2126 r2 = self->f->pushSmallContainer(self, &e); 2127 ck_assert_ptr_ne(r2, null); 2128 // pop 2129 r = self->f->popVoid(self); 2130 ck_assert_ptr_eq(r, &r); 2131 ck_assert_int_eq(lenO(self), 1); 2132 char *s = toStringO(self); 2133 ck_assert_str_eq(s, "[1]"); 2134 free(s); 2135 // pop element of unexpected type 2136 r = self->f->popVoid(self); 2137 ck_assert(!r); 2138 ck_assert_int_eq(lenO(self), 1); 2139 s = toStringO(self); 2140 ck_assert_str_eq(s, "[1]"); 2141 free(s); 2142 // empty array 2143 r3 = self->f->pop(self); 2144 ck_assert_ptr_ne(r3, null); 2145 terminateO(r3); 2146 s = toStringO(self); 2147 ck_assert_str_eq(s, "[]"); 2148 free(s); 2149 r = self->f->popVoid(self); 2150 ck_assert(!r); 2151 s = toStringO(self); 2152 ck_assert_str_eq(s, "[]"); 2153 free(s); 2154 terminateO(self); 2155 2156 } 2157 2158 2159 void popSmallContainerSmallArrayT(void) { 2160 2161 smallContainert* r; 2162 smallArrayt *self = allocG(rtSmallArrayt); 2163 smallArrayt *r2; 2164 baset *r3; 2165 2166 // add an element to check that the second element is poped 2167 // at the end 2168 r2 = self->f->pushInt(self, 1); 2169 ck_assert_ptr_ne(r2, null); 2170 // add second element 2171 createSmallContainer(e); 2172 r2 = self->f->pushSmallContainer(self, &e); 2173 ck_assert_ptr_ne(r2, null); 2174 r2 = self->f->pushUndefined(self); 2175 ck_assert_ptr_ne(r2, null); 2176 delElemO(self, -1); 2177 // pop 2178 r = self->f->popSmallContainer(self); 2179 ck_assert_ptr_ne(r, null); 2180 char *s = toStringO(r); 2181 terminateO(r); 2182 ck_assert_str_eq(s, "<data smallContainer>"); 2183 free(s); 2184 ck_assert_int_eq(lenO(self), 1); 2185 s = toStringO(self); 2186 ck_assert_str_eq(s, "[1]"); 2187 free(s); 2188 // container with baset object 2189 // push a base object of unknown type 2190 smallIntt *o = allocSmallInt(2); 2191 o->type = "newType"; 2192 r2 = self->f->pushNFree(self, (baset*)o); 2193 ck_assert_ptr_ne(r2, null); 2194 r = self->f->popSmallContainer(self); 2195 ck_assert_ptr_eq(r, NULL); 2196 ck_assert_int_eq(lenO(self), 2); 2197 s = toStringO(self); 2198 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 2199 free(s); 2200 r3 = self->f->pop(self); 2201 ck_assert_ptr_ne(r3, null); 2202 terminateO(r3); 2203 // pop element of unexpected type 2204 r = self->f->popSmallContainer(self); 2205 ck_assert_ptr_eq(r, NULL); 2206 ck_assert_int_eq(lenO(self), 1); 2207 s = toStringO(self); 2208 ck_assert_str_eq(s, "[1]"); 2209 free(s); 2210 // empty array 2211 r3 = self->f->pop(self); 2212 ck_assert_ptr_ne(r3, null); 2213 terminateO(r3); 2214 s = toStringO(self); 2215 ck_assert_str_eq(s, "[]"); 2216 free(s); 2217 r = self->f->popSmallContainer(self); 2218 ck_assert(!r); 2219 s = toStringO(self); 2220 ck_assert_str_eq(s, "[]"); 2221 free(s); 2222 r2 = self->f->pushUndefined(self); 2223 ck_assert_ptr_ne(r2, null); 2224 delElemO(self,-1); 2225 r = self->f->popSmallContainer(self); 2226 ck_assert_ptr_eq(r, null); 2227 terminateO(self); 2228 2229 } 2230 2231 2232 void popNumSmallArrayT(void) { 2233 2234 double r; 2235 smallArrayt *self = allocG(rtSmallArrayt); 2236 smallArrayt *r2; 2237 baset *r3; 2238 2239 // add an element to check that the second element is poped 2240 // at the end 2241 r2 = self->f->pushBool(self, TRUE); 2242 ck_assert_ptr_ne(r2, null); 2243 // add second element 2244 r2 = self->f->pushInt(self, 2); 2245 ck_assert_ptr_ne(r2, null); 2246 r2 = self->f->pushDouble(self, 2.5); 2247 ck_assert_ptr_ne(r2, null); 2248 r2 = self->f->pushUndefined(self); 2249 ck_assert_ptr_ne(r2, null); 2250 delElemO(self, -1); 2251 // pop 2252 r = self->f->popNum(self); 2253 ck_assert(r==2.5); 2254 ck_assert_int_eq(lenO(self), 2); 2255 char *s = toStringO(self); 2256 ck_assert_str_eq(s, "[true,2]"); 2257 free(s); 2258 r = self->f->popNum(self); 2259 ck_assert_int_eq(r, 2); 2260 ck_assert_int_eq(lenO(self), 1); 2261 s = toStringO(self); 2262 ck_assert_str_eq(s, "[true]"); 2263 free(s); 2264 // pop element of unexpected type 2265 r = self->f->popNum(self); 2266 ck_assert(!r); 2267 ck_assert_int_eq(lenO(self), 1); 2268 s = toStringO(self); 2269 ck_assert_str_eq(s, "[true]"); 2270 free(s); 2271 // empty array 2272 r3 = self->f->pop(self); 2273 ck_assert_ptr_ne(r3, null); 2274 terminateO(r3); 2275 s = toStringO(self); 2276 ck_assert_str_eq(s, "[]"); 2277 free(s); 2278 r = self->f->popNum(self); 2279 ck_assert(!r); 2280 s = toStringO(self); 2281 ck_assert_str_eq(s, "[]"); 2282 free(s); 2283 r2 = self->f->pushUndefined(self); 2284 ck_assert_ptr_ne(r2, null); 2285 delElemO(self,-1); 2286 r = self->f->popNum(self); 2287 ck_assert(!r); 2288 terminateO(self); 2289 2290 } 2291 2292 2293 void prependSmallArrayT(void) { 2294 2295 smallArrayt* r; 2296 smallArrayt *self = allocG(rtSmallArrayt); 2297 baset *value = (baset*) allocG(2); 2298 2299 // add an element to check that prepend adds the second element 2300 // at the start 2301 r = self->f->pushInt(self, 1); 2302 ck_assert_ptr_ne(r, null); 2303 2304 r = self->f->prepend(self, value); 2305 ck_assert_ptr_ne(r, null); 2306 ck_assert_int_eq(lenO(r), 2); 2307 finishO(value); 2308 char *s = toStringO(r); 2309 ck_assert_str_eq(s, "[2,1]"); 2310 free(s); 2311 // null 2312 r = self->f->prepend(self, null); 2313 ck_assert_ptr_eq(r, null); 2314 ck_assert_int_eq(lenO(self), 2); 2315 s = toStringO(self); 2316 ck_assert_str_eq(s, "[2,1]"); 2317 free(s); 2318 2319 //r = prependO(self); 2320 terminateO(self); 2321 2322 } 2323 2324 2325 void prependUndefinedSmallArrayT(void) { 2326 2327 smallArrayt* r; 2328 smallArrayt *self = allocG(rtSmallArrayt); 2329 2330 // add an element to check that push adds the second element 2331 // at the end 2332 r = self->f->pushInt(self, 1); 2333 ck_assert_ptr_ne(r, null); 2334 2335 r = self->f->prependUndefined(self); 2336 ck_assert_ptr_ne(r, null); 2337 ck_assert_int_eq(lenO(r), 2); 2338 char *s = toStringO(r); 2339 ck_assert_str_eq(s, "[null,1]"); 2340 free(s); 2341 terminateO(self); 2342 2343 } 2344 2345 2346 void prependBoolSmallArrayT(void) { 2347 2348 smallArrayt* r; 2349 smallArrayt *self = allocG(rtSmallArrayt); 2350 2351 // add an element to check that push adds the second element 2352 // at the end 2353 r = self->f->pushInt(self, 1); 2354 ck_assert_ptr_ne(r, null); 2355 2356 r = self->f->prependBool(self, TRUE); 2357 ck_assert_ptr_ne(r, null); 2358 ck_assert_int_eq(lenO(r), 2); 2359 char *s = toStringO(r); 2360 ck_assert_str_eq(s, "[true,1]"); 2361 free(s); 2362 terminateO(self); 2363 2364 } 2365 2366 2367 void prependDoubleSmallArrayT(void) { 2368 2369 smallArrayt* r; 2370 smallArrayt *self = allocG(rtSmallArrayt); 2371 2372 // add an element to check that push adds the second element 2373 // at the end 2374 r = self->f->pushInt(self, 1); 2375 ck_assert_ptr_ne(r, null); 2376 2377 r = self->f->prependDouble(self, 1.0); 2378 ck_assert_ptr_ne(r, null); 2379 ck_assert_int_eq(lenO(r), 2); 2380 char *s = toStringO(r); 2381 ck_assert_str_eq(s, "[1.000000e+00,1]"); 2382 free(s); 2383 terminateO(self); 2384 2385 } 2386 2387 2388 void prependIntSmallArrayT(void) { 2389 2390 smallArrayt* r; 2391 smallArrayt *self = allocG(rtSmallArrayt); 2392 2393 // add an element to check that push adds the second element 2394 // at the end 2395 r = self->f->prependInt(self, 1); 2396 ck_assert_ptr_ne(r, null); 2397 2398 r = self->f->prependInt(self, 1); 2399 ck_assert_ptr_ne(r, null); 2400 ck_assert_int_eq(lenO(r), 2); 2401 char *s = toStringO(r); 2402 ck_assert_str_eq(s, "[1,1]"); 2403 free(s); 2404 terminateO(self); 2405 2406 } 2407 2408 2409 void prependSSmallArrayT(void) { 2410 2411 smallArrayt* r; 2412 smallArrayt *self = allocG(rtSmallArrayt); 2413 2414 // add an element to check that push adds the second element 2415 // at the end 2416 r = self->f->pushInt(self, 1); 2417 ck_assert_ptr_ne(r, null); 2418 2419 r = self->f->prependS(self, null); 2420 ck_assert_ptr_eq(r, null); 2421 ck_assert_int_eq(lenO(self), 1); 2422 char *s = toStringO(self); 2423 ck_assert_str_eq(s, "[1]"); 2424 free(s); 2425 2426 char *str = "poi"; 2427 r = self->f->prependS(self, str); 2428 ck_assert_ptr_ne(r, null); 2429 ck_assert_int_eq(lenO(self), 2); 2430 s = toStringO(r); 2431 ck_assert_str_eq(s, "[\"poi\",1]"); 2432 free(s); 2433 2434 terminateO(self); 2435 2436 } 2437 2438 2439 void prependCharSmallArrayT(void) { 2440 2441 smallArrayt* r; 2442 smallArrayt *self = allocG(rtSmallArrayt); 2443 2444 // add an element to check that push adds the second element 2445 // at the end 2446 r = self->f->pushInt(self, 1); 2447 ck_assert_ptr_ne(r, null); 2448 2449 r = self->f->prependChar(self, 'a'); 2450 ck_assert_ptr_ne(r, null); 2451 ck_assert_int_eq(lenO(r), 2); 2452 char *s = toStringO(r); 2453 ck_assert_str_eq(s, "[\"a\",1]"); 2454 free(s); 2455 terminateO(self); 2456 2457 } 2458 2459 2460 void prependDictSmallArrayT(void) { 2461 2462 smallArrayt* r; 2463 smallArrayt *self = allocG(rtSmallArrayt); 2464 smallDictt *dict = allocG(rtSmallDictt); 2465 2466 // add an element to check that push adds the second element 2467 // at the end 2468 r = self->f->pushInt(self, 1); 2469 ck_assert_ptr_ne(r, null); 2470 2471 // push dict 2472 r = self->f->prependDict(self, dict); 2473 ck_assert_ptr_ne(r, null); 2474 ck_assert_int_eq(lenO(r), 2); 2475 finishO(dict); 2476 ck_assert_ptr_ne(r, null); 2477 char *s = toStringO(r); 2478 ck_assert_str_eq(s, "[{},1]"); 2479 free(s); 2480 // non smallDict object 2481 dict = (smallDictt*) allocSmallInt(2); 2482 r = self->f->prependDict(self, dict); 2483 ck_assert_ptr_eq(r, null); 2484 terminateO(dict); 2485 // null 2486 r = self->f->prependDict(self, null); 2487 ck_assert_ptr_eq(r, null); 2488 ck_assert_int_eq(lenO(self), 2); 2489 s = toStringO(self); 2490 ck_assert_str_eq(s, "[{},1]"); 2491 free(s); 2492 terminateO(self); 2493 2494 } 2495 2496 2497 void prependArraySmallArrayT(void) { 2498 2499 smallArrayt* r; 2500 smallArrayt *self = allocG(rtSmallArrayt); 2501 smallArrayt *array = allocG(rtSmallArrayt); 2502 2503 // add an element to check that push adds the second element 2504 // at the end 2505 r = self->f->pushInt(self, 1); 2506 ck_assert_ptr_ne(r, null); 2507 2508 r = self->f->prependArray(self, array); 2509 ck_assert_ptr_ne(r, null); 2510 ck_assert_int_eq(lenO(r), 2); 2511 finishO(array); 2512 char *s = toStringO(r); 2513 ck_assert_str_eq(s, "[[],1]"); 2514 free(s); 2515 // non smallArray object 2516 array = (smallArrayt*) allocSmallInt(2); 2517 r = self->f->prependArray(self, array); 2518 ck_assert_ptr_eq(r, null); 2519 terminateO(array); 2520 // null 2521 r = self->f->prependArray(self, null); 2522 ck_assert_ptr_eq(r, null); 2523 ck_assert_int_eq(lenO(self), 2); 2524 s = toStringO(self); 2525 ck_assert_str_eq(s, "[[],1]"); 2526 free(s); 2527 terminateO(self); 2528 2529 } 2530 2531 2532 void prependArraycSmallArrayT(void) { 2533 2534 smallArrayt* r; 2535 smallArrayt *self = allocG(rtSmallArrayt); 2536 char **array = listCreateS("a","bb"); 2537 2538 // add an element to check that push adds the second element 2539 // at the end 2540 r = self->f->pushInt(self, 1); 2541 ck_assert_ptr_ne(r, null); 2542 2543 r = self->f->prependArrayc(self, array); 2544 ck_assert_ptr_ne(r, null); 2545 ck_assert_int_eq(lenO(r), 2); 2546 listFreeS(array); 2547 char *s = toStringO(r); 2548 ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]"); 2549 free(s); 2550 // null 2551 r = self->f->prependArrayc(self, null); 2552 ck_assert_ptr_eq(r, null); 2553 ck_assert_int_eq(lenO(self), 2); 2554 s = toStringO(self); 2555 ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]"); 2556 free(s); 2557 terminateO(self); 2558 2559 } 2560 2561 2562 void prependSmallBoolSmallArrayT(void) { 2563 2564 smallArrayt* r; 2565 smallArrayt *self = allocG(rtSmallArrayt); 2566 smallBoolt *value = allocG(TRUE); 2567 2568 // add an element to check that push adds the second element 2569 // at the end 2570 r = self->f->pushInt(self, 1); 2571 ck_assert_ptr_ne(r, null); 2572 2573 r = self->f->prependSmallBool(self, value); 2574 ck_assert_ptr_ne(r, null); 2575 ck_assert_int_eq(lenO(r), 2); 2576 finishO(value); 2577 char *s = toStringO(r); 2578 ck_assert_str_eq(s, "[true,1]"); 2579 free(s); 2580 // bool object with no data 2581 createAllocateSmallBool(b); 2582 r = self->f->prependSmallBool(self, b); 2583 ck_assert_ptr_ne(r, null); 2584 ck_assert_int_eq(lenO(r), 3); 2585 finishO(b); 2586 s = toStringO(r); 2587 ck_assert_str_eq(s, "[false,true,1]"); 2588 free(s); 2589 // non smallBool object 2590 value = (smallBoolt*) allocSmallInt(2); 2591 r = self->f->prependSmallBool(self, value); 2592 ck_assert_ptr_eq(r, null); 2593 terminateO(value); 2594 // null 2595 r = self->f->prependSmallBool(self, null); 2596 ck_assert_ptr_eq(r, null); 2597 ck_assert_int_eq(lenO(self), 3); 2598 s = toStringO(self); 2599 ck_assert_str_eq(s, "[false,true,1]"); 2600 free(s); 2601 terminateO(self); 2602 2603 } 2604 2605 2606 void prependSmallBytesSmallArrayT(void) { 2607 2608 smallArrayt* r; 2609 smallArrayt *self = allocG(rtSmallArrayt); 2610 createAllocateSmallBytes(value); 2611 2612 // add an element to check that push adds the second element 2613 // at the end 2614 r = self->f->pushInt(self, 1); 2615 ck_assert_ptr_ne(r, null); 2616 2617 // the smallBytes container is empty 2618 r = self->f->prependSmallBytes(self, value); 2619 ck_assert_ptr_ne(r, null); 2620 ck_assert_int_eq(lenO(r), 2); 2621 char *s = toStringO(r); 2622 ck_assert_str_eq(s, "[[],1]"); 2623 free(s); 2624 // reuse value 2625 value->B = null; 2626 char *buffer = "poi"; 2627 pushBufferO(value, buffer, strlen(buffer)); 2628 r = self->f->prependSmallBytes(self, value); 2629 finishO(value); 2630 ck_assert_ptr_ne(r, null); 2631 ck_assert_int_eq(lenO(r), 3); 2632 s = toStringO(r); 2633 ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]"); 2634 free(s); 2635 // non smallBytes object 2636 value = (smallBytest*) allocSmallInt(2); 2637 r = self->f->prependSmallBytes(self, value); 2638 ck_assert_ptr_eq(r, null); 2639 terminateO(value); 2640 // null 2641 r = self->f->prependSmallBytes(self, null); 2642 ck_assert_ptr_eq(r, null); 2643 ck_assert_int_eq(lenO(self), 3); 2644 s = toStringO(self); 2645 ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]"); 2646 free(s); 2647 terminateO(self); 2648 2649 } 2650 2651 2652 void prependSmallDoubleSmallArrayT(void) { 2653 2654 smallArrayt* r; 2655 smallArrayt *self = allocG(rtSmallArrayt); 2656 smallDoublet *value = allocG(1.0); 2657 2658 // add an element to check that push adds the second element 2659 // at the end 2660 r = self->f->pushInt(self, 1); 2661 ck_assert_ptr_ne(r, null); 2662 2663 r = self->f->prependSmallDouble(self, value); 2664 ck_assert_ptr_ne(r, null); 2665 ck_assert_int_eq(lenO(r), 2); 2666 finishO(value); 2667 char *s = toStringO(r); 2668 ck_assert_str_eq(s, "[1.000000e+00,1]"); 2669 free(s); 2670 // object with no data 2671 createAllocateSmallDouble(b); 2672 r = self->f->prependSmallDouble(self, b); 2673 ck_assert_ptr_ne(r, null); 2674 ck_assert_int_eq(lenO(r), 3); 2675 finishO(b); 2676 s = toStringO(r); 2677 ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]"); 2678 free(s); 2679 // non smallDouble object 2680 value = (smallDoublet*) allocSmallInt(2); 2681 r = self->f->prependSmallDouble(self, value); 2682 ck_assert_ptr_eq(r, null); 2683 terminateO(value); 2684 // null 2685 r = self->f->prependSmallDouble(self, null); 2686 ck_assert_ptr_eq(r, null); 2687 ck_assert_int_eq(lenO(self), 3); 2688 s = toStringO(self); 2689 ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]"); 2690 free(s); 2691 terminateO(self); 2692 2693 } 2694 2695 2696 void prependSmallIntSmallArrayT(void) { 2697 2698 smallArrayt* r; 2699 smallArrayt *self = allocG(rtSmallArrayt); 2700 smallIntt *value = allocG(1); 2701 2702 // add an element to check that push adds the second element 2703 // at the end 2704 r = self->f->pushInt(self, 1); 2705 ck_assert_ptr_ne(r, null); 2706 2707 r = self->f->prependSmallInt(self, value); 2708 ck_assert_ptr_ne(r, null); 2709 ck_assert_int_eq(lenO(r), 2); 2710 finishO(value); 2711 char *s = toStringO(r); 2712 ck_assert_str_eq(s, "[1,1]"); 2713 free(s); 2714 // bool object with no data 2715 createAllocateSmallInt(b); 2716 r = self->f->prependSmallInt(self, b); 2717 ck_assert_ptr_ne(r, null); 2718 ck_assert_int_eq(lenO(r), 3); 2719 finishO(b); 2720 s = toStringO(r); 2721 ck_assert_str_eq(s, "[0,1,1]"); 2722 free(s); 2723 // non smallInt object 2724 value = (smallIntt*) allocSmallBool(true); 2725 r = self->f->prependSmallInt(self, value); 2726 ck_assert_ptr_eq(r, null); 2727 terminateO(value); 2728 // null 2729 r = self->f->prependSmallInt(self, null); 2730 ck_assert_ptr_eq(r, null); 2731 ck_assert_int_eq(lenO(self), 3); 2732 s = toStringO(self); 2733 ck_assert_str_eq(s, "[0,1,1]"); 2734 free(s); 2735 terminateO(self); 2736 2737 } 2738 2739 2740 void prependSmallJsonSmallArrayT(void) { 2741 2742 smallArrayt* r; 2743 smallArrayt *self = allocG(rtSmallArrayt); 2744 smallJsont *value = allocG(rtSmallJsont); 2745 2746 // add an element to check that push adds the second element 2747 // at the end 2748 r = self->f->pushInt(self, 1); 2749 ck_assert_ptr_ne(r, null); 2750 2751 // the smallJson container is empty 2752 r = self->f->prependSmallJson(self, value); 2753 ck_assert_ptr_ne(r, null); 2754 ck_assert_int_eq(lenO(r), 2); 2755 char *s = toStringO(r); 2756 ck_assert_str_eq(s, "[{},1]"); 2757 free(s); 2758 resetO(value); 2759 parseO(value, "{}"); 2760 r = self->f->prependSmallJson(self, value); 2761 finishO(value); 2762 ck_assert_ptr_ne(r, null); 2763 ck_assert_int_eq(lenO(r), 3); 2764 s = toStringO(r); 2765 ck_assert_str_eq(s, "[{},{},1]"); 2766 free(s); 2767 // non smallJson object 2768 value = (smallJsont*) allocSmallInt(2); 2769 r = self->f->prependSmallJson(self, value); 2770 ck_assert_ptr_eq(r, null); 2771 terminateO(value); 2772 // null 2773 r = self->f->prependSmallJson(self, null); 2774 ck_assert_ptr_eq(r, null); 2775 ck_assert_int_eq(lenO(self), 3); 2776 s = toStringO(self); 2777 ck_assert_str_eq(s, "[{},{},1]"); 2778 free(s); 2779 terminateO(self); 2780 2781 } 2782 2783 2784 void prependSmallStringSmallArrayT(void) { 2785 2786 smallArrayt* r; 2787 smallArrayt *self = allocG(rtSmallArrayt); 2788 createAllocateSmallString(string); 2789 2790 // add an element to check that push adds the second element 2791 // at the end 2792 r = self->f->pushInt(self, 1); 2793 ck_assert_ptr_ne(r, null); 2794 2795 r = self->f->prependSmallString(self, string); 2796 ck_assert_ptr_ne(r, null); 2797 ck_assert_int_eq(lenO(r), 2); 2798 finishO(string); 2799 char *s = toStringO(r); 2800 ck_assert_str_eq(s, "[\"\",1]"); 2801 free(s); 2802 // non smallString object 2803 string = (smallStringt*) allocSmallInt(2); 2804 r = self->f->prependSmallString(self, string); 2805 ck_assert_ptr_eq(r, null); 2806 terminateO(string); 2807 // null 2808 r = self->f->prependSmallString(self, null); 2809 ck_assert_ptr_eq(r, null); 2810 ck_assert_int_eq(lenO(self), 2); 2811 s = toStringO(self); 2812 ck_assert_str_eq(s, "[\"\",1]"); 2813 free(s); 2814 terminateO(self); 2815 2816 } 2817 2818 2819 void prependSmallContainerSmallArrayT(void) { 2820 2821 smallArrayt* r; 2822 smallArrayt *self = allocG(rtSmallArrayt); 2823 createAllocateSmallContainer(container); 2824 2825 // add an element to check that push adds the second element 2826 // at the end 2827 r = self->f->pushInt(self, 1); 2828 ck_assert_ptr_ne(r, null); 2829 2830 r = self->f->prependSmallContainer(self, container); 2831 ck_assert_ptr_ne(r, null); 2832 ck_assert_int_eq(lenO(r), 2); 2833 finishO(container); 2834 char *s = toStringO(r); 2835 ck_assert_str_eq(s, "[\"<data container>\",1]"); 2836 free(s); 2837 // non smallContainer object 2838 container = (smallContainert*) allocSmallInt(2); 2839 r = self->f->prependSmallContainer(self, container); 2840 ck_assert_ptr_eq(r, null); 2841 terminateO(container); 2842 // null 2843 r = self->f->prependSmallContainer(self, null); 2844 ck_assert_ptr_eq(r, null); 2845 ck_assert_int_eq(lenO(self), 2); 2846 s = toStringO(self); 2847 ck_assert_str_eq(s, "[\"<data container>\",1]"); 2848 free(s); 2849 terminateO(self); 2850 2851 } 2852 2853 2854 void prependNFreeSmallArrayT(void) { 2855 2856 smallArrayt* r; 2857 smallArrayt *self = allocG(rtSmallArrayt); 2858 baset *value = (baset*) allocG(2); 2859 2860 // add an element to check that prepend adds the second element 2861 // at the start 2862 r = self->f->pushInt(self, 1); 2863 ck_assert_ptr_ne(r, null); 2864 2865 r = self->f->prependNFree(self, value); 2866 ck_assert_ptr_ne(r, null); 2867 ck_assert_int_eq(lenO(r), 2); 2868 char *s = toStringO(r); 2869 ck_assert_str_eq(s, "[2,1]"); 2870 free(s); 2871 // null 2872 r = self->f->prependNFree(self, null); 2873 ck_assert_ptr_eq(r, null); 2874 ck_assert_int_eq(lenO(self), 2); 2875 s = toStringO(self); 2876 ck_assert_str_eq(s, "[2,1]"); 2877 free(s); 2878 2879 //r = prependO(self); 2880 terminateO(self); 2881 2882 } 2883 2884 2885 void prependNFreeUndefinedSmallArrayT(void) { 2886 2887 smallArrayt* r; 2888 smallArrayt *self = allocG(rtSmallArrayt); 2889 2890 // add an element to check that push adds the second element 2891 // at the end 2892 r = self->f->pushInt(self, 1); 2893 ck_assert_ptr_ne(r, null); 2894 2895 createAllocateUndefined(value); 2896 r = self->f->prependNFreeUndefined(self, value); 2897 ck_assert_ptr_ne(r, null); 2898 ck_assert_int_eq(lenO(r), 2); 2899 char *s = toStringO(r); 2900 ck_assert_str_eq(s, "[null,1]"); 2901 free(s); 2902 terminateO(self); 2903 2904 } 2905 2906 2907 void prependNFreeSSmallArrayT(void) { 2908 2909 smallArrayt* r; 2910 smallArrayt *self = allocG(rtSmallArrayt); 2911 2912 // add an element to check that push adds the second element 2913 // at the end 2914 r = self->f->pushInt(self, 1); 2915 ck_assert_ptr_ne(r, null); 2916 2917 r = self->f->prependNFreeS(self, null); 2918 ck_assert_ptr_eq(r, null); 2919 ck_assert_int_eq(lenO(self), 1); 2920 char *s = toStringO(self); 2921 ck_assert_str_eq(s, "[1]"); 2922 free(s); 2923 2924 char *str = strdup("poi"); 2925 r = self->f->prependNFreeS(self, str); 2926 ck_assert_ptr_ne(r, null); 2927 ck_assert_int_eq(lenO(self), 2); 2928 s = toStringO(r); 2929 ck_assert_str_eq(s, "[\"poi\",1]"); 2930 free(s); 2931 2932 terminateO(self); 2933 2934 } 2935 2936 2937 void prependNFreeDictSmallArrayT(void) { 2938 2939 smallArrayt* r; 2940 smallArrayt *self = allocG(rtSmallArrayt); 2941 smallDictt *dict = allocG(rtSmallDictt); 2942 2943 // add an element to check that push adds the second element 2944 // at the end 2945 r = self->f->pushInt(self, 1); 2946 ck_assert_ptr_ne(r, null); 2947 2948 // push dict 2949 r = self->f->prependNFreeDict(self, dict); 2950 ck_assert_ptr_ne(r, null); 2951 ck_assert_int_eq(lenO(r), 2); 2952 ck_assert_ptr_ne(r, null); 2953 char *s = toStringO(r); 2954 ck_assert_str_eq(s, "[{},1]"); 2955 free(s); 2956 // null 2957 r = self->f->prependNFreeDict(self, null); 2958 ck_assert_ptr_eq(r, null); 2959 ck_assert_int_eq(lenO(self), 2); 2960 s = toStringO(self); 2961 ck_assert_str_eq(s, "[{},1]"); 2962 free(s); 2963 terminateO(self); 2964 2965 } 2966 2967 2968 void prependNFreeArraySmallArrayT(void) { 2969 2970 smallArrayt* r; 2971 smallArrayt *self = allocG(rtSmallArrayt); 2972 smallArrayt *array = allocG(rtSmallArrayt); 2973 2974 // add an element to check that push adds the second element 2975 // at the end 2976 r = self->f->pushInt(self, 1); 2977 ck_assert_ptr_ne(r, null); 2978 2979 r = self->f->prependNFreeArray(self, array); 2980 ck_assert_ptr_ne(r, null); 2981 ck_assert_int_eq(lenO(r), 2); 2982 char *s = toStringO(r); 2983 ck_assert_str_eq(s, "[[],1]"); 2984 free(s); 2985 // null 2986 r = self->f->prependNFreeArray(self, null); 2987 ck_assert_ptr_eq(r, null); 2988 ck_assert_int_eq(lenO(self), 2); 2989 s = toStringO(self); 2990 ck_assert_str_eq(s, "[[],1]"); 2991 free(s); 2992 terminateO(self); 2993 2994 } 2995 2996 2997 void prependNFreeArraycSmallArrayT(void) { 2998 2999 smallArrayt* r; 3000 smallArrayt *self = allocG(rtSmallArrayt); 3001 char **array = listCreateS("a","bb"); 3002 3003 // add an element to check that push adds the second element 3004 // at the end 3005 r = self->f->pushInt(self, 1); 3006 ck_assert_ptr_ne(r, null); 3007 3008 r = self->f->prependNFreeArrayc(self, array); 3009 ck_assert_ptr_ne(r, null); 3010 ck_assert_int_eq(lenO(r), 2); 3011 char *s = toStringO(r); 3012 ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]"); 3013 free(s); 3014 // null 3015 r = self->f->prependNFreeArrayc(self, null); 3016 ck_assert_ptr_eq(r, null); 3017 ck_assert_int_eq(lenO(self), 2); 3018 s = toStringO(self); 3019 ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]"); 3020 free(s); 3021 terminateO(self); 3022 3023 } 3024 3025 3026 void prependNFreeSmallBoolSmallArrayT(void) { 3027 3028 smallArrayt* r; 3029 smallArrayt *self = allocG(rtSmallArrayt); 3030 smallBoolt *value = allocG(TRUE); 3031 3032 // add an element to check that push adds the second element 3033 // at the end 3034 r = self->f->pushInt(self, 1); 3035 ck_assert_ptr_ne(r, null); 3036 3037 r = self->f->prependNFreeSmallBool(self, value); 3038 ck_assert_ptr_ne(r, null); 3039 ck_assert_int_eq(lenO(r), 2); 3040 char *s = toStringO(r); 3041 ck_assert_str_eq(s, "[true,1]"); 3042 free(s); 3043 // bool object with no data 3044 createAllocateSmallBool(b); 3045 r = self->f->prependNFreeSmallBool(self, b); 3046 ck_assert_ptr_ne(r, null); 3047 ck_assert_int_eq(lenO(r), 3); 3048 s = toStringO(r); 3049 ck_assert_str_eq(s, "[false,true,1]"); 3050 free(s); 3051 // null 3052 r = self->f->prependNFreeSmallBool(self, null); 3053 ck_assert_ptr_eq(r, null); 3054 ck_assert_int_eq(lenO(self), 3); 3055 s = toStringO(self); 3056 ck_assert_str_eq(s, "[false,true,1]"); 3057 free(s); 3058 terminateO(self); 3059 3060 } 3061 3062 3063 void prependNFreeSmallBytesSmallArrayT(void) { 3064 3065 smallArrayt* r; 3066 smallArrayt *self = allocG(rtSmallArrayt); 3067 createAllocateSmallBytes(value); 3068 3069 // add an element to check that push adds the second element 3070 // at the end 3071 r = self->f->pushInt(self, 1); 3072 ck_assert_ptr_ne(r, null); 3073 3074 // the smallBytes container is empty 3075 r = self->f->prependNFreeSmallBytes(self, value); 3076 ck_assert_ptr_ne(r, null); 3077 ck_assert_int_eq(lenO(r), 2); 3078 char *s = toStringO(r); 3079 ck_assert_str_eq(s, "[[],1]"); 3080 free(s); 3081 3082 char *buffer = "poi"; 3083 value = allocSmallBytes(buffer, strlen(buffer)); 3084 r = self->f->prependNFreeSmallBytes(self, value); 3085 ck_assert_ptr_ne(r, null); 3086 ck_assert_int_eq(lenO(r), 3); 3087 s = toStringO(r); 3088 ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]"); 3089 free(s); 3090 // null 3091 r = self->f->prependNFreeSmallBytes(self, null); 3092 ck_assert_ptr_eq(r, null); 3093 ck_assert_int_eq(lenO(self), 3); 3094 s = toStringO(self); 3095 ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]"); 3096 free(s); 3097 terminateO(self); 3098 3099 } 3100 3101 3102 void prependNFreeSmallDoubleSmallArrayT(void) { 3103 3104 smallArrayt* r; 3105 smallArrayt *self = allocG(rtSmallArrayt); 3106 smallDoublet *value = allocG(1.0); 3107 3108 // add an element to check that push adds the second element 3109 // at the end 3110 r = self->f->pushInt(self, 1); 3111 ck_assert_ptr_ne(r, null); 3112 3113 r = self->f->prependNFreeSmallDouble(self, value); 3114 ck_assert_ptr_ne(r, null); 3115 ck_assert_int_eq(lenO(r), 2); 3116 char *s = toStringO(r); 3117 ck_assert_str_eq(s, "[1.000000e+00,1]"); 3118 free(s); 3119 // object with no data 3120 createAllocateSmallDouble(b); 3121 r = self->f->prependNFreeSmallDouble(self, b); 3122 ck_assert_ptr_ne(r, null); 3123 ck_assert_int_eq(lenO(r), 3); 3124 s = toStringO(r); 3125 ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]"); 3126 free(s); 3127 // null 3128 r = self->f->prependNFreeSmallDouble(self, null); 3129 ck_assert_ptr_eq(r, null); 3130 ck_assert_int_eq(lenO(self), 3); 3131 s = toStringO(self); 3132 ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]"); 3133 free(s); 3134 terminateO(self); 3135 3136 } 3137 3138 3139 void prependNFreeSmallIntSmallArrayT(void) { 3140 3141 smallArrayt* r; 3142 smallArrayt *self = allocG(rtSmallArrayt); 3143 smallIntt *value = allocG(1); 3144 3145 // add an element to check that push adds the second element 3146 // at the end 3147 r = self->f->pushInt(self, 1); 3148 ck_assert_ptr_ne(r, null); 3149 3150 r = self->f->prependNFreeSmallInt(self, value); 3151 ck_assert_ptr_ne(r, null); 3152 ck_assert_int_eq(lenO(r), 2); 3153 char *s = toStringO(r); 3154 ck_assert_str_eq(s, "[1,1]"); 3155 free(s); 3156 // bool object with no data 3157 createAllocateSmallInt(b); 3158 r = self->f->prependNFreeSmallInt(self, b); 3159 ck_assert_ptr_ne(r, null); 3160 ck_assert_int_eq(lenO(r), 3); 3161 s = toStringO(r); 3162 ck_assert_str_eq(s, "[0,1,1]"); 3163 free(s); 3164 // null 3165 r = self->f->prependNFreeSmallInt(self, null); 3166 ck_assert_ptr_eq(r, null); 3167 ck_assert_int_eq(lenO(self), 3); 3168 s = toStringO(self); 3169 ck_assert_str_eq(s, "[0,1,1]"); 3170 free(s); 3171 terminateO(self); 3172 3173 } 3174 3175 3176 void prependNFreeSmallJsonSmallArrayT(void) { 3177 3178 smallArrayt* r; 3179 smallArrayt *self = allocG(rtSmallArrayt); 3180 smallJsont *value = allocG(rtSmallJsont); 3181 3182 // add an element to check that push adds the second element 3183 // at the end 3184 r = self->f->pushInt(self, 1); 3185 ck_assert_ptr_ne(r, null); 3186 3187 // the smallJson container is empty 3188 r = self->f->prependNFreeSmallJson(self, value); 3189 ck_assert_ptr_ne(r, null); 3190 ck_assert_int_eq(lenO(r), 2); 3191 char *s = toStringO(r); 3192 ck_assert_str_eq(s, "[{},1]"); 3193 free(s); 3194 3195 value = allocG(rtSmallJsont); 3196 parseO(value, "{}"); 3197 r = self->f->prependNFreeSmallJson(self, value); 3198 ck_assert_ptr_ne(r, null); 3199 ck_assert_int_eq(lenO(r), 3); 3200 s = toStringO(r); 3201 ck_assert_str_eq(s, "[{},{},1]"); 3202 free(s); 3203 // null 3204 r = self->f->prependNFreeSmallJson(self, null); 3205 ck_assert_ptr_eq(r, null); 3206 ck_assert_int_eq(lenO(self), 3); 3207 s = toStringO(self); 3208 ck_assert_str_eq(s, "[{},{},1]"); 3209 free(s); 3210 terminateO(self); 3211 3212 } 3213 3214 3215 void prependNFreeSmallStringSmallArrayT(void) { 3216 3217 smallArrayt* r; 3218 smallArrayt *self = allocG(rtSmallArrayt); 3219 createAllocateSmallString(string); 3220 3221 // add an element to check that push adds the second element 3222 // at the end 3223 r = self->f->pushInt(self, 1); 3224 ck_assert_ptr_ne(r, null); 3225 3226 r = self->f->prependNFreeSmallString(self, string); 3227 ck_assert_ptr_ne(r, null); 3228 ck_assert_int_eq(lenO(r), 2); 3229 char *s = toStringO(r); 3230 ck_assert_str_eq(s, "[\"\",1]"); 3231 free(s); 3232 // null 3233 r = self->f->prependNFreeSmallString(self, null); 3234 ck_assert_ptr_eq(r, null); 3235 ck_assert_int_eq(lenO(self), 2); 3236 s = toStringO(self); 3237 ck_assert_str_eq(s, "[\"\",1]"); 3238 free(s); 3239 terminateO(self); 3240 3241 } 3242 3243 3244 void prependNFreeSmallContainerSmallArrayT(void) { 3245 3246 smallArrayt* r; 3247 smallArrayt *self = allocG(rtSmallArrayt); 3248 createAllocateSmallContainer(container); 3249 3250 // add an element to check that push adds the second element 3251 // at the end 3252 r = self->f->pushInt(self, 1); 3253 ck_assert_ptr_ne(r, null); 3254 3255 r = self->f->prependNFreeSmallContainer(self, container); 3256 ck_assert_ptr_ne(r, null); 3257 ck_assert_int_eq(lenO(r), 2); 3258 char *s = toStringO(r); 3259 ck_assert_str_eq(s, "[\"<data container>\",1]"); 3260 free(s); 3261 // null 3262 r = self->f->prependNFreeSmallContainer(self, null); 3263 ck_assert_ptr_eq(r, null); 3264 ck_assert_int_eq(lenO(self), 2); 3265 s = toStringO(self); 3266 ck_assert_str_eq(s, "[\"<data container>\",1]"); 3267 free(s); 3268 terminateO(self); 3269 3270 } 3271 3272 3273 void dequeueSmallArrayT(void) { 3274 3275 baset* r; 3276 smallArrayt *self = allocG(rtSmallArrayt); 3277 smallArrayt *r2; 3278 3279 // add an element to check that the second element is dequeueed 3280 // at the end 3281 r2 = self->f->prependInt(self, 1); 3282 ck_assert_ptr_ne(r2, null); 3283 // prepend a base object of unknown type 3284 smallIntt *o = allocSmallInt(2); 3285 o->type = "newType"; 3286 r2 = self->f->prependNFree(self, (baset*)o); 3287 ck_assert_ptr_ne(r2, null); 3288 r2 = self->f->prependUndefined(self); 3289 ck_assert_ptr_ne(r2, null); 3290 r = self->f->dequeue(self); 3291 ck_assert_ptr_ne(r, null); 3292 ck_assert(isOUndefined(r)); 3293 terminateO(r); 3294 r = self->f->dequeue(self); 3295 ck_assert_ptr_ne(r, null); 3296 ck_assert_str_eq(r->type, "newType"); 3297 char *s = toStringO(r); 3298 terminateO(r); 3299 ck_assert_str_eq(s, "2"); 3300 free(s); 3301 ck_assert_int_eq(lenO(self), 1); 3302 s = toStringO(self); 3303 ck_assert_str_eq(s, "[1]"); 3304 free(s); 3305 // empty array 3306 r = self->f->dequeue(self); 3307 ck_assert_ptr_ne(r, null); 3308 terminateO(r); 3309 s = toStringO(self); 3310 ck_assert_str_eq(s, "[]"); 3311 free(s); 3312 r = self->f->dequeue(self); 3313 ck_assert_ptr_eq(r, null); 3314 s = toStringO(self); 3315 ck_assert_str_eq(s, "[]"); 3316 free(s); 3317 r2 = self->f->pushUndefined(self); 3318 ck_assert_ptr_ne(r2, null); 3319 delElemO(self,-1); 3320 r = self->f->dequeue(self); 3321 ck_assert_ptr_eq(r, null); 3322 terminateO(self); 3323 3324 } 3325 3326 3327 void dequeueUndefinedSmallArrayT(void) { 3328 3329 undefinedt* r; 3330 smallArrayt *self = allocG(rtSmallArrayt); 3331 smallArrayt *r2; 3332 baset *r3; 3333 3334 // add an element to check that the second element is poped 3335 // at the end 3336 r2 = self->f->pushInt(self, 1); 3337 ck_assert_ptr_ne(r2, null); 3338 // add second element 3339 r2 = self->f->prependUndefined(self); 3340 ck_assert_ptr_ne(r2, null); 3341 // pop 3342 r = self->f->dequeueUndefined(self); 3343 ck_assert_ptr_ne(r, null); 3344 char *s = toStringO(r); 3345 terminateO(r); 3346 ck_assert_str_eq(s, "null"); 3347 free(s); 3348 ck_assert_int_eq(lenO(self), 1); 3349 s = toStringO(self); 3350 ck_assert_str_eq(s, "[1]"); 3351 free(s); 3352 // pop element of unexpected type 3353 r = self->f->dequeueUndefined(self); 3354 ck_assert_ptr_eq(r, null); 3355 ck_assert_int_eq(lenO(self), 1); 3356 s = toStringO(self); 3357 ck_assert_str_eq(s, "[1]"); 3358 free(s); 3359 // empty array 3360 r3 = self->f->pop(self); 3361 ck_assert_ptr_ne(r3, null); 3362 terminateO(r3); 3363 s = toStringO(self); 3364 ck_assert_str_eq(s, "[]"); 3365 free(s); 3366 r = self->f->dequeueUndefined(self); 3367 ck_assert_ptr_eq(r, null); 3368 s = toStringO(self); 3369 ck_assert_str_eq(s, "[]"); 3370 free(s); 3371 r2 = self->f->pushUndefined(self); 3372 ck_assert_ptr_ne(r2, null); 3373 delElemO(self,-1); 3374 r = self->f->dequeueUndefined(self); 3375 ck_assert_ptr_eq(r, null); 3376 terminateO(self); 3377 3378 } 3379 3380 3381 void dequeueBoolSmallArrayT(void) { 3382 3383 bool r; 3384 smallArrayt *self = allocG(rtSmallArrayt); 3385 smallArrayt *r2; 3386 baset *r3; 3387 3388 // add an element to check that the second element is poped 3389 // at the end 3390 r2 = self->f->pushInt(self, 1); 3391 ck_assert_ptr_ne(r2, null); 3392 3393 // add second element 3394 r2 = self->f->prependBool(self, TRUE); 3395 ck_assert_ptr_ne(r2, null); 3396 3397 // pop 3398 r = self->f->dequeueBool(self); 3399 ck_assert(r); 3400 ck_assert_int_eq(lenO(self), 1); 3401 char *s = toStringO(self); 3402 ck_assert_str_eq(s, "[1]"); 3403 free(s); 3404 3405 // pop element of unexpected type 3406 r = self->f->dequeueBool(self); 3407 ck_assert(!r); 3408 ck_assert_int_eq(lenO(self), 1); 3409 s = toStringO(self); 3410 ck_assert_str_eq(s, "[1]"); 3411 free(s); 3412 3413 // empty array 3414 r3 = self->f->pop(self); 3415 ck_assert_ptr_ne(r3, null); 3416 terminateO(r3); 3417 s = toStringO(self); 3418 ck_assert_str_eq(s, "[]"); 3419 free(s); 3420 r = self->f->dequeueBool(self); 3421 ck_assert(!r); 3422 s = toStringO(self); 3423 ck_assert_str_eq(s, "[]"); 3424 free(s); 3425 terminateO(self); 3426 3427 } 3428 3429 3430 void dequeueDoubleSmallArrayT(void) { 3431 3432 double r; 3433 smallArrayt *self = allocG(rtSmallArrayt); 3434 smallArrayt *r2; 3435 baset *r3; 3436 3437 // add an element to check that the second element is poped 3438 // at the end 3439 r2 = self->f->pushInt(self, 1); 3440 ck_assert_ptr_ne(r2, null); 3441 3442 // add second element 3443 r2 = self->f->prependDouble(self, 2.0); 3444 ck_assert_ptr_ne(r2, null); 3445 3446 // pop 3447 r = self->f->dequeueDouble(self); 3448 ck_assert(r==2.0); 3449 ck_assert_int_eq(lenO(self), 1); 3450 char *s = toStringO(self); 3451 ck_assert_str_eq(s, "[1]"); 3452 free(s); 3453 3454 // pop element of unexpected type 3455 r = self->f->dequeueDouble(self); 3456 ck_assert(!r); 3457 ck_assert_int_eq(lenO(self), 1); 3458 s = toStringO(self); 3459 ck_assert_str_eq(s, "[1]"); 3460 free(s); 3461 3462 // empty array 3463 r3 = self->f->pop(self); 3464 ck_assert_ptr_ne(r3, null); 3465 terminateO(r3); 3466 s = toStringO(self); 3467 ck_assert_str_eq(s, "[]"); 3468 free(s); 3469 r = self->f->dequeueDouble(self); 3470 ck_assert(!r); 3471 s = toStringO(self); 3472 ck_assert_str_eq(s, "[]"); 3473 free(s); 3474 terminateO(self); 3475 3476 } 3477 3478 3479 void dequeueIntSmallArrayT(void) { 3480 3481 int64_t r; 3482 smallArrayt *self = allocG(rtSmallArrayt); 3483 smallArrayt *r2; 3484 baset *r3; 3485 3486 // add an element to check that the second element is poped 3487 // at the end 3488 r2 = self->f->pushBool(self, FALSE); 3489 ck_assert_ptr_ne(r2, null); 3490 3491 // add second element 3492 r2 = self->f->prependInt(self, 2); 3493 ck_assert_ptr_ne(r2, null); 3494 3495 // pop 3496 r = self->f->dequeueInt(self); 3497 ck_assert_int_eq(r, 2); 3498 ck_assert_int_eq(lenO(self), 1); 3499 char *s = toStringO(self); 3500 ck_assert_str_eq(s, "[false]"); 3501 free(s); 3502 3503 // pop element of unexpected type 3504 r = self->f->dequeueInt(self); 3505 ck_assert(!r); 3506 ck_assert_int_eq(lenO(self), 1); 3507 s = toStringO(self); 3508 ck_assert_str_eq(s, "[false]"); 3509 free(s); 3510 3511 // empty array 3512 r3 = self->f->pop(self); 3513 ck_assert_ptr_ne(r3, null); 3514 terminateO(r3); 3515 s = toStringO(self); 3516 ck_assert_str_eq(s, "[]"); 3517 free(s); 3518 r = self->f->dequeueInt(self); 3519 ck_assert(!r); 3520 s = toStringO(self); 3521 ck_assert_str_eq(s, "[]"); 3522 free(s); 3523 terminateO(self); 3524 3525 } 3526 3527 3528 void dequeueInt32SmallArrayT(void) { 3529 3530 int32_t r; 3531 smallArrayt *self = allocG(rtSmallArrayt); 3532 smallArrayt *r2; 3533 baset *r3; 3534 3535 // add an element to check that the second element is poped 3536 // at the end 3537 r2 = self->f->pushBool(self, FALSE); 3538 ck_assert_ptr_ne(r2, null); 3539 3540 // add second element 3541 r2 = self->f->prependInt(self, 2); 3542 ck_assert_ptr_ne(r2, null); 3543 3544 // pop 3545 r = self->f->dequeueInt32(self); 3546 ck_assert_int_eq(r, 2); 3547 ck_assert_int_eq(lenO(self), 1); 3548 char *s = toStringO(self); 3549 ck_assert_str_eq(s, "[false]"); 3550 free(s); 3551 3552 // pop element of unexpected type 3553 r = self->f->dequeueInt32(self); 3554 ck_assert(!r); 3555 ck_assert_int_eq(lenO(self), 1); 3556 s = toStringO(self); 3557 ck_assert_str_eq(s, "[false]"); 3558 free(s); 3559 3560 // empty array 3561 r3 = self->f->pop(self); 3562 ck_assert_ptr_ne(r3, null); 3563 terminateO(r3); 3564 s = toStringO(self); 3565 ck_assert_str_eq(s, "[]"); 3566 free(s); 3567 r = self->f->dequeueInt32(self); 3568 ck_assert(!r); 3569 s = toStringO(self); 3570 ck_assert_str_eq(s, "[]"); 3571 free(s); 3572 terminateO(self); 3573 3574 } 3575 3576 3577 void dequeueUintSmallArrayT(void) { 3578 3579 uint64_t r; 3580 smallArrayt *self = allocG(rtSmallArrayt); 3581 smallArrayt *r2; 3582 baset *r3; 3583 3584 // add an element to check that the second element is poped 3585 // at the end 3586 r2 = self->f->pushBool(self, FALSE); 3587 ck_assert_ptr_ne(r2, null); 3588 3589 // add second element 3590 r2 = self->f->prependInt(self, 2); 3591 ck_assert_ptr_ne(r2, null); 3592 3593 // pop 3594 r = self->f->dequeueUint(self); 3595 ck_assert_int_eq(r, 2); 3596 ck_assert_int_eq(lenO(self), 1); 3597 char *s = toStringO(self); 3598 ck_assert_str_eq(s, "[false]"); 3599 free(s); 3600 3601 // pop element of unexpected type 3602 r = self->f->dequeueUint(self); 3603 ck_assert(!r); 3604 ck_assert_int_eq(lenO(self), 1); 3605 s = toStringO(self); 3606 ck_assert_str_eq(s, "[false]"); 3607 free(s); 3608 3609 // empty array 3610 r3 = self->f->pop(self); 3611 ck_assert_ptr_ne(r3, null); 3612 terminateO(r3); 3613 s = toStringO(self); 3614 ck_assert_str_eq(s, "[]"); 3615 free(s); 3616 r = self->f->dequeueUint(self); 3617 ck_assert(!r); 3618 s = toStringO(self); 3619 ck_assert_str_eq(s, "[]"); 3620 free(s); 3621 terminateO(self); 3622 3623 } 3624 3625 3626 void dequeueUint32SmallArrayT(void) { 3627 3628 uint32_t r; 3629 smallArrayt *self = allocG(rtSmallArrayt); 3630 smallArrayt *r2; 3631 baset *r3; 3632 3633 // add an element to check that the second element is poped 3634 // at the end 3635 r2 = self->f->pushBool(self, FALSE); 3636 ck_assert_ptr_ne(r2, null); 3637 3638 // add second element 3639 r2 = self->f->prependInt(self, 2); 3640 ck_assert_ptr_ne(r2, null); 3641 3642 // pop 3643 r = self->f->dequeueUint32(self); 3644 ck_assert_int_eq(r, 2); 3645 ck_assert_int_eq(lenO(self), 1); 3646 char *s = toStringO(self); 3647 ck_assert_str_eq(s, "[false]"); 3648 free(s); 3649 3650 // pop element of unexpected type 3651 r = self->f->dequeueUint32(self); 3652 ck_assert(!r); 3653 ck_assert_int_eq(lenO(self), 1); 3654 s = toStringO(self); 3655 ck_assert_str_eq(s, "[false]"); 3656 free(s); 3657 3658 // empty array 3659 r3 = self->f->pop(self); 3660 ck_assert_ptr_ne(r3, null); 3661 terminateO(r3); 3662 s = toStringO(self); 3663 ck_assert_str_eq(s, "[]"); 3664 free(s); 3665 r = self->f->dequeueUint32(self); 3666 ck_assert(!r); 3667 s = toStringO(self); 3668 ck_assert_str_eq(s, "[]"); 3669 free(s); 3670 terminateO(self); 3671 3672 } 3673 3674 3675 void dequeueSSmallArrayT(void) { 3676 3677 char* r; 3678 smallArrayt *self = allocG(rtSmallArrayt); 3679 smallArrayt *r2; 3680 baset *r3; 3681 3682 // add an element to check that the second element is poped 3683 // at the end 3684 r2 = self->f->pushInt(self, 1); 3685 ck_assert_ptr_ne(r2, null); 3686 3687 // add second element 3688 r2 = self->f->prependS(self, "bb"); 3689 ck_assert_ptr_ne(r2, null); 3690 3691 // pop 3692 r = self->f->dequeueS(self); 3693 ck_assert_str_eq(r, "bb"); 3694 free(r); 3695 ck_assert_int_eq(lenO(self), 1); 3696 char *s = toStringO(self); 3697 ck_assert_str_eq(s, "[1]"); 3698 free(s); 3699 3700 // pop element of unexpected type 3701 r = self->f->dequeueS(self); 3702 ck_assert(!r); 3703 ck_assert_int_eq(lenO(self), 1); 3704 s = toStringO(self); 3705 ck_assert_str_eq(s, "[1]"); 3706 free(s); 3707 3708 // empty array 3709 r3 = self->f->pop(self); 3710 ck_assert_ptr_ne(r3, null); 3711 terminateO(r3); 3712 s = toStringO(self); 3713 ck_assert_str_eq(s, "[]"); 3714 free(s); 3715 r = self->f->dequeueS(self); 3716 ck_assert(!r); 3717 s = toStringO(self); 3718 ck_assert_str_eq(s, "[]"); 3719 free(s); 3720 terminateO(self); 3721 3722 } 3723 3724 3725 void dequeueDictSmallArrayT(void) { 3726 3727 smallDictt* r; 3728 smallArrayt *self = allocG(rtSmallArrayt); 3729 smallArrayt *r2; 3730 baset *r3; 3731 3732 // add an element to check that the second element is poped 3733 // at the end 3734 r2 = self->f->pushInt(self, 1); 3735 ck_assert_ptr_ne(r2, null); 3736 // add second element 3737 createSmallDict(e); 3738 r2 = self->f->prependDict(self, &e); 3739 ck_assert_ptr_ne(r2, null); 3740 // pop 3741 r = self->f->dequeueDict(self); 3742 ck_assert_ptr_ne(r, null); 3743 char *s = toStringO(r); 3744 terminateO(r); 3745 ck_assert_str_eq(s, "{}"); 3746 free(s); 3747 ck_assert_int_eq(lenO(self), 1); 3748 s = toStringO(self); 3749 ck_assert_str_eq(s, "[1]"); 3750 free(s); 3751 // pop element of unexpected type 3752 r = self->f->dequeueDict(self); 3753 ck_assert(!r); 3754 ck_assert_int_eq(lenO(self), 1); 3755 s = toStringO(self); 3756 ck_assert_str_eq(s, "[1]"); 3757 free(s); 3758 // empty array 3759 r3 = self->f->pop(self); 3760 ck_assert_ptr_ne(r3, null); 3761 terminateO(r3); 3762 s = toStringO(self); 3763 ck_assert_str_eq(s, "[]"); 3764 free(s); 3765 r = self->f->dequeueDict(self); 3766 ck_assert(!r); 3767 s = toStringO(self); 3768 ck_assert_str_eq(s, "[]"); 3769 free(s); 3770 r2 = self->f->pushUndefined(self); 3771 ck_assert_ptr_ne(r2, null); 3772 delElemO(self,-1); 3773 r = self->f->dequeueDict(self); 3774 ck_assert_ptr_eq(r, null); 3775 terminateO(self); 3776 3777 } 3778 3779 3780 void dequeueArraySmallArrayT(void) { 3781 3782 smallArrayt* r; 3783 smallArrayt *self = allocG(rtSmallArrayt); 3784 smallArrayt *r2; 3785 baset *r3; 3786 3787 // add an element to check that the second element is poped 3788 // at the end 3789 r2 = self->f->pushInt(self, 1); 3790 ck_assert_ptr_ne(r2, null); 3791 // add second element 3792 createSmallArray(e); 3793 r2 = self->f->prependArray(self, &e); 3794 ck_assert_ptr_ne(r2, null); 3795 // pop 3796 r = self->f->dequeueArray(self); 3797 ck_assert_ptr_ne(r, null); 3798 char *s = toStringO(r); 3799 terminateO(r); 3800 ck_assert_str_eq(s, "[]"); 3801 free(s); 3802 ck_assert_int_eq(lenO(self), 1); 3803 s = toStringO(self); 3804 ck_assert_str_eq(s, "[1]"); 3805 free(s); 3806 // pop element of unexpected type 3807 r = self->f->dequeueArray(self); 3808 ck_assert(!r); 3809 ck_assert_int_eq(lenO(self), 1); 3810 s = toStringO(self); 3811 ck_assert_str_eq(s, "[1]"); 3812 free(s); 3813 // empty array 3814 r3 = self->f->pop(self); 3815 ck_assert_ptr_ne(r3, null); 3816 terminateO(r3); 3817 s = toStringO(self); 3818 ck_assert_str_eq(s, "[]"); 3819 free(s); 3820 r = self->f->dequeueArray(self); 3821 ck_assert(!r); 3822 s = toStringO(self); 3823 ck_assert_str_eq(s, "[]"); 3824 free(s); 3825 r2 = self->f->pushUndefined(self); 3826 ck_assert_ptr_ne(r2, null); 3827 delElemO(self,-1); 3828 r = self->f->dequeueArray(self); 3829 ck_assert_ptr_eq(r, null); 3830 terminateO(self); 3831 3832 } 3833 3834 3835 void dequeueSmallBoolSmallArrayT(void) { 3836 3837 smallBoolt* r; 3838 smallArrayt *self = allocG(rtSmallArrayt); 3839 smallArrayt *r2; 3840 baset *r3; 3841 3842 // add an element to check that the second element is poped 3843 // at the end 3844 r2 = self->f->pushInt(self, 1); 3845 ck_assert_ptr_ne(r2, null); 3846 3847 // add second element 3848 createSmallBool(e); 3849 r2 = self->f->prependSmallBool(self, &e); 3850 ck_assert_ptr_ne(r2, null); 3851 // pop 3852 r = self->f->dequeueSmallBool(self); 3853 ck_assert_ptr_ne(r, null); 3854 char *s = toStringO(r); 3855 terminateO(r); 3856 ck_assert_str_eq(s, "false"); 3857 free(s); 3858 ck_assert_int_eq(lenO(self), 1); 3859 s = toStringO(self); 3860 ck_assert_str_eq(s, "[1]"); 3861 free(s); 3862 // pop element of unexpected type 3863 r = self->f->dequeueSmallBool(self); 3864 ck_assert(!r); 3865 ck_assert_int_eq(lenO(self), 1); 3866 s = toStringO(self); 3867 ck_assert_str_eq(s, "[1]"); 3868 free(s); 3869 // empty array 3870 r3 = self->f->pop(self); 3871 ck_assert_ptr_ne(r3, null); 3872 terminateO(r3); 3873 s = toStringO(self); 3874 ck_assert_str_eq(s, "[]"); 3875 free(s); 3876 r = self->f->dequeueSmallBool(self); 3877 ck_assert(!r); 3878 s = toStringO(self); 3879 ck_assert_str_eq(s, "[]"); 3880 free(s); 3881 r2 = self->f->pushUndefined(self); 3882 ck_assert_ptr_ne(r2, null); 3883 delElemO(self,-1); 3884 r = self->f->dequeueSmallBool(self); 3885 ck_assert_ptr_eq(r, null); 3886 terminateO(self); 3887 3888 } 3889 3890 3891 void dequeueSmallBytesSmallArrayT(void) { 3892 3893 smallBytest* r; 3894 smallArrayt *self = allocG(rtSmallArrayt); 3895 smallArrayt *r2; 3896 baset *r3; 3897 3898 // add an element to check that the second element is poped 3899 // at the end 3900 r2 = self->f->pushInt(self, 1); 3901 ck_assert_ptr_ne(r2, null); 3902 // add second element 3903 createSmallBytes(e); 3904 r2 = self->f->prependSmallBytes(self, &e); 3905 ck_assert_ptr_ne(r2, null); 3906 // pop 3907 r = self->f->dequeueSmallBytes(self); 3908 ck_assert_ptr_ne(r, null); 3909 char *s = toStringO(r); 3910 terminateO(r); 3911 ck_assert_str_eq(s, "[]"); 3912 free(s); 3913 ck_assert_int_eq(lenO(self), 1); 3914 s = toStringO(self); 3915 ck_assert_str_eq(s, "[1]"); 3916 free(s); 3917 // pop element of unexpected type 3918 r = self->f->dequeueSmallBytes(self); 3919 ck_assert(!r); 3920 ck_assert_int_eq(lenO(self), 1); 3921 s = toStringO(self); 3922 ck_assert_str_eq(s, "[1]"); 3923 free(s); 3924 // empty array 3925 r3 = self->f->pop(self); 3926 ck_assert_ptr_ne(r3, null); 3927 terminateO(r3); 3928 s = toStringO(self); 3929 ck_assert_str_eq(s, "[]"); 3930 free(s); 3931 r = self->f->dequeueSmallBytes(self); 3932 ck_assert(!r); 3933 s = toStringO(self); 3934 ck_assert_str_eq(s, "[]"); 3935 free(s); 3936 r2 = self->f->pushUndefined(self); 3937 ck_assert_ptr_ne(r2, null); 3938 delElemO(self,-1); 3939 r = self->f->dequeueSmallBytes(self); 3940 ck_assert_ptr_eq(r, null); 3941 terminateO(self); 3942 3943 } 3944 3945 3946 void dequeueSmallDoubleSmallArrayT(void) { 3947 3948 smallDoublet* r; 3949 smallArrayt *self = allocG(rtSmallArrayt); 3950 smallArrayt *r2; 3951 baset *r3; 3952 3953 // add an element to check that the second element is poped 3954 // at the end 3955 r2 = self->f->pushInt(self, 1); 3956 ck_assert_ptr_ne(r2, null); 3957 // add second element 3958 createSmallDouble(e); 3959 r2 = self->f->prependSmallDouble(self, &e); 3960 ck_assert_ptr_ne(r2, null); 3961 // pop 3962 r = self->f->dequeueSmallDouble(self); 3963 ck_assert_ptr_ne(r, null); 3964 char *s = toStringO(r); 3965 terminateO(r); 3966 ck_assert_str_eq(s, "0.000000e+00"); 3967 free(s); 3968 ck_assert_int_eq(lenO(self), 1); 3969 s = toStringO(self); 3970 ck_assert_str_eq(s, "[1]"); 3971 free(s); 3972 // pop element of unexpected type 3973 r = self->f->dequeueSmallDouble(self); 3974 ck_assert(!r); 3975 ck_assert_int_eq(lenO(self), 1); 3976 s = toStringO(self); 3977 ck_assert_str_eq(s, "[1]"); 3978 free(s); 3979 // empty array 3980 r3 = self->f->pop(self); 3981 ck_assert_ptr_ne(r3, null); 3982 terminateO(r3); 3983 s = toStringO(self); 3984 ck_assert_str_eq(s, "[]"); 3985 free(s); 3986 r = self->f->dequeueSmallDouble(self); 3987 ck_assert(!r); 3988 s = toStringO(self); 3989 ck_assert_str_eq(s, "[]"); 3990 free(s); 3991 r2 = self->f->pushUndefined(self); 3992 ck_assert_ptr_ne(r2, null); 3993 delElemO(self,-1); 3994 r = self->f->dequeueSmallDouble(self); 3995 ck_assert_ptr_eq(r, null); 3996 terminateO(self); 3997 3998 } 3999 4000 4001 void dequeueSmallIntSmallArrayT(void) { 4002 4003 smallIntt* r; 4004 smallArrayt *self = allocG(rtSmallArrayt); 4005 smallArrayt *r2; 4006 baset *r3; 4007 4008 // add an element to check that the second element is poped 4009 // at the end 4010 r2 = self->f->pushBool(self, TRUE); 4011 ck_assert_ptr_ne(r2, null); 4012 // add second element 4013 createSmallInt(e); 4014 r2 = self->f->prependSmallInt(self, &e); 4015 ck_assert_ptr_ne(r2, null); 4016 // pop 4017 r = self->f->dequeueSmallInt(self); 4018 ck_assert_ptr_ne(r, null); 4019 char *s = toStringO(r); 4020 terminateO(r); 4021 ck_assert_str_eq(s, "0"); 4022 free(s); 4023 ck_assert_int_eq(lenO(self), 1); 4024 s = toStringO(self); 4025 ck_assert_str_eq(s, "[true]"); 4026 free(s); 4027 // pop element of unexpected type 4028 r = self->f->dequeueSmallInt(self); 4029 ck_assert(!r); 4030 ck_assert_int_eq(lenO(self), 1); 4031 s = toStringO(self); 4032 ck_assert_str_eq(s, "[true]"); 4033 free(s); 4034 // empty array 4035 r3 = self->f->pop(self); 4036 ck_assert_ptr_ne(r3, null); 4037 terminateO(r3); 4038 s = toStringO(self); 4039 ck_assert_str_eq(s, "[]"); 4040 free(s); 4041 r = self->f->dequeueSmallInt(self); 4042 ck_assert(!r); 4043 s = toStringO(self); 4044 ck_assert_str_eq(s, "[]"); 4045 free(s); 4046 r2 = self->f->pushUndefined(self); 4047 ck_assert_ptr_ne(r2, null); 4048 delElemO(self,-1); 4049 r = self->f->dequeueSmallInt(self); 4050 ck_assert_ptr_eq(r, null); 4051 terminateO(self); 4052 4053 } 4054 4055 4056 void dequeueSmallJsonSmallArrayT(void) { 4057 4058 smallJsont* r; 4059 smallArrayt *self = allocG(rtSmallArrayt); 4060 smallArrayt *r2; 4061 baset *r3; 4062 4063 // add an element to check that the second element is poped 4064 // at the end 4065 createSmallBytes(B); 4066 r2 = self->f->pushSmallBytes(self, &B); 4067 ck_assert_ptr_ne(r2, null); 4068 // add second element 4069 createSmallJson(e); 4070 r2 = self->f->prependSmallJson(self, &e); 4071 ck_assert_ptr_ne(r2, null); 4072 // pop 4073 r = self->f->dequeueSmallJson(self); 4074 ck_assert_ptr_ne(r, null); 4075 char *s = toStringO(r); 4076 terminateO(r); 4077 ck_assert_str_eq(s, "{}"); 4078 free(s); 4079 ck_assert_int_eq(lenO(self), 1); 4080 s = toStringO(self); 4081 ck_assert_str_eq(s, "[[]]"); 4082 free(s); 4083 // pop element of unexpected type 4084 r = self->f->dequeueSmallJson(self); 4085 ck_assert(!r); 4086 ck_assert_int_eq(lenO(self), 1); 4087 s = toStringO(self); 4088 ck_assert_str_eq(s, "[[]]"); 4089 free(s); 4090 // empty array 4091 r3 = self->f->pop(self); 4092 ck_assert_ptr_ne(r3, null); 4093 terminateO(r3); 4094 s = toStringO(self); 4095 ck_assert_str_eq(s, "[]"); 4096 free(s); 4097 r = self->f->dequeueSmallJson(self); 4098 ck_assert(!r); 4099 s = toStringO(self); 4100 ck_assert_str_eq(s, "[]"); 4101 free(s); 4102 r2 = self->f->pushUndefined(self); 4103 ck_assert_ptr_ne(r2, null); 4104 delElemO(self,-1); 4105 r = self->f->dequeueSmallJson(self); 4106 ck_assert_ptr_eq(r, null); 4107 terminateO(self); 4108 4109 } 4110 4111 4112 void dequeueSmallStringSmallArrayT(void) { 4113 4114 smallStringt* r; 4115 smallArrayt *self = allocG(rtSmallArrayt); 4116 smallArrayt *r2; 4117 baset *r3; 4118 4119 // add an element to check that the second element is poped 4120 // at the end 4121 r2 = self->f->pushInt(self, 1); 4122 ck_assert_ptr_ne(r2, null); 4123 // add second element 4124 createSmallString(e); 4125 r2 = self->f->prependSmallString(self, &e); 4126 ck_assert_ptr_ne(r2, null); 4127 // pop 4128 r = self->f->dequeueSmallString(self); 4129 ck_assert_ptr_ne(r, null); 4130 char *s = toStringO(r); 4131 terminateO(r); 4132 ck_assert_str_eq(s, ""); 4133 free(s); 4134 ck_assert_int_eq(lenO(self), 1); 4135 s = toStringO(self); 4136 ck_assert_str_eq(s, "[1]"); 4137 free(s); 4138 // pop element of unexpected type 4139 r = self->f->dequeueSmallString(self); 4140 ck_assert(!r); 4141 ck_assert_int_eq(lenO(self), 1); 4142 s = toStringO(self); 4143 ck_assert_str_eq(s, "[1]"); 4144 free(s); 4145 // empty array 4146 r3 = self->f->pop(self); 4147 ck_assert_ptr_ne(r3, null); 4148 terminateO(r3); 4149 s = toStringO(self); 4150 ck_assert_str_eq(s, "[]"); 4151 free(s); 4152 r = self->f->dequeueSmallString(self); 4153 ck_assert(!r); 4154 s = toStringO(self); 4155 ck_assert_str_eq(s, "[]"); 4156 free(s); 4157 r2 = self->f->pushUndefined(self); 4158 ck_assert_ptr_ne(r2, null); 4159 delElemO(self,-1); 4160 r = self->f->dequeueSmallString(self); 4161 ck_assert_ptr_eq(r, null); 4162 terminateO(self); 4163 4164 } 4165 4166 4167 void dequeueVoidSmallArrayT(void) { 4168 4169 void* r; 4170 smallArrayt *self = allocG(rtSmallArrayt); 4171 smallArrayt *r2; 4172 baset *r3; 4173 4174 // add an element to check that the second element is poped 4175 // at the end 4176 r2 = self->f->pushInt(self, 1); 4177 ck_assert_ptr_ne(r2, null); 4178 4179 // add second element 4180 createSmallContainer(e); 4181 setValO(&e, &r); 4182 r2 = self->f->prependSmallContainer(self, &e); 4183 ck_assert_ptr_ne(r2, null); 4184 4185 // pop 4186 r = self->f->dequeueVoid(self); 4187 ck_assert_ptr_eq(r, &r); 4188 ck_assert_int_eq(lenO(self), 1); 4189 char *s = toStringO(self); 4190 ck_assert_str_eq(s, "[1]"); 4191 free(s); 4192 4193 // pop element of unexpected type 4194 r = self->f->dequeueVoid(self); 4195 ck_assert(!r); 4196 ck_assert_int_eq(lenO(self), 1); 4197 s = toStringO(self); 4198 ck_assert_str_eq(s, "[1]"); 4199 free(s); 4200 4201 // empty array 4202 r3 = self->f->pop(self); 4203 ck_assert_ptr_ne(r3, null); 4204 terminateO(r3); 4205 s = toStringO(self); 4206 ck_assert_str_eq(s, "[]"); 4207 free(s); 4208 r = self->f->dequeueVoid(self); 4209 ck_assert(!r); 4210 s = toStringO(self); 4211 ck_assert_str_eq(s, "[]"); 4212 free(s); 4213 terminateO(self); 4214 4215 } 4216 4217 4218 void dequeueSmallContainerSmallArrayT(void) { 4219 4220 smallContainert* r; 4221 smallArrayt *self = allocG(rtSmallArrayt); 4222 smallArrayt *r2; 4223 baset *r3; 4224 4225 // add an element to check that the second element is poped 4226 // at the end 4227 r2 = self->f->pushInt(self, 1); 4228 ck_assert_ptr_ne(r2, null); 4229 // add second element 4230 createSmallContainer(e); 4231 r2 = self->f->prependSmallContainer(self, &e); 4232 ck_assert_ptr_ne(r2, null); 4233 // pop 4234 r = self->f->dequeueSmallContainer(self); 4235 ck_assert_ptr_ne(r, null); 4236 char *s = toStringO(r); 4237 terminateO(r); 4238 ck_assert_str_eq(s, "<data smallContainer>"); 4239 free(s); 4240 ck_assert_int_eq(lenO(self), 1); 4241 s = toStringO(self); 4242 ck_assert_str_eq(s, "[1]"); 4243 free(s); 4244 // container with baset object 4245 // push a base object of unknown type 4246 smallIntt *o = allocSmallInt(2); 4247 o->type = "newType"; 4248 r2 = self->f->prependNFree(self, (baset*)o); 4249 ck_assert_ptr_ne(r2, null); 4250 r = self->f->dequeueSmallContainer(self); 4251 ck_assert_ptr_eq(r, NULL); 4252 ck_assert_int_eq(lenO(self), 2); 4253 s = toStringO(self); 4254 ck_assert_str_eq(s, "[\"<data container>\",1]"); 4255 free(s); 4256 r3 = self->f->dequeue(self); 4257 ck_assert_ptr_ne(r3, null); 4258 terminateO(r3); 4259 // pop element of unexpected type 4260 r = self->f->dequeueSmallContainer(self); 4261 ck_assert_ptr_eq(r, NULL); 4262 ck_assert_int_eq(lenO(self), 1); 4263 s = toStringO(self); 4264 ck_assert_str_eq(s, "[1]"); 4265 free(s); 4266 // empty array 4267 r3 = self->f->pop(self); 4268 ck_assert_ptr_ne(r3, null); 4269 terminateO(r3); 4270 s = toStringO(self); 4271 ck_assert_str_eq(s, "[]"); 4272 free(s); 4273 r = self->f->dequeueSmallContainer(self); 4274 ck_assert(!r); 4275 s = toStringO(self); 4276 ck_assert_str_eq(s, "[]"); 4277 free(s); 4278 r2 = self->f->pushUndefined(self); 4279 ck_assert_ptr_ne(r2, null); 4280 delElemO(self,-1); 4281 r = self->f->dequeueSmallContainer(self); 4282 ck_assert_ptr_eq(r, null); 4283 terminateO(self); 4284 4285 } 4286 4287 4288 void dequeueNumSmallArrayT(void) { 4289 4290 double r; 4291 smallArrayt *self = allocG(rtSmallArrayt); 4292 smallArrayt *r2; 4293 baset *r3; 4294 4295 // add an element to check that the second element is poped 4296 // at the end 4297 r2 = self->f->pushBool(self, TRUE); 4298 ck_assert_ptr_ne(r2, null); 4299 // add second element 4300 r2 = self->f->prependInt(self, 2); 4301 ck_assert_ptr_ne(r2, null); 4302 r2 = self->f->prependDouble(self, 2.5); 4303 ck_assert_ptr_ne(r2, null); 4304 // pop 4305 r = self->f->dequeueNum(self); 4306 ck_assert(r==2.5); 4307 ck_assert_int_eq(lenO(self), 2); 4308 char *s = toStringO(self); 4309 ck_assert_str_eq(s, "[2,true]"); 4310 free(s); 4311 r = self->f->dequeueNum(self); 4312 ck_assert_int_eq(r, 2); 4313 ck_assert_int_eq(lenO(self), 1); 4314 s = toStringO(self); 4315 ck_assert_str_eq(s, "[true]"); 4316 free(s); 4317 // pop element of unexpected type 4318 r = self->f->dequeueNum(self); 4319 ck_assert(!r); 4320 ck_assert_int_eq(lenO(self), 1); 4321 s = toStringO(self); 4322 ck_assert_str_eq(s, "[true]"); 4323 free(s); 4324 // empty array 4325 r3 = self->f->pop(self); 4326 ck_assert_ptr_ne(r3, null); 4327 terminateO(r3); 4328 s = toStringO(self); 4329 ck_assert_str_eq(s, "[]"); 4330 free(s); 4331 r = self->f->dequeueNum(self); 4332 ck_assert(!r); 4333 s = toStringO(self); 4334 ck_assert_str_eq(s, "[]"); 4335 free(s); 4336 r2 = self->f->pushUndefined(self); 4337 ck_assert_ptr_ne(r2, null); 4338 delElemO(self,-1); 4339 r = self->f->dequeueNum(self); 4340 ck_assert(!r); 4341 terminateO(self); 4342 4343 } 4344 4345 4346 void reverseSmallArrayT(void) { 4347 4348 smallArrayt* r; 4349 smallArrayt *self = allocG(rtSmallArrayt); 4350 4351 // empty array 4352 r = reverseO(self); 4353 ck_assert_ptr_ne(r, NULL); 4354 char *s = toStringO(r); 4355 ck_assert_str_eq(s, "[]"); 4356 free(s); 4357 // 1 element array 4358 self->f->pushInt(self,1); 4359 r = reverseO(self); 4360 ck_assert_ptr_ne(r, NULL); 4361 s = toStringO(r); 4362 ck_assert_str_eq(s, "[1]"); 4363 free(s); 4364 // 2 elements array 4365 self->f->pushInt(self,2); 4366 r = reverseO(self); 4367 ck_assert_ptr_ne(r, NULL); 4368 s = toStringO(r); 4369 ck_assert_str_eq(s, "[2,1]"); 4370 free(s); 4371 terminateO(self); 4372 4373 } 4374 4375 4376 void catSmallArrayT(void) { 4377 4378 smallArrayt* r; 4379 smallArrayt *self = allocG(rtSmallArrayt); 4380 4381 // cat arrays 4382 self->f->pushInt(self,1); 4383 createAllocateSmallArray(a); 4384 createAllocateSmallArray(a2); 4385 a2->f->pushInt(a2,2); 4386 r = catO(self, a, a2); 4387 char *s = toStringO(r); 4388 ck_assert_str_eq(s, "[1,2]"); 4389 free(s); 4390 smashManyO(a,a2); 4391 emptyO(self); 4392 4393 // null parameter 4394 r = catO(self, null); 4395 s = toStringO(r); 4396 ck_assert_str_eq(s, "[]"); 4397 free(s); 4398 terminateO(self); 4399 4400 } 4401 4402 4403 void appendSmallJsonSmallArrayT(void) { 4404 4405 smallArrayt* r; 4406 smallArrayt *self = allocG(rtSmallArrayt); 4407 createAllocateSmallJson(json); 4408 4409 // add an element to check that the second array is appended 4410 // at the end 4411 r = self->f->pushInt(self, 1); 4412 ck_assert_ptr_ne(r, null); 4413 4414 // append json array 4415 json->f->pushInt(json, 2); 4416 r = self->f->appendSmallJson(self, json); 4417 smashO(json); 4418 ck_assert_ptr_ne(r, null); 4419 char *s = toStringO(r); 4420 ck_assert_str_eq(s, "[1,2]"); 4421 free(s); 4422 // length 0 4423 json = allocSmallJson(); 4424 json->f->pushInt(json, 2); 4425 baset *o = json->f->pop(json); 4426 terminateO(o); 4427 r = self->f->appendSmallJson(self, json); 4428 smashO(json); 4429 ck_assert_ptr_ne(r, null); 4430 s = toStringO(r); 4431 ck_assert_str_eq(s, "[1,2]"); 4432 free(s); 4433 // same sArray in both self and json 4434 json = allocSmallJson(); 4435 setsoO(json, (smallt*) getsoO(self)); 4436 r = self->f->appendSmallJson(self, json); 4437 ck_assert_ptr_eq(r, null); 4438 finishO(json); 4439 s = toStringO(self); 4440 ck_assert_str_eq(s, "[1,2]"); 4441 free(s); 4442 // json of type not array 4443 json = allocSmallJson(); 4444 setTopIntO(json, 1); 4445 r = self->f->appendSmallJson(self, json); 4446 ck_assert_ptr_eq(r, null); 4447 terminateO(json); 4448 s = toStringO(self); 4449 ck_assert_str_eq(s, "[1,2]"); 4450 free(s); 4451 // non smallJson object 4452 json = (smallJsont*) allocSmallInt(2); 4453 r = self->f->appendSmallJson(self, json); 4454 ck_assert_ptr_eq(r, null); 4455 terminateO(json); 4456 // null 4457 r = self->f->appendSmallJson(self, null); 4458 ck_assert_ptr_eq(r, null); 4459 s = toStringO(self); 4460 ck_assert_str_eq(s, "[1,2]"); 4461 free(s); 4462 terminateO(self); 4463 4464 } 4465 4466 4467 void appendNSmashSmallArrayT(void) { 4468 4469 smallArrayt* r; 4470 smallArrayt *self = allocG(rtSmallArrayt); 4471 createAllocateSmallArray(a); 4472 4473 // add an element to check that the second array is appended 4474 // at the end 4475 r = self->f->pushInt(self, 1); 4476 ck_assert_ptr_ne(r, null); 4477 4478 // append array 4479 a->f->pushInt(a, 2); 4480 r = self->f->appendNSmash(self, a); 4481 ck_assert_ptr_ne(r, null); 4482 char *s = toStringO(r); 4483 ck_assert_str_eq(s, "[1,2]"); 4484 free(s); 4485 // length 0 4486 a = allocSmallArray(); 4487 a->f->pushInt(a, 2); 4488 delElemO(a,0); 4489 r = self->f->appendNSmash(self, a); 4490 ck_assert_ptr_ne(r, null); 4491 s = toStringO(r); 4492 ck_assert_str_eq(s, "[1,2]"); 4493 free(s); 4494 // same sArray in both self and a 4495 a = allocSmallArray(); 4496 setsoO(a, getsoO(self)); 4497 r = self->f->appendNSmash(self, a); 4498 ck_assert_ptr_eq(r, null); 4499 finishO(a); 4500 s = toStringO(self); 4501 ck_assert_str_eq(s, "[1,2]"); 4502 free(s); 4503 // null 4504 r = self->f->appendNSmash(self, null); 4505 ck_assert_ptr_eq(r, null); 4506 s = toStringO(self); 4507 ck_assert_str_eq(s, "[1,2]"); 4508 free(s); 4509 terminateO(self); 4510 4511 } 4512 4513 4514 void appendNSmashSmallJsonSmallArrayT(void) { 4515 4516 smallArrayt* r; 4517 smallArrayt *self = allocG(rtSmallArrayt); 4518 createAllocateSmallJson(json); 4519 4520 // add an element to check that the second array is appended 4521 // at the end 4522 r = self->f->pushInt(self, 1); 4523 ck_assert_ptr_ne(r, null); 4524 4525 // append json array 4526 json->f->pushInt(json, 2); 4527 r = self->f->appendNSmashSmallJson(self, json); 4528 ck_assert_ptr_ne(r, null); 4529 char *s = toStringO(r); 4530 ck_assert_str_eq(s, "[1,2]"); 4531 free(s); 4532 // null 4533 r = self->f->appendNSmashSmallJson(self, null); 4534 ck_assert_ptr_eq(r, null); 4535 s = toStringO(self); 4536 ck_assert_str_eq(s, "[1,2]"); 4537 free(s); 4538 terminateO(self); 4539 4540 } 4541 4542 4543 void appendArraySmallArrayT(void) { 4544 4545 smallArrayt* r; 4546 smallArrayt *self = allocG(rtSmallArrayt); 4547 char **array; 4548 4549 // add an element to check that the second array is appended 4550 // at the end 4551 r = self->f->pushInt(self, 1); 4552 ck_assert_ptr_ne(r, null); 4553 4554 // append array 4555 array = null; 4556 listPushS(&array, "2"); 4557 r = self->f->appendArray(self, array); 4558 listFreeS(array); 4559 ck_assert_ptr_ne(r, null); 4560 char *s = toStringO(r); 4561 ck_assert_str_eq(s, "[1,\"2\"]"); 4562 free(s); 4563 // length 0 4564 listEmptyS(array); 4565 r = self->f->appendArray(self, array); 4566 free(array); 4567 ck_assert_ptr_ne(r, null); 4568 s = toStringO(r); 4569 ck_assert_str_eq(s, "[1,\"2\"]"); 4570 free(s); 4571 // null 4572 r = self->f->appendArray(self, null); 4573 ck_assert_ptr_eq(r, null); 4574 s = toStringO(self); 4575 ck_assert_str_eq(s, "[1,\"2\"]"); 4576 free(s); 4577 terminateO(self); 4578 4579 } 4580 4581 4582 void appendNSmashArraySmallArrayT(void) { 4583 4584 smallArrayt* r; 4585 smallArrayt *self = allocG(rtSmallArrayt); 4586 char **array; 4587 4588 // add an element to check that the second array is appended 4589 // at the end 4590 r = self->f->pushInt(self, 1); 4591 ck_assert_ptr_ne(r, null); 4592 4593 // append array 4594 array = null; 4595 listPushS(&array, "2"); 4596 r = self->f->appendNSmashArray(self, array); 4597 ck_assert_ptr_ne(r, null); 4598 char *s = toStringO(r); 4599 ck_assert_str_eq(s, "[1,\"2\"]"); 4600 free(s); 4601 // length 0 4602 listEmptyS(array); 4603 r = self->f->appendNSmashArray(self, array); 4604 ck_assert_ptr_ne(r, null); 4605 s = toStringO(r); 4606 ck_assert_str_eq(s, "[1,\"2\"]"); 4607 free(s); 4608 // null 4609 r = self->f->appendNSmashArray(self, null); 4610 ck_assert_ptr_eq(r, null); 4611 s = toStringO(self); 4612 ck_assert_str_eq(s, "[1,\"2\"]"); 4613 free(s); 4614 terminateO(self); 4615 4616 } 4617 4618 4619 void shiftSmallArrayT(void) { 4620 4621 smallArrayt* r; 4622 smallArrayt *self = allocG(rtSmallArrayt); 4623 createAllocateSmallArray(a); 4624 4625 // add an element to check that the second array is appended 4626 // at the end 4627 r = self->f->pushInt(self, 1); 4628 ck_assert_ptr_ne(r, null); 4629 4630 // append array 4631 a->f->pushInt(a, 2); 4632 r = self->f->shift(self, a); 4633 smashO(a); 4634 ck_assert_ptr_ne(r, null); 4635 char *s = toStringO(r); 4636 ck_assert_str_eq(s, "[2,1]"); 4637 free(s); 4638 // length 0 4639 a = allocSmallArray(); 4640 a->f->pushInt(a, 2); 4641 delElemO(a,0); 4642 r = self->f->shift(self, a); 4643 smashO(a); 4644 ck_assert_ptr_ne(r, null); 4645 s = toStringO(r); 4646 ck_assert_str_eq(s, "[2,1]"); 4647 free(s); 4648 // same sArray in both self and a 4649 a = allocSmallArray(); 4650 setsoO(a, getsoO(self)); 4651 r = self->f->shift(self, a); 4652 ck_assert_ptr_eq(r, null); 4653 finishO(a); 4654 s = toStringO(self); 4655 ck_assert_str_eq(s, "[2,1]"); 4656 free(s); 4657 // null 4658 r = self->f->shift(self, null); 4659 ck_assert_ptr_eq(r, null); 4660 s = toStringO(self); 4661 ck_assert_str_eq(s, "[2,1]"); 4662 free(s); 4663 terminateO(self); 4664 4665 } 4666 4667 4668 void shiftSmallJsonSmallArrayT(void) { 4669 4670 smallArrayt* r; 4671 smallArrayt *self = allocG(rtSmallArrayt); 4672 createAllocateSmallJson(json); 4673 4674 // add an element to check that the second array is shifted 4675 // at the end 4676 r = self->f->pushInt(self, 1); 4677 ck_assert_ptr_ne(r, null); 4678 4679 // shift json array 4680 json->f->pushInt(json, 2); 4681 r = self->f->shiftSmallJson(self, json); 4682 smashO(json); 4683 ck_assert_ptr_ne(r, null); 4684 char *s = toStringO(r); 4685 ck_assert_str_eq(s, "[2,1]"); 4686 free(s); 4687 // length 0 4688 json = allocSmallJson(); 4689 json->f->pushInt(json, 2); 4690 baset *o = json->f->pop(json); 4691 terminateO(o); 4692 r = self->f->shiftSmallJson(self, json); 4693 smashO(json); 4694 ck_assert_ptr_ne(r, null); 4695 s = toStringO(r); 4696 ck_assert_str_eq(s, "[2,1]"); 4697 free(s); 4698 // same sArray in both self and json 4699 json = allocSmallJson(); 4700 setsoO(json, (smallt*) getsoO(self)); 4701 r = self->f->shiftSmallJson(self, json); 4702 ck_assert_ptr_eq(r, null); 4703 finishO(json); 4704 s = toStringO(self); 4705 ck_assert_str_eq(s, "[2,1]"); 4706 free(s); 4707 // json of type not array 4708 json = allocSmallJson(); 4709 setTopIntO(json, 1); 4710 r = self->f->shiftSmallJson(self, json); 4711 ck_assert_ptr_eq(r, null); 4712 terminateO(json); 4713 s = toStringO(self); 4714 ck_assert_str_eq(s, "[2,1]"); 4715 free(s); 4716 // null 4717 r = self->f->shiftSmallJson(self, null); 4718 ck_assert_ptr_eq(r, null); 4719 s = toStringO(self); 4720 ck_assert_str_eq(s, "[2,1]"); 4721 free(s); 4722 terminateO(self); 4723 4724 } 4725 4726 4727 void shiftNSmashSmallArrayT(void) { 4728 4729 smallArrayt* r; 4730 smallArrayt *self = allocG(rtSmallArrayt); 4731 createAllocateSmallArray(a); 4732 4733 // add an element to check that the second array is appended 4734 // at the end 4735 r = self->f->pushInt(self, 1); 4736 ck_assert_ptr_ne(r, null); 4737 4738 // append array 4739 a->f->pushInt(a, 2); 4740 r = self->f->shiftNSmash(self, a); 4741 ck_assert_ptr_ne(r, null); 4742 char *s = toStringO(r); 4743 ck_assert_str_eq(s, "[2,1]"); 4744 free(s); 4745 // length 0 4746 a = allocSmallArray(); 4747 a->f->pushInt(a, 2); 4748 delElemO(a,0); 4749 r = self->f->shiftNSmash(self, a); 4750 ck_assert_ptr_ne(r, null); 4751 s = toStringO(r); 4752 ck_assert_str_eq(s, "[2,1]"); 4753 free(s); 4754 // same sArray in both self and a 4755 a = allocSmallArray(); 4756 setsoO(a, getsoO(self)); 4757 r = self->f->shiftNSmash(self, a); 4758 ck_assert_ptr_eq(r, null); 4759 finishO(a); 4760 s = toStringO(self); 4761 ck_assert_str_eq(s, "[2,1]"); 4762 free(s); 4763 // null 4764 r = self->f->shiftNSmash(self, null); 4765 ck_assert_ptr_eq(r, null); 4766 s = toStringO(self); 4767 ck_assert_str_eq(s, "[2,1]"); 4768 free(s); 4769 terminateO(self); 4770 4771 } 4772 4773 4774 void shiftNSmashSmallJsonSmallArrayT(void) { 4775 4776 smallArrayt* r; 4777 smallArrayt *self = allocG(rtSmallArrayt); 4778 createAllocateSmallJson(json); 4779 4780 // add an element to check that the second array is shifted 4781 // at the end 4782 r = self->f->pushInt(self, 1); 4783 ck_assert_ptr_ne(r, null); 4784 4785 // shift json array 4786 json->f->pushInt(json, 2); 4787 r = self->f->shiftNSmashSmallJson(self, json); 4788 ck_assert_ptr_ne(r, null); 4789 char *s = toStringO(r); 4790 ck_assert_str_eq(s, "[2,1]"); 4791 free(s); 4792 // length 0 4793 json = allocSmallJson(); 4794 json->f->pushInt(json, 2); 4795 baset *o = json->f->pop(json); 4796 terminateO(o); 4797 r = self->f->shiftNSmashSmallJson(self, json); 4798 ck_assert_ptr_ne(r, null); 4799 s = toStringO(r); 4800 ck_assert_str_eq(s, "[2,1]"); 4801 free(s); 4802 // same sArray in both self and json 4803 json = allocSmallJson(); 4804 setsoO(json, (smallt*) getsoO(self)); 4805 r = self->f->shiftNSmashSmallJson(self, json); 4806 ck_assert_ptr_eq(r, null); 4807 finishO(json); 4808 s = toStringO(self); 4809 ck_assert_str_eq(s, "[2,1]"); 4810 free(s); 4811 // json of type not array 4812 json = allocSmallJson(); 4813 setTopIntO(json, 1); 4814 r = self->f->shiftNSmashSmallJson(self, json); 4815 ck_assert_ptr_eq(r, null); 4816 terminateO(json); 4817 s = toStringO(self); 4818 ck_assert_str_eq(s, "[2,1]"); 4819 free(s); 4820 // null 4821 r = self->f->shiftNSmashSmallJson(self, null); 4822 ck_assert_ptr_eq(r, null); 4823 s = toStringO(self); 4824 ck_assert_str_eq(s, "[2,1]"); 4825 free(s); 4826 terminateO(self); 4827 4828 } 4829 4830 4831 void addSmallArrayT(void) { 4832 4833 smallArrayt* r; 4834 smallArrayt *self = allocG(rtSmallArrayt); 4835 createAllocateSmallArray(a); 4836 4837 // add an element to check that the second array is added 4838 // at the end 4839 r = self->f->pushInt(self, 1); 4840 ck_assert_ptr_ne(r, null); 4841 4842 // add array 4843 a->f->pushInt(a, 2); 4844 r = addO(self, a); 4845 smashO(a); 4846 ck_assert_ptr_ne(r, null); 4847 char *s = toStringO(r); 4848 terminateO(r); 4849 ck_assert_str_eq(s, "[1,2]"); 4850 free(s); 4851 // length 0 4852 a = allocSmallArray(); 4853 a->f->pushInt(a, 2); 4854 delElemO(a,0); 4855 r = addO(self, a); 4856 smashO(a); 4857 ck_assert_ptr_ne(r, null); 4858 s = toStringO(r); 4859 terminateO(r); 4860 ck_assert_str_eq(s, "[1]"); 4861 free(s); 4862 // same sArray in both self and a 4863 a = allocSmallArray(); 4864 setsoO(a, getsoO(self)); 4865 r = addO(self, a); 4866 ck_assert_ptr_eq(r, null); 4867 finishO(a); 4868 s = toStringO(self); 4869 ck_assert_str_eq(s, "[1]"); 4870 free(s); 4871 // null 4872 r = addO(self, null); 4873 ck_assert_ptr_eq(r, null); 4874 s = toStringO(self); 4875 ck_assert_str_eq(s, "[1]"); 4876 free(s); 4877 terminateO(self); 4878 4879 } 4880 4881 4882 void cropSmallArrayT(void) { 4883 4884 smallArrayt* r; 4885 smallArrayt *self = allocG(rtSmallArrayt); 4886 4887 // add elements to self 4888 r = self->f->pushInt(self, 1); 4889 ck_assert_ptr_ne(r, null); 4890 r = self->f->pushInt(self, 2); 4891 ck_assert_ptr_ne(r, null); 4892 r = self->f->pushInt(self, 3); 4893 ck_assert_ptr_ne(r, null); 4894 r = self->f->pushInt(self, 4); 4895 ck_assert_ptr_ne(r, null); 4896 4897 // negative index 4898 r = cropO(self, 1, -1); 4899 ck_assert_ptr_ne(r, null); 4900 ck_assert_int_eq(lenO(r), 2); 4901 char *s = toStringO(r); 4902 terminateO(r); 4903 ck_assert_str_eq(s, "[2,3]"); 4904 free(s); 4905 s = toStringO(self); 4906 ck_assert_str_eq(s, "[1,4]"); 4907 free(s); 4908 // start outside 4909 ck_assert_ptr_eq(cropO(self, 20, -4), NULL); 4910 // end outside 4911 r = cropO(self, 0, 40); 4912 ck_assert_ptr_ne(r, null); 4913 ck_assert_int_eq(lenO(r), 2); 4914 s = toStringO(r); 4915 terminateO(r); 4916 ck_assert_str_eq(s, "[1,4]"); 4917 free(s); 4918 s = toStringO(self); 4919 ck_assert_str_eq(s, "[]"); 4920 free(s); 4921 // end negative and outside 4922 // add elements to self 4923 r = self->f->pushInt(self, 1); 4924 ck_assert_ptr_ne(r, null); 4925 r = self->f->pushInt(self, 2); 4926 ck_assert_ptr_ne(r, null); 4927 r = self->f->pushInt(self, 3); 4928 ck_assert_ptr_ne(r, null); 4929 r = self->f->pushInt(self, 4); 4930 ck_assert_ptr_ne(r, null); 4931 ck_assert_ptr_eq(cropO(self, 2, -40), NULL); 4932 s = toStringO(self); 4933 ck_assert_str_eq(s, "[1,2,3,4]"); 4934 free(s); 4935 // end before start 4936 ck_assert_ptr_eq(cropO(self, 3, 2), NULL); 4937 s = toStringO(self); 4938 ck_assert_str_eq(s, "[1,2,3,4]"); 4939 free(s); 4940 // negative start last element 4941 r = cropO(self, -1, 0); 4942 ck_assert_ptr_ne(r, null); 4943 ck_assert_int_eq(lenO(r), 1); 4944 s = toStringO(r); 4945 terminateO(r); 4946 ck_assert_str_eq(s, "[4]"); 4947 free(s); 4948 s = toStringO(self); 4949 ck_assert_str_eq(s, "[1,2,3]"); 4950 free(s); 4951 // negative start and outside 4952 r = cropO(self, -10, 1); 4953 ck_assert_ptr_ne(r, null); 4954 ck_assert_int_eq(lenO(r), 1); 4955 s = toStringO(r); 4956 terminateO(r); 4957 ck_assert_str_eq(s, "[1]"); 4958 free(s); 4959 s = toStringO(self); 4960 ck_assert_str_eq(s, "[2,3]"); 4961 free(s); 4962 // start = end 4963 r = cropO(self, 1, 1); 4964 ck_assert_ptr_ne(r, null); 4965 ck_assert_int_eq(lenO(r), 0); 4966 terminateO(r); 4967 s = toStringO(self); 4968 ck_assert_str_eq(s, "[2,3]"); 4969 free(s); 4970 // empty list 4971 emptyO(self); 4972 ck_assert_ptr_eq(cropO(self, 0, 0), NULL); 4973 ck_assert_ptr_eq(cropO(self, -1, 0), NULL); 4974 terminateO(self); 4975 4976 } 4977 4978 4979 void cropElemSmallArrayT(void) { 4980 4981 baset* r; 4982 smallArrayt *self = allocG(rtSmallArrayt); 4983 smallArrayt *r2; 4984 4985 // add elements to self 4986 r2 = self->f->pushInt(self, 1); 4987 ck_assert_ptr_ne(r2, null); 4988 r2 = self->f->pushInt(self, 2); 4989 ck_assert_ptr_ne(r2, null); 4990 r2 = self->f->pushInt(self, 3); 4991 ck_assert_ptr_ne(r2, null); 4992 r2 = self->f->pushInt(self, 4); 4993 ck_assert_ptr_ne(r2, null); 4994 4995 // positive index 4996 r = cropElemO(self,1); 4997 ck_assert_ptr_ne(r, null); 4998 char *s = toStringO(r); 4999 terminateO(r); 5000 ck_assert_str_eq(s, "2"); 5001 free(s); 5002 s = toStringO(self); 5003 ck_assert_str_eq(s, "[1,3,4]"); 5004 free(s); 5005 // negative index 5006 r = cropElemO(self,-1); 5007 ck_assert_ptr_ne(r, null); 5008 s = toStringO(r); 5009 terminateO(r); 5010 ck_assert_str_eq(s, "4"); 5011 free(s); 5012 s = toStringO(self); 5013 ck_assert_str_eq(s, "[1,3]"); 5014 free(s); 5015 // undefined object 5016 r2 = self->f->pushUndefined(self); 5017 ck_assert_ptr_ne(r2, null); 5018 r = cropElemO(self,2); 5019 ck_assert_ptr_ne(r, null); 5020 s = toStringO(r); 5021 terminateO(r); 5022 ck_assert_str_eq(s, "null"); 5023 free(s); 5024 s = toStringO(self); 5025 ck_assert_str_eq(s, "[1,3]"); 5026 free(s); 5027 // container 5028 createSmallContainer(c); 5029 r2 = self->f->pushSmallContainer(self, &c); 5030 r = cropElemO(self,2); 5031 ck_assert_ptr_ne(r, null); 5032 s = toStringO(r); 5033 terminateO(r); 5034 ck_assert_str_eq(s, "<data smallContainer>"); 5035 free(s); 5036 s = toStringO(self); 5037 ck_assert_str_eq(s, "[1,3]"); 5038 free(s); 5039 // base object in container 5040 createAllocateSmallInt(I); 5041 setValG(I, 11); 5042 I->type = "anothertype"; 5043 r2 = self->f->push(self, (baset*)I); 5044 r = cropElemO(self,2); 5045 ck_assert_ptr_ne(r, null); 5046 ck_assert_str_eq(r->type, "anothertype"); 5047 s = toStringO(r); 5048 terminateO(r); 5049 ck_assert_str_eq(s, "11"); 5050 free(s); 5051 s = toStringO(self); 5052 ck_assert_str_eq(s, "[1,3]"); 5053 free(s); 5054 // index outside 5055 ck_assert_ptr_eq(cropElemO(self, 20), NULL); 5056 ck_assert_ptr_eq(cropElemO(self, -4), NULL); 5057 // empty list 5058 emptyO(self); 5059 ck_assert_ptr_eq(cropElemO(self, 0), NULL); 5060 ck_assert_ptr_eq(cropElemO(self, -1), NULL); 5061 // crop empty slot in array 5062 r2 = self->f->pushUndefined(self); 5063 ck_assert_ptr_ne(r2, null); 5064 delElemO(self,0); 5065 ck_assert_ptr_eq(cropElemO(self, 0), NULL); 5066 terminateO(self); 5067 5068 } 5069 5070 5071 void cropElemUndefinedSmallArrayT(void) { 5072 5073 undefinedt* r; 5074 smallArrayt *self = allocG(rtSmallArrayt); 5075 smallArrayt *r2; 5076 5077 // add elements to self 5078 r2 = self->f->pushInt(self, 1); 5079 ck_assert_ptr_ne(r2, null); 5080 r2 = self->f->pushUndefined(self); 5081 ck_assert_ptr_ne(r2, null); 5082 r2 = self->f->pushInt(self, 3); 5083 ck_assert_ptr_ne(r2, null); 5084 r2 = self->f->pushUndefined(self); 5085 ck_assert_ptr_ne(r2, null); 5086 5087 // positive index 5088 r = cropElemUndefinedO(self,1); 5089 ck_assert_ptr_ne(r, null); 5090 char *s = toStringO(r); 5091 terminateO(r); 5092 ck_assert_str_eq(s, "null"); 5093 free(s); 5094 s = toStringO(self); 5095 ck_assert_str_eq(s, "[1,3,null]"); 5096 free(s); 5097 // negative index 5098 r = cropElemUndefinedO(self,-1); 5099 ck_assert_ptr_ne(r, null); 5100 s = toStringO(r); 5101 terminateO(r); 5102 ck_assert_str_eq(s, "null"); 5103 free(s); 5104 s = toStringO(self); 5105 ck_assert_str_eq(s, "[1,3]"); 5106 free(s); 5107 // wrong object type 5108 createSmallInt(I); 5109 setValG(&I, 11); 5110 r2 = self->f->pushSmallInt(self, &I); 5111 ck_assert_ptr_ne(r2, null); 5112 r = cropElemUndefinedO(self,2); 5113 ck_assert_ptr_eq(r, null); 5114 s = toStringO(self); 5115 ck_assert_str_eq(s, "[1,3,11]"); 5116 free(s); 5117 // index outside 5118 ck_assert_ptr_eq(cropElemUndefinedO(self, 20), NULL); 5119 ck_assert_ptr_eq(cropElemUndefinedO(self, -4), NULL); 5120 // empty list 5121 emptyO(self); 5122 ck_assert_ptr_eq(cropElemUndefinedO(self, 0), NULL); 5123 ck_assert_ptr_eq(cropElemUndefinedO(self, -1), NULL); 5124 // crop empty slot in array 5125 r2 = self->f->pushUndefined(self); 5126 ck_assert_ptr_ne(r2, null); 5127 delElemO(self,0); 5128 ck_assert_ptr_eq(cropElemUndefinedO(self, 0), NULL); 5129 terminateO(self); 5130 5131 } 5132 5133 5134 void cropElemBoolSmallArrayT(void) { 5135 5136 bool r; 5137 smallArrayt *self = allocG(rtSmallArrayt); 5138 smallArrayt *r2; 5139 5140 // add elements to self 5141 r2 = self->f->pushInt(self, 1); 5142 ck_assert_ptr_ne(r2, null); 5143 r2 = self->f->pushBool(self, TRUE); 5144 ck_assert_ptr_ne(r2, null); 5145 r2 = self->f->pushInt(self, 3); 5146 ck_assert_ptr_ne(r2, null); 5147 r2 = self->f->pushBool(self, TRUE); 5148 ck_assert_ptr_ne(r2, null); 5149 5150 // positive index 5151 r = cropElemBoolO(self,1); 5152 ck_assert(r); 5153 char *s = toStringO(self); 5154 ck_assert_str_eq(s, "[1,3,true]"); 5155 free(s); 5156 // negative index 5157 r = cropElemBoolO(self,-1); 5158 ck_assert(r); 5159 s = toStringO(self); 5160 ck_assert_str_eq(s, "[1,3]"); 5161 free(s); 5162 // wrong object type 5163 createSmallInt(I); 5164 setValG(&I, 11); 5165 r2 = self->f->pushSmallInt(self, &I); 5166 r = cropElemBoolO(self,2); 5167 ck_assert(!r); 5168 s = toStringO(self); 5169 ck_assert_str_eq(s, "[1,3,11]"); 5170 free(s); 5171 // wrong object type of another user class 5172 // User classes are stored in containers transparently 5173 createAllocateSmallInt(ip); 5174 ip->type = "anothertype"; 5175 setValG(ip, 11); 5176 r2 = self->f->push(self, (baset*)ip); 5177 ck_assert_ptr_ne(r2, null); 5178 r = cropElemBoolO(self,3); 5179 ck_assert(!r); 5180 s = toStringO(self); 5181 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5182 free(s); 5183 // index outside 5184 ck_assert(!cropElemBoolO(self, 20)); 5185 ck_assert(!cropElemBoolO(self, -5)); 5186 // empty list 5187 emptyO(self); 5188 ck_assert(!cropElemBoolO(self, 0)); 5189 ck_assert(!cropElemBoolO(self, -1)); 5190 // crop empty slot in array 5191 r2 = self->f->pushUndefined(self); 5192 ck_assert_ptr_ne(r2, null); 5193 delElemO(self,0); 5194 ck_assert(!cropElemBoolO(self, 0)); 5195 terminateO(self); 5196 5197 } 5198 5199 5200 void cropElemDoubleSmallArrayT(void) { 5201 5202 double r; 5203 smallArrayt *self = allocG(rtSmallArrayt); 5204 smallArrayt *r2; 5205 5206 // add elements to self 5207 r2 = self->f->pushInt(self, 1); 5208 ck_assert_ptr_ne(r2, null); 5209 r2 = self->f->pushDouble(self, 2); 5210 ck_assert_ptr_ne(r2, null); 5211 r2 = self->f->pushInt(self, 3); 5212 ck_assert_ptr_ne(r2, null); 5213 r2 = self->f->pushDouble(self, 4); 5214 ck_assert_ptr_ne(r2, null); 5215 5216 // positive index 5217 r = cropElemDoubleO(self,1); 5218 ck_assert(r==2); 5219 char *s = toStringO(self); 5220 ck_assert_str_eq(s, "[1,3,4.000000e+00]"); 5221 free(s); 5222 // negative index 5223 r = cropElemDoubleO(self,-1); 5224 ck_assert(r==4); 5225 s = toStringO(self); 5226 ck_assert_str_eq(s, "[1,3]"); 5227 free(s); 5228 // wrong object type 5229 createSmallInt(I); 5230 setValG(&I, 11); 5231 r2 = self->f->pushSmallInt(self, &I); 5232 r = cropElemDoubleO(self,2); 5233 ck_assert(!r); 5234 s = toStringO(self); 5235 ck_assert_str_eq(s, "[1,3,11]"); 5236 free(s); 5237 // wrong object type of another user class 5238 // User classes are stored in containers transparently 5239 createAllocateSmallInt(ip); 5240 ip->type = "anothertype"; 5241 setValG(ip, 11); 5242 r2 = self->f->push(self, (baset*)ip); 5243 ck_assert_ptr_ne(r2, null); 5244 r = cropElemDoubleO(self,3); 5245 ck_assert(!r); 5246 s = toStringO(self); 5247 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5248 free(s); 5249 // index outside 5250 ck_assert(!cropElemDoubleO(self, 20)); 5251 ck_assert(!cropElemDoubleO(self, -5)); 5252 // empty list 5253 emptyO(self); 5254 ck_assert(!cropElemDoubleO(self, 0)); 5255 ck_assert(!cropElemDoubleO(self, -1)); 5256 // crop empty slot in array 5257 r2 = self->f->pushUndefined(self); 5258 ck_assert_ptr_ne(r2, null); 5259 delElemO(self,0); 5260 ck_assert(!cropElemDoubleO(self, 0)); 5261 terminateO(self); 5262 5263 } 5264 5265 5266 void cropElemIntSmallArrayT(void) { 5267 5268 int64_t r; 5269 smallArrayt *self = allocG(rtSmallArrayt); 5270 smallArrayt *r2; 5271 5272 // add elements to self 5273 r2 = self->f->pushInt(self, 1); 5274 ck_assert_ptr_ne(r2, null); 5275 r2 = self->f->pushInt(self, 2); 5276 ck_assert_ptr_ne(r2, null); 5277 r2 = self->f->pushInt(self, 3); 5278 ck_assert_ptr_ne(r2, null); 5279 r2 = self->f->pushInt(self, 4); 5280 ck_assert_ptr_ne(r2, null); 5281 5282 // positive index 5283 r = cropElemIntO(self,1); 5284 ck_assert(r==2); 5285 char *s = toStringO(self); 5286 ck_assert_str_eq(s, "[1,3,4]"); 5287 free(s); 5288 // negative index 5289 r = cropElemIntO(self,-1); 5290 ck_assert(r==4); 5291 s = toStringO(self); 5292 ck_assert_str_eq(s, "[1,3]"); 5293 free(s); 5294 // wrong object type 5295 createSmallDouble(I); 5296 setValG(&I, 11); 5297 r2 = self->f->pushSmallDouble(self, &I); 5298 r = cropElemIntO(self,2); 5299 ck_assert(!r); 5300 s = toStringO(self); 5301 ck_assert_str_eq(s, "[1,3,1.100000e+01]"); 5302 free(s); 5303 // wrong object type of another user class 5304 // User classes are stored in containers transparently 5305 createAllocateSmallInt(ip); 5306 ip->type = "anothertype"; 5307 setValG(ip, 11); 5308 r2 = self->f->push(self, (baset*)ip); 5309 ck_assert_ptr_ne(r2, null); 5310 r = cropElemIntO(self,3); 5311 ck_assert(!r); 5312 s = toStringO(self); 5313 ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]"); 5314 free(s); 5315 // index outside 5316 ck_assert(!cropElemIntO(self, 20)); 5317 ck_assert(!cropElemIntO(self, -5)); 5318 // empty list 5319 emptyO(self); 5320 ck_assert(!cropElemIntO(self, 0)); 5321 ck_assert(!cropElemIntO(self, -1)); 5322 // crop empty slot in array 5323 r2 = self->f->pushUndefined(self); 5324 ck_assert_ptr_ne(r2, null); 5325 delElemO(self,0); 5326 ck_assert_int_eq(cropElemIntO(self, 0), 0); 5327 terminateO(self); 5328 5329 } 5330 5331 5332 void cropElemInt32SmallArrayT(void) { 5333 5334 int32_t r; 5335 smallArrayt *self = allocG(rtSmallArrayt); 5336 smallArrayt *r2; 5337 5338 // add elements to self 5339 r2 = self->f->pushInt(self, 1); 5340 ck_assert_ptr_ne(r2, null); 5341 r2 = self->f->pushInt(self, 2); 5342 ck_assert_ptr_ne(r2, null); 5343 r2 = self->f->pushInt(self, 3); 5344 ck_assert_ptr_ne(r2, null); 5345 r2 = self->f->pushInt(self, 4); 5346 ck_assert_ptr_ne(r2, null); 5347 5348 // positive index 5349 r = cropElemInt32O(self,1); 5350 ck_assert(r==2); 5351 char *s = toStringO(self); 5352 ck_assert_str_eq(s, "[1,3,4]"); 5353 free(s); 5354 // negative index 5355 r = cropElemInt32O(self,-1); 5356 ck_assert(r==4); 5357 s = toStringO(self); 5358 ck_assert_str_eq(s, "[1,3]"); 5359 free(s); 5360 // wrong object type 5361 createSmallDouble(I); 5362 setValG(&I, 11); 5363 r2 = self->f->pushSmallDouble(self, &I); 5364 r = cropElemInt32O(self,2); 5365 ck_assert(!r); 5366 s = toStringO(self); 5367 ck_assert_str_eq(s, "[1,3,1.100000e+01]"); 5368 free(s); 5369 // wrong object type of another user class 5370 // User classes are stored in containers transparently 5371 createAllocateSmallInt(ip); 5372 ip->type = "anothertype"; 5373 setValG(ip, 11); 5374 r2 = self->f->push(self, (baset*)ip); 5375 ck_assert_ptr_ne(r2, null); 5376 r = cropElemInt32O(self,3); 5377 ck_assert(!r); 5378 s = toStringO(self); 5379 ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]"); 5380 free(s); 5381 // index outside 5382 ck_assert(!cropElemInt32O(self, 20)); 5383 ck_assert(!cropElemInt32O(self, -5)); 5384 // empty list 5385 emptyO(self); 5386 ck_assert(!cropElemInt32O(self, 0)); 5387 ck_assert(!cropElemInt32O(self, -1)); 5388 // crop empty slot in array 5389 r2 = self->f->pushUndefined(self); 5390 ck_assert_ptr_ne(r2, null); 5391 delElemO(self,0); 5392 ck_assert_int_eq(cropElemInt32O(self, 0), 0); 5393 terminateO(self); 5394 5395 } 5396 5397 5398 void cropElemUintSmallArrayT(void) { 5399 5400 uint64_t r; 5401 smallArrayt *self = allocG(rtSmallArrayt); 5402 smallArrayt *r2; 5403 5404 // add elements to self 5405 r2 = self->f->pushInt(self, 1); 5406 ck_assert_ptr_ne(r2, null); 5407 r2 = self->f->pushInt(self, 2); 5408 ck_assert_ptr_ne(r2, null); 5409 r2 = self->f->pushInt(self, 3); 5410 ck_assert_ptr_ne(r2, null); 5411 r2 = self->f->pushInt(self, 4); 5412 ck_assert_ptr_ne(r2, null); 5413 5414 // positive index 5415 r = cropElemUintO(self,1); 5416 ck_assert(r==2); 5417 char *s = toStringO(self); 5418 ck_assert_str_eq(s, "[1,3,4]"); 5419 free(s); 5420 // negative index 5421 r = cropElemUintO(self,-1); 5422 ck_assert(r==4); 5423 s = toStringO(self); 5424 ck_assert_str_eq(s, "[1,3]"); 5425 free(s); 5426 // wrong object type 5427 createSmallDouble(I); 5428 setValG(&I, 11); 5429 r2 = self->f->pushSmallDouble(self, &I); 5430 r = cropElemUintO(self,2); 5431 ck_assert(!r); 5432 s = toStringO(self); 5433 ck_assert_str_eq(s, "[1,3,1.100000e+01]"); 5434 free(s); 5435 // wrong object type of another user class 5436 // User classes are stored in containers transparently 5437 createAllocateSmallInt(ip); 5438 ip->type = "anothertype"; 5439 setValG(ip, 11); 5440 r2 = self->f->push(self, (baset*)ip); 5441 ck_assert_ptr_ne(r2, null); 5442 r = cropElemUintO(self,3); 5443 ck_assert(!r); 5444 s = toStringO(self); 5445 ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]"); 5446 free(s); 5447 // index outside 5448 ck_assert(!cropElemUintO(self, 20)); 5449 ck_assert(!cropElemUintO(self, -5)); 5450 // empty list 5451 emptyO(self); 5452 ck_assert(!cropElemUintO(self, 0)); 5453 ck_assert(!cropElemUintO(self, -1)); 5454 // crop empty slot in array 5455 r2 = self->f->pushUndefined(self); 5456 ck_assert_ptr_ne(r2, null); 5457 delElemO(self,0); 5458 ck_assert_int_eq(cropElemUintO(self, 0), 0); 5459 terminateO(self); 5460 5461 } 5462 5463 5464 void cropElemUint32SmallArrayT(void) { 5465 5466 uint32_t r; 5467 smallArrayt *self = allocG(rtSmallArrayt); 5468 smallArrayt *r2; 5469 5470 // add elements to self 5471 r2 = self->f->pushInt(self, 1); 5472 ck_assert_ptr_ne(r2, null); 5473 r2 = self->f->pushInt(self, 2); 5474 ck_assert_ptr_ne(r2, null); 5475 r2 = self->f->pushInt(self, 3); 5476 ck_assert_ptr_ne(r2, null); 5477 r2 = self->f->pushInt(self, 4); 5478 ck_assert_ptr_ne(r2, null); 5479 5480 // positive index 5481 r = cropElemUint32O(self,1); 5482 ck_assert(r==2); 5483 char *s = toStringO(self); 5484 ck_assert_str_eq(s, "[1,3,4]"); 5485 free(s); 5486 // negative index 5487 r = cropElemUint32O(self,-1); 5488 ck_assert(r==4); 5489 s = toStringO(self); 5490 ck_assert_str_eq(s, "[1,3]"); 5491 free(s); 5492 // wrong object type 5493 createSmallDouble(I); 5494 setValG(&I, 11); 5495 r2 = self->f->pushSmallDouble(self, &I); 5496 r = cropElemUint32O(self,2); 5497 ck_assert(!r); 5498 s = toStringO(self); 5499 ck_assert_str_eq(s, "[1,3,1.100000e+01]"); 5500 free(s); 5501 // wrong object type of another user class 5502 // User classes are stored in containers transparently 5503 createAllocateSmallInt(ip); 5504 ip->type = "anothertype"; 5505 setValG(ip, 11); 5506 r2 = self->f->push(self, (baset*)ip); 5507 ck_assert_ptr_ne(r2, null); 5508 r = cropElemUint32O(self,3); 5509 ck_assert(!r); 5510 s = toStringO(self); 5511 ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]"); 5512 free(s); 5513 // index outside 5514 ck_assert(!cropElemUint32O(self, 20)); 5515 ck_assert(!cropElemUint32O(self, -5)); 5516 // empty list 5517 emptyO(self); 5518 ck_assert(!cropElemUint32O(self, 0)); 5519 ck_assert(!cropElemUint32O(self, -1)); 5520 // crop empty slot in array 5521 r2 = self->f->pushUndefined(self); 5522 ck_assert_ptr_ne(r2, null); 5523 delElemO(self,0); 5524 ck_assert_int_eq(cropElemUint32O(self, 0), 0); 5525 terminateO(self); 5526 5527 } 5528 5529 5530 void cropElemSSmallArrayT(void) { 5531 5532 char* r; 5533 smallArrayt *self = allocG(rtSmallArrayt); 5534 smallArrayt *r2; 5535 5536 // add elements to self 5537 r2 = self->f->pushInt(self, 1); 5538 ck_assert_ptr_ne(r2, null); 5539 r2 = self->f->pushS(self, "2"); 5540 ck_assert_ptr_ne(r2, null); 5541 r2 = self->f->pushInt(self, 3); 5542 ck_assert_ptr_ne(r2, null); 5543 r2 = self->f->pushS(self, "4"); 5544 ck_assert_ptr_ne(r2, null); 5545 5546 // positive index 5547 r = cropElemSO(self,1); 5548 ck_assert_ptr_ne(r, null); 5549 ck_assert_str_eq(r, "2"); 5550 free(r); 5551 char *s = toStringO(self); 5552 ck_assert_str_eq(s, "[1,3,\"4\"]"); 5553 free(s); 5554 // negative index 5555 r = cropElemSO(self,-1); 5556 ck_assert_ptr_ne(r, null); 5557 ck_assert_str_eq(r, "4"); 5558 free(r); 5559 s = toStringO(self); 5560 ck_assert_str_eq(s, "[1,3]"); 5561 free(s); 5562 // wrong object type 5563 createSmallInt(I); 5564 setValG(&I, 11); 5565 r2 = self->f->pushSmallInt(self, &I); 5566 r = cropElemSO(self,2); 5567 ck_assert_ptr_eq(r, NULL); 5568 s = toStringO(self); 5569 ck_assert_str_eq(s, "[1,3,11]"); 5570 free(s); 5571 // wrong object type of another user class 5572 // User classes are stored in containers transparently 5573 createAllocateSmallInt(ip); 5574 ip->type = "anothertype"; 5575 setValG(ip, 11); 5576 r2 = self->f->push(self, (baset*)ip); 5577 ck_assert_ptr_ne(r2, null); 5578 r = cropElemSO(self,3); 5579 ck_assert_ptr_eq(r, NULL); 5580 s = toStringO(self); 5581 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5582 free(s); 5583 // index outside 5584 ck_assert_ptr_eq(cropElemSO(self, 20), NULL); 5585 ck_assert_ptr_eq(cropElemSO(self, -5), NULL); 5586 // empty list 5587 emptyO(self); 5588 ck_assert_ptr_eq(cropElemSO(self, 0), NULL); 5589 ck_assert_ptr_eq(cropElemSO(self, -1), NULL); 5590 // crop empty slot in array 5591 r2 = self->f->pushUndefined(self); 5592 ck_assert_ptr_ne(r2, null); 5593 delElemO(self,0); 5594 ck_assert_ptr_eq(cropElemSO(self, 0), NULL); 5595 terminateO(self); 5596 5597 } 5598 5599 5600 void cropElemDictSmallArrayT(void) { 5601 5602 smallDictt* r; 5603 smallArrayt *self = allocG(rtSmallArrayt); 5604 smallArrayt *r2; 5605 5606 // add elements to self 5607 r2 = self->f->pushInt(self, 1); 5608 ck_assert_ptr_ne(r2, null); 5609 createSmallDict(e2); 5610 r2 = self->f->pushDict(self, &e2); 5611 ck_assert_ptr_ne(r2, null); 5612 r2 = self->f->pushInt(self, 3); 5613 ck_assert_ptr_ne(r2, null); 5614 createSmallDict(e4); 5615 r2 = self->f->pushDict(self, &e4); 5616 ck_assert_ptr_ne(r2, null); 5617 5618 // positive index 5619 r = cropElemDictO(self,1); 5620 ck_assert_ptr_ne(r, null); 5621 char *s = toStringO(r); 5622 terminateO(r); 5623 ck_assert_str_eq(s, "{}"); 5624 free(s); 5625 s = toStringO(self); 5626 ck_assert_str_eq(s, "[1,3,{}]"); 5627 free(s); 5628 // negative index 5629 r = cropElemDictO(self,-1); 5630 ck_assert_ptr_ne(r, null); 5631 s = toStringO(r); 5632 terminateO(r); 5633 ck_assert_str_eq(s, "{}"); 5634 free(s); 5635 s = toStringO(self); 5636 ck_assert_str_eq(s, "[1,3]"); 5637 free(s); 5638 // wrong object type 5639 createSmallInt(I); 5640 setValG(&I, 11); 5641 r2 = self->f->pushSmallInt(self, &I); 5642 r = cropElemDictO(self,2); 5643 ck_assert_ptr_eq(r, NULL); 5644 s = toStringO(self); 5645 ck_assert_str_eq(s, "[1,3,11]"); 5646 free(s); 5647 // wrong object type of another user class 5648 // User classes are stored in containers transparently 5649 createAllocateSmallInt(ip); 5650 ip->type = "anothertype"; 5651 setValG(ip, 11); 5652 r2 = self->f->push(self, (baset*)ip); 5653 ck_assert_ptr_ne(r2, null); 5654 r = cropElemDictO(self,3); 5655 ck_assert_ptr_eq(r, NULL); 5656 s = toStringO(self); 5657 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5658 free(s); 5659 // index outside 5660 ck_assert_ptr_eq(cropElemDictO(self, 20), NULL); 5661 ck_assert_ptr_eq(cropElemDictO(self, -5), NULL); 5662 // empty list 5663 emptyO(self); 5664 ck_assert_ptr_eq(cropElemDictO(self, 0), NULL); 5665 ck_assert_ptr_eq(cropElemDictO(self, -1), NULL); 5666 // crop empty slot in array 5667 r2 = self->f->pushUndefined(self); 5668 ck_assert_ptr_ne(r2, null); 5669 delElemO(self,0); 5670 ck_assert_ptr_eq(cropElemDictO(self, 0), NULL); 5671 terminateO(self); 5672 5673 } 5674 5675 5676 void cropElemArraySmallArrayT(void) { 5677 5678 smallArrayt* r; 5679 smallArrayt *self = allocG(rtSmallArrayt); 5680 smallArrayt *r2; 5681 5682 // add elements to self 5683 r2 = self->f->pushInt(self, 1); 5684 ck_assert_ptr_ne(r2, null); 5685 createSmallArray(e2); 5686 r2 = self->f->pushArray(self, &e2); 5687 ck_assert_ptr_ne(r2, null); 5688 r2 = self->f->pushInt(self, 3); 5689 ck_assert_ptr_ne(r2, null); 5690 createSmallArray(e4); 5691 r2 = self->f->pushArray(self, &e4); 5692 ck_assert_ptr_ne(r2, null); 5693 5694 // positive index 5695 r = cropElemArrayO(self,1); 5696 ck_assert_ptr_ne(r, null); 5697 char *s = toStringO(r); 5698 terminateO(r); 5699 ck_assert_str_eq(s, "[]"); 5700 free(s); 5701 s = toStringO(self); 5702 ck_assert_str_eq(s, "[1,3,[]]"); 5703 free(s); 5704 // negative index 5705 r = cropElemArrayO(self,-1); 5706 ck_assert_ptr_ne(r, null); 5707 s = toStringO(r); 5708 terminateO(r); 5709 ck_assert_str_eq(s, "[]"); 5710 free(s); 5711 s = toStringO(self); 5712 ck_assert_str_eq(s, "[1,3]"); 5713 free(s); 5714 // wrong object type 5715 createSmallInt(I); 5716 setValG(&I, 11); 5717 r2 = self->f->pushSmallInt(self, &I); 5718 r = cropElemArrayO(self,2); 5719 ck_assert_ptr_eq(r, NULL); 5720 s = toStringO(self); 5721 ck_assert_str_eq(s, "[1,3,11]"); 5722 free(s); 5723 // wrong object type of another user class 5724 // User classes are stored in containers transparently 5725 createAllocateSmallInt(ip); 5726 ip->type = "anothertype"; 5727 setValG(ip, 11); 5728 r2 = self->f->push(self, (baset*)ip); 5729 ck_assert_ptr_ne(r2, null); 5730 r = cropElemArrayO(self,3); 5731 ck_assert_ptr_eq(r, NULL); 5732 s = toStringO(self); 5733 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5734 free(s); 5735 // index outside 5736 ck_assert_ptr_eq(cropElemArrayO(self, 20), NULL); 5737 ck_assert_ptr_eq(cropElemArrayO(self, -5), NULL); 5738 // empty list 5739 emptyO(self); 5740 ck_assert_ptr_eq(cropElemArrayO(self, 0), NULL); 5741 ck_assert_ptr_eq(cropElemArrayO(self, -1), NULL); 5742 // crop empty slot in array 5743 r2 = self->f->pushUndefined(self); 5744 ck_assert_ptr_ne(r2, null); 5745 delElemO(self,0); 5746 ck_assert_ptr_eq(cropElemArrayO(self, 0), NULL); 5747 terminateO(self); 5748 5749 } 5750 5751 5752 void cropElemSmallBoolSmallArrayT(void) { 5753 5754 smallBoolt* r; 5755 smallArrayt *self = allocG(rtSmallArrayt); 5756 smallArrayt *r2; 5757 5758 // add elements to self 5759 r2 = self->f->pushInt(self, 1); 5760 ck_assert_ptr_ne(r2, null); 5761 createSmallBool(e2); 5762 r2 = self->f->pushBool(self, true); 5763 ck_assert_ptr_ne(r2, null); 5764 r2 = self->f->pushInt(self, 3); 5765 ck_assert_ptr_ne(r2, null); 5766 createSmallBool(e4); 5767 r2 = self->f->pushBool(self, true); 5768 ck_assert_ptr_ne(r2, null); 5769 5770 // positive index 5771 r = cropElemSmallBoolO(self,1); 5772 ck_assert_ptr_ne(r, null); 5773 char *s = toStringO(r); 5774 terminateO(r); 5775 ck_assert_str_eq(s, "true"); 5776 free(s); 5777 s = toStringO(self); 5778 ck_assert_str_eq(s, "[1,3,true]"); 5779 free(s); 5780 // negative index 5781 r = cropElemSmallBoolO(self,-1); 5782 ck_assert_ptr_ne(r, null); 5783 s = toStringO(r); 5784 terminateO(r); 5785 ck_assert_str_eq(s, "true"); 5786 free(s); 5787 s = toStringO(self); 5788 ck_assert_str_eq(s, "[1,3]"); 5789 free(s); 5790 // wrong object type 5791 createSmallInt(I); 5792 setValG(&I, 11); 5793 r2 = self->f->pushSmallInt(self, &I); 5794 r = cropElemSmallBoolO(self,2); 5795 ck_assert_ptr_eq(r, NULL); 5796 s = toStringO(self); 5797 ck_assert_str_eq(s, "[1,3,11]"); 5798 free(s); 5799 // wrong object type of another user class 5800 // User classes are stored in containers transparently 5801 createAllocateSmallInt(ip); 5802 ip->type = "anothertype"; 5803 setValG(ip, 11); 5804 r2 = self->f->push(self, (baset*)ip); 5805 ck_assert_ptr_ne(r2, null); 5806 r = cropElemSmallBoolO(self,3); 5807 ck_assert_ptr_eq(r, NULL); 5808 s = toStringO(self); 5809 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5810 free(s); 5811 // index outside 5812 ck_assert_ptr_eq(cropElemSmallBoolO(self, 20), NULL); 5813 ck_assert_ptr_eq(cropElemSmallBoolO(self, -5), NULL); 5814 // empty list 5815 emptyO(self); 5816 ck_assert_ptr_eq(cropElemSmallBoolO(self, 0), NULL); 5817 ck_assert_ptr_eq(cropElemSmallBoolO(self, -1), NULL); 5818 // crop empty slot in array 5819 r2 = self->f->pushUndefined(self); 5820 ck_assert_ptr_ne(r2, null); 5821 delElemO(self,0); 5822 ck_assert_ptr_eq(cropElemSmallBoolO(self, 0), NULL); 5823 terminateO(self); 5824 5825 } 5826 5827 5828 void cropElemSmallBytesSmallArrayT(void) { 5829 5830 smallBytest* r; 5831 smallArrayt *self = allocG(rtSmallArrayt); 5832 smallArrayt *r2; 5833 5834 // add elements to self 5835 r2 = self->f->pushInt(self, 1); 5836 ck_assert_ptr_ne(r2, null); 5837 createSmallBytes(e2); 5838 r2 = self->f->pushSmallBytes(self, &e2); 5839 ck_assert_ptr_ne(r2, null); 5840 r2 = self->f->pushInt(self, 3); 5841 ck_assert_ptr_ne(r2, null); 5842 createSmallBytes(e4); 5843 r2 = self->f->pushSmallBytes(self, &e4); 5844 ck_assert_ptr_ne(r2, null); 5845 5846 // positive index 5847 r = cropElemSmallBytesO(self,1); 5848 ck_assert_ptr_ne(r, null); 5849 char *s = toStringO(r); 5850 terminateO(r); 5851 ck_assert_str_eq(s, "[]"); 5852 free(s); 5853 s = toStringO(self); 5854 ck_assert_str_eq(s, "[1,3,[]]"); 5855 free(s); 5856 // negative index 5857 r = cropElemSmallBytesO(self,-1); 5858 ck_assert_ptr_ne(r, null); 5859 s = toStringO(r); 5860 terminateO(r); 5861 ck_assert_str_eq(s, "[]"); 5862 free(s); 5863 s = toStringO(self); 5864 ck_assert_str_eq(s, "[1,3]"); 5865 free(s); 5866 // wrong object type 5867 createSmallInt(I); 5868 setValG(&I, 11); 5869 r2 = self->f->pushSmallInt(self, &I); 5870 r = cropElemSmallBytesO(self,2); 5871 ck_assert_ptr_eq(r, NULL); 5872 s = toStringO(self); 5873 ck_assert_str_eq(s, "[1,3,11]"); 5874 free(s); 5875 // wrong object type of another user class 5876 // User classes are stored in containers transparently 5877 createAllocateSmallInt(ip); 5878 ip->type = "anothertype"; 5879 setValG(ip, 11); 5880 r2 = self->f->push(self, (baset*)ip); 5881 ck_assert_ptr_ne(r2, null); 5882 r = cropElemSmallBytesO(self,3); 5883 ck_assert_ptr_eq(r, NULL); 5884 s = toStringO(self); 5885 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5886 free(s); 5887 // index outside 5888 ck_assert_ptr_eq(cropElemSmallBytesO(self, 20), NULL); 5889 ck_assert_ptr_eq(cropElemSmallBytesO(self, -5), NULL); 5890 // empty list 5891 emptyO(self); 5892 ck_assert_ptr_eq(cropElemSmallBytesO(self, 0), NULL); 5893 ck_assert_ptr_eq(cropElemSmallBytesO(self, -1), NULL); 5894 // crop empty slot in array 5895 r2 = self->f->pushUndefined(self); 5896 ck_assert_ptr_ne(r2, null); 5897 delElemO(self,0); 5898 ck_assert_ptr_eq(cropElemSmallBytesO(self, 0), NULL); 5899 terminateO(self); 5900 5901 } 5902 5903 5904 void cropElemSmallDoubleSmallArrayT(void) { 5905 5906 smallDoublet* r; 5907 smallArrayt *self = allocG(rtSmallArrayt); 5908 smallArrayt *r2; 5909 5910 // add elements to self 5911 r2 = self->f->pushInt(self, 1); 5912 ck_assert_ptr_ne(r2, null); 5913 createSmallDouble(e2); 5914 r2 = self->f->pushSmallDouble(self, &e2); 5915 ck_assert_ptr_ne(r2, null); 5916 r2 = self->f->pushInt(self, 3); 5917 ck_assert_ptr_ne(r2, null); 5918 createSmallDouble(e4); 5919 r2 = self->f->pushSmallDouble(self, &e4); 5920 ck_assert_ptr_ne(r2, null); 5921 5922 // positive index 5923 r = cropElemSmallDoubleO(self,1); 5924 ck_assert_ptr_ne(r, null); 5925 char *s = toStringO(r); 5926 terminateO(r); 5927 ck_assert_str_eq(s, "0.000000e+00"); 5928 free(s); 5929 s = toStringO(self); 5930 ck_assert_str_eq(s, "[1,3,0.000000e+00]"); 5931 free(s); 5932 // negative index 5933 r = cropElemSmallDoubleO(self,-1); 5934 ck_assert_ptr_ne(r, null); 5935 s = toStringO(r); 5936 terminateO(r); 5937 ck_assert_str_eq(s, "0.000000e+00"); 5938 free(s); 5939 s = toStringO(self); 5940 ck_assert_str_eq(s, "[1,3]"); 5941 free(s); 5942 // wrong object type 5943 createSmallInt(I); 5944 setValG(&I, 11); 5945 r2 = self->f->pushSmallInt(self, &I); 5946 r = cropElemSmallDoubleO(self,2); 5947 ck_assert_ptr_eq(r, NULL); 5948 s = toStringO(self); 5949 ck_assert_str_eq(s, "[1,3,11]"); 5950 free(s); 5951 // wrong object type of another user class 5952 // User classes are stored in containers transparently 5953 createAllocateSmallInt(ip); 5954 ip->type = "anothertype"; 5955 setValG(ip, 11); 5956 r2 = self->f->push(self, (baset*)ip); 5957 ck_assert_ptr_ne(r2, null); 5958 r = cropElemSmallDoubleO(self,3); 5959 ck_assert_ptr_eq(r, NULL); 5960 s = toStringO(self); 5961 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5962 free(s); 5963 // index outside 5964 ck_assert_ptr_eq(cropElemSmallDoubleO(self, 20), NULL); 5965 ck_assert_ptr_eq(cropElemSmallDoubleO(self, -5), NULL); 5966 // empty list 5967 emptyO(self); 5968 ck_assert_ptr_eq(cropElemSmallDoubleO(self, 0), NULL); 5969 ck_assert_ptr_eq(cropElemSmallDoubleO(self, -1), NULL); 5970 // crop empty slot in array 5971 r2 = self->f->pushUndefined(self); 5972 ck_assert_ptr_ne(r2, null); 5973 delElemO(self,0); 5974 ck_assert_ptr_eq(cropElemSmallDoubleO(self, 0), NULL); 5975 terminateO(self); 5976 5977 } 5978 5979 5980 void cropElemSmallIntSmallArrayT(void) { 5981 5982 smallIntt* r; 5983 smallArrayt *self = allocG(rtSmallArrayt); 5984 smallArrayt *r2; 5985 5986 // add elements to self 5987 r2 = self->f->pushBool(self, true); 5988 ck_assert_ptr_ne(r2, null); 5989 createSmallInt(e2); 5990 r2 = self->f->pushSmallInt(self, &e2); 5991 ck_assert_ptr_ne(r2, null); 5992 r2 = self->f->pushBool(self, true); 5993 ck_assert_ptr_ne(r2, null); 5994 createSmallInt(e4); 5995 r2 = self->f->pushSmallInt(self, &e4); 5996 ck_assert_ptr_ne(r2, null); 5997 5998 // positive index 5999 r = cropElemSmallIntO(self,1); 6000 ck_assert_ptr_ne(r, null); 6001 char *s = toStringO(r); 6002 terminateO(r); 6003 ck_assert_str_eq(s, "0"); 6004 free(s); 6005 s = toStringO(self); 6006 ck_assert_str_eq(s, "[true,true,0]"); 6007 free(s); 6008 // negative index 6009 r = cropElemSmallIntO(self,-1); 6010 ck_assert_ptr_ne(r, null); 6011 s = toStringO(r); 6012 terminateO(r); 6013 ck_assert_str_eq(s, "0"); 6014 free(s); 6015 s = toStringO(self); 6016 ck_assert_str_eq(s, "[true,true]"); 6017 free(s); 6018 // wrong object type 6019 createSmallDouble(I); 6020 setValG(&I, 11); 6021 r2 = self->f->pushSmallDouble(self, &I); 6022 r = cropElemSmallIntO(self,2); 6023 ck_assert_ptr_eq(r, NULL); 6024 s = toStringO(self); 6025 ck_assert_str_eq(s, "[true,true,1.100000e+01]"); 6026 free(s); 6027 // wrong object type of another user class 6028 // User classes are stored in containers transparently 6029 createAllocateSmallInt(ip); 6030 ip->type = "anothertype"; 6031 setValG(ip, 11); 6032 r2 = self->f->push(self, (baset*)ip); 6033 ck_assert_ptr_ne(r2, null); 6034 r = cropElemSmallIntO(self,3); 6035 ck_assert_ptr_eq(r, NULL); 6036 s = toStringO(self); 6037 ck_assert_str_eq(s, "[true,true,1.100000e+01,\"<data container>\"]"); 6038 free(s); 6039 // index outside 6040 ck_assert_ptr_eq(cropElemSmallIntO(self, 20), NULL); 6041 ck_assert_ptr_eq(cropElemSmallIntO(self, -5), NULL); 6042 // empty list 6043 emptyO(self); 6044 ck_assert_ptr_eq(cropElemSmallIntO(self, 0), NULL); 6045 ck_assert_ptr_eq(cropElemSmallIntO(self, -1), NULL); 6046 // crop empty slot in array 6047 r2 = self->f->pushUndefined(self); 6048 ck_assert_ptr_ne(r2, null); 6049 delElemO(self,0); 6050 ck_assert_ptr_eq(cropElemSmallIntO(self, 0), NULL); 6051 terminateO(self); 6052 6053 } 6054 6055 6056 void cropElemSmallJsonSmallArrayT(void) { 6057 6058 smallJsont* r; 6059 smallArrayt *self = allocG(rtSmallArrayt); 6060 smallArrayt *r2; 6061 6062 // add elements to self 6063 r2 = self->f->pushInt(self, 1); 6064 ck_assert_ptr_ne(r2, null); 6065 createSmallJson(e2); 6066 r2 = self->f->pushSmallJson(self, &e2); 6067 ck_assert_ptr_ne(r2, null); 6068 r2 = self->f->pushInt(self, 3); 6069 ck_assert_ptr_ne(r2, null); 6070 createSmallJson(e4); 6071 r2 = self->f->pushSmallJson(self, &e4); 6072 ck_assert_ptr_ne(r2, null); 6073 6074 // positive index 6075 r = cropElemSmallJsonO(self,1); 6076 ck_assert_ptr_ne(r, null); 6077 char *s = toStringO(r); 6078 terminateO(r); 6079 ck_assert_str_eq(s, "{}"); 6080 free(s); 6081 s = toStringO(self); 6082 ck_assert_str_eq(s, "[1,3,{}]"); 6083 free(s); 6084 // negative index 6085 r = cropElemSmallJsonO(self,-1); 6086 ck_assert_ptr_ne(r, null); 6087 s = toStringO(r); 6088 terminateO(r); 6089 ck_assert_str_eq(s, "{}"); 6090 free(s); 6091 s = toStringO(self); 6092 ck_assert_str_eq(s, "[1,3]"); 6093 free(s); 6094 // wrong object type 6095 createSmallBytes(I); 6096 r2 = self->f->pushSmallBytes(self, &I); 6097 r = cropElemSmallJsonO(self,2); 6098 ck_assert_ptr_eq(r, NULL); 6099 s = toStringO(self); 6100 ck_assert_str_eq(s, "[1,3,[]]"); 6101 free(s); 6102 // wrong object type of another user class 6103 // User classes are stored in containers transparently 6104 createAllocateSmallInt(ip); 6105 ip->type = "anothertype"; 6106 setValG(ip, 11); 6107 r2 = self->f->push(self, (baset*)ip); 6108 ck_assert_ptr_ne(r2, null); 6109 r = cropElemSmallJsonO(self,3); 6110 ck_assert_ptr_eq(r, NULL); 6111 s = toStringO(self); 6112 ck_assert_str_eq(s, "[1,3,[],\"<data container>\"]"); 6113 free(s); 6114 // index outside 6115 ck_assert_ptr_eq(cropElemSmallJsonO(self, 20), NULL); 6116 ck_assert_ptr_eq(cropElemSmallJsonO(self, -5), NULL); 6117 // empty list 6118 emptyO(self); 6119 ck_assert_ptr_eq(cropElemSmallJsonO(self, 0), NULL); 6120 ck_assert_ptr_eq(cropElemSmallJsonO(self, -1), NULL); 6121 // crop empty slot in array 6122 r2 = self->f->pushUndefined(self); 6123 ck_assert_ptr_ne(r2, null); 6124 delElemO(self,0); 6125 ck_assert_ptr_eq(cropElemSmallJsonO(self, 0), NULL); 6126 terminateO(self); 6127 6128 } 6129 6130 6131 void cropElemSmallStringSmallArrayT(void) { 6132 6133 smallStringt* r; 6134 smallArrayt *self = allocG(rtSmallArrayt); 6135 smallArrayt *r2; 6136 6137 // add elements to self 6138 r2 = self->f->pushInt(self, 1); 6139 ck_assert_ptr_ne(r2, null); 6140 createSmallString(e2); 6141 r2 = self->f->pushSmallString(self, &e2); 6142 ck_assert_ptr_ne(r2, null); 6143 r2 = self->f->pushInt(self, 3); 6144 ck_assert_ptr_ne(r2, null); 6145 createSmallString(e4); 6146 r2 = self->f->pushSmallString(self, &e4); 6147 ck_assert_ptr_ne(r2, null); 6148 6149 // positive index 6150 r = cropElemSmallStringO(self,1); 6151 ck_assert_ptr_ne(r, null); 6152 char *s = toStringO(r); 6153 terminateO(r); 6154 ck_assert_str_eq(s, ""); 6155 free(s); 6156 s = toStringO(self); 6157 ck_assert_str_eq(s, "[1,3,\"\"]"); 6158 free(s); 6159 // negative index 6160 r = cropElemSmallStringO(self,-1); 6161 ck_assert_ptr_ne(r, null); 6162 s = toStringO(r); 6163 terminateO(r); 6164 ck_assert_str_eq(s, ""); 6165 free(s); 6166 s = toStringO(self); 6167 ck_assert_str_eq(s, "[1,3]"); 6168 free(s); 6169 // wrong object type 6170 createSmallInt(I); 6171 setValG(&I, 11); 6172 r2 = self->f->pushSmallInt(self, &I); 6173 r = cropElemSmallStringO(self,2); 6174 ck_assert_ptr_eq(r, NULL); 6175 s = toStringO(self); 6176 ck_assert_str_eq(s, "[1,3,11]"); 6177 free(s); 6178 // wrong object type of another user class 6179 // User classes are stored in containers transparently 6180 createAllocateSmallInt(ip); 6181 ip->type = "anothertype"; 6182 setValG(ip, 11); 6183 r2 = self->f->push(self, (baset*)ip); 6184 ck_assert_ptr_ne(r2, null); 6185 r = cropElemSmallStringO(self,3); 6186 ck_assert_ptr_eq(r, NULL); 6187 s = toStringO(self); 6188 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 6189 free(s); 6190 // index outside 6191 ck_assert_ptr_eq(cropElemSmallStringO(self, 20), NULL); 6192 ck_assert_ptr_eq(cropElemSmallStringO(self, -5), NULL); 6193 // empty list 6194 emptyO(self); 6195 ck_assert_ptr_eq(cropElemSmallStringO(self, 0), NULL); 6196 ck_assert_ptr_eq(cropElemSmallStringO(self, -1), NULL); 6197 // crop empty slot in array 6198 r2 = self->f->pushUndefined(self); 6199 ck_assert_ptr_ne(r2, null); 6200 delElemO(self,0); 6201 ck_assert_ptr_eq(cropElemSmallStringO(self, 0), NULL); 6202 terminateO(self); 6203 6204 } 6205 6206 6207 void cropElemVoidSmallArrayT(void) { 6208 6209 void* r; 6210 smallArrayt *self = allocG(rtSmallArrayt); 6211 smallArrayt *r2; 6212 6213 // add elements to self 6214 r2 = self->f->pushInt(self, 1); 6215 ck_assert_ptr_ne(r2, null); 6216 r2 = pushVoidSmallArrayG(self, &r); 6217 ck_assert_ptr_ne(r2, null); 6218 r2 = self->f->pushInt(self, 3); 6219 ck_assert_ptr_ne(r2, null); 6220 r2 = pushVoidSmallArrayG(self, &self); 6221 ck_assert_ptr_ne(r2, null); 6222 6223 // positive index 6224 r = cropElemVoidO(self,1); 6225 ck_assert_ptr_eq(r, &r); 6226 char *s = toStringO(self); 6227 ck_assert_str_eq(s, "[1,3,\"<data container>\"]"); 6228 free(s); 6229 // negative index 6230 r = cropElemVoidO(self,-1); 6231 ck_assert_ptr_eq(r, &self); 6232 s = toStringO(self); 6233 ck_assert_str_eq(s, "[1,3]"); 6234 free(s); 6235 // wrong object type 6236 createSmallInt(I); 6237 setValG(&I, 11); 6238 r2 = self->f->pushSmallInt(self, &I); 6239 r = cropElemVoidO(self,2); 6240 ck_assert_ptr_eq(r, NULL); 6241 s = toStringO(self); 6242 ck_assert_str_eq(s, "[1,3,11]"); 6243 free(s); 6244 // wrong object type of another user class 6245 // User classes are stored in containers transparently 6246 createAllocateSmallInt(ip); 6247 ip->type = "anothertype"; 6248 setValG(ip, 11); 6249 r2 = self->f->push(self, (baset*)ip); 6250 ck_assert_ptr_ne(r2, null); 6251 r = cropElemVoidO(self,3); 6252 ck_assert_ptr_eq(r, NULL); 6253 s = toStringO(self); 6254 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 6255 free(s); 6256 // index outside 6257 ck_assert_ptr_eq(cropElemVoidO(self, 20), NULL); 6258 ck_assert_ptr_eq(cropElemVoidO(self, -5), NULL); 6259 // empty list 6260 emptyO(self); 6261 ck_assert_ptr_eq(cropElemVoidO(self, 0), NULL); 6262 ck_assert_ptr_eq(cropElemVoidO(self, -1), NULL); 6263 // crop empty slot in array 6264 r2 = self->f->pushUndefined(self); 6265 ck_assert_ptr_ne(r2, null); 6266 delElemO(self,0); 6267 ck_assert_ptr_eq(cropElemVoidO(self, 0), NULL); 6268 terminateO(self); 6269 6270 } 6271 6272 6273 void cropElemSmallContainerSmallArrayT(void) { 6274 6275 smallContainert* r; 6276 smallArrayt *self = allocG(rtSmallArrayt); 6277 smallArrayt *r2; 6278 6279 // add elements to self 6280 r2 = self->f->pushInt(self, 1); 6281 ck_assert_ptr_ne(r2, null); 6282 createSmallContainer(e2); 6283 r2 = self->f->pushSmallContainer(self, &e2); 6284 ck_assert_ptr_ne(r2, null); 6285 r2 = self->f->pushInt(self, 3); 6286 ck_assert_ptr_ne(r2, null); 6287 createSmallContainer(e4); 6288 r2 = self->f->pushSmallContainer(self, &e4); 6289 ck_assert_ptr_ne(r2, null); 6290 6291 // positive index 6292 r = cropElemSmallContainerO(self,1); 6293 ck_assert_ptr_ne(r, null); 6294 char *s = toStringO(r); 6295 terminateO(r); 6296 ck_assert_str_eq(s, "<data smallContainer>"); 6297 free(s); 6298 s = toStringO(self); 6299 ck_assert_str_eq(s, "[1,3,\"<data container>\"]"); 6300 free(s); 6301 // negative index 6302 r = cropElemSmallContainerO(self,-1); 6303 ck_assert_ptr_ne(r, null); 6304 s = toStringO(r); 6305 terminateO(r); 6306 ck_assert_str_eq(s, "<data smallContainer>"); 6307 free(s); 6308 s = toStringO(self); 6309 ck_assert_str_eq(s, "[1,3]"); 6310 free(s); 6311 // wrong object type 6312 createSmallInt(I); 6313 setValG(&I, 11); 6314 r2 = self->f->pushSmallInt(self, &I); 6315 r = cropElemSmallContainerO(self,2); 6316 ck_assert_ptr_eq(r, NULL); 6317 s = toStringO(self); 6318 ck_assert_str_eq(s, "[1,3,11]"); 6319 free(s); 6320 // wrong object type of another user class 6321 // User classes are stored in containers transparently 6322 createAllocateSmallInt(ip); 6323 ip->type = "anothertype"; 6324 setValG(ip, 11); 6325 r2 = self->f->push(self, (baset*)ip); 6326 ck_assert_ptr_ne(r2, null); 6327 r = cropElemSmallContainerO(self,3); 6328 ck_assert_ptr_eq(r, NULL); 6329 s = toStringO(self); 6330 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 6331 free(s); 6332 // index outside 6333 ck_assert_ptr_eq(cropElemSmallContainerO(self, 20), NULL); 6334 ck_assert_ptr_eq(cropElemSmallContainerO(self, -5), NULL); 6335 // empty list 6336 emptyO(self); 6337 ck_assert_ptr_eq(cropElemSmallContainerO(self, 0), NULL); 6338 ck_assert_ptr_eq(cropElemSmallContainerO(self, -1), NULL); 6339 // crop empty slot in array 6340 r2 = self->f->pushUndefined(self); 6341 ck_assert_ptr_ne(r2, null); 6342 delElemO(self,0); 6343 ck_assert_ptr_eq(cropElemSmallContainerO(self, 0), NULL); 6344 terminateO(self); 6345 6346 } 6347 6348 6349 void copySmallArrayT(void) { 6350 6351 smallArrayt* r; 6352 smallArrayt *self = allocG(rtSmallArrayt); 6353 6354 // add elements to self 6355 r = self->f->pushInt(self, 1); 6356 ck_assert_ptr_ne(r, null); 6357 r = self->f->pushInt(self, 2); 6358 ck_assert_ptr_ne(r, null); 6359 r = self->f->pushInt(self, 3); 6360 ck_assert_ptr_ne(r, null); 6361 r = self->f->pushInt(self, 4); 6362 ck_assert_ptr_ne(r, null); 6363 6364 // negative index 6365 r = copyRngO(self, 1, -1); 6366 ck_assert_ptr_ne(r, null); 6367 ck_assert_int_eq(lenO(r), 2); 6368 char *s = toStringO(r); 6369 terminateO(r); 6370 ck_assert_str_eq(s, "[2,3]"); 6371 free(s); 6372 s = toStringO(self); 6373 ck_assert_str_eq(s, "[1,2,3,4]"); 6374 free(s); 6375 // start outside 6376 ck_assert_ptr_eq(copyRngO(self, 20, -3), NULL); 6377 // end outside 6378 r = copyRngO(self, 0, 40); 6379 ck_assert_ptr_ne(r, null); 6380 ck_assert_int_eq(lenO(r), 4); 6381 s = toStringO(r); 6382 terminateO(r); 6383 ck_assert_str_eq(s, "[1,2,3,4]"); 6384 free(s); 6385 s = toStringO(self); 6386 ck_assert_str_eq(s, "[1,2,3,4]"); 6387 free(s); 6388 // end negative and outside 6389 ck_assert_ptr_eq(copyRngO(self, 2, -40), NULL); 6390 s = toStringO(self); 6391 ck_assert_str_eq(s, "[1,2,3,4]"); 6392 free(s); 6393 // end before start 6394 ck_assert_ptr_eq(copyRngO(self, 3, 2), NULL); 6395 s = toStringO(self); 6396 ck_assert_str_eq(s, "[1,2,3,4]"); 6397 free(s); 6398 // negative start last element 6399 r = copyRngO(self, -1, 0); 6400 ck_assert_ptr_ne(r, null); 6401 ck_assert_int_eq(lenO(r), 1); 6402 s = toStringO(r); 6403 terminateO(r); 6404 ck_assert_str_eq(s, "[4]"); 6405 free(s); 6406 s = toStringO(self); 6407 ck_assert_str_eq(s, "[1,2,3,4]"); 6408 free(s); 6409 // negative start and outside 6410 r = copyRngO(self, -10, 1); 6411 ck_assert_ptr_ne(r, null); 6412 ck_assert_int_eq(lenO(r), 1); 6413 s = toStringO(r); 6414 terminateO(r); 6415 ck_assert_str_eq(s, "[1]"); 6416 free(s); 6417 s = toStringO(self); 6418 ck_assert_str_eq(s, "[1,2,3,4]"); 6419 free(s); 6420 // start = end 6421 r = copyRngO(self, 1, 1); 6422 ck_assert_ptr_ne(r, null); 6423 ck_assert_int_eq(lenO(r), 0); 6424 terminateO(r); 6425 s = toStringO(self); 6426 ck_assert_str_eq(s, "[1,2,3,4]"); 6427 free(s); 6428 // empty list 6429 emptyO(self); 6430 ck_assert_ptr_eq(copyRngO(self, 0, 0), NULL); 6431 ck_assert_ptr_eq(copyRngO(self, -1, 0), NULL); 6432 terminateO(self); 6433 6434 } 6435 6436 6437 void insertSmallArrayT(void) { 6438 6439 smallArrayt* r; 6440 smallArrayt *self = allocG(rtSmallArrayt); 6441 smallArrayt *toInsert; 6442 6443 // add elements to self 6444 r = self->f->pushInt(self, 1); 6445 ck_assert_ptr_ne(r, null); 6446 r = self->f->pushInt(self, 2); 6447 ck_assert_ptr_ne(r, null); 6448 6449 // positive index 6450 toInsert = allocSmallArray(); 6451 toInsert->f->pushInt(toInsert, 3); 6452 r = self->f->insert(self, 1, toInsert); 6453 smashO(toInsert); 6454 ck_assert_ptr_ne(r, null); 6455 char *s = toStringO(r); 6456 ck_assert_str_eq(s, "[1,3,2]"); 6457 free(s); 6458 // negative index 6459 toInsert = allocSmallArray(); 6460 toInsert->f->pushInt(toInsert, 4); 6461 r = self->f->insert(self, -1, toInsert); 6462 smashO(toInsert); 6463 ck_assert_ptr_ne(r, null); 6464 s = toStringO(r); 6465 ck_assert_str_eq(s, "[1,3,2,4]"); 6466 free(s); 6467 // empty list 6468 emptyO(self); 6469 toInsert = allocSmallArray(); 6470 toInsert->f->pushInt(toInsert, 3); 6471 r = self->f->insert(self, 0, 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 emptyO(self); 6478 toInsert = allocSmallArray(); 6479 toInsert->f->pushInt(toInsert, 3); 6480 r = self->f->insert(self, -1, toInsert); 6481 smashO(toInsert); 6482 ck_assert_ptr_ne(r, null); 6483 s = toStringO(r); 6484 ck_assert_str_eq(s, "[3]"); 6485 free(s); 6486 // Array array length 0 6487 toInsert = allocSmallArray(); 6488 r = self->f->insert(self, -1, toInsert); 6489 smashO(toInsert); 6490 ck_assert_ptr_ne(r, null); 6491 s = toStringO(r); 6492 ck_assert_str_eq(s, "[3]"); 6493 free(s); 6494 // index outside 6495 toInsert = allocSmallArray(); 6496 ck_assert_ptr_eq(self->f->insert(self, 20, toInsert), NULL); 6497 ck_assert_ptr_eq(self->f->insert(self, -5, toInsert), NULL); 6498 smashO(toInsert); 6499 // non smallArray toInsert 6500 toInsert = (smallArrayt*) allocSmallInt(1); 6501 ck_assert_ptr_eq(self->f->insert(self, 0, toInsert), NULL); 6502 terminateO(toInsert); 6503 // insert NULL 6504 ck_assert_ptr_eq(self->f->insert(self, 0, NULL), NULL); 6505 terminateO(self); 6506 6507 } 6508 6509 6510 void insertSmallJsonSmallArrayT(void) { 6511 6512 smallArrayt* r; 6513 smallArrayt *self = allocG(rtSmallArrayt); 6514 smallJsont *toInsert; 6515 6516 // add elements to self 6517 r = self->f->pushInt(self, 1); 6518 ck_assert_ptr_ne(r, null); 6519 r = self->f->pushInt(self, 2); 6520 ck_assert_ptr_ne(r, null); 6521 6522 // positive index 6523 toInsert = allocSmallJson(); 6524 toInsert->f->pushInt(toInsert, 3); 6525 r = self->f->insertSmallJson(self, 1, toInsert); 6526 smashO(toInsert); 6527 ck_assert_ptr_ne(r, null); 6528 char *s = toStringO(r); 6529 ck_assert_str_eq(s, "[1,3,2]"); 6530 free(s); 6531 // negative index 6532 toInsert = allocSmallJson(); 6533 toInsert->f->pushInt(toInsert, 4); 6534 r = self->f->insertSmallJson(self, -1, toInsert); 6535 smashO(toInsert); 6536 ck_assert_ptr_ne(r, null); 6537 s = toStringO(r); 6538 ck_assert_str_eq(s, "[1,3,2,4]"); 6539 free(s); 6540 // empty list 6541 emptyO(self); 6542 toInsert = allocSmallJson(); 6543 toInsert->f->pushInt(toInsert, 3); 6544 r = self->f->insertSmallJson(self, 0, 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 emptyO(self); 6551 toInsert = allocSmallJson(); 6552 toInsert->f->pushInt(toInsert, 3); 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 array length 0 6560 toInsert = allocSmallJson(); 6561 setTypeArrayG(toInsert); 6562 r = self->f->insertSmallJson(self, -1, toInsert); 6563 smashO(toInsert); 6564 ck_assert_ptr_ne(r, null); 6565 s = toStringO(r); 6566 ck_assert_str_eq(s, "[3]"); 6567 free(s); 6568 // json with no type 6569 toInsert = allocSmallJson(); 6570 r = self->f->insertSmallJson(self, -1, toInsert); 6571 smashO(toInsert); 6572 ck_assert_ptr_eq(r, null); 6573 s = toStringO(self); 6574 ck_assert_str_eq(s, "[3]"); 6575 free(s); 6576 // non smallJson object 6577 toInsert = (smallJsont*) allocSmallInt(2); 6578 r = self->f->insertSmallJson(self, -1, toInsert); 6579 ck_assert_ptr_eq(r, null); 6580 terminateO(toInsert); 6581 // index outside 6582 toInsert = allocSmallJson(); 6583 ck_assert_ptr_eq(self->f->insertSmallJson(self, 20, toInsert), NULL); 6584 ck_assert_ptr_eq(self->f->insertSmallJson(self, -5, toInsert), NULL); 6585 smashO(toInsert); 6586 // insert NULL 6587 ck_assert_ptr_eq(self->f->insertSmallJson(self, 0, NULL), NULL); 6588 terminateO(self); 6589 6590 } 6591 6592 6593 void insertNSmashSmallArrayT(void) { 6594 6595 smallArrayt* r; 6596 smallArrayt *self = allocG(rtSmallArrayt); 6597 smallArrayt *toInsert; 6598 6599 // add elements to self 6600 r = self->f->pushInt(self, 1); 6601 ck_assert_ptr_ne(r, null); 6602 r = self->f->pushInt(self, 2); 6603 ck_assert_ptr_ne(r, null); 6604 6605 // positive index 6606 toInsert = allocSmallArray(); 6607 toInsert->f->pushInt(toInsert, 3); 6608 r = self->f->insertNSmash(self, 1, toInsert); 6609 ck_assert_ptr_ne(r, null); 6610 char *s = toStringO(r); 6611 ck_assert_str_eq(s, "[1,3,2]"); 6612 free(s); 6613 // negative index 6614 toInsert = allocSmallArray(); 6615 toInsert->f->pushInt(toInsert, 4); 6616 r = self->f->insertNSmash(self, -1, toInsert); 6617 ck_assert_ptr_ne(r, null); 6618 s = toStringO(r); 6619 ck_assert_str_eq(s, "[1,3,2,4]"); 6620 free(s); 6621 // empty list 6622 emptyO(self); 6623 toInsert = allocSmallArray(); 6624 toInsert->f->pushInt(toInsert, 3); 6625 r = self->f->insertNSmash(self, 0, toInsert); 6626 ck_assert_ptr_ne(r, null); 6627 s = toStringO(r); 6628 ck_assert_str_eq(s, "[3]"); 6629 free(s); 6630 emptyO(self); 6631 toInsert = allocSmallArray(); 6632 toInsert->f->pushInt(toInsert, 3); 6633 r = self->f->insertNSmash(self, -1, toInsert); 6634 ck_assert_ptr_ne(r, null); 6635 s = toStringO(r); 6636 ck_assert_str_eq(s, "[3]"); 6637 free(s); 6638 // Array array length 0 6639 toInsert = allocSmallArray(); 6640 r = self->f->insertNSmash(self, -1, toInsert); 6641 ck_assert_ptr_ne(r, null); 6642 s = toStringO(r); 6643 ck_assert_str_eq(s, "[3]"); 6644 free(s); 6645 // index outside 6646 toInsert = allocSmallArray(); 6647 ck_assert_ptr_eq(self->f->insertNSmash(self, 20, toInsert), NULL); 6648 ck_assert_ptr_eq(self->f->insertNSmash(self, -5, toInsert), NULL); 6649 smashO(toInsert); 6650 // insert NULL 6651 ck_assert_ptr_eq(self->f->insertNSmash(self, 0, NULL), NULL); 6652 terminateO(self); 6653 6654 } 6655 6656 6657 void insertNSmashSmallJsonSmallArrayT(void) { 6658 6659 smallArrayt* r; 6660 smallArrayt *self = allocG(rtSmallArrayt); 6661 smallJsont *toInsert; 6662 6663 // add elements to self 6664 r = self->f->pushInt(self, 1); 6665 ck_assert_ptr_ne(r, null); 6666 r = self->f->pushInt(self, 2); 6667 ck_assert_ptr_ne(r, null); 6668 6669 // positive index 6670 toInsert = allocSmallJson(); 6671 toInsert->f->pushInt(toInsert, 3); 6672 r = self->f->insertNSmashSmallJson(self, 1, toInsert); 6673 ck_assert_ptr_ne(r, null); 6674 char *s = toStringO(r); 6675 ck_assert_str_eq(s, "[1,3,2]"); 6676 free(s); 6677 // negative index 6678 toInsert = allocSmallJson(); 6679 toInsert->f->pushInt(toInsert, 4); 6680 r = self->f->insertNSmashSmallJson(self, -1, toInsert); 6681 ck_assert_ptr_ne(r, null); 6682 s = toStringO(r); 6683 ck_assert_str_eq(s, "[1,3,2,4]"); 6684 free(s); 6685 // empty list 6686 emptyO(self); 6687 toInsert = allocSmallJson(); 6688 toInsert->f->pushInt(toInsert, 3); 6689 r = self->f->insertNSmashSmallJson(self, 0, toInsert); 6690 ck_assert_ptr_ne(r, null); 6691 s = toStringO(r); 6692 ck_assert_str_eq(s, "[3]"); 6693 free(s); 6694 emptyO(self); 6695 toInsert = allocSmallJson(); 6696 toInsert->f->pushInt(toInsert, 3); 6697 r = self->f->insertNSmashSmallJson(self, -1, toInsert); 6698 ck_assert_ptr_ne(r, null); 6699 s = toStringO(r); 6700 ck_assert_str_eq(s, "[3]"); 6701 free(s); 6702 // json array length 0 6703 toInsert = allocSmallJson(); 6704 setTypeArrayG(toInsert); 6705 r = self->f->insertNSmashSmallJson(self, -1, toInsert); 6706 ck_assert_ptr_ne(r, null); 6707 s = toStringO(r); 6708 ck_assert_str_eq(s, "[3]"); 6709 free(s); 6710 // json with no type 6711 toInsert = allocSmallJson(); 6712 r = self->f->insertNSmashSmallJson(self, -1, toInsert); 6713 smashO(toInsert); 6714 ck_assert_ptr_eq(r, null); 6715 s = toStringO(self); 6716 ck_assert_str_eq(s, "[3]"); 6717 free(s); 6718 // index outside 6719 toInsert = allocSmallJson(); 6720 ck_assert_ptr_eq(self->f->insertNSmashSmallJson(self, 20, toInsert), NULL); 6721 ck_assert_ptr_eq(self->f->insertNSmashSmallJson(self, -5, toInsert), NULL); 6722 smashO(toInsert); 6723 // insert NULL 6724 ck_assert_ptr_eq(self->f->insertNSmashSmallJson(self, 0, NULL), NULL); 6725 terminateO(self); 6726 6727 } 6728 6729 6730 void injectSmallArrayT(void) { 6731 6732 smallArrayt* r; 6733 smallArrayt *self = allocG(rtSmallArrayt); 6734 baset *toInject; 6735 6736 // add elements to self 6737 r = self->f->pushInt(self, 1); 6738 ck_assert_ptr_ne(r, null); 6739 r = self->f->pushInt(self, 2); 6740 ck_assert_ptr_ne(r, null); 6741 r = self->f->pushInt(self, 3); 6742 ck_assert_ptr_ne(r, null); 6743 r = self->f->pushInt(self, 4); 6744 ck_assert_ptr_ne(r, null); 6745 6746 // positive index 6747 toInject = (baset*) allocSmallInt(8); 6748 r = self->f->inject(self, 1, toInject); 6749 ck_assert_ptr_ne(r, null); 6750 finishO(toInject); 6751 char *s = toStringO(r); 6752 ck_assert_str_eq(s, "[1,8,2,3,4]"); 6753 free(s); 6754 // negative index 6755 toInject = (baset*) allocSmallInt(9); 6756 r = self->f->inject(self,-1, toInject); 6757 ck_assert_ptr_ne(r, null); 6758 finishO(toInject); 6759 s = toStringO(r); 6760 ck_assert_str_eq(s, "[1,8,2,3,4,9]"); 6761 free(s); 6762 // index 0 6763 toInject = (baset*) allocSmallInt(6); 6764 r = self->f->inject(self,0, toInject); 6765 ck_assert_ptr_ne(r, null); 6766 finishO(toInject); 6767 s = toStringO(r); 6768 ck_assert_str_eq(s, "[6,1,8,2,3,4,9]"); 6769 free(s); 6770 // index outside 6771 toInject = (baset*) allocSmallInt(7); 6772 ck_assert_ptr_eq(self->f->inject(self, 20, toInject), NULL); 6773 ck_assert_ptr_eq(self->f->inject(self, -9, toInject), NULL); 6774 terminateO(toInject); 6775 // empty list 6776 emptyO(self); 6777 toInject = (baset*) allocSmallInt(7); 6778 ck_assert_ptr_ne(self->f->inject(self, 0, toInject), NULL); 6779 finishO(toInject); 6780 s = toStringO(r); 6781 ck_assert_str_eq(s, "[7]"); 6782 free(s); 6783 emptyO(self); 6784 toInject = (baset*) allocSmallInt(7); 6785 ck_assert_ptr_ne(self->f->inject(self, -1, toInject), NULL); 6786 finishO(toInject); 6787 s = toStringO(r); 6788 ck_assert_str_eq(s, "[7]"); 6789 free(s); 6790 // null toInsert 6791 ck_assert_ptr_eq(self->f->inject(self, 0, NULL), NULL); 6792 terminateO(self); 6793 6794 } 6795 6796 6797 void injectUndefinedSmallArrayT(void) { 6798 6799 smallArrayt* r; 6800 smallArrayt *self = allocG(rtSmallArrayt); 6801 6802 // add elements to self 6803 r = self->f->pushInt(self, 1); 6804 ck_assert_ptr_ne(r, null); 6805 r = self->f->pushInt(self, 2); 6806 ck_assert_ptr_ne(r, null); 6807 r = self->f->pushInt(self, 3); 6808 ck_assert_ptr_ne(r, null); 6809 r = self->f->pushInt(self, 4); 6810 ck_assert_ptr_ne(r, null); 6811 6812 // positive index 6813 r = self->f->injectUndefined(self, 1); 6814 ck_assert_ptr_ne(r, null); 6815 char *s = toStringO(r); 6816 ck_assert_str_eq(s, "[1,null,2,3,4]"); 6817 free(s); 6818 // negative index 6819 r = self->f->injectUndefined(self,-1); 6820 ck_assert_ptr_ne(r, null); 6821 s = toStringO(r); 6822 ck_assert_str_eq(s, "[1,null,2,3,4,null]"); 6823 free(s); 6824 // index 0 6825 r = self->f->injectUndefined(self,0); 6826 ck_assert_ptr_ne(r, null); 6827 s = toStringO(r); 6828 ck_assert_str_eq(s, "[null,1,null,2,3,4,null]"); 6829 free(s); 6830 // index outside 6831 ck_assert_ptr_eq(self->f->injectUndefined(self, 20), NULL); 6832 ck_assert_ptr_eq(self->f->injectUndefined(self, -9), NULL); 6833 // empty list 6834 emptyO(self); 6835 ck_assert_ptr_ne(self->f->injectUndefined(self, 0), NULL); 6836 s = toStringO(r); 6837 ck_assert_str_eq(s, "[null]"); 6838 free(s); 6839 emptyO(self); 6840 ck_assert_ptr_ne(self->f->injectUndefined(self, -1), NULL); 6841 s = toStringO(r); 6842 ck_assert_str_eq(s, "[null]"); 6843 free(s); 6844 terminateO(self); 6845 6846 } 6847 6848 6849 void injectBoolSmallArrayT(void) { 6850 6851 smallArrayt* r; 6852 smallArrayt *self = allocG(rtSmallArrayt); 6853 6854 // add elements to self 6855 r = self->f->pushInt(self, 1); 6856 ck_assert_ptr_ne(r, null); 6857 r = self->f->pushInt(self, 2); 6858 ck_assert_ptr_ne(r, null); 6859 r = self->f->pushInt(self, 3); 6860 ck_assert_ptr_ne(r, null); 6861 r = self->f->pushInt(self, 4); 6862 ck_assert_ptr_ne(r, null); 6863 6864 // positive index 6865 r = self->f->injectBool(self, 1, true); 6866 ck_assert_ptr_ne(r, null); 6867 char *s = toStringO(r); 6868 ck_assert_str_eq(s, "[1,true,2,3,4]"); 6869 free(s); 6870 // negative index 6871 r = self->f->injectBool(self,-1, true); 6872 ck_assert_ptr_ne(r, null); 6873 s = toStringO(r); 6874 ck_assert_str_eq(s, "[1,true,2,3,4,true]"); 6875 free(s); 6876 // index 0 6877 r = self->f->injectBool(self,0, true); 6878 ck_assert_ptr_ne(r, null); 6879 s = toStringO(r); 6880 ck_assert_str_eq(s, "[true,1,true,2,3,4,true]"); 6881 free(s); 6882 // index outside 6883 ck_assert_ptr_eq(self->f->injectBool(self, 20, true), NULL); 6884 ck_assert_ptr_eq(self->f->injectBool(self, -9, true), NULL); 6885 // empty list 6886 emptyO(self); 6887 ck_assert_ptr_ne(self->f->injectBool(self, 0, true), NULL); 6888 s = toStringO(r); 6889 ck_assert_str_eq(s, "[true]"); 6890 free(s); 6891 emptyO(self); 6892 ck_assert_ptr_ne(self->f->injectBool(self, -1, true), NULL); 6893 s = toStringO(r); 6894 ck_assert_str_eq(s, "[true]"); 6895 free(s); 6896 terminateO(self); 6897 6898 } 6899 6900 6901 void injectDoubleSmallArrayT(void) { 6902 6903 smallArrayt* r; 6904 smallArrayt *self = allocG(rtSmallArrayt); 6905 6906 // add elements to self 6907 r = self->f->pushInt(self, 1); 6908 ck_assert_ptr_ne(r, null); 6909 r = self->f->pushInt(self, 2); 6910 ck_assert_ptr_ne(r, null); 6911 r = self->f->pushInt(self, 3); 6912 ck_assert_ptr_ne(r, null); 6913 r = self->f->pushInt(self, 4); 6914 ck_assert_ptr_ne(r, null); 6915 6916 // positive index 6917 r = self->f->injectDouble(self, 1, 7); 6918 ck_assert_ptr_ne(r, null); 6919 char *s = toStringO(r); 6920 ck_assert_str_eq(s, "[1,7.000000e+00,2,3,4]"); 6921 free(s); 6922 // negative index 6923 r = self->f->injectDouble(self,-1, 8); 6924 ck_assert_ptr_ne(r, null); 6925 s = toStringO(r); 6926 ck_assert_str_eq(s, "[1,7.000000e+00,2,3,4,8.000000e+00]"); 6927 free(s); 6928 // index 0 6929 r = self->f->injectDouble(self,0, 9); 6930 ck_assert_ptr_ne(r, null); 6931 s = toStringO(r); 6932 ck_assert_str_eq(s, "[9.000000e+00,1,7.000000e+00,2,3,4,8.000000e+00]"); 6933 free(s); 6934 // index outside 6935 ck_assert_ptr_eq(self->f->injectDouble(self, 20, 7.000000e+00), NULL); 6936 ck_assert_ptr_eq(self->f->injectDouble(self, -9, 7.000000e+00), NULL); 6937 // empty list 6938 emptyO(self); 6939 ck_assert_ptr_ne(self->f->injectDouble(self, 0, 9), NULL); 6940 s = toStringO(r); 6941 ck_assert_str_eq(s, "[9.000000e+00]"); 6942 free(s); 6943 emptyO(self); 6944 ck_assert_ptr_ne(self->f->injectDouble(self, -1, 9), NULL); 6945 s = toStringO(r); 6946 ck_assert_str_eq(s, "[9.000000e+00]"); 6947 free(s); 6948 terminateO(self); 6949 6950 } 6951 6952 6953 void injectIntSmallArrayT(void) { 6954 6955 smallArrayt* r; 6956 smallArrayt *self = allocG(rtSmallArrayt); 6957 6958 // add elements to self 6959 r = self->f->pushInt(self, 1); 6960 ck_assert_ptr_ne(r, null); 6961 r = self->f->pushInt(self, 2); 6962 ck_assert_ptr_ne(r, null); 6963 r = self->f->pushInt(self, 3); 6964 ck_assert_ptr_ne(r, null); 6965 r = self->f->pushInt(self, 4); 6966 ck_assert_ptr_ne(r, null); 6967 6968 // positive index 6969 r = self->f->injectInt(self, 1, 5); 6970 ck_assert_ptr_ne(r, null); 6971 char *s = toStringO(r); 6972 ck_assert_str_eq(s, "[1,5,2,3,4]"); 6973 free(s); 6974 // negative index 6975 r = self->f->injectInt(self,-1, 6); 6976 ck_assert_ptr_ne(r, null); 6977 s = toStringO(r); 6978 ck_assert_str_eq(s, "[1,5,2,3,4,6]"); 6979 free(s); 6980 // index 0 6981 r = self->f->injectInt(self,0, 7); 6982 ck_assert_ptr_ne(r, null); 6983 s = toStringO(r); 6984 ck_assert_str_eq(s, "[7,1,5,2,3,4,6]"); 6985 free(s); 6986 // index outside 6987 ck_assert_ptr_eq(self->f->injectInt(self, 20, true), NULL); 6988 ck_assert_ptr_eq(self->f->injectInt(self, -9, true), NULL); 6989 // empty list 6990 emptyO(self); 6991 ck_assert_ptr_ne(self->f->injectInt(self, 0, 7), NULL); 6992 s = toStringO(r); 6993 ck_assert_str_eq(s, "[7]"); 6994 free(s); 6995 emptyO(self); 6996 ck_assert_ptr_ne(self->f->injectInt(self, -1, 7), NULL); 6997 s = toStringO(r); 6998 ck_assert_str_eq(s, "[7]"); 6999 free(s); 7000 terminateO(self); 7001 7002 } 7003 7004 7005 void injectSSmallArrayT(void) { 7006 7007 smallArrayt* r; 7008 smallArrayt *self = allocG(rtSmallArrayt); 7009 7010 // add elements to self 7011 r = self->f->pushInt(self, 1); 7012 ck_assert_ptr_ne(r, null); 7013 r = self->f->pushInt(self, 2); 7014 ck_assert_ptr_ne(r, null); 7015 r = self->f->pushInt(self, 3); 7016 ck_assert_ptr_ne(r, null); 7017 r = self->f->pushInt(self, 4); 7018 ck_assert_ptr_ne(r, null); 7019 // positive index 7020 r = self->f->injectS(self, 1, "5"); 7021 ck_assert_ptr_ne(r, null); 7022 char *s = toStringO(r); 7023 ck_assert_str_eq(s, "[1,\"5\",2,3,4]"); 7024 free(s); 7025 // negative index 7026 r = self->f->injectS(self,-1, "6"); 7027 ck_assert_ptr_ne(r, null); 7028 s = toStringO(r); 7029 ck_assert_str_eq(s, "[1,\"5\",2,3,4,\"6\"]"); 7030 free(s); 7031 // index 0 7032 r = self->f->injectS(self,0, "7"); 7033 ck_assert_ptr_ne(r, null); 7034 s = toStringO(r); 7035 ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]"); 7036 free(s); 7037 // null toInject 7038 r = self->f->injectS(self,0, null); 7039 ck_assert_ptr_eq(r, null); 7040 s = toStringO(self); 7041 ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]"); 7042 free(s); 7043 // index outside 7044 ck_assert_ptr_eq(self->f->injectS(self, 20, ""), NULL); 7045 ck_assert_ptr_eq(self->f->injectS(self, -9, ""), NULL); 7046 // empty list 7047 emptyO(self); 7048 ck_assert_ptr_ne(self->f->injectS(self, 0, "7"), NULL); 7049 s = toStringO(self); 7050 ck_assert_str_eq(s, "[\"7\"]"); 7051 free(s); 7052 emptyO(self); 7053 ck_assert_ptr_ne(self->f->injectS(self, -1, "7"), NULL); 7054 s = toStringO(self); 7055 ck_assert_str_eq(s, "[\"7\"]"); 7056 free(s); 7057 terminateO(self); 7058 7059 } 7060 7061 7062 void injectCharSmallArrayT(void) { 7063 7064 smallArrayt* r; 7065 smallArrayt *self = allocG(rtSmallArrayt); 7066 7067 // add elements to self 7068 r = self->f->pushInt(self, 1); 7069 ck_assert_ptr_ne(r, null); 7070 r = self->f->pushInt(self, 2); 7071 ck_assert_ptr_ne(r, null); 7072 r = self->f->pushInt(self, 3); 7073 ck_assert_ptr_ne(r, null); 7074 r = self->f->pushInt(self, 4); 7075 ck_assert_ptr_ne(r, null); 7076 7077 // positive index 7078 r = self->f->injectChar(self, 1, '5'); 7079 ck_assert_ptr_ne(r, null); 7080 char *s = toStringO(r); 7081 ck_assert_str_eq(s, "[1,\"5\",2,3,4]"); 7082 free(s); 7083 // negative index 7084 r = self->f->injectChar(self,-1, '6'); 7085 ck_assert_ptr_ne(r, null); 7086 s = toStringO(r); 7087 ck_assert_str_eq(s, "[1,\"5\",2,3,4,\"6\"]"); 7088 free(s); 7089 // index 0 7090 r = self->f->injectChar(self,0, '7'); 7091 ck_assert_ptr_ne(r, null); 7092 s = toStringO(r); 7093 ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]"); 7094 free(s); 7095 // index outside 7096 ck_assert_ptr_eq(self->f->injectChar(self, 20, 'y'), NULL); 7097 ck_assert_ptr_eq(self->f->injectChar(self, -9, 'y'), NULL); 7098 // empty list 7099 emptyO(self); 7100 ck_assert_ptr_ne(self->f->injectChar(self, 0, '7'), NULL); 7101 s = toStringO(r); 7102 ck_assert_str_eq(s, "[\"7\"]"); 7103 free(s); 7104 emptyO(self); 7105 ck_assert_ptr_ne(self->f->injectChar(self, -1, '7'), NULL); 7106 s = toStringO(r); 7107 ck_assert_str_eq(s, "[\"7\"]"); 7108 free(s); 7109 terminateO(self); 7110 7111 } 7112 7113 7114 void injectDictSmallArrayT(void) { 7115 7116 smallArrayt* r; 7117 smallArrayt *self = allocG(rtSmallArrayt); 7118 smallDictt *toInject; 7119 7120 // add elements to self 7121 r = self->f->pushInt(self, 1); 7122 ck_assert_ptr_ne(r, null); 7123 r = self->f->pushInt(self, 2); 7124 ck_assert_ptr_ne(r, null); 7125 r = self->f->pushInt(self, 3); 7126 ck_assert_ptr_ne(r, null); 7127 r = self->f->pushInt(self, 4); 7128 ck_assert_ptr_ne(r, null); 7129 7130 // positive index 7131 toInject = allocSmallDict(); 7132 r = self->f->injectDict(self, 1, toInject); 7133 ck_assert_ptr_ne(r, null); 7134 finishO(toInject); 7135 char *s = toStringO(r); 7136 ck_assert_str_eq(s, "[1,{},2,3,4]"); 7137 free(s); 7138 // negative index 7139 toInject = allocSmallDict(); 7140 r = self->f->injectDict(self,-1, toInject); 7141 ck_assert_ptr_ne(r, null); 7142 finishO(toInject); 7143 s = toStringO(r); 7144 ck_assert_str_eq(s, "[1,{},2,3,4,{}]"); 7145 free(s); 7146 // index 0 7147 toInject = allocSmallDict(); 7148 r = self->f->injectDict(self,0, toInject); 7149 ck_assert_ptr_ne(r, null); 7150 finishO(toInject); 7151 s = toStringO(r); 7152 ck_assert_str_eq(s, "[{},1,{},2,3,4,{}]"); 7153 free(s); 7154 // index outside 7155 toInject = allocSmallDict(); 7156 ck_assert_ptr_eq(self->f->injectDict(self, 20, toInject), NULL); 7157 ck_assert_ptr_eq(self->f->injectDict(self, -9, toInject), NULL); 7158 terminateO(toInject); 7159 // empty list 7160 emptyO(self); 7161 toInject = allocSmallDict(); 7162 ck_assert_ptr_ne(self->f->injectDict(self, 0, toInject), NULL); 7163 finishO(toInject); 7164 s = toStringO(r); 7165 ck_assert_str_eq(s, "[{}]"); 7166 free(s); 7167 emptyO(self); 7168 toInject = allocSmallDict(); 7169 ck_assert_ptr_ne(self->f->injectDict(self, -1, toInject), NULL); 7170 finishO(toInject); 7171 s = toStringO(r); 7172 ck_assert_str_eq(s, "[{}]"); 7173 free(s); 7174 // non smallDict object 7175 toInject = (smallDictt*) allocSmallInt(2); 7176 r = self->f->injectDict(self, 0, toInject); 7177 ck_assert_ptr_eq(r, null); 7178 terminateO(toInject); 7179 // null toInsert 7180 ck_assert_ptr_eq(self->f->injectDict(self, 0, NULL), NULL); 7181 terminateO(self); 7182 7183 } 7184 7185 7186 void injectArraySmallArrayT(void) { 7187 7188 smallArrayt* r; 7189 smallArrayt *self = allocG(rtSmallArrayt); 7190 smallArrayt *toInject; 7191 7192 // add elements to self 7193 r = self->f->pushInt(self, 1); 7194 ck_assert_ptr_ne(r, null); 7195 r = self->f->pushInt(self, 2); 7196 ck_assert_ptr_ne(r, null); 7197 r = self->f->pushInt(self, 3); 7198 ck_assert_ptr_ne(r, null); 7199 r = self->f->pushInt(self, 4); 7200 ck_assert_ptr_ne(r, null); 7201 7202 // positive index 7203 toInject = allocSmallArray(); 7204 r = self->f->injectArray(self, 1, toInject); 7205 ck_assert_ptr_ne(r, null); 7206 finishO(toInject); 7207 char *s = toStringO(r); 7208 ck_assert_str_eq(s, "[1,[],2,3,4]"); 7209 free(s); 7210 // negative index 7211 toInject = allocSmallArray(); 7212 r = self->f->injectArray(self,-1, toInject); 7213 ck_assert_ptr_ne(r, null); 7214 finishO(toInject); 7215 s = toStringO(r); 7216 ck_assert_str_eq(s, "[1,[],2,3,4,[]]"); 7217 free(s); 7218 // index 0 7219 toInject = allocSmallArray(); 7220 r = self->f->injectArray(self,0, toInject); 7221 ck_assert_ptr_ne(r, null); 7222 finishO(toInject); 7223 s = toStringO(r); 7224 ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]"); 7225 free(s); 7226 // index outside 7227 toInject = allocSmallArray(); 7228 ck_assert_ptr_eq(self->f->injectArray(self, 20, toInject), NULL); 7229 ck_assert_ptr_eq(self->f->injectArray(self, -9, toInject), NULL); 7230 terminateO(toInject); 7231 // empty list 7232 emptyO(self); 7233 toInject = allocSmallArray(); 7234 ck_assert_ptr_ne(self->f->injectArray(self, 0, toInject), NULL); 7235 finishO(toInject); 7236 s = toStringO(r); 7237 ck_assert_str_eq(s, "[[]]"); 7238 free(s); 7239 emptyO(self); 7240 toInject = allocSmallArray(); 7241 ck_assert_ptr_ne(self->f->injectArray(self, -1, toInject), NULL); 7242 finishO(toInject); 7243 s = toStringO(r); 7244 ck_assert_str_eq(s, "[[]]"); 7245 free(s); 7246 // non smallArray object 7247 toInject = (smallArrayt*) allocSmallInt(2); 7248 r = self->f->injectArray(self, 0, toInject); 7249 ck_assert_ptr_eq(r, null); 7250 terminateO(toInject); 7251 // null toInsert 7252 ck_assert_ptr_eq(self->f->injectArray(self, 0, NULL), NULL); 7253 terminateO(self); 7254 7255 } 7256 7257 7258 void injectArraycSmallArrayT(void) { 7259 7260 smallArrayt* r; 7261 smallArrayt *self = allocG(rtSmallArrayt); 7262 char **toInject; 7263 7264 // add elements to self 7265 r = self->f->pushInt(self, 1); 7266 ck_assert_ptr_ne(r, null); 7267 r = self->f->pushInt(self, 2); 7268 ck_assert_ptr_ne(r, null); 7269 r = self->f->pushInt(self, 3); 7270 ck_assert_ptr_ne(r, null); 7271 r = self->f->pushInt(self, 4); 7272 ck_assert_ptr_ne(r, null); 7273 7274 // positive index 7275 toInject = listCreateS("a","b"); 7276 r = self->f->injectArrayc(self, 1, toInject); 7277 listFreeS(toInject); 7278 ck_assert_ptr_ne(r, null); 7279 char *s = toStringO(r); 7280 ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4]"); 7281 free(s); 7282 // negative index 7283 toInject = listCreateS("c","d"); 7284 r = self->f->injectArrayc(self,-1, toInject); 7285 listFreeS(toInject); 7286 ck_assert_ptr_ne(r, null); 7287 s = toStringO(r); 7288 ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]"); 7289 free(s); 7290 // index 0 7291 toInject = listCreateS("e","ff"); 7292 r = self->f->injectArrayc(self,0, toInject); 7293 listFreeS(toInject); 7294 ck_assert_ptr_ne(r, null); 7295 s = toStringO(r); 7296 ck_assert_str_eq(s, "[[\"e\",\"ff\"],1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]"); 7297 free(s); 7298 // index outside 7299 toInject = listCreateS("a","b"); 7300 ck_assert_ptr_eq(self->f->injectArrayc(self, 20, toInject), NULL); 7301 ck_assert_ptr_eq(self->f->injectArrayc(self, -9, toInject), NULL); 7302 listFreeS(toInject); 7303 // empty list 7304 emptyO(self); 7305 toInject = listCreateS("a","b"); 7306 ck_assert_ptr_ne(self->f->injectArrayc(self, 0, toInject), NULL); 7307 listFreeS(toInject); 7308 s = toStringO(r); 7309 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 7310 free(s); 7311 emptyO(self); 7312 toInject = listCreateS("a","b"); 7313 ck_assert_ptr_ne(self->f->injectArrayc(self, -1, toInject), NULL); 7314 listFreeS(toInject); 7315 s = toStringO(r); 7316 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 7317 free(s); 7318 // null toInsert 7319 ck_assert_ptr_eq(self->f->injectArrayc(self, 0, NULL), NULL); 7320 terminateO(self); 7321 7322 } 7323 7324 7325 void injectSmallBoolSmallArrayT(void) { 7326 7327 smallArrayt* r; 7328 smallArrayt *self = allocG(rtSmallArrayt); 7329 smallBoolt *toInject; 7330 7331 // add elements to self 7332 r = self->f->pushInt(self, 1); 7333 ck_assert_ptr_ne(r, null); 7334 r = self->f->pushInt(self, 2); 7335 ck_assert_ptr_ne(r, null); 7336 r = self->f->pushInt(self, 3); 7337 ck_assert_ptr_ne(r, null); 7338 r = self->f->pushInt(self, 4); 7339 ck_assert_ptr_ne(r, null); 7340 7341 // positive index 7342 toInject = allocSmallBool(true); 7343 r = self->f->injectSmallBool(self, 1, toInject); 7344 ck_assert_ptr_ne(r, null); 7345 finishO(toInject); 7346 char *s = toStringO(r); 7347 ck_assert_str_eq(s, "[1,true,2,3,4]"); 7348 free(s); 7349 // negative index 7350 toInject = allocSmallBool(true); 7351 r = self->f->injectSmallBool(self,-1, toInject); 7352 ck_assert_ptr_ne(r, null); 7353 finishO(toInject); 7354 s = toStringO(r); 7355 ck_assert_str_eq(s, "[1,true,2,3,4,true]"); 7356 free(s); 7357 // index 0 7358 toInject = allocSmallBool(true); 7359 r = self->f->injectSmallBool(self,0, toInject); 7360 ck_assert_ptr_ne(r, null); 7361 finishO(toInject); 7362 s = toStringO(r); 7363 ck_assert_str_eq(s, "[true,1,true,2,3,4,true]"); 7364 free(s); 7365 // index outside 7366 toInject = allocSmallBool(true); 7367 ck_assert_ptr_eq(self->f->injectSmallBool(self, 20, toInject), NULL); 7368 ck_assert_ptr_eq(self->f->injectSmallBool(self, -9, toInject), NULL); 7369 terminateO(toInject); 7370 // empty object 7371 emptyO(self); 7372 toInject = allocSmallBool(true); 7373 freeO(toInject); 7374 ck_assert_ptr_ne(self->f->injectSmallBool(self, 0, toInject), NULL); 7375 finishO(toInject); 7376 s = toStringO(r); 7377 ck_assert_str_eq(s, "[false]"); 7378 free(s); 7379 // empty list 7380 emptyO(self); 7381 toInject = allocSmallBool(true); 7382 ck_assert_ptr_ne(self->f->injectSmallBool(self, 0, toInject), NULL); 7383 finishO(toInject); 7384 s = toStringO(r); 7385 ck_assert_str_eq(s, "[true]"); 7386 free(s); 7387 emptyO(self); 7388 toInject = allocSmallBool(true); 7389 ck_assert_ptr_ne(self->f->injectSmallBool(self, -1, toInject), NULL); 7390 finishO(toInject); 7391 s = toStringO(r); 7392 ck_assert_str_eq(s, "[true]"); 7393 free(s); 7394 // non smallBool object 7395 toInject = (smallBoolt*) allocSmallInt(2); 7396 r = self->f->injectSmallBool(self, 0, toInject); 7397 ck_assert_ptr_eq(r, null); 7398 terminateO(toInject); 7399 // null toInsert 7400 ck_assert_ptr_eq(self->f->injectSmallBool(self, 0, NULL), NULL); 7401 terminateO(self); 7402 7403 } 7404 7405 7406 void injectSmallBytesSmallArrayT(void) { 7407 7408 smallArrayt* r; 7409 smallArrayt *self = allocG(rtSmallArrayt); 7410 smallBytest *toInject; 7411 7412 // add elements to self 7413 r = self->f->pushInt(self, 1); 7414 ck_assert_ptr_ne(r, null); 7415 r = self->f->pushInt(self, 2); 7416 ck_assert_ptr_ne(r, null); 7417 r = self->f->pushInt(self, 3); 7418 ck_assert_ptr_ne(r, null); 7419 r = self->f->pushInt(self, 4); 7420 ck_assert_ptr_ne(r, null); 7421 7422 // positive index 7423 toInject = allocSmallBytes(null, 0); 7424 r = self->f->injectSmallBytes(self, 1, toInject); 7425 ck_assert_ptr_ne(r, null); 7426 finishO(toInject); 7427 char *s = toStringO(r); 7428 ck_assert_str_eq(s, "[1,[],2,3,4]"); 7429 free(s); 7430 // negative index 7431 toInject = allocSmallBytes(null, 0); 7432 r = self->f->injectSmallBytes(self,-1, toInject); 7433 ck_assert_ptr_ne(r, null); 7434 finishO(toInject); 7435 s = toStringO(r); 7436 ck_assert_str_eq(s, "[1,[],2,3,4,[]]"); 7437 free(s); 7438 // index 0 7439 toInject = allocSmallBytes(null, 0); 7440 r = self->f->injectSmallBytes(self,0, toInject); 7441 ck_assert_ptr_ne(r, null); 7442 finishO(toInject); 7443 s = toStringO(r); 7444 ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]"); 7445 free(s); 7446 // index outside 7447 toInject = allocSmallBytes(null, 0); 7448 ck_assert_ptr_eq(self->f->injectSmallBytes(self, 20, toInject), NULL); 7449 ck_assert_ptr_eq(self->f->injectSmallBytes(self, -9, toInject), NULL); 7450 terminateO(toInject); 7451 // empty object 7452 emptyO(self); 7453 toInject = allocSmallBytes(null, 0); 7454 freeO(toInject); 7455 ck_assert_ptr_ne(self->f->injectSmallBytes(self, 0, toInject), NULL); 7456 finishO(toInject); 7457 s = toStringO(r); 7458 ck_assert_str_eq(s, "[[]]"); 7459 free(s); 7460 // empty list 7461 emptyO(self); 7462 toInject = allocSmallBytes(null, 0); 7463 ck_assert_ptr_ne(self->f->injectSmallBytes(self, 0, toInject), NULL); 7464 finishO(toInject); 7465 s = toStringO(r); 7466 ck_assert_str_eq(s, "[[]]"); 7467 free(s); 7468 emptyO(self); 7469 toInject = allocSmallBytes(null, 0); 7470 ck_assert_ptr_ne(self->f->injectSmallBytes(self, -1, toInject), NULL); 7471 finishO(toInject); 7472 s = toStringO(r); 7473 ck_assert_str_eq(s, "[[]]"); 7474 free(s); 7475 // non smallBytes object 7476 toInject = (smallBytest*) allocSmallInt(2); 7477 r = self->f->injectSmallBytes(self, 0, toInject); 7478 ck_assert_ptr_eq(r, null); 7479 terminateO(toInject); 7480 // null toInsert 7481 ck_assert_ptr_eq(self->f->injectSmallBytes(self, 0, NULL), NULL); 7482 terminateO(self); 7483 7484 } 7485 7486 7487 void injectSmallDoubleSmallArrayT(void) { 7488 7489 smallArrayt* r; 7490 smallArrayt *self = allocG(rtSmallArrayt); 7491 smallDoublet *toInject; 7492 7493 // add elements to self 7494 r = self->f->pushInt(self, 1); 7495 ck_assert_ptr_ne(r, null); 7496 r = self->f->pushInt(self, 2); 7497 ck_assert_ptr_ne(r, null); 7498 r = self->f->pushInt(self, 3); 7499 ck_assert_ptr_ne(r, null); 7500 r = self->f->pushInt(self, 4); 7501 ck_assert_ptr_ne(r, null); 7502 7503 // positive index 7504 toInject = allocSmallDouble(2); 7505 r = self->f->injectSmallDouble(self, 1, toInject); 7506 ck_assert_ptr_ne(r, null); 7507 finishO(toInject); 7508 char *s = toStringO(r); 7509 ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4]"); 7510 free(s); 7511 // negative index 7512 toInject = allocSmallDouble(3); 7513 r = self->f->injectSmallDouble(self,-1, toInject); 7514 ck_assert_ptr_ne(r, null); 7515 finishO(toInject); 7516 s = toStringO(r); 7517 ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4,3.000000e+00]"); 7518 free(s); 7519 // index 0 7520 toInject = allocSmallDouble(1); 7521 r = self->f->injectSmallDouble(self,0, toInject); 7522 ck_assert_ptr_ne(r, null); 7523 finishO(toInject); 7524 s = toStringO(r); 7525 ck_assert_str_eq(s, "[1.000000e+00,1,2.000000e+00,2,3,4,3.000000e+00]"); 7526 free(s); 7527 // index outside 7528 toInject = allocSmallDouble(1); 7529 ck_assert_ptr_eq(self->f->injectSmallDouble(self, 20, toInject), NULL); 7530 ck_assert_ptr_eq(self->f->injectSmallDouble(self, -9, toInject), NULL); 7531 terminateO(toInject); 7532 // empty object 7533 emptyO(self); 7534 toInject = allocSmallDouble(1); 7535 freeO(toInject); 7536 ck_assert_ptr_ne(self->f->injectSmallDouble(self, 0, toInject), NULL); 7537 finishO(toInject); 7538 s = toStringO(r); 7539 ck_assert_str_eq(s, "[0.000000e+00]"); 7540 free(s); 7541 // empty list 7542 emptyO(self); 7543 toInject = allocSmallDouble(1); 7544 ck_assert_ptr_ne(self->f->injectSmallDouble(self, 0, toInject), NULL); 7545 finishO(toInject); 7546 s = toStringO(r); 7547 ck_assert_str_eq(s, "[1.000000e+00]"); 7548 free(s); 7549 emptyO(self); 7550 toInject = allocSmallDouble(1); 7551 ck_assert_ptr_ne(self->f->injectSmallDouble(self, -1, toInject), NULL); 7552 finishO(toInject); 7553 s = toStringO(r); 7554 ck_assert_str_eq(s, "[1.000000e+00]"); 7555 free(s); 7556 // non smallDouble object 7557 toInject = (smallDoublet*) allocSmallInt(2); 7558 r = self->f->injectSmallDouble(self, 0, toInject); 7559 ck_assert_ptr_eq(r, null); 7560 terminateO(toInject); 7561 // null toInsert 7562 ck_assert_ptr_eq(self->f->injectSmallDouble(self, 0, NULL), NULL); 7563 terminateO(self); 7564 7565 } 7566 7567 7568 void injectSmallIntSmallArrayT(void) { 7569 7570 smallArrayt* r; 7571 smallArrayt *self = allocG(rtSmallArrayt); 7572 smallIntt *toInject; 7573 7574 // add elements to self 7575 r = self->f->pushInt(self, 1); 7576 ck_assert_ptr_ne(r, null); 7577 r = self->f->pushInt(self, 2); 7578 ck_assert_ptr_ne(r, null); 7579 r = self->f->pushInt(self, 3); 7580 ck_assert_ptr_ne(r, null); 7581 r = self->f->pushInt(self, 4); 7582 ck_assert_ptr_ne(r, null); 7583 7584 // positive index 7585 toInject = allocSmallInt(10); 7586 r = self->f->injectSmallInt(self, 1, toInject); 7587 ck_assert_ptr_ne(r, null); 7588 finishO(toInject); 7589 char *s = toStringO(r); 7590 ck_assert_str_eq(s, "[1,10,2,3,4]"); 7591 free(s); 7592 // negative index 7593 toInject = allocSmallInt(11); 7594 r = self->f->injectSmallInt(self,-1, toInject); 7595 ck_assert_ptr_ne(r, null); 7596 finishO(toInject); 7597 s = toStringO(r); 7598 ck_assert_str_eq(s, "[1,10,2,3,4,11]"); 7599 free(s); 7600 // index 0 7601 toInject = allocSmallInt(12); 7602 r = self->f->injectSmallInt(self,0, toInject); 7603 ck_assert_ptr_ne(r, null); 7604 finishO(toInject); 7605 s = toStringO(r); 7606 ck_assert_str_eq(s, "[12,1,10,2,3,4,11]"); 7607 free(s); 7608 // index outside 7609 toInject = allocSmallInt(10); 7610 ck_assert_ptr_eq(self->f->injectSmallInt(self, 20, toInject), NULL); 7611 ck_assert_ptr_eq(self->f->injectSmallInt(self, -9, toInject), NULL); 7612 terminateO(toInject); 7613 // empty object 7614 emptyO(self); 7615 toInject = allocSmallInt(10); 7616 freeO(toInject); 7617 ck_assert_ptr_ne(self->f->injectSmallInt(self, 0, toInject), NULL); 7618 finishO(toInject); 7619 s = toStringO(r); 7620 ck_assert_str_eq(s, "[0]"); 7621 free(s); 7622 // empty list 7623 emptyO(self); 7624 toInject = allocSmallInt(10); 7625 ck_assert_ptr_ne(self->f->injectSmallInt(self, 0, toInject), NULL); 7626 finishO(toInject); 7627 s = toStringO(r); 7628 ck_assert_str_eq(s, "[10]"); 7629 free(s); 7630 emptyO(self); 7631 toInject = allocSmallInt(10); 7632 ck_assert_ptr_ne(self->f->injectSmallInt(self, -1, toInject), NULL); 7633 finishO(toInject); 7634 s = toStringO(r); 7635 ck_assert_str_eq(s, "[10]"); 7636 free(s); 7637 // non smallInt object 7638 toInject = (smallIntt*) allocSmallBool(true); 7639 r = self->f->injectSmallInt(self, 0, toInject); 7640 ck_assert_ptr_eq(r, null); 7641 terminateO(toInject); 7642 // null toInsert 7643 ck_assert_ptr_eq(self->f->injectSmallInt(self, 0, NULL), NULL); 7644 terminateO(self); 7645 7646 } 7647 7648 7649 void injectSmallJsonSmallArrayT(void) { 7650 7651 smallArrayt* r; 7652 smallArrayt *self = allocG(rtSmallArrayt); 7653 smallJsont *toInject; 7654 7655 // add elements to self 7656 r = self->f->pushInt(self, 1); 7657 ck_assert_ptr_ne(r, null); 7658 r = self->f->pushInt(self, 2); 7659 ck_assert_ptr_ne(r, null); 7660 r = self->f->pushInt(self, 3); 7661 ck_assert_ptr_ne(r, null); 7662 r = self->f->pushInt(self, 4); 7663 ck_assert_ptr_ne(r, null); 7664 7665 // positive index 7666 toInject = allocSmallJson(); 7667 r = self->f->injectSmallJson(self, 1, toInject); 7668 ck_assert_ptr_ne(r, null); 7669 finishO(toInject); 7670 char *s = toStringO(r); 7671 ck_assert_str_eq(s, "[1,{},2,3,4]"); 7672 free(s); 7673 // negative index 7674 toInject = allocSmallJson(); 7675 r = self->f->injectSmallJson(self,-1, toInject); 7676 ck_assert_ptr_ne(r, null); 7677 finishO(toInject); 7678 s = toStringO(r); 7679 ck_assert_str_eq(s, "[1,{},2,3,4,{}]"); 7680 free(s); 7681 // index 0 7682 toInject = allocSmallJson(); 7683 toInject->f->setS(toInject, "key", "value"); 7684 r = self->f->injectSmallJson(self,0, toInject); 7685 ck_assert_ptr_ne(r, null); 7686 finishO(toInject); 7687 s = toStringO(r); 7688 ck_assert_str_eq(s, "[{\"key\":\"value\"},1,{},2,3,4,{}]"); 7689 free(s); 7690 // index outside 7691 toInject = allocSmallJson(); 7692 ck_assert_ptr_eq(self->f->injectSmallJson(self, 20, toInject), NULL); 7693 ck_assert_ptr_eq(self->f->injectSmallJson(self, -9, toInject), NULL); 7694 terminateO(toInject); 7695 // empty object 7696 emptyO(self); 7697 toInject = allocSmallJson(); 7698 freeO(toInject); 7699 ck_assert_ptr_ne(self->f->injectSmallJson(self, 0, toInject), NULL); 7700 finishO(toInject); 7701 s = toStringO(r); 7702 ck_assert_str_eq(s, "[{}]"); 7703 free(s); 7704 // empty list 7705 emptyO(self); 7706 toInject = allocSmallJson(); 7707 ck_assert_ptr_ne(self->f->injectSmallJson(self, 0, toInject), NULL); 7708 finishO(toInject); 7709 s = toStringO(r); 7710 ck_assert_str_eq(s, "[{}]"); 7711 free(s); 7712 emptyO(self); 7713 toInject = allocSmallJson(); 7714 ck_assert_ptr_ne(self->f->injectSmallJson(self, -1, toInject), NULL); 7715 finishO(toInject); 7716 s = toStringO(r); 7717 ck_assert_str_eq(s, "[{}]"); 7718 free(s); 7719 // non smallJson object 7720 toInject = (smallJsont*) allocSmallInt(2); 7721 r = self->f->injectSmallJson(self, 0, toInject); 7722 ck_assert_ptr_eq(r, null); 7723 terminateO(toInject); 7724 // null toInsert 7725 ck_assert_ptr_eq(self->f->injectSmallJson(self, 0, NULL), NULL); 7726 terminateO(self); 7727 7728 } 7729 7730 7731 void injectSmallStringSmallArrayT(void) { 7732 7733 smallArrayt* r; 7734 smallArrayt *self = allocG(rtSmallArrayt); 7735 smallStringt *toInject; 7736 7737 // add elements to self 7738 r = self->f->pushInt(self, 1); 7739 ck_assert_ptr_ne(r, null); 7740 r = self->f->pushInt(self, 2); 7741 ck_assert_ptr_ne(r, null); 7742 r = self->f->pushInt(self, 3); 7743 ck_assert_ptr_ne(r, null); 7744 r = self->f->pushInt(self, 4); 7745 ck_assert_ptr_ne(r, null); 7746 7747 // positive index 7748 toInject = allocSmallString("1"); 7749 r = self->f->injectSmallString(self, 1, toInject); 7750 ck_assert_ptr_ne(r, null); 7751 finishO(toInject); 7752 char *s = toStringO(r); 7753 ck_assert_str_eq(s, "[1,\"1\",2,3,4]"); 7754 free(s); 7755 // negative index 7756 toInject = allocSmallString("2"); 7757 r = self->f->injectSmallString(self,-1, toInject); 7758 ck_assert_ptr_ne(r, null); 7759 finishO(toInject); 7760 s = toStringO(r); 7761 ck_assert_str_eq(s, "[1,\"1\",2,3,4,\"2\"]"); 7762 free(s); 7763 // index 0 7764 toInject = allocSmallString("3"); 7765 r = self->f->injectSmallString(self,0, toInject); 7766 ck_assert_ptr_ne(r, null); 7767 finishO(toInject); 7768 s = toStringO(r); 7769 ck_assert_str_eq(s, "[\"3\",1,\"1\",2,3,4,\"2\"]"); 7770 free(s); 7771 // index outside 7772 toInject = allocSmallString("1"); 7773 ck_assert_ptr_eq(self->f->injectSmallString(self, 20, toInject), NULL); 7774 ck_assert_ptr_eq(self->f->injectSmallString(self, -9, toInject), NULL); 7775 terminateO(toInject); 7776 // empty object 7777 emptyO(self); 7778 toInject = allocSmallString("1"); 7779 freeO(toInject); 7780 ck_assert_ptr_ne(self->f->injectSmallString(self, 0, toInject), NULL); 7781 finishO(toInject); 7782 s = toStringO(r); 7783 ck_assert_str_eq(s, "[\"\"]"); 7784 free(s); 7785 // empty list 7786 emptyO(self); 7787 toInject = allocSmallString("1"); 7788 ck_assert_ptr_ne(self->f->injectSmallString(self, 0, toInject), NULL); 7789 finishO(toInject); 7790 s = toStringO(r); 7791 ck_assert_str_eq(s, "[\"1\"]"); 7792 free(s); 7793 emptyO(self); 7794 toInject = allocSmallString("1"); 7795 ck_assert_ptr_ne(self->f->injectSmallString(self, -1, toInject), NULL); 7796 finishO(toInject); 7797 s = toStringO(r); 7798 ck_assert_str_eq(s, "[\"1\"]"); 7799 free(s); 7800 // non smallString object 7801 toInject = (smallStringt*) allocSmallInt(2); 7802 r = self->f->injectSmallString(self, 0, toInject); 7803 ck_assert_ptr_eq(r, null); 7804 terminateO(toInject); 7805 // null toInsert 7806 ck_assert_ptr_eq(self->f->injectSmallString(self, 0, NULL), NULL); 7807 terminateO(self); 7808 7809 } 7810 7811 7812 void injectSmallContainerSmallArrayT(void) { 7813 7814 smallArrayt* r; 7815 smallArrayt *self = allocG(rtSmallArrayt); 7816 smallContainert *toInject; 7817 7818 // add elements to self 7819 r = self->f->pushInt(self, 1); 7820 ck_assert_ptr_ne(r, null); 7821 r = self->f->pushInt(self, 2); 7822 ck_assert_ptr_ne(r, null); 7823 r = self->f->pushInt(self, 3); 7824 ck_assert_ptr_ne(r, null); 7825 r = self->f->pushInt(self, 4); 7826 ck_assert_ptr_ne(r, null); 7827 7828 // positive index 7829 toInject = allocSmallContainer(NULL); 7830 r = self->f->injectSmallContainer(self, 1, toInject); 7831 ck_assert_ptr_ne(r, null); 7832 finishO(toInject); 7833 char *s = toStringO(r); 7834 ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4]"); 7835 free(s); 7836 // negative index 7837 toInject = allocSmallContainer(NULL); 7838 r = self->f->injectSmallContainer(self,-1, toInject); 7839 ck_assert_ptr_ne(r, null); 7840 finishO(toInject); 7841 s = toStringO(r); 7842 ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4,\"<data container>\"]"); 7843 free(s); 7844 // index 0 7845 toInject = allocSmallContainer(NULL); 7846 r = self->f->injectSmallContainer(self,0, toInject); 7847 ck_assert_ptr_ne(r, null); 7848 finishO(toInject); 7849 s = toStringO(r); 7850 ck_assert_str_eq(s, "[\"<data container>\",1,\"<data container>\",2,3,4,\"<data container>\"]"); 7851 free(s); 7852 // index outside 7853 toInject = allocSmallContainer(NULL); 7854 ck_assert_ptr_eq(self->f->injectSmallContainer(self, 20, toInject), NULL); 7855 ck_assert_ptr_eq(self->f->injectSmallContainer(self, -9, toInject), NULL); 7856 terminateO(toInject); 7857 // empty object 7858 emptyO(self); 7859 toInject = allocSmallContainer(NULL); 7860 freeO(toInject); 7861 ck_assert_ptr_ne(self->f->injectSmallContainer(self, 0, toInject), NULL); 7862 finishO(toInject); 7863 s = toStringO(r); 7864 ck_assert_str_eq(s, "[\"<data container>\"]"); 7865 free(s); 7866 // empty list 7867 emptyO(self); 7868 toInject = allocSmallContainer(NULL); 7869 ck_assert_ptr_ne(self->f->injectSmallContainer(self, 0, toInject), NULL); 7870 finishO(toInject); 7871 s = toStringO(r); 7872 ck_assert_str_eq(s, "[\"<data container>\"]"); 7873 free(s); 7874 emptyO(self); 7875 toInject = allocSmallContainer(NULL); 7876 ck_assert_ptr_ne(self->f->injectSmallContainer(self, -1, toInject), NULL); 7877 finishO(toInject); 7878 s = toStringO(r); 7879 ck_assert_str_eq(s, "[\"<data container>\"]"); 7880 free(s); 7881 // non smallContainer object 7882 toInject = (smallContainert*) allocSmallInt(2); 7883 r = self->f->injectSmallContainer(self, 0, toInject); 7884 ck_assert_ptr_eq(r, null); 7885 terminateO(toInject); 7886 // null toInsert 7887 ck_assert_ptr_eq(self->f->injectSmallContainer(self, 0, NULL), NULL); 7888 terminateO(self); 7889 7890 } 7891 7892 7893 void injectNFreeSmallArrayT(void) { 7894 7895 smallArrayt* r; 7896 smallArrayt *self = allocG(rtSmallArrayt); 7897 baset *toInject; 7898 7899 // add elements to self 7900 r = self->f->pushInt(self, 1); 7901 ck_assert_ptr_ne(r, null); 7902 r = self->f->pushInt(self, 2); 7903 ck_assert_ptr_ne(r, null); 7904 r = self->f->pushInt(self, 3); 7905 ck_assert_ptr_ne(r, null); 7906 r = self->f->pushInt(self, 4); 7907 ck_assert_ptr_ne(r, null); 7908 7909 // positive index 7910 toInject = (baset*) allocSmallInt(8); 7911 r = self->f->injectNFree(self, 1, toInject); 7912 ck_assert_ptr_ne(r, null); 7913 char *s = toStringO(r); 7914 ck_assert_str_eq(s, "[1,8,2,3,4]"); 7915 free(s); 7916 // negative index 7917 toInject = (baset*) allocSmallInt(9); 7918 r = self->f->injectNFree(self,-1, toInject); 7919 ck_assert_ptr_ne(r, null); 7920 s = toStringO(r); 7921 ck_assert_str_eq(s, "[1,8,2,3,4,9]"); 7922 free(s); 7923 // index 0 7924 toInject = (baset*) allocSmallInt(6); 7925 r = self->f->injectNFree(self,0, toInject); 7926 ck_assert_ptr_ne(r, null); 7927 s = toStringO(r); 7928 ck_assert_str_eq(s, "[6,1,8,2,3,4,9]"); 7929 free(s); 7930 // index outside 7931 toInject = (baset*) allocSmallInt(7); 7932 ck_assert_ptr_eq(self->f->injectNFree(self, 20, toInject), NULL); 7933 ck_assert_ptr_eq(self->f->injectNFree(self, -9, toInject), NULL); 7934 terminateO(toInject); 7935 // empty list 7936 emptyO(self); 7937 toInject = (baset*) allocSmallInt(7); 7938 ck_assert_ptr_ne(self->f->injectNFree(self, 0, toInject), NULL); 7939 s = toStringO(r); 7940 ck_assert_str_eq(s, "[7]"); 7941 free(s); 7942 emptyO(self); 7943 toInject = (baset*) allocSmallInt(7); 7944 ck_assert_ptr_ne(self->f->injectNFree(self, -1, toInject), NULL); 7945 s = toStringO(r); 7946 ck_assert_str_eq(s, "[7]"); 7947 free(s); 7948 // null toInsert 7949 ck_assert_ptr_eq(self->f->injectNFree(self, 0, NULL), NULL); 7950 terminateO(self); 7951 7952 } 7953 7954 7955 void injectNFreeUndefinedSmallArrayT(void) { 7956 7957 smallArrayt* r; 7958 smallArrayt *self = allocG(rtSmallArrayt); 7959 undefinedt *value = NULL; 7960 7961 7962 // add elements to self 7963 r = self->f->pushInt(self, 1); 7964 ck_assert_ptr_ne(r, null); 7965 r = self->f->pushInt(self, 2); 7966 ck_assert_ptr_ne(r, null); 7967 r = self->f->pushInt(self, 3); 7968 ck_assert_ptr_ne(r, null); 7969 r = self->f->pushInt(self, 4); 7970 ck_assert_ptr_ne(r, null); 7971 7972 // positive index 7973 value = allocUndefined(); 7974 r = self->f->injectNFreeUndefined(self, 1, value); 7975 ck_assert_ptr_ne(r, null); 7976 char *s = toStringO(r); 7977 ck_assert_str_eq(s, "[1,null,2,3,4]"); 7978 free(s); 7979 // negative index 7980 value = allocUndefined(); 7981 r = self->f->injectNFreeUndefined(self,-1, value); 7982 ck_assert_ptr_ne(r, null); 7983 s = toStringO(r); 7984 ck_assert_str_eq(s, "[1,null,2,3,4,null]"); 7985 free(s); 7986 // index 0 7987 value = allocUndefined(); 7988 r = self->f->injectNFreeUndefined(self,0, value); 7989 ck_assert_ptr_ne(r, null); 7990 s = toStringO(r); 7991 ck_assert_str_eq(s, "[null,1,null,2,3,4,null]"); 7992 free(s); 7993 // index outside 7994 value = allocUndefined(); 7995 ck_assert_ptr_eq(self->f->injectNFreeUndefined(self, 20, value), NULL); 7996 terminateO(value); 7997 7998 value = allocUndefined(); 7999 ck_assert_ptr_eq(self->f->injectNFreeUndefined(self, -9, value), NULL); 8000 terminateO(value); 8001 8002 // empty list 8003 emptyO(self); 8004 value = allocUndefined(); 8005 ck_assert_ptr_ne(self->f->injectNFreeUndefined(self, 0, value), NULL); 8006 s = toStringO(r); 8007 ck_assert_str_eq(s, "[null]"); 8008 free(s); 8009 emptyO(self); 8010 value = allocUndefined(); 8011 ck_assert_ptr_ne(self->f->injectNFreeUndefined(self, -1, value), NULL); 8012 s = toStringO(r); 8013 ck_assert_str_eq(s, "[null]"); 8014 free(s); 8015 terminateO(self); 8016 8017 } 8018 8019 8020 void injectNFreeSSmallArrayT(void) { 8021 8022 smallArrayt* r; 8023 smallArrayt *self = allocG(rtSmallArrayt); 8024 8025 // add elements to self 8026 r = self->f->pushInt(self, 1); 8027 ck_assert_ptr_ne(r, null); 8028 r = self->f->pushInt(self, 2); 8029 ck_assert_ptr_ne(r, null); 8030 r = self->f->pushInt(self, 3); 8031 ck_assert_ptr_ne(r, null); 8032 r = self->f->pushInt(self, 4); 8033 ck_assert_ptr_ne(r, null); 8034 8035 // positive index 8036 r = self->f->injectNFreeS(self, 1, strdup("5")); 8037 ck_assert_ptr_ne(r, null); 8038 char *s = toStringO(r); 8039 ck_assert_str_eq(s, "[1,\"5\",2,3,4]"); 8040 free(s); 8041 // negative index 8042 r = self->f->injectNFreeS(self,-1, strdup("6")); 8043 ck_assert_ptr_ne(r, null); 8044 s = toStringO(r); 8045 ck_assert_str_eq(s, "[1,\"5\",2,3,4,\"6\"]"); 8046 free(s); 8047 // index 0 8048 r = self->f->injectNFreeS(self,0, strdup("7")); 8049 ck_assert_ptr_ne(r, null); 8050 s = toStringO(r); 8051 ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]"); 8052 free(s); 8053 // index outside 8054 ck_assert_ptr_eq(self->f->injectNFreeS(self, 20, ""), NULL); 8055 ck_assert_ptr_eq(self->f->injectNFreeS(self, -9, ""), NULL); 8056 // empty list 8057 emptyO(self); 8058 ck_assert_ptr_ne(self->f->injectNFreeS(self, 0, strdup("7")), NULL); 8059 s = toStringO(r); 8060 ck_assert_str_eq(s, "[\"7\"]"); 8061 free(s); 8062 emptyO(self); 8063 ck_assert_ptr_ne(self->f->injectNFreeS(self, -1, strdup("7")), NULL); 8064 s = toStringO(r); 8065 ck_assert_str_eq(s, "[\"7\"]"); 8066 free(s); 8067 terminateO(self); 8068 8069 } 8070 8071 8072 void injectNFreeDictSmallArrayT(void) { 8073 8074 smallArrayt* r; 8075 smallArrayt *self = allocG(rtSmallArrayt); 8076 smallDictt *toInject; 8077 8078 // add elements to self 8079 r = self->f->pushInt(self, 1); 8080 ck_assert_ptr_ne(r, null); 8081 r = self->f->pushInt(self, 2); 8082 ck_assert_ptr_ne(r, null); 8083 r = self->f->pushInt(self, 3); 8084 ck_assert_ptr_ne(r, null); 8085 r = self->f->pushInt(self, 4); 8086 ck_assert_ptr_ne(r, null); 8087 8088 // positive index 8089 toInject = allocSmallDict(); 8090 r = self->f->injectNFreeDict(self, 1, toInject); 8091 ck_assert_ptr_ne(r, null); 8092 char *s = toStringO(r); 8093 ck_assert_str_eq(s, "[1,{},2,3,4]"); 8094 free(s); 8095 // negative index 8096 toInject = allocSmallDict(); 8097 r = self->f->injectNFreeDict(self,-1, toInject); 8098 ck_assert_ptr_ne(r, null); 8099 s = toStringO(r); 8100 ck_assert_str_eq(s, "[1,{},2,3,4,{}]"); 8101 free(s); 8102 // index 0 8103 toInject = allocSmallDict(); 8104 r = self->f->injectNFreeDict(self,0, toInject); 8105 ck_assert_ptr_ne(r, null); 8106 s = toStringO(r); 8107 ck_assert_str_eq(s, "[{},1,{},2,3,4,{}]"); 8108 free(s); 8109 // index outside 8110 toInject = allocSmallDict(); 8111 ck_assert_ptr_eq(self->f->injectNFreeDict(self, 20, toInject), NULL); 8112 ck_assert_ptr_eq(self->f->injectNFreeDict(self, -9, toInject), NULL); 8113 terminateO(toInject); 8114 // empty list 8115 emptyO(self); 8116 toInject = allocSmallDict(); 8117 ck_assert_ptr_ne(self->f->injectNFreeDict(self, 0, toInject), NULL); 8118 s = toStringO(r); 8119 ck_assert_str_eq(s, "[{}]"); 8120 free(s); 8121 emptyO(self); 8122 toInject = allocSmallDict(); 8123 ck_assert_ptr_ne(self->f->injectNFreeDict(self, -1, toInject), NULL); 8124 s = toStringO(r); 8125 ck_assert_str_eq(s, "[{}]"); 8126 free(s); 8127 // null toInsert 8128 ck_assert_ptr_eq(self->f->injectNFreeDict(self, 0, NULL), NULL); 8129 terminateO(self); 8130 8131 } 8132 8133 8134 void injectNFreeArraySmallArrayT(void) { 8135 8136 smallArrayt* r; 8137 smallArrayt *self = allocG(rtSmallArrayt); 8138 smallArrayt *toInject; 8139 8140 // add elements to self 8141 r = self->f->pushInt(self, 1); 8142 ck_assert_ptr_ne(r, null); 8143 r = self->f->pushInt(self, 2); 8144 ck_assert_ptr_ne(r, null); 8145 r = self->f->pushInt(self, 3); 8146 ck_assert_ptr_ne(r, null); 8147 r = self->f->pushInt(self, 4); 8148 ck_assert_ptr_ne(r, null); 8149 8150 // positive index 8151 toInject = allocSmallArray(); 8152 r = self->f->injectNFreeArray(self, 1, toInject); 8153 ck_assert_ptr_ne(r, null); 8154 char *s = toStringO(r); 8155 ck_assert_str_eq(s, "[1,[],2,3,4]"); 8156 free(s); 8157 // negative index 8158 toInject = allocSmallArray(); 8159 r = self->f->injectNFreeArray(self,-1, toInject); 8160 ck_assert_ptr_ne(r, null); 8161 s = toStringO(r); 8162 ck_assert_str_eq(s, "[1,[],2,3,4,[]]"); 8163 free(s); 8164 // index 0 8165 toInject = allocSmallArray(); 8166 r = self->f->injectNFreeArray(self,0, toInject); 8167 ck_assert_ptr_ne(r, null); 8168 s = toStringO(r); 8169 ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]"); 8170 free(s); 8171 // index outside 8172 toInject = allocSmallArray(); 8173 ck_assert_ptr_eq(self->f->injectNFreeArray(self, 20, toInject), NULL); 8174 ck_assert_ptr_eq(self->f->injectNFreeArray(self, -9, toInject), NULL); 8175 terminateO(toInject); 8176 // empty list 8177 emptyO(self); 8178 toInject = allocSmallArray(); 8179 ck_assert_ptr_ne(self->f->injectNFreeArray(self, 0, toInject), NULL); 8180 s = toStringO(r); 8181 ck_assert_str_eq(s, "[[]]"); 8182 free(s); 8183 emptyO(self); 8184 toInject = allocSmallArray(); 8185 ck_assert_ptr_ne(self->f->injectNFreeArray(self, -1, toInject), NULL); 8186 s = toStringO(r); 8187 ck_assert_str_eq(s, "[[]]"); 8188 free(s); 8189 // null toInsert 8190 ck_assert_ptr_eq(self->f->injectNFreeArray(self, 0, NULL), NULL); 8191 terminateO(self); 8192 8193 } 8194 8195 8196 void injectNFreeArraycSmallArrayT(void) { 8197 8198 smallArrayt* r; 8199 smallArrayt *self = allocG(rtSmallArrayt); 8200 char **toInject; 8201 8202 // add elements to self 8203 r = self->f->pushInt(self, 1); 8204 ck_assert_ptr_ne(r, null); 8205 r = self->f->pushInt(self, 2); 8206 ck_assert_ptr_ne(r, null); 8207 r = self->f->pushInt(self, 3); 8208 ck_assert_ptr_ne(r, null); 8209 r = self->f->pushInt(self, 4); 8210 ck_assert_ptr_ne(r, null); 8211 8212 // positive index 8213 toInject = listCreateS("a","b"); 8214 r = self->f->injectNFreeArrayc(self, 1, toInject); 8215 ck_assert_ptr_ne(r, null); 8216 char *s = toStringO(r); 8217 ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4]"); 8218 free(s); 8219 // negative index 8220 toInject = listCreateS("c","d"); 8221 r = self->f->injectNFreeArrayc(self,-1, toInject); 8222 ck_assert_ptr_ne(r, null); 8223 s = toStringO(r); 8224 ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]"); 8225 free(s); 8226 // index 0 8227 toInject = listCreateS("e","ff"); 8228 r = self->f->injectNFreeArrayc(self,0, toInject); 8229 ck_assert_ptr_ne(r, null); 8230 s = toStringO(r); 8231 ck_assert_str_eq(s, "[[\"e\",\"ff\"],1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]"); 8232 free(s); 8233 // index outside 8234 toInject = listCreateS("a","b"); 8235 ck_assert_ptr_eq(self->f->injectNFreeArrayc(self, 20, toInject), NULL); 8236 ck_assert_ptr_eq(self->f->injectNFreeArrayc(self, -9, toInject), NULL); 8237 listFreeS(toInject); 8238 // empty list 8239 emptyO(self); 8240 toInject = listCreateS("a","b"); 8241 ck_assert_ptr_ne(self->f->injectNFreeArrayc(self, 0, toInject), NULL); 8242 s = toStringO(r); 8243 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 8244 free(s); 8245 emptyO(self); 8246 toInject = listCreateS("a","b"); 8247 ck_assert_ptr_ne(self->f->injectNFreeArrayc(self, -1, toInject), NULL); 8248 s = toStringO(r); 8249 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 8250 free(s); 8251 // null toInsert 8252 ck_assert_ptr_eq(self->f->injectNFreeArrayc(self, 0, NULL), NULL); 8253 terminateO(self); 8254 8255 } 8256 8257 8258 void injectNFreeSmallBoolSmallArrayT(void) { 8259 8260 smallArrayt* r; 8261 smallArrayt *self = allocG(rtSmallArrayt); 8262 smallBoolt *toInject; 8263 8264 // add elements to self 8265 r = self->f->pushInt(self, 1); 8266 ck_assert_ptr_ne(r, null); 8267 r = self->f->pushInt(self, 2); 8268 ck_assert_ptr_ne(r, null); 8269 r = self->f->pushInt(self, 3); 8270 ck_assert_ptr_ne(r, null); 8271 r = self->f->pushInt(self, 4); 8272 ck_assert_ptr_ne(r, null); 8273 8274 // positive index 8275 toInject = allocSmallBool(true); 8276 r = self->f->injectNFreeSmallBool(self, 1, toInject); 8277 ck_assert_ptr_ne(r, null); 8278 char *s = toStringO(r); 8279 ck_assert_str_eq(s, "[1,true,2,3,4]"); 8280 free(s); 8281 // negative index 8282 toInject = allocSmallBool(true); 8283 r = self->f->injectNFreeSmallBool(self,-1, toInject); 8284 ck_assert_ptr_ne(r, null); 8285 s = toStringO(r); 8286 ck_assert_str_eq(s, "[1,true,2,3,4,true]"); 8287 free(s); 8288 // index 0 8289 toInject = allocSmallBool(true); 8290 r = self->f->injectNFreeSmallBool(self,0, toInject); 8291 ck_assert_ptr_ne(r, null); 8292 s = toStringO(r); 8293 ck_assert_str_eq(s, "[true,1,true,2,3,4,true]"); 8294 free(s); 8295 // index outside 8296 toInject = allocSmallBool(true); 8297 ck_assert_ptr_eq(self->f->injectNFreeSmallBool(self, 20, toInject), NULL); 8298 ck_assert_ptr_eq(self->f->injectNFreeSmallBool(self, -9, toInject), NULL); 8299 terminateO(toInject); 8300 // empty object 8301 emptyO(self); 8302 toInject = allocSmallBool(true); 8303 freeO(toInject); 8304 ck_assert_ptr_ne(self->f->injectNFreeSmallBool(self, 0, toInject), NULL); 8305 s = toStringO(r); 8306 ck_assert_str_eq(s, "[false]"); 8307 free(s); 8308 // empty list 8309 emptyO(self); 8310 toInject = allocSmallBool(true); 8311 ck_assert_ptr_ne(self->f->injectNFreeSmallBool(self, 0, toInject), NULL); 8312 s = toStringO(r); 8313 ck_assert_str_eq(s, "[true]"); 8314 free(s); 8315 emptyO(self); 8316 toInject = allocSmallBool(true); 8317 ck_assert_ptr_ne(self->f->injectNFreeSmallBool(self, -1, toInject), NULL); 8318 s = toStringO(r); 8319 ck_assert_str_eq(s, "[true]"); 8320 free(s); 8321 // null toInsert 8322 ck_assert_ptr_eq(self->f->injectNFreeSmallBool(self, 0, NULL), NULL); 8323 terminateO(self); 8324 8325 } 8326 8327 8328 void injectNFreeSmallBytesSmallArrayT(void) { 8329 8330 smallArrayt* r; 8331 smallArrayt *self = allocG(rtSmallArrayt); 8332 smallBytest *toInject; 8333 8334 // add elements to self 8335 r = self->f->pushInt(self, 1); 8336 ck_assert_ptr_ne(r, null); 8337 r = self->f->pushInt(self, 2); 8338 ck_assert_ptr_ne(r, null); 8339 r = self->f->pushInt(self, 3); 8340 ck_assert_ptr_ne(r, null); 8341 r = self->f->pushInt(self, 4); 8342 ck_assert_ptr_ne(r, null); 8343 8344 // positive index 8345 toInject = allocSmallBytes(null, 0); 8346 r = self->f->injectNFreeSmallBytes(self, 1, toInject); 8347 ck_assert_ptr_ne(r, null); 8348 char *s = toStringO(r); 8349 ck_assert_str_eq(s, "[1,[],2,3,4]"); 8350 free(s); 8351 // negative index 8352 toInject = allocSmallBytes(null, 0); 8353 r = self->f->injectNFreeSmallBytes(self,-1, toInject); 8354 ck_assert_ptr_ne(r, null); 8355 s = toStringO(r); 8356 ck_assert_str_eq(s, "[1,[],2,3,4,[]]"); 8357 free(s); 8358 // index 0 8359 toInject = allocSmallBytes(null, 0); 8360 r = self->f->injectNFreeSmallBytes(self,0, toInject); 8361 ck_assert_ptr_ne(r, null); 8362 s = toStringO(r); 8363 ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]"); 8364 free(s); 8365 // index outside 8366 toInject = allocSmallBytes(null, 0); 8367 ck_assert_ptr_eq(self->f->injectNFreeSmallBytes(self, 20, toInject), NULL); 8368 ck_assert_ptr_eq(self->f->injectNFreeSmallBytes(self, -9, toInject), NULL); 8369 terminateO(toInject); 8370 // empty object 8371 emptyO(self); 8372 toInject = allocSmallBytes(null, 0); 8373 freeO(toInject); 8374 ck_assert_ptr_ne(self->f->injectNFreeSmallBytes(self, 0, toInject), NULL); 8375 s = toStringO(r); 8376 ck_assert_str_eq(s, "[[]]"); 8377 free(s); 8378 // empty list 8379 emptyO(self); 8380 toInject = allocSmallBytes(null, 0); 8381 ck_assert_ptr_ne(self->f->injectNFreeSmallBytes(self, 0, toInject), NULL); 8382 s = toStringO(r); 8383 ck_assert_str_eq(s, "[[]]"); 8384 free(s); 8385 emptyO(self); 8386 toInject = allocSmallBytes(null, 0); 8387 ck_assert_ptr_ne(self->f->injectNFreeSmallBytes(self, -1, toInject), NULL); 8388 s = toStringO(r); 8389 ck_assert_str_eq(s, "[[]]"); 8390 free(s); 8391 // null toInsert 8392 ck_assert_ptr_eq(self->f->injectNFreeSmallBytes(self, 0, NULL), NULL); 8393 terminateO(self); 8394 8395 } 8396 8397 8398 void injectNFreeSmallDoubleSmallArrayT(void) { 8399 8400 smallArrayt* r; 8401 smallArrayt *self = allocG(rtSmallArrayt); 8402 smallDoublet *toInject; 8403 8404 // add elements to self 8405 r = self->f->pushInt(self, 1); 8406 ck_assert_ptr_ne(r, null); 8407 r = self->f->pushInt(self, 2); 8408 ck_assert_ptr_ne(r, null); 8409 r = self->f->pushInt(self, 3); 8410 ck_assert_ptr_ne(r, null); 8411 r = self->f->pushInt(self, 4); 8412 ck_assert_ptr_ne(r, null); 8413 8414 // positive index 8415 toInject = allocSmallDouble(2); 8416 r = self->f->injectNFreeSmallDouble(self, 1, toInject); 8417 ck_assert_ptr_ne(r, null); 8418 char *s = toStringO(r); 8419 ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4]"); 8420 free(s); 8421 // negative index 8422 toInject = allocSmallDouble(3); 8423 r = self->f->injectNFreeSmallDouble(self,-1, toInject); 8424 ck_assert_ptr_ne(r, null); 8425 s = toStringO(r); 8426 ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4,3.000000e+00]"); 8427 free(s); 8428 // index 0 8429 toInject = allocSmallDouble(1); 8430 r = self->f->injectNFreeSmallDouble(self,0, toInject); 8431 ck_assert_ptr_ne(r, null); 8432 s = toStringO(r); 8433 ck_assert_str_eq(s, "[1.000000e+00,1,2.000000e+00,2,3,4,3.000000e+00]"); 8434 free(s); 8435 // index outside 8436 toInject = allocSmallDouble(1); 8437 ck_assert_ptr_eq(self->f->injectNFreeSmallDouble(self, 20, toInject), NULL); 8438 ck_assert_ptr_eq(self->f->injectNFreeSmallDouble(self, -9, toInject), NULL); 8439 terminateO(toInject); 8440 // empty object 8441 emptyO(self); 8442 toInject = allocSmallDouble(1); 8443 freeO(toInject); 8444 ck_assert_ptr_ne(self->f->injectNFreeSmallDouble(self, 0, toInject), NULL); 8445 s = toStringO(r); 8446 ck_assert_str_eq(s, "[0.000000e+00]"); 8447 free(s); 8448 // empty list 8449 emptyO(self); 8450 toInject = allocSmallDouble(1); 8451 ck_assert_ptr_ne(self->f->injectNFreeSmallDouble(self, 0, toInject), NULL); 8452 s = toStringO(r); 8453 ck_assert_str_eq(s, "[1.000000e+00]"); 8454 free(s); 8455 emptyO(self); 8456 toInject = allocSmallDouble(1); 8457 ck_assert_ptr_ne(self->f->injectNFreeSmallDouble(self, -1, toInject), NULL); 8458 s = toStringO(r); 8459 ck_assert_str_eq(s, "[1.000000e+00]"); 8460 free(s); 8461 // null toInsert 8462 ck_assert_ptr_eq(self->f->injectNFreeSmallDouble(self, 0, NULL), NULL); 8463 terminateO(self); 8464 8465 } 8466 8467 8468 void injectNFreeSmallIntSmallArrayT(void) { 8469 8470 smallArrayt* r; 8471 smallArrayt *self = allocG(rtSmallArrayt); 8472 smallIntt *toInject; 8473 8474 // add elements to self 8475 r = self->f->pushInt(self, 1); 8476 ck_assert_ptr_ne(r, null); 8477 r = self->f->pushInt(self, 2); 8478 ck_assert_ptr_ne(r, null); 8479 r = self->f->pushInt(self, 3); 8480 ck_assert_ptr_ne(r, null); 8481 r = self->f->pushInt(self, 4); 8482 ck_assert_ptr_ne(r, null); 8483 8484 // positive index 8485 toInject = allocSmallInt(10); 8486 r = self->f->injectNFreeSmallInt(self, 1, toInject); 8487 ck_assert_ptr_ne(r, null); 8488 char *s = toStringO(r); 8489 ck_assert_str_eq(s, "[1,10,2,3,4]"); 8490 free(s); 8491 // negative index 8492 toInject = allocSmallInt(11); 8493 r = self->f->injectNFreeSmallInt(self,-1, toInject); 8494 ck_assert_ptr_ne(r, null); 8495 s = toStringO(r); 8496 ck_assert_str_eq(s, "[1,10,2,3,4,11]"); 8497 free(s); 8498 // index 0 8499 toInject = allocSmallInt(12); 8500 r = self->f->injectNFreeSmallInt(self,0, toInject); 8501 ck_assert_ptr_ne(r, null); 8502 s = toStringO(r); 8503 ck_assert_str_eq(s, "[12,1,10,2,3,4,11]"); 8504 free(s); 8505 // index outside 8506 toInject = allocSmallInt(10); 8507 ck_assert_ptr_eq(self->f->injectNFreeSmallInt(self, 20, toInject), NULL); 8508 ck_assert_ptr_eq(self->f->injectNFreeSmallInt(self, -9, toInject), NULL); 8509 terminateO(toInject); 8510 // empty object 8511 emptyO(self); 8512 toInject = allocSmallInt(10); 8513 freeO(toInject); 8514 ck_assert_ptr_ne(self->f->injectNFreeSmallInt(self, 0, toInject), NULL); 8515 s = toStringO(r); 8516 ck_assert_str_eq(s, "[0]"); 8517 free(s); 8518 // empty list 8519 emptyO(self); 8520 toInject = allocSmallInt(10); 8521 ck_assert_ptr_ne(self->f->injectNFreeSmallInt(self, 0, toInject), NULL); 8522 s = toStringO(r); 8523 ck_assert_str_eq(s, "[10]"); 8524 free(s); 8525 emptyO(self); 8526 toInject = allocSmallInt(10); 8527 ck_assert_ptr_ne(self->f->injectNFreeSmallInt(self, -1, toInject), NULL); 8528 s = toStringO(r); 8529 ck_assert_str_eq(s, "[10]"); 8530 free(s); 8531 // null toInsert 8532 ck_assert_ptr_eq(self->f->injectNFreeSmallInt(self, 0, NULL), NULL); 8533 terminateO(self); 8534 8535 } 8536 8537 8538 void injectNFreeSmallJsonSmallArrayT(void) { 8539 8540 smallArrayt* r; 8541 smallArrayt *self = allocG(rtSmallArrayt); 8542 smallJsont *toInject; 8543 8544 // add elements to self 8545 r = self->f->pushInt(self, 1); 8546 ck_assert_ptr_ne(r, null); 8547 r = self->f->pushInt(self, 2); 8548 ck_assert_ptr_ne(r, null); 8549 r = self->f->pushInt(self, 3); 8550 ck_assert_ptr_ne(r, null); 8551 r = self->f->pushInt(self, 4); 8552 ck_assert_ptr_ne(r, null); 8553 8554 // positive index 8555 toInject = allocSmallJson(); 8556 r = self->f->injectNFreeSmallJson(self, 1, toInject); 8557 ck_assert_ptr_ne(r, null); 8558 char *s = toStringO(r); 8559 ck_assert_str_eq(s, "[1,{},2,3,4]"); 8560 free(s); 8561 // negative index 8562 toInject = allocSmallJson(); 8563 r = self->f->injectNFreeSmallJson(self,-1, toInject); 8564 ck_assert_ptr_ne(r, null); 8565 s = toStringO(r); 8566 ck_assert_str_eq(s, "[1,{},2,3,4,{}]"); 8567 free(s); 8568 // index 0 8569 toInject = allocSmallJson(); 8570 toInject->f->setS(toInject, "key", "value"); 8571 r = self->f->injectNFreeSmallJson(self,0, toInject); 8572 ck_assert_ptr_ne(r, null); 8573 s = toStringO(r); 8574 ck_assert_str_eq(s, "[{\"key\":\"value\"},1,{},2,3,4,{}]"); 8575 free(s); 8576 // index outside 8577 toInject = allocSmallJson(); 8578 ck_assert_ptr_eq(self->f->injectNFreeSmallJson(self, 20, toInject), NULL); 8579 ck_assert_ptr_eq(self->f->injectNFreeSmallJson(self, -9, toInject), NULL); 8580 terminateO(toInject); 8581 // empty object 8582 emptyO(self); 8583 toInject = allocSmallJson(); 8584 freeO(toInject); 8585 ck_assert_ptr_ne(self->f->injectNFreeSmallJson(self, 0, toInject), NULL); 8586 s = toStringO(r); 8587 ck_assert_str_eq(s, "[{}]"); 8588 free(s); 8589 // empty list 8590 emptyO(self); 8591 toInject = allocSmallJson(); 8592 ck_assert_ptr_ne(self->f->injectNFreeSmallJson(self, 0, toInject), NULL); 8593 s = toStringO(r); 8594 ck_assert_str_eq(s, "[{}]"); 8595 free(s); 8596 emptyO(self); 8597 toInject = allocSmallJson(); 8598 ck_assert_ptr_ne(self->f->injectNFreeSmallJson(self, -1, toInject), NULL); 8599 s = toStringO(r); 8600 ck_assert_str_eq(s, "[{}]"); 8601 free(s); 8602 // null toInsert 8603 ck_assert_ptr_eq(self->f->injectNFreeSmallJson(self, 0, NULL), NULL); 8604 terminateO(self); 8605 8606 } 8607 8608 8609 void injectNFreeSmallStringSmallArrayT(void) { 8610 8611 smallArrayt* r; 8612 smallArrayt *self = allocG(rtSmallArrayt); 8613 smallStringt *toInject; 8614 8615 // add elements to self 8616 r = self->f->pushInt(self, 1); 8617 ck_assert_ptr_ne(r, null); 8618 r = self->f->pushInt(self, 2); 8619 ck_assert_ptr_ne(r, null); 8620 r = self->f->pushInt(self, 3); 8621 ck_assert_ptr_ne(r, null); 8622 r = self->f->pushInt(self, 4); 8623 ck_assert_ptr_ne(r, null); 8624 8625 // positive index 8626 toInject = allocSmallString("1"); 8627 r = self->f->injectNFreeSmallString(self, 1, toInject); 8628 ck_assert_ptr_ne(r, null); 8629 char *s = toStringO(r); 8630 ck_assert_str_eq(s, "[1,\"1\",2,3,4]"); 8631 free(s); 8632 // negative index 8633 toInject = allocSmallString("2"); 8634 r = self->f->injectNFreeSmallString(self,-1, toInject); 8635 ck_assert_ptr_ne(r, null); 8636 s = toStringO(r); 8637 ck_assert_str_eq(s, "[1,\"1\",2,3,4,\"2\"]"); 8638 free(s); 8639 // index 0 8640 toInject = allocSmallString("3"); 8641 r = self->f->injectNFreeSmallString(self,0, toInject); 8642 ck_assert_ptr_ne(r, null); 8643 s = toStringO(r); 8644 ck_assert_str_eq(s, "[\"3\",1,\"1\",2,3,4,\"2\"]"); 8645 free(s); 8646 // index outside 8647 toInject = allocSmallString("1"); 8648 ck_assert_ptr_eq(self->f->injectNFreeSmallString(self, 20, toInject), NULL); 8649 ck_assert_ptr_eq(self->f->injectNFreeSmallString(self, -9, toInject), NULL); 8650 terminateO(toInject); 8651 // empty object 8652 emptyO(self); 8653 toInject = allocSmallString("1"); 8654 freeO(toInject); 8655 ck_assert_ptr_ne(self->f->injectNFreeSmallString(self, 0, toInject), NULL); 8656 s = toStringO(r); 8657 ck_assert_str_eq(s, "[\"\"]"); 8658 free(s); 8659 // empty list 8660 emptyO(self); 8661 toInject = allocSmallString("1"); 8662 ck_assert_ptr_ne(self->f->injectNFreeSmallString(self, 0, toInject), NULL); 8663 s = toStringO(r); 8664 ck_assert_str_eq(s, "[\"1\"]"); 8665 free(s); 8666 emptyO(self); 8667 toInject = allocSmallString("1"); 8668 ck_assert_ptr_ne(self->f->injectNFreeSmallString(self, -1, toInject), NULL); 8669 s = toStringO(r); 8670 ck_assert_str_eq(s, "[\"1\"]"); 8671 free(s); 8672 // null toInsert 8673 ck_assert_ptr_eq(self->f->injectNFreeSmallString(self, 0, NULL), NULL); 8674 terminateO(self); 8675 8676 } 8677 8678 8679 void injectNFreeSmallContainerSmallArrayT(void) { 8680 8681 smallArrayt* r; 8682 smallArrayt *self = allocG(rtSmallArrayt); 8683 smallContainert *toInject; 8684 8685 // add elements to self 8686 r = self->f->pushInt(self, 1); 8687 ck_assert_ptr_ne(r, null); 8688 r = self->f->pushInt(self, 2); 8689 ck_assert_ptr_ne(r, null); 8690 r = self->f->pushInt(self, 3); 8691 ck_assert_ptr_ne(r, null); 8692 r = self->f->pushInt(self, 4); 8693 ck_assert_ptr_ne(r, null); 8694 8695 // positive index 8696 toInject = allocSmallContainer(NULL); 8697 r = self->f->injectNFreeSmallContainer(self, 1, toInject); 8698 ck_assert_ptr_ne(r, null); 8699 char *s = toStringO(r); 8700 ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4]"); 8701 free(s); 8702 // negative index 8703 toInject = allocSmallContainer(NULL); 8704 r = self->f->injectNFreeSmallContainer(self,-1, toInject); 8705 ck_assert_ptr_ne(r, null); 8706 s = toStringO(r); 8707 ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4,\"<data container>\"]"); 8708 free(s); 8709 // index 0 8710 toInject = allocSmallContainer(NULL); 8711 r = self->f->injectNFreeSmallContainer(self,0, toInject); 8712 ck_assert_ptr_ne(r, null); 8713 s = toStringO(r); 8714 ck_assert_str_eq(s, "[\"<data container>\",1,\"<data container>\",2,3,4,\"<data container>\"]"); 8715 free(s); 8716 // index outside 8717 toInject = allocSmallContainer(NULL); 8718 ck_assert_ptr_eq(self->f->injectNFreeSmallContainer(self, 20, toInject), NULL); 8719 ck_assert_ptr_eq(self->f->injectNFreeSmallContainer(self, -9, toInject), NULL); 8720 terminateO(toInject); 8721 // empty object 8722 emptyO(self); 8723 toInject = allocSmallContainer(NULL); 8724 freeO(toInject); 8725 ck_assert_ptr_ne(self->f->injectNFreeSmallContainer(self, 0, toInject), NULL); 8726 s = toStringO(r); 8727 ck_assert_str_eq(s, "[\"<data container>\"]"); 8728 free(s); 8729 // empty list 8730 emptyO(self); 8731 toInject = allocSmallContainer(NULL); 8732 ck_assert_ptr_ne(self->f->injectNFreeSmallContainer(self, 0, toInject), NULL); 8733 s = toStringO(r); 8734 ck_assert_str_eq(s, "[\"<data container>\"]"); 8735 free(s); 8736 emptyO(self); 8737 toInject = allocSmallContainer(NULL); 8738 ck_assert_ptr_ne(self->f->injectNFreeSmallContainer(self, -1, toInject), NULL); 8739 s = toStringO(r); 8740 ck_assert_str_eq(s, "[\"<data container>\"]"); 8741 free(s); 8742 // null toInsert 8743 ck_assert_ptr_eq(self->f->injectNFreeSmallContainer(self, 0, NULL), NULL); 8744 terminateO(self); 8745 8746 } 8747 8748 8749 void removeSmallArrayT(void) { 8750 8751 smallArrayt* r; 8752 smallArrayt *self = allocG(rtSmallArrayt); 8753 8754 // add elements to self 8755 r = self->f->pushInt(self, 1); 8756 ck_assert_ptr_ne(r, null); 8757 r = self->f->pushInt(self, 2); 8758 ck_assert_ptr_ne(r, null); 8759 r = self->f->pushInt(self, 3); 8760 ck_assert_ptr_ne(r, null); 8761 r = self->f->pushInt(self, 4); 8762 ck_assert_ptr_ne(r, null); 8763 8764 smallIntt *e[4]; 8765 arange(i,e) { 8766 e[i] = self->f->getAtSmallInt(self, i); 8767 } 8768 8769 // negative index 8770 r = removeO(self, 1, -1); 8771 ck_assert_ptr_ne(r, null); 8772 char *s = toStringO(self); 8773 ck_assert_str_eq(s, "[1,4]"); 8774 free(s); 8775 // start outside 8776 ck_assert_ptr_eq(removeO(self, 20, -4), NULL); 8777 // end outside 8778 r = removeO(self, 0, 40); 8779 ck_assert_ptr_ne(r, null); 8780 s = toStringO(self); 8781 ck_assert_str_eq(s, "[]"); 8782 free(s); 8783 arange(i,e) { 8784 terminateO(e[i]); 8785 } 8786 // end negative and outside 8787 // remove elements with NULL (set by removeO) 8788 trimO(self); 8789 // add elements to self 8790 r = self->f->pushInt(self, 1); 8791 ck_assert_ptr_ne(r, null); 8792 r = self->f->pushInt(self, 2); 8793 ck_assert_ptr_ne(r, null); 8794 r = self->f->pushInt(self, 3); 8795 ck_assert_ptr_ne(r, null); 8796 r = self->f->pushInt(self, 4); 8797 ck_assert_ptr_ne(r, null); 8798 arange(i,e) { 8799 e[i] = self->f->getAtSmallInt(self, i); 8800 } 8801 ck_assert_ptr_eq(removeO(self, 2, -40), NULL); 8802 s = toStringO(self); 8803 ck_assert_str_eq(s, "[1,2,3,4]"); 8804 free(s); 8805 // end before start 8806 ck_assert_ptr_eq(removeO(self, 3, 2), NULL); 8807 s = toStringO(self); 8808 ck_assert_str_eq(s, "[1,2,3,4]"); 8809 free(s); 8810 // negative start last element 8811 r = removeO(self, -1, 0); 8812 ck_assert_ptr_ne(r, null); 8813 s = toStringO(self); 8814 ck_assert_str_eq(s, "[1,2,3]"); 8815 free(s); 8816 // negative start and outside 8817 r = removeO(self, -10, 1); 8818 ck_assert_ptr_ne(r, null); 8819 s = toStringO(self); 8820 ck_assert_str_eq(s, "[2,3]"); 8821 free(s); 8822 // start = end 8823 r = removeO(self, 1, 1); 8824 ck_assert_ptr_ne(r, null); 8825 s = toStringO(self); 8826 ck_assert_str_eq(s, "[2,3]"); 8827 free(s); 8828 // remove all 8829 r = removeO(self, 0, 0); 8830 ck_assert_ptr_ne(r, null); 8831 s = toStringO(self); 8832 ck_assert_str_eq(s, "[]"); 8833 free(s); 8834 arange(i,e) { 8835 terminateO(e[i]); 8836 } 8837 // empty list 8838 emptyO(self); 8839 ck_assert_ptr_eq(removeO(self, 0, 0), NULL); 8840 ck_assert_ptr_eq(removeO(self, -1, 0), NULL); 8841 terminateO(self); 8842 8843 } 8844 8845 8846 void removeElemSmallArrayT(void) { 8847 8848 smallArrayt* r; 8849 smallArrayt *self = allocG(rtSmallArrayt); 8850 8851 // add elements to self 8852 r = self->f->pushInt(self, 1); 8853 ck_assert_ptr_ne(r, null); 8854 r = self->f->pushInt(self, 2); 8855 ck_assert_ptr_ne(r, null); 8856 r = self->f->pushInt(self, 3); 8857 ck_assert_ptr_ne(r, null); 8858 r = self->f->pushInt(self, 4); 8859 ck_assert_ptr_ne(r, null); 8860 8861 smallIntt *e[2]; 8862 e[0] = self->f->getAtSmallInt(self, 1); 8863 e[1] = self->f->getAtSmallInt(self, 3); 8864 8865 // positive index 8866 r = removeElemO(self,1); 8867 ck_assert_ptr_ne(r, null); 8868 char *s = toStringO(self); 8869 ck_assert_str_eq(s, "[1,3,4]"); 8870 free(s); 8871 // negative index 8872 r = removeElemO(self,-1); 8873 ck_assert_ptr_ne(r, null); 8874 s = toStringO(self); 8875 ck_assert_str_eq(s, "[1,3]"); 8876 free(s); 8877 terminateO(e[0]); 8878 terminateO(e[1]); 8879 // index outside 8880 ck_assert_ptr_eq(removeElemO(self, 20), NULL); 8881 ck_assert_ptr_eq(removeElemO(self, -5), NULL); 8882 // empty list 8883 emptyO(self); 8884 ck_assert_ptr_eq(removeElemO(self, 0), NULL); 8885 ck_assert_ptr_eq(removeElemO(self, -1), NULL); 8886 terminateO(self); 8887 8888 } 8889 8890 8891 void sortSmallArrayT(void) { 8892 8893 smallArrayt* r; 8894 smallArrayt *self = allocG(rtSmallArrayt); 8895 8896 // sort undefined 8897 self->f->pushInt(self, 0); 8898 self->f->pushUndefined(self); 8899 self->f->pushUndefined(self); 8900 self->f->pushUndefined(self); 8901 self->f->pushUndefined(self); 8902 r = sortO(self); 8903 ck_assert_ptr_ne(r, null); 8904 char *s = toStringO(r); 8905 ck_assert_str_eq(s, "[null,null,null,null,0]"); 8906 free(s); 8907 // sort bool 8908 emptyO(self); 8909 self->f->pushBool(self, false); 8910 self->f->pushBool(self, true); 8911 r = sortO(self); 8912 ck_assert_ptr_ne(r, null); 8913 s = toStringO(r); 8914 ck_assert_str_eq(s, "[false,true]"); 8915 free(s); 8916 // sort container 8917 emptyO(self); 8918 pushVoidSmallArrayG(self, &r); 8919 pushVoidSmallArrayG(self, &r); 8920 r = sortO(self); 8921 ck_assert_ptr_ne(r, null); 8922 s = toStringO(r); 8923 ck_assert_str_eq(s, "[\"<data container>\",\"<data container>\"]"); 8924 free(s); 8925 // sort dict 8926 emptyO(self); 8927 smallDictt *d[4]; 8928 arange(i,d) d[i] = allocSmallDict(); 8929 d[0]->f->setInt(d[0], "a", 1); 8930 d[1]->f->setInt(d[1], "a", 0); 8931 d[3]->f->setInt(d[3], "a", 0); 8932 d[3]->f->setInt(d[3], "b", 0); 8933 arange(i,d) self->f->pushNFreeDict(self, d[i]); 8934 r = sortO(self); 8935 ck_assert_ptr_ne(r, null); 8936 s = toStringO(r); 8937 ck_assert_str_eq(s, "[{},{\"a\":0},{\"a\":1},{\"a\":0,\"b\":0}]"); 8938 free(s); 8939 // sort double 8940 emptyO(self); 8941 self->f->pushDouble(self, 0); 8942 self->f->pushDouble(self, 0); 8943 self->f->pushDouble(self, 1); 8944 self->f->pushDouble(self, -1); 8945 r = sortO(self); 8946 ck_assert_ptr_ne(r, null); 8947 s = toStringO(r); 8948 ck_assert_str_eq(s, "[-1.000000e+00,0.000000e+00,0.000000e+00,1.000000e+00]"); 8949 free(s); 8950 // sort Int 8951 emptyO(self); 8952 self->f->pushInt(self, 0); 8953 self->f->pushInt(self, 0); 8954 self->f->pushInt(self, 1); 8955 self->f->pushInt(self, -1); 8956 r = sortO(self); 8957 ck_assert_ptr_ne(r, null); 8958 s = toStringO(r); 8959 ck_assert_str_eq(s, "[-1,0,0,1]"); 8960 free(s); 8961 // sort strings 8962 emptyO(self); 8963 self->f->pushS(self, "bb"); 8964 self->f->pushS(self, "a"); 8965 r = sortO(self); 8966 ck_assert_ptr_ne(r, null); 8967 s = toStringO(r); 8968 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 8969 free(s); 8970 // sort Array 8971 emptyO(self); 8972 smallArrayt *a[4]; 8973 arange(i,a) a[i] = allocSmallArray(); 8974 a[0]->f->pushInt(a[0], 1); 8975 a[1]->f->pushInt(a[1], 0); 8976 a[3]->f->pushInt(a[3], 0); 8977 a[3]->f->pushInt(a[3], 0); 8978 arange(i,a) self->f->pushNFreeArray(self, a[i]); 8979 r = sortO(self); 8980 ck_assert_ptr_ne(r, null); 8981 s = toStringO(r); 8982 ck_assert_str_eq(s, "[[],[0],[1],[0,0]]"); 8983 free(s); 8984 // sort bytes 8985 emptyO(self); 8986 smallBytest *B[4]; 8987 range(i,3) B[i] = allocSmallBytes("12345678", i); 8988 B[3] = allocSmallBytes("0", 1); 8989 arange(i,B) self->f->pushNFreeSmallBytes(self, B[i]); 8990 r = sortO(self); 8991 ck_assert_ptr_ne(r, null); 8992 s = toStringO(r); 8993 ck_assert_str_eq(s, "[[],[0x30],[0x31],[0x31,0x32]]"); 8994 free(s); 8995 // TODO add element and remove some elements 8996 emptyO(self); 8997 self->f->pushInt(self, 0); 8998 self->f->pushInt(self, 0); 8999 self->f->pushInt(self, 1); 9000 self->f->pushInt(self, -1); 9001 smallIntt *i1 = self->f->getAtSmallInt(self, 1); 9002 smallIntt *i2 = self->f->getAtSmallInt(self, 2); 9003 removeO(self, 1, 3); 9004 terminateO(i1); 9005 terminateO(i2); 9006 r = sortO(self); 9007 ck_assert_ptr_ne(r, null); 9008 s = toStringO(r); 9009 ck_assert_str_eq(s, "[-1,0]"); 9010 free(s); 9011 // length 0 9012 emptyO(self); 9013 r = sortO(self); 9014 ck_assert_ptr_eq(r, null); 9015 terminateO(self); 9016 9017 } 9018 9019 9020 void icSortSmallArrayT(void) { 9021 9022 smallArrayt* r; 9023 smallArrayt *self = allocG(rtSmallArrayt); 9024 9025 // sort undefined 9026 self->f->pushInt(self, 0); 9027 self->f->pushUndefined(self); 9028 self->f->pushUndefined(self); 9029 self->f->pushUndefined(self); 9030 self->f->pushUndefined(self); 9031 r = icSortO(self); 9032 ck_assert_ptr_ne(r, null); 9033 char *s = toStringO(r); 9034 ck_assert_str_eq(s, "[null,null,null,null,0]"); 9035 free(s); 9036 // sort bool 9037 emptyO(self); 9038 self->f->pushBool(self, false); 9039 self->f->pushBool(self, true); 9040 r = icSortO(self); 9041 ck_assert_ptr_ne(r, null); 9042 s = toStringO(r); 9043 ck_assert_str_eq(s, "[false,true]"); 9044 free(s); 9045 // sort container 9046 emptyO(self); 9047 pushVoidSmallArrayG(self, &r); 9048 pushVoidSmallArrayG(self, &r); 9049 r = icSortO(self); 9050 ck_assert_ptr_ne(r, null); 9051 s = toStringO(r); 9052 ck_assert_str_eq(s, "[\"<data container>\",\"<data container>\"]"); 9053 free(s); 9054 // sort dict 9055 emptyO(self); 9056 smallDictt *d[4]; 9057 arange(i,d) d[i] = allocSmallDict(); 9058 d[0]->f->setInt(d[0], "a", 1); 9059 d[1]->f->setInt(d[1], "A", 0); 9060 d[3]->f->setInt(d[3], "a", 0); 9061 d[3]->f->setInt(d[3], "b", 0); 9062 arange(i,d) self->f->pushNFreeDict(self, d[i]); 9063 r = icSortO(self); 9064 ck_assert_ptr_ne(r, null); 9065 s = toStringO(r); 9066 ck_assert_str_eq(s, "[{},{\"A\":0},{\"a\":1},{\"a\":0,\"b\":0}]"); 9067 free(s); 9068 // sort double 9069 emptyO(self); 9070 self->f->pushDouble(self, 0); 9071 self->f->pushDouble(self, 0); 9072 self->f->pushDouble(self, 1); 9073 self->f->pushDouble(self, -1); 9074 r = icSortO(self); 9075 ck_assert_ptr_ne(r, null); 9076 s = toStringO(r); 9077 ck_assert_str_eq(s, "[-1.000000e+00,0.000000e+00,0.000000e+00,1.000000e+00]"); 9078 free(s); 9079 // sort Int 9080 emptyO(self); 9081 self->f->pushInt(self, 0); 9082 self->f->pushInt(self, 0); 9083 self->f->pushInt(self, 1); 9084 self->f->pushInt(self, -1); 9085 r = icSortO(self); 9086 ck_assert_ptr_ne(r, null); 9087 s = toStringO(r); 9088 ck_assert_str_eq(s, "[-1,0,0,1]"); 9089 free(s); 9090 // sort strings 9091 emptyO(self); 9092 self->f->pushS(self, "bb"); 9093 self->f->pushS(self, "B"); 9094 r = icSortO(self); 9095 ck_assert_ptr_ne(r, null); 9096 s = toStringO(r); 9097 ck_assert_str_eq(s, "[\"B\",\"bb\"]"); 9098 free(s); 9099 // sort Array 9100 emptyO(self); 9101 smallArrayt *a[4]; 9102 arange(i,a) a[i] = allocSmallArray(); 9103 a[0]->f->pushInt(a[0], 1); 9104 a[1]->f->pushInt(a[1], 0); 9105 a[3]->f->pushInt(a[3], 0); 9106 a[3]->f->pushInt(a[3], 0); 9107 arange(i,a) self->f->pushNFreeArray(self, a[i]); 9108 r = icSortO(self); 9109 ck_assert_ptr_ne(r, null); 9110 s = toStringO(r); 9111 ck_assert_str_eq(s, "[[],[0],[1],[0,0]]"); 9112 free(s); 9113 // sort bytes 9114 emptyO(self); 9115 smallBytest *B[4]; 9116 range(i,3) B[i] = allocSmallBytes("12345678", i); 9117 B[3] = allocSmallBytes("0", 1); 9118 arange(i,B) self->f->pushNFreeSmallBytes(self, B[i]); 9119 r = icSortO(self); 9120 ck_assert_ptr_ne(r, null); 9121 s = toStringO(r); 9122 ck_assert_str_eq(s, "[[],[0x30],[0x31],[0x31,0x32]]"); 9123 free(s); 9124 // TODO add element and remove some elements 9125 emptyO(self); 9126 self->f->pushInt(self, 0); 9127 self->f->pushInt(self, 0); 9128 self->f->pushInt(self, 1); 9129 self->f->pushInt(self, -1); 9130 smallIntt *i1 = self->f->getAtSmallInt(self, 1); 9131 smallIntt *i2 = self->f->getAtSmallInt(self, 2); 9132 removeO(self, 1, 3); 9133 terminateO(i1); 9134 terminateO(i2); 9135 r = icSortO(self); 9136 ck_assert_ptr_ne(r, null); 9137 s = toStringO(r); 9138 ck_assert_str_eq(s, "[-1,0]"); 9139 free(s); 9140 // length 0 9141 emptyO(self); 9142 r = icSortO(self); 9143 ck_assert_ptr_eq(r, null); 9144 terminateO(self); 9145 9146 } 9147 9148 int sortFOCmp(const void *A, const void *B) { 9149 cast(smallDictt*, a, A); 9150 cast(smallDictt*, b, B); 9151 9152 if (lenO(a) < lenO(b)) 9153 return -1; 9154 else if (lenO(a) == lenO(b)) { 9155 var As = toStringO(a); 9156 var Bs = toStringO(b); 9157 int r = strcmp(As,Bs); 9158 freeManyS(As,Bs); 9159 return r; 9160 } 9161 else 9162 return 1; 9163 } 9164 9165 void sortFSmallArrayT(void) { 9166 9167 smallArrayt* r; 9168 smallArrayt *self = allocG(rtSmallArrayt); 9169 9170 // sort dict 9171 smallDictt *d[4]; 9172 arange(i,d) d[i] = allocSmallDict(); 9173 d[0]->f->setInt(d[0], "a", 1); 9174 d[1]->f->setInt(d[1], "a", 0); 9175 d[3]->f->setInt(d[3], "a", 0); 9176 d[3]->f->setInt(d[3], "b", 0); 9177 arange(i,d) self->f->pushNFreeDict(self, d[i]); 9178 r = sortFO(self, sortFOCmp); 9179 ck_assert_ptr_ne(r, null); 9180 char *s = toStringO(r); 9181 ck_assert_str_eq(s, "[{},{\"a\":0},{\"a\":1},{\"a\":0,\"b\":0}]"); 9182 free(s); 9183 // no compare function 9184 r = sortFO(self, NULL); 9185 ck_assert_ptr_eq(r, null); 9186 // empty array 9187 emptyO(self); 9188 r = sortFO(self, sortFOCmp); 9189 ck_assert_ptr_eq(r, null); 9190 terminateO(self); 9191 9192 } 9193 9194 9195 void equalSmallArrayT(void) { 9196 9197 bool r; 9198 smallArrayt *self = allocG(rtSmallArrayt); 9199 smallArrayt *array = allocG(rtSmallArrayt); 9200 9201 // empty arrays 9202 r = equalO(self, array); 9203 ck_assert(r); 9204 // empty self, non empty array 9205 array->f->pushInt(array, 1); 9206 r = equalO(self, array); 9207 ck_assert(!r); 9208 // non empty self, empty array 9209 emptyO(array); 9210 self->f->pushInt(self, 1); 9211 r = equalO(self, array); 9212 ck_assert(!r); 9213 // different lengths 9214 array->f->pushInt(array, 1); 9215 self->f->pushInt(self, 1); 9216 r = equalO(self, array); 9217 ck_assert(!r); 9218 // equal arrays 9219 array->f->pushInt(array, 1); 9220 r = equalO(self, array); 9221 ck_assert(r); 9222 // different int value 9223 array->f->setAtInt(array, 1, 2); 9224 r = equalO(self, array); 9225 ck_assert(!r); 9226 // array same length with a null element in self 9227 smallIntt *i = self->f->getAtSmallInt(self, 1); 9228 removeElemO(self, 1); 9229 terminateO(i); 9230 r = equalO(self, array); 9231 ck_assert(!r); 9232 // array same length with a null element in both arrays 9233 i = array->f->getAtSmallInt(array, 1); 9234 removeElemO(array, 1); 9235 terminateO(i); 9236 r = equalO(self, array); 9237 ck_assert(r); 9238 // elements of different types 9239 self->f->setAtBool(self, 1, true); 9240 array->f->setAtInt(array, 1, 1); 9241 r = equalO(self, array); 9242 ck_assert(!r); 9243 // compare bool 9244 array->f->setAtBool(array, 1, true); 9245 r = equalO(self, array); 9246 ck_assert(r); 9247 array->f->setAtBool(array, 1, false); 9248 r = equalO(self, array); 9249 ck_assert(!r); 9250 // compare dict 9251 createSmallDict(d1); 9252 createSmallDict(d2); 9253 self->f->setAtDict(self, 1, &d1); 9254 array->f->setAtDict(array, 1, &d2); 9255 r = equalO(self, array); 9256 ck_assert(r); 9257 // reuse dict container, the data is in self already 9258 resetO(&d1); 9259 (&d1)->f->setInt(&d1, "a", 1); 9260 self->f->setAtDict(self, 1, &d1); 9261 r = equalO(self, array); 9262 ck_assert(!r); 9263 // compare double 9264 self->f->setAtDouble(self, 1, 0); 9265 array->f->setAtDouble(array, 1, 0); 9266 r = equalO(self, array); 9267 ck_assert(r); 9268 array->f->setAtDouble(array, 1, 10.5); 9269 r = equalO(self, array); 9270 ck_assert(!r); 9271 // compare string 9272 self->f->setAtS(self, 1, ""); 9273 array->f->setAtS(array, 1, ""); 9274 r = equalO(self, array); 9275 ck_assert(r); 9276 array->f->setAtS(array, 1, "NO"); 9277 r = equalO(self, array); 9278 ck_assert(!r); 9279 // compare array elements 9280 createSmallArray(a1); 9281 createSmallArray(a2); 9282 self->f->setAtArray(self, 1, &a1); 9283 array->f->setAtArray(array, 1, &a2); 9284 r = equalO(self, array); 9285 ck_assert(r); 9286 // reuse Array container, the data is in self already 9287 resetO(&a1); 9288 (&a1)->f->pushInt(&a1, 1); 9289 self->f->setAtArray(self, 1, &a1); 9290 r = equalO(self, array); 9291 ck_assert(!r); 9292 // compare bytes 9293 createSmallBytes(b1); 9294 createSmallBytes(b2); 9295 self->f->setAtSmallBytes(self, 1, &b1); 9296 array->f->setAtSmallBytes(array, 1, &b2); 9297 r = equalO(self, array); 9298 ck_assert(r); 9299 // reuse SmallBytes container, the data is in self already 9300 b1.B = null; 9301 pushBufferO(&b1, &self, 2); 9302 self->f->setAtSmallBytes(self, 1, &b1); 9303 r = equalO(self, array); 9304 ck_assert(!r); 9305 // compare data in both smallBytes elements 9306 b2.B = null; 9307 pushBufferO(&b2, (char*)(&self) + 4, 2); 9308 array->f->setAtSmallBytes(array, 1, &b2); 9309 r = equalO(self, array); 9310 ck_assert(!r); 9311 // non smallArray object 9312 terminateO(array); 9313 array = (smallArrayt*) allocSmallInt(2); 9314 r = equalO(self, array); 9315 ck_assert(!r); 9316 // NULL array 9317 r = equalO(self, NULL); 9318 ck_assert(!r); 9319 terminateO(self); 9320 terminateO(array); 9321 9322 } 9323 9324 9325 void equalSmallArraySmallJsonT(void) { 9326 9327 bool r; 9328 smallArrayt *self = allocG(rtSmallArrayt); 9329 smallJsont *array = allocG(rtSmallJsont); 9330 9331 // NULL array 9332 r = self->f->equalSmallJson(self, NULL); 9333 ck_assert(!r); 9334 // compare 9335 r = self->f->equalSmallJson(self, array); 9336 // the smallJson is empty, so the result is false 9337 ck_assert(!r); 9338 // non smallJson object 9339 terminateO(array); 9340 array = (smallJsont*) allocSmallInt(2); 9341 r = self->f->equalSmallJson(self, array); 9342 ck_assert(!r); 9343 terminateO(self); 9344 terminateO(array); 9345 9346 } 9347 9348 9349 void equalSmallArrayArrayT(void) { 9350 9351 bool r; 9352 smallArrayt* self = allocG(rtSmallArrayt); 9353 char ** p2 = NULL; 9354 9355 // empty arrays 9356 r = self->f->equalArray(self, NULL); 9357 ck_assert(r); 9358 // empty self, non empty array 9359 p2 = listCreateS("a"); 9360 r = self->f->equalArray(self, p2); 9361 ck_assert(!r); 9362 // non empty self, empty array 9363 self->f->pushInt(self, 1); 9364 listFreeS(p2); 9365 listEmptyS(p2); 9366 r = self->f->equalArray(self, p2); 9367 ck_assert(!r); 9368 // different lengths 9369 listPushS(&p2, "a"); 9370 self->f->pushInt(self, 2); 9371 r = self->f->equalArray(self, p2); 9372 ck_assert(!r); 9373 // equal arrays 9374 emptyO(self); 9375 self->f->pushS(self, "a"); 9376 r = self->f->equalArray(self, p2); 9377 ck_assert(r); 9378 // not string type in self 9379 self->f->setAtInt(self, 0, 0); 9380 r = self->f->equalArray(self, p2); 9381 ck_assert(!r); 9382 // array same length with a null element in self 9383 smallIntt *i = self->f->getAtSmallInt(self, 0); 9384 terminateO(i); 9385 removeElemO(self, 0); 9386 r = self->f->equalArray(self, p2); 9387 ck_assert(!r); 9388 // different strings 9389 self->f->setAtS(self, 0, "bb"); 9390 r = self->f->equalArray(self, p2); 9391 ck_assert(!r); 9392 terminateO(self); 9393 listFreeS(p2); 9394 9395 9396 } 9397 9398 9399 void equalSmallArrayBaseT(void) { 9400 9401 bool r; 9402 smallArrayt* self = allocG(rtSmallArrayt); 9403 baset* p2 = (baset*) allocG(1); 9404 9405 // empty self array 9406 r = self->f->equalBase(self, p2); 9407 ck_assert(!r); 9408 // NULL 9409 r = self->f->equalBase(self, NULL); 9410 ck_assert(!r); 9411 // not array type 9412 self->f->pushInt(self, 1); 9413 r = self->f->equalBase(self, p2); 9414 ck_assert(!r); 9415 // equal 9416 terminateO(p2); 9417 p2 = (baset*) allocG(rtSmallArrayt); 9418 r = self->f->equalBase(self, p2); 9419 ck_assert(!r); 9420 terminateO(self); 9421 terminateO(p2); 9422 9423 } 9424 9425 9426 void icEqualSmallArrayT(void) { 9427 9428 bool r; 9429 smallArrayt *self = allocG(rtSmallArrayt); 9430 smallArrayt *array = allocG(rtSmallArrayt); 9431 9432 // empty arrays 9433 r = icEqualO(self, array); 9434 ck_assert(r); 9435 // empty self, non empty array 9436 array->f->pushInt(array, 1); 9437 r = icEqualO(self, array); 9438 ck_assert(!r); 9439 // non empty self, empty array 9440 emptyO(array); 9441 self->f->pushInt(self, 1); 9442 r = icEqualO(self, array); 9443 ck_assert(!r); 9444 // different lengths 9445 array->f->pushInt(array, 1); 9446 self->f->pushInt(self, 1); 9447 r = icEqualO(self, array); 9448 ck_assert(!r); 9449 // equal arrays 9450 array->f->pushInt(array, 1); 9451 r = icEqualO(self, array); 9452 ck_assert(r); 9453 // different int value 9454 array->f->setAtInt(array, 1, 2); 9455 r = icEqualO(self, array); 9456 ck_assert(!r); 9457 // array same length with a null element in self 9458 smallIntt *i = self->f->getAtSmallInt(self, 1); 9459 removeElemO(self, 1); 9460 terminateO(i); 9461 r = icEqualO(self, array); 9462 ck_assert(!r); 9463 // array same length with a null element in both arrays 9464 i = array->f->getAtSmallInt(array, 1); 9465 removeElemO(array, 1); 9466 terminateO(i); 9467 r = icEqualO(self, array); 9468 ck_assert(r); 9469 // elements of different types 9470 self->f->setAtBool(self, 1, true); 9471 array->f->setAtInt(array, 1, 1); 9472 r = icEqualO(self, array); 9473 ck_assert(!r); 9474 // compare bool 9475 array->f->setAtBool(array, 1, true); 9476 r = icEqualO(self, array); 9477 ck_assert(r); 9478 array->f->setAtBool(array, 1, false); 9479 r = icEqualO(self, array); 9480 ck_assert(!r); 9481 // compare dict 9482 createSmallDict(d1); 9483 createSmallDict(d2); 9484 self->f->setAtDict(self, 1, &d1); 9485 array->f->setAtDict(array, 1, &d2); 9486 r = icEqualO(self, array); 9487 ck_assert(r); 9488 // reuse dict container, the data is in self already 9489 resetO(&d1); 9490 (&d1)->f->setInt(&d1, "a", 1); 9491 self->f->setAtDict(self, 1, &d1); 9492 r = icEqualO(self, array); 9493 ck_assert(!r); 9494 // compare double 9495 self->f->setAtDouble(self, 1, 0); 9496 array->f->setAtDouble(array, 1, 0); 9497 r = icEqualO(self, array); 9498 ck_assert(r); 9499 array->f->setAtDouble(array, 1, 10.5); 9500 r = icEqualO(self, array); 9501 ck_assert(!r); 9502 // compare string 9503 self->f->setAtS(self, 1, "a"); 9504 array->f->setAtS(array, 1, "A"); 9505 r = icEqualO(self, array); 9506 ck_assert(r); 9507 array->f->setAtS(array, 1, "NO"); 9508 r = icEqualO(self, array); 9509 ck_assert(!r); 9510 // compare array elements 9511 createSmallArray(a1); 9512 createSmallArray(a2); 9513 self->f->setAtArray(self, 1, &a1); 9514 array->f->setAtArray(array, 1, &a2); 9515 r = icEqualO(self, array); 9516 ck_assert(r); 9517 // reuse Array container, the data is in self already 9518 resetO(&a1); 9519 (&a1)->f->pushInt(&a1, 1); 9520 self->f->setAtArray(self, 1, &a1); 9521 r = icEqualO(self, array); 9522 ck_assert(!r); 9523 // compare bytes 9524 createSmallBytes(b1); 9525 createSmallBytes(b2); 9526 self->f->setAtSmallBytes(self, 1, &b1); 9527 array->f->setAtSmallBytes(array, 1, &b2); 9528 r = icEqualO(self, array); 9529 ck_assert(r); 9530 // reuse SmallBytes container, the data is in self already 9531 b1.B = null; 9532 pushBufferO(&b1, &self, 2); 9533 self->f->setAtSmallBytes(self, 1, &b1); 9534 r = icEqualO(self, array); 9535 ck_assert(!r); 9536 // compare data in both smallBytes elements 9537 b2.B = null; 9538 pushBufferO(&b2, &self + 4, 2); 9539 array->f->setAtSmallBytes(array, 1, &b2); 9540 r = icEqualO(self, array); 9541 ck_assert(!r); 9542 // non smallArray object 9543 terminateO(array); 9544 array = (smallArrayt*) allocSmallInt(2); 9545 r = icEqualO(self, array); 9546 ck_assert(!r); 9547 // NULL array 9548 r = icEqualO(self, NULL); 9549 ck_assert(!r); 9550 terminateO(self); 9551 terminateO(array); 9552 9553 } 9554 9555 9556 void icEqualSmallArraySmallJsonT(void) { 9557 9558 bool r; 9559 smallArrayt *self = allocG(rtSmallArrayt); 9560 smallJsont *array = allocG(rtSmallJsont); 9561 9562 // NULL array 9563 r = self->f->icEqualSmallJson(self, NULL); 9564 ck_assert(!r); 9565 // json is not array 9566 r = self->f->icEqualSmallJson(self, array); 9567 ck_assert(!r); 9568 // compare 9569 self->f->pushS(self, "A"); 9570 array->f->pushS(array, "a"); 9571 r = self->f->icEqualSmallJson(self, array); 9572 ck_assert(r); 9573 // non smallJson object 9574 terminateO(array); 9575 array = (smallJsont*) allocSmallInt(2); 9576 r = self->f->icEqualSmallJson(self, array); 9577 ck_assert(!r); 9578 terminateO(self); 9579 terminateO(array); 9580 9581 } 9582 9583 9584 void icEqualSmallArrayArrayT(void) { 9585 9586 bool r; 9587 smallArrayt* self = allocG(rtSmallArrayt); 9588 char ** p2 = NULL; 9589 9590 // empty arrays 9591 r = self->f->icEqualArray(self, NULL); 9592 ck_assert(r); 9593 // empty self, non empty array 9594 p2 = listCreateS("a"); 9595 r = self->f->icEqualArray(self, p2); 9596 ck_assert(!r); 9597 // non empty self, empty array 9598 self->f->pushInt(self, 1); 9599 listFreeS(p2); 9600 listEmptyS(p2); 9601 r = self->f->icEqualArray(self, p2); 9602 ck_assert(!r); 9603 // different lengths 9604 listPushS(&p2, "a"); 9605 self->f->pushInt(self, 2); 9606 r = self->f->icEqualArray(self, p2); 9607 ck_assert(!r); 9608 // equal arrays 9609 emptyO(self); 9610 self->f->pushS(self, "A"); 9611 r = self->f->icEqualArray(self, p2); 9612 ck_assert(r); 9613 // not string type in self 9614 self->f->setAtInt(self, 0, 0); 9615 r = self->f->icEqualArray(self, p2); 9616 ck_assert(!r); 9617 // array same length with a null element in self 9618 smallIntt *i = self->f->getAtSmallInt(self, 0); 9619 terminateO(i); 9620 removeElemO(self, 0); 9621 r = self->f->icEqualArray(self, p2); 9622 ck_assert(!r); 9623 // different strings 9624 self->f->setAtS(self, 0, "bb"); 9625 r = self->f->icEqualArray(self, p2); 9626 ck_assert(!r); 9627 terminateO(self); 9628 listFreeS(p2); 9629 9630 } 9631 9632 9633 void icEqualSmallArrayBaseT(void) { 9634 9635 bool r; 9636 smallArrayt* self = allocG(rtSmallArrayt); 9637 baset* p2 = (baset*) allocG(1); 9638 9639 // empty self array 9640 r = self->f->icEqualBase(self, p2); 9641 ck_assert(!r); 9642 // NULL 9643 r = self->f->icEqualBase(self, NULL); 9644 ck_assert(!r); 9645 // not array type 9646 self->f->pushInt(self, 1); 9647 r = self->f->icEqualBase(self, p2); 9648 ck_assert(!r); 9649 // equal 9650 terminateO(p2); 9651 self->f->setAtS(self, 0, "a"); 9652 smallArrayt *a = allocG(rtSmallArrayt); 9653 a->f->pushS(a, "A"); 9654 p2 = (baset*) a; 9655 r = self->f->icEqualBase(self, p2); 9656 ck_assert(r); 9657 terminateO(self); 9658 terminateO(p2); 9659 9660 } 9661 9662 9663 void getAtUndefinedSmallArrayT(void) { 9664 9665 undefinedt* r; 9666 smallArrayt *self = allocG(rtSmallArrayt); 9667 smallArrayt *r2; 9668 9669 // add elements to self 9670 r2 = self->f->pushInt(self, 1); 9671 ck_assert_ptr_ne(r2, null); 9672 r2 = self->f->pushUndefined(self); 9673 ck_assert_ptr_ne(r2, null); 9674 r2 = self->f->pushInt(self, 3); 9675 ck_assert_ptr_ne(r2, null); 9676 r2 = self->f->pushUndefined(self); 9677 ck_assert_ptr_ne(r2, null); 9678 9679 // positive index 9680 r = self->f->getAtUndefined(self,1); 9681 ck_assert_ptr_ne(r, null); 9682 char *s = toStringO(r); 9683 finishO(r); 9684 ck_assert_str_eq(s, "null"); 9685 free(s); 9686 s = toStringO(self); 9687 ck_assert_str_eq(s, "[1,null,3,null]"); 9688 free(s); 9689 // negative index 9690 r = self->f->getAtUndefined(self,-1); 9691 ck_assert_ptr_ne(r, null); 9692 s = toStringO(r); 9693 finishO(r); 9694 ck_assert_str_eq(s, "null"); 9695 free(s); 9696 s = toStringO(self); 9697 ck_assert_str_eq(s, "[1,null,3,null]"); 9698 free(s); 9699 // wrong object type 9700 createSmallInt(I); 9701 setValG(&I, 11); 9702 r2 = self->f->pushSmallInt(self, &I); 9703 ck_assert_ptr_ne(r2, null); 9704 r = self->f->getAtUndefined(self,-1); 9705 ck_assert_ptr_eq(r, null); 9706 s = toStringO(self); 9707 ck_assert_str_eq(s, "[1,null,3,null,11]"); 9708 free(s); 9709 // index outside 9710 ck_assert_ptr_eq(self->f->getAtUndefined(self, 20), NULL); 9711 ck_assert_ptr_eq(self->f->getAtUndefined(self, -6), NULL); 9712 // empty list 9713 emptyO(self); 9714 ck_assert_ptr_eq(self->f->getAtUndefined(self, 0), NULL); 9715 ck_assert_ptr_eq(self->f->getAtUndefined(self, -1), NULL); 9716 // get empty slot in array 9717 r2 = self->f->pushUndefined(self); 9718 ck_assert_ptr_ne(r2, null); 9719 delElemO(self,0); 9720 ck_assert_ptr_eq(self->f->getAtUndefined(self, 0), NULL); 9721 terminateO(self); 9722 9723 } 9724 9725 9726 void getAtBoolSmallArrayT(void) { 9727 9728 bool r; 9729 smallArrayt *self = allocG(rtSmallArrayt); 9730 smallArrayt *r2; 9731 9732 // add elements to self 9733 r2 = self->f->pushInt(self, 1); 9734 ck_assert_ptr_ne(r2, null); 9735 r2 = self->f->pushBool(self, TRUE); 9736 ck_assert_ptr_ne(r2, null); 9737 r2 = self->f->pushInt(self, 3); 9738 ck_assert_ptr_ne(r2, null); 9739 r2 = self->f->pushBool(self, TRUE); 9740 ck_assert_ptr_ne(r2, null); 9741 9742 // positive index 9743 r = self->f->getAtBool(self,1); 9744 ck_assert(r); 9745 char *s = toStringO(self); 9746 ck_assert_str_eq(s, "[1,true,3,true]"); 9747 free(s); 9748 // negative index 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]"); 9753 free(s); 9754 // wrong object type 9755 createSmallInt(I); 9756 setValG(&I, 11); 9757 r2 = self->f->pushSmallInt(self, &I); 9758 r = self->f->getAtBool(self,-1); 9759 ck_assert(!r); 9760 s = toStringO(self); 9761 ck_assert_str_eq(s, "[1,true,3,true,11]"); 9762 free(s); 9763 // wrong object type of another user class 9764 // User classes are stored in containers transparently 9765 createAllocateSmallInt(ip); 9766 ip->type = "anothertype"; 9767 setValG(ip, 11); 9768 r2 = self->f->push(self, (baset*)ip); 9769 ck_assert_ptr_ne(r2, null); 9770 r = self->f->getAtBool(self,-1); 9771 ck_assert(!r); 9772 s = toStringO(self); 9773 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 9774 free(s); 9775 // index outside 9776 ck_assert(!self->f->getAtBool(self, 20)); 9777 ck_assert(!self->f->getAtBool(self, -7)); 9778 // empty list 9779 emptyO(self); 9780 ck_assert(!self->f->getAtBool(self, 0)); 9781 ck_assert(!self->f->getAtBool(self, -1)); 9782 terminateO(self); 9783 9784 } 9785 9786 9787 void getAtBoolPSmallArrayT(void) { 9788 9789 bool* r; 9790 smallArrayt *self = allocG(rtSmallArrayt); 9791 smallArrayt *r2; 9792 9793 // add elements to self 9794 r2 = self->f->pushInt(self, 1); 9795 ck_assert_ptr_ne(r2, null); 9796 r2 = self->f->pushBool(self, TRUE); 9797 ck_assert_ptr_ne(r2, null); 9798 r2 = self->f->pushInt(self, 3); 9799 ck_assert_ptr_ne(r2, null); 9800 r2 = self->f->pushBool(self, TRUE); 9801 ck_assert_ptr_ne(r2, null); 9802 9803 // positive index 9804 r = self->f->getAtBoolP(self,1); 9805 ck_assert_ptr_ne(r, null); 9806 ck_assert(*r); 9807 char *s = toStringO(self); 9808 ck_assert_str_eq(s, "[1,true,3,true]"); 9809 free(s); 9810 // negative index 9811 r = self->f->getAtBoolP(self,-1); 9812 ck_assert_ptr_ne(r, null); 9813 ck_assert(*r); 9814 s = toStringO(self); 9815 ck_assert_str_eq(s, "[1,true,3,true]"); 9816 free(s); 9817 // wrong object type 9818 createSmallInt(I); 9819 setValG(&I, 11); 9820 r2 = self->f->pushSmallInt(self, &I); 9821 r = self->f->getAtBoolP(self,-1); 9822 ck_assert_ptr_eq(r, null); 9823 s = toStringO(self); 9824 ck_assert_str_eq(s, "[1,true,3,true,11]"); 9825 free(s); 9826 // wrong object type of another user class 9827 // User classes are stored in containers transparently 9828 createAllocateSmallInt(ip); 9829 ip->type = "anothertype"; 9830 setValG(ip, 11); 9831 r2 = self->f->push(self, (baset*)ip); 9832 ck_assert_ptr_ne(r2, null); 9833 r = self->f->getAtBoolP(self,-1); 9834 ck_assert_ptr_eq(r, null); 9835 s = toStringO(self); 9836 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 9837 free(s); 9838 // index outside 9839 ck_assert(!self->f->getAtBoolP(self, 20)); 9840 ck_assert(!self->f->getAtBoolP(self, -7)); 9841 // empty list 9842 emptyO(self); 9843 ck_assert(!self->f->getAtBoolP(self, 0)); 9844 ck_assert(!self->f->getAtBoolP(self, -1)); 9845 terminateO(self); 9846 9847 } 9848 9849 9850 void getAtDoubleSmallArrayT(void) { 9851 9852 double r; 9853 smallArrayt *self = allocG(rtSmallArrayt); 9854 smallArrayt *r2; 9855 9856 // add elements to self 9857 r2 = self->f->pushInt(self, 1); 9858 ck_assert_ptr_ne(r2, null); 9859 r2 = self->f->pushDouble(self, 2); 9860 ck_assert_ptr_ne(r2, null); 9861 r2 = self->f->pushInt(self, 3); 9862 ck_assert_ptr_ne(r2, null); 9863 r2 = self->f->pushDouble(self, 4); 9864 ck_assert_ptr_ne(r2, null); 9865 9866 // positive index 9867 r = self->f->getAtDouble(self,1); 9868 ck_assert(r==2); 9869 char *s = toStringO(self); 9870 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 9871 free(s); 9872 // negative index 9873 r = self->f->getAtDouble(self,-1); 9874 ck_assert(r==4); 9875 s = toStringO(self); 9876 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 9877 free(s); 9878 // wrong object type 9879 createSmallInt(I); 9880 setValG(&I, 11); 9881 r2 = self->f->pushSmallInt(self, &I); 9882 r = self->f->getAtDouble(self,-1); 9883 ck_assert(!r); 9884 s = toStringO(self); 9885 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11]"); 9886 free(s); 9887 // wrong object type of another user class 9888 // User classes are stored in containers transparently 9889 createAllocateSmallInt(ip); 9890 ip->type = "anothertype"; 9891 setValG(ip, 11); 9892 r2 = self->f->push(self, (baset*)ip); 9893 ck_assert_ptr_ne(r2, null); 9894 r = self->f->getAtDouble(self,-1); 9895 ck_assert(!r); 9896 s = toStringO(self); 9897 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11,\"<data container>\"]"); 9898 free(s); 9899 // index outside 9900 ck_assert(!self->f->getAtDouble(self, 20)); 9901 ck_assert(!self->f->getAtDouble(self, -7)); 9902 // empty list 9903 emptyO(self); 9904 ck_assert(!self->f->getAtDouble(self, 0)); 9905 ck_assert(!self->f->getAtDouble(self, -1)); 9906 terminateO(self); 9907 9908 } 9909 9910 9911 void getAtDoublePSmallArrayT(void) { 9912 9913 double* r; 9914 smallArrayt *self = allocG(rtSmallArrayt); 9915 smallArrayt *r2; 9916 9917 // add elements to self 9918 r2 = self->f->pushInt(self, 1); 9919 ck_assert_ptr_ne(r2, null); 9920 r2 = self->f->pushDouble(self, 2); 9921 ck_assert_ptr_ne(r2, null); 9922 r2 = self->f->pushInt(self, 3); 9923 ck_assert_ptr_ne(r2, null); 9924 r2 = self->f->pushDouble(self, 4); 9925 ck_assert_ptr_ne(r2, null); 9926 9927 // positive index 9928 r = self->f->getAtDoubleP(self,1); 9929 ck_assert_ptr_ne(r, null); 9930 ck_assert(*r==2); 9931 char *s = toStringO(self); 9932 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 9933 free(s); 9934 // negative index 9935 r = self->f->getAtDoubleP(self,-1); 9936 ck_assert_ptr_ne(r, null); 9937 ck_assert(*r==4); 9938 s = toStringO(self); 9939 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 9940 free(s); 9941 // wrong object type 9942 createSmallInt(I); 9943 setValG(&I, 11); 9944 r2 = self->f->pushSmallInt(self, &I); 9945 r = self->f->getAtDoubleP(self,-1); 9946 ck_assert_ptr_eq(r, null); 9947 s = toStringO(self); 9948 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11]"); 9949 free(s); 9950 // wrong object type of another user class 9951 // User classes are stored in containers transparently 9952 createAllocateSmallInt(ip); 9953 ip->type = "anothertype"; 9954 setValG(ip, 11); 9955 r2 = self->f->push(self, (baset*)ip); 9956 ck_assert_ptr_ne(r2, null); 9957 r = self->f->getAtDoubleP(self,-1); 9958 ck_assert_ptr_eq(r, null); 9959 s = toStringO(self); 9960 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11,\"<data container>\"]"); 9961 free(s); 9962 // index outside 9963 ck_assert(!self->f->getAtDoubleP(self, 20)); 9964 ck_assert(!self->f->getAtDoubleP(self, -7)); 9965 // empty list 9966 emptyO(self); 9967 ck_assert(!self->f->getAtDoubleP(self, 0)); 9968 ck_assert(!self->f->getAtDoubleP(self, -1)); 9969 terminateO(self); 9970 9971 } 9972 9973 9974 void getAtIntSmallArrayT(void) { 9975 9976 int64_t r; 9977 smallArrayt *self = allocG(rtSmallArrayt); 9978 smallArrayt *r2; 9979 9980 // add elements to self 9981 r2 = self->f->pushInt(self, 1); 9982 ck_assert_ptr_ne(r2, null); 9983 r2 = self->f->pushInt(self, 2); 9984 ck_assert_ptr_ne(r2, null); 9985 r2 = self->f->pushInt(self, 3); 9986 ck_assert_ptr_ne(r2, null); 9987 r2 = self->f->pushInt(self, 4); 9988 ck_assert_ptr_ne(r2, null); 9989 9990 // positive index 9991 r = self->f->getAtInt(self,1); 9992 ck_assert(r==2); 9993 char *s = toStringO(self); 9994 ck_assert_str_eq(s, "[1,2,3,4]"); 9995 free(s); 9996 // negative index 9997 r = self->f->getAtInt(self,-1); 9998 ck_assert(r==4); 9999 s = toStringO(self); 10000 ck_assert_str_eq(s, "[1,2,3,4]"); 10001 free(s); 10002 // wrong object type 10003 createSmallDouble(I); 10004 setValG(&I, 11); 10005 r2 = self->f->pushSmallDouble(self, &I); 10006 r = self->f->getAtInt(self,-1); 10007 ck_assert(!r); 10008 s = toStringO(self); 10009 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10010 free(s); 10011 // wrong object type of another user class 10012 // User classes are stored in containers transparently 10013 createAllocateSmallInt(ip); 10014 ip->type = "anothertype"; 10015 setValG(ip, 11); 10016 r2 = self->f->push(self, (baset*)ip); 10017 ck_assert_ptr_ne(r2, null); 10018 r = self->f->getAtInt(self,-1); 10019 ck_assert(!r); 10020 s = toStringO(self); 10021 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10022 free(s); 10023 // index outside 10024 ck_assert(!self->f->getAtInt(self, 20)); 10025 ck_assert(!self->f->getAtInt(self, -7)); 10026 // empty list 10027 emptyO(self); 10028 ck_assert(!self->f->getAtInt(self, 0)); 10029 ck_assert(!self->f->getAtInt(self, -1)); 10030 terminateO(self); 10031 10032 } 10033 10034 10035 void getAtIntPSmallArrayT(void) { 10036 10037 int64_t* r; 10038 smallArrayt *self = allocG(rtSmallArrayt); 10039 smallArrayt *r2; 10040 10041 // add elements to self 10042 r2 = self->f->pushInt(self, 1); 10043 ck_assert_ptr_ne(r2, null); 10044 r2 = self->f->pushInt(self, 2); 10045 ck_assert_ptr_ne(r2, null); 10046 r2 = self->f->pushInt(self, 3); 10047 ck_assert_ptr_ne(r2, null); 10048 r2 = self->f->pushInt(self, 4); 10049 ck_assert_ptr_ne(r2, null); 10050 10051 // positive index 10052 r = self->f->getAtIntP(self,1); 10053 ck_assert_ptr_ne(r, null); 10054 ck_assert(*r==2); 10055 char *s = toStringO(self); 10056 ck_assert_str_eq(s, "[1,2,3,4]"); 10057 free(s); 10058 // negative index 10059 r = self->f->getAtIntP(self,-1); 10060 ck_assert_ptr_ne(r, null); 10061 ck_assert(*r==4); 10062 s = toStringO(self); 10063 ck_assert_str_eq(s, "[1,2,3,4]"); 10064 free(s); 10065 // wrong object type 10066 createSmallDouble(I); 10067 setValG(&I, 11); 10068 r2 = self->f->pushSmallDouble(self, &I); 10069 r = self->f->getAtIntP(self,-1); 10070 ck_assert_ptr_eq(r, null); 10071 s = toStringO(self); 10072 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10073 free(s); 10074 // wrong object type of another user class 10075 // User classes are stored in containers transparently 10076 createAllocateSmallInt(ip); 10077 ip->type = "anothertype"; 10078 setValG(ip, 11); 10079 r2 = self->f->push(self, (baset*)ip); 10080 ck_assert_ptr_ne(r2, null); 10081 r = self->f->getAtIntP(self,-1); 10082 ck_assert_ptr_eq(r, null); 10083 s = toStringO(self); 10084 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10085 free(s); 10086 // index outside 10087 ck_assert(!self->f->getAtIntP(self, 20)); 10088 ck_assert(!self->f->getAtIntP(self, -7)); 10089 // empty list 10090 emptyO(self); 10091 ck_assert(!self->f->getAtIntP(self, 0)); 10092 ck_assert(!self->f->getAtIntP(self, -1)); 10093 terminateO(self); 10094 10095 } 10096 10097 10098 void getAtInt32SmallArrayT(void) { 10099 10100 int32_t r; 10101 smallArrayt *self = allocG(rtSmallArrayt); 10102 smallArrayt *r2; 10103 10104 // add elements to self 10105 r2 = self->f->pushInt(self, 1); 10106 ck_assert_ptr_ne(r2, null); 10107 r2 = self->f->pushInt(self, 2); 10108 ck_assert_ptr_ne(r2, null); 10109 r2 = self->f->pushInt(self, 3); 10110 ck_assert_ptr_ne(r2, null); 10111 r2 = self->f->pushInt(self, 4); 10112 ck_assert_ptr_ne(r2, null); 10113 10114 // positive index 10115 r = self->f->getAtInt32(self,1); 10116 ck_assert(r==2); 10117 char *s = toStringO(self); 10118 ck_assert_str_eq(s, "[1,2,3,4]"); 10119 free(s); 10120 // negative index 10121 r = self->f->getAtInt32(self,-1); 10122 ck_assert(r==4); 10123 s = toStringO(self); 10124 ck_assert_str_eq(s, "[1,2,3,4]"); 10125 free(s); 10126 // wrong object type 10127 createSmallDouble(I); 10128 setValG(&I, 11); 10129 r2 = self->f->pushSmallDouble(self, &I); 10130 r = self->f->getAtInt32(self,-1); 10131 ck_assert(!r); 10132 s = toStringO(self); 10133 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10134 free(s); 10135 // wrong object type of another user class 10136 // User classes are stored in containers transparently 10137 createAllocateSmallInt(ip); 10138 ip->type = "anothertype"; 10139 setValG(ip, 11); 10140 r2 = self->f->push(self, (baset*)ip); 10141 ck_assert_ptr_ne(r2, null); 10142 r = self->f->getAtInt32(self,-1); 10143 ck_assert(!r); 10144 s = toStringO(self); 10145 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10146 free(s); 10147 // index outside 10148 ck_assert(!self->f->getAtInt32(self, 20)); 10149 ck_assert(!self->f->getAtInt32(self, -7)); 10150 // empty list 10151 emptyO(self); 10152 ck_assert(!self->f->getAtInt32(self, 0)); 10153 ck_assert(!self->f->getAtInt32(self, -1)); 10154 terminateO(self); 10155 10156 } 10157 10158 10159 void getAtInt32PSmallArrayT(void) { 10160 10161 int32_t* r; 10162 smallArrayt *self = allocG(rtSmallArrayt); 10163 smallArrayt *r2; 10164 10165 // add elements to self 10166 r2 = self->f->pushInt(self, 1); 10167 ck_assert_ptr_ne(r2, null); 10168 r2 = self->f->pushInt(self, 2); 10169 ck_assert_ptr_ne(r2, null); 10170 r2 = self->f->pushInt(self, 3); 10171 ck_assert_ptr_ne(r2, null); 10172 r2 = self->f->pushInt(self, 4); 10173 ck_assert_ptr_ne(r2, null); 10174 10175 // positive index 10176 r = self->f->getAtInt32P(self,1); 10177 ck_assert_ptr_ne(r, null); 10178 ck_assert(*r==2); 10179 char *s = toStringO(self); 10180 ck_assert_str_eq(s, "[1,2,3,4]"); 10181 free(s); 10182 // negative index 10183 r = self->f->getAtInt32P(self,-1); 10184 ck_assert_ptr_ne(r, null); 10185 ck_assert(*r==4); 10186 s = toStringO(self); 10187 ck_assert_str_eq(s, "[1,2,3,4]"); 10188 free(s); 10189 // wrong object type 10190 createSmallDouble(I); 10191 setValG(&I, 11); 10192 r2 = self->f->pushSmallDouble(self, &I); 10193 r = self->f->getAtInt32P(self,-1); 10194 ck_assert_ptr_eq(r, null); 10195 s = toStringO(self); 10196 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10197 free(s); 10198 // wrong object type of another user class 10199 // User classes are stored in containers transparently 10200 createAllocateSmallInt(ip); 10201 ip->type = "anothertype"; 10202 setValG(ip, 11); 10203 r2 = self->f->push(self, (baset*)ip); 10204 ck_assert_ptr_ne(r2, null); 10205 r = self->f->getAtInt32P(self,-1); 10206 ck_assert_ptr_eq(r, null); 10207 s = toStringO(self); 10208 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10209 free(s); 10210 // index outside 10211 ck_assert(!self->f->getAtInt32P(self, 20)); 10212 ck_assert(!self->f->getAtInt32P(self, -7)); 10213 // empty list 10214 emptyO(self); 10215 ck_assert(!self->f->getAtInt32P(self, 0)); 10216 ck_assert(!self->f->getAtInt32P(self, -1)); 10217 terminateO(self); 10218 10219 } 10220 10221 10222 void getAtUintSmallArrayT(void) { 10223 10224 uint64_t r; 10225 smallArrayt *self = allocG(rtSmallArrayt); 10226 smallArrayt *r2; 10227 10228 // add elements to self 10229 r2 = self->f->pushInt(self, 1); 10230 ck_assert_ptr_ne(r2, null); 10231 r2 = self->f->pushInt(self, 2); 10232 ck_assert_ptr_ne(r2, null); 10233 r2 = self->f->pushInt(self, 3); 10234 ck_assert_ptr_ne(r2, null); 10235 r2 = self->f->pushInt(self, 4); 10236 ck_assert_ptr_ne(r2, null); 10237 10238 // positive index 10239 r = self->f->getAtUint(self,1); 10240 ck_assert(r==2); 10241 char *s = toStringO(self); 10242 ck_assert_str_eq(s, "[1,2,3,4]"); 10243 free(s); 10244 // negative index 10245 r = self->f->getAtUint(self,-1); 10246 ck_assert(r==4); 10247 s = toStringO(self); 10248 ck_assert_str_eq(s, "[1,2,3,4]"); 10249 free(s); 10250 // wrong object type 10251 createSmallDouble(I); 10252 setValG(&I, 11); 10253 r2 = self->f->pushSmallDouble(self, &I); 10254 r = self->f->getAtUint(self,-1); 10255 ck_assert(!r); 10256 s = toStringO(self); 10257 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10258 free(s); 10259 // wrong object type of another user class 10260 // User classes are stored in containers transparently 10261 createAllocateSmallInt(ip); 10262 ip->type = "anothertype"; 10263 setValG(ip, 11); 10264 r2 = self->f->push(self, (baset*)ip); 10265 ck_assert_ptr_ne(r2, null); 10266 r = self->f->getAtUint(self,-1); 10267 ck_assert(!r); 10268 s = toStringO(self); 10269 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10270 free(s); 10271 // index outside 10272 ck_assert(!self->f->getAtUint(self, 20)); 10273 ck_assert(!self->f->getAtUint(self, -7)); 10274 // empty list 10275 emptyO(self); 10276 ck_assert(!self->f->getAtUint(self, 0)); 10277 ck_assert(!self->f->getAtUint(self, -1)); 10278 terminateO(self); 10279 10280 } 10281 10282 10283 void getAtUintPSmallArrayT(void) { 10284 10285 uint64_t* r; 10286 smallArrayt *self = allocG(rtSmallArrayt); 10287 smallArrayt *r2; 10288 10289 // add elements to self 10290 r2 = self->f->pushInt(self, 1); 10291 ck_assert_ptr_ne(r2, null); 10292 r2 = self->f->pushInt(self, 2); 10293 ck_assert_ptr_ne(r2, null); 10294 r2 = self->f->pushInt(self, 3); 10295 ck_assert_ptr_ne(r2, null); 10296 r2 = self->f->pushInt(self, 4); 10297 ck_assert_ptr_ne(r2, null); 10298 10299 // positive index 10300 r = self->f->getAtUintP(self,1); 10301 ck_assert_ptr_ne(r, null); 10302 ck_assert(*r==2); 10303 char *s = toStringO(self); 10304 ck_assert_str_eq(s, "[1,2,3,4]"); 10305 free(s); 10306 // negative index 10307 r = self->f->getAtUintP(self,-1); 10308 ck_assert_ptr_ne(r, null); 10309 ck_assert(*r==4); 10310 s = toStringO(self); 10311 ck_assert_str_eq(s, "[1,2,3,4]"); 10312 free(s); 10313 // wrong object type 10314 createSmallDouble(I); 10315 setValG(&I, 11); 10316 r2 = self->f->pushSmallDouble(self, &I); 10317 r = self->f->getAtUintP(self,-1); 10318 ck_assert_ptr_eq(r, null); 10319 s = toStringO(self); 10320 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10321 free(s); 10322 // wrong object type of another user class 10323 // User classes are stored in containers transparently 10324 createAllocateSmallInt(ip); 10325 ip->type = "anothertype"; 10326 setValG(ip, 11); 10327 r2 = self->f->push(self, (baset*)ip); 10328 ck_assert_ptr_ne(r2, null); 10329 r = self->f->getAtUintP(self,-1); 10330 ck_assert_ptr_eq(r, null); 10331 s = toStringO(self); 10332 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10333 free(s); 10334 // index outside 10335 ck_assert(!self->f->getAtUintP(self, 20)); 10336 ck_assert(!self->f->getAtUintP(self, -7)); 10337 // empty list 10338 emptyO(self); 10339 ck_assert(!self->f->getAtUintP(self, 0)); 10340 ck_assert(!self->f->getAtUintP(self, -1)); 10341 terminateO(self); 10342 10343 } 10344 10345 10346 void getAtUint32SmallArrayT(void) { 10347 10348 uint32_t r; 10349 smallArrayt *self = allocG(rtSmallArrayt); 10350 smallArrayt *r2; 10351 10352 // add elements to self 10353 r2 = self->f->pushInt(self, 1); 10354 ck_assert_ptr_ne(r2, null); 10355 r2 = self->f->pushInt(self, 2); 10356 ck_assert_ptr_ne(r2, null); 10357 r2 = self->f->pushInt(self, 3); 10358 ck_assert_ptr_ne(r2, null); 10359 r2 = self->f->pushInt(self, 4); 10360 ck_assert_ptr_ne(r2, null); 10361 10362 // positive index 10363 r = self->f->getAtUint32(self,1); 10364 ck_assert(r==2); 10365 char *s = toStringO(self); 10366 ck_assert_str_eq(s, "[1,2,3,4]"); 10367 free(s); 10368 // negative index 10369 r = self->f->getAtUint32(self,-1); 10370 ck_assert(r==4); 10371 s = toStringO(self); 10372 ck_assert_str_eq(s, "[1,2,3,4]"); 10373 free(s); 10374 // wrong object type 10375 createSmallDouble(I); 10376 setValG(&I, 11); 10377 r2 = self->f->pushSmallDouble(self, &I); 10378 r = self->f->getAtUint32(self,-1); 10379 ck_assert(!r); 10380 s = toStringO(self); 10381 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10382 free(s); 10383 // wrong object type of another user class 10384 // User classes are stored in containers transparently 10385 createAllocateSmallInt(ip); 10386 ip->type = "anothertype"; 10387 setValG(ip, 11); 10388 r2 = self->f->push(self, (baset*)ip); 10389 ck_assert_ptr_ne(r2, null); 10390 r = self->f->getAtUint32(self,-1); 10391 ck_assert(!r); 10392 s = toStringO(self); 10393 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10394 free(s); 10395 // index outside 10396 ck_assert(!self->f->getAtUint32(self, 20)); 10397 ck_assert(!self->f->getAtUint32(self, -7)); 10398 // empty list 10399 emptyO(self); 10400 ck_assert(!self->f->getAtUint32(self, 0)); 10401 ck_assert(!self->f->getAtUint32(self, -1)); 10402 terminateO(self); 10403 10404 } 10405 10406 10407 void getAtUint32PSmallArrayT(void) { 10408 10409 uint32_t* r; 10410 smallArrayt *self = allocG(rtSmallArrayt); 10411 smallArrayt *r2; 10412 10413 // add elements to self 10414 r2 = self->f->pushInt(self, 1); 10415 ck_assert_ptr_ne(r2, null); 10416 r2 = self->f->pushInt(self, 2); 10417 ck_assert_ptr_ne(r2, null); 10418 r2 = self->f->pushInt(self, 3); 10419 ck_assert_ptr_ne(r2, null); 10420 r2 = self->f->pushInt(self, 4); 10421 ck_assert_ptr_ne(r2, null); 10422 10423 // positive index 10424 r = self->f->getAtUint32P(self,1); 10425 ck_assert_ptr_ne(r, null); 10426 ck_assert(*r==2); 10427 char *s = toStringO(self); 10428 ck_assert_str_eq(s, "[1,2,3,4]"); 10429 free(s); 10430 // negative index 10431 r = self->f->getAtUint32P(self,-1); 10432 ck_assert_ptr_ne(r, null); 10433 ck_assert(*r==4); 10434 s = toStringO(self); 10435 ck_assert_str_eq(s, "[1,2,3,4]"); 10436 free(s); 10437 // wrong object type 10438 createSmallDouble(I); 10439 setValG(&I, 11); 10440 r2 = self->f->pushSmallDouble(self, &I); 10441 r = self->f->getAtUint32P(self,-1); 10442 ck_assert_ptr_eq(r, null); 10443 s = toStringO(self); 10444 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10445 free(s); 10446 // wrong object type of another user class 10447 // User classes are stored in containers transparently 10448 createAllocateSmallInt(ip); 10449 ip->type = "anothertype"; 10450 setValG(ip, 11); 10451 r2 = self->f->push(self, (baset*)ip); 10452 ck_assert_ptr_ne(r2, null); 10453 r = self->f->getAtUint32P(self,-1); 10454 ck_assert_ptr_eq(r, null); 10455 s = toStringO(self); 10456 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10457 free(s); 10458 // index outside 10459 ck_assert(!self->f->getAtUint32P(self, 20)); 10460 ck_assert(!self->f->getAtUint32P(self, -7)); 10461 // empty list 10462 emptyO(self); 10463 ck_assert(!self->f->getAtUint32P(self, 0)); 10464 ck_assert(!self->f->getAtUint32P(self, -1)); 10465 terminateO(self); 10466 10467 } 10468 10469 10470 void getAtSSmallArrayT(void) { 10471 10472 char* r; 10473 smallArrayt *self = allocG(rtSmallArrayt); 10474 smallArrayt *r2; 10475 10476 // add elements to self 10477 r2 = self->f->pushInt(self, 1); 10478 ck_assert_ptr_ne(r2, null); 10479 r2 = self->f->pushS(self, "2"); 10480 ck_assert_ptr_ne(r2, null); 10481 r2 = self->f->pushInt(self, 3); 10482 ck_assert_ptr_ne(r2, null); 10483 r2 = self->f->pushS(self, "4"); 10484 ck_assert_ptr_ne(r2, null); 10485 10486 // positive index 10487 r = self->f->getAtS(self,1); 10488 ck_assert_ptr_ne(r, null); 10489 ck_assert_str_eq(r, "2"); 10490 char *s = toStringO(self); 10491 ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]"); 10492 free(s); 10493 // negative index 10494 r = self->f->getAtS(self,-1); 10495 ck_assert_ptr_ne(r, null); 10496 ck_assert_str_eq(r, "4"); 10497 s = toStringO(self); 10498 ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]"); 10499 free(s); 10500 // wrong object type 10501 createSmallInt(I); 10502 setValG(&I, 11); 10503 r2 = self->f->pushSmallInt(self, &I); 10504 r = self->f->getAtS(self,-1); 10505 ck_assert_ptr_eq(r, NULL); 10506 s = toStringO(self); 10507 ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11]"); 10508 free(s); 10509 // wrong object type of another user class 10510 // User classes are stored in containers transparently 10511 createAllocateSmallInt(ip); 10512 ip->type = "anothertype"; 10513 setValG(ip, 11); 10514 r2 = self->f->push(self, (baset*)ip); 10515 ck_assert_ptr_ne(r2, null); 10516 r = self->f->getAtS(self,-1); 10517 ck_assert_ptr_eq(r, NULL); 10518 s = toStringO(self); 10519 ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11,\"<data container>\"]"); 10520 free(s); 10521 // index outside 10522 ck_assert_ptr_eq(self->f->getAtS(self, 20), NULL); 10523 ck_assert_ptr_eq(self->f->getAtS(self, -7), NULL); 10524 // empty list 10525 emptyO(self); 10526 ck_assert_ptr_eq(self->f->getAtS(self, 0), NULL); 10527 ck_assert_ptr_eq(self->f->getAtS(self, -1), NULL); 10528 terminateO(self); 10529 10530 } 10531 10532 10533 void getAtDictSmallArrayT(void) { 10534 10535 smallDictt* r; 10536 smallArrayt *self = allocG(rtSmallArrayt); 10537 smallArrayt *r2; 10538 10539 // add elements to self 10540 r2 = self->f->pushInt(self, 1); 10541 ck_assert_ptr_ne(r2, null); 10542 createSmallDict(e2); 10543 r2 = self->f->pushDict(self, &e2); 10544 ck_assert_ptr_ne(r2, null); 10545 r2 = self->f->pushInt(self, 3); 10546 ck_assert_ptr_ne(r2, null); 10547 createSmallDict(e4); 10548 r2 = self->f->pushDict(self, &e4); 10549 ck_assert_ptr_ne(r2, null); 10550 10551 // positive index 10552 r = self->f->getAtDict(self,1); 10553 ck_assert_ptr_ne(r, null); 10554 char *s = toStringO(r); 10555 finishO(r); 10556 ck_assert_str_eq(s, "{}"); 10557 free(s); 10558 s = toStringO(self); 10559 ck_assert_str_eq(s, "[1,{},3,{}]"); 10560 free(s); 10561 // negative index 10562 r = self->f->getAtDict(self,-1); 10563 ck_assert_ptr_ne(r, null); 10564 s = toStringO(r); 10565 finishO(r); 10566 ck_assert_str_eq(s, "{}"); 10567 free(s); 10568 s = toStringO(self); 10569 ck_assert_str_eq(s, "[1,{},3,{}]"); 10570 free(s); 10571 // wrong object type 10572 createSmallInt(I); 10573 setValG(&I, 11); 10574 r2 = self->f->pushSmallInt(self, &I); 10575 r = self->f->getAtDict(self,-1); 10576 ck_assert_ptr_eq(r, NULL); 10577 s = toStringO(self); 10578 ck_assert_str_eq(s, "[1,{},3,{},11]"); 10579 free(s); 10580 // wrong object type of another user class 10581 // User classes are stored in containers transparently 10582 createAllocateSmallInt(ip); 10583 ip->type = "anothertype"; 10584 setValG(ip, 11); 10585 r2 = self->f->push(self, (baset*)ip); 10586 ck_assert_ptr_ne(r2, null); 10587 r = self->f->getAtDict(self,-1); 10588 ck_assert_ptr_eq(r, NULL); 10589 s = toStringO(self); 10590 ck_assert_str_eq(s, "[1,{},3,{},11,\"<data container>\"]"); 10591 free(s); 10592 // index outside 10593 ck_assert_ptr_eq(self->f->getAtDict(self, 20), NULL); 10594 ck_assert_ptr_eq(self->f->getAtDict(self, -7), NULL); 10595 // empty list 10596 emptyO(self); 10597 ck_assert_ptr_eq(self->f->getAtDict(self, 0), NULL); 10598 ck_assert_ptr_eq(self->f->getAtDict(self, -1), NULL); 10599 // get empty slot in array 10600 r2 = self->f->pushUndefined(self); 10601 ck_assert_ptr_ne(r2, null); 10602 delElemO(self,0); 10603 ck_assert_ptr_eq(self->f->getAtDict(self, 0), NULL); 10604 terminateO(self); 10605 10606 } 10607 10608 10609 void getAtArraySmallArrayT(void) { 10610 10611 smallArrayt* r; 10612 smallArrayt *self = allocG(rtSmallArrayt); 10613 smallArrayt *r2; 10614 10615 // add elements to self 10616 r2 = self->f->pushInt(self, 1); 10617 ck_assert_ptr_ne(r2, null); 10618 createSmallArray(e2); 10619 r2 = self->f->pushArray(self, &e2); 10620 ck_assert_ptr_ne(r2, null); 10621 r2 = self->f->pushInt(self, 3); 10622 ck_assert_ptr_ne(r2, null); 10623 createSmallArray(e4); 10624 r2 = self->f->pushArray(self, &e4); 10625 ck_assert_ptr_ne(r2, null); 10626 10627 // positive index 10628 r = self->f->getAtArray(self,1); 10629 ck_assert_ptr_ne(r, null); 10630 char *s = toStringO(r); 10631 finishO(r); 10632 ck_assert_str_eq(s, "[]"); 10633 free(s); 10634 s = toStringO(self); 10635 ck_assert_str_eq(s, "[1,[],3,[]]"); 10636 free(s); 10637 // negative index 10638 r = self->f->getAtArray(self,-1); 10639 ck_assert_ptr_ne(r, null); 10640 s = toStringO(r); 10641 finishO(r); 10642 ck_assert_str_eq(s, "[]"); 10643 free(s); 10644 s = toStringO(self); 10645 ck_assert_str_eq(s, "[1,[],3,[]]"); 10646 free(s); 10647 // wrong object type 10648 createSmallInt(I); 10649 setValG(&I, 11); 10650 r2 = self->f->pushSmallInt(self, &I); 10651 r = self->f->getAtArray(self,-1); 10652 ck_assert_ptr_eq(r, NULL); 10653 s = toStringO(self); 10654 ck_assert_str_eq(s, "[1,[],3,[],11]"); 10655 free(s); 10656 // wrong object type of another user class 10657 // User classes are stored in containers transparently 10658 createAllocateSmallInt(ip); 10659 ip->type = "anothertype"; 10660 setValG(ip, 11); 10661 r2 = self->f->push(self, (baset*)ip); 10662 ck_assert_ptr_ne(r2, null); 10663 r = self->f->getAtArray(self,-1); 10664 ck_assert_ptr_eq(r, NULL); 10665 s = toStringO(self); 10666 ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]"); 10667 free(s); 10668 // index outside 10669 ck_assert_ptr_eq(self->f->getAtArray(self, 20), NULL); 10670 ck_assert_ptr_eq(self->f->getAtArray(self, -7), NULL); 10671 // empty list 10672 emptyO(self); 10673 ck_assert_ptr_eq(self->f->getAtArray(self, 0), NULL); 10674 ck_assert_ptr_eq(self->f->getAtArray(self, -1), NULL); 10675 // get empty slot in array 10676 r2 = self->f->pushUndefined(self); 10677 ck_assert_ptr_ne(r2, null); 10678 delElemO(self,0); 10679 ck_assert_ptr_eq(self->f->getAtArray(self, 0), NULL); 10680 terminateO(self); 10681 10682 } 10683 10684 10685 void getAtSmallBoolSmallArrayT(void) { 10686 10687 smallBoolt* r; 10688 smallArrayt *self = allocG(rtSmallArrayt); 10689 smallArrayt *r2; 10690 10691 // add elements to self 10692 r2 = self->f->pushInt(self, 1); 10693 ck_assert_ptr_ne(r2, null); 10694 createSmallBool(e2); 10695 r2 = self->f->pushBool(self, true); 10696 ck_assert_ptr_ne(r2, null); 10697 r2 = self->f->pushInt(self, 3); 10698 ck_assert_ptr_ne(r2, null); 10699 createSmallBool(e4); 10700 r2 = self->f->pushBool(self, true); 10701 ck_assert_ptr_ne(r2, null); 10702 10703 // positive index 10704 r = self->f->getAtSmallBool(self,1); 10705 ck_assert_ptr_ne(r, null); 10706 char *s = toStringO(r); 10707 finishO(r); 10708 ck_assert_str_eq(s, "true"); 10709 free(s); 10710 s = toStringO(self); 10711 ck_assert_str_eq(s, "[1,true,3,true]"); 10712 free(s); 10713 // negative index 10714 r = self->f->getAtSmallBool(self,-1); 10715 ck_assert_ptr_ne(r, null); 10716 s = toStringO(r); 10717 finishO(r); 10718 ck_assert_str_eq(s, "true"); 10719 free(s); 10720 s = toStringO(self); 10721 ck_assert_str_eq(s, "[1,true,3,true]"); 10722 free(s); 10723 // wrong object type 10724 createSmallInt(I); 10725 setValG(&I, 11); 10726 r2 = self->f->pushSmallInt(self, &I); 10727 r = self->f->getAtSmallBool(self,2); 10728 ck_assert_ptr_eq(r, NULL); 10729 s = toStringO(self); 10730 ck_assert_str_eq(s, "[1,true,3,true,11]"); 10731 free(s); 10732 // wrong object type of another user class 10733 // User classes are stored in containers transparently 10734 createAllocateSmallInt(ip); 10735 ip->type = "anothertype"; 10736 setValG(ip, 11); 10737 r2 = self->f->push(self, (baset*)ip); 10738 ck_assert_ptr_ne(r2, null); 10739 r = self->f->getAtSmallBool(self,-1); 10740 ck_assert_ptr_eq(r, NULL); 10741 s = toStringO(self); 10742 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 10743 free(s); 10744 // index outside 10745 ck_assert_ptr_eq(self->f->getAtSmallBool(self, 20), NULL); 10746 ck_assert_ptr_eq(self->f->getAtSmallBool(self, -7), NULL); 10747 // empty list 10748 emptyO(self); 10749 ck_assert_ptr_eq(self->f->getAtSmallBool(self, 0), NULL); 10750 ck_assert_ptr_eq(self->f->getAtSmallBool(self, -1), NULL); 10751 // get empty slot in array 10752 r2 = self->f->pushUndefined(self); 10753 ck_assert_ptr_ne(r2, null); 10754 delElemO(self,0); 10755 ck_assert_ptr_eq(self->f->getAtSmallBool(self, 0), NULL); 10756 terminateO(self); 10757 10758 } 10759 10760 10761 void getAtSmallBytesSmallArrayT(void) { 10762 10763 smallBytest* r; 10764 smallArrayt *self = allocG(rtSmallArrayt); 10765 smallArrayt *r2; 10766 10767 // add elements to self 10768 r2 = self->f->pushInt(self, 1); 10769 ck_assert_ptr_ne(r2, null); 10770 createSmallBytes(e2); 10771 r2 = self->f->pushSmallBytes(self, &e2); 10772 ck_assert_ptr_ne(r2, null); 10773 r2 = self->f->pushInt(self, 3); 10774 ck_assert_ptr_ne(r2, null); 10775 createSmallBytes(e4); 10776 r2 = self->f->pushSmallBytes(self, &e4); 10777 ck_assert_ptr_ne(r2, null); 10778 10779 // positive index 10780 r = self->f->getAtSmallBytes(self,1); 10781 ck_assert_ptr_ne(r, null); 10782 char *s = toStringO(r); 10783 finishO(r); 10784 ck_assert_str_eq(s, "[]"); 10785 free(s); 10786 s = toStringO(self); 10787 ck_assert_str_eq(s, "[1,[],3,[]]"); 10788 free(s); 10789 // negative index 10790 r = self->f->getAtSmallBytes(self,-1); 10791 ck_assert_ptr_ne(r, null); 10792 s = toStringO(r); 10793 finishO(r); 10794 ck_assert_str_eq(s, "[]"); 10795 free(s); 10796 s = toStringO(self); 10797 ck_assert_str_eq(s, "[1,[],3,[]]"); 10798 free(s); 10799 // wrong object type 10800 createSmallInt(I); 10801 setValG(&I, 11); 10802 r2 = self->f->pushSmallInt(self, &I); 10803 r = self->f->getAtSmallBytes(self,-1); 10804 ck_assert_ptr_eq(r, NULL); 10805 s = toStringO(self); 10806 ck_assert_str_eq(s, "[1,[],3,[],11]"); 10807 free(s); 10808 // wrong object type of another user class 10809 // User classes are stored in containers transparently 10810 createAllocateSmallInt(ip); 10811 ip->type = "anothertype"; 10812 setValG(ip, 11); 10813 r2 = self->f->push(self, (baset*)ip); 10814 ck_assert_ptr_ne(r2, null); 10815 r = self->f->getAtSmallBytes(self,-1); 10816 ck_assert_ptr_eq(r, NULL); 10817 s = toStringO(self); 10818 ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]"); 10819 free(s); 10820 // index outside 10821 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, 20), NULL); 10822 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, -7), NULL); 10823 // empty list 10824 emptyO(self); 10825 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, 0), NULL); 10826 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, -1), NULL); 10827 // get empty slot in array 10828 r2 = self->f->pushUndefined(self); 10829 ck_assert_ptr_ne(r2, null); 10830 delElemO(self,0); 10831 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, 0), NULL); 10832 terminateO(self); 10833 10834 } 10835 10836 10837 void getAtSmallDoubleSmallArrayT(void) { 10838 10839 smallDoublet* r; 10840 smallArrayt *self = allocG(rtSmallArrayt); 10841 smallArrayt *r2; 10842 10843 // add elements to self 10844 r2 = self->f->pushInt(self, 1); 10845 ck_assert_ptr_ne(r2, null); 10846 createSmallDouble(e2); 10847 r2 = self->f->pushSmallDouble(self, &e2); 10848 ck_assert_ptr_ne(r2, null); 10849 r2 = self->f->pushInt(self, 3); 10850 ck_assert_ptr_ne(r2, null); 10851 createSmallDouble(e4); 10852 r2 = self->f->pushSmallDouble(self, &e4); 10853 ck_assert_ptr_ne(r2, null); 10854 10855 // positive index 10856 r = self->f->getAtSmallDouble(self,1); 10857 ck_assert_ptr_ne(r, null); 10858 char *s = toStringO(r); 10859 finishO(r); 10860 ck_assert_str_eq(s, "0.000000e+00"); 10861 free(s); 10862 s = toStringO(self); 10863 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]"); 10864 free(s); 10865 // negative index 10866 r = self->f->getAtSmallDouble(self,-1); 10867 ck_assert_ptr_ne(r, null); 10868 s = toStringO(r); 10869 finishO(r); 10870 ck_assert_str_eq(s, "0.000000e+00"); 10871 free(s); 10872 s = toStringO(self); 10873 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]"); 10874 free(s); 10875 // wrong object type 10876 createSmallInt(I); 10877 setValG(&I, 11); 10878 r2 = self->f->pushSmallInt(self, &I); 10879 r = self->f->getAtSmallDouble(self,-1); 10880 ck_assert_ptr_eq(r, NULL); 10881 s = toStringO(self); 10882 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11]"); 10883 free(s); 10884 // wrong object type of another user class 10885 // User classes are stored in containers transparently 10886 createAllocateSmallInt(ip); 10887 ip->type = "anothertype"; 10888 setValG(ip, 11); 10889 r2 = self->f->push(self, (baset*)ip); 10890 ck_assert_ptr_ne(r2, null); 10891 r = self->f->getAtSmallDouble(self,-1); 10892 ck_assert_ptr_eq(r, NULL); 10893 s = toStringO(self); 10894 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11,\"<data container>\"]"); 10895 free(s); 10896 // index outside 10897 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, 20), NULL); 10898 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, -7), NULL); 10899 // empty list 10900 emptyO(self); 10901 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, 0), NULL); 10902 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, -1), NULL); 10903 // get empty slot in array 10904 r2 = self->f->pushUndefined(self); 10905 ck_assert_ptr_ne(r2, null); 10906 delElemO(self,0); 10907 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, 0), NULL); 10908 terminateO(self); 10909 10910 } 10911 10912 10913 void getAtSmallIntSmallArrayT(void) { 10914 10915 smallIntt* r; 10916 smallArrayt *self = allocG(rtSmallArrayt); 10917 smallArrayt *r2; 10918 10919 // add elements to self 10920 r2 = self->f->pushBool(self, true); 10921 ck_assert_ptr_ne(r2, null); 10922 createSmallInt(e2); 10923 r2 = self->f->pushSmallInt(self, &e2); 10924 ck_assert_ptr_ne(r2, null); 10925 r2 = self->f->pushBool(self, true); 10926 ck_assert_ptr_ne(r2, null); 10927 createSmallInt(e4); 10928 r2 = self->f->pushSmallInt(self, &e4); 10929 ck_assert_ptr_ne(r2, null); 10930 10931 // positive index 10932 r = self->f->getAtSmallInt(self,1); 10933 ck_assert_ptr_ne(r, null); 10934 char *s = toStringO(r); 10935 finishO(r); 10936 ck_assert_str_eq(s, "0"); 10937 free(s); 10938 s = toStringO(self); 10939 ck_assert_str_eq(s, "[true,0,true,0]"); 10940 free(s); 10941 // negative index 10942 r = self->f->getAtSmallInt(self,-1); 10943 ck_assert_ptr_ne(r, null); 10944 s = toStringO(r); 10945 finishO(r); 10946 ck_assert_str_eq(s, "0"); 10947 free(s); 10948 s = toStringO(self); 10949 ck_assert_str_eq(s, "[true,0,true,0]"); 10950 free(s); 10951 // wrong object type 10952 createSmallDouble(I); 10953 setValG(&I, 11); 10954 r2 = self->f->pushSmallDouble(self, &I); 10955 r = self->f->getAtSmallInt(self,-1); 10956 ck_assert_ptr_eq(r, NULL); 10957 s = toStringO(self); 10958 ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01]"); 10959 free(s); 10960 // wrong object type of another user class 10961 // User classes are stored in containers transparently 10962 createAllocateSmallInt(ip); 10963 ip->type = "anothertype"; 10964 setValG(ip, 11); 10965 r2 = self->f->push(self, (baset*)ip); 10966 ck_assert_ptr_ne(r2, null); 10967 r = self->f->getAtSmallInt(self,-1); 10968 ck_assert_ptr_eq(r, NULL); 10969 s = toStringO(self); 10970 ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01,\"<data container>\"]"); 10971 free(s); 10972 // index outside 10973 ck_assert_ptr_eq(self->f->getAtSmallInt(self, 20), NULL); 10974 ck_assert_ptr_eq(self->f->getAtSmallInt(self, -7), NULL); 10975 // empty list 10976 emptyO(self); 10977 ck_assert_ptr_eq(self->f->getAtSmallInt(self, 0), NULL); 10978 ck_assert_ptr_eq(self->f->getAtSmallInt(self, -1), NULL); 10979 // get empty slot in array 10980 r2 = self->f->pushUndefined(self); 10981 ck_assert_ptr_ne(r2, null); 10982 delElemO(self,0); 10983 ck_assert_ptr_eq(self->f->getAtSmallInt(self, 0), NULL); 10984 terminateO(self); 10985 10986 } 10987 10988 10989 void getAtSmallJsonSmallArrayT(void) { 10990 10991 smallJsont* r; 10992 smallArrayt *self = allocG(rtSmallArrayt); 10993 smallArrayt *r2; 10994 10995 // add elements to self 10996 r2 = self->f->pushInt(self, 1); 10997 ck_assert_ptr_ne(r2, null); 10998 createSmallJson(e2); 10999 r2 = self->f->pushSmallJson(self, &e2); 11000 ck_assert_ptr_ne(r2, null); 11001 r2 = self->f->pushInt(self, 3); 11002 ck_assert_ptr_ne(r2, null); 11003 createSmallJson(e4); 11004 r2 = self->f->pushSmallJson(self, &e4); 11005 ck_assert_ptr_ne(r2, null); 11006 11007 // positive index 11008 r = self->f->getAtSmallJson(self,1); 11009 ck_assert_ptr_ne(r, null); 11010 char *s = toStringO(r); 11011 finishO(r); 11012 ck_assert_str_eq(s, "{}"); 11013 free(s); 11014 s = toStringO(self); 11015 ck_assert_str_eq(s, "[1,{},3,{}]"); 11016 free(s); 11017 // negative index 11018 r = self->f->getAtSmallJson(self,-1); 11019 ck_assert_ptr_ne(r, null); 11020 s = toStringO(r); 11021 finishO(r); 11022 ck_assert_str_eq(s, "{}"); 11023 free(s); 11024 s = toStringO(self); 11025 ck_assert_str_eq(s, "[1,{},3,{}]"); 11026 free(s); 11027 // wrong object type 11028 createSmallBytes(I); 11029 r2 = self->f->pushSmallBytes(self, &I); 11030 r = self->f->getAtSmallJson(self,-1); 11031 ck_assert_ptr_eq(r, NULL); 11032 s = toStringO(self); 11033 ck_assert_str_eq(s, "[1,{},3,{},[]]"); 11034 free(s); 11035 // wrong object type of another user class 11036 // User classes are stored in containers transparently 11037 createAllocateSmallInt(ip); 11038 ip->type = "anothertype"; 11039 setValG(ip, 11); 11040 r2 = self->f->push(self, (baset*)ip); 11041 ck_assert_ptr_ne(r2, null); 11042 r = self->f->getAtSmallJson(self,-1); 11043 ck_assert_ptr_eq(r, NULL); 11044 s = toStringO(self); 11045 ck_assert_str_eq(s, "[1,{},3,{},[],\"<data container>\"]"); 11046 free(s); 11047 // index outside 11048 ck_assert_ptr_eq(self->f->getAtSmallJson(self, 20), NULL); 11049 ck_assert_ptr_eq(self->f->getAtSmallJson(self, -7), NULL); 11050 // empty list 11051 emptyO(self); 11052 ck_assert_ptr_eq(self->f->getAtSmallJson(self, 0), NULL); 11053 ck_assert_ptr_eq(self->f->getAtSmallJson(self, -1), NULL); 11054 // get empty slot in array 11055 r2 = self->f->pushUndefined(self); 11056 ck_assert_ptr_ne(r2, null); 11057 delElemO(self,0); 11058 ck_assert_ptr_eq(self->f->getAtSmallJson(self, 0), NULL); 11059 terminateO(self); 11060 11061 } 11062 11063 11064 void getAtSmallStringSmallArrayT(void) { 11065 11066 smallStringt* r; 11067 smallArrayt *self = allocG(rtSmallArrayt); 11068 smallArrayt *r2; 11069 11070 // add elements to self 11071 r2 = self->f->pushInt(self, 1); 11072 ck_assert_ptr_ne(r2, null); 11073 createSmallString(e2); 11074 r2 = self->f->pushSmallString(self, &e2); 11075 ck_assert_ptr_ne(r2, null); 11076 r2 = self->f->pushInt(self, 3); 11077 ck_assert_ptr_ne(r2, null); 11078 createSmallString(e4); 11079 r2 = self->f->pushSmallString(self, &e4); 11080 ck_assert_ptr_ne(r2, null); 11081 11082 // positive index 11083 r = self->f->getAtSmallString(self,1); 11084 ck_assert_ptr_ne(r, null); 11085 char *s = toStringO(r); 11086 finishO(r); 11087 ck_assert_str_eq(s, ""); 11088 free(s); 11089 s = toStringO(self); 11090 ck_assert_str_eq(s, "[1,\"\",3,\"\"]"); 11091 free(s); 11092 // negative index 11093 r = self->f->getAtSmallString(self,-1); 11094 ck_assert_ptr_ne(r, null); 11095 s = toStringO(r); 11096 finishO(r); 11097 ck_assert_str_eq(s, ""); 11098 free(s); 11099 s = toStringO(self); 11100 ck_assert_str_eq(s, "[1,\"\",3,\"\"]"); 11101 free(s); 11102 // wrong object type 11103 createSmallInt(I); 11104 setValG(&I, 11); 11105 r2 = self->f->pushSmallInt(self, &I); 11106 r = self->f->getAtSmallString(self,-1); 11107 ck_assert_ptr_eq(r, NULL); 11108 s = toStringO(self); 11109 ck_assert_str_eq(s, "[1,\"\",3,\"\",11]"); 11110 free(s); 11111 // wrong object type of another user class 11112 // User classes are stored in containers transparently 11113 createAllocateSmallInt(ip); 11114 ip->type = "anothertype"; 11115 setValG(ip, 11); 11116 r2 = self->f->push(self, (baset*)ip); 11117 ck_assert_ptr_ne(r2, null); 11118 r = self->f->getAtSmallString(self,-1); 11119 ck_assert_ptr_eq(r, NULL); 11120 s = toStringO(self); 11121 ck_assert_str_eq(s, "[1,\"\",3,\"\",11,\"<data container>\"]"); 11122 free(s); 11123 // index outside 11124 ck_assert_ptr_eq(self->f->getAtSmallString(self, 20), NULL); 11125 ck_assert_ptr_eq(self->f->getAtSmallString(self, -7), NULL); 11126 // empty list 11127 emptyO(self); 11128 ck_assert_ptr_eq(self->f->getAtSmallString(self, 0), NULL); 11129 ck_assert_ptr_eq(self->f->getAtSmallString(self, -1), NULL); 11130 // get empty slot in array 11131 r2 = self->f->pushUndefined(self); 11132 ck_assert_ptr_ne(r2, null); 11133 delElemO(self,0); 11134 ck_assert_ptr_eq(self->f->getAtSmallString(self, 0), NULL); 11135 terminateO(self); 11136 11137 } 11138 11139 11140 void getAtVoidSmallArrayT(void) { 11141 11142 void* r; 11143 smallArrayt *self = allocG(rtSmallArrayt); 11144 smallArrayt *r2; 11145 11146 // add elements to self 11147 r2 = self->f->pushInt(self, 1); 11148 ck_assert_ptr_ne(r2, null); 11149 r2 = pushVoidSmallArrayG(self, &r); 11150 ck_assert_ptr_ne(r2, null); 11151 r2 = self->f->pushInt(self, 3); 11152 ck_assert_ptr_ne(r2, null); 11153 r2 = pushVoidSmallArrayG(self, &self); 11154 ck_assert_ptr_ne(r2, null); 11155 11156 // positive index 11157 r = self->f->getAtVoid(self,1); 11158 ck_assert_ptr_eq(r, &r); 11159 char *s = toStringO(self); 11160 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 11161 free(s); 11162 // negative index 11163 r = self->f->getAtVoid(self,-1); 11164 ck_assert_ptr_eq(r, &self); 11165 s = toStringO(self); 11166 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 11167 free(s); 11168 // wrong object type 11169 createSmallInt(I); 11170 setValG(&I, 11); 11171 r2 = self->f->pushSmallInt(self, &I); 11172 r = self->f->getAtVoid(self,-1); 11173 ck_assert_ptr_eq(r, NULL); 11174 s = toStringO(self); 11175 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]"); 11176 free(s); 11177 // wrong object type of another user class 11178 // User classes are stored in containers transparently 11179 createAllocateSmallInt(ip); 11180 ip->type = "anothertype"; 11181 setValG(ip, 11); 11182 r2 = self->f->push(self, (baset*)ip); 11183 ck_assert_ptr_ne(r2, null); 11184 r = self->f->getAtVoid(self,-1); 11185 ck_assert_ptr_eq(r, NULL); 11186 s = toStringO(self); 11187 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]"); 11188 free(s); 11189 // index outside 11190 ck_assert_ptr_eq(self->f->getAtVoid(self, 20), NULL); 11191 ck_assert_ptr_eq(self->f->getAtVoid(self, -7), NULL); 11192 // empty list 11193 emptyO(self); 11194 ck_assert_ptr_eq(self->f->getAtVoid(self, 0), NULL); 11195 ck_assert_ptr_eq(self->f->getAtVoid(self, -1), NULL); 11196 terminateO(self); 11197 11198 } 11199 11200 11201 void getAtSmallContainerSmallArrayT(void) { 11202 11203 smallContainert* r; 11204 smallArrayt *self = allocG(rtSmallArrayt); 11205 smallArrayt *r2; 11206 11207 // add elements to self 11208 r2 = self->f->pushInt(self, 1); 11209 ck_assert_ptr_ne(r2, null); 11210 createSmallContainer(e2); 11211 r2 = self->f->pushSmallContainer(self, &e2); 11212 ck_assert_ptr_ne(r2, null); 11213 r2 = self->f->pushInt(self, 3); 11214 ck_assert_ptr_ne(r2, null); 11215 createSmallContainer(e4); 11216 r2 = self->f->pushSmallContainer(self, &e4); 11217 ck_assert_ptr_ne(r2, null); 11218 11219 // positive index 11220 r = self->f->getAtSmallContainer(self,1); 11221 ck_assert_ptr_ne(r, null); 11222 char *s = toStringO(r); 11223 finishO(r); 11224 ck_assert_str_eq(s, "<data smallContainer>"); 11225 free(s); 11226 s = toStringO(self); 11227 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 11228 free(s); 11229 // negative index 11230 r = self->f->getAtSmallContainer(self,-1); 11231 ck_assert_ptr_ne(r, null); 11232 s = toStringO(r); 11233 finishO(r); 11234 ck_assert_str_eq(s, "<data smallContainer>"); 11235 free(s); 11236 s = toStringO(self); 11237 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 11238 free(s); 11239 // wrong object type 11240 createSmallInt(I); 11241 setValG(&I, 11); 11242 r2 = self->f->pushSmallInt(self, &I); 11243 r = self->f->getAtSmallContainer(self,-1); 11244 ck_assert_ptr_eq(r, NULL); 11245 s = toStringO(self); 11246 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]"); 11247 free(s); 11248 // wrong object type of another user class 11249 // User classes are stored in containers transparently 11250 createAllocateSmallInt(ip); 11251 ip->type = "anothertype"; 11252 setValG(ip, 11); 11253 r2 = self->f->push(self, (baset*)ip); 11254 ck_assert_ptr_ne(r2, null); 11255 r = self->f->getAtSmallContainer(self,-1); 11256 ck_assert_ptr_eq(r, NULL); 11257 s = toStringO(self); 11258 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]"); 11259 free(s); 11260 // index outside 11261 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, 20), NULL); 11262 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, -7), NULL); 11263 // empty list 11264 emptyO(self); 11265 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, 0), NULL); 11266 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, -1), NULL); 11267 // get empty slot in array 11268 r2 = self->f->pushUndefined(self); 11269 ck_assert_ptr_ne(r2, null); 11270 delElemO(self,0); 11271 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, 0), NULL); 11272 terminateO(self); 11273 11274 } 11275 11276 11277 void getAtNDupSmallArrayT(void) { 11278 11279 baset* r; 11280 smallArrayt *self = allocG(rtSmallArrayt); 11281 smallArrayt *r2; 11282 11283 // add elements to self 11284 r2 = self->f->pushInt(self, 1); 11285 ck_assert_ptr_ne(r2, null); 11286 r2 = self->f->pushInt(self, 2); 11287 ck_assert_ptr_ne(r2, null); 11288 r2 = self->f->pushInt(self, 3); 11289 ck_assert_ptr_ne(r2, null); 11290 r2 = self->f->pushInt(self, 4); 11291 ck_assert_ptr_ne(r2, null); 11292 11293 // positive index 11294 r = self->f->getAtNDup(self,1); 11295 ck_assert_ptr_ne(r, null); 11296 char *s = toStringO(r); 11297 terminateO(r); 11298 ck_assert_str_eq(s, "2"); 11299 free(s); 11300 s = toStringO(self); 11301 ck_assert_str_eq(s, "[1,2,3,4]"); 11302 free(s); 11303 // negative index 11304 r = self->f->getAtNDup(self,-1); 11305 ck_assert_ptr_ne(r, null); 11306 s = toStringO(r); 11307 terminateO(r); 11308 ck_assert_str_eq(s, "4"); 11309 free(s); 11310 s = toStringO(self); 11311 ck_assert_str_eq(s, "[1,2,3,4]"); 11312 free(s); 11313 // undefined object 11314 r2 = self->f->pushUndefined(self); 11315 ck_assert_ptr_ne(r2, null); 11316 r = self->f->getAtNDup(self,-1); 11317 ck_assert_ptr_ne(r, null); 11318 s = toStringO(r); 11319 terminateO(r); 11320 ck_assert_str_eq(s, "null"); 11321 free(s); 11322 s = toStringO(self); 11323 ck_assert_str_eq(s, "[1,2,3,4,null]"); 11324 free(s); 11325 // container 11326 createSmallContainer(c); 11327 r2 = self->f->pushSmallContainer(self, &c); 11328 r = self->f->getAtNDup(self,-1); 11329 ck_assert_ptr_ne(r, null); 11330 s = toStringO(r); 11331 terminateO(r); 11332 ck_assert_str_eq(s, "<data smallContainer>"); 11333 free(s); 11334 s = toStringO(self); 11335 ck_assert_str_eq(s, "[1,2,3,4,null,\"<data container>\"]"); 11336 free(s); 11337 // base object in container 11338 createAllocateSmallInt(I); 11339 setValG(I, 11); 11340 I->type = "anothertype"; 11341 r2 = self->f->push(self, (baset*)I); 11342 r = self->f->getAtNDup(self,-1); 11343 ck_assert_ptr_ne(r, null); 11344 // r->type is not anothertype, because the duplicate function is from the smallInt class 11345 ck_assert_str_eq(r->type, "smallInt"); 11346 s = toStringO(r); 11347 terminateO(r); 11348 ck_assert_str_eq(s, "11"); 11349 free(s); 11350 s = toStringO(self); 11351 ck_assert_str_eq(s, "[1,2,3,4,null,\"<data container>\",\"<data container>\"]"); 11352 free(s); 11353 // index outside 11354 ck_assert_ptr_eq(self->f->getAtNDup(self, 20), NULL); 11355 ck_assert_ptr_eq(self->f->getAtNDup(self, -8), NULL); 11356 // empty list 11357 emptyO(self); 11358 ck_assert_ptr_eq(self->f->getAtNDup(self, 0), NULL); 11359 ck_assert_ptr_eq(self->f->getAtNDup(self, -1), NULL); 11360 // get empty slot in array 11361 r2 = self->f->pushUndefined(self); 11362 ck_assert_ptr_ne(r2, null); 11363 delElemO(self,0); 11364 ck_assert_ptr_eq(self->f->getAtNDup(self, 0), NULL); 11365 terminateO(self); 11366 11367 } 11368 11369 11370 void getAtNDupUndefinedSmallArrayT(void) { 11371 11372 undefinedt* r; 11373 smallArrayt *self = allocG(rtSmallArrayt); 11374 smallArrayt *r2; 11375 11376 // add elements to self 11377 r2 = self->f->pushInt(self, 1); 11378 ck_assert_ptr_ne(r2, null); 11379 r2 = self->f->pushUndefined(self); 11380 ck_assert_ptr_ne(r2, null); 11381 r2 = self->f->pushInt(self, 3); 11382 ck_assert_ptr_ne(r2, null); 11383 r2 = self->f->pushUndefined(self); 11384 ck_assert_ptr_ne(r2, null); 11385 11386 // positive index 11387 r = self->f->getAtNDupUndefined(self,1); 11388 ck_assert_ptr_ne(r, null); 11389 char *s = toStringO(r); 11390 terminateO(r); 11391 ck_assert_str_eq(s, "null"); 11392 free(s); 11393 s = toStringO(self); 11394 ck_assert_str_eq(s, "[1,null,3,null]"); 11395 free(s); 11396 // negative index 11397 r = self->f->getAtNDupUndefined(self,-1); 11398 ck_assert_ptr_ne(r, null); 11399 s = toStringO(r); 11400 terminateO(r); 11401 ck_assert_str_eq(s, "null"); 11402 free(s); 11403 s = toStringO(self); 11404 ck_assert_str_eq(s, "[1,null,3,null]"); 11405 free(s); 11406 // wrong object type 11407 createSmallInt(I); 11408 setValG(&I, 11); 11409 r2 = self->f->pushSmallInt(self, &I); 11410 ck_assert_ptr_ne(r2, null); 11411 r = self->f->getAtNDupUndefined(self,-1); 11412 ck_assert_ptr_eq(r, null); 11413 s = toStringO(self); 11414 ck_assert_str_eq(s, "[1,null,3,null,11]"); 11415 free(s); 11416 // index outside 11417 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, 20), NULL); 11418 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, -6), NULL); 11419 // empty list 11420 emptyO(self); 11421 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, 0), NULL); 11422 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, -1), NULL); 11423 // get empty slot in array 11424 r2 = self->f->pushUndefined(self); 11425 ck_assert_ptr_ne(r2, null); 11426 delElemO(self,0); 11427 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, 0), NULL); 11428 terminateO(self); 11429 11430 } 11431 11432 11433 void getAtNDupBoolSmallArrayT(void) { 11434 11435 bool r; 11436 smallArrayt *self = allocG(rtSmallArrayt); 11437 smallArrayt *r2; 11438 11439 // add elements to self 11440 r2 = self->f->pushInt(self, 1); 11441 ck_assert_ptr_ne(r2, null); 11442 r2 = self->f->pushBool(self, TRUE); 11443 ck_assert_ptr_ne(r2, null); 11444 r2 = self->f->pushInt(self, 3); 11445 ck_assert_ptr_ne(r2, null); 11446 r2 = self->f->pushBool(self, TRUE); 11447 ck_assert_ptr_ne(r2, null); 11448 11449 // positive index 11450 r = self->f->getAtNDupBool(self,1); 11451 ck_assert(r); 11452 char *s = toStringO(self); 11453 ck_assert_str_eq(s, "[1,true,3,true]"); 11454 free(s); 11455 // negative index 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]"); 11460 free(s); 11461 // wrong object type 11462 createSmallInt(I); 11463 setValG(&I, 11); 11464 r2 = self->f->pushSmallInt(self, &I); 11465 r = self->f->getAtNDupBool(self,-1); 11466 ck_assert(!r); 11467 s = toStringO(self); 11468 ck_assert_str_eq(s, "[1,true,3,true,11]"); 11469 free(s); 11470 // wrong object type of another user class 11471 // User classes are stored in containers transparently 11472 createAllocateSmallInt(ip); 11473 ip->type = "anothertype"; 11474 setValG(ip, 11); 11475 r2 = self->f->push(self, (baset*)ip); 11476 ck_assert_ptr_ne(r2, null); 11477 r = self->f->getAtNDupBool(self,-1); 11478 ck_assert(!r); 11479 s = toStringO(self); 11480 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 11481 free(s); 11482 // index outside 11483 ck_assert(!self->f->getAtNDupBool(self, 20)); 11484 ck_assert(!self->f->getAtNDupBool(self, -7)); 11485 // empty list 11486 emptyO(self); 11487 ck_assert(!self->f->getAtNDupBool(self, 0)); 11488 ck_assert(!self->f->getAtNDupBool(self, -1)); 11489 terminateO(self); 11490 11491 } 11492 11493 11494 void getAtNDupDoubleSmallArrayT(void) { 11495 11496 double r; 11497 smallArrayt *self = allocG(rtSmallArrayt); 11498 smallArrayt *r2; 11499 11500 // add elements to self 11501 r2 = self->f->pushInt(self, 1); 11502 ck_assert_ptr_ne(r2, null); 11503 r2 = self->f->pushDouble(self, 2); 11504 ck_assert_ptr_ne(r2, null); 11505 r2 = self->f->pushInt(self, 3); 11506 ck_assert_ptr_ne(r2, null); 11507 r2 = self->f->pushDouble(self, 4); 11508 ck_assert_ptr_ne(r2, null); 11509 11510 // positive index 11511 r = self->f->getAtNDupDouble(self,1); 11512 ck_assert(r==2); 11513 char *s = toStringO(self); 11514 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 11515 free(s); 11516 // negative index 11517 r = self->f->getAtNDupDouble(self,-1); 11518 ck_assert(r==4); 11519 s = toStringO(self); 11520 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 11521 free(s); 11522 // wrong object type 11523 createSmallInt(I); 11524 setValG(&I, 11); 11525 r2 = self->f->pushSmallInt(self, &I); 11526 r = self->f->getAtNDupDouble(self,-1); 11527 ck_assert(!r); 11528 s = toStringO(self); 11529 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11]"); 11530 free(s); 11531 // wrong object type of another user class 11532 // User classes are stored in containers transparently 11533 createAllocateSmallInt(ip); 11534 ip->type = "anothertype"; 11535 setValG(ip, 11); 11536 r2 = self->f->push(self, (baset*)ip); 11537 ck_assert_ptr_ne(r2, null); 11538 r = self->f->getAtNDupDouble(self,-1); 11539 ck_assert(!r); 11540 s = toStringO(self); 11541 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11,\"<data container>\"]"); 11542 free(s); 11543 // index outside 11544 ck_assert(!self->f->getAtNDupDouble(self, 20)); 11545 ck_assert(!self->f->getAtNDupDouble(self, -7)); 11546 // empty list 11547 emptyO(self); 11548 ck_assert(!self->f->getAtNDupDouble(self, 0)); 11549 ck_assert(!self->f->getAtNDupDouble(self, -1)); 11550 terminateO(self); 11551 11552 } 11553 11554 11555 void getAtNDupIntSmallArrayT(void) { 11556 11557 int64_t r; 11558 smallArrayt *self = allocG(rtSmallArrayt); 11559 smallArrayt *r2; 11560 11561 // add elements to self 11562 r2 = self->f->pushInt(self, 1); 11563 ck_assert_ptr_ne(r2, null); 11564 r2 = self->f->pushInt(self, 2); 11565 ck_assert_ptr_ne(r2, null); 11566 r2 = self->f->pushInt(self, 3); 11567 ck_assert_ptr_ne(r2, null); 11568 r2 = self->f->pushInt(self, 4); 11569 ck_assert_ptr_ne(r2, null); 11570 11571 // positive index 11572 r = self->f->getAtNDupInt(self,1); 11573 ck_assert(r==2); 11574 char *s = toStringO(self); 11575 ck_assert_str_eq(s, "[1,2,3,4]"); 11576 free(s); 11577 // negative index 11578 r = self->f->getAtNDupInt(self,-1); 11579 ck_assert(r==4); 11580 s = toStringO(self); 11581 ck_assert_str_eq(s, "[1,2,3,4]"); 11582 free(s); 11583 // wrong object type 11584 createSmallDouble(I); 11585 setValG(&I, 11); 11586 r2 = self->f->pushSmallDouble(self, &I); 11587 r = self->f->getAtNDupInt(self,-1); 11588 ck_assert(!r); 11589 s = toStringO(self); 11590 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 11591 free(s); 11592 // wrong object type of another user class 11593 // User classes are stored in containers transparently 11594 createAllocateSmallInt(ip); 11595 ip->type = "anothertype"; 11596 setValG(ip, 11); 11597 r2 = self->f->push(self, (baset*)ip); 11598 ck_assert_ptr_ne(r2, null); 11599 r = self->f->getAtNDupInt(self,-1); 11600 ck_assert(!r); 11601 s = toStringO(self); 11602 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 11603 free(s); 11604 // index outside 11605 ck_assert(!self->f->getAtNDupInt(self, 20)); 11606 ck_assert(!self->f->getAtNDupInt(self, -7)); 11607 // empty list 11608 emptyO(self); 11609 ck_assert(!self->f->getAtNDupInt(self, 0)); 11610 ck_assert(!self->f->getAtNDupInt(self, -1)); 11611 terminateO(self); 11612 11613 } 11614 11615 11616 void getAtNDupInt32SmallArrayT(void) { 11617 11618 int32_t r; 11619 smallArrayt *self = allocG(rtSmallArrayt); 11620 smallArrayt *r2; 11621 11622 // add elements to self 11623 r2 = self->f->pushInt(self, 1); 11624 ck_assert_ptr_ne(r2, null); 11625 r2 = self->f->pushInt(self, 2); 11626 ck_assert_ptr_ne(r2, null); 11627 r2 = self->f->pushInt(self, 3); 11628 ck_assert_ptr_ne(r2, null); 11629 r2 = self->f->pushInt(self, 4); 11630 ck_assert_ptr_ne(r2, null); 11631 11632 // positive index 11633 r = self->f->getAtNDupInt32(self,1); 11634 ck_assert(r==2); 11635 char *s = toStringO(self); 11636 ck_assert_str_eq(s, "[1,2,3,4]"); 11637 free(s); 11638 // negative index 11639 r = self->f->getAtNDupInt32(self,-1); 11640 ck_assert(r==4); 11641 s = toStringO(self); 11642 ck_assert_str_eq(s, "[1,2,3,4]"); 11643 free(s); 11644 // wrong object type 11645 createSmallDouble(I); 11646 setValG(&I, 11); 11647 r2 = self->f->pushSmallDouble(self, &I); 11648 r = self->f->getAtNDupInt32(self,-1); 11649 ck_assert(!r); 11650 s = toStringO(self); 11651 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 11652 free(s); 11653 // wrong object type of another user class 11654 // User classes are stored in containers transparently 11655 createAllocateSmallInt(ip); 11656 ip->type = "anothertype"; 11657 setValG(ip, 11); 11658 r2 = self->f->push(self, (baset*)ip); 11659 ck_assert_ptr_ne(r2, null); 11660 r = self->f->getAtNDupInt32(self,-1); 11661 ck_assert(!r); 11662 s = toStringO(self); 11663 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 11664 free(s); 11665 // index outside 11666 ck_assert(!self->f->getAtNDupInt32(self, 20)); 11667 ck_assert(!self->f->getAtNDupInt32(self, -7)); 11668 // empty list 11669 emptyO(self); 11670 ck_assert(!self->f->getAtNDupInt32(self, 0)); 11671 ck_assert(!self->f->getAtNDupInt32(self, -1)); 11672 terminateO(self); 11673 11674 } 11675 11676 11677 void getAtNDupUintSmallArrayT(void) { 11678 11679 uint64_t r; 11680 smallArrayt *self = allocG(rtSmallArrayt); 11681 smallArrayt *r2; 11682 11683 // add elements to self 11684 r2 = self->f->pushInt(self, 1); 11685 ck_assert_ptr_ne(r2, null); 11686 r2 = self->f->pushInt(self, 2); 11687 ck_assert_ptr_ne(r2, null); 11688 r2 = self->f->pushInt(self, 3); 11689 ck_assert_ptr_ne(r2, null); 11690 r2 = self->f->pushInt(self, 4); 11691 ck_assert_ptr_ne(r2, null); 11692 11693 // positive index 11694 r = self->f->getAtNDupUint(self,1); 11695 ck_assert(r==2); 11696 char *s = toStringO(self); 11697 ck_assert_str_eq(s, "[1,2,3,4]"); 11698 free(s); 11699 // negative index 11700 r = self->f->getAtNDupUint(self,-1); 11701 ck_assert(r==4); 11702 s = toStringO(self); 11703 ck_assert_str_eq(s, "[1,2,3,4]"); 11704 free(s); 11705 // wrong object type 11706 createSmallDouble(I); 11707 setValG(&I, 11); 11708 r2 = self->f->pushSmallDouble(self, &I); 11709 r = self->f->getAtNDupUint(self,-1); 11710 ck_assert(!r); 11711 s = toStringO(self); 11712 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 11713 free(s); 11714 // wrong object type of another user class 11715 // User classes are stored in containers transparently 11716 createAllocateSmallInt(ip); 11717 ip->type = "anothertype"; 11718 setValG(ip, 11); 11719 r2 = self->f->push(self, (baset*)ip); 11720 ck_assert_ptr_ne(r2, null); 11721 r = self->f->getAtNDupUint(self,-1); 11722 ck_assert(!r); 11723 s = toStringO(self); 11724 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 11725 free(s); 11726 // index outside 11727 ck_assert(!self->f->getAtNDupUint(self, 20)); 11728 ck_assert(!self->f->getAtNDupUint(self, -7)); 11729 // empty list 11730 emptyO(self); 11731 ck_assert(!self->f->getAtNDupUint(self, 0)); 11732 ck_assert(!self->f->getAtNDupUint(self, -1)); 11733 terminateO(self); 11734 11735 } 11736 11737 11738 void getAtNDupUint32SmallArrayT(void) { 11739 11740 uint32_t r; 11741 smallArrayt *self = allocG(rtSmallArrayt); 11742 smallArrayt *r2; 11743 11744 // add elements to self 11745 r2 = self->f->pushInt(self, 1); 11746 ck_assert_ptr_ne(r2, null); 11747 r2 = self->f->pushInt(self, 2); 11748 ck_assert_ptr_ne(r2, null); 11749 r2 = self->f->pushInt(self, 3); 11750 ck_assert_ptr_ne(r2, null); 11751 r2 = self->f->pushInt(self, 4); 11752 ck_assert_ptr_ne(r2, null); 11753 11754 // positive index 11755 r = self->f->getAtNDupUint32(self,1); 11756 ck_assert(r==2); 11757 char *s = toStringO(self); 11758 ck_assert_str_eq(s, "[1,2,3,4]"); 11759 free(s); 11760 // negative index 11761 r = self->f->getAtNDupUint32(self,-1); 11762 ck_assert(r==4); 11763 s = toStringO(self); 11764 ck_assert_str_eq(s, "[1,2,3,4]"); 11765 free(s); 11766 // wrong object type 11767 createSmallDouble(I); 11768 setValG(&I, 11); 11769 r2 = self->f->pushSmallDouble(self, &I); 11770 r = self->f->getAtNDupUint32(self,-1); 11771 ck_assert(!r); 11772 s = toStringO(self); 11773 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 11774 free(s); 11775 // wrong object type of another user class 11776 // User classes are stored in containers transparently 11777 createAllocateSmallInt(ip); 11778 ip->type = "anothertype"; 11779 setValG(ip, 11); 11780 r2 = self->f->push(self, (baset*)ip); 11781 ck_assert_ptr_ne(r2, null); 11782 r = self->f->getAtNDupUint32(self,-1); 11783 ck_assert(!r); 11784 s = toStringO(self); 11785 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 11786 free(s); 11787 // index outside 11788 ck_assert(!self->f->getAtNDupUint32(self, 20)); 11789 ck_assert(!self->f->getAtNDupUint32(self, -7)); 11790 // empty list 11791 emptyO(self); 11792 ck_assert(!self->f->getAtNDupUint32(self, 0)); 11793 ck_assert(!self->f->getAtNDupUint32(self, -1)); 11794 terminateO(self); 11795 11796 } 11797 11798 11799 void getAtNDupSSmallArrayT(void) { 11800 11801 char* r; 11802 smallArrayt *self = allocG(rtSmallArrayt); 11803 smallArrayt *r2; 11804 11805 // add elements to self 11806 r2 = self->f->pushInt(self, 1); 11807 ck_assert_ptr_ne(r2, null); 11808 r2 = self->f->pushS(self, "2"); 11809 ck_assert_ptr_ne(r2, null); 11810 r2 = self->f->pushInt(self, 3); 11811 ck_assert_ptr_ne(r2, null); 11812 r2 = self->f->pushS(self, "4"); 11813 ck_assert_ptr_ne(r2, null); 11814 11815 // positive index 11816 r = self->f->getAtNDupS(self,1); 11817 ck_assert_ptr_ne(r, null); 11818 ck_assert_str_eq(r, "2"); 11819 free(r); 11820 char *s = toStringO(self); 11821 ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]"); 11822 free(s); 11823 // negative index 11824 r = self->f->getAtNDupS(self,-1); 11825 ck_assert_ptr_ne(r, null); 11826 ck_assert_str_eq(r, "4"); 11827 free(r); 11828 s = toStringO(self); 11829 ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]"); 11830 free(s); 11831 // wrong object type 11832 createSmallInt(I); 11833 setValG(&I, 11); 11834 r2 = self->f->pushSmallInt(self, &I); 11835 r = self->f->getAtNDupS(self,-1); 11836 ck_assert_ptr_eq(r, NULL); 11837 s = toStringO(self); 11838 ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11]"); 11839 free(s); 11840 // wrong object type of another user class 11841 // User classes are stored in containers transparently 11842 createAllocateSmallInt(ip); 11843 ip->type = "anothertype"; 11844 setValG(ip, 11); 11845 r2 = self->f->push(self, (baset*)ip); 11846 ck_assert_ptr_ne(r2, null); 11847 r = self->f->getAtNDupS(self,-1); 11848 ck_assert_ptr_eq(r, NULL); 11849 s = toStringO(self); 11850 ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11,\"<data container>\"]"); 11851 free(s); 11852 // index outside 11853 ck_assert_ptr_eq(self->f->getAtNDupS(self, 20), NULL); 11854 ck_assert_ptr_eq(self->f->getAtNDupS(self, -7), NULL); 11855 // empty list 11856 emptyO(self); 11857 ck_assert_ptr_eq(self->f->getAtNDupS(self, 0), NULL); 11858 ck_assert_ptr_eq(self->f->getAtNDupS(self, -1), NULL); 11859 terminateO(self); 11860 11861 } 11862 11863 11864 void getAtNDupDictSmallArrayT(void) { 11865 11866 smallDictt* r; 11867 smallArrayt *self = allocG(rtSmallArrayt); 11868 smallArrayt *r2; 11869 11870 // add elements to self 11871 r2 = self->f->pushInt(self, 1); 11872 ck_assert_ptr_ne(r2, null); 11873 createSmallDict(e2); 11874 r2 = self->f->pushDict(self, &e2); 11875 ck_assert_ptr_ne(r2, null); 11876 r2 = self->f->pushInt(self, 3); 11877 ck_assert_ptr_ne(r2, null); 11878 createSmallDict(e4); 11879 r2 = self->f->pushDict(self, &e4); 11880 ck_assert_ptr_ne(r2, null); 11881 11882 // positive index 11883 r = self->f->getAtNDupDict(self,1); 11884 ck_assert_ptr_ne(r, null); 11885 char *s = toStringO(r); 11886 terminateO(r); 11887 ck_assert_str_eq(s, "{}"); 11888 free(s); 11889 s = toStringO(self); 11890 ck_assert_str_eq(s, "[1,{},3,{}]"); 11891 free(s); 11892 // negative index 11893 r = self->f->getAtNDupDict(self,-1); 11894 ck_assert_ptr_ne(r, null); 11895 s = toStringO(r); 11896 terminateO(r); 11897 ck_assert_str_eq(s, "{}"); 11898 free(s); 11899 s = toStringO(self); 11900 ck_assert_str_eq(s, "[1,{},3,{}]"); 11901 free(s); 11902 // wrong object type 11903 createSmallInt(I); 11904 setValG(&I, 11); 11905 r2 = self->f->pushSmallInt(self, &I); 11906 r = self->f->getAtNDupDict(self,-1); 11907 ck_assert_ptr_eq(r, NULL); 11908 s = toStringO(self); 11909 ck_assert_str_eq(s, "[1,{},3,{},11]"); 11910 free(s); 11911 // wrong object type of another user class 11912 // User classes are stored in containers transparently 11913 createAllocateSmallInt(ip); 11914 ip->type = "anothertype"; 11915 setValG(ip, 11); 11916 r2 = self->f->push(self, (baset*)ip); 11917 ck_assert_ptr_ne(r2, null); 11918 r = self->f->getAtNDupDict(self,-1); 11919 ck_assert_ptr_eq(r, NULL); 11920 s = toStringO(self); 11921 ck_assert_str_eq(s, "[1,{},3,{},11,\"<data container>\"]"); 11922 free(s); 11923 // index outside 11924 ck_assert_ptr_eq(self->f->getAtNDupDict(self, 20), NULL); 11925 ck_assert_ptr_eq(self->f->getAtNDupDict(self, -7), NULL); 11926 // empty list 11927 emptyO(self); 11928 ck_assert_ptr_eq(self->f->getAtNDupDict(self, 0), NULL); 11929 ck_assert_ptr_eq(self->f->getAtNDupDict(self, -1), NULL); 11930 // get empty slot in array 11931 r2 = self->f->pushUndefined(self); 11932 ck_assert_ptr_ne(r2, null); 11933 delElemO(self,0); 11934 ck_assert_ptr_eq(self->f->getAtNDupDict(self, 0), NULL); 11935 terminateO(self); 11936 11937 } 11938 11939 11940 void getAtNDupArraySmallArrayT(void) { 11941 11942 smallArrayt* r; 11943 smallArrayt *self = allocG(rtSmallArrayt); 11944 smallArrayt *r2; 11945 11946 // add elements to self 11947 r2 = self->f->pushInt(self, 1); 11948 ck_assert_ptr_ne(r2, null); 11949 createSmallArray(e2); 11950 r2 = self->f->pushArray(self, &e2); 11951 ck_assert_ptr_ne(r2, null); 11952 r2 = self->f->pushInt(self, 3); 11953 ck_assert_ptr_ne(r2, null); 11954 createSmallArray(e4); 11955 r2 = self->f->pushArray(self, &e4); 11956 ck_assert_ptr_ne(r2, null); 11957 11958 // positive index 11959 r = self->f->getAtNDupArray(self,1); 11960 ck_assert_ptr_ne(r, null); 11961 char *s = toStringO(r); 11962 terminateO(r); 11963 ck_assert_str_eq(s, "[]"); 11964 free(s); 11965 s = toStringO(self); 11966 ck_assert_str_eq(s, "[1,[],3,[]]"); 11967 free(s); 11968 // negative index 11969 r = self->f->getAtNDupArray(self,-1); 11970 ck_assert_ptr_ne(r, null); 11971 s = toStringO(r); 11972 terminateO(r); 11973 ck_assert_str_eq(s, "[]"); 11974 free(s); 11975 s = toStringO(self); 11976 ck_assert_str_eq(s, "[1,[],3,[]]"); 11977 free(s); 11978 // wrong object type 11979 createSmallInt(I); 11980 setValG(&I, 11); 11981 r2 = self->f->pushSmallInt(self, &I); 11982 r = self->f->getAtNDupArray(self,-1); 11983 ck_assert_ptr_eq(r, NULL); 11984 s = toStringO(self); 11985 ck_assert_str_eq(s, "[1,[],3,[],11]"); 11986 free(s); 11987 // wrong object type of another user class 11988 // User classes are stored in containers transparently 11989 createAllocateSmallInt(ip); 11990 ip->type = "anothertype"; 11991 setValG(ip, 11); 11992 r2 = self->f->push(self, (baset*)ip); 11993 ck_assert_ptr_ne(r2, null); 11994 r = self->f->getAtNDupArray(self,-1); 11995 ck_assert_ptr_eq(r, NULL); 11996 s = toStringO(self); 11997 ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]"); 11998 free(s); 11999 // index outside 12000 ck_assert_ptr_eq(self->f->getAtNDupArray(self, 20), NULL); 12001 ck_assert_ptr_eq(self->f->getAtNDupArray(self, -7), NULL); 12002 // empty list 12003 emptyO(self); 12004 ck_assert_ptr_eq(self->f->getAtNDupArray(self, 0), NULL); 12005 ck_assert_ptr_eq(self->f->getAtNDupArray(self, -1), NULL); 12006 // get empty slot in array 12007 r2 = self->f->pushUndefined(self); 12008 ck_assert_ptr_ne(r2, null); 12009 delElemO(self,0); 12010 ck_assert_ptr_eq(self->f->getAtNDupArray(self, 0), NULL); 12011 terminateO(self); 12012 12013 } 12014 12015 12016 void getAtNDupSmallBoolSmallArrayT(void) { 12017 12018 smallBoolt* r; 12019 smallArrayt *self = allocG(rtSmallArrayt); 12020 smallArrayt *r2; 12021 12022 // add elements to self 12023 r2 = self->f->pushInt(self, 1); 12024 ck_assert_ptr_ne(r2, null); 12025 createSmallBool(e2); 12026 r2 = self->f->pushBool(self, true); 12027 ck_assert_ptr_ne(r2, null); 12028 r2 = self->f->pushInt(self, 3); 12029 ck_assert_ptr_ne(r2, null); 12030 createSmallBool(e4); 12031 r2 = self->f->pushBool(self, true); 12032 ck_assert_ptr_ne(r2, null); 12033 12034 // positive index 12035 r = self->f->getAtNDupSmallBool(self,1); 12036 ck_assert_ptr_ne(r, null); 12037 char *s = toStringO(r); 12038 terminateO(r); 12039 ck_assert_str_eq(s, "true"); 12040 free(s); 12041 s = toStringO(self); 12042 ck_assert_str_eq(s, "[1,true,3,true]"); 12043 free(s); 12044 // negative index 12045 r = self->f->getAtNDupSmallBool(self,-1); 12046 ck_assert_ptr_ne(r, null); 12047 s = toStringO(r); 12048 terminateO(r); 12049 ck_assert_str_eq(s, "true"); 12050 free(s); 12051 s = toStringO(self); 12052 ck_assert_str_eq(s, "[1,true,3,true]"); 12053 free(s); 12054 // wrong object type 12055 createSmallInt(I); 12056 setValG(&I, 11); 12057 r2 = self->f->pushSmallInt(self, &I); 12058 r = self->f->getAtNDupSmallBool(self,2); 12059 ck_assert_ptr_eq(r, NULL); 12060 s = toStringO(self); 12061 ck_assert_str_eq(s, "[1,true,3,true,11]"); 12062 free(s); 12063 // wrong object type of another user class 12064 // User classes are stored in containers transparently 12065 createAllocateSmallInt(ip); 12066 ip->type = "anothertype"; 12067 setValG(ip, 11); 12068 r2 = self->f->push(self, (baset*)ip); 12069 ck_assert_ptr_ne(r2, null); 12070 r = self->f->getAtNDupSmallBool(self,-1); 12071 ck_assert_ptr_eq(r, NULL); 12072 s = toStringO(self); 12073 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 12074 free(s); 12075 // index outside 12076 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, 20), NULL); 12077 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, -7), NULL); 12078 // empty list 12079 emptyO(self); 12080 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, 0), NULL); 12081 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, -1), NULL); 12082 // get empty slot in array 12083 r2 = self->f->pushUndefined(self); 12084 ck_assert_ptr_ne(r2, null); 12085 delElemO(self,0); 12086 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, 0), NULL); 12087 terminateO(self); 12088 12089 } 12090 12091 12092 void getAtNDupSmallBytesSmallArrayT(void) { 12093 12094 smallBytest* r; 12095 smallArrayt *self = allocG(rtSmallArrayt); 12096 smallArrayt *r2; 12097 12098 // add elements to self 12099 r2 = self->f->pushInt(self, 1); 12100 ck_assert_ptr_ne(r2, null); 12101 createSmallBytes(e2); 12102 r2 = self->f->pushSmallBytes(self, &e2); 12103 ck_assert_ptr_ne(r2, null); 12104 r2 = self->f->pushInt(self, 3); 12105 ck_assert_ptr_ne(r2, null); 12106 createSmallBytes(e4); 12107 r2 = self->f->pushSmallBytes(self, &e4); 12108 ck_assert_ptr_ne(r2, null); 12109 12110 // positive index 12111 r = self->f->getAtNDupSmallBytes(self,1); 12112 ck_assert_ptr_ne(r, null); 12113 char *s = toStringO(r); 12114 terminateO(r); 12115 ck_assert_str_eq(s, "[]"); 12116 free(s); 12117 s = toStringO(self); 12118 ck_assert_str_eq(s, "[1,[],3,[]]"); 12119 free(s); 12120 // negative index 12121 r = self->f->getAtNDupSmallBytes(self,-1); 12122 ck_assert_ptr_ne(r, null); 12123 s = toStringO(r); 12124 terminateO(r); 12125 ck_assert_str_eq(s, "[]"); 12126 free(s); 12127 s = toStringO(self); 12128 ck_assert_str_eq(s, "[1,[],3,[]]"); 12129 free(s); 12130 // wrong object type 12131 createSmallInt(I); 12132 setValG(&I, 11); 12133 r2 = self->f->pushSmallInt(self, &I); 12134 r = self->f->getAtNDupSmallBytes(self,-1); 12135 ck_assert_ptr_eq(r, NULL); 12136 s = toStringO(self); 12137 ck_assert_str_eq(s, "[1,[],3,[],11]"); 12138 free(s); 12139 // wrong object type of another user class 12140 // User classes are stored in containers transparently 12141 createAllocateSmallInt(ip); 12142 ip->type = "anothertype"; 12143 setValG(ip, 11); 12144 r2 = self->f->push(self, (baset*)ip); 12145 ck_assert_ptr_ne(r2, null); 12146 r = self->f->getAtNDupSmallBytes(self,-1); 12147 ck_assert_ptr_eq(r, NULL); 12148 s = toStringO(self); 12149 ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]"); 12150 free(s); 12151 // index outside 12152 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, 20), NULL); 12153 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, -7), NULL); 12154 // empty list 12155 emptyO(self); 12156 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, 0), NULL); 12157 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, -1), NULL); 12158 // get empty slot in array 12159 r2 = self->f->pushUndefined(self); 12160 ck_assert_ptr_ne(r2, null); 12161 delElemO(self,0); 12162 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, 0), NULL); 12163 terminateO(self); 12164 12165 } 12166 12167 12168 void getAtNDupSmallDoubleSmallArrayT(void) { 12169 12170 smallDoublet* r; 12171 smallArrayt *self = allocG(rtSmallArrayt); 12172 smallArrayt *r2; 12173 12174 // add elements to self 12175 r2 = self->f->pushInt(self, 1); 12176 ck_assert_ptr_ne(r2, null); 12177 createSmallDouble(e2); 12178 r2 = self->f->pushSmallDouble(self, &e2); 12179 ck_assert_ptr_ne(r2, null); 12180 r2 = self->f->pushInt(self, 3); 12181 ck_assert_ptr_ne(r2, null); 12182 createSmallDouble(e4); 12183 r2 = self->f->pushSmallDouble(self, &e4); 12184 ck_assert_ptr_ne(r2, null); 12185 12186 // positive index 12187 r = self->f->getAtNDupSmallDouble(self,1); 12188 ck_assert_ptr_ne(r, null); 12189 char *s = toStringO(r); 12190 terminateO(r); 12191 ck_assert_str_eq(s, "0.000000e+00"); 12192 free(s); 12193 s = toStringO(self); 12194 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]"); 12195 free(s); 12196 // negative index 12197 r = self->f->getAtNDupSmallDouble(self,-1); 12198 ck_assert_ptr_ne(r, null); 12199 s = toStringO(r); 12200 terminateO(r); 12201 ck_assert_str_eq(s, "0.000000e+00"); 12202 free(s); 12203 s = toStringO(self); 12204 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]"); 12205 free(s); 12206 // wrong object type 12207 createSmallInt(I); 12208 setValG(&I, 11); 12209 r2 = self->f->pushSmallInt(self, &I); 12210 r = self->f->getAtNDupSmallDouble(self,-1); 12211 ck_assert_ptr_eq(r, NULL); 12212 s = toStringO(self); 12213 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11]"); 12214 free(s); 12215 // wrong object type of another user class 12216 // User classes are stored in containers transparently 12217 createAllocateSmallInt(ip); 12218 ip->type = "anothertype"; 12219 setValG(ip, 11); 12220 r2 = self->f->push(self, (baset*)ip); 12221 ck_assert_ptr_ne(r2, null); 12222 r = self->f->getAtNDupSmallDouble(self,-1); 12223 ck_assert_ptr_eq(r, NULL); 12224 s = toStringO(self); 12225 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11,\"<data container>\"]"); 12226 free(s); 12227 // index outside 12228 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, 20), NULL); 12229 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, -7), NULL); 12230 // empty list 12231 emptyO(self); 12232 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, 0), NULL); 12233 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, -1), NULL); 12234 // get empty slot in array 12235 r2 = self->f->pushUndefined(self); 12236 ck_assert_ptr_ne(r2, null); 12237 delElemO(self,0); 12238 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, 0), NULL); 12239 terminateO(self); 12240 12241 } 12242 12243 12244 void getAtNDupSmallIntSmallArrayT(void) { 12245 12246 smallIntt* r; 12247 smallArrayt *self = allocG(rtSmallArrayt); 12248 smallArrayt *r2; 12249 12250 // add elements to self 12251 r2 = self->f->pushBool(self, true); 12252 ck_assert_ptr_ne(r2, null); 12253 createSmallInt(e2); 12254 r2 = self->f->pushSmallInt(self, &e2); 12255 ck_assert_ptr_ne(r2, null); 12256 r2 = self->f->pushBool(self, true); 12257 ck_assert_ptr_ne(r2, null); 12258 createSmallInt(e4); 12259 r2 = self->f->pushSmallInt(self, &e4); 12260 ck_assert_ptr_ne(r2, null); 12261 12262 // positive index 12263 r = self->f->getAtNDupSmallInt(self,1); 12264 ck_assert_ptr_ne(r, null); 12265 char *s = toStringO(r); 12266 terminateO(r); 12267 ck_assert_str_eq(s, "0"); 12268 free(s); 12269 s = toStringO(self); 12270 ck_assert_str_eq(s, "[true,0,true,0]"); 12271 free(s); 12272 // negative index 12273 r = self->f->getAtNDupSmallInt(self,-1); 12274 ck_assert_ptr_ne(r, null); 12275 s = toStringO(r); 12276 terminateO(r); 12277 ck_assert_str_eq(s, "0"); 12278 free(s); 12279 s = toStringO(self); 12280 ck_assert_str_eq(s, "[true,0,true,0]"); 12281 free(s); 12282 // wrong object type 12283 createSmallDouble(I); 12284 setValG(&I, 11); 12285 r2 = self->f->pushSmallDouble(self, &I); 12286 r = self->f->getAtNDupSmallInt(self,-1); 12287 ck_assert_ptr_eq(r, NULL); 12288 s = toStringO(self); 12289 ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01]"); 12290 free(s); 12291 // wrong object type of another user class 12292 // User classes are stored in containers transparently 12293 createAllocateSmallInt(ip); 12294 ip->type = "anothertype"; 12295 setValG(ip, 11); 12296 r2 = self->f->push(self, (baset*)ip); 12297 ck_assert_ptr_ne(r2, null); 12298 r = self->f->getAtNDupSmallInt(self,-1); 12299 ck_assert_ptr_eq(r, NULL); 12300 s = toStringO(self); 12301 ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01,\"<data container>\"]"); 12302 free(s); 12303 // index outside 12304 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, 20), NULL); 12305 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, -7), NULL); 12306 // empty list 12307 emptyO(self); 12308 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, 0), NULL); 12309 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, -1), NULL); 12310 // get empty slot in array 12311 r2 = self->f->pushUndefined(self); 12312 ck_assert_ptr_ne(r2, null); 12313 delElemO(self,0); 12314 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, 0), NULL); 12315 terminateO(self); 12316 12317 } 12318 12319 12320 void getAtNDupSmallJsonSmallArrayT(void) { 12321 12322 smallJsont* r; 12323 smallArrayt *self = allocG(rtSmallArrayt); 12324 smallArrayt *r2; 12325 12326 // add elements to self 12327 r2 = self->f->pushInt(self, 1); 12328 ck_assert_ptr_ne(r2, null); 12329 createSmallJson(e2); 12330 r2 = self->f->pushSmallJson(self, &e2); 12331 ck_assert_ptr_ne(r2, null); 12332 r2 = self->f->pushInt(self, 3); 12333 ck_assert_ptr_ne(r2, null); 12334 createSmallJson(e4); 12335 r2 = self->f->pushSmallJson(self, &e4); 12336 ck_assert_ptr_ne(r2, null); 12337 12338 // positive index 12339 r = self->f->getAtNDupSmallJson(self,1); 12340 ck_assert_ptr_ne(r, null); 12341 char *s = toStringO(r); 12342 terminateO(r); 12343 ck_assert_str_eq(s, "{}"); 12344 free(s); 12345 s = toStringO(self); 12346 ck_assert_str_eq(s, "[1,{},3,{}]"); 12347 free(s); 12348 // negative index 12349 r = self->f->getAtNDupSmallJson(self,-1); 12350 ck_assert_ptr_ne(r, null); 12351 s = toStringO(r); 12352 terminateO(r); 12353 ck_assert_str_eq(s, "{}"); 12354 free(s); 12355 s = toStringO(self); 12356 ck_assert_str_eq(s, "[1,{},3,{}]"); 12357 free(s); 12358 // wrong object type 12359 createSmallBytes(I); 12360 r2 = self->f->pushSmallBytes(self, &I); 12361 r = self->f->getAtNDupSmallJson(self,-1); 12362 ck_assert_ptr_eq(r, NULL); 12363 s = toStringO(self); 12364 ck_assert_str_eq(s, "[1,{},3,{},[]]"); 12365 free(s); 12366 // wrong object type of another user class 12367 // User classes are stored in containers transparently 12368 createAllocateSmallInt(ip); 12369 ip->type = "anothertype"; 12370 setValG(ip, 11); 12371 r2 = self->f->push(self, (baset*)ip); 12372 ck_assert_ptr_ne(r2, null); 12373 r = self->f->getAtNDupSmallJson(self,-1); 12374 ck_assert_ptr_eq(r, NULL); 12375 s = toStringO(self); 12376 ck_assert_str_eq(s, "[1,{},3,{},[],\"<data container>\"]"); 12377 free(s); 12378 // index outside 12379 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, 20), NULL); 12380 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, -7), NULL); 12381 // empty list 12382 emptyO(self); 12383 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, 0), NULL); 12384 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, -1), NULL); 12385 // get empty slot in array 12386 r2 = self->f->pushUndefined(self); 12387 ck_assert_ptr_ne(r2, null); 12388 delElemO(self,0); 12389 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, 0), NULL); 12390 terminateO(self); 12391 12392 } 12393 12394 12395 void getAtNDupSmallStringSmallArrayT(void) { 12396 12397 smallStringt* r; 12398 smallArrayt *self = allocG(rtSmallArrayt); 12399 smallArrayt *r2; 12400 12401 // add elements to self 12402 r2 = self->f->pushInt(self, 1); 12403 ck_assert_ptr_ne(r2, null); 12404 createSmallString(e2); 12405 r2 = self->f->pushSmallString(self, &e2); 12406 ck_assert_ptr_ne(r2, null); 12407 r2 = self->f->pushInt(self, 3); 12408 ck_assert_ptr_ne(r2, null); 12409 createSmallString(e4); 12410 r2 = self->f->pushSmallString(self, &e4); 12411 ck_assert_ptr_ne(r2, null); 12412 12413 // positive index 12414 r = self->f->getAtNDupSmallString(self,1); 12415 ck_assert_ptr_ne(r, null); 12416 char *s = toStringO(r); 12417 terminateO(r); 12418 ck_assert_str_eq(s, ""); 12419 free(s); 12420 s = toStringO(self); 12421 ck_assert_str_eq(s, "[1,\"\",3,\"\"]"); 12422 free(s); 12423 // negative index 12424 r = self->f->getAtNDupSmallString(self,-1); 12425 ck_assert_ptr_ne(r, null); 12426 s = toStringO(r); 12427 terminateO(r); 12428 ck_assert_str_eq(s, ""); 12429 free(s); 12430 s = toStringO(self); 12431 ck_assert_str_eq(s, "[1,\"\",3,\"\"]"); 12432 free(s); 12433 // wrong object type 12434 createSmallInt(I); 12435 setValG(&I, 11); 12436 r2 = self->f->pushSmallInt(self, &I); 12437 r = self->f->getAtNDupSmallString(self,-1); 12438 ck_assert_ptr_eq(r, NULL); 12439 s = toStringO(self); 12440 ck_assert_str_eq(s, "[1,\"\",3,\"\",11]"); 12441 free(s); 12442 // wrong object type of another user class 12443 // User classes are stored in containers transparently 12444 createAllocateSmallInt(ip); 12445 ip->type = "anothertype"; 12446 setValG(ip, 11); 12447 r2 = self->f->push(self, (baset*)ip); 12448 ck_assert_ptr_ne(r2, null); 12449 r = self->f->getAtNDupSmallString(self,-1); 12450 ck_assert_ptr_eq(r, NULL); 12451 s = toStringO(self); 12452 ck_assert_str_eq(s, "[1,\"\",3,\"\",11,\"<data container>\"]"); 12453 free(s); 12454 // index outside 12455 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, 20), NULL); 12456 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, -7), NULL); 12457 // empty list 12458 emptyO(self); 12459 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, 0), NULL); 12460 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, -1), NULL); 12461 // get empty slot in array 12462 r2 = self->f->pushUndefined(self); 12463 ck_assert_ptr_ne(r2, null); 12464 delElemO(self,0); 12465 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, 0), NULL); 12466 terminateO(self); 12467 12468 } 12469 12470 12471 void getAtNDupVoidSmallArrayT(void) { 12472 12473 void* r; 12474 smallArrayt *self = allocG(rtSmallArrayt); 12475 smallArrayt *r2; 12476 12477 // add elements to self 12478 r2 = self->f->pushInt(self, 1); 12479 ck_assert_ptr_ne(r2, null); 12480 r2 = pushVoidSmallArrayG(self, &r); 12481 ck_assert_ptr_ne(r2, null); 12482 r2 = self->f->pushInt(self, 3); 12483 ck_assert_ptr_ne(r2, null); 12484 r2 = pushVoidSmallArrayG(self, &self); 12485 ck_assert_ptr_ne(r2, null); 12486 12487 // positive index 12488 r = self->f->getAtNDupVoid(self,1); 12489 // duplicate function is not set so the data is not duplicated 12490 ck_assert_ptr_eq(r, NULL); 12491 char *s = toStringO(self); 12492 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 12493 free(s); 12494 // negative index 12495 r = self->f->getAtNDupVoid(self,-1); 12496 // duplicate function is not set so the data is not duplicated 12497 ck_assert_ptr_eq(r, NULL); 12498 s = toStringO(self); 12499 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 12500 free(s); 12501 // wrong object type 12502 createSmallInt(I); 12503 setValG(&I, 11); 12504 r2 = self->f->pushSmallInt(self, &I); 12505 r = self->f->getAtNDupVoid(self,-1); 12506 ck_assert_ptr_eq(r, NULL); 12507 s = toStringO(self); 12508 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]"); 12509 free(s); 12510 // wrong object type of another user class 12511 // User classes are stored in containers transparently 12512 createAllocateSmallInt(ip); 12513 ip->type = "anothertype"; 12514 setValG(ip, 11); 12515 r2 = self->f->push(self, (baset*)ip); 12516 ck_assert_ptr_ne(r2, null); 12517 r = self->f->getAtNDupVoid(self,-1); 12518 ck_assert_ptr_eq(r, NULL); 12519 s = toStringO(self); 12520 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]"); 12521 free(s); 12522 // index outside 12523 ck_assert_ptr_eq(self->f->getAtNDupVoid(self, 20), NULL); 12524 ck_assert_ptr_eq(self->f->getAtNDupVoid(self, -7), NULL); 12525 // empty list 12526 emptyO(self); 12527 ck_assert_ptr_eq(self->f->getAtNDupVoid(self, 0), NULL); 12528 ck_assert_ptr_eq(self->f->getAtNDupVoid(self, -1), NULL); 12529 terminateO(self); 12530 12531 } 12532 12533 12534 void getAtNDupSmallContainerSmallArrayT(void) { 12535 12536 smallContainert* r; 12537 smallArrayt *self = allocG(rtSmallArrayt); 12538 smallArrayt *r2; 12539 12540 // add elements to self 12541 r2 = self->f->pushInt(self, 1); 12542 ck_assert_ptr_ne(r2, null); 12543 createSmallContainer(e2); 12544 r2 = self->f->pushSmallContainer(self, &e2); 12545 ck_assert_ptr_ne(r2, null); 12546 r2 = self->f->pushInt(self, 3); 12547 ck_assert_ptr_ne(r2, null); 12548 createSmallContainer(e4); 12549 r2 = self->f->pushSmallContainer(self, &e4); 12550 ck_assert_ptr_ne(r2, null); 12551 12552 // positive index 12553 r = self->f->getAtNDupSmallContainer(self,1); 12554 ck_assert_ptr_ne(r, null); 12555 char *s = toStringO(r); 12556 terminateO(r); 12557 ck_assert_str_eq(s, "<data smallContainer>"); 12558 free(s); 12559 s = toStringO(self); 12560 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 12561 free(s); 12562 // negative index 12563 r = self->f->getAtNDupSmallContainer(self,-1); 12564 ck_assert_ptr_ne(r, null); 12565 s = toStringO(r); 12566 terminateO(r); 12567 ck_assert_str_eq(s, "<data smallContainer>"); 12568 free(s); 12569 s = toStringO(self); 12570 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 12571 free(s); 12572 // wrong object type 12573 createSmallInt(I); 12574 setValG(&I, 11); 12575 r2 = self->f->pushSmallInt(self, &I); 12576 r = self->f->getAtNDupSmallContainer(self,-1); 12577 ck_assert_ptr_eq(r, NULL); 12578 s = toStringO(self); 12579 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]"); 12580 free(s); 12581 // wrong object type of another user class 12582 // User classes are stored in containers transparently 12583 createAllocateSmallInt(ip); 12584 ip->type = "anothertype"; 12585 setValG(ip, 11); 12586 r2 = self->f->push(self, (baset*)ip); 12587 ck_assert_ptr_ne(r2, null); 12588 r = self->f->getAtNDupSmallContainer(self,-1); 12589 ck_assert_ptr_eq(r, NULL); 12590 s = toStringO(self); 12591 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]"); 12592 free(s); 12593 // index outside 12594 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, 20), NULL); 12595 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, -7), NULL); 12596 // empty list 12597 emptyO(self); 12598 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, 0), NULL); 12599 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, -1), NULL); 12600 // get empty slot in array 12601 r2 = self->f->pushUndefined(self); 12602 ck_assert_ptr_ne(r2, null); 12603 delElemO(self,0); 12604 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, 0), NULL); 12605 terminateO(self); 12606 12607 } 12608 12609 12610 void setAtSmallArrayT(void) { 12611 12612 smallArrayt* r; 12613 smallArrayt *self = allocG(rtSmallArrayt); 12614 baset *value; 12615 12616 // add elements to self 12617 r = self->f->pushInt(self, 1); 12618 ck_assert_ptr_ne(r, null); 12619 r = self->f->pushInt(self, 2); 12620 ck_assert_ptr_ne(r, null); 12621 r = self->f->pushInt(self, 3); 12622 ck_assert_ptr_ne(r, null); 12623 r = self->f->pushInt(self, 4); 12624 ck_assert_ptr_ne(r, null); 12625 12626 // positive index 12627 value = (baset*)allocSmallInt(123); 12628 r = self->f->setAt(self, 1, value); 12629 ck_assert_ptr_ne(r, null); 12630 finishO(value); 12631 char *s = toStringO(r); 12632 ck_assert_str_eq(s, "[1,123,3,4]"); 12633 free(s); 12634 // negative index 12635 value = (baset*)allocSmallInt(234); 12636 r = self->f->setAt(self, -1, value); 12637 ck_assert_ptr_ne(r, null); 12638 finishO(value); 12639 s = toStringO(r); 12640 ck_assert_str_eq(s, "[1,123,3,234]"); 12641 free(s); 12642 // undefined object 12643 value = (baset*)allocUndefined(); 12644 r = self->f->setAt(self, -1, value); 12645 ck_assert_ptr_ne(r, null); 12646 finishO(value); 12647 s = toStringO(r); 12648 ck_assert_str_eq(s, "[1,123,3,null]"); 12649 free(s); 12650 // container 12651 createAllocateSmallContainer(c); 12652 r = self->f->setAt(self, -1, (baset*)c); 12653 ck_assert_ptr_ne(r, null); 12654 finishO(c); 12655 s = toStringO(r); 12656 ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]"); 12657 free(s); 12658 // base object in container 12659 createAllocateSmallInt(I); 12660 setValG(I, 11); 12661 I->type = "anothertype"; 12662 r = self->f->setAt(self, -1, (baset*)I); 12663 ck_assert_ptr_ne(r, null); 12664 s = toStringO(r); 12665 ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]"); 12666 free(s); 12667 // index outside 12668 value = (baset*)allocSmallInt(123); 12669 ck_assert_ptr_eq(self->f->setAt(self, 20, value), NULL); 12670 ck_assert_ptr_eq(self->f->setAt(self, -8, value), NULL); 12671 // empty list 12672 emptyO(self); 12673 ck_assert_ptr_eq(self->f->setAt(self, 0, value), NULL); 12674 ck_assert_ptr_eq(self->f->setAt(self, -1, value), NULL); 12675 terminateO(value); 12676 // NULL value 12677 ck_assert_ptr_eq(self->f->setAt(self, 0, NULL), NULL); 12678 terminateO(self); 12679 12680 } 12681 12682 12683 void setAtUndefinedSmallArrayT(void) { 12684 12685 smallArrayt* r; 12686 smallArrayt *self = allocG(rtSmallArrayt); 12687 12688 // add elements to self 12689 r = self->f->pushInt(self, 1); 12690 ck_assert_ptr_ne(r, null); 12691 r = self->f->pushInt(self, 2); 12692 ck_assert_ptr_ne(r, null); 12693 r = self->f->pushInt(self, 3); 12694 ck_assert_ptr_ne(r, null); 12695 r = self->f->pushInt(self, 4); 12696 ck_assert_ptr_ne(r, null); 12697 12698 // positive index 12699 r = self->f->setAtUndefined(self, 1); 12700 ck_assert_ptr_ne(r, null); 12701 char *s = toStringO(r); 12702 ck_assert_str_eq(s, "[1,null,3,4]"); 12703 free(s); 12704 // negative index 12705 r = self->f->setAtUndefined(self, -1); 12706 ck_assert_ptr_ne(r, null); 12707 s = toStringO(r); 12708 ck_assert_str_eq(s, "[1,null,3,null]"); 12709 free(s); 12710 // index outside 12711 ck_assert_ptr_eq(self->f->setAtUndefined(self, 20), NULL); 12712 ck_assert_ptr_eq(self->f->setAtUndefined(self, -8), NULL); 12713 // empty list 12714 emptyO(self); 12715 ck_assert_ptr_eq(self->f->setAtUndefined(self, 0), NULL); 12716 ck_assert_ptr_eq(self->f->setAtUndefined(self, -1), NULL); 12717 terminateO(self); 12718 12719 } 12720 12721 12722 void setAtBoolSmallArrayT(void) { 12723 12724 smallArrayt* r; 12725 smallArrayt *self = allocG(rtSmallArrayt); 12726 12727 // add elements to self 12728 r = self->f->pushInt(self, 1); 12729 ck_assert_ptr_ne(r, null); 12730 r = self->f->pushInt(self, 2); 12731 ck_assert_ptr_ne(r, null); 12732 r = self->f->pushInt(self, 3); 12733 ck_assert_ptr_ne(r, null); 12734 r = self->f->pushInt(self, 4); 12735 ck_assert_ptr_ne(r, null); 12736 12737 // positive index 12738 r = self->f->setAtBool(self, 1, true); 12739 ck_assert_ptr_ne(r, null); 12740 char *s = toStringO(r); 12741 ck_assert_str_eq(s, "[1,true,3,4]"); 12742 free(s); 12743 // negative index 12744 r = self->f->setAtBool(self, -1, true); 12745 ck_assert_ptr_ne(r, null); 12746 s = toStringO(r); 12747 ck_assert_str_eq(s, "[1,true,3,true]"); 12748 free(s); 12749 // index outside 12750 ck_assert_ptr_eq(self->f->setAtBool(self, 20, true), NULL); 12751 ck_assert_ptr_eq(self->f->setAtBool(self, -8, true), NULL); 12752 // empty list 12753 emptyO(self); 12754 ck_assert_ptr_eq(self->f->setAtBool(self, 0, true), NULL); 12755 ck_assert_ptr_eq(self->f->setAtBool(self, -1, true), NULL); 12756 terminateO(self); 12757 12758 } 12759 12760 12761 void setAtDoubleSmallArrayT(void) { 12762 12763 smallArrayt* r; 12764 smallArrayt *self = allocG(rtSmallArrayt); 12765 12766 // add elements to self 12767 r = self->f->pushInt(self, 1); 12768 ck_assert_ptr_ne(r, null); 12769 r = self->f->pushInt(self, 2); 12770 ck_assert_ptr_ne(r, null); 12771 r = self->f->pushInt(self, 3); 12772 ck_assert_ptr_ne(r, null); 12773 r = self->f->pushInt(self, 4); 12774 ck_assert_ptr_ne(r, null); 12775 12776 // positive index 12777 r = self->f->setAtDouble(self, 1, 12); 12778 ck_assert_ptr_ne(r, null); 12779 char *s = toStringO(r); 12780 ck_assert_str_eq(s, "[1,1.200000e+01,3,4]"); 12781 free(s); 12782 // negative index 12783 r = self->f->setAtDouble(self, -1, 14); 12784 ck_assert_ptr_ne(r, null); 12785 s = toStringO(r); 12786 ck_assert_str_eq(s, "[1,1.200000e+01,3,1.400000e+01]"); 12787 free(s); 12788 // index outside 12789 ck_assert_ptr_eq(self->f->setAtDouble(self, 20, 1), NULL); 12790 ck_assert_ptr_eq(self->f->setAtDouble(self, -8, 1), NULL); 12791 // empty list 12792 emptyO(self); 12793 ck_assert_ptr_eq(self->f->setAtDouble(self, 0, 1), NULL); 12794 ck_assert_ptr_eq(self->f->setAtDouble(self, -1, 1), NULL); 12795 terminateO(self); 12796 12797 } 12798 12799 12800 void setAtIntSmallArrayT(void) { 12801 12802 smallArrayt* r; 12803 smallArrayt *self = allocG(rtSmallArrayt); 12804 12805 // add elements to self 12806 r = self->f->pushInt(self, 1); 12807 ck_assert_ptr_ne(r, null); 12808 r = self->f->pushInt(self, 2); 12809 ck_assert_ptr_ne(r, null); 12810 r = self->f->pushInt(self, 3); 12811 ck_assert_ptr_ne(r, null); 12812 r = self->f->pushInt(self, 4); 12813 ck_assert_ptr_ne(r, null); 12814 12815 // positive index 12816 r = self->f->setAtInt(self, 1, 12); 12817 ck_assert_ptr_ne(r, null); 12818 char *s = toStringO(r); 12819 ck_assert_str_eq(s, "[1,12,3,4]"); 12820 free(s); 12821 // negative index 12822 r = self->f->setAtInt(self, -1, 14); 12823 ck_assert_ptr_ne(r, null); 12824 s = toStringO(r); 12825 ck_assert_str_eq(s, "[1,12,3,14]"); 12826 free(s); 12827 // index outside 12828 ck_assert_ptr_eq(self->f->setAtInt(self, 20, 1), NULL); 12829 ck_assert_ptr_eq(self->f->setAtInt(self, -8, 1), NULL); 12830 // empty list 12831 emptyO(self); 12832 ck_assert_ptr_eq(self->f->setAtInt(self, 0, 1), NULL); 12833 ck_assert_ptr_eq(self->f->setAtInt(self, -1, 1), NULL); 12834 terminateO(self); 12835 12836 } 12837 12838 12839 void setAtSSmallArrayT(void) { 12840 12841 smallArrayt* r; 12842 smallArrayt *self = allocG(rtSmallArrayt); 12843 12844 // add elements to self 12845 r = self->f->pushInt(self, 1); 12846 ck_assert_ptr_ne(r, null); 12847 r = self->f->pushInt(self, 2); 12848 ck_assert_ptr_ne(r, null); 12849 r = self->f->pushInt(self, 3); 12850 ck_assert_ptr_ne(r, null); 12851 r = self->f->pushInt(self, 4); 12852 ck_assert_ptr_ne(r, null); 12853 12854 // positive index 12855 r = self->f->setAtS(self, 1, "a"); 12856 ck_assert_ptr_ne(r, null); 12857 char *s = toStringO(r); 12858 ck_assert_str_eq(s, "[1,\"a\",3,4]"); 12859 free(s); 12860 // negative index 12861 r = self->f->setAtS(self, -1, "b"); 12862 ck_assert_ptr_ne(r, null); 12863 s = toStringO(r); 12864 ck_assert_str_eq(s, "[1,\"a\",3,\"b\"]"); 12865 free(s); 12866 // NULL string 12867 r = self->f->setAtS(self, -1, NULL); 12868 ck_assert_ptr_eq(r, null); 12869 // index outside 12870 ck_assert_ptr_eq(self->f->setAtS(self, 20, ""), NULL); 12871 ck_assert_ptr_eq(self->f->setAtS(self, -8, ""), NULL); 12872 // empty list 12873 emptyO(self); 12874 ck_assert_ptr_eq(self->f->setAtS(self, 0, ""), NULL); 12875 ck_assert_ptr_eq(self->f->setAtS(self, -1, ""), NULL); 12876 terminateO(self); 12877 12878 } 12879 12880 12881 void setAtCharSmallArrayT(void) { 12882 12883 smallArrayt* r; 12884 smallArrayt *self = allocG(rtSmallArrayt); 12885 12886 // add elements to self 12887 r = self->f->pushInt(self, 1); 12888 ck_assert_ptr_ne(r, null); 12889 r = self->f->pushInt(self, 2); 12890 ck_assert_ptr_ne(r, null); 12891 r = self->f->pushInt(self, 3); 12892 ck_assert_ptr_ne(r, null); 12893 r = self->f->pushInt(self, 4); 12894 ck_assert_ptr_ne(r, null); 12895 12896 // positive index 12897 r = self->f->setAtChar(self, 1, 'a'); 12898 ck_assert_ptr_ne(r, null); 12899 char *s = toStringO(r); 12900 ck_assert_str_eq(s, "[1,\"a\",3,4]"); 12901 free(s); 12902 // negative index 12903 r = self->f->setAtChar(self, -1, 'b'); 12904 ck_assert_ptr_ne(r, null); 12905 s = toStringO(r); 12906 ck_assert_str_eq(s, "[1,\"a\",3,\"b\"]"); 12907 free(s); 12908 // index outside 12909 ck_assert_ptr_eq(self->f->setAtChar(self, 20, 'a'), NULL); 12910 ck_assert_ptr_eq(self->f->setAtChar(self, -8, 's'), NULL); 12911 // empty list 12912 emptyO(self); 12913 ck_assert_ptr_eq(self->f->setAtChar(self, 0, 'a'), NULL); 12914 ck_assert_ptr_eq(self->f->setAtChar(self, -1, 's'), NULL); 12915 terminateO(self); 12916 12917 } 12918 12919 12920 void setAtDictSmallArrayT(void) { 12921 12922 smallArrayt* r; 12923 smallArrayt *self = allocG(rtSmallArrayt); 12924 smallDictt *value; 12925 12926 // add elements to self 12927 r = self->f->pushInt(self, 1); 12928 ck_assert_ptr_ne(r, null); 12929 r = self->f->pushInt(self, 2); 12930 ck_assert_ptr_ne(r, null); 12931 r = self->f->pushInt(self, 3); 12932 ck_assert_ptr_ne(r, null); 12933 r = self->f->pushInt(self, 4); 12934 ck_assert_ptr_ne(r, null); 12935 12936 // positive index 12937 value = allocSmallDict(); 12938 r = self->f->setAtDict(self, 1, value); 12939 ck_assert_ptr_ne(r, null); 12940 finishO(value); 12941 char *s = toStringO(r); 12942 ck_assert_str_eq(s, "[1,{},3,4]"); 12943 free(s); 12944 // negative index 12945 value = allocSmallDict(); 12946 r = self->f->setAtDict(self, -1, value); 12947 ck_assert_ptr_ne(r, null); 12948 finishO(value); 12949 s = toStringO(r); 12950 ck_assert_str_eq(s, "[1,{},3,{}]"); 12951 free(s); 12952 // index outside 12953 value = allocSmallDict(); 12954 ck_assert_ptr_eq(self->f->setAtDict(self, 20, value), NULL); 12955 ck_assert_ptr_eq(self->f->setAtDict(self, -8, value), NULL); 12956 // empty list 12957 emptyO(self); 12958 ck_assert_ptr_eq(self->f->setAtDict(self, 0, value), NULL); 12959 ck_assert_ptr_eq(self->f->setAtDict(self, -1, value), NULL); 12960 terminateO(value); 12961 // non smallDict object 12962 value = (smallDictt*) allocSmallInt(2); 12963 r = self->f->setAtDict(self, 0, value); 12964 ck_assert_ptr_eq(r, null); 12965 terminateO(value); 12966 // NULL value 12967 ck_assert_ptr_eq(self->f->setAtDict(self, 0, NULL), NULL); 12968 terminateO(self); 12969 12970 } 12971 12972 12973 void setAtArraySmallArrayT(void) { 12974 12975 smallArrayt* r; 12976 smallArrayt *self = allocG(rtSmallArrayt); 12977 smallArrayt *value; 12978 12979 // add elements to self 12980 r = self->f->pushInt(self, 1); 12981 ck_assert_ptr_ne(r, null); 12982 r = self->f->pushInt(self, 2); 12983 ck_assert_ptr_ne(r, null); 12984 r = self->f->pushInt(self, 3); 12985 ck_assert_ptr_ne(r, null); 12986 r = self->f->pushInt(self, 4); 12987 ck_assert_ptr_ne(r, null); 12988 12989 // positive index 12990 value = allocSmallArray(); 12991 r = self->f->setAtArray(self, 1, value); 12992 ck_assert_ptr_ne(r, null); 12993 finishO(value); 12994 char *s = toStringO(r); 12995 ck_assert_str_eq(s, "[1,[],3,4]"); 12996 free(s); 12997 // negative index 12998 value = allocSmallArray(); 12999 r = self->f->setAtArray(self, -1, value); 13000 ck_assert_ptr_ne(r, null); 13001 finishO(value); 13002 s = toStringO(r); 13003 ck_assert_str_eq(s, "[1,[],3,[]]"); 13004 free(s); 13005 // index outside 13006 value = allocSmallArray(); 13007 ck_assert_ptr_eq(self->f->setAtArray(self, 20, value), NULL); 13008 ck_assert_ptr_eq(self->f->setAtArray(self, -8, value), NULL); 13009 // empty list 13010 emptyO(self); 13011 ck_assert_ptr_eq(self->f->setAtArray(self, 0, value), NULL); 13012 ck_assert_ptr_eq(self->f->setAtArray(self, -1, value), NULL); 13013 terminateO(value); 13014 // non smallArray object 13015 value = (smallArrayt*) allocSmallInt(2); 13016 r = self->f->setAtArray(self, 0, value); 13017 ck_assert_ptr_eq(r, null); 13018 terminateO(value); 13019 // NULL value 13020 ck_assert_ptr_eq(self->f->setAtArray(self, 0, NULL), NULL); 13021 terminateO(self); 13022 13023 } 13024 13025 13026 void setAtArraycSmallArrayT(void) { 13027 13028 smallArrayt* r; 13029 smallArrayt *self = allocG(rtSmallArrayt); 13030 char **value; 13031 13032 // add elements to self 13033 r = self->f->pushInt(self, 1); 13034 ck_assert_ptr_ne(r, null); 13035 r = self->f->pushInt(self, 2); 13036 ck_assert_ptr_ne(r, null); 13037 r = self->f->pushInt(self, 3); 13038 ck_assert_ptr_ne(r, null); 13039 r = self->f->pushInt(self, 4); 13040 ck_assert_ptr_ne(r, null); 13041 13042 // positive index 13043 value = listCreateS("a"); 13044 r = self->f->setAtArrayc(self, 1, value); 13045 ck_assert_ptr_ne(r, null); 13046 listFreeS(value); 13047 char *s = toStringO(r); 13048 ck_assert_str_eq(s, "[1,[\"a\"],3,4]"); 13049 free(s); 13050 // negative index 13051 value = listCreateS("b"); 13052 r = self->f->setAtArrayc(self, -1, value); 13053 ck_assert_ptr_ne(r, null); 13054 listFreeS(value); 13055 s = toStringO(r); 13056 ck_assert_str_eq(s, "[1,[\"a\"],3,[\"b\"]]"); 13057 free(s); 13058 // index outside 13059 value = (char**)r; 13060 ck_assert_ptr_eq(self->f->setAtArrayc(self, 20, value), NULL); 13061 ck_assert_ptr_eq(self->f->setAtArrayc(self, -8, value), NULL); 13062 // empty list 13063 emptyO(self); 13064 ck_assert_ptr_eq(self->f->setAtArrayc(self, 0, value), NULL); 13065 ck_assert_ptr_eq(self->f->setAtArrayc(self, -1, value), NULL); 13066 // NULL value 13067 ck_assert_ptr_eq(self->f->setAtArrayc(self, 0, NULL), NULL); 13068 terminateO(self); 13069 13070 } 13071 13072 13073 void setAtSmallBoolSmallArrayT(void) { 13074 13075 smallArrayt* r; 13076 smallArrayt *self = allocG(rtSmallArrayt); 13077 smallBoolt *value; 13078 13079 // add elements to self 13080 r = self->f->pushInt(self, 1); 13081 ck_assert_ptr_ne(r, null); 13082 r = self->f->pushInt(self, 2); 13083 ck_assert_ptr_ne(r, null); 13084 r = self->f->pushInt(self, 3); 13085 ck_assert_ptr_ne(r, null); 13086 r = self->f->pushInt(self, 4); 13087 ck_assert_ptr_ne(r, null); 13088 13089 // positive index 13090 value = allocSmallBool(true); 13091 r = self->f->setAtSmallBool(self, 1, value); 13092 ck_assert_ptr_ne(r, null); 13093 finishO(value); 13094 char *s = toStringO(r); 13095 ck_assert_str_eq(s, "[1,true,3,4]"); 13096 free(s); 13097 // negative index 13098 value = allocSmallBool(true); 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,true]"); 13104 free(s); 13105 // empty smallBool 13106 value = allocSmallBool(true); 13107 freeO(value); 13108 r = self->f->setAtSmallBool(self, -1, value); 13109 ck_assert_ptr_ne(r, null); 13110 finishO(value); 13111 s = toStringO(r); 13112 ck_assert_str_eq(s, "[1,true,3,false]"); 13113 free(s); 13114 // index outside 13115 value = allocSmallBool(true); 13116 ck_assert_ptr_eq(self->f->setAtSmallBool(self, 20, value), NULL); 13117 ck_assert_ptr_eq(self->f->setAtSmallBool(self, -8, value), NULL); 13118 // empty list 13119 emptyO(self); 13120 ck_assert_ptr_eq(self->f->setAtSmallBool(self, 0, value), NULL); 13121 ck_assert_ptr_eq(self->f->setAtSmallBool(self, -1, value), NULL); 13122 terminateO(value); 13123 // non smallBool object 13124 value = (smallBoolt*) allocSmallInt(2); 13125 r = self->f->setAtSmallBool(self, 0, value); 13126 ck_assert_ptr_eq(r, null); 13127 terminateO(value); 13128 // NULL value 13129 ck_assert_ptr_eq(self->f->setAtSmallBool(self, 0, NULL), NULL); 13130 terminateO(self); 13131 13132 } 13133 13134 13135 void setAtSmallBytesSmallArrayT(void) { 13136 13137 smallArrayt* r; 13138 smallArrayt *self = allocG(rtSmallArrayt); 13139 smallBytest *value; 13140 13141 // add elements to self 13142 r = self->f->pushInt(self, 1); 13143 ck_assert_ptr_ne(r, null); 13144 r = self->f->pushInt(self, 2); 13145 ck_assert_ptr_ne(r, null); 13146 r = self->f->pushInt(self, 3); 13147 ck_assert_ptr_ne(r, null); 13148 r = self->f->pushInt(self, 4); 13149 ck_assert_ptr_ne(r, null); 13150 13151 // positive index 13152 value = allocSmallBytes(NULL, 0); 13153 r = self->f->setAtSmallBytes(self, 1, value); 13154 ck_assert_ptr_ne(r, null); 13155 finishO(value); 13156 char *s = toStringO(r); 13157 ck_assert_str_eq(s, "[1,[],3,4]"); 13158 free(s); 13159 // negative index 13160 value = allocSmallBytes(NULL, 0); 13161 r = self->f->setAtSmallBytes(self, -1, value); 13162 ck_assert_ptr_ne(r, null); 13163 finishO(value); 13164 s = toStringO(r); 13165 ck_assert_str_eq(s, "[1,[],3,[]]"); 13166 free(s); 13167 // index outside 13168 value = allocSmallBytes(NULL, 0); 13169 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, 20, value), NULL); 13170 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, -5, value), NULL); 13171 // empty list 13172 emptyO(self); 13173 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, 0, value), NULL); 13174 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, -1, value), NULL); 13175 terminateO(value); 13176 // non smallBytes object 13177 value = (smallBytest*) allocSmallInt(2); 13178 r = self->f->setAtSmallBytes(self, 0, value); 13179 ck_assert_ptr_eq(r, null); 13180 terminateO(value); 13181 // NULL value 13182 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, 0, NULL), NULL); 13183 terminateO(self); 13184 13185 } 13186 13187 13188 void setAtSmallDoubleSmallArrayT(void) { 13189 13190 smallArrayt* r; 13191 smallArrayt *self = allocG(rtSmallArrayt); 13192 smallDoublet *value; 13193 13194 // add elements to self 13195 r = self->f->pushInt(self, 1); 13196 ck_assert_ptr_ne(r, null); 13197 r = self->f->pushInt(self, 2); 13198 ck_assert_ptr_ne(r, null); 13199 r = self->f->pushInt(self, 3); 13200 ck_assert_ptr_ne(r, null); 13201 r = self->f->pushInt(self, 4); 13202 ck_assert_ptr_ne(r, null); 13203 13204 // positive index 13205 value = allocSmallDouble(5); 13206 r = self->f->setAtSmallDouble(self, 1, value); 13207 ck_assert_ptr_ne(r, null); 13208 finishO(value); 13209 char *s = toStringO(r); 13210 ck_assert_str_eq(s, "[1,5.000000e+00,3,4]"); 13211 free(s); 13212 // negative index 13213 value = allocSmallDouble(6); 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,6.000000e+00]"); 13219 free(s); 13220 // empty smallDouble 13221 value = allocSmallDouble(0); 13222 freeO(value); 13223 r = self->f->setAtSmallDouble(self, -1, value); 13224 ck_assert_ptr_ne(r, null); 13225 finishO(value); 13226 s = toStringO(r); 13227 ck_assert_str_eq(s, "[1,5.000000e+00,3,0.000000e+00]"); 13228 free(s); 13229 // index outside 13230 value = allocSmallDouble(1); 13231 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, 20, value), NULL); 13232 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, -8, value), NULL); 13233 // empty list 13234 emptyO(self); 13235 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, 0, value), NULL); 13236 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, -1, value), NULL); 13237 terminateO(value); 13238 // non smallDouble object 13239 value = (smallDoublet*) allocSmallInt(2); 13240 r = self->f->setAtSmallDouble(self, 0, value); 13241 ck_assert_ptr_eq(r, null); 13242 terminateO(value); 13243 // NULL value 13244 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, 0, NULL), NULL); 13245 terminateO(self); 13246 13247 } 13248 13249 13250 void setAtSmallIntSmallArrayT(void) { 13251 13252 smallArrayt* r; 13253 smallArrayt *self = allocG(rtSmallArrayt); 13254 smallIntt *value; 13255 13256 // add elements to self 13257 r = self->f->pushInt(self, 1); 13258 ck_assert_ptr_ne(r, null); 13259 r = self->f->pushInt(self, 2); 13260 ck_assert_ptr_ne(r, null); 13261 r = self->f->pushInt(self, 3); 13262 ck_assert_ptr_ne(r, null); 13263 r = self->f->pushInt(self, 4); 13264 ck_assert_ptr_ne(r, null); 13265 13266 // positive index 13267 value = allocSmallInt(5); 13268 r = self->f->setAtSmallInt(self, 1, value); 13269 ck_assert_ptr_ne(r, null); 13270 finishO(value); 13271 char *s = toStringO(r); 13272 ck_assert_str_eq(s, "[1,5,3,4]"); 13273 free(s); 13274 // negative index 13275 value = allocSmallInt(6); 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,6]"); 13281 free(s); 13282 // empty SmallInt 13283 value = allocSmallInt(0); 13284 freeO(value); 13285 r = self->f->setAtSmallInt(self, -1, value); 13286 ck_assert_ptr_ne(r, null); 13287 finishO(value); 13288 s = toStringO(r); 13289 ck_assert_str_eq(s, "[1,5,3,0]"); 13290 free(s); 13291 // index outside 13292 value = allocSmallInt(1); 13293 ck_assert_ptr_eq(self->f->setAtSmallInt(self, 20, value), NULL); 13294 ck_assert_ptr_eq(self->f->setAtSmallInt(self, -8, value), NULL); 13295 // empty list 13296 emptyO(self); 13297 ck_assert_ptr_eq(self->f->setAtSmallInt(self, 0, value), NULL); 13298 ck_assert_ptr_eq(self->f->setAtSmallInt(self, -1, value), NULL); 13299 terminateO(value); 13300 // non smallInt object 13301 value = (smallIntt*) allocSmallBool(true); 13302 r = self->f->setAtSmallInt(self, 0, value); 13303 ck_assert_ptr_eq(r, null); 13304 terminateO(value); 13305 // NULL value 13306 ck_assert_ptr_eq(self->f->setAtSmallInt(self, 0, NULL), NULL); 13307 terminateO(self); 13308 13309 } 13310 13311 13312 void setAtSmallJsonSmallArrayT(void) { 13313 13314 smallArrayt* r; 13315 smallArrayt *self = allocG(rtSmallArrayt); 13316 smallJsont *value; 13317 13318 // add elements to self 13319 r = self->f->pushInt(self, 1); 13320 ck_assert_ptr_ne(r, null); 13321 r = self->f->pushInt(self, 2); 13322 ck_assert_ptr_ne(r, null); 13323 r = self->f->pushInt(self, 3); 13324 ck_assert_ptr_ne(r, null); 13325 r = self->f->pushInt(self, 4); 13326 ck_assert_ptr_ne(r, null); 13327 13328 // positive index 13329 value = allocSmallJson(); 13330 r = self->f->setAtSmallJson(self, 1, value); 13331 ck_assert_ptr_ne(r, null); 13332 finishO(value); 13333 char *s = toStringO(r); 13334 ck_assert_str_eq(s, "[1,{},3,4]"); 13335 free(s); 13336 // negative index 13337 value = allocSmallJson(); 13338 r = self->f->setAtSmallJson(self, -1, value); 13339 ck_assert_ptr_ne(r, null); 13340 finishO(value); 13341 s = toStringO(r); 13342 ck_assert_str_eq(s, "[1,{},3,{}]"); 13343 free(s); 13344 // index outside 13345 value = allocSmallJson(); 13346 ck_assert_ptr_eq(self->f->setAtSmallJson(self, 20, value), NULL); 13347 ck_assert_ptr_eq(self->f->setAtSmallJson(self, -8, value), NULL); 13348 // empty list 13349 emptyO(self); 13350 ck_assert_ptr_eq(self->f->setAtSmallJson(self, 0, value), NULL); 13351 ck_assert_ptr_eq(self->f->setAtSmallJson(self, -1, value), NULL); 13352 terminateO(value); 13353 // non smallJson object 13354 value = (smallJsont*) allocSmallInt(2); 13355 r = self->f->setAtSmallJson(self, 0, value); 13356 ck_assert_ptr_eq(r, null); 13357 terminateO(value); 13358 // NULL value 13359 ck_assert_ptr_eq(self->f->setAtSmallJson(self, 0, NULL), NULL); 13360 terminateO(self); 13361 13362 } 13363 13364 13365 void setAtSmallStringSmallArrayT(void) { 13366 13367 smallArrayt* r; 13368 smallArrayt *self = allocG(rtSmallArrayt); 13369 smallStringt *value; 13370 13371 // add elements to self 13372 r = self->f->pushInt(self, 1); 13373 ck_assert_ptr_ne(r, null); 13374 r = self->f->pushInt(self, 2); 13375 ck_assert_ptr_ne(r, null); 13376 r = self->f->pushInt(self, 3); 13377 ck_assert_ptr_ne(r, null); 13378 r = self->f->pushInt(self, 4); 13379 ck_assert_ptr_ne(r, null); 13380 13381 // positive index 13382 initiateAllocateSmallString(&value); 13383 r = self->f->setAtSmallString(self, 1, value); 13384 ck_assert_ptr_ne(r, null); 13385 finishO(value); 13386 char *s = toStringO(r); 13387 ck_assert_str_eq(s, "[1,\"\",3,4]"); 13388 free(s); 13389 // negative index 13390 value = allocSmallString("a"); 13391 r = self->f->setAtSmallString(self, -1, value); 13392 ck_assert_ptr_ne(r, null); 13393 finishO(value); 13394 s = toStringO(r); 13395 ck_assert_str_eq(s, "[1,\"\",3,\"a\"]"); 13396 free(s); 13397 // index outside 13398 value = allocSmallString("asd"); 13399 ck_assert_ptr_eq(self->f->setAtSmallString(self, 20, value), NULL); 13400 ck_assert_ptr_eq(self->f->setAtSmallString(self, -8, value), NULL); 13401 // empty list 13402 emptyO(self); 13403 ck_assert_ptr_eq(self->f->setAtSmallString(self, 0, value), NULL); 13404 ck_assert_ptr_eq(self->f->setAtSmallString(self, -1, value), NULL); 13405 terminateO(value); 13406 // non smallString object 13407 value = (smallStringt*) allocSmallInt(2); 13408 r = self->f->setAtSmallString(self, 0, value); 13409 ck_assert_ptr_eq(r, null); 13410 terminateO(value); 13411 // NULL value 13412 ck_assert_ptr_eq(self->f->setAtSmallString(self, 0, NULL), NULL); 13413 terminateO(self); 13414 13415 } 13416 13417 13418 void setAtSmallContainerSmallArrayT(void) { 13419 13420 smallArrayt* r; 13421 smallArrayt *self = allocG(rtSmallArrayt); 13422 smallContainert *value; 13423 13424 // add elements to self 13425 r = self->f->pushInt(self, 1); 13426 ck_assert_ptr_ne(r, null); 13427 r = self->f->pushInt(self, 2); 13428 ck_assert_ptr_ne(r, null); 13429 r = self->f->pushInt(self, 3); 13430 ck_assert_ptr_ne(r, null); 13431 r = self->f->pushInt(self, 4); 13432 ck_assert_ptr_ne(r, null); 13433 13434 // positive index 13435 initiateAllocateSmallContainer(&value); 13436 r = self->f->setAtSmallContainer(self, 1, value); 13437 ck_assert_ptr_ne(r, null); 13438 finishO(value); 13439 char *s = toStringO(r); 13440 ck_assert_str_eq(s, "[1,\"<data container>\",3,4]"); 13441 free(s); 13442 // negative index 13443 initiateAllocateSmallContainer(&value); 13444 r = self->f->setAtSmallContainer(self, -1, value); 13445 ck_assert_ptr_ne(r, null); 13446 finishO(value); 13447 s = toStringO(r); 13448 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 13449 free(s); 13450 // index outside 13451 initiateAllocateSmallContainer(&value); 13452 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, 20, value), NULL); 13453 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, -8, value), NULL); 13454 // empty list 13455 emptyO(self); 13456 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, 0, value), NULL); 13457 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, -1, value), NULL); 13458 terminateO(value); 13459 // non smallContainer object 13460 value = (smallContainert*) allocSmallInt(2); 13461 r = self->f->setAtSmallContainer(self, 0, value); 13462 ck_assert_ptr_eq(r, null); 13463 terminateO(value); 13464 // NULL value 13465 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, 0, NULL), NULL); 13466 terminateO(self); 13467 13468 } 13469 13470 13471 void setAtNFreeSmallArrayT(void) { 13472 13473 smallArrayt* r; 13474 smallArrayt *self = allocG(rtSmallArrayt); 13475 baset *value; 13476 13477 // add elements to self 13478 r = self->f->pushInt(self, 1); 13479 ck_assert_ptr_ne(r, null); 13480 r = self->f->pushInt(self, 2); 13481 ck_assert_ptr_ne(r, null); 13482 r = self->f->pushInt(self, 3); 13483 ck_assert_ptr_ne(r, null); 13484 r = self->f->pushInt(self, 4); 13485 ck_assert_ptr_ne(r, null); 13486 13487 // positive index 13488 value = (baset*)allocSmallInt(123); 13489 r = self->f->setAtNFree(self, 1, value); 13490 ck_assert_ptr_ne(r, null); 13491 char *s = toStringO(r); 13492 ck_assert_str_eq(s, "[1,123,3,4]"); 13493 free(s); 13494 // negative index 13495 value = (baset*)allocSmallInt(234); 13496 r = self->f->setAtNFree(self, -1, value); 13497 ck_assert_ptr_ne(r, null); 13498 s = toStringO(r); 13499 ck_assert_str_eq(s, "[1,123,3,234]"); 13500 free(s); 13501 // undefined object 13502 value = (baset*)allocUndefined(); 13503 r = self->f->setAtNFree(self, -1, value); 13504 ck_assert_ptr_ne(r, null); 13505 s = toStringO(r); 13506 ck_assert_str_eq(s, "[1,123,3,null]"); 13507 free(s); 13508 // container 13509 createAllocateSmallContainer(c); 13510 r = self->f->setAtNFree(self, -1, (baset*)c); 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 // base object in container 13516 createAllocateSmallInt(I); 13517 setValG(I, 11); 13518 I->type = "anothertype"; 13519 r = self->f->setAtNFree(self, -1, (baset*)I); 13520 ck_assert_ptr_ne(r, null); 13521 s = toStringO(r); 13522 ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]"); 13523 free(s); 13524 // index outside 13525 value = (baset*)allocSmallInt(123); 13526 ck_assert_ptr_eq(self->f->setAtNFree(self, 20, value), NULL); 13527 ck_assert_ptr_eq(self->f->setAtNFree(self, -8, value), NULL); 13528 // empty list 13529 emptyO(self); 13530 ck_assert_ptr_eq(self->f->setAtNFree(self, 0, value), NULL); 13531 ck_assert_ptr_eq(self->f->setAtNFree(self, -1, value), NULL); 13532 terminateO(value); 13533 // NULL value 13534 ck_assert_ptr_eq(self->f->setAtNFree(self, 0, NULL), NULL); 13535 terminateO(self); 13536 13537 } 13538 13539 13540 void setAtNFreeUndefinedSmallArrayT(void) { 13541 13542 smallArrayt* r; 13543 smallArrayt *self = allocG(rtSmallArrayt); 13544 undefinedt *value = NULL; 13545 13546 13547 // add elements to self 13548 r = self->f->pushInt(self, 1); 13549 ck_assert_ptr_ne(r, null); 13550 r = self->f->pushInt(self, 2); 13551 ck_assert_ptr_ne(r, null); 13552 r = self->f->pushInt(self, 3); 13553 ck_assert_ptr_ne(r, null); 13554 r = self->f->pushInt(self, 4); 13555 ck_assert_ptr_ne(r, null); 13556 13557 // positive index 13558 value = allocUndefined(); 13559 r = self->f->setAtNFreeUndefined(self, 1, value); 13560 ck_assert_ptr_ne(r, null); 13561 char *s = toStringO(r); 13562 ck_assert_str_eq(s, "[1,null,3,4]"); 13563 free(s); 13564 // negative index 13565 value = allocUndefined(); 13566 r = self->f->setAtNFreeUndefined(self, -1, value); 13567 ck_assert_ptr_ne(r, null); 13568 s = toStringO(r); 13569 ck_assert_str_eq(s, "[1,null,3,null]"); 13570 free(s); 13571 // index outside 13572 value = allocUndefined(); 13573 ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, 20, value), NULL); 13574 terminateO(value); 13575 13576 value = allocUndefined(); 13577 ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, -8, value), NULL); 13578 terminateO(value); 13579 13580 // empty list 13581 emptyO(self); 13582 value = allocUndefined(); 13583 ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, 0, value), NULL); 13584 terminateO(value); 13585 13586 value = allocUndefined(); 13587 ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, -1, value), NULL); 13588 terminateO(value); 13589 13590 terminateO(self); 13591 13592 } 13593 13594 13595 void setAtNFreeSSmallArrayT(void) { 13596 13597 smallArrayt* r; 13598 smallArrayt *self = allocG(rtSmallArrayt); 13599 13600 // add elements to self 13601 r = self->f->pushInt(self, 1); 13602 ck_assert_ptr_ne(r, null); 13603 r = self->f->pushInt(self, 2); 13604 ck_assert_ptr_ne(r, null); 13605 r = self->f->pushInt(self, 3); 13606 ck_assert_ptr_ne(r, null); 13607 r = self->f->pushInt(self, 4); 13608 ck_assert_ptr_ne(r, null); 13609 13610 // positive index 13611 r = self->f->setAtNFreeS(self, 1, strdup("a")); 13612 ck_assert_ptr_ne(r, null); 13613 char *s = toStringO(r); 13614 ck_assert_str_eq(s, "[1,\"a\",3,4]"); 13615 free(s); 13616 // negative index 13617 r = self->f->setAtNFreeS(self, -1, strdup("b")); 13618 ck_assert_ptr_ne(r, null); 13619 s = toStringO(r); 13620 ck_assert_str_eq(s, "[1,\"a\",3,\"b\"]"); 13621 free(s); 13622 // NULL string 13623 r = self->f->setAtNFreeS(self, -1, NULL); 13624 ck_assert_ptr_eq(r, null); 13625 // index outside 13626 ck_assert_ptr_eq(self->f->setAtNFreeS(self, 20, ""), NULL); 13627 ck_assert_ptr_eq(self->f->setAtNFreeS(self, -8, ""), NULL); 13628 // empty list 13629 emptyO(self); 13630 ck_assert_ptr_eq(self->f->setAtNFreeS(self, 0, ""), NULL); 13631 ck_assert_ptr_eq(self->f->setAtNFreeS(self, -1, ""), NULL); 13632 terminateO(self); 13633 13634 } 13635 13636 13637 void setAtNFreeDictSmallArrayT(void) { 13638 13639 smallArrayt* r; 13640 smallArrayt *self = allocG(rtSmallArrayt); 13641 smallDictt *value; 13642 13643 // add elements to self 13644 r = self->f->pushInt(self, 1); 13645 ck_assert_ptr_ne(r, null); 13646 r = self->f->pushInt(self, 2); 13647 ck_assert_ptr_ne(r, null); 13648 r = self->f->pushInt(self, 3); 13649 ck_assert_ptr_ne(r, null); 13650 r = self->f->pushInt(self, 4); 13651 ck_assert_ptr_ne(r, null); 13652 13653 // positive index 13654 value = allocSmallDict(); 13655 r = self->f->setAtNFreeDict(self, 1, value); 13656 ck_assert_ptr_ne(r, null); 13657 char *s = toStringO(r); 13658 ck_assert_str_eq(s, "[1,{},3,4]"); 13659 free(s); 13660 // negative index 13661 value = allocSmallDict(); 13662 r = self->f->setAtNFreeDict(self, -1, value); 13663 ck_assert_ptr_ne(r, null); 13664 s = toStringO(r); 13665 ck_assert_str_eq(s, "[1,{},3,{}]"); 13666 free(s); 13667 // index outside 13668 value = allocSmallDict(); 13669 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, 20, value), NULL); 13670 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, -8, value), NULL); 13671 // empty list 13672 emptyO(self); 13673 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, 0, value), NULL); 13674 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, -1, value), NULL); 13675 terminateO(value); 13676 // NULL value 13677 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, 0, NULL), NULL); 13678 terminateO(self); 13679 13680 } 13681 13682 13683 void setAtNFreeArraySmallArrayT(void) { 13684 13685 smallArrayt* r; 13686 smallArrayt *self = allocG(rtSmallArrayt); 13687 smallArrayt *value; 13688 13689 // add elements to self 13690 r = self->f->pushInt(self, 1); 13691 ck_assert_ptr_ne(r, null); 13692 r = self->f->pushInt(self, 2); 13693 ck_assert_ptr_ne(r, null); 13694 r = self->f->pushInt(self, 3); 13695 ck_assert_ptr_ne(r, null); 13696 r = self->f->pushInt(self, 4); 13697 ck_assert_ptr_ne(r, null); 13698 13699 // positive index 13700 value = allocSmallArray(); 13701 r = self->f->setAtNFreeArray(self, 1, value); 13702 ck_assert_ptr_ne(r, null); 13703 char *s = toStringO(r); 13704 ck_assert_str_eq(s, "[1,[],3,4]"); 13705 free(s); 13706 // negative index 13707 value = allocSmallArray(); 13708 r = self->f->setAtNFreeArray(self, -1, value); 13709 ck_assert_ptr_ne(r, null); 13710 s = toStringO(r); 13711 ck_assert_str_eq(s, "[1,[],3,[]]"); 13712 free(s); 13713 // index outside 13714 value = allocSmallArray(); 13715 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, 20, value), NULL); 13716 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, -8, value), NULL); 13717 // empty list 13718 emptyO(self); 13719 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, 0, value), NULL); 13720 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, -1, value), NULL); 13721 terminateO(value); 13722 // NULL value 13723 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, 0, NULL), NULL); 13724 terminateO(self); 13725 13726 } 13727 13728 13729 void setAtNFreeArraycSmallArrayT(void) { 13730 13731 smallArrayt* r; 13732 smallArrayt *self = allocG(rtSmallArrayt); 13733 char **value; 13734 13735 // add elements to self 13736 r = self->f->pushInt(self, 1); 13737 ck_assert_ptr_ne(r, null); 13738 r = self->f->pushInt(self, 2); 13739 ck_assert_ptr_ne(r, null); 13740 r = self->f->pushInt(self, 3); 13741 ck_assert_ptr_ne(r, null); 13742 r = self->f->pushInt(self, 4); 13743 ck_assert_ptr_ne(r, null); 13744 13745 // positive index 13746 value = listCreateS("a"); 13747 r = self->f->setAtNFreeArrayc(self, 1, value); 13748 ck_assert_ptr_ne(r, null); 13749 char *s = toStringO(r); 13750 ck_assert_str_eq(s, "[1,[\"a\"],3,4]"); 13751 free(s); 13752 // negative index 13753 value = listCreateS("b"); 13754 r = self->f->setAtNFreeArrayc(self, -1, value); 13755 ck_assert_ptr_ne(r, null); 13756 s = toStringO(r); 13757 ck_assert_str_eq(s, "[1,[\"a\"],3,[\"b\"]]"); 13758 free(s); 13759 // index outside 13760 value = (char**)r; 13761 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, 20, value), NULL); 13762 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, -8, value), NULL); 13763 // empty list 13764 emptyO(self); 13765 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, 0, value), NULL); 13766 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, -1, value), NULL); 13767 // NULL value 13768 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, 0, NULL), NULL); 13769 terminateO(self); 13770 13771 } 13772 13773 13774 void setAtNFreeSmallBoolSmallArrayT(void) { 13775 13776 smallArrayt* r; 13777 smallArrayt *self = allocG(rtSmallArrayt); 13778 smallBoolt *value; 13779 13780 // add elements to self 13781 r = self->f->pushInt(self, 1); 13782 ck_assert_ptr_ne(r, null); 13783 r = self->f->pushInt(self, 2); 13784 ck_assert_ptr_ne(r, null); 13785 r = self->f->pushInt(self, 3); 13786 ck_assert_ptr_ne(r, null); 13787 r = self->f->pushInt(self, 4); 13788 ck_assert_ptr_ne(r, null); 13789 13790 // positive index 13791 value = allocSmallBool(true); 13792 r = self->f->setAtNFreeSmallBool(self, 1, value); 13793 ck_assert_ptr_ne(r, null); 13794 char *s = toStringO(r); 13795 ck_assert_str_eq(s, "[1,true,3,4]"); 13796 free(s); 13797 // negative index 13798 value = allocSmallBool(true); 13799 r = self->f->setAtNFreeSmallBool(self, -1, value); 13800 ck_assert_ptr_ne(r, null); 13801 s = toStringO(r); 13802 ck_assert_str_eq(s, "[1,true,3,true]"); 13803 free(s); 13804 // index outside 13805 value = allocSmallBool(true); 13806 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, 20, value), NULL); 13807 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, -8, value), NULL); 13808 // empty list 13809 emptyO(self); 13810 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, 0, value), NULL); 13811 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, -1, value), NULL); 13812 terminateO(value); 13813 // NULL value 13814 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, 0, NULL), NULL); 13815 terminateO(self); 13816 13817 } 13818 13819 13820 void setAtNFreeSmallBytesSmallArrayT(void) { 13821 13822 smallArrayt* r; 13823 smallArrayt *self = allocG(rtSmallArrayt); 13824 smallBytest *value; 13825 13826 // add elements to self 13827 r = self->f->pushInt(self, 1); 13828 ck_assert_ptr_ne(r, null); 13829 r = self->f->pushInt(self, 2); 13830 ck_assert_ptr_ne(r, null); 13831 r = self->f->pushInt(self, 3); 13832 ck_assert_ptr_ne(r, null); 13833 r = self->f->pushInt(self, 4); 13834 ck_assert_ptr_ne(r, null); 13835 13836 // positive index 13837 value = allocSmallBytes(NULL, 0); 13838 r = self->f->setAtNFreeSmallBytes(self, 1, value); 13839 ck_assert_ptr_ne(r, null); 13840 char *s = toStringO(r); 13841 ck_assert_str_eq(s, "[1,[],3,4]"); 13842 free(s); 13843 // negative index 13844 value = allocSmallBytes(NULL, 0); 13845 r = self->f->setAtNFreeSmallBytes(self, -1, value); 13846 ck_assert_ptr_ne(r, null); 13847 s = toStringO(r); 13848 ck_assert_str_eq(s, "[1,[],3,[]]"); 13849 free(s); 13850 // index outside 13851 value = allocSmallBytes(NULL, 0); 13852 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, 20, value), NULL); 13853 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, -5, value), NULL); 13854 // empty list 13855 emptyO(self); 13856 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, 0, value), NULL); 13857 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, -1, value), NULL); 13858 terminateO(value); 13859 // NULL value 13860 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, 0, NULL), NULL); 13861 terminateO(self); 13862 13863 } 13864 13865 13866 void setAtNFreeSmallDoubleSmallArrayT(void) { 13867 13868 smallArrayt* r; 13869 smallArrayt *self = allocG(rtSmallArrayt); 13870 smallDoublet *value; 13871 13872 // add elements to self 13873 r = self->f->pushInt(self, 1); 13874 ck_assert_ptr_ne(r, null); 13875 r = self->f->pushInt(self, 2); 13876 ck_assert_ptr_ne(r, null); 13877 r = self->f->pushInt(self, 3); 13878 ck_assert_ptr_ne(r, null); 13879 r = self->f->pushInt(self, 4); 13880 ck_assert_ptr_ne(r, null); 13881 13882 // positive index 13883 value = allocSmallDouble(5); 13884 r = self->f->setAtNFreeSmallDouble(self, 1, value); 13885 ck_assert_ptr_ne(r, null); 13886 char *s = toStringO(r); 13887 ck_assert_str_eq(s, "[1,5.000000e+00,3,4]"); 13888 free(s); 13889 // negative index 13890 value = allocSmallDouble(6); 13891 r = self->f->setAtNFreeSmallDouble(self, -1, value); 13892 ck_assert_ptr_ne(r, null); 13893 s = toStringO(r); 13894 ck_assert_str_eq(s, "[1,5.000000e+00,3,6.000000e+00]"); 13895 free(s); 13896 // index outside 13897 value = allocSmallDouble(1); 13898 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, 20, value), NULL); 13899 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, -8, value), NULL); 13900 // empty list 13901 emptyO(self); 13902 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, 0, value), NULL); 13903 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, -1, value), NULL); 13904 terminateO(value); 13905 // NULL value 13906 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, 0, NULL), NULL); 13907 terminateO(self); 13908 13909 } 13910 13911 13912 void setAtNFreeSmallIntSmallArrayT(void) { 13913 13914 smallArrayt* r; 13915 smallArrayt *self = allocG(rtSmallArrayt); 13916 smallIntt *value; 13917 13918 // add elements to self 13919 r = self->f->pushInt(self, 1); 13920 ck_assert_ptr_ne(r, null); 13921 r = self->f->pushInt(self, 2); 13922 ck_assert_ptr_ne(r, null); 13923 r = self->f->pushInt(self, 3); 13924 ck_assert_ptr_ne(r, null); 13925 r = self->f->pushInt(self, 4); 13926 ck_assert_ptr_ne(r, null); 13927 13928 // positive index 13929 value = allocSmallInt(5); 13930 r = self->f->setAtNFreeSmallInt(self, 1, value); 13931 ck_assert_ptr_ne(r, null); 13932 char *s = toStringO(r); 13933 ck_assert_str_eq(s, "[1,5,3,4]"); 13934 free(s); 13935 // negative index 13936 value = allocSmallInt(6); 13937 r = self->f->setAtNFreeSmallInt(self, -1, value); 13938 ck_assert_ptr_ne(r, null); 13939 s = toStringO(r); 13940 ck_assert_str_eq(s, "[1,5,3,6]"); 13941 free(s); 13942 // index outside 13943 value = allocSmallInt(1); 13944 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, 20, value), NULL); 13945 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, -8, value), NULL); 13946 // empty list 13947 emptyO(self); 13948 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, 0, value), NULL); 13949 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, -1, value), NULL); 13950 terminateO(value); 13951 // NULL value 13952 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, 0, NULL), NULL); 13953 terminateO(self); 13954 13955 } 13956 13957 13958 void setAtNFreeSmallJsonSmallArrayT(void) { 13959 13960 smallArrayt* r; 13961 smallArrayt *self = allocG(rtSmallArrayt); 13962 smallJsont *value; 13963 13964 // add elements to self 13965 r = self->f->pushInt(self, 1); 13966 ck_assert_ptr_ne(r, null); 13967 r = self->f->pushInt(self, 2); 13968 ck_assert_ptr_ne(r, null); 13969 r = self->f->pushInt(self, 3); 13970 ck_assert_ptr_ne(r, null); 13971 r = self->f->pushInt(self, 4); 13972 ck_assert_ptr_ne(r, null); 13973 13974 // positive index 13975 value = allocSmallJson(); 13976 r = self->f->setAtNFreeSmallJson(self, 1, value); 13977 ck_assert_ptr_ne(r, null); 13978 char *s = toStringO(r); 13979 ck_assert_str_eq(s, "[1,{},3,4]"); 13980 free(s); 13981 // negative index 13982 value = allocSmallJson(); 13983 r = self->f->setAtNFreeSmallJson(self, -1, value); 13984 ck_assert_ptr_ne(r, null); 13985 s = toStringO(r); 13986 ck_assert_str_eq(s, "[1,{},3,{}]"); 13987 free(s); 13988 // index outside 13989 value = allocSmallJson(); 13990 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, 20, value), NULL); 13991 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, -8, value), NULL); 13992 // empty list 13993 emptyO(self); 13994 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, 0, value), NULL); 13995 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, -1, value), NULL); 13996 terminateO(value); 13997 // NULL value 13998 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, 0, NULL), NULL); 13999 terminateO(self); 14000 14001 } 14002 14003 14004 void setAtNFreeSmallStringSmallArrayT(void) { 14005 14006 smallArrayt* r; 14007 smallArrayt *self = allocG(rtSmallArrayt); 14008 smallStringt *value; 14009 14010 // add elements to self 14011 r = self->f->pushInt(self, 1); 14012 ck_assert_ptr_ne(r, null); 14013 r = self->f->pushInt(self, 2); 14014 ck_assert_ptr_ne(r, null); 14015 r = self->f->pushInt(self, 3); 14016 ck_assert_ptr_ne(r, null); 14017 r = self->f->pushInt(self, 4); 14018 ck_assert_ptr_ne(r, null); 14019 14020 // positive index 14021 initiateAllocateSmallString(&value); 14022 r = self->f->setAtNFreeSmallString(self, 1, value); 14023 ck_assert_ptr_ne(r, null); 14024 char *s = toStringO(r); 14025 ck_assert_str_eq(s, "[1,\"\",3,4]"); 14026 free(s); 14027 // negative index 14028 value = allocSmallString("a"); 14029 r = self->f->setAtNFreeSmallString(self, -1, value); 14030 ck_assert_ptr_ne(r, null); 14031 s = toStringO(r); 14032 ck_assert_str_eq(s, "[1,\"\",3,\"a\"]"); 14033 free(s); 14034 // index outside 14035 value = allocSmallString("asd"); 14036 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, 20, value), NULL); 14037 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, -8, value), NULL); 14038 // empty list 14039 emptyO(self); 14040 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, 0, value), NULL); 14041 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, -1, value), NULL); 14042 terminateO(value); 14043 // NULL value 14044 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, 0, NULL), NULL); 14045 terminateO(self); 14046 14047 } 14048 14049 14050 void setAtNFreeSmallContainerSmallArrayT(void) { 14051 14052 smallArrayt* r; 14053 smallArrayt *self = allocG(rtSmallArrayt); 14054 smallContainert *value; 14055 14056 // add elements to self 14057 r = self->f->pushInt(self, 1); 14058 ck_assert_ptr_ne(r, null); 14059 r = self->f->pushInt(self, 2); 14060 ck_assert_ptr_ne(r, null); 14061 r = self->f->pushInt(self, 3); 14062 ck_assert_ptr_ne(r, null); 14063 r = self->f->pushInt(self, 4); 14064 ck_assert_ptr_ne(r, null); 14065 14066 // positive index 14067 initiateAllocateSmallContainer(&value); 14068 r = self->f->setAtNFreeSmallContainer(self, 1, value); 14069 ck_assert_ptr_ne(r, null); 14070 char *s = toStringO(r); 14071 ck_assert_str_eq(s, "[1,\"<data container>\",3,4]"); 14072 free(s); 14073 // negative index 14074 initiateAllocateSmallContainer(&value); 14075 r = self->f->setAtNFreeSmallContainer(self, -1, value); 14076 ck_assert_ptr_ne(r, null); 14077 s = toStringO(r); 14078 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 14079 free(s); 14080 // index outside 14081 initiateAllocateSmallContainer(&value); 14082 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, 20, value), NULL); 14083 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, -8, value), NULL); 14084 // empty list 14085 emptyO(self); 14086 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, 0, value), NULL); 14087 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, -1, value), NULL); 14088 terminateO(value); 14089 // NULL value 14090 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, 0, NULL), NULL); 14091 terminateO(self); 14092 14093 } 14094 14095 14096 void setPAtDictSmallArrayT(void) { 14097 14098 smallArrayt* r; 14099 smallArrayt *self = allocG(rtSmallArrayt); 14100 smallDictt *value; 14101 14102 // add elements to self 14103 r = self->f->pushInt(self, 1); 14104 ck_assert_ptr_ne(r, null); 14105 r = self->f->pushInt(self, 2); 14106 ck_assert_ptr_ne(r, null); 14107 r = self->f->pushInt(self, 3); 14108 ck_assert_ptr_ne(r, null); 14109 r = self->f->pushInt(self, 4); 14110 ck_assert_ptr_ne(r, null); 14111 14112 // positive index 14113 value = allocSmallDict(); 14114 r = self->f->setAtDict(self, 1, value); 14115 ck_assert_ptr_ne(r, null); 14116 value->f->setInt(value, "a", 1); 14117 r = self->f->setPAtDict(self, 1, value); 14118 ck_assert_ptr_ne(r, null); 14119 finishO(value); 14120 char *s = toStringO(r); 14121 ck_assert_str_eq(s, "[1,{\"a\":1},3,4]"); 14122 free(s); 14123 // negative index 14124 value = allocSmallDict(); 14125 r = self->f->setAtDict(self, -1, value); 14126 ck_assert_ptr_ne(r, null); 14127 value->f->setInt(value, "a", 2); 14128 r = self->f->setPAtDict(self, -1, value); 14129 ck_assert_ptr_ne(r, null); 14130 finishO(value); 14131 s = toStringO(r); 14132 ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]"); 14133 free(s); 14134 // empty smallDict 14135 value = allocSmallDict(); 14136 r = self->f->setPAtDict(self, -1, value); 14137 ck_assert_ptr_eq(r, null); 14138 terminateO(value); 14139 // non smallDict object 14140 value = (smallDictt*) allocSmallInt(2); 14141 r = self->f->setPAtDict(self, 0, value); 14142 ck_assert_ptr_eq(r, null); 14143 terminateO(value); 14144 // index outside 14145 value = allocSmallDict(); 14146 ck_assert_ptr_eq(self->f->setPAtDict(self, 20, value), NULL); 14147 ck_assert_ptr_eq(self->f->setPAtDict(self, -8, value), NULL); 14148 // empty list 14149 emptyO(self); 14150 ck_assert_ptr_eq(self->f->setPAtDict(self, 0, value), NULL); 14151 ck_assert_ptr_eq(self->f->setPAtDict(self, -1, value), NULL); 14152 terminateO(value); 14153 // NULL value 14154 ck_assert_ptr_eq(self->f->setPAtDict(self, 0, NULL), NULL); 14155 terminateO(self); 14156 14157 } 14158 14159 14160 void setPAtArraySmallArrayT(void) { 14161 14162 smallArrayt* r; 14163 smallArrayt *self = allocG(rtSmallArrayt); 14164 smallArrayt *value; 14165 14166 // add elements to self 14167 r = self->f->pushInt(self, 1); 14168 ck_assert_ptr_ne(r, null); 14169 r = self->f->pushInt(self, 2); 14170 ck_assert_ptr_ne(r, null); 14171 r = self->f->pushInt(self, 3); 14172 ck_assert_ptr_ne(r, null); 14173 r = self->f->pushInt(self, 4); 14174 ck_assert_ptr_ne(r, null); 14175 14176 // positive index 14177 value = allocSmallArray(); 14178 r = self->f->setAtArray(self, 1, value); 14179 ck_assert_ptr_ne(r, null); 14180 value->f->pushInt(value, 1); 14181 r = self->f->setPAtArray(self, 1, value); 14182 ck_assert_ptr_ne(r, null); 14183 finishO(value); 14184 char *s = toStringO(r); 14185 ck_assert_str_eq(s, "[1,[1],3,4]"); 14186 free(s); 14187 // negative index 14188 value = allocSmallArray(); 14189 r = self->f->setAtArray(self, -1, value); 14190 ck_assert_ptr_ne(r, null); 14191 value->f->pushInt(value, 2); 14192 r = self->f->setPAtArray(self, -1, value); 14193 ck_assert_ptr_ne(r, null); 14194 finishO(value); 14195 s = toStringO(r); 14196 ck_assert_str_eq(s, "[1,[1],3,[2]]"); 14197 free(s); 14198 // empty smallArray 14199 value = allocSmallArray(); 14200 r = self->f->setPAtArray(self, -1, value); 14201 ck_assert_ptr_eq(r, null); 14202 terminateO(value); 14203 // non smallArray object 14204 value = (smallArrayt*) allocSmallInt(2); 14205 r = self->f->setPAtArray(self, 0, value); 14206 ck_assert_ptr_eq(r, null); 14207 terminateO(value); 14208 // index outside 14209 value = allocSmallArray(); 14210 ck_assert_ptr_eq(self->f->setPAtArray(self, 20, value), NULL); 14211 ck_assert_ptr_eq(self->f->setPAtArray(self, -8, value), NULL); 14212 // empty list 14213 emptyO(self); 14214 ck_assert_ptr_eq(self->f->setPAtArray(self, 0, value), NULL); 14215 ck_assert_ptr_eq(self->f->setPAtArray(self, -1, value), NULL); 14216 terminateO(value); 14217 // NULL value 14218 ck_assert_ptr_eq(self->f->setPAtArray(self, 0, NULL), NULL); 14219 terminateO(self); 14220 14221 } 14222 14223 14224 void setPAtSmallJsonSmallArrayT(void) { 14225 14226 smallArrayt* r; 14227 smallArrayt *self = allocG(rtSmallArrayt); 14228 smallJsont *value; 14229 14230 // add elements to self 14231 r = self->f->pushInt(self, 1); 14232 ck_assert_ptr_ne(r, null); 14233 r = self->f->pushInt(self, 2); 14234 ck_assert_ptr_ne(r, null); 14235 r = self->f->pushInt(self, 3); 14236 ck_assert_ptr_ne(r, null); 14237 r = self->f->pushInt(self, 4); 14238 ck_assert_ptr_ne(r, null); 14239 14240 // positive index 14241 value = allocSmallJson(); 14242 r = self->f->setAtSmallJson(self, 1, value); 14243 ck_assert_ptr_ne(r, null); 14244 value->f->setInt(value, "a", 1); 14245 r = self->f->setPAtSmallJson(self, 1, value); 14246 ck_assert_ptr_ne(r, null); 14247 finishO(value); 14248 char *s = toStringO(r); 14249 ck_assert_str_eq(s, "[1,{\"a\":1},3,4]"); 14250 free(s); 14251 // negative index 14252 value = allocSmallJson(); 14253 r = self->f->setAtSmallJson(self, -1, value); 14254 ck_assert_ptr_ne(r, null); 14255 value->f->setInt(value, "a", 2); 14256 r = self->f->setPAtSmallJson(self, -1, value); 14257 ck_assert_ptr_ne(r, null); 14258 finishO(value); 14259 s = toStringO(r); 14260 ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]"); 14261 free(s); 14262 // empty smallJson 14263 value = allocSmallJson(); 14264 r = self->f->setPAtSmallJson(self, -1, value); 14265 ck_assert_ptr_eq(r, null); 14266 terminateO(value); 14267 // non smallJson object 14268 value = (smallJsont*) allocSmallInt(2); 14269 r = self->f->setPAtSmallJson(self, 0, value); 14270 ck_assert_ptr_eq(r, null); 14271 terminateO(value); 14272 // index outside 14273 value = allocSmallJson(); 14274 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, 20, value), NULL); 14275 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, -8, value), NULL); 14276 // empty list 14277 emptyO(self); 14278 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, 0, value), NULL); 14279 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, -1, value), NULL); 14280 terminateO(value); 14281 // NULL value 14282 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, 0, NULL), NULL); 14283 terminateO(self); 14284 14285 } 14286 14287 14288 void setPAtSmallStringSmallArrayT(void) { 14289 14290 smallArrayt* r; 14291 smallArrayt *self = allocG(rtSmallArrayt); 14292 smallStringt *value; 14293 14294 // add elements to self 14295 r = self->f->pushInt(self, 1); 14296 ck_assert_ptr_ne(r, null); 14297 r = self->f->pushInt(self, 2); 14298 ck_assert_ptr_ne(r, null); 14299 r = self->f->pushInt(self, 3); 14300 ck_assert_ptr_ne(r, null); 14301 r = self->f->pushInt(self, 4); 14302 ck_assert_ptr_ne(r, null); 14303 14304 // positive index 14305 initiateAllocateSmallString(&value); 14306 r = self->f->setAtSmallString(self, 1, value); 14307 ck_assert_ptr_ne(r, null); 14308 value->f->appendS(value, "1"); 14309 r = self->f->setPAtSmallString(self, 1, value); 14310 ck_assert_ptr_ne(r, null); 14311 finishO(value); 14312 char *s = toStringO(r); 14313 ck_assert_str_eq(s, "[1,\"1\",3,4]"); 14314 free(s); 14315 // negative index 14316 value = allocSmallString("a"); 14317 r = self->f->setAtSmallString(self, -1, value); 14318 ck_assert_ptr_ne(r, null); 14319 value->f->appendS(value, "2"); 14320 r = self->f->setPAtSmallString(self, -1, value); 14321 ck_assert_ptr_ne(r, null); 14322 finishO(value); 14323 s = toStringO(r); 14324 ck_assert_str_eq(s, "[1,\"1\",3,\"a2\"]"); 14325 free(s); 14326 // empty SmallString 14327 value = allocSmallString(""); 14328 freeO(value); 14329 r = self->f->setPAtSmallString(self, -1, value); 14330 ck_assert_ptr_eq(r, null); 14331 terminateO(value); 14332 // non smallString object 14333 value = (smallStringt*) allocSmallInt(2); 14334 r = self->f->setPAtSmallString(self, 0, value); 14335 ck_assert_ptr_eq(r, null); 14336 terminateO(value); 14337 // index outside 14338 value = allocSmallString("asd"); 14339 ck_assert_ptr_eq(self->f->setPAtSmallString(self, 20, value), NULL); 14340 ck_assert_ptr_eq(self->f->setPAtSmallString(self, -8, value), NULL); 14341 // empty list 14342 emptyO(self); 14343 ck_assert_ptr_eq(self->f->setPAtSmallString(self, 0, value), NULL); 14344 ck_assert_ptr_eq(self->f->setPAtSmallString(self, -1, value), NULL); 14345 terminateO(value); 14346 // NULL value 14347 ck_assert_ptr_eq(self->f->setPAtSmallString(self, 0, NULL), NULL); 14348 terminateO(self); 14349 14350 } 14351 14352 14353 void setPAtNFreeDictSmallArrayT(void) { 14354 14355 smallArrayt* r; 14356 smallArrayt *self = allocG(rtSmallArrayt); 14357 smallDictt *value; 14358 14359 // add elements to self 14360 r = self->f->pushInt(self, 1); 14361 ck_assert_ptr_ne(r, null); 14362 r = self->f->pushInt(self, 2); 14363 ck_assert_ptr_ne(r, null); 14364 r = self->f->pushInt(self, 3); 14365 ck_assert_ptr_ne(r, null); 14366 r = self->f->pushInt(self, 4); 14367 ck_assert_ptr_ne(r, null); 14368 14369 // positive index 14370 value = allocSmallDict(); 14371 r = self->f->setAtDict(self, 1, value); 14372 ck_assert_ptr_ne(r, null); 14373 value->f->setInt(value, "a", 1); 14374 r = self->f->setPAtNFreeDict(self, 1, value); 14375 ck_assert_ptr_ne(r, null); 14376 char *s = toStringO(r); 14377 ck_assert_str_eq(s, "[1,{\"a\":1},3,4]"); 14378 free(s); 14379 // negative index 14380 value = allocSmallDict(); 14381 r = self->f->setAtDict(self, -1, value); 14382 ck_assert_ptr_ne(r, null); 14383 value->f->setInt(value, "a", 2); 14384 r = self->f->setPAtNFreeDict(self, -1, value); 14385 ck_assert_ptr_ne(r, null); 14386 s = toStringO(r); 14387 ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]"); 14388 free(s); 14389 // empty smallDict 14390 value = allocSmallDict(); 14391 r = self->f->setPAtNFreeDict(self, -1, value); 14392 ck_assert_ptr_eq(r, null); 14393 terminateO(value); 14394 // non smallDict object 14395 value = (smallDictt*) allocSmallInt(2); 14396 r = self->f->setPAtNFreeDict(self, 0, value); 14397 ck_assert_ptr_eq(r, null); 14398 terminateO(value); 14399 // index outside 14400 value = allocSmallDict(); 14401 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, 20, value), NULL); 14402 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, -8, value), NULL); 14403 // empty list 14404 emptyO(self); 14405 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, 0, value), NULL); 14406 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, -1, value), NULL); 14407 terminateO(value); 14408 // NULL value 14409 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, 0, NULL), NULL); 14410 terminateO(self); 14411 14412 } 14413 14414 14415 void setPAtNFreeArraySmallArrayT(void) { 14416 14417 smallArrayt* r; 14418 smallArrayt *self = allocG(rtSmallArrayt); 14419 smallArrayt *value; 14420 14421 // add elements to self 14422 r = self->f->pushInt(self, 1); 14423 ck_assert_ptr_ne(r, null); 14424 r = self->f->pushInt(self, 2); 14425 ck_assert_ptr_ne(r, null); 14426 r = self->f->pushInt(self, 3); 14427 ck_assert_ptr_ne(r, null); 14428 r = self->f->pushInt(self, 4); 14429 ck_assert_ptr_ne(r, null); 14430 14431 // positive index 14432 value = allocSmallArray(); 14433 r = self->f->setAtArray(self, 1, value); 14434 ck_assert_ptr_ne(r, null); 14435 value->f->pushInt(value, 1); 14436 r = self->f->setPAtNFreeArray(self, 1, value); 14437 ck_assert_ptr_ne(r, null); 14438 char *s = toStringO(r); 14439 ck_assert_str_eq(s, "[1,[1],3,4]"); 14440 free(s); 14441 // negative index 14442 value = allocSmallArray(); 14443 r = self->f->setAtArray(self, -1, value); 14444 ck_assert_ptr_ne(r, null); 14445 value->f->pushInt(value, 2); 14446 r = self->f->setPAtNFreeArray(self, -1, value); 14447 ck_assert_ptr_ne(r, null); 14448 s = toStringO(r); 14449 ck_assert_str_eq(s, "[1,[1],3,[2]]"); 14450 free(s); 14451 // empty smallArray 14452 value = allocSmallArray(); 14453 r = self->f->setPAtNFreeArray(self, -1, value); 14454 ck_assert_ptr_eq(r, null); 14455 terminateO(value); 14456 // non smallArray object 14457 value = (smallArrayt*) allocSmallInt(2); 14458 r = self->f->setPAtNFreeArray(self, 0, value); 14459 ck_assert_ptr_eq(r, null); 14460 terminateO(value); 14461 // index outside 14462 value = allocSmallArray(); 14463 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, 20, value), NULL); 14464 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, -8, value), NULL); 14465 // empty list 14466 emptyO(self); 14467 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, 0, value), NULL); 14468 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, -1, value), NULL); 14469 terminateO(value); 14470 // NULL value 14471 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, 0, NULL), NULL); 14472 terminateO(self); 14473 14474 } 14475 14476 14477 void setPAtNFreeSmallJsonSmallArrayT(void) { 14478 14479 smallArrayt* r; 14480 smallArrayt *self = allocG(rtSmallArrayt); 14481 smallJsont *value; 14482 14483 // add elements to self 14484 r = self->f->pushInt(self, 1); 14485 ck_assert_ptr_ne(r, null); 14486 r = self->f->pushInt(self, 2); 14487 ck_assert_ptr_ne(r, null); 14488 r = self->f->pushInt(self, 3); 14489 ck_assert_ptr_ne(r, null); 14490 r = self->f->pushInt(self, 4); 14491 ck_assert_ptr_ne(r, null); 14492 14493 // positive index 14494 value = allocSmallJson(); 14495 r = self->f->setAtSmallJson(self, 1, value); 14496 ck_assert_ptr_ne(r, null); 14497 value->f->setInt(value, "a", 1); 14498 r = self->f->setPAtNFreeSmallJson(self, 1, value); 14499 ck_assert_ptr_ne(r, null); 14500 char *s = toStringO(r); 14501 ck_assert_str_eq(s, "[1,{\"a\":1},3,4]"); 14502 free(s); 14503 // negative index 14504 value = allocSmallJson(); 14505 r = self->f->setAtSmallJson(self, -1, value); 14506 ck_assert_ptr_ne(r, null); 14507 value->f->setInt(value, "a", 2); 14508 r = self->f->setPAtNFreeSmallJson(self, -1, value); 14509 ck_assert_ptr_ne(r, null); 14510 s = toStringO(r); 14511 ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]"); 14512 free(s); 14513 // empty smallJson 14514 value = allocSmallJson(); 14515 r = self->f->setPAtNFreeSmallJson(self, -1, value); 14516 ck_assert_ptr_eq(r, null); 14517 terminateO(value); 14518 // non smallJson object 14519 value = (smallJsont*) allocSmallInt(2); 14520 r = self->f->setPAtNFreeSmallJson(self, 0, value); 14521 ck_assert_ptr_eq(r, null); 14522 terminateO(value); 14523 // index outside 14524 value = allocSmallJson(); 14525 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, 20, value), NULL); 14526 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, -8, value), NULL); 14527 // empty list 14528 emptyO(self); 14529 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, 0, value), NULL); 14530 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, -1, value), NULL); 14531 terminateO(value); 14532 // NULL value 14533 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, 0, NULL), NULL); 14534 terminateO(self); 14535 14536 } 14537 14538 14539 void setPAtNFreeSmallStringSmallArrayT(void) { 14540 14541 smallArrayt* r; 14542 smallArrayt *self = allocG(rtSmallArrayt); 14543 smallStringt *value; 14544 14545 // add elements to self 14546 r = self->f->pushInt(self, 1); 14547 ck_assert_ptr_ne(r, null); 14548 r = self->f->pushInt(self, 2); 14549 ck_assert_ptr_ne(r, null); 14550 r = self->f->pushInt(self, 3); 14551 ck_assert_ptr_ne(r, null); 14552 r = self->f->pushInt(self, 4); 14553 ck_assert_ptr_ne(r, null); 14554 14555 // positive index 14556 initiateAllocateSmallString(&value); 14557 r = self->f->setAtSmallString(self, 1, value); 14558 ck_assert_ptr_ne(r, null); 14559 value->f->appendS(value, "1"); 14560 r = self->f->setPAtNFreeSmallString(self, 1, value); 14561 ck_assert_ptr_ne(r, null); 14562 char *s = toStringO(r); 14563 ck_assert_str_eq(s, "[1,\"1\",3,4]"); 14564 free(s); 14565 // negative index 14566 value = allocSmallString("a"); 14567 r = self->f->setAtSmallString(self, -1, value); 14568 ck_assert_ptr_ne(r, null); 14569 value->f->appendS(value, "2"); 14570 r = self->f->setPAtNFreeSmallString(self, -1, value); 14571 ck_assert_ptr_ne(r, null); 14572 s = toStringO(r); 14573 ck_assert_str_eq(s, "[1,\"1\",3,\"a2\"]"); 14574 free(s); 14575 // empty SmallString 14576 value = allocSmallString(""); 14577 freeO(value); 14578 r = self->f->setPAtNFreeSmallString(self, -1, value); 14579 ck_assert_ptr_eq(r, null); 14580 terminateO(value); 14581 // non smallString object 14582 value = (smallStringt*) allocSmallInt(2); 14583 r = self->f->setPAtNFreeSmallString(self, 0, value); 14584 ck_assert_ptr_eq(r, null); 14585 terminateO(value); 14586 // index outside 14587 value = allocSmallString("asd"); 14588 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, 20, value), NULL); 14589 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, -8, value), NULL); 14590 // empty list 14591 emptyO(self); 14592 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, 0, value), NULL); 14593 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, -1, value), NULL); 14594 terminateO(value); 14595 // NULL value 14596 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, 0, NULL), NULL); 14597 terminateO(self); 14598 14599 } 14600 14601 14602 void getNumSmallArrayT(void) { 14603 14604 double r; 14605 smallArrayt *self = allocG(rtSmallArrayt); 14606 smallArrayt *r2; 14607 14608 // add elements to self 14609 r2 = self->f->pushInt(self, 1); 14610 ck_assert_ptr_ne(r2, null); 14611 r2 = self->f->pushDouble(self, 2); 14612 ck_assert_ptr_ne(r2, null); 14613 r2 = self->f->pushInt(self, 3); 14614 ck_assert_ptr_ne(r2, null); 14615 r2 = self->f->pushInt(self, 4); 14616 ck_assert_ptr_ne(r2, null); 14617 14618 // positive index 14619 r = self->f->getNum(self,1); 14620 ck_assert(r==2); 14621 char *s = toStringO(self); 14622 ck_assert_str_eq(s, "[1,2.000000e+00,3,4]"); 14623 free(s); 14624 // negative index 14625 r = self->f->getNum(self,-1); 14626 ck_assert(r==4); 14627 s = toStringO(self); 14628 ck_assert_str_eq(s, "[1,2.000000e+00,3,4]"); 14629 free(s); 14630 // wrong object type of another user class 14631 // User classes are stored in containers transparently 14632 createAllocateSmallInt(ip); 14633 ip->type = "anothertype"; 14634 setValG(ip, 11); 14635 r2 = self->f->push(self, (baset*)ip); 14636 ck_assert_ptr_ne(r2, null); 14637 r = self->f->getNum(self,-1); 14638 ck_assert(!r); 14639 s = toStringO(self); 14640 ck_assert_str_eq(s, "[1,2.000000e+00,3,4,\"<data container>\"]"); 14641 free(s); 14642 // index outside 14643 ck_assert(!self->f->getNum(self, 20)); 14644 ck_assert(!self->f->getNum(self, -7)); 14645 // empty list 14646 emptyO(self); 14647 ck_assert(!self->f->getNum(self, 0)); 14648 ck_assert(!self->f->getNum(self, -1)); 14649 terminateO(self); 14650 14651 } 14652 14653 14654 void hasSmallArrayT(void) { 14655 14656 bool r; 14657 smallArrayt *self = allocG(rtSmallArrayt); 14658 baset *value = (baset*)allocSmallInt(1); 14659 14660 // has 14661 self->f->pushInt(self, 1); 14662 r = hasO(self, value); 14663 ck_assert(r); 14664 // not has 14665 emptyO(self); 14666 r = hasO(self, value); 14667 ck_assert(!r); 14668 // NULL value 14669 r = hasO(self, NULL); 14670 ck_assert(!r); 14671 terminateO(self); 14672 terminateO(value); 14673 14674 } 14675 14676 14677 void hasUndefinedSmallArrayT(void) { 14678 14679 bool r; 14680 smallArrayt *self = allocG(rtSmallArrayt); 14681 undefinedt *value = allocUndefined(); 14682 14683 // has 14684 self->f->pushUndefined(self); 14685 r = hasUndefinedO(self, value); 14686 ck_assert(r); 14687 // not has 14688 emptyO(self); 14689 r = hasUndefinedO(self, value); 14690 ck_assert(!r); 14691 // non undefined object 14692 terminateO(value); 14693 value = (undefinedt*) allocSmallInt(2); 14694 r = hasUndefinedO(self, value); 14695 ck_assert(!r); 14696 // NULL value 14697 r = hasUndefinedO(self, NULL); 14698 ck_assert(!r); 14699 terminateO(self); 14700 terminateO(value); 14701 14702 } 14703 14704 14705 void hasBoolSmallArrayT(void) { 14706 14707 bool r; 14708 smallArrayt *self = allocG(rtSmallArrayt); 14709 bool value = true; 14710 14711 // has 14712 self->f->pushBool(self, true); 14713 r = hasBoolO(self, value); 14714 ck_assert(r); 14715 // not has 14716 emptyO(self); 14717 r = hasBoolO(self, value); 14718 ck_assert(!r); 14719 terminateO(self); 14720 14721 } 14722 14723 14724 void hasDoubleSmallArrayT(void) { 14725 14726 bool r; 14727 smallArrayt *self = allocG(rtSmallArrayt); 14728 double value = 2; 14729 14730 // has 14731 self->f->pushDouble(self, 2); 14732 r = hasDoubleO(self, value); 14733 ck_assert(r); 14734 // not has 14735 emptyO(self); 14736 r = hasDoubleO(self, value); 14737 ck_assert(!r); 14738 terminateO(self); 14739 14740 } 14741 14742 14743 void hasIntSmallArrayT(void) { 14744 14745 bool r; 14746 smallArrayt *self = allocG(rtSmallArrayt); 14747 int64_t value = 1000; 14748 14749 // has 14750 self->f->pushInt(self, 1000); 14751 r = hasIntO(self, value); 14752 ck_assert(r); 14753 // not has 14754 emptyO(self); 14755 r = hasIntO(self, value); 14756 ck_assert(!r); 14757 terminateO(self); 14758 14759 } 14760 14761 14762 void hasSSmallArrayT(void) { 14763 14764 bool r; 14765 smallArrayt *self = allocG(rtSmallArrayt); 14766 const char *value = "asd"; 14767 14768 // has 14769 self->f->pushS(self, "asd"); 14770 r = hasSO(self, value); 14771 ck_assert(r); 14772 // not has 14773 emptyO(self); 14774 r = hasSO(self, value); 14775 ck_assert(!r); 14776 // NULL value 14777 r = hasSO(self, NULL); 14778 ck_assert(!r); 14779 terminateO(self); 14780 14781 } 14782 14783 14784 void hasCharSmallArrayT(void) { 14785 14786 bool r; 14787 smallArrayt *self = allocG(rtSmallArrayt); 14788 char value = 'a'; 14789 14790 // has 14791 self->f->pushS(self, "a"); 14792 r = hasCharO(self, value); 14793 ck_assert(r); 14794 // not has 14795 emptyO(self); 14796 r = hasCharO(self, value); 14797 ck_assert(!r); 14798 terminateO(self); 14799 14800 } 14801 14802 14803 void hasDictSmallArrayT(void) { 14804 14805 bool r; 14806 smallArrayt *self = allocG(rtSmallArrayt); 14807 smallDictt *value = allocSmallDict(); 14808 14809 // has 14810 self->f->pushNFreeDict(self, allocSmallDict()); 14811 r = hasDictO(self, value); 14812 ck_assert(r); 14813 // not has 14814 emptyO(self); 14815 r = hasDictO(self, value); 14816 ck_assert(!r); 14817 // non smallDict object 14818 terminateO(value); 14819 value = (smallDictt*) allocSmallInt(2); 14820 r = hasDictO(self, value); 14821 ck_assert(!r); 14822 // NULL value 14823 r = hasDictO(self, NULL); 14824 ck_assert(!r); 14825 terminateO(self); 14826 terminateO(value); 14827 14828 } 14829 14830 14831 void hasArraySmallArrayT(void) { 14832 14833 bool r; 14834 smallArrayt *self = allocG(rtSmallArrayt); 14835 smallArrayt *value = allocSmallArray(); 14836 14837 // has 14838 self->f->pushNFreeArray(self, allocSmallArray()); 14839 r = hasArrayO(self, value); 14840 ck_assert(r); 14841 // not has 14842 emptyO(self); 14843 r = hasArrayO(self, value); 14844 ck_assert(!r); 14845 // non smallArray object 14846 terminateO(value); 14847 value = (smallArrayt*) allocSmallInt(2); 14848 r = hasArrayO(self, value); 14849 ck_assert(!r); 14850 // NULL value 14851 r = hasArrayO(self, NULL); 14852 ck_assert(!r); 14853 terminateO(self); 14854 terminateO(value); 14855 14856 } 14857 14858 14859 void hasArraycSmallArrayT(void) { 14860 14861 bool r; 14862 smallArrayt *self = allocG(rtSmallArrayt); 14863 char **value = listCreateS("a","bb"); 14864 14865 // has 14866 self->f->pushNFreeArrayc(self, listCreateS("a","bb")); 14867 r = hasArraycO(self, value); 14868 ck_assert(r); 14869 // not has 14870 emptyO(self); 14871 r = hasArraycO(self, value); 14872 ck_assert(!r); 14873 // NULL value 14874 r = hasArraycO(self, NULL); 14875 ck_assert(!r); 14876 terminateO(self); 14877 listFreeS(value); 14878 14879 } 14880 14881 14882 void hasSmallBoolSmallArrayT(void) { 14883 14884 bool r; 14885 smallArrayt *self = allocG(rtSmallArrayt); 14886 smallBoolt *value = allocSmallBool(true); 14887 14888 // has 14889 self->f->pushBool(self, true); 14890 r = hasSmallBoolO(self, value); 14891 ck_assert(r); 14892 // not has 14893 emptyO(self); 14894 r = hasSmallBoolO(self, value); 14895 ck_assert(!r); 14896 // non smallBool object 14897 terminateO(value); 14898 value = (smallBoolt*) allocSmallInt(2); 14899 r = hasSmallBoolO(self, value); 14900 ck_assert(!r); 14901 // NULL value 14902 r = hasSmallBoolO(self, NULL); 14903 ck_assert(!r); 14904 terminateO(self); 14905 terminateO(value); 14906 14907 } 14908 14909 14910 void hasSmallBytesSmallArrayT(void) { 14911 14912 bool r; 14913 smallArrayt *self = allocG(rtSmallArrayt); 14914 createAllocateSmallBytes(value); 14915 pushBufferO(value, &self, 8); 14916 14917 // has 14918 createAllocateSmallBytes(elem); 14919 pushBufferO(elem, &self, 8); 14920 self->f->pushNFreeSmallBytes(self, elem); 14921 r = hasSmallBytesO(self, value); 14922 ck_assert(r); 14923 // not has 14924 emptyO(self); 14925 r = hasSmallBytesO(self, value); 14926 ck_assert(!r); 14927 // non smallBytes object 14928 terminateO(value); 14929 value = (smallBytest*) allocSmallInt(2); 14930 r = hasSmallBytesO(self, value); 14931 ck_assert(!r); 14932 // NULL value 14933 r = hasSmallBytesO(self, NULL); 14934 ck_assert(!r); 14935 terminateO(self); 14936 terminateO(value); 14937 14938 } 14939 14940 14941 void hasSmallDoubleSmallArrayT(void) { 14942 14943 bool r; 14944 smallArrayt *self = allocG(rtSmallArrayt); 14945 smallDoublet *value = allocSmallDouble(2); 14946 14947 // has 14948 self->f->pushDouble(self, 2); 14949 r = hasSmallDoubleO(self, value); 14950 ck_assert(r); 14951 // not has 14952 emptyO(self); 14953 r = hasSmallDoubleO(self, value); 14954 ck_assert(!r); 14955 // non smallDouble object 14956 terminateO(value); 14957 value = (smallDoublet*) allocSmallInt(2); 14958 r = hasSmallDoubleO(self, value); 14959 ck_assert(!r); 14960 // NULL value 14961 r = hasSmallDoubleO(self, NULL); 14962 ck_assert(!r); 14963 terminateO(self); 14964 terminateO(value); 14965 14966 } 14967 14968 14969 void hasSmallIntSmallArrayT(void) { 14970 14971 bool r; 14972 smallArrayt *self = allocG(rtSmallArrayt); 14973 smallIntt *value = allocSmallInt(12); 14974 14975 // has 14976 self->f->pushInt(self, 12); 14977 r = hasSmallIntO(self, value); 14978 ck_assert(r); 14979 // not has 14980 emptyO(self); 14981 r = hasSmallIntO(self, value); 14982 ck_assert(!r); 14983 // non smallInt object 14984 terminateO(value); 14985 value = (smallIntt*) allocSmallBool(true); 14986 r = hasSmallIntO(self, value); 14987 ck_assert(!r); 14988 // NULL value 14989 r = hasSmallIntO(self, NULL); 14990 ck_assert(!r); 14991 terminateO(self); 14992 terminateO(value); 14993 14994 } 14995 14996 14997 void hasSmallJsonSmallArrayT(void) { 14998 14999 bool r; 15000 smallArrayt *self = allocG(rtSmallArrayt); 15001 smallJsont *value = allocSmallJson(); 15002 value->f->pushInt(value, 1); 15003 15004 // has 15005 createAllocateSmallJson(elem); 15006 elem->f->pushInt(elem, 1); 15007 self->f->pushNFreeSmallJson(self, elem); 15008 r = self->f->hasSmallJson(self, value); 15009 ck_assert(r); 15010 // not has 15011 emptyO(self); 15012 r = self->f->hasSmallJson(self, value); 15013 ck_assert(!r); 15014 // non smallJson object 15015 terminateO(value); 15016 value = (smallJsont*) allocSmallInt(2); 15017 r = self->f->hasSmallJson(self, value); 15018 ck_assert(!r); 15019 // NULL value 15020 r = self->f->hasSmallJson(self, NULL); 15021 ck_assert(!r); 15022 terminateO(self); 15023 terminateO(value); 15024 15025 } 15026 15027 15028 void hasSmallStringSmallArrayT(void) { 15029 15030 bool r; 15031 smallArrayt *self = allocG(rtSmallArrayt); 15032 smallStringt *value = allocSmallString("qwe"); 15033 15034 // has 15035 self->f->pushS(self, "qwe"); 15036 r = self->f->hasSmallString(self, value); 15037 ck_assert(r); 15038 // not has 15039 emptyO(self); 15040 r = self->f->hasSmallString(self, value); 15041 ck_assert(!r); 15042 // non smallString object 15043 terminateO(value); 15044 value = (smallStringt*) allocSmallInt(2); 15045 r = self->f->hasSmallString(self, value); 15046 ck_assert(!r); 15047 // NULL value 15048 r = self->f->hasSmallString(self, NULL); 15049 ck_assert(!r); 15050 terminateO(self); 15051 terminateO(value); 15052 15053 } 15054 15055 15056 void hasSmallContainerSmallArrayT(void) { 15057 15058 bool r; 15059 smallArrayt *self = allocG(rtSmallArrayt); 15060 createAllocateSmallContainer(value); 15061 15062 // has 15063 createAllocateSmallContainer(elem); 15064 self->f->pushNFreeSmallContainer(self, elem); 15065 r = hasSmallContainerO(self, value); 15066 ck_assert(!r); 15067 // not has 15068 emptyO(self); 15069 r = hasSmallContainerO(self, value); 15070 ck_assert(!r); 15071 // non smallContainer object 15072 terminateO(value); 15073 value = (smallContainert*) allocSmallInt(2); 15074 r = self->f->hasSmallContainer(self, value); 15075 ck_assert(!r); 15076 // NULL value 15077 r = hasSmallContainerO(self, NULL); 15078 ck_assert(!r); 15079 terminateO(self); 15080 terminateO(value); 15081 15082 } 15083 15084 15085 void indexOfSmallArrayT(void) { 15086 15087 ssize_t r; 15088 smallArrayt *self = allocG(rtSmallArrayt); 15089 baset *value = (baset*)allocSmallInt(1); 15090 15091 // index 15092 self->f->pushInt(self, 2); 15093 self->f->pushInt(self, 0); 15094 delElemO(self, 1); 15095 self->f->pushInt(self, 1); 15096 r = indexOfO(self, value); 15097 ck_assert_int_eq(r, 2); 15098 // not index 15099 smallIntt *v = (smallIntt*) value; 15100 setValO(v, 0); 15101 r = indexOfO(self, value); 15102 ck_assert_int_eq(r, -1); 15103 // NULL value 15104 r = indexOfO(self, NULL); 15105 ck_assert_int_eq(r, -1); 15106 terminateO(self); 15107 terminateO(value); 15108 15109 } 15110 15111 15112 void indexOfUndefinedSmallArrayT(void) { 15113 15114 ssize_t r; 15115 smallArrayt *self = allocG(rtSmallArrayt); 15116 undefinedt *value = allocUndefined(); 15117 15118 // indexOf 15119 self->f->pushInt(self, 1); 15120 self->f->pushUndefined(self); 15121 delElemO(self, 1); 15122 self->f->pushUndefined(self); 15123 r = indexOfUndefinedO(self, value); 15124 ck_assert_int_eq(r, 2); 15125 // not indexOf 15126 delElemO(self, 2); 15127 r = indexOfUndefinedO(self, value); 15128 ck_assert_int_eq(r, -1); 15129 // non undefined object 15130 terminateO(value); 15131 value = (undefinedt*) allocSmallInt(2); 15132 r = indexOfUndefinedO(self, value); 15133 ck_assert_int_eq(r, -1); 15134 // NULL value 15135 r = indexOfUndefinedO(self, NULL); 15136 ck_assert_int_eq(r, -1); 15137 terminateO(self); 15138 terminateO(value); 15139 15140 } 15141 15142 15143 void indexOfBoolSmallArrayT(void) { 15144 15145 ssize_t r; 15146 smallArrayt *self = allocG(rtSmallArrayt); 15147 bool value = true; 15148 15149 // indexOf 15150 self->f->pushInt(self, 1); 15151 self->f->pushUndefined(self); 15152 delElemO(self, 1); 15153 self->f->pushBool(self, true); 15154 r = indexOfBoolO(self, value); 15155 ck_assert_int_eq(r, 2); 15156 // not indexOf 15157 delElemO(self, 2); 15158 r = indexOfBoolO(self, value); 15159 ck_assert_int_eq(r, -1); 15160 terminateO(self); 15161 15162 } 15163 15164 15165 void indexOfDoubleSmallArrayT(void) { 15166 15167 ssize_t r; 15168 smallArrayt *self = allocG(rtSmallArrayt); 15169 double value = 2; 15170 15171 // indexOf 15172 self->f->pushInt(self, 1); 15173 self->f->pushUndefined(self); 15174 delElemO(self, 1); 15175 self->f->pushDouble(self, 2); 15176 r = indexOfDoubleO(self, value); 15177 ck_assert_int_eq(r, 2); 15178 // not indexOf 15179 delElemO(self, 2); 15180 r = indexOfDoubleO(self, value); 15181 ck_assert_int_eq(r, -1); 15182 terminateO(self); 15183 15184 } 15185 15186 15187 void indexOfIntSmallArrayT(void) { 15188 15189 ssize_t r; 15190 smallArrayt *self = allocG(rtSmallArrayt); 15191 int64_t value = 1000; 15192 15193 // indexOf 15194 self->f->pushUndefined(self); 15195 self->f->pushUndefined(self); 15196 delElemO(self, 1); 15197 self->f->pushInt(self, 1000); 15198 r = indexOfIntO(self, value); 15199 ck_assert_int_eq(r, 2); 15200 // not indexOf 15201 delElemO(self, 2); 15202 r = indexOfIntO(self, value); 15203 ck_assert_int_eq(r, -1); 15204 terminateO(self); 15205 15206 } 15207 15208 15209 void indexOfSSmallArrayT(void) { 15210 15211 ssize_t r; 15212 smallArrayt *self = allocG(rtSmallArrayt); 15213 const char *value = "asd"; 15214 15215 // indexOf 15216 self->f->pushUndefined(self); 15217 self->f->pushUndefined(self); 15218 delElemO(self, 1); 15219 self->f->pushS(self, "asd"); 15220 r = indexOfSO(self, value); 15221 ck_assert_int_eq(r, 2); 15222 // not indexOf 15223 delElemO(self, 2); 15224 r = indexOfSO(self, value); 15225 ck_assert_int_eq(r, -1); 15226 // NULL value 15227 r = indexOfSO(self, NULL); 15228 ck_assert_int_eq(r, -1); 15229 terminateO(self); 15230 15231 } 15232 15233 15234 void indexOfCharSmallArrayT(void) { 15235 15236 ssize_t r; 15237 smallArrayt *self = allocG(rtSmallArrayt); 15238 char value = 'a'; 15239 15240 // indexOf 15241 self->f->pushUndefined(self); 15242 self->f->pushUndefined(self); 15243 delElemO(self, 1); 15244 self->f->pushS(self, "a"); 15245 r = indexOfCharO(self, value); 15246 ck_assert_int_eq(r, 2); 15247 // not indexOf 15248 delElemO(self, 2); 15249 r = indexOfCharO(self, value); 15250 ck_assert_int_eq(r, -1); 15251 terminateO(self); 15252 15253 } 15254 15255 15256 void indexOfDictSmallArrayT(void) { 15257 15258 ssize_t r; 15259 smallArrayt *self = allocG(rtSmallArrayt); 15260 smallDictt *value = allocSmallDict(); 15261 15262 // indexOf 15263 createAllocateSmallDict(elem); 15264 elem->f->setInt(elem, "a", 1); 15265 self->f->pushNFreeDict(self, elem); 15266 self->f->pushUndefined(self); 15267 delElemO(self, 1); 15268 self->f->pushNFreeDict(self, allocSmallDict()); 15269 r = indexOfDictO(self, value); 15270 ck_assert_int_eq(r, 2); 15271 // not indexOf 15272 delElemO(self, 2); 15273 r = indexOfDictO(self, value); 15274 ck_assert_int_eq(r, -1); 15275 // non smallDict object 15276 terminateO(value); 15277 value = (smallDictt*) allocSmallInt(2); 15278 r = indexOfDictO(self, value); 15279 ck_assert_int_eq(r, -1); 15280 // NULL value 15281 r = indexOfDictO(self, NULL); 15282 ck_assert_int_eq(r, -1); 15283 terminateO(self); 15284 terminateO(value); 15285 15286 } 15287 15288 15289 void indexOfArraySmallArrayT(void) { 15290 15291 ssize_t r; 15292 smallArrayt *self = allocG(rtSmallArrayt); 15293 smallArrayt *value = allocSmallArray(); 15294 15295 // indexOf 15296 createAllocateSmallArray(elem); 15297 elem->f->pushInt(elem, 1); 15298 self->f->pushNFreeArray(self, elem); 15299 self->f->pushUndefined(self); 15300 delElemO(self, 1); 15301 self->f->pushNFreeArray(self, allocSmallArray()); 15302 r = indexOfArrayO(self, value); 15303 ck_assert_int_eq(r, 2); 15304 // non smallArray object 15305 terminateO(value); 15306 value = (smallArrayt*) allocSmallInt(2); 15307 r = indexOfArrayO(self, value); 15308 ck_assert_int_eq(r, -1); 15309 // not indexOf 15310 emptyO(self); 15311 r = indexOfArrayO(self, value); 15312 ck_assert_int_eq(r, -1); 15313 // NULL value 15314 r = indexOfArrayO(self, NULL); 15315 ck_assert_int_eq(r, -1); 15316 terminateO(self); 15317 terminateO(value); 15318 15319 } 15320 15321 15322 void indexOfArraycSmallArrayT(void) { 15323 15324 ssize_t r; 15325 smallArrayt *self = allocG(rtSmallArrayt); 15326 char **value = listCreateS("a","bb"); 15327 15328 // indexOf 15329 char **elem = listCreateS("!!","@@@"); 15330 self->f->pushNFreeArrayc(self, elem); 15331 self->f->pushUndefined(self); 15332 delElemO(self, 1); 15333 self->f->pushNFreeArrayc(self, listCreateS("a","bb")); 15334 r = indexOfArraycO(self, value); 15335 ck_assert_int_eq(r, 2); 15336 // not indexOf 15337 delElemO(self, 2); 15338 r = indexOfArraycO(self, value); 15339 ck_assert_int_eq(r, -1); 15340 // NULL value 15341 r = indexOfArraycO(self, NULL); 15342 ck_assert_int_eq(r, -1); 15343 terminateO(self); 15344 listFreeS(value); 15345 15346 } 15347 15348 15349 void indexOfSmallBoolSmallArrayT(void) { 15350 15351 ssize_t r; 15352 smallArrayt *self = allocG(rtSmallArrayt); 15353 smallBoolt *value = allocSmallBool(true); 15354 15355 // indexOf 15356 self->f->pushUndefined(self); 15357 self->f->pushUndefined(self); 15358 delElemO(self, 1); 15359 self->f->pushBool(self, true); 15360 r = indexOfSmallBoolO(self, value); 15361 ck_assert_int_eq(r, 2); 15362 // not indexOf 15363 delElemO(self, 2); 15364 r = indexOfSmallBoolO(self, value); 15365 ck_assert_int_eq(r, -1); 15366 // non smallBool object 15367 terminateO(value); 15368 value = (smallBoolt*) allocSmallInt(2); 15369 r = indexOfSmallBoolO(self, value); 15370 ck_assert_int_eq(r, -1); 15371 // NULL value 15372 r = indexOfSmallBoolO(self, NULL); 15373 ck_assert_int_eq(r, -1); 15374 terminateO(self); 15375 terminateO(value); 15376 15377 } 15378 15379 15380 void indexOfSmallBytesSmallArrayT(void) { 15381 15382 ssize_t r; 15383 smallArrayt *self = allocG(rtSmallArrayt); 15384 createAllocateSmallBytes(value); 15385 pushBufferO(value, &self, 8); 15386 15387 // indexOf 15388 self->f->pushUndefined(self); 15389 self->f->pushUndefined(self); 15390 delElemO(self, 1); 15391 createAllocateSmallBytes(elem); 15392 pushBufferO(elem, &self, 8); 15393 self->f->pushNFreeSmallBytes(self, elem); 15394 r = indexOfSmallBytesO(self, value); 15395 ck_assert_int_eq(r, 2); 15396 // not indexOf 15397 delElemO(self, 2); 15398 r = indexOfSmallBytesO(self, value); 15399 ck_assert_int_eq(r, -1); 15400 // non smallBytes object 15401 terminateO(value); 15402 value = (smallBytest*) allocSmallInt(2); 15403 r = indexOfSmallBytesO(self, value); 15404 ck_assert_int_eq(r, -1); 15405 // NULL value 15406 r = indexOfSmallBytesO(self, NULL); 15407 ck_assert_int_eq(r, -1); 15408 terminateO(self); 15409 terminateO(value); 15410 15411 } 15412 15413 15414 void indexOfSmallDoubleSmallArrayT(void) { 15415 15416 ssize_t r; 15417 smallArrayt *self = allocG(rtSmallArrayt); 15418 smallDoublet *value = allocSmallDouble(2); 15419 15420 // indexOf 15421 self->f->pushUndefined(self); 15422 self->f->pushUndefined(self); 15423 delElemO(self, 1); 15424 self->f->pushDouble(self, 2); 15425 r = indexOfSmallDoubleO(self, value); 15426 ck_assert_int_eq(r, 2); 15427 // not indexOf 15428 delElemO(self, 2); 15429 r = indexOfSmallDoubleO(self, value); 15430 ck_assert_int_eq(r, -1); 15431 // non smallDouble object 15432 terminateO(value); 15433 value = (smallDoublet*) allocSmallInt(2); 15434 r = indexOfSmallDoubleO(self, value); 15435 ck_assert_int_eq(r, -1); 15436 // NULL value 15437 r = indexOfSmallDoubleO(self, NULL); 15438 ck_assert_int_eq(r, -1); 15439 terminateO(self); 15440 terminateO(value); 15441 15442 } 15443 15444 15445 void indexOfSmallIntSmallArrayT(void) { 15446 15447 ssize_t r; 15448 smallArrayt *self = allocG(rtSmallArrayt); 15449 smallIntt *value = allocSmallInt(12); 15450 15451 // indexOf 15452 self->f->pushUndefined(self); 15453 self->f->pushUndefined(self); 15454 delElemO(self, 1); 15455 self->f->pushInt(self, 12); 15456 r = indexOfSmallIntO(self, value); 15457 ck_assert_int_eq(r, 2); 15458 // not indexOf 15459 delElemO(self, 2); 15460 r = indexOfSmallIntO(self, value); 15461 ck_assert_int_eq(r, -1); 15462 // non smallInt object 15463 terminateO(value); 15464 value = (smallIntt*) allocSmallBool(true); 15465 r = indexOfSmallIntO(self, value); 15466 ck_assert_int_eq(r, -1); 15467 // NULL value 15468 r = indexOfSmallIntO(self, NULL); 15469 ck_assert_int_eq(r, -1); 15470 terminateO(self); 15471 terminateO(value); 15472 15473 } 15474 15475 15476 void indexOfSmallJsonSmallArrayT(void) { 15477 15478 ssize_t r; 15479 smallArrayt *self = allocG(rtSmallArrayt); 15480 smallJsont *value = allocSmallJson(); 15481 15482 // indexOf json undefined 15483 createUndefined(u); 15484 setTopO(value, (baset*)&u); 15485 self->f->pushUndefined(self); 15486 r = self->f->indexOfSmallJson(self, value); 15487 ck_assert_int_eq(r, 0); 15488 freeO(value); 15489 // indexOf json bool 15490 smallBoolt *b = allocSmallBool(true); 15491 setTopNFreeSmallBoolO(value, b); 15492 self->f->pushBool(self, true); 15493 r = self->f->indexOfSmallJson(self, value); 15494 ck_assert_int_eq(r, 1); 15495 freeO(value); 15496 // indexOf json double 15497 smallDoublet *d = allocSmallDouble(1); 15498 setTopNFreeSmallDoubleO(value, d); 15499 self->f->pushDouble(self, 1); 15500 r = self->f->indexOfSmallJson(self, value); 15501 ck_assert_int_eq(r, 2); 15502 freeO(value); 15503 // indexOf json int 15504 smallIntt *i = allocSmallInt(1); 15505 setTopNFreeSmallIntO(value, i); 15506 self->f->pushInt(self, 1); 15507 r = self->f->indexOfSmallJson(self, value); 15508 ck_assert_int_eq(r, 3); 15509 freeO(value); 15510 // indexOf json string 15511 smallStringt *s = allocSmallString("asd"); 15512 setTopNFreeSmallStringO(value, s); 15513 self->f->pushS(self, "asd"); 15514 r = self->f->indexOfSmallJson(self, value); 15515 ck_assert_int_eq(r, 4); 15516 freeO(value); 15517 // indexOf json dict 15518 smallDictt *D = allocSmallDict(); 15519 setTopNFreeDictO(value, D); 15520 self->f->pushNFreeDict(self, allocSmallDict()); 15521 r = self->f->indexOfSmallJson(self, value); 15522 ck_assert_int_eq(r, 5); 15523 freeO(value); 15524 // indexOf json array 15525 value->f->pushInt(value, 1); 15526 delElemO(self, 1); 15527 createAllocateSmallJson(elem); 15528 elem->f->pushInt(elem, 1); 15529 self->f->pushNFreeSmallJson(self, elem); 15530 r = self->f->indexOfSmallJson(self, value); 15531 ck_assert_int_eq(r, 6); 15532 // not indexOf 15533 delElemO(self, 6); 15534 r = self->f->indexOfSmallJson(self, value); 15535 ck_assert_int_eq(r, -1); 15536 // empty json object 15537 freeO(value); 15538 r = self->f->indexOfSmallJson(self, value); 15539 ck_assert_int_eq(r, -1); 15540 // non smallJson object 15541 terminateO(value); 15542 value = (smallJsont*) allocSmallInt(2); 15543 r = self->f->indexOfSmallJson(self, value); 15544 ck_assert_int_eq(r, -1); 15545 // NULL value 15546 r = self->f->indexOfSmallJson(self, NULL); 15547 ck_assert_int_eq(r, -1); 15548 terminateO(self); 15549 terminateO(value); 15550 15551 } 15552 15553 15554 void indexOfSmallStringSmallArrayT(void) { 15555 15556 ssize_t r; 15557 smallArrayt *self = allocG(rtSmallArrayt); 15558 smallStringt *value = allocSmallString("qwe"); 15559 15560 // indexOf 15561 self->f->pushUndefined(self); 15562 self->f->pushUndefined(self); 15563 delElemO(self, 1); 15564 self->f->pushS(self, "qwe"); 15565 r = self->f->indexOfSmallString(self, value); 15566 ck_assert_int_eq(r, 2); 15567 // not indexOf 15568 delElemO(self, 2); 15569 r = self->f->indexOfSmallString(self, value); 15570 ck_assert_int_eq(r, -1); 15571 // non smallString object 15572 terminateO(value); 15573 value = (smallStringt*) allocSmallInt(2); 15574 r = self->f->indexOfSmallString(self, value); 15575 ck_assert_int_eq(r, -1); 15576 // NULL value 15577 r = self->f->indexOfSmallString(self, NULL); 15578 ck_assert_int_eq(r, -1); 15579 terminateO(self); 15580 terminateO(value); 15581 15582 } 15583 15584 15585 void indexOfSmallContainerSmallArrayT(void) { 15586 15587 ssize_t r; 15588 smallArrayt *self = allocG(rtSmallArrayt); 15589 createAllocateSmallContainer(value); 15590 15591 // indexOf 15592 self->f->pushUndefined(self); 15593 self->f->pushUndefined(self); 15594 delElemO(self, 1); 15595 createAllocateSmallContainer(elem); 15596 self->f->pushNFreeSmallContainer(self, elem); 15597 r = self->f->indexOfSmallContainer(self, value); 15598 ck_assert_int_eq(r, -1); 15599 // not indexOf 15600 delElemO(self, 2); 15601 r = self->f->indexOfSmallContainer(self, value); 15602 ck_assert_int_eq(r, -1); 15603 // non smallContainer object 15604 terminateO(value); 15605 value = (smallContainert*) allocSmallInt(2); 15606 r = self->f->indexOfSmallContainer(self, value); 15607 ck_assert_int_eq(r, -1); 15608 // NULL value 15609 r = self->f->indexOfSmallContainer(self, NULL); 15610 ck_assert_int_eq(r, -1); 15611 terminateO(self); 15612 terminateO(value); 15613 15614 } 15615 15616 15617 void binarySearchSmallArrayT(void) { 15618 15619 ssize_t r; 15620 smallArrayt *self = allocG(rtSmallArrayt); 15621 baset *value = (baset*)allocSmallString("4"); 15622 15623 // index not trimmed (an element is NULL) 15624 self->f->pushS(self, "0"); 15625 self->f->pushS(self, "1"); 15626 self->f->pushS(self, "2"); 15627 delElemO(self, 2); 15628 self->f->pushS(self, "3"); 15629 self->f->pushS(self, "4"); 15630 self->f->pushS(self, "5"); 15631 r = binarySearchO(self, value); 15632 ck_assert_int_eq(r, -1); 15633 // index 15634 trimO(self); 15635 r = binarySearchO(self, value); 15636 ck_assert_int_eq(r, 3); 15637 smallStringt *v = (smallStringt*) value; 15638 // index in the lower half of the array 15639 setValO(v, "1"); 15640 r = binarySearchO(self, value); 15641 ck_assert_int_eq(r, 1); 15642 // not index 15643 setValO(v, "asd"); 15644 r = binarySearchO(self, value); 15645 ck_assert_int_eq(r, -1); 15646 // NULL value 15647 r = binarySearchO(self, NULL); 15648 ck_assert_int_eq(r, -1); 15649 // empty array 15650 emptyO(self); 15651 r = binarySearchO(self, value); 15652 ck_assert_int_eq(r, -1); 15653 terminateO(self); 15654 terminateO(value); 15655 15656 } 15657 15658 15659 void binarySearchUndefinedSmallArrayT(void) { 15660 15661 ssize_t r; 15662 smallArrayt *self = allocG(rtSmallArrayt); 15663 undefinedt *undefined = (undefinedt*) 1234; 15664 15665 r = binarySearchUndefinedO(self, undefined); 15666 ck_assert_int_eq(r, -1); 15667 terminateO(self); 15668 15669 } 15670 15671 15672 void binarySearchBoolSmallArrayT(void) { 15673 15674 ssize_t r; 15675 smallArrayt *self = allocG(rtSmallArrayt); 15676 bool value = true; 15677 15678 // index not trimmed (an element is NULL) 15679 self->f->pushUndefined(self); 15680 self->f->pushBool(self, false); 15681 self->f->pushUndefined(self); 15682 delElemO(self, 2); 15683 self->f->pushBool(self, true); 15684 self->f->pushS(self, "4"); 15685 self->f->pushS(self, "5"); 15686 r = binarySearchBoolO(self, value); 15687 ck_assert_int_eq(r, -1); 15688 // index 15689 trimO(self); 15690 r = binarySearchBoolO(self, value); 15691 ck_assert_int_eq(r, 2); 15692 // index in the lower half of the array 15693 value = false; 15694 r = binarySearchBoolO(self, value); 15695 ck_assert_int_eq(r, 1); 15696 // not index 15697 delElemO(self, 1); 15698 trimO(self); 15699 r = binarySearchBoolO(self, value); 15700 ck_assert_int_eq(r, -1); 15701 // empty array 15702 emptyO(self); 15703 r = binarySearchBoolO(self, value); 15704 ck_assert_int_eq(r, -1); 15705 terminateO(self); 15706 15707 } 15708 15709 15710 void binarySearchDoubleSmallArrayT(void) { 15711 15712 ssize_t r; 15713 smallArrayt *self = allocG(rtSmallArrayt); 15714 double value = 2; 15715 15716 // index not trimmed (an element is NULL) 15717 self->f->pushUndefined(self); 15718 self->f->pushDouble(self, 1); 15719 self->f->pushUndefined(self); 15720 delElemO(self, 2); 15721 self->f->pushDouble(self, 2); 15722 self->f->pushS(self, "4"); 15723 self->f->pushS(self, "5"); 15724 r = binarySearchDoubleO(self, value); 15725 ck_assert_int_eq(r, -1); 15726 // index 15727 trimO(self); 15728 r = binarySearchDoubleO(self, value); 15729 ck_assert_int_eq(r, 2); 15730 // index in the lower half of the array 15731 value = 1; 15732 r = binarySearchDoubleO(self, value); 15733 ck_assert_int_eq(r, 1); 15734 // not index 15735 delElemO(self, 1); 15736 trimO(self); 15737 r = binarySearchDoubleO(self, value); 15738 ck_assert_int_eq(r, -1); 15739 // empty array 15740 emptyO(self); 15741 r = binarySearchDoubleO(self, value); 15742 ck_assert_int_eq(r, -1); 15743 terminateO(self); 15744 15745 } 15746 15747 15748 void binarySearchIntSmallArrayT(void) { 15749 15750 ssize_t r; 15751 smallArrayt *self = allocG(rtSmallArrayt); 15752 int64_t value = 2; 15753 15754 // index not trimmed (an element is NULL) 15755 self->f->pushUndefined(self); 15756 self->f->pushInt(self, 1); 15757 self->f->pushUndefined(self); 15758 delElemO(self, 2); 15759 self->f->pushInt(self, 2); 15760 self->f->pushS(self, "4"); 15761 self->f->pushS(self, "5"); 15762 r = binarySearchIntO(self, value); 15763 ck_assert_int_eq(r, -1); 15764 // index 15765 trimO(self); 15766 r = binarySearchIntO(self, value); 15767 ck_assert_int_eq(r, 2); 15768 // index in the lower half of the array 15769 value = 1; 15770 r = binarySearchIntO(self, value); 15771 ck_assert_int_eq(r, 1); 15772 // not index 15773 delElemO(self, 1); 15774 trimO(self); 15775 r = binarySearchIntO(self, value); 15776 ck_assert_int_eq(r, -1); 15777 // empty array 15778 emptyO(self); 15779 r = binarySearchIntO(self, value); 15780 ck_assert_int_eq(r, -1); 15781 terminateO(self); 15782 15783 } 15784 15785 15786 void binarySearchSSmallArrayT(void) { 15787 15788 ssize_t r; 15789 smallArrayt *self = allocG(rtSmallArrayt); 15790 const char *value = "4"; 15791 15792 // index not trimmed (an element is NULL) 15793 self->f->pushS(self, "0"); 15794 self->f->pushS(self, "1"); 15795 self->f->pushS(self, "2"); 15796 delElemO(self, 2); 15797 self->f->pushS(self, "3"); 15798 self->f->pushS(self, "4"); 15799 self->f->pushS(self, "5"); 15800 r = binarySearchSO(self, value); 15801 ck_assert_int_eq(r, -1); 15802 // index 15803 trimO(self); 15804 r = binarySearchSO(self, value); 15805 ck_assert_int_eq(r, 3); 15806 // index in the lower half of the array 15807 value = "1"; 15808 r = binarySearchSO(self, value); 15809 ck_assert_int_eq(r, 1); 15810 // not index 15811 value = "asd"; 15812 r = binarySearchSO(self, value); 15813 ck_assert_int_eq(r, -1); 15814 // NULL value 15815 r = binarySearchSO(self, NULL); 15816 ck_assert_int_eq(r, -1); 15817 // empty array 15818 emptyO(self); 15819 r = binarySearchSO(self, value); 15820 ck_assert_int_eq(r, -1); 15821 terminateO(self); 15822 15823 } 15824 15825 15826 void binarySearchCharSmallArrayT(void) { 15827 15828 ssize_t r; 15829 smallArrayt *self = allocG(rtSmallArrayt); 15830 char value = '4'; 15831 15832 // index not trimmed (an element is NULL) 15833 self->f->pushS(self, "0"); 15834 self->f->pushS(self, "1"); 15835 self->f->pushS(self, "2"); 15836 delElemO(self, 2); 15837 self->f->pushS(self, "3"); 15838 self->f->pushS(self, "4"); 15839 self->f->pushS(self, "5"); 15840 r = binarySearchCharO(self, value); 15841 ck_assert_int_eq(r, -1); 15842 // index 15843 trimO(self); 15844 r = binarySearchCharO(self, value); 15845 ck_assert_int_eq(r, 3); 15846 // index in the lower half of the array 15847 value = '1'; 15848 r = binarySearchCharO(self, value); 15849 ck_assert_int_eq(r, 1); 15850 // not index 15851 value = 'a'; 15852 r = binarySearchCharO(self, value); 15853 ck_assert_int_eq(r, -1); 15854 // empty array 15855 emptyO(self); 15856 r = binarySearchCharO(self, value); 15857 ck_assert_int_eq(r, -1); 15858 terminateO(self); 15859 15860 } 15861 15862 15863 void binarySearchDictSmallArrayT(void) { 15864 15865 ssize_t r; 15866 smallArrayt *self = allocG(rtSmallArrayt); 15867 smallDictt *value = allocSmallDict(); 15868 value->f->setInt(value, "b", 2); 15869 15870 // index not trimmed (an element is NULL) 15871 createAllocateSmallDict(elem); 15872 elem->f->setInt(elem, "a", 1); 15873 self->f->pushUndefined(self); 15874 self->f->pushDict(self, elem); 15875 resetO(elem); 15876 self->f->pushUndefined(self); 15877 delElemO(self, 2); 15878 elem->f->setInt(elem, "b", 2); 15879 self->f->pushNFreeDict(self, elem); 15880 self->f->pushS(self, "4"); 15881 self->f->pushS(self, "5"); 15882 r = binarySearchDictO(self, value); 15883 ck_assert_int_eq(r, -1); 15884 // index 15885 trimO(self); 15886 r = binarySearchDictO(self, value); 15887 ck_assert_int_eq(r, 2); 15888 // index in the lower half of the array 15889 freeO(value); 15890 value->f->setInt(value, "a", 1); 15891 r = binarySearchDictO(self, value); 15892 ck_assert_int_eq(r, 1); 15893 // not index 15894 freeO(value); 15895 r = binarySearchDictO(self, value); 15896 ck_assert_int_eq(r, -1); 15897 // non smallDict object 15898 terminateO(value); 15899 value = (smallDictt*) allocSmallInt(2); 15900 r = binarySearchDictO(self, value); 15901 ck_assert_int_eq(r, -1); 15902 // NULL value 15903 r = binarySearchDictO(self, NULL); 15904 ck_assert_int_eq(r, -1); 15905 // empty array 15906 emptyO(self); 15907 r = binarySearchDictO(self, value); 15908 ck_assert_int_eq(r, -1); 15909 terminateO(self); 15910 terminateO(value); 15911 15912 } 15913 15914 15915 void binarySearchArraySmallArrayT(void) { 15916 15917 ssize_t r; 15918 smallArrayt *self = allocG(rtSmallArrayt); 15919 smallArrayt *value = allocSmallArray(); 15920 value->f->pushInt(value, 2); 15921 15922 // index not trimmed (an element is NULL) 15923 createAllocateSmallArray(elem); 15924 elem->f->pushInt(elem, 1); 15925 self->f->pushUndefined(self); 15926 self->f->pushArray(self, elem); 15927 resetO(elem); 15928 self->f->pushUndefined(self); 15929 delElemO(self, 2); 15930 elem->f->pushInt(elem, 2); 15931 self->f->pushNFreeArray(self, elem); 15932 self->f->pushS(self, "4"); 15933 self->f->pushS(self, "5"); 15934 r = binarySearchArrayO(self, value); 15935 ck_assert_int_eq(r, -1); 15936 // index 15937 trimO(self); 15938 r = binarySearchArrayO(self, value); 15939 ck_assert_int_eq(r, 2); 15940 // index in the lower half of the array 15941 freeO(value); 15942 value->f->pushInt(value, 1); 15943 r = binarySearchArrayO(self, value); 15944 ck_assert_int_eq(r, 1); 15945 // not index 15946 freeO(value); 15947 r = binarySearchArrayO(self, value); 15948 ck_assert_int_eq(r, -1); 15949 // non smallArray object 15950 terminateO(value); 15951 value = (smallArrayt*) allocSmallInt(2); 15952 r = binarySearchArrayO(self, value); 15953 ck_assert_int_eq(r, -1); 15954 // NULL value 15955 r = binarySearchArrayO(self, NULL); 15956 ck_assert_int_eq(r, -1); 15957 // empty array 15958 emptyO(self); 15959 r = binarySearchArrayO(self, value); 15960 ck_assert_int_eq(r, -1); 15961 terminateO(self); 15962 terminateO(value); 15963 15964 } 15965 15966 15967 void binarySearchArraycSmallArrayT(void) { 15968 15969 ssize_t r; 15970 smallArrayt *self = allocG(rtSmallArrayt); 15971 char **value = listCreateS("b"); 15972 15973 // index not trimmed (an element is NULL) 15974 char **elem = listCreateS("a"); 15975 self->f->pushUndefined(self); 15976 self->f->pushNFreeArrayc(self, elem); 15977 self->f->pushUndefined(self); 15978 delElemO(self, 2); 15979 elem = listCreateS("b"); 15980 self->f->pushNFreeArrayc(self, elem); 15981 self->f->pushS(self, "4"); 15982 self->f->pushS(self, "5"); 15983 r = binarySearchArraycO(self, value); 15984 ck_assert_int_eq(r, -1); 15985 // index 15986 trimO(self); 15987 r = binarySearchArraycO(self, value); 15988 ck_assert_int_eq(r, 2); 15989 // index in the lower half of the array 15990 free(value[0]); 15991 value[0] = strdup("a"); 15992 r = binarySearchArraycO(self, value); 15993 ck_assert_int_eq(r, 1); 15994 // not index 15995 free(value[0]); 15996 value[0] = strdup("asd"); 15997 r = binarySearchArraycO(self, value); 15998 ck_assert_int_eq(r, -1); 15999 // NULL value 16000 r = binarySearchArraycO(self, NULL); 16001 ck_assert_int_eq(r, -1); 16002 // empty array 16003 emptyO(self); 16004 r = binarySearchArraycO(self, value); 16005 ck_assert_int_eq(r, -1); 16006 terminateO(self); 16007 listFreeS(value); 16008 16009 } 16010 16011 16012 void binarySearchSmallBoolSmallArrayT(void) { 16013 16014 ssize_t r; 16015 smallArrayt *self = allocG(rtSmallArrayt); 16016 smallBoolt *value = allocSmallBool(true); 16017 16018 // index not trimmed (an element is NULL) 16019 self->f->pushUndefined(self); 16020 self->f->pushBool(self, false); 16021 self->f->pushUndefined(self); 16022 delElemO(self, 2); 16023 self->f->pushBool(self, true); 16024 self->f->pushS(self, "4"); 16025 self->f->pushS(self, "5"); 16026 r = binarySearchSmallBoolO(self, value); 16027 ck_assert_int_eq(r, -1); 16028 // index 16029 trimO(self); 16030 r = binarySearchSmallBoolO(self, value); 16031 ck_assert_int_eq(r, 2); 16032 // index in the lower half of the array 16033 setValO(value, false); 16034 r = binarySearchSmallBoolO(self, value); 16035 ck_assert_int_eq(r, 1); 16036 // not index 16037 delElemO(self, 1); 16038 trimO(self); 16039 r = binarySearchSmallBoolO(self, value); 16040 ck_assert_int_eq(r, -1); 16041 // non smallBool object 16042 terminateO(value); 16043 value = (smallBoolt*) allocSmallInt(2); 16044 r = binarySearchSmallBoolO(self, value); 16045 ck_assert_int_eq(r, -1); 16046 // NULL value 16047 r = binarySearchArraycO(self, NULL); 16048 ck_assert_int_eq(r, -1); 16049 // empty array 16050 emptyO(self); 16051 r = binarySearchSmallBoolO(self, value); 16052 ck_assert_int_eq(r, -1); 16053 terminateO(self); 16054 terminateO(value); 16055 16056 } 16057 16058 16059 void binarySearchSmallBytesSmallArrayT(void) { 16060 16061 ssize_t r; 16062 smallArrayt *self = allocG(rtSmallArrayt); 16063 createAllocateSmallBytes(value); 16064 pushBufferO(value, "bbc", 4); 16065 16066 // index not trimmed (an element is NULL) 16067 createAllocateSmallBytes(elem); 16068 pushBufferO(elem, "abc", 4); 16069 self->f->pushUndefined(self); 16070 self->f->pushNFreeSmallBytes(self, elem); 16071 self->f->pushUndefined(self); 16072 delElemO(self, 2); 16073 elem = allocSmallBytes("bbc", 4); 16074 self->f->pushNFreeSmallBytes(self, elem); 16075 self->f->pushS(self, "4"); 16076 self->f->pushS(self, "5"); 16077 r = binarySearchSmallBytesO(self, value); 16078 ck_assert_int_eq(r, -1); 16079 // index 16080 trimO(self); 16081 r = binarySearchSmallBytesO(self, value); 16082 ck_assert_int_eq(r, 2); 16083 // index in the lower half of the array 16084 freeO(value); 16085 pushBufferO(value, "abc", 4); 16086 r = binarySearchSmallBytesO(self, value); 16087 ck_assert_int_eq(r, 1); 16088 // not index 16089 freeO(value); 16090 pushBufferO(value, "###", 4); 16091 r = binarySearchSmallBytesO(self, value); 16092 ck_assert_int_eq(r, -1); 16093 // non smallBytes object 16094 terminateO(value); 16095 value = (smallBytest*) allocSmallInt(2); 16096 r = binarySearchSmallBytesO(self, value); 16097 ck_assert_int_eq(r, -1); 16098 // NULL value 16099 r = binarySearchSmallBytesO(self, NULL); 16100 ck_assert_int_eq(r, -1); 16101 // empty array 16102 emptyO(self); 16103 r = binarySearchSmallBytesO(self, value); 16104 ck_assert_int_eq(r, -1); 16105 terminateO(self); 16106 terminateO(value); 16107 16108 } 16109 16110 16111 void binarySearchSmallDoubleSmallArrayT(void) { 16112 16113 ssize_t r; 16114 smallArrayt *self = allocG(rtSmallArrayt); 16115 smallDoublet *value = allocSmallDouble(2); 16116 16117 // index not trimmed (an element is NULL) 16118 self->f->pushUndefined(self); 16119 self->f->pushDouble(self, 1); 16120 self->f->pushUndefined(self); 16121 delElemO(self, 2); 16122 self->f->pushDouble(self, 2); 16123 self->f->pushS(self, "4"); 16124 self->f->pushS(self, "5"); 16125 r = binarySearchSmallDoubleO(self, value); 16126 ck_assert_int_eq(r, -1); 16127 // index 16128 trimO(self); 16129 r = binarySearchSmallDoubleO(self, value); 16130 ck_assert_int_eq(r, 2); 16131 // index in the lower half of the array 16132 setValO(value, 1); 16133 r = binarySearchSmallDoubleO(self, value); 16134 ck_assert_int_eq(r, 1); 16135 // not index 16136 delElemO(self, 1); 16137 trimO(self); 16138 r = binarySearchSmallDoubleO(self, value); 16139 ck_assert_int_eq(r, -1); 16140 // non smallDouble object 16141 terminateO(value); 16142 value = (smallDoublet*) allocSmallInt(2); 16143 r = binarySearchSmallDoubleO(self, value); 16144 ck_assert_int_eq(r, -1); 16145 // NULL value 16146 r = binarySearchArraycO(self, NULL); 16147 ck_assert_int_eq(r, -1); 16148 // empty array 16149 emptyO(self); 16150 r = binarySearchSmallDoubleO(self, value); 16151 ck_assert_int_eq(r, -1); 16152 terminateO(self); 16153 terminateO(value); 16154 16155 } 16156 16157 16158 void binarySearchSmallIntSmallArrayT(void) { 16159 16160 ssize_t r; 16161 smallArrayt *self = allocG(rtSmallArrayt); 16162 smallIntt *value = allocSmallInt(2); 16163 16164 // index not trimmed (an element is NULL) 16165 self->f->pushUndefined(self); 16166 self->f->pushInt(self, 1); 16167 self->f->pushUndefined(self); 16168 delElemO(self, 2); 16169 self->f->pushInt(self, 2); 16170 self->f->pushS(self, "4"); 16171 self->f->pushS(self, "5"); 16172 r = binarySearchSmallIntO(self, value); 16173 ck_assert_int_eq(r, -1); 16174 // index 16175 trimO(self); 16176 r = binarySearchSmallIntO(self, value); 16177 ck_assert_int_eq(r, 2); 16178 // index in the lower half of the array 16179 setValO(value, 1); 16180 r = binarySearchSmallIntO(self, value); 16181 ck_assert_int_eq(r, 1); 16182 // not index 16183 delElemO(self, 1); 16184 trimO(self); 16185 r = binarySearchSmallIntO(self, value); 16186 ck_assert_int_eq(r, -1); 16187 // non smallInt object 16188 terminateO(value); 16189 value = (smallIntt*) allocSmallBool(true); 16190 r = binarySearchSmallIntO(self, value); 16191 ck_assert_int_eq(r, -1); 16192 // NULL value 16193 r = binarySearchArraycO(self, NULL); 16194 ck_assert_int_eq(r, -1); 16195 // empty array 16196 emptyO(self); 16197 r = binarySearchSmallIntO(self, value); 16198 ck_assert_int_eq(r, -1); 16199 terminateO(self); 16200 terminateO(value); 16201 16202 } 16203 16204 16205 void binarySearchSmallJsonSmallArrayT(void) { 16206 16207 ssize_t r; 16208 smallArrayt *self = allocG(rtSmallArrayt); 16209 smallJsont *value = allocSmallJson(); 16210 value->f->pushInt(value, 2); 16211 16212 // index not trimmed (an element is NULL) 16213 self->f->pushUndefined(self); 16214 createAllocateSmallArray(elem); 16215 elem->f->pushInt(elem, 1); 16216 self->f->pushArray(self, elem); 16217 resetO(elem); 16218 self->f->pushUndefined(self); 16219 delElemO(self, 2); 16220 elem->f->pushInt(elem, 2); 16221 self->f->pushNFreeArray(self, elem); 16222 self->f->pushS(self, "4"); 16223 self->f->pushS(self, "5"); 16224 r = self->f->binarySearchSmallJson(self, value); 16225 ck_assert_int_eq(r, -1); 16226 // index 16227 trimO(self); 16228 r = self->f->binarySearchSmallJson(self, value); 16229 ck_assert_int_eq(r, 2); 16230 // index in the lower half of the array 16231 freeO(value); 16232 value->f->pushInt(value, 1); 16233 r = self->f->binarySearchSmallJson(self, value); 16234 ck_assert_int_eq(r, 1); 16235 // not index (json array) 16236 delElemO(self, 1); 16237 trimO(self); 16238 r = self->f->binarySearchSmallJson(self, value); 16239 ck_assert_int_eq(r, -1); 16240 // not index json undefined 16241 createUndefined(u); 16242 freeO(value); 16243 setTopO(value, (baset*)&u); 16244 r = self->f->binarySearchSmallJson(self, value); 16245 ck_assert_int_eq(r, -1); 16246 // not index json bool 16247 createSmallBool(b); 16248 freeO(value); 16249 setTopO(value, (baset*)&b); 16250 r = self->f->binarySearchSmallJson(self, value); 16251 ck_assert_int_eq(r, -1); 16252 // not index json double 16253 createSmallDouble(d); 16254 freeO(value); 16255 setTopO(value, (baset*)&d); 16256 r = self->f->binarySearchSmallJson(self, value); 16257 ck_assert_int_eq(r, -1); 16258 // not index json int 16259 createSmallInt(i); 16260 freeO(value); 16261 setTopO(value, (baset*)&i); 16262 r = self->f->binarySearchSmallJson(self, value); 16263 ck_assert_int_eq(r, -1); 16264 // not index json string 16265 createSmallString(s); 16266 freeO(value); 16267 setTopO(value, (baset*)&s); 16268 r = self->f->binarySearchSmallJson(self, value); 16269 ck_assert_int_eq(r, -1); 16270 // not index json dict 16271 createSmallDict(D); 16272 freeO(value); 16273 setTopO(value, (baset*)&D); 16274 r = self->f->binarySearchSmallJson(self, value); 16275 ck_assert_int_eq(r, -1); 16276 // empty json object 16277 freeO(value); 16278 r = self->f->binarySearchSmallJson(self, value); 16279 ck_assert_int_eq(r, -1); 16280 // non smallJson object 16281 terminateO(value); 16282 value = (smallJsont*) allocSmallInt(2); 16283 r = self->f->binarySearchSmallJson(self, value); 16284 ck_assert_int_eq(r, -1); 16285 // NULL value 16286 r = self->f->binarySearchSmallJson(self, NULL); 16287 ck_assert_int_eq(r, -1); 16288 // empty array 16289 emptyO(self); 16290 r = self->f->binarySearchSmallJson(self, value); 16291 ck_assert_int_eq(r, -1); 16292 terminateO(self); 16293 terminateO(value); 16294 16295 } 16296 16297 16298 void binarySearchSmallStringSmallArrayT(void) { 16299 16300 ssize_t r; 16301 smallArrayt *self = allocG(rtSmallArrayt); 16302 smallStringt *value = allocSmallString("4"); 16303 16304 // index not trimmed (an element is NULL) 16305 self->f->pushS(self, "0"); 16306 self->f->pushS(self, "1"); 16307 self->f->pushS(self, "2"); 16308 delElemO(self, 2); 16309 self->f->pushS(self, "3"); 16310 self->f->pushS(self, "4"); 16311 self->f->pushS(self, "5"); 16312 r = binarySearchSmallStringO(self, value); 16313 ck_assert_int_eq(r, -1); 16314 // index 16315 trimO(self); 16316 r = binarySearchSmallStringO(self, value); 16317 ck_assert_int_eq(r, 3); 16318 // index in the lower half of the array 16319 setValO(value, "1"); 16320 r = binarySearchSmallStringO(self, value); 16321 ck_assert_int_eq(r, 1); 16322 // not index 16323 setValO(value, "asd"); 16324 r = binarySearchSmallStringO(self, value); 16325 ck_assert_int_eq(r, -1); 16326 // non smallString object 16327 terminateO(value); 16328 value = (smallStringt*) allocSmallInt(2); 16329 r = binarySearchSmallStringO(self, value); 16330 ck_assert_int_eq(r, -1); 16331 // NULL value 16332 r = binarySearchSmallStringO(self, NULL); 16333 ck_assert_int_eq(r, -1); 16334 // empty array 16335 emptyO(self); 16336 r = binarySearchSmallStringO(self, value); 16337 ck_assert_int_eq(r, -1); 16338 terminateO(self); 16339 terminateO(value); 16340 16341 } 16342 16343 16344 void binarySearchSmallContainerSmallArrayT(void) { 16345 16346 ssize_t r; 16347 smallArrayt *self = allocG(rtSmallArrayt); 16348 createAllocateSmallContainer(value); 16349 16350 r = self->f->binarySearchSmallContainer(self, value); 16351 ck_assert_int_eq(r, -1); 16352 terminateO(self); 16353 terminateO(value); 16354 16355 } 16356 16357 16358 void uniqSmallArrayT(void) { 16359 16360 smallArrayt* r; 16361 smallArrayt *self = allocG(rtSmallArrayt); 16362 16363 // empty array 16364 r = self->f->uniq(self); 16365 ck_assert_ptr_eq(r, NULL); 16366 // one element 16367 self->f->pushUndefined(self); 16368 r = self->f->uniq(self); 16369 ck_assert_ptr_eq(r, self); 16370 // uniq elements 16371 self->f->pushUndefined(self); 16372 self->f->pushBool(self, true); 16373 self->f->pushNFreeDict(self, allocSmallDict()); 16374 self->f->pushDouble(self, 1); 16375 self->f->pushInt(self, 2); 16376 self->f->pushS(self, ""); 16377 self->f->pushNFreeArray(self, allocSmallArray()); 16378 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 16379 self->f->pushUndefined(self); 16380 self->f->pushBool(self, true); 16381 self->f->pushNFreeDict(self, allocSmallDict()); 16382 self->f->pushDouble(self, 1); 16383 self->f->pushInt(self, 2); 16384 self->f->pushS(self, ""); 16385 self->f->pushNFreeArray(self, allocSmallArray()); 16386 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 16387 r = self->f->uniq(self); 16388 ck_assert_ptr_ne(r, NULL); 16389 char *s = toStringO(r); 16390 ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"\",[],[0x71,0x77,0x65,0x00]]"); 16391 free(s); 16392 terminateO(self); 16393 16394 } 16395 16396 16397 void icHasSmallArrayT(void) { 16398 16399 bool r; 16400 smallArrayt *self = allocG(rtSmallArrayt); 16401 baset *value = (baset*)allocSmallString("a"); 16402 16403 // has 16404 self->f->pushS(self, "A"); 16405 r = icHasO(self, value); 16406 ck_assert(r); 16407 // not has 16408 emptyO(self); 16409 r = icHasO(self, value); 16410 ck_assert(!r); 16411 // NULL value 16412 r = icHasO(self, NULL); 16413 ck_assert(!r); 16414 terminateO(self); 16415 terminateO(value); 16416 16417 } 16418 16419 16420 void icHasSSmallArrayT(void) { 16421 16422 bool r; 16423 smallArrayt *self = allocG(rtSmallArrayt); 16424 const char *value = "ASD"; 16425 16426 // has 16427 self->f->pushS(self, "asd"); 16428 r = icHasSO(self, value); 16429 ck_assert(r); 16430 // not has 16431 emptyO(self); 16432 r = icHasSO(self, value); 16433 ck_assert(!r); 16434 // NULL value 16435 r = icHasSO(self, NULL); 16436 ck_assert(!r); 16437 terminateO(self); 16438 16439 } 16440 16441 16442 void icHasCharSmallArrayT(void) { 16443 16444 bool r; 16445 smallArrayt *self = allocG(rtSmallArrayt); 16446 char value = 'A'; 16447 16448 // has 16449 self->f->pushS(self, "a"); 16450 r = icHasCharO(self, value); 16451 ck_assert(r); 16452 // not has 16453 emptyO(self); 16454 r = icHasCharO(self, value); 16455 ck_assert(!r); 16456 terminateO(self); 16457 16458 } 16459 16460 16461 void icHasDictSmallArrayT(void) { 16462 16463 bool r; 16464 smallArrayt *self = allocG(rtSmallArrayt); 16465 smallDictt *value = allocSmallDict(); 16466 value->f->setInt(value, "A", 1); 16467 16468 // has 16469 createAllocateSmallDict(d); 16470 d->f->setInt(d, "a", 1); 16471 self->f->pushNFreeDict(self, d); 16472 r = icHasDictO(self, value); 16473 ck_assert(r); 16474 // not has 16475 emptyO(self); 16476 r = icHasDictO(self, value); 16477 ck_assert(!r); 16478 // NULL value 16479 r = icHasDictO(self, NULL); 16480 ck_assert(!r); 16481 terminateO(self); 16482 terminateO(value); 16483 16484 } 16485 16486 16487 void icHasArraySmallArrayT(void) { 16488 16489 bool r; 16490 smallArrayt *self = allocG(rtSmallArrayt); 16491 smallArrayt *value = allocSmallArray(); 16492 value->f->pushS(value, "A"); 16493 16494 // has 16495 createAllocateSmallArray(a); 16496 a->f->pushS(a, "a"); 16497 self->f->pushNFreeArray(self, a); 16498 r = icHasArrayO(self, value); 16499 ck_assert(r); 16500 // not has 16501 emptyO(self); 16502 r = icHasArrayO(self, value); 16503 ck_assert(!r); 16504 // NULL value 16505 r = icHasArrayO(self, NULL); 16506 ck_assert(!r); 16507 terminateO(self); 16508 terminateO(value); 16509 16510 } 16511 16512 16513 void icHasArraycSmallArrayT(void) { 16514 16515 bool r; 16516 smallArrayt *self = allocG(rtSmallArrayt); 16517 char **value = listCreateS("A","BB"); 16518 16519 // has 16520 self->f->pushNFreeArrayc(self, listCreateS("a","bb")); 16521 r = icHasArraycO(self, value); 16522 ck_assert(r); 16523 // not has 16524 emptyO(self); 16525 r = icHasArraycO(self, value); 16526 ck_assert(!r); 16527 // NULL value 16528 r = icHasArraycO(self, NULL); 16529 ck_assert(!r); 16530 terminateO(self); 16531 listFreeS(value); 16532 16533 } 16534 16535 16536 void icHasSmallJsonSmallArrayT(void) { 16537 16538 bool r; 16539 smallArrayt *self = allocG(rtSmallArrayt); 16540 smallJsont *value = allocSmallJson(); 16541 value->f->pushS(value, "A"); 16542 16543 // has 16544 createAllocateSmallJson(elem); 16545 elem->f->pushS(elem, "a"); 16546 self->f->pushNFreeSmallJson(self, elem); 16547 r = self->f->icHasSmallJson(self, value); 16548 ck_assert(r); 16549 // not has 16550 emptyO(self); 16551 r = self->f->icHasSmallJson(self, value); 16552 ck_assert(!r); 16553 // NULL value 16554 r = self->f->icHasSmallJson(self, NULL); 16555 ck_assert(!r); 16556 terminateO(self); 16557 terminateO(value); 16558 16559 } 16560 16561 16562 void icHasSmallStringSmallArrayT(void) { 16563 16564 bool r; 16565 smallArrayt *self = allocG(rtSmallArrayt); 16566 smallStringt *value = allocSmallString("QWE"); 16567 16568 // has 16569 self->f->pushS(self, "qwe"); 16570 r = self->f->icHasSmallString(self, value); 16571 ck_assert(r); 16572 // not has 16573 emptyO(self); 16574 r = self->f->icHasSmallString(self, value); 16575 ck_assert(!r); 16576 // NULL value 16577 r = self->f->icHasSmallString(self, NULL); 16578 ck_assert(!r); 16579 terminateO(self); 16580 terminateO(value); 16581 16582 } 16583 16584 16585 void icIndexOfSmallArrayT(void) { 16586 16587 ssize_t r; 16588 smallArrayt *self = allocG(rtSmallArrayt); 16589 baset *value = (baset*)allocSmallString("A"); 16590 16591 // index 16592 self->f->pushS(self, "2"); 16593 self->f->pushS(self, "3"); 16594 delElemO(self, 1); 16595 self->f->pushS(self, "a"); 16596 r = icIndexOfO(self, value); 16597 ck_assert_int_eq(r, 2); 16598 // not index 16599 smallStringt *v = (smallStringt*) value; 16600 setValO(v, "3"); 16601 r = icIndexOfO(self, value); 16602 ck_assert_int_eq(r, -1); 16603 // NULL value 16604 r = icIndexOfO(self, NULL); 16605 ck_assert_int_eq(r, -1); 16606 terminateO(self); 16607 terminateO(value); 16608 16609 } 16610 16611 16612 void icIndexOfSSmallArrayT(void) { 16613 16614 ssize_t r; 16615 smallArrayt *self = allocG(rtSmallArrayt); 16616 const char *value = "ASD"; 16617 16618 // indexOf 16619 self->f->pushUndefined(self); 16620 self->f->pushUndefined(self); 16621 delElemO(self, 1); 16622 self->f->pushS(self, "asd"); 16623 r = icIndexOfSO(self, value); 16624 ck_assert_int_eq(r, 2); 16625 // not indexOf 16626 delElemO(self, 2); 16627 r = icIndexOfSO(self, value); 16628 ck_assert_int_eq(r, -1); 16629 // NULL value 16630 r = icIndexOfSO(self, NULL); 16631 ck_assert_int_eq(r, -1); 16632 terminateO(self); 16633 16634 } 16635 16636 16637 void icIndexOfCharSmallArrayT(void) { 16638 16639 ssize_t r; 16640 smallArrayt *self = allocG(rtSmallArrayt); 16641 char value = 'A'; 16642 16643 // indexOf 16644 self->f->pushUndefined(self); 16645 self->f->pushUndefined(self); 16646 delElemO(self, 1); 16647 self->f->pushS(self, "a"); 16648 r = icIndexOfCharO(self, value); 16649 ck_assert_int_eq(r, 2); 16650 // not indexOf 16651 delElemO(self, 2); 16652 r = icIndexOfCharO(self, value); 16653 ck_assert_int_eq(r, -1); 16654 terminateO(self); 16655 16656 } 16657 16658 16659 void icIndexOfDictSmallArrayT(void) { 16660 16661 ssize_t r; 16662 smallArrayt *self = allocG(rtSmallArrayt); 16663 smallDictt *value = allocSmallDict(); 16664 value->f->setInt(value, "B", 1); 16665 16666 // indexOf 16667 createAllocateSmallDict(elem); 16668 elem->f->setInt(elem, "a", 1); 16669 self->f->pushDict(self, elem); 16670 resetO(elem); 16671 self->f->pushUndefined(self); 16672 delElemO(self, 1); 16673 elem->f->setInt(elem, "b", 1); 16674 self->f->pushNFreeDict(self, elem); 16675 r = icIndexOfDictO(self, value); 16676 ck_assert_int_eq(r, 2); 16677 // not indexOf 16678 delElemO(self, 2); 16679 r = icIndexOfDictO(self, value); 16680 ck_assert_int_eq(r, -1); 16681 // non smallDict object 16682 terminateO(value); 16683 value = (smallDictt*) allocSmallInt(2); 16684 r = icIndexOfDictO(self, value); 16685 ck_assert_int_eq(r, -1); 16686 // NULL value 16687 r = icIndexOfDictO(self, NULL); 16688 ck_assert_int_eq(r, -1); 16689 terminateO(self); 16690 terminateO(value); 16691 16692 } 16693 16694 16695 void icIndexOfArraySmallArrayT(void) { 16696 16697 ssize_t r; 16698 smallArrayt *self = allocG(rtSmallArrayt); 16699 smallArrayt *value = allocSmallArray(); 16700 value->f->pushS(value, "A"); 16701 16702 // indexOf 16703 createAllocateSmallArray(elem); 16704 elem->f->pushInt(elem, 1); 16705 self->f->pushArray(self, elem); 16706 resetO(elem); 16707 self->f->pushUndefined(self); 16708 delElemO(self, 1); 16709 elem->f->pushS(elem, "a"); 16710 self->f->pushNFreeArray(self, elem); 16711 r = icIndexOfArrayO(self, value); 16712 ck_assert_int_eq(r, 2); 16713 // non smallArray object 16714 terminateO(value); 16715 value = (smallArrayt*) allocSmallInt(2); 16716 r = icIndexOfArrayO(self, value); 16717 ck_assert_int_eq(r, -1); 16718 // not indexOf 16719 emptyO(self); 16720 r = icIndexOfArrayO(self, value); 16721 ck_assert_int_eq(r, -1); 16722 // NULL value 16723 r = icIndexOfArrayO(self, NULL); 16724 ck_assert_int_eq(r, -1); 16725 terminateO(self); 16726 terminateO(value); 16727 16728 } 16729 16730 16731 void icIndexOfArraycSmallArrayT(void) { 16732 16733 ssize_t r; 16734 smallArrayt *self = allocG(rtSmallArrayt); 16735 char **value = listCreateS("A","BB"); 16736 16737 // indexOf 16738 char **elem = listCreateS("!!","@@@"); 16739 self->f->pushNFreeArrayc(self, elem); 16740 self->f->pushUndefined(self); 16741 delElemO(self, 1); 16742 self->f->pushNFreeArrayc(self, listCreateS("a","bb")); 16743 r = icIndexOfArraycO(self, value); 16744 ck_assert_int_eq(r, 2); 16745 // not indexOf 16746 delElemO(self, 2); 16747 r = icIndexOfArraycO(self, value); 16748 ck_assert_int_eq(r, -1); 16749 // NULL value 16750 r = icIndexOfArraycO(self, NULL); 16751 ck_assert_int_eq(r, -1); 16752 terminateO(self); 16753 listFreeS(value); 16754 16755 } 16756 16757 16758 void icIndexOfSmallJsonSmallArrayT(void) { 16759 16760 ssize_t r; 16761 smallArrayt *self = allocG(rtSmallArrayt); 16762 smallJsont *value = allocSmallJson(); 16763 16764 // indexOf json undefined 16765 createUndefined(u); 16766 setTopO(value, (baset*)&u); 16767 self->f->pushUndefined(self); 16768 r = self->f->icIndexOfSmallJson(self, value); 16769 ck_assert_int_eq(r, 0); 16770 freeO(value); 16771 // indexOf json bool 16772 smallBoolt *b = allocSmallBool(true); 16773 setTopNFreeSmallBoolO(value, b); 16774 self->f->pushBool(self, true); 16775 r = self->f->icIndexOfSmallJson(self, value); 16776 ck_assert_int_eq(r, 1); 16777 freeO(value); 16778 // indexOf json double 16779 smallDoublet *d = allocSmallDouble(1); 16780 setTopNFreeSmallDoubleO(value, d); 16781 self->f->pushDouble(self, 1); 16782 r = self->f->icIndexOfSmallJson(self, value); 16783 ck_assert_int_eq(r, 2); 16784 freeO(value); 16785 // indexOf json int 16786 smallIntt *i = allocSmallInt(1); 16787 setTopNFreeSmallIntO(value, i); 16788 self->f->pushInt(self, 1); 16789 r = self->f->icIndexOfSmallJson(self, value); 16790 ck_assert_int_eq(r, 3); 16791 freeO(value); 16792 // indexOf json string 16793 smallStringt *s = allocSmallString("ASD"); 16794 setTopNFreeSmallStringO(value, s); 16795 self->f->pushS(self, "asd"); 16796 r = self->f->icIndexOfSmallJson(self, value); 16797 ck_assert_int_eq(r, 4); 16798 freeO(value); 16799 // indexOf json dict 16800 smallDictt *D = allocSmallDict(); 16801 D->f->setInt(D, "A", 1); 16802 setTopDictO(value, D); 16803 resetO(D); 16804 D->f->setInt(D, "a", 1); 16805 self->f->pushNFreeDict(self, D); 16806 r = self->f->icIndexOfSmallJson(self, value); 16807 ck_assert_int_eq(r, 5); 16808 freeO(value); 16809 // indexOf json array 16810 value->f->pushS(value, "A"); 16811 delElemO(self, 1); 16812 createAllocateSmallJson(elem); 16813 elem->f->pushS(elem, "a"); 16814 self->f->pushNFreeSmallJson(self, elem); 16815 r = self->f->icIndexOfSmallJson(self, value); 16816 ck_assert_int_eq(r, 6); 16817 // not indexOf 16818 delElemO(self, 6); 16819 r = self->f->icIndexOfSmallJson(self, value); 16820 ck_assert_int_eq(r, -1); 16821 // empty json object 16822 freeO(value); 16823 r = self->f->icIndexOfSmallJson(self, value); 16824 ck_assert_int_eq(r, -1); 16825 // non smallJson object 16826 terminateO(value); 16827 value = (smallJsont*) allocSmallInt(2); 16828 r = self->f->icIndexOfSmallJson(self, value); 16829 ck_assert_int_eq(r, -1); 16830 // NULL value 16831 r = self->f->icIndexOfSmallJson(self, NULL); 16832 ck_assert_int_eq(r, -1); 16833 terminateO(self); 16834 terminateO(value); 16835 16836 } 16837 16838 16839 void icIndexOfSmallStringSmallArrayT(void) { 16840 16841 ssize_t r; 16842 smallArrayt *self = allocG(rtSmallArrayt); 16843 smallStringt *value = allocSmallString("QWE"); 16844 16845 // indexOf 16846 self->f->pushUndefined(self); 16847 self->f->pushUndefined(self); 16848 delElemO(self, 1); 16849 self->f->pushS(self, "qwe"); 16850 r = self->f->icIndexOfSmallString(self, value); 16851 ck_assert_int_eq(r, 2); 16852 // not indexOf 16853 delElemO(self, 2); 16854 r = self->f->icIndexOfSmallString(self, value); 16855 ck_assert_int_eq(r, -1); 16856 // non smallString object 16857 terminateO(value); 16858 value = (smallStringt*) allocSmallInt(2); 16859 r = self->f->icIndexOfSmallString(self, value); 16860 ck_assert_int_eq(r, -1); 16861 // NULL value 16862 r = self->f->icIndexOfSmallString(self, NULL); 16863 ck_assert_int_eq(r, -1); 16864 terminateO(self); 16865 terminateO(value); 16866 16867 } 16868 16869 16870 void icBinarySearchSmallArrayT(void) { 16871 16872 ssize_t r; 16873 smallArrayt *self = allocG(rtSmallArrayt); 16874 baset *value = (baset*)allocSmallString("E"); 16875 16876 // index not trimmed (an element is NULL) 16877 self->f->pushS(self, "a"); 16878 self->f->pushS(self, "b"); 16879 self->f->pushS(self, "c"); 16880 delElemO(self, 2); 16881 self->f->pushS(self, "d"); 16882 self->f->pushS(self, "e"); 16883 self->f->pushS(self, "f"); 16884 r = icBinarySearchO(self, value); 16885 ck_assert_int_eq(r, -1); 16886 // index 16887 trimO(self); 16888 r = icBinarySearchO(self, value); 16889 ck_assert_int_eq(r, 3); 16890 smallStringt *v = (smallStringt*) value; 16891 // index in the lower half of the array 16892 setValO(v, "B"); 16893 r = icBinarySearchO(self, value); 16894 ck_assert_int_eq(r, 1); 16895 // not index 16896 setValO(v, "asd"); 16897 r = icBinarySearchO(self, value); 16898 ck_assert_int_eq(r, -1); 16899 // NULL value 16900 r = icBinarySearchO(self, NULL); 16901 ck_assert_int_eq(r, -1); 16902 // empty array 16903 emptyO(self); 16904 r = icBinarySearchO(self, value); 16905 ck_assert_int_eq(r, -1); 16906 terminateO(self); 16907 terminateO(value); 16908 16909 } 16910 16911 16912 void icBinarySearchSSmallArrayT(void) { 16913 16914 ssize_t r; 16915 smallArrayt *self = allocG(rtSmallArrayt); 16916 const char *value = "E"; 16917 16918 // index not trimmed (an element is NULL) 16919 self->f->pushS(self, "a"); 16920 self->f->pushS(self, "b"); 16921 self->f->pushS(self, "c"); 16922 delElemO(self, 2); 16923 self->f->pushS(self, "d"); 16924 self->f->pushS(self, "e"); 16925 self->f->pushS(self, "f"); 16926 r = icBinarySearchSO(self, value); 16927 ck_assert_int_eq(r, -1); 16928 // index 16929 trimO(self); 16930 r = icBinarySearchSO(self, value); 16931 ck_assert_int_eq(r, 3); 16932 // index in the lower half of the array 16933 value = "B"; 16934 r = icBinarySearchSO(self, value); 16935 ck_assert_int_eq(r, 1); 16936 // not index 16937 value = "asd"; 16938 r = icBinarySearchSO(self, value); 16939 ck_assert_int_eq(r, -1); 16940 // NULL value 16941 r = icBinarySearchSO(self, NULL); 16942 ck_assert_int_eq(r, -1); 16943 // empty array 16944 emptyO(self); 16945 r = icBinarySearchSO(self, value); 16946 ck_assert_int_eq(r, -1); 16947 terminateO(self); 16948 16949 } 16950 16951 16952 void icBinarySearchCharSmallArrayT(void) { 16953 16954 ssize_t r; 16955 smallArrayt *self = allocG(rtSmallArrayt); 16956 char value = 'E'; 16957 16958 // index not trimmed (an element is NULL) 16959 self->f->pushS(self, "a"); 16960 self->f->pushS(self, "b"); 16961 self->f->pushS(self, "c"); 16962 delElemO(self, 2); 16963 self->f->pushS(self, "d"); 16964 self->f->pushS(self, "e"); 16965 self->f->pushS(self, "f"); 16966 r = icBinarySearchCharO(self, value); 16967 ck_assert_int_eq(r, -1); 16968 // index 16969 trimO(self); 16970 r = icBinarySearchCharO(self, value); 16971 ck_assert_int_eq(r, 3); 16972 // index in the lower half of the array 16973 value = 'B'; 16974 r = icBinarySearchCharO(self, value); 16975 ck_assert_int_eq(r, 1); 16976 // not index 16977 value = '1'; 16978 r = icBinarySearchCharO(self, value); 16979 ck_assert_int_eq(r, -1); 16980 // empty array 16981 emptyO(self); 16982 r = icBinarySearchCharO(self, value); 16983 ck_assert_int_eq(r, -1); 16984 terminateO(self); 16985 16986 } 16987 16988 16989 void icBinarySearchDictSmallArrayT(void) { 16990 16991 ssize_t r; 16992 smallArrayt *self = allocG(rtSmallArrayt); 16993 smallDictt *value = allocSmallDict(); 16994 value->f->setInt(value, "B", 2); 16995 16996 // index not trimmed (an element is NULL) 16997 createAllocateSmallDict(elem); 16998 elem->f->setInt(elem, "a", 1); 16999 self->f->pushUndefined(self); 17000 self->f->pushDict(self, elem); 17001 resetO(elem); 17002 self->f->pushUndefined(self); 17003 delElemO(self, 2); 17004 elem->f->setInt(elem, "b", 2); 17005 self->f->pushNFreeDict(self, elem); 17006 self->f->pushS(self, "4"); 17007 self->f->pushS(self, "5"); 17008 r = icBinarySearchDictO(self, value); 17009 ck_assert_int_eq(r, -1); 17010 // index 17011 trimO(self); 17012 r = icBinarySearchDictO(self, value); 17013 ck_assert_int_eq(r, 2); 17014 // index in the lower half of the array 17015 freeO(value); 17016 value->f->setInt(value, "A", 1); 17017 r = icBinarySearchDictO(self, value); 17018 ck_assert_int_eq(r, 1); 17019 // not index 17020 freeO(value); 17021 r = icBinarySearchDictO(self, value); 17022 ck_assert_int_eq(r, -1); 17023 // non smallDict object 17024 terminateO(value); 17025 value = (smallDictt*) allocSmallInt(2); 17026 r = icBinarySearchDictO(self, value); 17027 ck_assert_int_eq(r, -1); 17028 // NULL value 17029 r = icBinarySearchDictO(self, NULL); 17030 ck_assert_int_eq(r, -1); 17031 // empty array 17032 emptyO(self); 17033 r = icBinarySearchDictO(self, value); 17034 ck_assert_int_eq(r, -1); 17035 terminateO(self); 17036 terminateO(value); 17037 17038 } 17039 17040 17041 void icBinarySearchArraySmallArrayT(void) { 17042 17043 ssize_t r; 17044 smallArrayt *self = allocG(rtSmallArrayt); 17045 smallArrayt *value = allocSmallArray(); 17046 value->f->pushS(value, "B"); 17047 17048 // index not trimmed (an element is NULL) 17049 createAllocateSmallArray(elem); 17050 elem->f->pushS(elem, "a"); 17051 self->f->pushUndefined(self); 17052 self->f->pushArray(self, elem); 17053 resetO(elem); 17054 self->f->pushUndefined(self); 17055 delElemO(self, 2); 17056 elem->f->pushS(elem, "b"); 17057 self->f->pushNFreeArray(self, elem); 17058 self->f->pushS(self, "4"); 17059 self->f->pushS(self, "5"); 17060 r = icBinarySearchArrayO(self, value); 17061 ck_assert_int_eq(r, -1); 17062 // index 17063 trimO(self); 17064 r = icBinarySearchArrayO(self, value); 17065 ck_assert_int_eq(r, 2); 17066 // index in the lower half of the array 17067 freeO(value); 17068 value->f->pushS(value, "A"); 17069 r = icBinarySearchArrayO(self, value); 17070 ck_assert_int_eq(r, 1); 17071 // not index 17072 freeO(value); 17073 r = icBinarySearchArrayO(self, value); 17074 ck_assert_int_eq(r, -1); 17075 // non smallArray object 17076 terminateO(value); 17077 value = (smallArrayt*) allocSmallInt(2); 17078 r = icBinarySearchArrayO(self, value); 17079 ck_assert_int_eq(r, -1); 17080 // NULL value 17081 r = icBinarySearchArrayO(self, NULL); 17082 ck_assert_int_eq(r, -1); 17083 // empty array 17084 emptyO(self); 17085 r = icBinarySearchArrayO(self, value); 17086 ck_assert_int_eq(r, -1); 17087 terminateO(self); 17088 terminateO(value); 17089 17090 } 17091 17092 17093 void icBinarySearchArraycSmallArrayT(void) { 17094 17095 ssize_t r; 17096 smallArrayt *self = allocG(rtSmallArrayt); 17097 char **value = listCreateS("B"); 17098 17099 // index not trimmed (an element is NULL) 17100 char **elem = listCreateS("a"); 17101 self->f->pushUndefined(self); 17102 self->f->pushNFreeArrayc(self, elem); 17103 self->f->pushUndefined(self); 17104 delElemO(self, 2); 17105 elem = listCreateS("b"); 17106 self->f->pushNFreeArrayc(self, elem); 17107 self->f->pushS(self, "4"); 17108 self->f->pushS(self, "5"); 17109 r = icBinarySearchArraycO(self, value); 17110 ck_assert_int_eq(r, -1); 17111 // index 17112 trimO(self); 17113 r = icBinarySearchArraycO(self, value); 17114 ck_assert_int_eq(r, 2); 17115 // index in the lower half of the array 17116 free(value[0]); 17117 value[0] = strdup("A"); 17118 r = icBinarySearchArraycO(self, value); 17119 ck_assert_int_eq(r, 1); 17120 // not index 17121 free(value[0]); 17122 value[0] = strdup("asd"); 17123 r = icBinarySearchArraycO(self, value); 17124 ck_assert_int_eq(r, -1); 17125 // NULL value 17126 r = icBinarySearchArraycO(self, NULL); 17127 ck_assert_int_eq(r, -1); 17128 // empty array 17129 emptyO(self); 17130 r = icBinarySearchArraycO(self, value); 17131 ck_assert_int_eq(r, -1); 17132 terminateO(self); 17133 listFreeS(value); 17134 17135 } 17136 17137 17138 void icBinarySearchSmallJsonSmallArrayT(void) { 17139 17140 ssize_t r; 17141 smallArrayt *self = allocG(rtSmallArrayt); 17142 smallJsont *value = allocSmallJson(); 17143 value->f->pushS(value, "B"); 17144 17145 // index not trimmed (an element is NULL) 17146 self->f->pushUndefined(self); 17147 createAllocateSmallArray(elem); 17148 elem->f->pushS(elem, "a"); 17149 self->f->pushArray(self, elem); 17150 resetO(elem); 17151 self->f->pushUndefined(self); 17152 delElemO(self, 2); 17153 elem->f->pushS(elem, "b"); 17154 self->f->pushNFreeArray(self, elem); 17155 self->f->pushS(self, "4"); 17156 self->f->pushS(self, "5"); 17157 r = self->f->icBinarySearchSmallJson(self, value); 17158 ck_assert_int_eq(r, -1); 17159 // index 17160 trimO(self); 17161 r = self->f->icBinarySearchSmallJson(self, value); 17162 ck_assert_int_eq(r, 2); 17163 // index in the lower half of the array 17164 freeO(value); 17165 value->f->pushS(value, "A"); 17166 r = self->f->icBinarySearchSmallJson(self, value); 17167 ck_assert_int_eq(r, 1); 17168 // not index (json array) 17169 delElemO(self, 1); 17170 trimO(self); 17171 r = self->f->icBinarySearchSmallJson(self, value); 17172 ck_assert_int_eq(r, -1); 17173 // not index json undefined 17174 createUndefined(u); 17175 freeO(value); 17176 setTopO(value, (baset*)&u); 17177 r = self->f->icBinarySearchSmallJson(self, value); 17178 ck_assert_int_eq(r, -1); 17179 // not index json bool 17180 createSmallBool(b); 17181 freeO(value); 17182 setTopO(value, (baset*)&b); 17183 r = self->f->icBinarySearchSmallJson(self, value); 17184 ck_assert_int_eq(r, -1); 17185 // not index json double 17186 createSmallDouble(d); 17187 freeO(value); 17188 setTopO(value, (baset*)&d); 17189 r = self->f->icBinarySearchSmallJson(self, value); 17190 ck_assert_int_eq(r, -1); 17191 // not index json int 17192 createSmallInt(i); 17193 freeO(value); 17194 setTopO(value, (baset*)&i); 17195 r = self->f->icBinarySearchSmallJson(self, value); 17196 ck_assert_int_eq(r, -1); 17197 // not index json string 17198 createSmallString(s); 17199 freeO(value); 17200 setTopO(value, (baset*)&s); 17201 r = self->f->icBinarySearchSmallJson(self, value); 17202 ck_assert_int_eq(r, -1); 17203 // not index json dict 17204 createSmallDict(D); 17205 freeO(value); 17206 setTopO(value, (baset*)&D); 17207 r = self->f->icBinarySearchSmallJson(self, value); 17208 ck_assert_int_eq(r, -1); 17209 // empty json object 17210 freeO(value); 17211 r = self->f->icBinarySearchSmallJson(self, value); 17212 ck_assert_int_eq(r, -1); 17213 // non smallJson object 17214 terminateO(value); 17215 value = (smallJsont*) allocSmallInt(2); 17216 r = self->f->icBinarySearchSmallJson(self, value); 17217 ck_assert_int_eq(r, -1); 17218 // NULL value 17219 r = self->f->icBinarySearchSmallJson(self, NULL); 17220 ck_assert_int_eq(r, -1); 17221 // empty array 17222 emptyO(self); 17223 r = self->f->icBinarySearchSmallJson(self, value); 17224 ck_assert_int_eq(r, -1); 17225 terminateO(self); 17226 terminateO(value); 17227 17228 } 17229 17230 17231 void icBinarySearchSmallStringSmallArrayT(void) { 17232 17233 ssize_t r; 17234 smallArrayt *self = allocG(rtSmallArrayt); 17235 smallStringt *value = allocSmallString("E"); 17236 17237 // index not trimmed (an element is NULL) 17238 self->f->pushS(self, "a"); 17239 self->f->pushS(self, "b"); 17240 self->f->pushS(self, "c"); 17241 delElemO(self, 2); 17242 self->f->pushS(self, "d"); 17243 self->f->pushS(self, "e"); 17244 self->f->pushS(self, "f"); 17245 r = icBinarySearchSmallStringO(self, value); 17246 ck_assert_int_eq(r, -1); 17247 // index 17248 trimO(self); 17249 r = icBinarySearchSmallStringO(self, value); 17250 ck_assert_int_eq(r, 3); 17251 // index in the lower half of the array 17252 setValO(value, "B"); 17253 r = icBinarySearchSmallStringO(self, value); 17254 ck_assert_int_eq(r, 1); 17255 // not index 17256 setValO(value, "asd"); 17257 r = icBinarySearchSmallStringO(self, value); 17258 ck_assert_int_eq(r, -1); 17259 // non smallString object 17260 terminateO(value); 17261 value = (smallStringt*) allocSmallInt(2); 17262 r = icBinarySearchSmallStringO(self, value); 17263 ck_assert_int_eq(r, -1); 17264 // NULL value 17265 r = icBinarySearchSmallStringO(self, NULL); 17266 ck_assert_int_eq(r, -1); 17267 // empty array 17268 emptyO(self); 17269 r = icBinarySearchSmallStringO(self, value); 17270 ck_assert_int_eq(r, -1); 17271 terminateO(self); 17272 terminateO(value); 17273 17274 } 17275 17276 17277 void icUniqSmallArrayT(void) { 17278 17279 smallArrayt* r; 17280 smallArrayt *self = allocG(rtSmallArrayt); 17281 17282 // empty array 17283 r = self->f->icUniq(self); 17284 ck_assert_ptr_eq(r, NULL); 17285 // one element 17286 self->f->pushUndefined(self); 17287 r = self->f->icUniq(self); 17288 ck_assert_ptr_eq(r, self); 17289 // uniq elements 17290 self->f->pushUndefined(self); 17291 self->f->pushBool(self, true); 17292 self->f->pushNFreeDict(self, allocSmallDict()); 17293 self->f->pushDouble(self, 1); 17294 self->f->pushInt(self, 2); 17295 self->f->pushS(self, "ASD"); 17296 self->f->pushNFreeArray(self, allocSmallArray()); 17297 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 17298 self->f->pushUndefined(self); 17299 self->f->pushBool(self, true); 17300 self->f->pushNFreeDict(self, allocSmallDict()); 17301 self->f->pushDouble(self, 1); 17302 self->f->pushInt(self, 2); 17303 self->f->pushS(self, "asd"); 17304 self->f->pushNFreeArray(self, allocSmallArray()); 17305 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 17306 r = self->f->icUniq(self); 17307 ck_assert_ptr_ne(r, NULL); 17308 char *s = toStringO(r); 17309 ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"ASD\",[],[0x71,0x77,0x65,0x00]]"); 17310 free(s); 17311 terminateO(self); 17312 17313 } 17314 17315 17316 void compactSmallArrayT(void) { 17317 17318 smallArrayt* r; 17319 smallArrayt *self = allocG(rtSmallArrayt); 17320 17321 // add and remove elements 17322 self->f->pushUndefined(self); 17323 // null element 17324 self->f->pushUndefined(self); 17325 delElemO(self, 1); 17326 self->f->pushBool(self, true); 17327 createSmallContainer(c); 17328 self->f->pushSmallContainer(self, &c); 17329 // empty dict 17330 createSmallDict(d); 17331 self->f->pushDict(self, &d); 17332 resetO(&d); 17333 (&d)->f->setInt(&d, "a", 1); 17334 self->f->pushDict(self, &d); 17335 self->f->pushDouble(self, 2); 17336 self->f->pushInt(self, 5); 17337 self->f->pushS(self, " "); 17338 self->f->pushS(self, "asd"); 17339 // empty Array 17340 createSmallArray(a); 17341 self->f->pushArray(self, &a); 17342 resetO(&a); 17343 (&a)->f->pushInt(&a, 1); 17344 self->f->pushArray(self, &a); 17345 // empty bytes 17346 createSmallBytes(b); 17347 self->f->pushSmallBytes(self, &b); 17348 smallBytest *B = allocSmallBytes("asd", 4); 17349 self->f->pushNFreeSmallBytes(self, B); 17350 r = compactO(self); 17351 ck_assert_ptr_ne(r, NULL); 17352 ck_assert_int_eq(lenO(r), 8); 17353 char *s = toStringO(r); 17354 ck_assert_str_eq(s, "[true,\"<data container>\",{\"a\":1},2.000000e+00,5,\"asd\",[1],[0x61,0x73,0x64,0x00]]"); 17355 free(s); 17356 // array with blank elements, becomes empty after compact 17357 // self->a should not be null 17358 // self->a should an empty sArray to avoid issues with the setP function 17359 self->f->free(self); 17360 self->f->pushS(self, " "); 17361 self->f->pushS(self, ""); 17362 r = compactO(self); 17363 ck_assert_ptr_ne(r, NULL); 17364 ck_assert_ptr_ne(r->a, NULL); 17365 ck_assert_int_eq(lenO(r), 0); 17366 s = toStringO(r); 17367 ck_assert_str_eq(s, "[]"); 17368 free(s); 17369 // empty array 17370 emptyO(self); 17371 r = compactO(self); 17372 ck_assert_ptr_eq(r, NULL); 17373 terminateO(self); 17374 17375 } 17376 17377 17378 void isBlankSmallArrayT(void) { 17379 17380 bool r; 17381 smallArrayt *self = allocG(rtSmallArrayt); 17382 17383 // bool 17384 self->f->pushBool(self, true); 17385 r = isBlankO(self); 17386 ck_assert(!r); 17387 // container 17388 emptyO(self); 17389 createSmallContainer(c); 17390 self->f->pushSmallContainer(self, &c); 17391 r = isBlankO(self); 17392 ck_assert(!r); 17393 // blank dict 17394 emptyO(self); 17395 createSmallDict(d); 17396 self->f->pushDict(self, &d); 17397 r = isBlankO(self); 17398 ck_assert(r); 17399 // dict 17400 emptyO(self); 17401 resetO(&d); 17402 (&d)->f->setInt(&d, "a", 1); 17403 self->f->pushDict(self, &d); 17404 r = isBlankO(self); 17405 ck_assert(!r); 17406 // double 17407 emptyO(self); 17408 self->f->pushDouble(self, 0); 17409 r = isBlankO(self); 17410 ck_assert(!r); 17411 // int 17412 emptyO(self); 17413 self->f->pushInt(self, 0); 17414 r = isBlankO(self); 17415 ck_assert(!r); 17416 // blank string 17417 emptyO(self); 17418 self->f->pushS(self, " "); 17419 r = isBlankO(self); 17420 ck_assert(r); 17421 // string 17422 emptyO(self); 17423 self->f->pushS(self, "asd"); 17424 r = isBlankO(self); 17425 ck_assert(!r); 17426 // blank dict 17427 emptyO(self); 17428 createSmallArray(a); 17429 self->f->pushArray(self, &a); 17430 r = isBlankO(self); 17431 ck_assert(r); 17432 // dict 17433 emptyO(self); 17434 resetO(&a); 17435 (&a)->f->pushInt(&a, 1); 17436 self->f->pushArray(self, &a); 17437 r = isBlankO(self); 17438 ck_assert(!r); 17439 // blank Bytes 17440 emptyO(self); 17441 createSmallBytes(b); 17442 self->f->pushSmallBytes(self, &b); 17443 r = isBlankO(self); 17444 ck_assert(r); 17445 // Bytes 17446 emptyO(self); 17447 smallBytest *B = allocSmallBytes("asd", 4); 17448 self->f->pushNFreeSmallBytes(self, B); 17449 r = isBlankO(self); 17450 ck_assert(!r); 17451 // empty array 17452 emptyO(self); 17453 r = isBlankO(self); 17454 ck_assert(r); 17455 terminateO(self); 17456 17457 } 17458 17459 17460 bool fef(void *closure UNUSED, baset *e) { 17461 bool r = true; 17462 if (isOUndefined(e)) r = true; 17463 elif (isOSmallInt(e)) r = false; 17464 else { 17465 static u16 c; 17466 r = !c; 17467 c++; 17468 } 17469 return r; 17470 } 17471 17472 void forEachSmallArrayFT(void) { 17473 17474 smallArrayt *self = allocG(rtSmallArrayt); 17475 17476 // empty 17477 self->f->forEach(self, NULL, fef); 17478 // array with elements 17479 self->f->pushUndefined(self); 17480 self->f->pushBool(self, true); 17481 // base class 17482 createAllocateSmallInt(i); 17483 i->type = "userclass"; 17484 self->f->push(self, (baset*)i); 17485 createAllocateSmallInt(j); 17486 j->type = "userclass"; 17487 self->f->push(self, (baset*)j); 17488 delElemO(self, 1); 17489 self->f->pushInt(self, 2); 17490 self->f->forEach(self, NULL, fef); 17491 self->f->del(self, 2, 4); 17492 self->f->forEach(self, NULL, fef); 17493 terminateO(self); 17494 17495 } 17496 17497 17498 bool ef(void *closure UNUSED, u64 i UNUSED, baset *e) { 17499 bool r = true; 17500 if (isOUndefined(e)) r = true; 17501 elif (isOSmallInt(e)) r = false; 17502 else { 17503 static u16 c; 17504 r = !c; 17505 c++; 17506 } 17507 return r; 17508 } 17509 17510 void enumerateSmallArrayFT(void) { 17511 17512 smallArrayt *self = allocG(rtSmallArrayt); 17513 17514 // empty 17515 self->f->enumerate(self, NULL, ef); 17516 // array with elements 17517 self->f->pushUndefined(self); 17518 self->f->pushBool(self, true); 17519 // base class 17520 createAllocateSmallInt(i); 17521 i->type = "userclass"; 17522 self->f->push(self, (baset*)i); 17523 createAllocateSmallInt(j); 17524 j->type = "userclass"; 17525 self->f->push(self, (baset*)j); 17526 delElemO(self, 1); 17527 self->f->pushInt(self, 2); 17528 self->f->enumerate(self, NULL, ef); 17529 self->f->del(self, 2, 4); 17530 self->f->enumerate(self, NULL, ef); 17531 terminateO(self); 17532 17533 } 17534 17535 17536 void iterStartSmallArrayT(void) { 17537 17538 baset* r; 17539 smallArrayt *self = allocG(rtSmallArrayt); 17540 17541 // array with sObjects 17542 self->f->pushUndefined(self); 17543 self->f->pushBool(self, true); 17544 r = iterStartO(self); 17545 ck_assert_ptr_ne(r, NULL); 17546 ck_assert(isOUndefined(r)); 17547 // start again 17548 r = iterStartO(self); 17549 ck_assert_ptr_ne(r, NULL); 17550 ck_assert(isOUndefined(r)); 17551 // array with objects from other classes 17552 emptyO(self); 17553 createAllocateSmallInt(ip); 17554 ip->type = "anothertype"; 17555 setValG(ip, 11); 17556 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17557 ck_assert_ptr_ne(r2, NULL); 17558 r = iterStartO(self); 17559 ck_assert_ptr_ne(r, NULL); 17560 // array with all deleted elements 17561 emptyO(self); 17562 self->f->pushUndefined(self); 17563 delElemO(self, 0); 17564 r = iterStartO(self); 17565 ck_assert_ptr_eq(r, NULL); 17566 // empty array 17567 emptyO(self); 17568 r = iterStartO(self); 17569 ck_assert_ptr_eq(r, NULL); 17570 terminateO(self); 17571 17572 } 17573 17574 17575 void iterStartLastSmallArrayT(void) { 17576 17577 baset* r; 17578 smallArrayt *self = allocG(rtSmallArrayt); 17579 17580 // array with sObjects 17581 self->f->pushUndefined(self); 17582 self->f->pushBool(self, true); 17583 r = iterStartLastO(self); 17584 ck_assert_ptr_ne(r, NULL); 17585 ck_assert(isOSmallBool(r)); 17586 // start again 17587 r = iterStartLastO(self); 17588 ck_assert_ptr_ne(r, NULL); 17589 ck_assert(isOSmallBool(r)); 17590 // array with objects from other classes 17591 emptyO(self); 17592 createAllocateSmallInt(ip); 17593 ip->type = "anothertype"; 17594 setValG(ip, 11); 17595 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17596 ck_assert_ptr_ne(r2, NULL); 17597 r = iterStartLastO(self); 17598 ck_assert_ptr_ne(r, NULL); 17599 ck_assert(isOType(r, "anothertype")); 17600 // array with all deleted elements 17601 emptyO(self); 17602 self->f->pushUndefined(self); 17603 delElemO(self, 0); 17604 r = iterStartLastO(self); 17605 ck_assert_ptr_eq(r, NULL); 17606 // empty array 17607 emptyO(self); 17608 r = iterStartLastO(self); 17609 ck_assert_ptr_eq(r, NULL); 17610 terminateO(self); 17611 17612 } 17613 17614 17615 void iterStartFromSmallArrayT(void) { 17616 17617 baset* r; 17618 smallArrayt *self = allocG(rtSmallArrayt); 17619 17620 // array with sObjects 17621 self->f->pushUndefined(self); 17622 self->f->pushBool(self, true); 17623 r = iterStartFromO(self, 1); 17624 ck_assert_ptr_ne(r, NULL); 17625 ck_assert(isOSmallBool(r)); 17626 // start again 17627 r = iterStartFromO(self, 1); 17628 ck_assert_ptr_ne(r, NULL); 17629 ck_assert(isOSmallBool(r)); 17630 // array with objects from other classes 17631 emptyO(self); 17632 self->f->pushUndefined(self); 17633 createAllocateSmallInt(ip); 17634 ip->type = "anothertype"; 17635 setValG(ip, 11); 17636 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17637 ck_assert_ptr_ne(r2, NULL); 17638 r = iterStartFromO(self, -1); 17639 ck_assert_ptr_ne(r, NULL); 17640 ck_assert(isOType(r, "anothertype")); 17641 // index outside array 17642 r = iterStartFromO(self, 2); 17643 ck_assert_ptr_eq(r, NULL); 17644 r = iterStartFromO(self, -3); 17645 ck_assert_ptr_eq(r, NULL); 17646 // array with all deleted elements 17647 // except the ones before the start index 17648 emptyO(self); 17649 self->f->pushUndefined(self); 17650 self->f->pushUndefined(self); 17651 self->f->pushUndefined(self); 17652 delElemO(self, 1); 17653 delElemO(self, 2); 17654 r = iterStartFromO(self, 1); 17655 ck_assert_ptr_eq(r, NULL); 17656 // array with all deleted elements 17657 emptyO(self); 17658 self->f->pushUndefined(self); 17659 self->f->pushUndefined(self); 17660 self->f->pushUndefined(self); 17661 delElemO(self, 0); 17662 delElemO(self, 1); 17663 delElemO(self, 2); 17664 r = iterStartFromO(self, 1); 17665 ck_assert_ptr_eq(r, NULL); 17666 // empty array 17667 emptyO(self); 17668 r = iterStartFromO(self, 1); 17669 ck_assert_ptr_eq(r, NULL); 17670 terminateO(self); 17671 17672 } 17673 17674 17675 void iterStartFromStepSmallArrayT(void) { 17676 17677 baset* r; 17678 smallArrayt *self = allocG(rtSmallArrayt); 17679 17680 // array with sObjects 17681 self->f->pushUndefined(self); 17682 self->f->pushBool(self, true); 17683 r = iterStartFromStepO(self, 1, 2); 17684 ck_assert_ptr_ne(r, NULL); 17685 ck_assert(isOSmallBool(r)); 17686 // start again 17687 r = iterStartFromStepO(self, 1, 2); 17688 ck_assert_ptr_ne(r, NULL); 17689 ck_assert(isOSmallBool(r)); 17690 // array with objects from other classes 17691 emptyO(self); 17692 self->f->pushUndefined(self); 17693 createAllocateSmallInt(ip); 17694 ip->type = "anothertype"; 17695 setValG(ip, 11); 17696 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17697 ck_assert_ptr_ne(r2, NULL); 17698 r = iterStartFromStepO(self, -1, 2); 17699 ck_assert_ptr_ne(r, NULL); 17700 ck_assert(isOType(r, "anothertype")); 17701 // index outside array 17702 r = iterStartFromStepO(self, 2, 1); 17703 ck_assert_ptr_eq(r, NULL); 17704 r = iterStartFromStepO(self, -3, 1); 17705 ck_assert_ptr_eq(r, NULL); 17706 // array with all deleted elements 17707 // except the ones before the start index 17708 emptyO(self); 17709 self->f->pushUndefined(self); 17710 self->f->pushUndefined(self); 17711 self->f->pushUndefined(self); 17712 delElemO(self, 1); 17713 delElemO(self, 2); 17714 r = iterStartFromStepO(self, 1, 1); 17715 ck_assert_ptr_eq(r, NULL); 17716 // negative step 17717 r = iterStartFromStepO(self, 1, -1); 17718 ck_assert_ptr_ne(r, NULL); 17719 ck_assert(isOUndefined(r)); 17720 // array with all deleted elements 17721 emptyO(self); 17722 self->f->pushUndefined(self); 17723 self->f->pushUndefined(self); 17724 self->f->pushUndefined(self); 17725 delElemO(self, 0); 17726 delElemO(self, 1); 17727 delElemO(self, 2); 17728 r = iterStartFromStepO(self, 1, 2); 17729 ck_assert_ptr_eq(r, NULL); 17730 // empty array 17731 emptyO(self); 17732 r = iterStartFromStepO(self, 1, 1); 17733 ck_assert_ptr_eq(r, NULL); 17734 // step 0 17735 self->f->pushUndefined(self); 17736 r = iterStartFromStepO(self, 0, 0); 17737 ck_assert_ptr_eq(r, NULL); 17738 terminateO(self); 17739 17740 } 17741 17742 17743 void iterNextSmallArrayT(void) { 17744 17745 baset* r; 17746 smallArrayt *self = allocG(rtSmallArrayt); 17747 17748 // array with sObjects 17749 self->f->pushUndefined(self); 17750 self->f->pushBool(self, true); 17751 r = iterStartO(self); 17752 ck_assert_ptr_ne(r, NULL); 17753 ck_assert(isOUndefined(r)); 17754 r = iterNextO(self); 17755 ck_assert(isOSmallBool(r)); 17756 // array with objects from other classes 17757 emptyO(self); 17758 createAllocateSmallInt(ip); 17759 ip->type = "anothertype"; 17760 setValG(ip, 11); 17761 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17762 ck_assert_ptr_ne(r2, NULL); 17763 createAllocateSmallInt(ip2); 17764 ip2->type = "anothertype2"; 17765 setValG(ip2, 11); 17766 r2 = self->f->push(self, (baset*)ip2); 17767 ck_assert_ptr_ne(r2, NULL); 17768 r = iterStartO(self); 17769 ck_assert_ptr_ne(r, NULL); 17770 ck_assert(isOType(r, "anothertype")); 17771 r = iterNextO(self); 17772 ck_assert_ptr_ne(r, NULL); 17773 ck_assert_str_eq(r->type, "anothertype2"); 17774 // iteration ended 17775 r = iterNextO(self); 17776 ck_assert_ptr_eq(r, NULL); 17777 // array with all deleted elements 17778 emptyO(self); 17779 self->f->pushUndefined(self); 17780 delElemO(self, 0); 17781 r = iterStartO(self); 17782 ck_assert_ptr_eq(r, NULL); 17783 // empty array 17784 emptyO(self); 17785 r = iterStartO(self); 17786 ck_assert_ptr_eq(r, NULL); 17787 // empty array, uninitialized iterator 17788 emptyO(self); 17789 r = iterNextO(self); 17790 ck_assert_ptr_eq(r, NULL); 17791 terminateO(self); 17792 17793 } 17794 17795 17796 void iterElementSmallArrayT(void) { 17797 17798 baset* r; 17799 smallArrayt *self = allocG(rtSmallArrayt); 17800 17801 // start iteration 17802 self->f->pushUndefined(self); 17803 r = iterStartO(self); 17804 ck_assert_ptr_ne(r, NULL); 17805 baset *r2 = iterElementO(self); 17806 ck_assert_ptr_eq(r, r2); 17807 ck_assert_str_eq(r->type, "undefined"); 17808 // end iteration 17809 r = iterNextO(self); 17810 ck_assert_ptr_eq(r, NULL); 17811 r = iterElementO(self); 17812 ck_assert_ptr_eq(r, NULL); 17813 terminateO(self); 17814 17815 } 17816 17817 17818 void iterIndexSmallArrayT(void) { 17819 17820 ssize_t r; 17821 baset* r2; 17822 smallArrayt *self = allocG(rtSmallArrayt); 17823 17824 // start iteration 17825 self->f->pushUndefined(self); 17826 r2 = iterStartO(self); 17827 ck_assert_ptr_ne(r2, NULL); 17828 ck_assert_str_eq(r2->type, "undefined"); 17829 r = iterIndexO(self); 17830 ck_assert_int_eq(r, 0); 17831 // end iteration 17832 r2 = iterNextO(self); 17833 ck_assert_ptr_eq(r2, NULL); 17834 r = iterIndexO(self); 17835 ck_assert_int_eq(r, -1); 17836 terminateO(self); 17837 17838 } 17839 17840 17841 void iterStepSmallArrayT(void) { 17842 17843 int64_t r; 17844 baset* r2; 17845 smallArrayt *self = allocG(rtSmallArrayt); 17846 17847 // start iteration 17848 self->f->pushUndefined(self); 17849 r2 = iterStartO(self); 17850 ck_assert_ptr_ne(r2, NULL); 17851 ck_assert_str_eq(r2->type, "undefined"); 17852 r = iterStepO(self); 17853 ck_assert_int_eq(r, 1); 17854 // start iterator twice and 17855 // set step 17856 r2 =iterStartFromStepO(self, 0, 10); 17857 ck_assert_ptr_ne(r2, NULL); 17858 ck_assert_str_eq(r2->type, "undefined"); 17859 r = iterStepO(self); 17860 ck_assert_int_eq(r, 10); 17861 terminateO(self); 17862 17863 } 17864 17865 17866 void joinSmallArrayT(void) { 17867 17868 smallStringt* r; 17869 smallArrayt *self = allocG(rtSmallArrayt); 17870 17871 // join non string objects 17872 self->f->pushUndefined(self); 17873 self->f->pushInt(self, 123); 17874 r = joinO(self, ";"); 17875 ck_assert_ptr_ne(r, NULL); 17876 char *s = toStringO(r); 17877 terminateO(r); 17878 ck_assert_str_eq(s, "null;123"); 17879 free(s); 17880 // join strings 17881 emptyO(self); 17882 self->f->pushS(self, "a"); 17883 self->f->pushS(self, "b"); 17884 self->f->pushS(self, "c"); 17885 self->f->pushS(self, "d"); 17886 delElemO(self, 1); 17887 r = joinO(self, ";"); 17888 ck_assert_ptr_ne(r, NULL); 17889 s = toStringO(r); 17890 terminateO(r); 17891 ck_assert_str_eq(s, "a;c;d"); 17892 free(s); 17893 // null delimiter 17894 r = joinO(self, NULL); 17895 ck_assert_ptr_eq(r, NULL); 17896 // empty array 17897 emptyO(self); 17898 r = joinO(self, ";"); 17899 ck_assert_ptr_eq(r, NULL); 17900 terminateO(self); 17901 17902 } 17903 17904 17905 void joinCharSmallArrayT(void) { 17906 17907 smallStringt* r; 17908 smallArrayt *self = allocG(rtSmallArrayt); 17909 17910 // join non string objects 17911 self->f->pushUndefined(self); 17912 self->f->pushInt(self, 123); 17913 r = joinCharO(self, ';'); 17914 ck_assert_ptr_ne(r, NULL); 17915 char *s = toStringO(r); 17916 terminateO(r); 17917 ck_assert_str_eq(s, "null;123"); 17918 free(s); 17919 // join strings 17920 emptyO(self); 17921 self->f->pushS(self, "a"); 17922 self->f->pushS(self, "b"); 17923 self->f->pushS(self, "c"); 17924 self->f->pushS(self, "d"); 17925 delElemO(self, 1); 17926 r = joinCharO(self, ';'); 17927 ck_assert_ptr_ne(r, NULL); 17928 s = toStringO(r); 17929 terminateO(r); 17930 ck_assert_str_eq(s, "a;c;d"); 17931 free(s); 17932 // empty array 17933 emptyO(self); 17934 r = joinCharO(self, ';'); 17935 ck_assert_ptr_eq(r, NULL); 17936 terminateO(self); 17937 17938 } 17939 17940 17941 void joinSmallJsonSmallArrayT(void) { 17942 17943 smallStringt* r; 17944 smallArrayt *self = allocG(rtSmallArrayt); 17945 smallJsont* delim = allocSmallJson(); 17946 17947 // join non string objects 17948 setTopSO(delim, ";"); 17949 self->f->pushUndefined(self); 17950 self->f->pushInt(self, 123); 17951 r = self->f->joinSmallJson(self, delim); 17952 ck_assert_ptr_ne(r, NULL); 17953 char *s = toStringO(r); 17954 terminateO(r); 17955 ck_assert_str_eq(s, "null;123"); 17956 free(s); 17957 // join strings 17958 emptyO(self); 17959 self->f->pushS(self, "a"); 17960 self->f->pushS(self, "b"); 17961 self->f->pushS(self, "c"); 17962 self->f->pushS(self, "d"); 17963 delElemO(self, 1); 17964 r = self->f->joinSmallJson(self, delim); 17965 ck_assert_ptr_ne(r, NULL); 17966 s = toStringO(r); 17967 terminateO(r); 17968 ck_assert_str_eq(s, "a;c;d"); 17969 free(s); 17970 // delimiter not a string 17971 freeO(delim); 17972 setTopIntO(delim, 1); 17973 r = self->f->joinSmallJson(self, delim); 17974 ck_assert_ptr_eq(r, NULL); 17975 // non smallJson object 17976 terminateO(delim); 17977 delim = (smallJsont*) allocSmallInt(2); 17978 r = self->f->joinSmallJson(self, delim); 17979 ck_assert_ptr_eq(r, NULL); 17980 // null delimiter 17981 r = self->f->joinSmallJson(self, NULL); 17982 ck_assert_ptr_eq(r, NULL); 17983 // empty array 17984 emptyO(self); 17985 freeO(delim); 17986 setTopSO(delim, ";"); 17987 r = self->f->joinSmallJson(self, delim); 17988 ck_assert_ptr_eq(r, NULL); 17989 terminateO(self); 17990 terminateO(delim); 17991 17992 } 17993 17994 17995 void joinSmallStringSmallArrayT(void) { 17996 17997 smallStringt* r; 17998 smallArrayt *self = allocG(rtSmallArrayt); 17999 smallStringt* delim = allocSmallString(";"); 18000 18001 // join non string objects 18002 self->f->pushUndefined(self); 18003 self->f->pushInt(self, 123); 18004 r = joinSmallStringO(self, delim); 18005 ck_assert_ptr_ne(r, NULL); 18006 char *s = toStringO(r); 18007 terminateO(r); 18008 ck_assert_str_eq(s, "null;123"); 18009 free(s); 18010 // join strings 18011 emptyO(self); 18012 self->f->pushS(self, "a"); 18013 self->f->pushS(self, "b"); 18014 self->f->pushS(self, "c"); 18015 self->f->pushS(self, "d"); 18016 delElemO(self, 1); 18017 r = joinSmallStringO(self, delim); 18018 ck_assert_ptr_ne(r, NULL); 18019 s = toStringO(r); 18020 terminateO(r); 18021 ck_assert_str_eq(s, "a;c;d"); 18022 free(s); 18023 // delimiter with no string 18024 freeO(delim); 18025 r = joinSmallStringO(self, delim); 18026 ck_assert_ptr_eq(r, NULL); 18027 // null delimiter 18028 r = joinSmallStringO(self, NULL); 18029 ck_assert_ptr_eq(r, NULL); 18030 // empty array 18031 emptyO(self); 18032 setValO(delim, ";"); 18033 r = joinSmallStringO(self, delim); 18034 ck_assert_ptr_eq(r, NULL); 18035 terminateO(self); 18036 terminateO(delim); 18037 18038 } 18039 18040 18041 void joinSSmallArrayT(void) { 18042 18043 char* r; 18044 smallArrayt *self = allocG(rtSmallArrayt); 18045 18046 // join non string objects 18047 self->f->pushUndefined(self); 18048 self->f->pushInt(self, 123); 18049 r = self->f->joinS(self, ";"); 18050 ck_assert_ptr_ne(r, NULL); 18051 ck_assert_str_eq(r, "null;123"); 18052 free(r); 18053 // join strings 18054 emptyO(self); 18055 self->f->pushS(self, "a"); 18056 self->f->pushS(self, "b"); 18057 self->f->pushS(self, "c"); 18058 self->f->pushS(self, "d"); 18059 delElemO(self, 1); 18060 r = self->f->joinS(self, ";"); 18061 ck_assert_ptr_ne(r, NULL); 18062 ck_assert_str_eq(r, "a;c;d"); 18063 free(r); 18064 // null delimiter 18065 r = self->f->joinS(self, NULL); 18066 ck_assert_ptr_eq(r, NULL); 18067 // empty array 18068 emptyO(self); 18069 r = self->f->joinS(self, ";"); 18070 ck_assert_ptr_eq(r, NULL); 18071 terminateO(self); 18072 18073 } 18074 18075 18076 void joinCharSSmallArrayT(void) { 18077 18078 char* r; 18079 smallArrayt *self = allocG(rtSmallArrayt); 18080 18081 // join non string objects 18082 self->f->pushUndefined(self); 18083 self->f->pushInt(self, 123); 18084 r = joinCharSO(self, ';'); 18085 ck_assert_ptr_ne(r, NULL); 18086 ck_assert_str_eq(r, "null;123"); 18087 free(r); 18088 // join strings 18089 emptyO(self); 18090 self->f->pushS(self, "a"); 18091 self->f->pushS(self, "b"); 18092 self->f->pushS(self, "c"); 18093 self->f->pushS(self, "d"); 18094 delElemO(self, 1); 18095 r = joinCharSO(self, ';'); 18096 ck_assert_ptr_ne(r, NULL); 18097 ck_assert_str_eq(r, "a;c;d"); 18098 free(r); 18099 // empty array 18100 emptyO(self); 18101 r = joinCharSO(self, ';'); 18102 ck_assert_ptr_eq(r, NULL); 18103 terminateO(self); 18104 18105 } 18106 18107 18108 void joinSmallJsonSSmallArrayT(void) { 18109 18110 char* r; 18111 smallArrayt *self = allocG(rtSmallArrayt); 18112 smallJsont* delim = allocSmallJson(); 18113 18114 // join non string objects 18115 setTopSO(delim, ";"); 18116 self->f->pushUndefined(self); 18117 self->f->pushInt(self, 123); 18118 r = joinSmallJsonSO(self, delim); 18119 ck_assert_ptr_ne(r, NULL); 18120 ck_assert_str_eq(r, "null;123"); 18121 free(r); 18122 // join strings 18123 emptyO(self); 18124 self->f->pushS(self, "a"); 18125 self->f->pushS(self, "b"); 18126 self->f->pushS(self, "c"); 18127 self->f->pushS(self, "d"); 18128 delElemO(self, 1); 18129 r = joinSmallJsonSO(self, delim); 18130 ck_assert_ptr_ne(r, NULL); 18131 ck_assert_str_eq(r, "a;c;d"); 18132 free(r); 18133 // delimiter not a string 18134 freeO(delim); 18135 setTopIntO(delim, 1); 18136 r = joinSmallJsonSO(self, delim); 18137 ck_assert_ptr_eq(r, NULL); 18138 // non smallJson object 18139 terminateO(delim); 18140 delim = (smallJsont*) allocSmallInt(2); 18141 r = joinSmallJsonSO(self, delim); 18142 ck_assert_ptr_eq(r, NULL); 18143 // null delimiter 18144 r = joinSmallJsonSO(self, NULL); 18145 ck_assert_ptr_eq(r, NULL); 18146 // empty array 18147 emptyO(self); 18148 freeO(delim); 18149 setTopSO(delim, ";"); 18150 r = joinSmallJsonSO(self, delim); 18151 ck_assert_ptr_eq(r, NULL); 18152 terminateO(self); 18153 terminateO(delim); 18154 18155 } 18156 18157 18158 void joinSmallStringSSmallArrayT(void) { 18159 18160 char* r; 18161 smallArrayt *self = allocG(rtSmallArrayt); 18162 smallStringt* delim = allocSmallString(";"); 18163 18164 // join non string objects 18165 self->f->pushUndefined(self); 18166 self->f->pushInt(self, 123); 18167 r = joinSmallStringSO(self, delim); 18168 ck_assert_ptr_ne(r, NULL); 18169 ck_assert_str_eq(r, "null;123"); 18170 free(r); 18171 // join strings 18172 emptyO(self); 18173 self->f->pushS(self, "a"); 18174 self->f->pushS(self, "b"); 18175 self->f->pushS(self, "c"); 18176 self->f->pushS(self, "d"); 18177 delElemO(self, 1); 18178 r = joinSmallStringSO(self, delim); 18179 ck_assert_ptr_ne(r, NULL); 18180 ck_assert_str_eq(r, "a;c;d"); 18181 free(r); 18182 // delimiter with no string 18183 freeO(delim); 18184 r = joinSmallStringSO(self, delim); 18185 ck_assert_ptr_eq(r, NULL); 18186 // null delimiter 18187 r = joinSmallStringSO(self, NULL); 18188 ck_assert_ptr_eq(r, NULL); 18189 // empty array 18190 emptyO(self); 18191 setValO(delim, ";"); 18192 r = joinSmallStringSO(self, delim); 18193 ck_assert_ptr_eq(r, NULL); 18194 terminateO(self); 18195 terminateO(delim); 18196 18197 } 18198 18199 18200 void zipSmallArrayT(void) { 18201 18202 smallArrayt* r; 18203 smallArrayt *self = allocG(rtSmallArrayt); 18204 smallArrayt *array1 = allocSmallArray(); 18205 smallArrayt *array2 = allocSmallArray(); 18206 18207 // zip arrays 18208 // add an element to self 18209 // array1 has 2 elements 18210 // array2 has 3 elements 18211 // only 2 elements are zipped 18212 self->f->pushS(self, "qwe"); 18213 array1->f->pushS(array1, "a"); 18214 array1->f->pushS(array1, "b"); 18215 array2->f->pushInt(array2, 1); 18216 array2->f->pushInt(array2, 2); 18217 array2->f->pushInt(array2, 3); 18218 r = zipO(self, array1, array2); 18219 ck_assert_ptr_ne(r, NULL); 18220 char *s = toStringO(r); 18221 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18222 free(s); 18223 // delete the element not in self 18224 delElemO(array2, 2); 18225 // empty arrays 18226 disposeO(array2); 18227 r = zipO(self, array1, array2); 18228 ck_assert_ptr_ne(r, NULL); 18229 s = toStringO(r); 18230 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18231 free(s); 18232 disposeO(array1); 18233 r = zipO(self, array1, array2); 18234 ck_assert_ptr_ne(r, NULL); 18235 s = toStringO(r); 18236 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18237 free(s); 18238 // array1 and array2 same element count 18239 array1->f->pushS(array1, "aa"); 18240 array1->f->pushS(array1, "bb"); 18241 array2->f->pushInt(array2, 11); 18242 array2->f->pushInt(array2, 22); 18243 delElemO(array1, 1); 18244 r = zipO(self, array1, array2); 18245 delElemO(array2, 1); 18246 ck_assert_ptr_ne(r, NULL); 18247 // some elements were zipped 18248 s = toStringO(self); 18249 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18250 free(s); 18251 // but an element is NULL 18252 // non smallArray objects 18253 smashO(array1); 18254 array1 = (smallArrayt*) allocSmallInt(2); 18255 r = zipO(self, array1, array2); 18256 ck_assert_ptr_eq(r, NULL); 18257 terminateO(array1); 18258 array1 = allocSmallArray(); 18259 smashO(array2); 18260 array2 = (smallArrayt*) allocSmallInt(2); 18261 r = zipO(self, array1, array2); 18262 ck_assert_ptr_eq(r, NULL); 18263 terminateO(array2); 18264 array2 = allocSmallArray(); 18265 // NULL arrays 18266 r = zipO(self, NULL, array2); 18267 ck_assert_ptr_eq(r, NULL); 18268 r = zipO(self, array1, NULL); 18269 ck_assert_ptr_eq(r, NULL); 18270 terminateO(self); 18271 smashO(array1); 18272 smashO(array2); 18273 18274 } 18275 18276 18277 void zipSmallJsonSmallArrayT(void) { 18278 18279 smallArrayt* r; 18280 smallArrayt *self = allocG(rtSmallArrayt); 18281 smallArrayt *array1 = allocSmallArray(); 18282 smallJsont *array2 = allocSmallJson(); 18283 18284 // zip arrays 18285 // add an element to self 18286 // array1 has 2 elements 18287 // array2 has 3 elements 18288 // only 2 elements are zipped 18289 self->f->pushS(self, "qwe"); 18290 array1->f->pushS(array1, "a"); 18291 array1->f->pushS(array1, "b"); 18292 array2->f->pushInt(array2, 1); 18293 array2->f->pushInt(array2, 2); 18294 array2->f->pushInt(array2, 3); 18295 r = self->f->zipSmallJson(self, array1, array2); 18296 ck_assert_ptr_ne(r, NULL); 18297 char *s = toStringO(r); 18298 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18299 free(s); 18300 // delete the element not in self 18301 delElemIndexO(array2, 2); 18302 // empty arrays 18303 disposeO(array1); 18304 r = self->f->zipSmallJson(self, array1, array2); 18305 ck_assert_ptr_ne(r, NULL); 18306 s = toStringO(r); 18307 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18308 free(s); 18309 disposeO(array2); 18310 r = self->f->zipSmallJson(self, array1, array2); 18311 ck_assert_ptr_eq(r, NULL); 18312 // array1 and array2 same element count 18313 array1->f->pushS(array1, "aa"); 18314 array1->f->pushS(array1, "bb"); 18315 array2->f->pushInt(array2, 11); 18316 array2->f->pushInt(array2, 22); 18317 delElemO(array1, 1); 18318 r = self->f->zipSmallJson(self, array1, array2); 18319 delElemIndexO(array2, 1); 18320 ck_assert_ptr_ne(r, NULL); 18321 // some elements were zipped 18322 s = toStringO(self); 18323 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18324 free(s); 18325 // but an element is NULL 18326 // non smallArray objects 18327 smashO(array1); 18328 array1 = (smallArrayt*) allocSmallInt(2); 18329 r = self->f->zipSmallJson(self, array1, array2); 18330 ck_assert_ptr_eq(r, NULL); 18331 terminateO(array1); 18332 array1 = allocSmallArray(); 18333 smashO(array2); 18334 array2 = (smallJsont*) allocSmallInt(2); 18335 r = self->f->zipSmallJson(self, array1, array2); 18336 ck_assert_ptr_eq(r, NULL); 18337 terminateO(array2); 18338 array2 = allocSmallJson(); 18339 // NULL arrays 18340 r = self->f->zipSmallJson(self, NULL, array2); 18341 ck_assert_ptr_eq(r, NULL); 18342 r = self->f->zipSmallJson(self, array1, NULL); 18343 ck_assert_ptr_eq(r, NULL); 18344 terminateO(self); 18345 smashO(array1); 18346 smashO(array2); 18347 18348 } 18349 18350 18351 void zipSmallJsonSmallArraySmallArrayT(void) { 18352 18353 smallArrayt* r; 18354 smallArrayt *self = allocG(rtSmallArrayt); 18355 smallJsont *array1 = allocSmallJson(); 18356 smallArrayt *array2 = allocSmallArray(); 18357 18358 // zip arrays 18359 // add an element to self 18360 // array1 has 2 elements 18361 // array2 has 3 elements 18362 // only 2 elements are zipped 18363 self->f->pushS(self, "qwe"); 18364 array1->f->pushS(array1, "a"); 18365 array1->f->pushS(array1, "b"); 18366 array2->f->pushInt(array2, 1); 18367 array2->f->pushInt(array2, 2); 18368 array2->f->pushInt(array2, 3); 18369 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18370 ck_assert_ptr_ne(r, NULL); 18371 char *s = toStringO(r); 18372 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18373 free(s); 18374 // delete the element not in self 18375 delElemO(array2, 2); 18376 // empty arrays 18377 disposeO(array2); 18378 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18379 ck_assert_ptr_ne(r, NULL); 18380 s = toStringO(r); 18381 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18382 free(s); 18383 disposeO(array1); 18384 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18385 ck_assert_ptr_eq(r, NULL); 18386 // array1 and array2 same element count 18387 array1->f->pushS(array1, "aa"); 18388 array1->f->pushS(array1, "bb"); 18389 array2->f->pushInt(array2, 11); 18390 array2->f->pushInt(array2, 22); 18391 delElemIndexO(array1, 1); 18392 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18393 delElemO(array2, 1); 18394 ck_assert_ptr_ne(r, NULL); 18395 // some elements were zipped 18396 s = toStringO(self); 18397 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18398 free(s); 18399 // but an element is NULL 18400 // non smallArray objects 18401 smashO(array1); 18402 array1 = (smallJsont*) allocSmallInt(2); 18403 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18404 ck_assert_ptr_eq(r, NULL); 18405 terminateO(array1); 18406 array1 = allocSmallJson(); 18407 smashO(array2); 18408 array2 = (smallArrayt*) allocSmallInt(2); 18409 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18410 ck_assert_ptr_eq(r, NULL); 18411 terminateO(array2); 18412 array2 = allocSmallArray(); 18413 // NULL arrays 18414 r = self->f->zipSmallJsonSmallArray(self, NULL, array2); 18415 ck_assert_ptr_eq(r, NULL); 18416 r = self->f->zipSmallJsonSmallArray(self, array1, NULL); 18417 ck_assert_ptr_eq(r, NULL); 18418 terminateO(self); 18419 smashO(array1); 18420 smashO(array2); 18421 18422 } 18423 18424 18425 void zipSmallJsonSmallJsonSmallArrayT(void) { 18426 18427 smallArrayt* r; 18428 smallArrayt *self = allocG(rtSmallArrayt); 18429 smallJsont *array1 = allocSmallJson(); 18430 smallJsont *array2 = allocSmallJson(); 18431 18432 // zip arrays 18433 // add an element to self 18434 // array1 has 2 elements 18435 // array2 has 3 elements 18436 // only 2 elements are zipped 18437 self->f->pushS(self, "qwe"); 18438 array1->f->pushS(array1, "a"); 18439 array1->f->pushS(array1, "b"); 18440 array2->f->pushInt(array2, 1); 18441 array2->f->pushInt(array2, 2); 18442 array2->f->pushInt(array2, 3); 18443 r = zipSmallJsonSmallJsonO(self, array1, array2); 18444 ck_assert_ptr_ne(r, NULL); 18445 char *s = toStringO(r); 18446 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18447 free(s); 18448 // delete the element not in self 18449 delElemIndexO(array2, 2); 18450 // empty arrays 18451 disposeO(array1); 18452 r = zipSmallJsonSmallJsonO(self, array1, array2); 18453 ck_assert_ptr_eq(r, NULL); 18454 disposeO(array2); 18455 array1->f->pushS(array1, "a"); 18456 r = zipSmallJsonSmallJsonO(self, array1, array2); 18457 ck_assert_ptr_eq(r, NULL); 18458 array2->f->pushInt(array2, 1); 18459 delElemIndexO(array2, 0); 18460 r = zipSmallJsonSmallJsonO(self, array1, array2); 18461 ck_assert_ptr_ne(r, NULL); 18462 s = toStringO(r); 18463 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"a\"]]"); 18464 free(s); 18465 disposeO(array1); 18466 trimO(array2); 18467 // array1 and array2 same element count 18468 array1->f->pushS(array1, "aa"); 18469 array1->f->pushS(array1, "bb"); 18470 array2->f->pushInt(array2, 11); 18471 array2->f->pushInt(array2, 22); 18472 delElemIndexO(array1, 1); 18473 r = zipSmallJsonSmallJsonO(self, array1, array2); 18474 delElemIndexO(array2, 1); 18475 ck_assert_ptr_ne(r, NULL); 18476 // some elements were zipped 18477 s = toStringO(self); 18478 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"a\"],[\"aa\",11]]"); 18479 free(s); 18480 // but an element is NULL 18481 // non smallJson objects 18482 smashO(array1); 18483 array1 = (smallJsont*) allocSmallInt(2); 18484 r = zipSmallJsonSmallJsonO(self, array1, array2); 18485 ck_assert_ptr_eq(r, NULL); 18486 terminateO(array1); 18487 array1 = allocSmallJson(); 18488 smashO(array2); 18489 array2 = (smallJsont*) allocSmallInt(2); 18490 r = zipSmallJsonSmallJsonO(self, array1, array2); 18491 ck_assert_ptr_eq(r, NULL); 18492 terminateO(array2); 18493 array2 = allocSmallJson(); 18494 // NULL arrays 18495 r = zipSmallJsonSmallJsonO(self, NULL, array2); 18496 ck_assert_ptr_eq(r, NULL); 18497 r = zipSmallJsonSmallJsonO(self, array1, NULL); 18498 ck_assert_ptr_eq(r, NULL); 18499 terminateO(self); 18500 smashO(array1); 18501 smashO(array2); 18502 18503 } 18504 18505 18506 void zipSmallJsonCharSmallArrayT(void) { 18507 18508 smallArrayt* r; 18509 smallArrayt *self = allocG(rtSmallArrayt); 18510 smallJsont *array1 = allocSmallJson(); 18511 char **array2; 18512 18513 // zip arrays 18514 // add an element to self 18515 // array1 has 2 elements 18516 // array2 has 3 elements 18517 // only 2 elements are zipped 18518 self->f->pushS(self, "qwe"); 18519 array1->f->pushS(array1, "a"); 18520 array1->f->pushS(array1, "b"); 18521 array2 = listCreateS("1", "2", "3"); 18522 r = zipSmallJsonCharO(self, array1, array2); 18523 ck_assert_ptr_ne(r, NULL); 18524 char *s = toStringO(r); 18525 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18526 free(s); 18527 // delete the element not in self 18528 iListDelElemS(&array2, 2); 18529 // empty arrays 18530 iListRemoveS(&array2, 0, 2); 18531 r = zipSmallJsonCharO(self, array1, array2); 18532 ck_assert_ptr_ne(r, NULL); 18533 s = toStringO(r); 18534 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18535 free(s); 18536 disposeO(array1); 18537 r = zipSmallJsonCharO(self, array1, array2); 18538 ck_assert_ptr_eq(r, NULL); 18539 free(array2); 18540 // array1 and array2 same element count 18541 array1->f->pushS(array1, "aa"); 18542 array1->f->pushS(array1, "bb"); 18543 array2 = listCreateS("11", "22"); 18544 delElemIndexO(array1, 1); 18545 r = zipSmallJsonCharO(self, array1, array2); 18546 iListDelElemS(&array2, 1); 18547 ck_assert_ptr_ne(r, NULL); 18548 // some elements were zipped 18549 s = toStringO(self); 18550 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 18551 free(s); 18552 // but an element is NULL 18553 // non smallJson objects 18554 smashO(array1); 18555 array1 = (smallJsont*) allocSmallInt(2); 18556 r = zipSmallJsonCharO(self, array1, array2); 18557 ck_assert_ptr_eq(r, NULL); 18558 terminateO(array1); 18559 array1 = allocSmallJson(); 18560 // NULL arrays 18561 r = zipSmallJsonCharO(self, NULL, array2); 18562 ck_assert_ptr_eq(r, NULL); 18563 r = zipSmallJsonCharO(self, array1, NULL); 18564 ck_assert_ptr_eq(r, NULL); 18565 terminateO(self); 18566 smashO(array1); 18567 free(array2); 18568 18569 } 18570 18571 18572 void zipSmallJsonCCharSmallArrayT(void) { 18573 18574 smallArrayt* r; 18575 smallArrayt *self = allocG(rtSmallArrayt); 18576 smallJsont *array1 = allocSmallJson(); 18577 const char* array2[] = {"1", "2", "3", null}; 18578 18579 // zip arrays 18580 // add an element to self 18581 // array1 has 2 elements 18582 // array2 has 3 elements 18583 // only 2 elements are zipped 18584 self->f->pushS(self, "qwe"); 18585 array1->f->pushS(array1, "a"); 18586 array1->f->pushS(array1, "b"); 18587 r = self->f->zipSmallJsonCChar(self, array1, array2); 18588 ck_assert_ptr_ne(r, NULL); 18589 char *s = toStringO(r); 18590 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18591 free(s); 18592 // empty arrays 18593 const char* array22[] = {null}; 18594 r = self->f->zipSmallJsonCChar(self, array1, array22); 18595 ck_assert_ptr_ne(r, NULL); 18596 s = toStringO(r); 18597 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18598 free(s); 18599 disposeO(array1); 18600 r = self->f->zipSmallJsonCChar(self, array1, array2); 18601 ck_assert_ptr_eq(r, NULL); 18602 // array1 and array2 same element count 18603 array1->f->pushS(array1, "aa"); 18604 array1->f->pushS(array1, "bb"); 18605 const char* array222[] = {"11", "22", null}; 18606 delElemIndexO(array1, 1); 18607 r = self->f->zipSmallJsonCChar(self, array1, array222); 18608 ck_assert_ptr_ne(r, NULL); 18609 // some elements were zipped 18610 s = toStringO(self); 18611 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 18612 free(s); 18613 // but an element is NULL 18614 // non smallJson objects 18615 smashO(array1); 18616 array1 = (smallJsont*) allocSmallInt(2); 18617 r = zipSmallJsonCCharO(self, array1, array2); 18618 ck_assert_ptr_eq(r, NULL); 18619 terminateO(array1); 18620 array1 = allocSmallJson(); 18621 // NULL arrays 18622 r = self->f->zipSmallJsonCChar(self, NULL, array2); 18623 ck_assert_ptr_eq(r, NULL); 18624 r = self->f->zipSmallJsonCChar(self, array1, NULL); 18625 ck_assert_ptr_eq(r, NULL); 18626 terminateO(self); 18627 smashO(array1); 18628 18629 } 18630 18631 18632 void zipArraySmallArrayT(void) { 18633 18634 smallArrayt* r; 18635 smallArrayt *self = allocG(rtSmallArrayt); 18636 char** array1; 18637 smallArrayt *array2 = allocSmallArray(); 18638 18639 // zip arrays 18640 // add an element to self 18641 // array1 has 2 elements 18642 // array2 has 3 elements 18643 // only 2 elements are zipped 18644 self->f->pushS(self, "qwe"); 18645 array1 = listCreateS("a", "b"); 18646 array2->f->pushInt(array2, 1); 18647 array2->f->pushInt(array2, 2); 18648 array2->f->pushInt(array2, 3); 18649 r = zipArrayO(self, array1, array2); 18650 ck_assert_ptr_ne(r, NULL); 18651 char *s = toStringO(r); 18652 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18653 free(s); 18654 // delete the element not in self 18655 delElemO(array2, 2); 18656 // empty arrays 18657 disposeO(array2); 18658 r = zipArrayO(self, array1, array2); 18659 ck_assert_ptr_ne(r, NULL); 18660 s = toStringO(r); 18661 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18662 free(s); 18663 iListRemoveS(&array1, 0, 2); 18664 r = zipArrayO(self, array1, array2); 18665 free(array1); 18666 ck_assert_ptr_ne(r, NULL); 18667 s = toStringO(r); 18668 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18669 free(s); 18670 // array1 and array2 same element count 18671 array1 = listCreateS("aa", "bb"); 18672 array2->f->pushInt(array2, 11); 18673 array2->f->pushInt(array2, 22); 18674 iListDelElemS(&array1, 1); 18675 r = zipArrayO(self, array1, array2); 18676 delElemO(array2, 1); 18677 ck_assert_ptr_ne(r, NULL); 18678 // some elements were zipped 18679 s = toStringO(self); 18680 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18681 free(s); 18682 // but an element is NULL 18683 // non smallArray objects 18684 smashO(array2); 18685 array2 = (smallArrayt*) allocSmallInt(2); 18686 r = zipArrayO(self, array1, array2); 18687 ck_assert_ptr_eq(r, NULL); 18688 terminateO(array2); 18689 array2 = allocSmallArray(); 18690 // NULL arrays 18691 r = zipArrayO(self, NULL, array2); 18692 ck_assert_ptr_eq(r, NULL); 18693 r = zipArrayO(self, array1, NULL); 18694 ck_assert_ptr_eq(r, NULL); 18695 terminateO(self); 18696 free(array1); 18697 smashO(array2); 18698 18699 } 18700 18701 18702 void zipCArraySmallArrayT(void) { 18703 18704 smallArrayt* r; 18705 smallArrayt *self = allocG(rtSmallArrayt); 18706 const char* array1[] = {"a", "b", null}; 18707 smallArrayt *array2 = allocSmallArray(); 18708 18709 // zip arrays 18710 // add an element to self 18711 // array1 has 2 elements 18712 // array2 has 3 elements 18713 // only 2 elements are zipped 18714 self->f->pushS(self, "qwe"); 18715 array2->f->pushInt(array2, 1); 18716 array2->f->pushInt(array2, 2); 18717 array2->f->pushInt(array2, 3); 18718 r = self->f->zipCArray(self, array1, array2); 18719 ck_assert_ptr_ne(r, NULL); 18720 char *s = toStringO(r); 18721 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18722 free(s); 18723 // delete the element not in self 18724 delElemO(array2, 2); 18725 // empty arrays 18726 disposeO(array2); 18727 r = self->f->zipCArray(self, array1, array2); 18728 ck_assert_ptr_ne(r, NULL); 18729 s = toStringO(r); 18730 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18731 free(s); 18732 const char* array11[] = {null}; 18733 r = self->f->zipCArray(self, array11, array2); 18734 ck_assert_ptr_ne(r, NULL); 18735 s = toStringO(r); 18736 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18737 free(s); 18738 // array1 and array2 same element count 18739 const char* array111[] = {"aa", null}; 18740 array2->f->pushInt(array2, 11); 18741 array2->f->pushInt(array2, 22); 18742 r = self->f->zipCArray(self, array111, array2); 18743 delElemO(array2, 1); 18744 ck_assert_ptr_ne(r, NULL); 18745 // some elements were zipped 18746 s = toStringO(self); 18747 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18748 free(s); 18749 // but an element is NULL 18750 // non smallArray objects 18751 smashO(array2); 18752 array2 = (smallArrayt*) allocSmallInt(2); 18753 r = self->f->zipCArray(self, array1, array2); 18754 ck_assert_ptr_eq(r, NULL); 18755 terminateO(array2); 18756 array2 = allocSmallArray(); 18757 // NULL arrays 18758 r = self->f->zipCArray(self, NULL, array2); 18759 ck_assert_ptr_eq(r, NULL); 18760 r = self->f->zipCArray(self, array1, NULL); 18761 ck_assert_ptr_eq(r, NULL); 18762 terminateO(self); 18763 smashO(array2); 18764 18765 } 18766 18767 18768 void zipArraySmallJsonSmallArrayT(void) { 18769 18770 smallArrayt* r; 18771 smallArrayt *self = allocG(rtSmallArrayt); 18772 char** array1; 18773 smallJsont *array2 = allocSmallJson(); 18774 18775 // zip arrays 18776 // add an element to self 18777 // array1 has 2 elements 18778 // array2 has 3 elements 18779 // only 2 elements are zipped 18780 self->f->pushS(self, "qwe"); 18781 array1 = listCreateS("a", "b"); 18782 array2->f->pushInt(array2, 1); 18783 array2->f->pushInt(array2, 2); 18784 array2->f->pushInt(array2, 3); 18785 r = self->f->zipArraySmallJson(self, array1, array2); 18786 ck_assert_ptr_ne(r, NULL); 18787 char *s = toStringO(r); 18788 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18789 free(s); 18790 // delete the element not in self 18791 delElemIndexO(array2, 2); 18792 // empty arrays 18793 iListRemoveS(&array1, 0, 2); 18794 r = self->f->zipArraySmallJson(self, array1, array2); 18795 ck_assert_ptr_ne(r, NULL); 18796 s = toStringO(r); 18797 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18798 free(s); 18799 disposeO(array2); 18800 r = self->f->zipArraySmallJson(self, array1, array2); 18801 free(array1); 18802 ck_assert_ptr_eq(r, NULL); 18803 // array1 and array2 same element count 18804 array1 = listCreateS("aa", "bb"); 18805 array2->f->pushInt(array2, 11); 18806 array2->f->pushInt(array2, 22); 18807 iListDelElemS(&array1, 1); 18808 r = self->f->zipArraySmallJson(self, array1, array2); 18809 delElemIndexO(array2, 1); 18810 ck_assert_ptr_ne(r, NULL); 18811 // some elements were zipped 18812 s = toStringO(self); 18813 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18814 free(s); 18815 // but an element is NULL 18816 // non smallJson object 18817 smashO(array2); 18818 array2 = (smallJsont*) allocSmallInt(2); 18819 r = self->f->zipArraySmallJson(self, array1, array2); 18820 ck_assert_ptr_eq(r, NULL); 18821 terminateO(array2); 18822 array2 = allocSmallJson(); 18823 // NULL arrays 18824 r = self->f->zipArraySmallJson(self, NULL, array2); 18825 ck_assert_ptr_eq(r, NULL); 18826 r = self->f->zipArraySmallJson(self, array1, NULL); 18827 ck_assert_ptr_eq(r, NULL); 18828 terminateO(self); 18829 free(array1); 18830 smashO(array2); 18831 18832 } 18833 18834 18835 void zipCArraySmallJsonSmallArrayT(void) { 18836 18837 smallArrayt* r; 18838 smallArrayt *self = allocG(rtSmallArrayt); 18839 const char* array1[] = {"a", "b", null}; 18840 smallJsont *array2 = allocSmallJson(); 18841 18842 // zip arrays 18843 // add an element to self 18844 // array1 has 2 elements 18845 // array2 has 3 elements 18846 // only 2 elements are zipped 18847 self->f->pushS(self, "qwe"); 18848 array2->f->pushInt(array2, 1); 18849 array2->f->pushInt(array2, 2); 18850 array2->f->pushInt(array2, 3); 18851 r = self->f->zipCArraySmallJson(self, array1, array2); 18852 ck_assert_ptr_ne(r, NULL); 18853 char *s = toStringO(r); 18854 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18855 free(s); 18856 // delete the element not in self 18857 delElemIndexO(array2, 2); 18858 // empty arrays 18859 const char* array11[] = {null}; 18860 r = self->f->zipCArraySmallJson(self, array11, array2); 18861 ck_assert_ptr_ne(r, NULL); 18862 s = toStringO(r); 18863 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18864 free(s); 18865 disposeO(array2); 18866 r = self->f->zipCArraySmallJson(self, array1, array2); 18867 ck_assert_ptr_eq(r, NULL); 18868 // array1 and array2 same element count 18869 const char *array111[] = {"aa", null}; 18870 array2->f->pushInt(array2, 11); 18871 array2->f->pushInt(array2, 22); 18872 r = self->f->zipCArraySmallJson(self, array111, array2); 18873 delElemIndexO(array2, 1); 18874 ck_assert_ptr_ne(r, NULL); 18875 // some elements were zipped 18876 s = toStringO(self); 18877 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18878 free(s); 18879 // but an element is NULL 18880 // non smallJson object 18881 smashO(array2); 18882 array2 = (smallJsont*) allocSmallInt(2); 18883 r = self->f->zipCArraySmallJson(self, array1, array2); 18884 ck_assert_ptr_eq(r, NULL); 18885 terminateO(array2); 18886 array2 = allocSmallJson(); 18887 // NULL arrays 18888 r = self->f->zipCArraySmallJson(self, NULL, array2); 18889 ck_assert_ptr_eq(r, NULL); 18890 r = self->f->zipCArraySmallJson(self, array1, NULL); 18891 ck_assert_ptr_eq(r, NULL); 18892 terminateO(self); 18893 smashO(array2); 18894 18895 } 18896 18897 18898 void zipCharSmallArrayT(void) { 18899 18900 smallArrayt* r; 18901 smallArrayt *self = allocG(rtSmallArrayt); 18902 smallArrayt *array1 = allocSmallArray(); 18903 char** array2; 18904 18905 // zip arrays 18906 // add an element to self 18907 // array1 has 2 elements 18908 // array2 has 3 elements 18909 // only 2 elements are zipped 18910 self->f->pushS(self, "qwe"); 18911 array1->f->pushS(array1, "a"); 18912 array1->f->pushS(array1, "b"); 18913 array2 = listCreateS("1", "2", "3"); 18914 r = zipCharO(self, array1, array2); 18915 ck_assert_ptr_ne(r, NULL); 18916 char *s = toStringO(r); 18917 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18918 free(s); 18919 // delete the element not in self 18920 iListDelElemS(&array2, 2); 18921 // empty arrays 18922 iListRemoveS(&array2, 0, 2); 18923 r = zipCharO(self, array1, array2); 18924 ck_assert_ptr_ne(r, NULL); 18925 s = toStringO(r); 18926 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18927 free(s); 18928 disposeO(array1); 18929 r = zipCharO(self, array1, array2); 18930 ck_assert_ptr_ne(r, NULL); 18931 s = toStringO(r); 18932 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18933 free(s); 18934 free(array2); 18935 // array1 and array2 same element count 18936 array1->f->pushS(array1, "aa"); 18937 array1->f->pushS(array1, "bb"); 18938 array2 = listCreateS("11", "22"); 18939 delElemO(array1, 1); 18940 r = zipCharO(self, array1, array2); 18941 iListDelElemS(&array2, 1); 18942 ck_assert_ptr_ne(r, NULL); 18943 // some elements were zipped 18944 s = toStringO(self); 18945 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 18946 free(s); 18947 // but an element is NULL 18948 // non smallJson objects 18949 smashO(array1); 18950 array1 = (smallArrayt*) allocSmallInt(2); 18951 r = zipCharO(self, array1, array2); 18952 ck_assert_ptr_eq(r, NULL); 18953 terminateO(array1); 18954 array1 = allocSmallArray(); 18955 // NULL arrays 18956 r = zipCharO(self, NULL, array2); 18957 ck_assert_ptr_eq(r, NULL); 18958 r = zipCharO(self, array1, NULL); 18959 ck_assert_ptr_eq(r, NULL); 18960 terminateO(self); 18961 smashO(array1); 18962 free(array2); 18963 18964 } 18965 18966 18967 void zipCCharSmallArrayT(void) { 18968 18969 smallArrayt* r; 18970 smallArrayt *self = allocG(rtSmallArrayt); 18971 smallArrayt *array1 = allocSmallArray(); 18972 const char* array2[] = {"1", "2", "3", null}; 18973 18974 // zip arrays 18975 // add an element to self 18976 // array1 has 2 elements 18977 // array2 has 3 elements 18978 // only 2 elements are zipped 18979 self->f->pushS(self, "qwe"); 18980 array1->f->pushS(array1, "a"); 18981 array1->f->pushS(array1, "b"); 18982 r = self->f->zipCChar(self, array1, array2); 18983 ck_assert_ptr_ne(r, NULL); 18984 char *s = toStringO(r); 18985 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18986 free(s); 18987 // delete the element not in self 18988 // empty arrays 18989 const char* array22[] = {null}; 18990 r = self->f->zipCChar(self, array1, array22); 18991 ck_assert_ptr_ne(r, NULL); 18992 s = toStringO(r); 18993 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18994 free(s); 18995 disposeO(array1); 18996 r = self->f->zipCChar(self, array1, array2); 18997 ck_assert_ptr_ne(r, NULL); 18998 s = toStringO(r); 18999 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19000 free(s); 19001 // array1 and array2 same element count 19002 array1->f->pushS(array1, "aa"); 19003 array1->f->pushS(array1, "bb"); 19004 const char* array222[] = {"11", "22", null}; 19005 delElemO(array1, 1); 19006 r = self->f->zipCChar(self, array1, array222); 19007 ck_assert_ptr_ne(r, NULL); 19008 // some elements were zipped 19009 s = toStringO(self); 19010 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19011 free(s); 19012 // but an element is NULL 19013 // non smallJson objects 19014 smashO(array1); 19015 array1 = (smallArrayt*) allocSmallInt(2); 19016 r = self->f->zipCChar(self, array1, array2); 19017 ck_assert_ptr_eq(r, NULL); 19018 terminateO(array1); 19019 array1 = allocSmallArray(); 19020 // NULL arrays 19021 r = self->f->zipCChar(self, NULL, array2); 19022 ck_assert_ptr_eq(r, NULL); 19023 r = self->f->zipCChar(self, array1, NULL); 19024 ck_assert_ptr_eq(r, NULL); 19025 terminateO(self); 19026 smashO(array1); 19027 19028 } 19029 19030 19031 void zipArrayCharSmallArrayT(void) { 19032 19033 smallArrayt* r; 19034 smallArrayt *self = allocG(rtSmallArrayt); 19035 char** array1; 19036 char** array2; 19037 19038 // zip arrays 19039 // add an element to self 19040 // array1 has 2 elements 19041 // array2 has 3 elements 19042 // only 2 elements are zipped 19043 self->f->pushS(self, "qwe"); 19044 array1 = listCreateS("a", "b"); 19045 array2 = listCreateS("1", "2", "3"); 19046 r = zipArrayCharO(self, array1, array2); 19047 ck_assert_ptr_ne(r, NULL); 19048 char *s = toStringO(r); 19049 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19050 free(s); 19051 // delete the element not in self 19052 iListDelElemS(&array2, 2); 19053 // empty arrays 19054 iListRemoveS(&array2, 0, 2); 19055 r = zipArrayCharO(self, array1, array2); 19056 ck_assert_ptr_ne(r, NULL); 19057 s = toStringO(r); 19058 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19059 free(s); 19060 iListRemoveS(&array1, 0, 2); 19061 r = zipArrayCharO(self, array1, array2); 19062 ck_assert_ptr_ne(r, NULL); 19063 s = toStringO(r); 19064 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19065 free(s); 19066 free(array1); 19067 free(array2); 19068 // array1 and array2 same element count 19069 array1 = listCreateS("aa", "bb"); 19070 array2 = listCreateS("11", "22"); 19071 iListDelElemS(&array1, 1); 19072 r = zipArrayCharO(self, array1, array2); 19073 iListDelElemS(&array2, 1); 19074 ck_assert_ptr_ne(r, NULL); 19075 // some elements were zipped 19076 s = toStringO(self); 19077 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19078 free(s); 19079 // but an element is NULL 19080 // NULL arrays 19081 r = zipArrayCharO(self, NULL, array2); 19082 ck_assert_ptr_eq(r, NULL); 19083 r = zipArrayCharO(self, array1, NULL); 19084 ck_assert_ptr_eq(r, NULL); 19085 terminateO(self); 19086 free(array1); 19087 free(array2); 19088 19089 } 19090 19091 19092 void zipCArrayCharSmallArrayT(void) { 19093 19094 smallArrayt* r; 19095 smallArrayt *self = allocG(rtSmallArrayt); 19096 const char* array1[] = {"a", "b", null}; 19097 char** array2; 19098 19099 // zip arrays 19100 // add an element to self 19101 // array1 has 2 elements 19102 // array2 has 3 elements 19103 // only 2 elements are zipped 19104 self->f->pushS(self, "qwe"); 19105 array2 = listCreateS("1", "2", "3"); 19106 r = self->f->zipCArrayChar(self, array1, array2); 19107 ck_assert_ptr_ne(r, NULL); 19108 char *s = toStringO(r); 19109 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19110 free(s); 19111 // delete the element not in self 19112 iListDelElemS(&array2, 2); 19113 // empty arrays 19114 iListRemoveS(&array2, 0, 2); 19115 r = self->f->zipCArrayChar(self, array1, array2); 19116 ck_assert_ptr_ne(r, NULL); 19117 s = toStringO(r); 19118 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19119 free(s); 19120 const char* array11[] = {null}; 19121 r = self->f->zipCArrayChar(self, array11, array2); 19122 ck_assert_ptr_ne(r, NULL); 19123 s = toStringO(r); 19124 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19125 free(s); 19126 free(array2); 19127 // array1 and array2 same element count 19128 const char *array111[] = {"aa", null}; 19129 array2 = listCreateS("11", "22"); 19130 r = self->f->zipCArrayChar(self, array111, array2); 19131 iListDelElemS(&array2, 1); 19132 ck_assert_ptr_ne(r, NULL); 19133 // some elements were zipped 19134 s = toStringO(self); 19135 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19136 free(s); 19137 // but an element is NULL 19138 // NULL arrays 19139 r = self->f->zipCArrayChar(self, NULL, array2); 19140 ck_assert_ptr_eq(r, NULL); 19141 r = self->f->zipCArrayChar(self, array1, NULL); 19142 ck_assert_ptr_eq(r, NULL); 19143 terminateO(self); 19144 free(array2); 19145 19146 } 19147 19148 19149 void zipArrayCCharSmallArrayT(void) { 19150 19151 smallArrayt* r; 19152 smallArrayt *self = allocG(rtSmallArrayt); 19153 char** array1; 19154 const char* array2[] = {"1", "2", "3", null}; 19155 19156 // zip arrays 19157 // add an element to self 19158 // array1 has 2 elements 19159 // array2 has 3 elements 19160 // only 2 elements are zipped 19161 self->f->pushS(self, "qwe"); 19162 array1 = listCreateS("a", "b"); 19163 r = self->f->zipArrayCChar(self, array1, array2); 19164 ck_assert_ptr_ne(r, NULL); 19165 char *s = toStringO(r); 19166 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19167 free(s); 19168 // empty arrays 19169 const char* array22[] = {null}; 19170 r = self->f->zipArrayCChar(self, array1, array22); 19171 ck_assert_ptr_ne(r, NULL); 19172 s = toStringO(r); 19173 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19174 free(s); 19175 iListRemoveS(&array1, 0, 2); 19176 r = self->f->zipArrayCChar(self, array1, array2); 19177 ck_assert_ptr_ne(r, NULL); 19178 s = toStringO(r); 19179 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19180 free(s); 19181 free(array1); 19182 // array1 and array2 same element count 19183 array1 = listCreateS("aa", "bb"); 19184 const char* array222[] = {"11", "22", null}; 19185 iListDelElemS(&array1, 1); 19186 r = self->f->zipArrayCChar(self, array1, array222); 19187 ck_assert_ptr_ne(r, NULL); 19188 // some elements were zipped 19189 s = toStringO(self); 19190 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19191 free(s); 19192 // but an element is NULL 19193 // NULL arrays 19194 r = self->f->zipArrayCChar(self, NULL, array2); 19195 ck_assert_ptr_eq(r, NULL); 19196 r = self->f->zipArrayCChar(self, array1, NULL); 19197 ck_assert_ptr_eq(r, NULL); 19198 terminateO(self); 19199 free(array1); 19200 19201 } 19202 19203 19204 void zipCArrayCCharSmallArrayT(void) { 19205 19206 smallArrayt* r; 19207 smallArrayt *self = allocG(rtSmallArrayt); 19208 const char* array1[] = {"a", "b", null}; 19209 const char* array2[] = {"1", "2", "3", null}; 19210 19211 // zip arrays 19212 // add an element to self 19213 // array1 has 2 elements 19214 // array2 has 3 elements 19215 // only 2 elements are zipped 19216 self->f->pushS(self, "qwe"); 19217 r = self->f->zipCArrayCChar(self, array1, array2); 19218 ck_assert_ptr_ne(r, NULL); 19219 char *s = toStringO(r); 19220 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19221 free(s); 19222 // delete the element not in self 19223 // empty arrays 19224 const char* array22[] = {null}; 19225 r = self->f->zipCArrayCChar(self, array1, array22); 19226 ck_assert_ptr_ne(r, NULL); 19227 s = toStringO(r); 19228 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19229 free(s); 19230 const char* array11[] = {null}; 19231 r = self->f->zipCArrayCChar(self, array11, array2); 19232 ck_assert_ptr_ne(r, NULL); 19233 s = toStringO(r); 19234 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19235 free(s); 19236 // array1 and array2 same element count 19237 const char *array111[] = {"aa", null}; 19238 const char *array222[] = {"11", "22", null}; 19239 r = self->f->zipCArrayCChar(self, array111, array222); 19240 ck_assert_ptr_ne(r, NULL); 19241 // some elements were zipped 19242 s = toStringO(self); 19243 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19244 free(s); 19245 // but an element is NULL 19246 // NULL arrays 19247 r = self->f->zipCArrayCChar(self, NULL, array2); 19248 ck_assert_ptr_eq(r, NULL); 19249 r = self->f->zipCArrayCChar(self, array1, NULL); 19250 ck_assert_ptr_eq(r, NULL); 19251 terminateO(self); 19252 19253 } 19254 19255 19256 void logSmallArrayT(void) { 19257 19258 smallArrayt *self = allocG(rtSmallArrayt); 19259 19260 // only prints to stdout 19261 logO(self); 19262 terminateO(self); 19263 19264 } 19265 19266 19267 void readTextSmallArrayT(void) { 19268 19269 smallArrayt* r; 19270 smallArrayt *self = allocG(rtSmallArrayt); 19271 19272 // text 19273 r = readTextO(self, "../textTest.null"); 19274 ck_assert_ptr_ne(r, NULL); 19275 char *s = toStringO(r); 19276 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19277 free(s); 19278 // empty text 19279 emptyO(self); 19280 r = readTextO(self, "../chmodTest.null"); 19281 ck_assert_ptr_ne(r, NULL); 19282 ck_assert(isEmptyO(self)); 19283 // NULL path 19284 r = readTextO(self, NULL); 19285 ck_assert_ptr_eq(r, NULL); 19286 // non existing path 19287 if (fileExists("../nonExistingFile")) 19288 rmAll("../nonExistingFile"); 19289 r = readTextO(self, "../nonExistingFile"); 19290 ck_assert_ptr_eq(r, NULL); 19291 terminateO(self); 19292 19293 } 19294 19295 19296 void readTextSmallJsonSmallArrayT(void) { 19297 19298 smallArrayt* r; 19299 smallArrayt *self = allocG(rtSmallArrayt); 19300 smallJsont *filePath = allocSmallJson(); 19301 19302 // text 19303 setTopSO(filePath, "../textTest.null"); 19304 r = self->f->readTextSmallJson(self, filePath); 19305 ck_assert_ptr_ne(r, NULL); 19306 char *s = toStringO(r); 19307 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19308 free(s); 19309 // empty text 19310 emptyO(self); 19311 freeO(filePath); 19312 setTopSO(filePath, "../chmodTest.null"); 19313 r = self->f->readTextSmallJson(self, filePath); 19314 ck_assert_ptr_ne(r, NULL); 19315 ck_assert(isEmptyO(self)); 19316 // NULL path 19317 r = self->f->readTextSmallJson(self, NULL); 19318 ck_assert_ptr_eq(r, NULL); 19319 // non existing path 19320 if (fileExists("../nonExistingFile")) 19321 rmAll("../nonExistingFile"); 19322 freeO(filePath); 19323 setTopSO(filePath, "../nonExistingFile"); 19324 r = self->f->readTextSmallJson(self, filePath); 19325 ck_assert_ptr_eq(r, NULL); 19326 // filePath not a string 19327 freeO(filePath); 19328 setTopIntO(filePath, 0); 19329 r = self->f->readTextSmallJson(self, filePath); 19330 ck_assert_ptr_eq(r, NULL); 19331 // non smallJson object 19332 terminateO(filePath); 19333 filePath = (smallJsont*) allocSmallInt(2); 19334 r = self->f->readTextSmallJson(self, filePath); 19335 ck_assert_ptr_eq(r, NULL); 19336 terminateO(self); 19337 terminateO(filePath); 19338 19339 } 19340 19341 19342 void readTextSmallStringSmallArrayT(void) { 19343 19344 smallArrayt* r; 19345 smallArrayt *self = allocG(rtSmallArrayt); 19346 smallStringt *filePath = allocSmallString(""); 19347 19348 // text 19349 setValO(filePath, "../textTest.null"); 19350 r = readTextSmallStringO(self, filePath); 19351 ck_assert_ptr_ne(r, NULL); 19352 char *s = toStringO(r); 19353 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19354 free(s); 19355 // empty text 19356 emptyO(self); 19357 setValO(filePath, "../chmodTest.null"); 19358 r = readTextSmallStringO(self, filePath); 19359 ck_assert_ptr_ne(r, NULL); 19360 ck_assert(isEmptyO(self)); 19361 // NULL path 19362 r = readTextSmallStringO(self, NULL); 19363 ck_assert_ptr_eq(r, NULL); 19364 // non existing path 19365 if (fileExists("../nonExistingFile")) 19366 rmAll("../nonExistingFile"); 19367 setValO(filePath, "../nonExistingFile"); 19368 r = readTextSmallStringO(self, filePath); 19369 ck_assert_ptr_eq(r, NULL); 19370 // blank file path 19371 setValO(filePath, " "); 19372 r = readTextSmallStringO(self, filePath); 19373 ck_assert_ptr_eq(r, NULL); 19374 // non smallString object 19375 terminateO(filePath); 19376 filePath = (smallStringt*) allocSmallInt(2); 19377 r = readTextSmallStringO(self, filePath); 19378 ck_assert_ptr_eq(r, NULL); 19379 terminateO(self); 19380 terminateO(filePath); 19381 19382 } 19383 19384 19385 void readStreamSmallArrayT(void) { 19386 19387 smallArrayt* r; 19388 smallArrayt *self = allocG(rtSmallArrayt); 19389 FILE *fp; 19390 19391 // stream 19392 fp = fopen("../textTest.null", "r"); 19393 r = readStreamO(self, fp); 19394 fclose(fp); 19395 ck_assert_ptr_ne(r, NULL); 19396 char *s = toStringO(r); 19397 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19398 free(s); 19399 // empty stream 19400 emptyO(self); 19401 fp = fopen("../chmodTest.null", "r"); 19402 r = readStreamO(self, fp); 19403 fclose(fp); 19404 ck_assert_ptr_ne(r, NULL); 19405 ck_assert(isEmptyO(self)); 19406 // NULL stream 19407 ck_assert_ptr_eq(readStreamO(self, NULL), NULL); 19408 terminateO(self); 19409 19410 } 19411 19412 19413 void writeTextSmallArrayT(void) { 19414 19415 bool r; 19416 smallArrayt *self = allocG(rtSmallArrayt); 19417 19418 // write textOutTest.null 19419 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19420 ck_assert_ptr_ne(r2, NULL); 19421 r = writeTextO(self, "../textOutTest.null"); 19422 ck_assert(r); 19423 // check textOutTest.null 19424 emptyO(self); 19425 r2 = readTextO(self, "../textOutTest.null"); 19426 ck_assert_ptr_ne(r2, NULL); 19427 char *s = toStringO(r2); 19428 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19429 free(s); 19430 // empty array 19431 emptyO(self); 19432 r = writeTextO(self, "../textOutTest.null"); 19433 ck_assert(!r); 19434 r2 = readTextO(self, "../textOutTest.null"); 19435 ck_assert_ptr_ne(r2, NULL); 19436 s = toStringO(r2); 19437 ck_assert_str_eq(s, "[]"); 19438 free(s); 19439 // non existing file 19440 // make sure the file doesnt exist 19441 if (fileExists("../nonExistingFile")) 19442 rmAll("../nonExistingFile"); 19443 self->f->pushS(self, "qwe"); 19444 ck_assert(writeTextO(self, "../nonExistingFile")); 19445 if (fileExists("../nonExistingFile")) 19446 rmAll("../nonExistingFile"); 19447 // write readonly path 19448 ck_assert(!writeTextO(self, "/readOnlyFileTest")); 19449 // NULL path 19450 ck_assert(!writeTextO(self, NULL)); 19451 terminateO(self); 19452 19453 } 19454 19455 19456 void writeTextSmallJsonSmallArrayT(void) { 19457 19458 bool r; 19459 smallArrayt *self = allocG(rtSmallArrayt); 19460 smallJsont *filePath = allocSmallJson(); 19461 19462 // write textOutTest.null 19463 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19464 ck_assert_ptr_ne(r2, NULL); 19465 setTopSO(filePath, "../textOutTest.null"); 19466 r = self->f->writeTextSmallJson(self, filePath); 19467 ck_assert(r); 19468 // check textOutTest.null 19469 emptyO(self); 19470 r2 = readTextO(self, "../textOutTest.null"); 19471 ck_assert_ptr_ne(r2, NULL); 19472 char *s = toStringO(r2); 19473 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19474 free(s); 19475 // empty array 19476 emptyO(self); 19477 freeO(filePath); 19478 setTopSO(filePath, "../textOutTest.null"); 19479 r = self->f->writeTextSmallJson(self, filePath); 19480 ck_assert(!r); 19481 r2 = readTextO(self, "../textOutTest.null"); 19482 ck_assert_ptr_ne(r2, NULL); 19483 s = toStringO(r2); 19484 ck_assert_str_eq(s, "[]"); 19485 free(s); 19486 // non existing file 19487 // make sure the file doesnt exist 19488 if (fileExists("../nonExistingFile")) 19489 rmAll("../nonExistingFile"); 19490 self->f->pushS(self, "qwe"); 19491 freeO(filePath); 19492 setTopSO(filePath, "../nonExistingFile"); 19493 ck_assert(self->f->writeTextSmallJson(self, filePath)); 19494 if (fileExists("../nonExistingFile")) 19495 rmAll("../nonExistingFile"); 19496 // filePath not a string 19497 freeO(filePath); 19498 setTopIntO(filePath, 0); 19499 r = self->f->writeTextSmallJson(self, filePath); 19500 ck_assert(!r); 19501 // non smallJson object 19502 terminateO(filePath); 19503 filePath = (smallJsont*) allocSmallInt(2); 19504 r = self->f->writeTextSmallJson(self, filePath); 19505 ck_assert(!r); 19506 // NULL path 19507 ck_assert(!self->f->writeTextSmallJson(self, NULL)); 19508 terminateO(self); 19509 terminateO(filePath); 19510 19511 } 19512 19513 19514 void writeTextSmallStringSmallArrayT(void) { 19515 19516 bool r; 19517 smallArrayt *self = allocG(rtSmallArrayt); 19518 smallStringt *filePath = allocSmallString(""); 19519 19520 // write textOutTest.null 19521 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19522 ck_assert_ptr_ne(r2, NULL); 19523 setValO(filePath, "../textOutTest.null"); 19524 r = writeTextSmallStringO(self, filePath); 19525 ck_assert(r); 19526 // check textOutTest.null 19527 emptyO(self); 19528 r2 = readTextO(self, "../textOutTest.null"); 19529 ck_assert_ptr_ne(r2, NULL); 19530 char *s = toStringO(r2); 19531 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19532 free(s); 19533 // empty array 19534 emptyO(self); 19535 setValO(filePath, "../textOutTest.null"); 19536 r = writeTextSmallStringO(self, filePath); 19537 ck_assert(!r); 19538 r2 = readTextO(self, "../textOutTest.null"); 19539 ck_assert_ptr_ne(r2, NULL); 19540 s = toStringO(r2); 19541 ck_assert_str_eq(s, "[]"); 19542 free(s); 19543 // non existing file 19544 // make sure the file doesnt exist 19545 if (fileExists("../nonExistingFile")) 19546 rmAll("../nonExistingFile"); 19547 self->f->pushS(self, "qwe"); 19548 setValO(filePath, "../nonExistingFile"); 19549 ck_assert(writeTextSmallStringO(self, filePath)); 19550 if (fileExists("../nonExistingFile")) 19551 rmAll("../nonExistingFile"); 19552 // non smallJson object 19553 terminateO(filePath); 19554 filePath = (smallStringt*) allocSmallInt(2); 19555 r = writeTextSmallStringO(self, filePath); 19556 ck_assert(!r); 19557 // NULL path 19558 ck_assert(!writeTextSmallStringO(self, NULL)); 19559 terminateO(self); 19560 terminateO(filePath); 19561 19562 } 19563 19564 19565 void writeStreamSmallArrayT(void) { 19566 19567 bool r; 19568 smallArrayt *self = allocG(rtSmallArrayt); 19569 FILE *fp; 19570 19571 // write textOutTest.null 19572 fp = fopen("../textTest.null", "r"); 19573 smallArrayt *r2 = readStreamO(self, fp); 19574 fclose(fp); 19575 ck_assert_ptr_ne(r2, NULL); 19576 fp = fopen("../textOutTest.null", "w"); 19577 r = writeStreamO(self, fp); 19578 ck_assert(r); 19579 // empty array 19580 emptyO(self); 19581 ck_assert(!writeStreamO(self, fp)); 19582 fclose(fp); 19583 // check textOutTest.null 19584 fp = fopen("../textOutTest.null", "r"); 19585 r2 = readStreamO(self, fp); 19586 fclose(fp); 19587 ck_assert_ptr_ne(r2, NULL); 19588 char *s = toStringO(r2); 19589 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19590 free(s); 19591 terminateO(self); 19592 19593 } 19594 19595 19596 void appendTextSmallArrayT(void) { 19597 19598 bool r; 19599 smallArrayt *self = allocG(rtSmallArrayt); 19600 19601 // append to textOutTest.null 19602 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19603 ck_assert_ptr_ne(r2, NULL); 19604 r = writeTextO(self, "../textOutTest.null"); 19605 ck_assert(r); 19606 emptyO(self); 19607 self->f->pushS(self, "A"); 19608 self->f->pushS(self, "B"); 19609 r = appendTextO(self, "../textOutTest.null"); 19610 // check textOutTest.null 19611 emptyO(self); 19612 r2 = readTextO(self, "../textOutTest.null"); 19613 ck_assert_ptr_ne(r2, NULL); 19614 char *s = toStringO(r2); 19615 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 19616 free(s); 19617 // non existing file 19618 // make sure the file doesnt exist 19619 if (fileExists("../nonExistingFile")) 19620 rmAll("../nonExistingFile"); 19621 ck_assert(appendTextO(self, "../nonExistingFile")); 19622 if (fileExists("../nonExistingFile")) 19623 rmAll("../nonExistingFile"); 19624 // empty array 19625 emptyO(self); 19626 r = appendTextO(self, "../textOutTest.null"); 19627 ck_assert(!r); 19628 // check textOutTest.null 19629 emptyO(self); 19630 r2 = readTextO(self, "../textOutTest.null"); 19631 ck_assert_ptr_ne(r2, NULL); 19632 s = toStringO(r2); 19633 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 19634 free(s); 19635 // blank path 19636 ck_assert(!appendTextO(self, " ")); 19637 // append readonly path 19638 ck_assert(!appendTextO(self, "/readOnlyFileTest")); 19639 // NULL path 19640 ck_assert(!appendTextO(self, NULL)); 19641 terminateO(self); 19642 19643 } 19644 19645 19646 void appendTextSmallStringSmallArrayT(void) { 19647 19648 bool r; 19649 smallArrayt *self = allocG(rtSmallArrayt); 19650 smallStringt *filePath = allocSmallString(""); 19651 19652 // append to textOutTest.null 19653 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19654 ck_assert_ptr_ne(r2, NULL); 19655 r = writeTextO(self, "../textOutTest.null"); 19656 ck_assert(r); 19657 emptyO(self); 19658 self->f->pushS(self, "A"); 19659 self->f->pushS(self, "B"); 19660 setValO(filePath, "../textOutTest.null"); 19661 r = appendTextSmallStringO(self, filePath); 19662 // check textOutTest.null 19663 emptyO(self); 19664 r2 = readTextO(self, "../textOutTest.null"); 19665 ck_assert_ptr_ne(r2, NULL); 19666 char *s = toStringO(r2); 19667 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 19668 free(s); 19669 // non existing file 19670 // make sure the file doesnt exist 19671 if (fileExists("../nonExistingFile")) 19672 rmAll("../nonExistingFile"); 19673 setValO(filePath, "../nonExistingFile"); 19674 ck_assert(appendTextSmallStringO(self, filePath)); 19675 if (fileExists("../nonExistingFile")) 19676 rmAll("../nonExistingFile"); 19677 // empty array 19678 emptyO(self); 19679 r = appendTextSmallStringO(self, filePath); 19680 ck_assert(!r); 19681 // check textOutTest.null 19682 emptyO(self); 19683 r2 = readTextO(self, "../textOutTest.null"); 19684 ck_assert_ptr_ne(r2, NULL); 19685 s = toStringO(r2); 19686 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 19687 free(s); 19688 // blank path 19689 setValO(filePath, " "); 19690 ck_assert(!appendTextSmallStringO(self, filePath)); 19691 // non smallString object 19692 terminateO(filePath); 19693 filePath = (smallStringt*) allocSmallInt(2); 19694 r = appendTextSmallStringO(self, filePath); 19695 ck_assert(!r); 19696 // NULL path 19697 ck_assert(!appendTextSmallStringO(self, NULL)); 19698 terminateO(self); 19699 terminateO(filePath); 19700 19701 } 19702 19703 19704 void typeSmallStringSmallArrayT(void) { 19705 19706 smallStringt* r; 19707 smallArrayt *self = allocG(rtSmallArrayt); 19708 19709 // empty array 19710 r = typeSmallStringO(self, 0); 19711 ck_assert_ptr_ne(r, NULL); 19712 char *s = toStringO(r); 19713 ck_assert_str_eq(s, "not a sheepy object"); 19714 free(s); 19715 terminateO(self); 19716 terminateO(r); 19717 19718 } 19719 19720 19721 void typeSmallStringsSmallArrayT(void) { 19722 19723 smallArrayt* r; 19724 smallArrayt *self = allocG(rtSmallArrayt); 19725 19726 // empty array 19727 r = typeSmallStringsO(self); 19728 ck_assert_ptr_eq(r, NULL); 19729 // array 19730 self->f->pushS(self, "qwe"); 19731 self->f->pushBool(self, true); 19732 self->f->pushDouble(self, 1); 19733 r = typeSmallStringsO(self); 19734 ck_assert_ptr_ne(r, NULL); 19735 char *s = toStringO(r); 19736 ck_assert_str_eq(s, "[\"string\",\"bool\",\"double\"]"); 19737 free(s); 19738 terminateO(self); 19739 terminateO(r); 19740 19741 } 19742 19743 19744 void isETypeSmallArrayT(void) { 19745 19746 bool r; 19747 smallArrayt *self = allocG(rtSmallArrayt); 19748 19749 self->f->pushUndefined(self); 19750 r = isETypeO(self, 0, "undefined"); 19751 ck_assert(r); 19752 // NULL type 19753 emptyO(self); 19754 r = isETypeO(self, 0, NULL); 19755 ck_assert(!r); 19756 terminateO(self); 19757 19758 } 19759 19760 19761 void isEUndefinedSmallArrayT(void) { 19762 19763 bool r; 19764 smallArrayt *self = allocG(rtSmallArrayt); 19765 19766 // array 19767 self->f->pushUndefined(self); 19768 self->f->pushS(self, ""); 19769 r = isEUndefinedO(self, 0); 19770 ck_assert(r); 19771 r = isEUndefinedO(self, -1); 19772 ck_assert(!r); 19773 terminateO(self); 19774 19775 } 19776 19777 19778 void isEBoolSmallArrayT(void) { 19779 19780 bool r; 19781 smallArrayt *self = allocG(rtSmallArrayt); 19782 19783 // array 19784 self->f->pushBool(self, true); 19785 self->f->pushS(self, ""); 19786 r = isEBoolO(self, 0); 19787 ck_assert(r); 19788 r = isEBoolO(self, -1); 19789 ck_assert(!r); 19790 terminateO(self); 19791 19792 } 19793 19794 19795 void isEContainerSmallArrayT(void) { 19796 19797 bool r; 19798 smallArrayt *self = allocG(rtSmallArrayt); 19799 19800 // array 19801 createSmallContainer(c); 19802 self->f->pushSmallContainer(self, &c); 19803 self->f->pushS(self, ""); 19804 r = isEContainerO(self, 0); 19805 ck_assert(r); 19806 r = isEContainerO(self, -1); 19807 ck_assert(!r); 19808 terminateO(self); 19809 19810 } 19811 19812 19813 void isEDictSmallArrayT(void) { 19814 19815 bool r; 19816 smallArrayt *self = allocG(rtSmallArrayt); 19817 19818 // array 19819 createSmallDict(d); 19820 self->f->pushDict(self, &d); 19821 self->f->pushS(self, ""); 19822 r = isEDictO(self, 0); 19823 ck_assert(r); 19824 r = isEDictO(self, -1); 19825 ck_assert(!r); 19826 terminateO(self); 19827 19828 } 19829 19830 19831 void isEDoubleSmallArrayT(void) { 19832 19833 bool r; 19834 smallArrayt *self = allocG(rtSmallArrayt); 19835 19836 // array 19837 self->f->pushDouble(self, 1); 19838 self->f->pushS(self, ""); 19839 r = isEDoubleO(self, 0); 19840 ck_assert(r); 19841 r = isEDoubleO(self, -1); 19842 ck_assert(!r); 19843 terminateO(self); 19844 19845 } 19846 19847 19848 void isEIntSmallArrayT(void) { 19849 19850 bool r; 19851 smallArrayt *self = allocG(rtSmallArrayt); 19852 19853 // array 19854 self->f->pushInt(self, 1); 19855 self->f->pushS(self, ""); 19856 r = isEIntO(self, 0); 19857 ck_assert(r); 19858 r = isEIntO(self, -1); 19859 ck_assert(!r); 19860 terminateO(self); 19861 19862 } 19863 19864 19865 void isEStringSmallArrayT(void) { 19866 19867 bool r; 19868 smallArrayt *self = allocG(rtSmallArrayt); 19869 19870 // array 19871 self->f->pushUndefined(self); 19872 self->f->pushS(self, ""); 19873 r = isEStringO(self, -1); 19874 ck_assert(r); 19875 r = isEStringO(self, 0); 19876 ck_assert(!r); 19877 terminateO(self); 19878 19879 } 19880 19881 19882 void isEFaststringSmallArrayT(void) { 19883 19884 bool r; 19885 smallArrayt *self = allocG(rtSmallArrayt); 19886 19887 r = isEFaststringO(self, 0); 19888 ck_assert(!r); 19889 terminateO(self); 19890 19891 } 19892 19893 19894 void isEArraySmallArrayT(void) { 19895 19896 bool r; 19897 smallArrayt *self = allocG(rtSmallArrayt); 19898 19899 // array 19900 createSmallArray(a); 19901 self->f->pushArray(self, &a); 19902 self->f->pushS(self, ""); 19903 r = isEArrayO(self, 0); 19904 ck_assert(r); 19905 r = isEArrayO(self, -1); 19906 ck_assert(!r); 19907 terminateO(self); 19908 19909 } 19910 19911 19912 void isEBytesSmallArrayT(void) { 19913 19914 bool r; 19915 smallArrayt *self = allocG(rtSmallArrayt); 19916 19917 // array 19918 createSmallBytes(b); 19919 self->f->pushSmallBytes(self, &b); 19920 self->f->pushS(self, ""); 19921 r = isEBytesO(self, 0); 19922 ck_assert(r); 19923 r = isEBytesO(self, -1); 19924 ck_assert(!r); 19925 terminateO(self); 19926 19927 } 19928 19929 19930 void areAllETypeSmallArrayT(void) { 19931 19932 bool r; 19933 smallArrayt *self = allocG(rtSmallArrayt); 19934 19935 // empty array 19936 r = areAllETypeO(self, "undefined"); 19937 ck_assert(!r); 19938 // array 19939 self->f->pushUndefined(self); 19940 self->f->pushUndefined(self); 19941 self->f->pushUndefined(self); 19942 delElemO(self, 1); 19943 r = areAllETypeO(self, "undefined"); 19944 ck_assert(!r); 19945 trimO(self); 19946 r = areAllETypeO(self, "undefined"); 19947 ck_assert(r); 19948 // NULL type 19949 r = areAllETypeO(self, NULL); 19950 ck_assert(!r); 19951 terminateO(self); 19952 19953 } 19954 19955 19956 void areAllEUndefinedSmallArrayT(void) { 19957 19958 bool r; 19959 smallArrayt *self = allocG(rtSmallArrayt); 19960 19961 // array 19962 self->f->pushUndefined(self); 19963 self->f->pushUndefined(self); 19964 self->f->pushUndefined(self); 19965 r = areAllEUndefinedO(self); 19966 ck_assert(r); 19967 terminateO(self); 19968 19969 } 19970 19971 19972 void areAllEBoolSmallArrayT(void) { 19973 19974 bool r; 19975 smallArrayt *self = allocG(rtSmallArrayt); 19976 19977 // array 19978 self->f->pushBool(self, true); 19979 self->f->pushBool(self, true); 19980 self->f->pushBool(self, true); 19981 r = areAllEBoolO(self); 19982 ck_assert(r); 19983 terminateO(self); 19984 19985 } 19986 19987 19988 void areAllEContainerSmallArrayT(void) { 19989 19990 bool r; 19991 smallArrayt *self = allocG(rtSmallArrayt); 19992 19993 createSmallContainer(c); 19994 self->f->pushSmallContainer(self, &c); 19995 r = areAllEContainerO(self); 19996 ck_assert(r); 19997 terminateO(self); 19998 19999 } 20000 20001 20002 void areAllEDictSmallArrayT(void) { 20003 20004 bool r; 20005 smallArrayt *self = allocG(rtSmallArrayt); 20006 20007 createSmallDict(d); 20008 self->f->pushDict(self, &d); 20009 r = areAllEDictO(self); 20010 ck_assert(r); 20011 terminateO(self); 20012 20013 } 20014 20015 20016 void areAllEDoubleSmallArrayT(void) { 20017 20018 bool r; 20019 smallArrayt *self = allocG(rtSmallArrayt); 20020 20021 self->f->pushDouble(self, 1); 20022 r = areAllEDoubleO(self); 20023 ck_assert(r); 20024 terminateO(self); 20025 20026 } 20027 20028 20029 void areAllEIntSmallArrayT(void) { 20030 20031 bool r; 20032 smallArrayt *self = allocG(rtSmallArrayt); 20033 20034 self->f->pushInt(self, 1); 20035 r = areAllEIntO(self); 20036 ck_assert(r); 20037 terminateO(self); 20038 20039 } 20040 20041 20042 void areAllEStringSmallArrayT(void) { 20043 20044 bool r; 20045 smallArrayt *self = allocG(rtSmallArrayt); 20046 20047 self->f->pushS(self, ""); 20048 r = areAllEStringO(self); 20049 ck_assert(r); 20050 terminateO(self); 20051 20052 } 20053 20054 20055 void areAllEFaststringSmallArrayT(void) { 20056 20057 bool r; 20058 smallArrayt *self = allocG(rtSmallArrayt); 20059 20060 self->f->pushS(self, ""); 20061 r = areAllEFaststringO(self); 20062 ck_assert(!r); 20063 terminateO(self); 20064 20065 } 20066 20067 20068 void areAllEArraySmallArrayT(void) { 20069 20070 bool r; 20071 smallArrayt *self = allocG(rtSmallArrayt); 20072 20073 createSmallArray(a); 20074 self->f->pushArray(self, &a); 20075 r = areAllEArrayO(self); 20076 ck_assert(r); 20077 terminateO(self); 20078 20079 } 20080 20081 20082 void areAllEBytesSmallArrayT(void) { 20083 20084 bool r; 20085 smallArrayt *self = allocG(rtSmallArrayt); 20086 20087 createSmallBytes(b); 20088 self->f->pushSmallBytes(self, &b); 20089 r = areAllEBytesO(self); 20090 ck_assert(r); 20091 terminateO(self); 20092 20093 } 20094 20095 20096 void allocSmallArrayGT(void) { 20097 20098 smallArrayt *self = allocSmallArrayG(self); 20099 20100 ck_assert_ptr_ne(self, NULL); 20101 char *s = toStringO(self); 20102 ck_assert_str_eq(s, "[]"); 20103 free(s); 20104 terminateO(self); 20105 20106 } 20107 20108 20109 void duplicateSmallArrayGT(void) { 20110 20111 smallArrayt* r; 20112 smallArrayt *self = allocG(rtSmallArrayt); 20113 20114 self->f->pushInt(self, 1); 20115 r = duplicateSmallArrayG(self); 20116 char *s = toStringO(r); 20117 terminateO(r); 20118 ck_assert_str_eq(s, "[1]"); 20119 free(s); 20120 terminateO(self); 20121 20122 } 20123 20124 20125 void freeSmallArrayGT(void) { 20126 20127 smallArrayt *self = allocG(rtSmallArrayt); 20128 20129 self->f->pushInt(self, 1); 20130 freeSmallArrayG(self); 20131 char *s = toStringO(self); 20132 ck_assert_str_eq(s, "[]"); 20133 free(s); 20134 terminateO(self); 20135 20136 } 20137 20138 20139 void fromArraySmallArrayGT(void) { 20140 20141 smallArrayt* r; 20142 smallArrayt *self = allocG(rtSmallArrayt); 20143 20144 char *array[] = {"1", "22", "333"}; 20145 r = fromArraySmallArrayG(self, array, 3); 20146 ck_assert_ptr_ne(r, NULL); 20147 char *s = toStringO(r); 20148 ck_assert_str_eq(s, "[\"1\",\"22\",\"333\"]"); 20149 free(s); 20150 terminateO(self); 20151 20152 } 20153 20154 20155 void fromCArraySmallArrayGT(void) { 20156 20157 smallArrayt* r; 20158 smallArrayt *self = allocG(rtSmallArrayt); 20159 20160 const char *array[] = {"1", "22", "333"}; 20161 r = fromCArraySmallArrayG(self, array, 3); 20162 ck_assert_ptr_ne(r, NULL); 20163 char *s = toStringO(r); 20164 ck_assert_str_eq(s, "[\"1\",\"22\",\"333\"]"); 20165 free(s); 20166 terminateO(self); 20167 20168 } 20169 20170 20171 void setFromSmallArrayGT(void) { 20172 20173 smallArrayt* r; 20174 smallArrayt *self = allocG(rtSmallArrayt); 20175 20176 char *array[] = {"1", "22", "333", NULL}; 20177 r = setFromSmallArrayG(self, array); 20178 ck_assert_ptr_ne(r, NULL); 20179 char *s = toStringO(r); 20180 ck_assert_str_eq(s, "[\"1\",\"22\",\"333\"]"); 20181 free(s); 20182 terminateO(self); 20183 20184 } 20185 20186 20187 void setFromCSmallArrayGT(void) { 20188 20189 smallArrayt *r; 20190 smallArrayt *self = allocG(rtSmallArrayt); 20191 20192 const char *array[] = {"1", "22", "333", NULL}; 20193 r = setFromCSmallArrayG(self, array); 20194 ck_assert_ptr_ne(r, NULL); 20195 char *s = toStringO(r); 20196 ck_assert_str_eq(s, "[\"1\",\"22\",\"333\"]"); 20197 free(s); 20198 terminateO(self); 20199 20200 } 20201 20202 20203 void pushSmallArrayGT(void) { 20204 20205 smallArrayt* r; 20206 smallArrayt *self = allocG(rtSmallArrayt); 20207 baset *value = (baset*) allocSmallInt(1); 20208 20209 r = pushSmallArrayG(self, value); 20210 ck_assert_ptr_ne(r, null); 20211 finishO(value); 20212 char *s = toStringO(r); 20213 ck_assert_str_eq(s, "[1]"); 20214 free(s); 20215 terminateO(self); 20216 20217 } 20218 20219 20220 void pushUndefinedSmallArrayGT(void) { 20221 20222 smallArrayt* r; 20223 smallArrayt *self = allocG(rtSmallArrayt); 20224 20225 r = pushUndefinedSmallArrayG(self, NULL); 20226 ck_assert_ptr_ne(r, null); 20227 char *s = toStringO(r); 20228 ck_assert_str_eq(s, "[null]"); 20229 free(s); 20230 terminateO(self); 20231 20232 } 20233 20234 20235 void pushBoolSmallArrayGT(void) { 20236 20237 smallArrayt* r; 20238 smallArrayt *self = allocG(rtSmallArrayt); 20239 20240 r = pushBoolSmallArrayG(self, true); 20241 ck_assert_ptr_ne(r, null); 20242 char *s = toStringO(r); 20243 ck_assert_str_eq(s, "[true]"); 20244 free(s); 20245 terminateO(self); 20246 20247 } 20248 20249 20250 void pushDoubleSmallArrayGT(void) { 20251 20252 smallArrayt* r; 20253 smallArrayt *self = allocG(rtSmallArrayt); 20254 20255 r = pushDoubleSmallArrayG(self, 1); 20256 ck_assert_ptr_ne(r, null); 20257 char *s = toStringO(r); 20258 ck_assert_str_eq(s, "[1.000000e+00]"); 20259 free(s); 20260 terminateO(self); 20261 20262 } 20263 20264 20265 void pushIntSmallArrayGT(void) { 20266 20267 smallArrayt* r; 20268 smallArrayt *self = allocG(rtSmallArrayt); 20269 20270 r = pushIntSmallArrayG(self, 1); 20271 ck_assert_ptr_ne(r, null); 20272 char *s = toStringO(r); 20273 ck_assert_str_eq(s, "[1]"); 20274 free(s); 20275 terminateO(self); 20276 20277 } 20278 20279 20280 void pushSSmallArrayGT(void) { 20281 20282 smallArrayt* r; 20283 smallArrayt *self = allocG(rtSmallArrayt); 20284 20285 r = pushSSmallArrayG(self, "qwe"); 20286 ck_assert_ptr_ne(r, null); 20287 char *s = toStringO(r); 20288 ck_assert_str_eq(s, "[\"qwe\"]"); 20289 free(s); 20290 terminateO(self); 20291 20292 } 20293 20294 20295 void pushCharSmallArrayGT(void) { 20296 20297 smallArrayt* r; 20298 smallArrayt *self = allocG(rtSmallArrayt); 20299 20300 r = pushCharSmallArrayG(self, 'Q'); 20301 ck_assert_ptr_ne(r, null); 20302 char *s = toStringO(r); 20303 ck_assert_str_eq(s, "[\"Q\"]"); 20304 free(s); 20305 terminateO(self); 20306 20307 } 20308 20309 20310 void pushDictSmallArrayGT(void) { 20311 20312 smallArrayt* r; 20313 smallArrayt *self = allocG(rtSmallArrayt); 20314 smallDictt *dict = allocSmallDict(); 20315 20316 r = pushDictSmallArrayG(self, dict); 20317 ck_assert_ptr_ne(r, null); 20318 finishO(dict); 20319 char *s = toStringO(r); 20320 ck_assert_str_eq(s, "[{}]"); 20321 free(s); 20322 terminateO(self); 20323 20324 } 20325 20326 20327 void pushArraySmallArrayGT(void) { 20328 20329 smallArrayt* r; 20330 smallArrayt *self = allocG(rtSmallArrayt); 20331 smallArrayt *array = allocSmallArray(); 20332 20333 r = pushArraySmallArrayG(self, array); 20334 ck_assert_ptr_ne(r, null); 20335 finishO(array); 20336 char *s = toStringO(r); 20337 ck_assert_str_eq(s, "[[]]"); 20338 free(s); 20339 terminateO(self); 20340 20341 } 20342 20343 20344 void pushArraycSmallArrayGT(void) { 20345 20346 smallArrayt* r; 20347 smallArrayt *self = allocG(rtSmallArrayt); 20348 char **array = listCreateS("a","bb"); 20349 20350 r = pushArraycSmallArrayG(self, array); 20351 ck_assert_ptr_ne(r, null); 20352 ck_assert_int_eq(lenO(r), 1); 20353 listFreeS(array); 20354 char *s = toStringO(r); 20355 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 20356 free(s); 20357 terminateO(self); 20358 20359 } 20360 20361 20362 void pushCArraycSmallArrayGT(void) { 20363 20364 smallArrayt* r; 20365 smallArrayt *self = allocG(rtSmallArrayt); 20366 const char *array[] = {"a", "bb", NULL}; 20367 20368 r = pushCArraycSmallArrayG(self, array); 20369 ck_assert_ptr_ne(r, null); 20370 ck_assert_int_eq(lenO(r), 1); 20371 char *s = toStringO(r); 20372 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 20373 free(s); 20374 terminateO(self); 20375 20376 } 20377 20378 20379 void pushVoidSmallArrayGT(void) { 20380 20381 smallArrayt* r; 20382 smallArrayt *self = allocG(rtSmallArrayt); 20383 20384 // NULL value 20385 r = pushVoidSmallArrayG(self, NULL); 20386 ck_assert_ptr_ne(r, null); 20387 char *s = toStringO(r); 20388 ck_assert_str_eq(s, "[null]"); 20389 free(s); 20390 // value 20391 r = pushVoidSmallArrayG(self, r); 20392 s = toStringO(r); 20393 ck_assert_str_eq(s, "[null,\"<data container>\"]"); 20394 free(s); 20395 terminateO(self); 20396 20397 } 20398 20399 20400 void pushSmallBoolSmallArrayGT(void) { 20401 20402 smallArrayt* r; 20403 smallArrayt *self = allocG(rtSmallArrayt); 20404 smallBoolt *value = allocSmallBool(true); 20405 20406 r = pushSmallBoolSmallArrayG(self, value); 20407 ck_assert_ptr_ne(r, null); 20408 finishO(value); 20409 char *s = toStringO(r); 20410 ck_assert_str_eq(s, "[true]"); 20411 free(s); 20412 terminateO(self); 20413 20414 } 20415 20416 20417 void pushSmallBytesSmallArrayGT(void) { 20418 20419 smallArrayt* r; 20420 smallArrayt *self = allocG(rtSmallArrayt); 20421 smallBytest *value = allocSmallBytes("qwe", 3); 20422 20423 r = pushSmallBytesSmallArrayG(self, value); 20424 ck_assert_ptr_ne(r, null); 20425 finishO(value); 20426 char *s = toStringO(r); 20427 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 20428 free(s); 20429 terminateO(self); 20430 20431 } 20432 20433 20434 void pushSmallDoubleSmallArrayGT(void) { 20435 20436 smallArrayt* r; 20437 smallArrayt *self = allocG(rtSmallArrayt); 20438 smallDoublet *value = allocSmallDouble(1); 20439 20440 r = pushSmallDoubleSmallArrayG(self, value); 20441 ck_assert_ptr_ne(r, null); 20442 finishO(value); 20443 char *s = toStringO(r); 20444 ck_assert_str_eq(s, "[1.000000e+00]"); 20445 free(s); 20446 terminateO(self); 20447 20448 } 20449 20450 20451 void pushSmallIntSmallArrayGT(void) { 20452 20453 smallArrayt* r; 20454 smallArrayt *self = allocG(rtSmallArrayt); 20455 smallIntt *value = allocSmallInt(1); 20456 20457 r = pushSmallIntSmallArrayG(self, value); 20458 ck_assert_ptr_ne(r, null); 20459 finishO(value); 20460 char *s = toStringO(r); 20461 ck_assert_str_eq(s, "[1]"); 20462 free(s); 20463 terminateO(self); 20464 20465 } 20466 20467 20468 void pushSmallJsonSmallArrayGT(void) { 20469 20470 smallArrayt* r; 20471 smallArrayt *self = allocG(rtSmallArrayt); 20472 smallJsont *value = allocSmallJson(); 20473 20474 r = pushSmallJsonSmallArrayG(self, value); 20475 ck_assert_ptr_ne(r, null); 20476 finishO(value); 20477 char *s = toStringO(r); 20478 ck_assert_str_eq(s, "[{}]"); 20479 free(s); 20480 terminateO(self); 20481 20482 } 20483 20484 20485 void pushSmallStringSmallArrayGT(void) { 20486 20487 smallArrayt* r; 20488 smallArrayt *self = allocG(rtSmallArrayt); 20489 smallStringt *string = allocSmallString("qwe"); 20490 20491 r = pushSmallStringSmallArrayG(self, string); 20492 ck_assert_ptr_ne(r, null); 20493 finishO(string); 20494 char *s = toStringO(r); 20495 ck_assert_str_eq(s, "[\"qwe\"]"); 20496 free(s); 20497 terminateO(self); 20498 20499 } 20500 20501 20502 void pushSmallContainerSmallArrayGT(void) { 20503 20504 smallArrayt* r; 20505 smallArrayt *self = allocG(rtSmallArrayt); 20506 20507 createSmallContainer(c); 20508 r = pushSmallContainerSmallArrayG(self, &c); 20509 ck_assert_ptr_ne(r, null); 20510 char *s = toStringO(r); 20511 ck_assert_str_eq(s, "[\"<data container>\"]"); 20512 free(s); 20513 terminateO(self); 20514 20515 } 20516 20517 20518 void pushNFreeSmallArrayGT(void) { 20519 20520 smallArrayt* r; 20521 smallArrayt *self = allocG(rtSmallArrayt); 20522 baset *value = (baset*) allocSmallInt(1); 20523 20524 r = pushNFreeSmallArrayG(self, value); 20525 ck_assert_ptr_ne(r, null); 20526 char *s = toStringO(r); 20527 ck_assert_str_eq(s, "[1]"); 20528 free(s); 20529 terminateO(self); 20530 20531 } 20532 20533 20534 void pushNFreeUndefinedSmallArrayGT(void) { 20535 20536 smallArrayt* r; 20537 smallArrayt *self = allocG(rtSmallArrayt); 20538 undefinedt *value = allocUndefined(); 20539 20540 r = pushNFreeUndefinedSmallArrayG(self, value); 20541 ck_assert_ptr_ne(r, null); 20542 char *s = toStringO(r); 20543 ck_assert_str_eq(s, "[null]"); 20544 free(s); 20545 terminateO(self); 20546 20547 } 20548 20549 20550 void pushNFreeSSmallArrayGT(void) { 20551 20552 smallArrayt* r; 20553 smallArrayt *self = allocG(rtSmallArrayt); 20554 20555 r = pushNFreeSSmallArrayG(self, strdup("qwe")); 20556 ck_assert_ptr_ne(r, null); 20557 char *s = toStringO(r); 20558 ck_assert_str_eq(s, "[\"qwe\"]"); 20559 free(s); 20560 terminateO(self); 20561 20562 } 20563 20564 20565 void pushNFreeDictSmallArrayGT(void) { 20566 20567 smallArrayt* r; 20568 smallArrayt *self = allocG(rtSmallArrayt); 20569 smallDictt *dict = allocSmallDict(); 20570 20571 r = pushNFreeDictSmallArrayG(self, dict); 20572 ck_assert_ptr_ne(r, null); 20573 char *s = toStringO(r); 20574 ck_assert_str_eq(s, "[{}]"); 20575 free(s); 20576 terminateO(self); 20577 20578 } 20579 20580 20581 void pushNFreeArraySmallArrayGT(void) { 20582 20583 smallArrayt* r; 20584 smallArrayt *self = allocG(rtSmallArrayt); 20585 smallArrayt *array = allocSmallArray(); 20586 20587 r = pushNFreeArraySmallArrayG(self, array); 20588 ck_assert_ptr_ne(r, null); 20589 char *s = toStringO(r); 20590 ck_assert_str_eq(s, "[[]]"); 20591 free(s); 20592 terminateO(self); 20593 20594 } 20595 20596 20597 void pushNFreeArraycSmallArrayGT(void) { 20598 20599 smallArrayt* r; 20600 smallArrayt *self = allocG(rtSmallArrayt); 20601 char **array = listCreateS("a","bb"); 20602 20603 r = pushNFreeArraycSmallArrayG(self, array); 20604 ck_assert_ptr_ne(r, null); 20605 ck_assert_int_eq(lenO(r), 1); 20606 char *s = toStringO(r); 20607 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 20608 free(s); 20609 terminateO(self); 20610 20611 } 20612 20613 20614 void pushNFreeSmallBoolSmallArrayGT(void) { 20615 20616 smallArrayt* r; 20617 smallArrayt *self = allocG(rtSmallArrayt); 20618 smallBoolt *value = allocSmallBool(true); 20619 20620 r = pushNFreeSmallBoolSmallArrayG(self, value); 20621 ck_assert_ptr_ne(r, null); 20622 char *s = toStringO(r); 20623 ck_assert_str_eq(s, "[true]"); 20624 free(s); 20625 terminateO(self); 20626 20627 } 20628 20629 20630 void pushNFreeSmallBytesSmallArrayGT(void) { 20631 20632 smallArrayt* r; 20633 smallArrayt *self = allocG(rtSmallArrayt); 20634 smallBytest *value = allocSmallBytes("qwe", 3); 20635 20636 r = pushNFreeSmallBytesSmallArrayG(self, value); 20637 ck_assert_ptr_ne(r, null); 20638 char *s = toStringO(r); 20639 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 20640 free(s); 20641 terminateO(self); 20642 20643 } 20644 20645 20646 void pushNFreeSmallDoubleSmallArrayGT(void) { 20647 20648 smallArrayt* r; 20649 smallArrayt *self = allocG(rtSmallArrayt); 20650 smallDoublet *value = allocSmallDouble(1); 20651 20652 r = pushNFreeSmallDoubleSmallArrayG(self, value); 20653 ck_assert_ptr_ne(r, null); 20654 char *s = toStringO(r); 20655 ck_assert_str_eq(s, "[1.000000e+00]"); 20656 free(s); 20657 terminateO(self); 20658 20659 } 20660 20661 20662 void pushNFreeSmallIntSmallArrayGT(void) { 20663 20664 smallArrayt* r; 20665 smallArrayt *self = allocG(rtSmallArrayt); 20666 smallIntt *value = allocSmallInt(1); 20667 20668 r = pushNFreeSmallIntSmallArrayG(self, value); 20669 ck_assert_ptr_ne(r, null); 20670 char *s = toStringO(r); 20671 ck_assert_str_eq(s, "[1]"); 20672 free(s); 20673 terminateO(self); 20674 20675 } 20676 20677 20678 void pushNFreeSmallJsonSmallArrayGT(void) { 20679 20680 smallArrayt* r; 20681 smallArrayt *self = allocG(rtSmallArrayt); 20682 smallJsont *value = allocSmallJson(); 20683 20684 r = pushNFreeSmallJsonSmallArrayG(self, value); 20685 ck_assert_ptr_ne(r, null); 20686 char *s = toStringO(r); 20687 ck_assert_str_eq(s, "[{}]"); 20688 free(s); 20689 terminateO(self); 20690 20691 } 20692 20693 20694 void pushNFreeSmallStringSmallArrayGT(void) { 20695 20696 smallArrayt* r; 20697 smallArrayt *self = allocG(rtSmallArrayt); 20698 smallStringt *string = allocSmallString("qwe"); 20699 20700 r = pushNFreeSmallStringSmallArrayG(self, string); 20701 ck_assert_ptr_ne(r, null); 20702 char *s = toStringO(r); 20703 ck_assert_str_eq(s, "[\"qwe\"]"); 20704 free(s); 20705 terminateO(self); 20706 20707 } 20708 20709 20710 void pushNFreeSmallContainerSmallArrayGT(void) { 20711 20712 smallArrayt* r; 20713 smallArrayt *self = allocG(rtSmallArrayt); 20714 20715 createAllocateSmallContainer(c); 20716 r = pushNFreeSmallContainerSmallArrayG(self, c); 20717 ck_assert_ptr_ne(r, null); 20718 char *s = toStringO(r); 20719 ck_assert_str_eq(s, "[\"<data container>\"]"); 20720 free(s); 20721 terminateO(self); 20722 20723 } 20724 20725 20726 void popSmallArrayGT(void) { 20727 20728 baset* r; 20729 smallArrayt *self = allocG(rtSmallArrayt); 20730 20731 smallArrayt *r2 = self->f->pushInt(self, 1); 20732 ck_assert_ptr_ne(r2, null); 20733 r = popSmallArrayG(self, NULL); 20734 ck_assert_ptr_ne(r, null); 20735 char *s = toStringO(r); 20736 terminateO(r); 20737 ck_assert_str_eq(s, "1"); 20738 free(s); 20739 // empty array 20740 self->f->pushUndefined(self); 20741 delElemO(self, -1); 20742 r = popSmallArrayG(self, NULL); 20743 ck_assert_ptr_eq(r, null); 20744 terminateO(self); 20745 20746 } 20747 20748 20749 void popUndefinedSmallArrayGT(void) { 20750 20751 undefinedt* r; 20752 smallArrayt *self = allocG(rtSmallArrayt); 20753 20754 smallArrayt *r2 = self->f->pushUndefined(self); 20755 ck_assert_ptr_ne(r2, null); 20756 r = popUndefinedSmallArrayG(self, null); 20757 ck_assert_ptr_ne(r, null); 20758 char *s = toStringO(r); 20759 terminateO(r); 20760 ck_assert_str_eq(s, "null"); 20761 free(s); 20762 terminateO(self); 20763 20764 } 20765 20766 20767 void popBoolSmallArrayGT(void) { 20768 20769 bool r; 20770 smallArrayt *self = allocG(rtSmallArrayt); 20771 20772 smallArrayt *r2 = self->f->pushBool(self, TRUE); 20773 ck_assert_ptr_ne(r2, null); 20774 r = popBoolSmallArrayG(self, null); 20775 ck_assert(r); 20776 terminateO(self); 20777 20778 } 20779 20780 20781 void popDoubleSmallArrayGT(void) { 20782 20783 double r; 20784 smallArrayt *self = allocG(rtSmallArrayt); 20785 20786 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 20787 ck_assert_ptr_ne(r2, null); 20788 r = popDoubleSmallArrayG(self, 0); 20789 ck_assert(r==2.0); 20790 terminateO(self); 20791 20792 } 20793 20794 20795 void popIntSmallArrayGT(void) { 20796 20797 int64_t r; 20798 smallArrayt *self = allocG(rtSmallArrayt); 20799 20800 smallArrayt *r2 = self->f->pushInt(self, 2); 20801 ck_assert_ptr_ne(r2, null); 20802 r = popIntSmallArrayG(self, 0); 20803 ck_assert_int_eq(r, 2); 20804 terminateO(self); 20805 20806 } 20807 20808 20809 void popInt32SmallArrayGT(void) { 20810 20811 int32_t r; 20812 smallArrayt *self = allocG(rtSmallArrayt); 20813 20814 smallArrayt *r2 = self->f->pushInt(self, 2); 20815 ck_assert_ptr_ne(r2, null); 20816 r = popInt32SmallArrayG(self, 0); 20817 ck_assert_int_eq(r, 2); 20818 terminateO(self); 20819 20820 } 20821 20822 20823 void popUintSmallArrayGT(void) { 20824 20825 uint64_t r; 20826 smallArrayt *self = allocG(rtSmallArrayt); 20827 20828 smallArrayt *r2 = self->f->pushInt(self, 2); 20829 ck_assert_ptr_ne(r2, null); 20830 r = popUintSmallArrayG(self, 0); 20831 ck_assert_int_eq(r, 2); 20832 terminateO(self); 20833 20834 } 20835 20836 20837 void popUint32SmallArrayGT(void) { 20838 20839 uint32_t r; 20840 smallArrayt *self = allocG(rtSmallArrayt); 20841 20842 smallArrayt *r2 = self->f->pushInt(self, 2); 20843 ck_assert_ptr_ne(r2, null); 20844 r = popUint32SmallArrayG(self, 0); 20845 ck_assert_int_eq(r, 2); 20846 terminateO(self); 20847 20848 } 20849 20850 20851 void popSSmallArrayGT(void) { 20852 20853 char* r; 20854 smallArrayt *self = allocG(rtSmallArrayt); 20855 20856 smallArrayt *r2 = self->f->pushS(self, "2"); 20857 ck_assert_ptr_ne(r2, null); 20858 r = popSSmallArrayG(self, null); 20859 ck_assert_str_eq(r, "2"); 20860 free(r); 20861 terminateO(self); 20862 20863 } 20864 20865 20866 void popDictSmallArrayGT(void) { 20867 20868 smallDictt* r; 20869 smallArrayt *self = allocG(rtSmallArrayt); 20870 20871 createSmallDict(d); 20872 smallArrayt *r2 = self->f->pushDict(self, &d); 20873 ck_assert_ptr_ne(r2, null); 20874 r = popDictSmallArrayG(self, null); 20875 ck_assert_ptr_ne(r, null); 20876 char *s = toStringO(r); 20877 ck_assert_str_eq(s, "{}"); 20878 free(s); 20879 terminateO(r); 20880 terminateO(self); 20881 20882 } 20883 20884 20885 void popArraySmallArrayGT(void) { 20886 20887 smallArrayt* r; 20888 smallArrayt *self = allocG(rtSmallArrayt); 20889 20890 createSmallArray(a); 20891 smallArrayt *r2 = self->f->pushArray(self, &a); 20892 ck_assert_ptr_ne(r2, null); 20893 r = popArraySmallArrayG(self, null); 20894 ck_assert_ptr_ne(r, null); 20895 char *s = toStringO(r); 20896 ck_assert_str_eq(s, "[]"); 20897 free(s); 20898 terminateO(r); 20899 terminateO(self); 20900 20901 } 20902 20903 20904 void popSmallBoolSmallArrayGT(void) { 20905 20906 smallBoolt* r; 20907 smallArrayt *self = allocG(rtSmallArrayt); 20908 20909 smallArrayt *r2 = self->f->pushBool(self, true); 20910 ck_assert_ptr_ne(r2, null); 20911 r = popSmallBoolSmallArrayG(self, null); 20912 ck_assert_ptr_ne(r, null); 20913 char *s = toStringO(r); 20914 ck_assert_str_eq(s, "true"); 20915 free(s); 20916 terminateO(r); 20917 terminateO(self); 20918 20919 } 20920 20921 20922 void popSmallBytesSmallArrayGT(void) { 20923 20924 smallBytest* r; 20925 smallArrayt *self = allocG(rtSmallArrayt); 20926 20927 createSmallBytes(b); 20928 smallArrayt *r2 = self->f->pushSmallBytes(self, &b); 20929 ck_assert_ptr_ne(r2, null); 20930 r = popSmallBytesSmallArrayG(self, null); 20931 ck_assert_ptr_ne(r, null); 20932 char *s = toStringO(r); 20933 ck_assert_str_eq(s, "[]"); 20934 free(s); 20935 terminateO(r); 20936 terminateO(self); 20937 20938 } 20939 20940 20941 void popSmallDoubleSmallArrayGT(void) { 20942 20943 smallDoublet* r; 20944 smallArrayt *self = allocG(rtSmallArrayt); 20945 20946 smallArrayt *r2 = self->f->pushDouble(self, 1); 20947 ck_assert_ptr_ne(r2, null); 20948 r = popSmallDoubleSmallArrayG(self, null); 20949 ck_assert_ptr_ne(r, null); 20950 char *s = toStringO(r); 20951 ck_assert_str_eq(s, "1.000000e+00"); 20952 free(s); 20953 terminateO(r); 20954 terminateO(self); 20955 20956 } 20957 20958 20959 void popSmallIntSmallArrayGT(void) { 20960 20961 smallIntt* r; 20962 smallArrayt *self = allocG(rtSmallArrayt); 20963 20964 smallArrayt *r2 = self->f->pushInt(self, 1); 20965 ck_assert_ptr_ne(r2, null); 20966 r = popSmallIntSmallArrayG(self, null); 20967 ck_assert_ptr_ne(r, null); 20968 char *s = toStringO(r); 20969 ck_assert_str_eq(s, "1"); 20970 free(s); 20971 terminateO(r); 20972 terminateO(self); 20973 20974 } 20975 20976 20977 void popSmallJsonSmallArrayGT(void) { 20978 20979 smallJsont* r; 20980 smallArrayt *self = allocG(rtSmallArrayt); 20981 20982 createSmallJson(j); 20983 smallArrayt *r2 = self->f->pushSmallJson(self, &j); 20984 ck_assert_ptr_ne(r2, null); 20985 r = popSmallJsonSmallArrayG(self, null); 20986 ck_assert_ptr_ne(r, null); 20987 char *s = toStringO(r); 20988 ck_assert_str_eq(s, "{}"); 20989 free(s); 20990 terminateO(r); 20991 terminateO(self); 20992 20993 } 20994 20995 20996 void popSmallStringSmallArrayGT(void) { 20997 20998 smallStringt* r; 20999 smallArrayt *self = allocG(rtSmallArrayt); 21000 21001 createSmallString(S); 21002 smallArrayt *r2 = self->f->pushSmallString(self, &S); 21003 ck_assert_ptr_ne(r2, null); 21004 r = popSmallStringSmallArrayG(self, null); 21005 ck_assert_ptr_ne(r, null); 21006 char *s = toStringO(r); 21007 ck_assert_str_eq(s, ""); 21008 free(s); 21009 terminateO(r); 21010 terminateO(self); 21011 21012 } 21013 21014 21015 void popVoidSmallArrayGT(void) { 21016 21017 void* r; 21018 smallArrayt *self = allocG(rtSmallArrayt); 21019 21020 createSmallContainer(c); 21021 setValO(&c, &r); 21022 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 21023 ck_assert_ptr_ne(r2, null); 21024 r = popVoidSmallArrayG(self, null); 21025 ck_assert_ptr_eq(r, &r); 21026 terminateO(self); 21027 21028 } 21029 21030 21031 void popSmallContainerSmallArrayGT(void) { 21032 21033 smallContainert* r; 21034 smallArrayt *self = allocG(rtSmallArrayt); 21035 21036 createSmallContainer(c); 21037 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 21038 ck_assert_ptr_ne(r2, null); 21039 r = popSmallContainerSmallArrayG(self, null); 21040 ck_assert_ptr_ne(r, null); 21041 char *s = toStringO(r); 21042 ck_assert_str_eq(s, "<data smallContainer>"); 21043 free(s); 21044 terminateO(r); 21045 terminateO(self); 21046 21047 } 21048 21049 21050 void prependSmallArrayGT(void) { 21051 21052 smallArrayt* r; 21053 smallArrayt *self = allocG(rtSmallArrayt); 21054 baset *value = (baset*) allocSmallInt(1); 21055 21056 r = prependSmallArrayG(self, value); 21057 ck_assert_ptr_ne(r, null); 21058 finishO(value); 21059 char *s = toStringO(r); 21060 ck_assert_str_eq(s, "[1]"); 21061 free(s); 21062 terminateO(self); 21063 21064 } 21065 21066 21067 void prependUndefinedSmallArrayGT(void) { 21068 21069 smallArrayt* r; 21070 smallArrayt *self = allocG(rtSmallArrayt); 21071 21072 r = prependUndefinedSmallArrayG(self, NULL); 21073 ck_assert_ptr_ne(r, null); 21074 char *s = toStringO(r); 21075 ck_assert_str_eq(s, "[null]"); 21076 free(s); 21077 terminateO(self); 21078 21079 } 21080 21081 21082 void prependBoolSmallArrayGT(void) { 21083 21084 smallArrayt* r; 21085 smallArrayt *self = allocG(rtSmallArrayt); 21086 21087 r = prependBoolSmallArrayG(self, true); 21088 ck_assert_ptr_ne(r, null); 21089 char *s = toStringO(r); 21090 ck_assert_str_eq(s, "[true]"); 21091 free(s); 21092 terminateO(self); 21093 21094 } 21095 21096 21097 void prependDoubleSmallArrayGT(void) { 21098 21099 smallArrayt* r; 21100 smallArrayt *self = allocG(rtSmallArrayt); 21101 21102 r = prependDoubleSmallArrayG(self, 1); 21103 ck_assert_ptr_ne(r, null); 21104 char *s = toStringO(r); 21105 ck_assert_str_eq(s, "[1.000000e+00]"); 21106 free(s); 21107 terminateO(self); 21108 21109 } 21110 21111 21112 void prependIntSmallArrayGT(void) { 21113 21114 smallArrayt* r; 21115 smallArrayt *self = allocG(rtSmallArrayt); 21116 21117 r = prependIntSmallArrayG(self, 1); 21118 ck_assert_ptr_ne(r, null); 21119 char *s = toStringO(r); 21120 ck_assert_str_eq(s, "[1]"); 21121 free(s); 21122 terminateO(self); 21123 21124 } 21125 21126 21127 void prependSSmallArrayGT(void) { 21128 21129 smallArrayt* r; 21130 smallArrayt *self = allocG(rtSmallArrayt); 21131 21132 r = prependSSmallArrayG(self, "qwe"); 21133 ck_assert_ptr_ne(r, null); 21134 char *s = toStringO(r); 21135 ck_assert_str_eq(s, "[\"qwe\"]"); 21136 free(s); 21137 terminateO(self); 21138 21139 } 21140 21141 21142 void prependCharSmallArrayGT(void) { 21143 21144 smallArrayt* r; 21145 smallArrayt *self = allocG(rtSmallArrayt); 21146 21147 r = prependCharSmallArrayG(self, 'Q'); 21148 ck_assert_ptr_ne(r, null); 21149 char *s = toStringO(r); 21150 ck_assert_str_eq(s, "[\"Q\"]"); 21151 free(s); 21152 terminateO(self); 21153 21154 } 21155 21156 21157 void prependDictSmallArrayGT(void) { 21158 21159 smallArrayt* r; 21160 smallArrayt *self = allocG(rtSmallArrayt); 21161 smallDictt *dict = allocSmallDict(); 21162 21163 r = prependDictSmallArrayG(self, dict); 21164 ck_assert_ptr_ne(r, null); 21165 finishO(dict); 21166 char *s = toStringO(r); 21167 ck_assert_str_eq(s, "[{}]"); 21168 free(s); 21169 terminateO(self); 21170 21171 } 21172 21173 21174 void prependArraySmallArrayGT(void) { 21175 21176 smallArrayt* r; 21177 smallArrayt *self = allocG(rtSmallArrayt); 21178 smallArrayt *array = allocSmallArray(); 21179 21180 r = prependArraySmallArrayG(self, array); 21181 ck_assert_ptr_ne(r, null); 21182 finishO(array); 21183 char *s = toStringO(r); 21184 ck_assert_str_eq(s, "[[]]"); 21185 free(s); 21186 terminateO(self); 21187 21188 } 21189 21190 21191 void prependArraycSmallArrayGT(void) { 21192 21193 smallArrayt* r; 21194 smallArrayt *self = allocG(rtSmallArrayt); 21195 char **array = listCreateS("a","bb"); 21196 21197 r = prependArraycSmallArrayG(self, array); 21198 ck_assert_ptr_ne(r, null); 21199 ck_assert_int_eq(lenO(r), 1); 21200 listFreeS(array); 21201 char *s = toStringO(r); 21202 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 21203 free(s); 21204 terminateO(self); 21205 21206 } 21207 21208 21209 void prependCArraycSmallArrayGT(void) { 21210 21211 smallArrayt* r; 21212 smallArrayt *self = allocG(rtSmallArrayt); 21213 const char *array[] = {"a", "bb", NULL}; 21214 21215 r = prependCArraycSmallArrayG(self, array); 21216 ck_assert_ptr_ne(r, null); 21217 ck_assert_int_eq(lenO(r), 1); 21218 char *s = toStringO(r); 21219 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 21220 free(s); 21221 terminateO(self); 21222 21223 } 21224 21225 21226 void prependVoidSmallArrayGT(void) { 21227 21228 smallArrayt* r; 21229 smallArrayt *self = allocG(rtSmallArrayt); 21230 21231 // NULL value 21232 r = prependVoidSmallArrayG(self, NULL); 21233 ck_assert_ptr_ne(r, null); 21234 char *s = toStringO(r); 21235 ck_assert_str_eq(s, "[null]"); 21236 free(s); 21237 // value 21238 r = prependVoidSmallArrayG(self, r); 21239 s = toStringO(r); 21240 ck_assert_str_eq(s, "[\"<data container>\",null]"); 21241 free(s); 21242 terminateO(self); 21243 21244 } 21245 21246 21247 void prependSmallBoolSmallArrayGT(void) { 21248 21249 smallArrayt* r; 21250 smallArrayt *self = allocG(rtSmallArrayt); 21251 smallBoolt *value = allocSmallBool(true); 21252 21253 r = prependSmallBoolSmallArrayG(self, value); 21254 ck_assert_ptr_ne(r, null); 21255 finishO(value); 21256 char *s = toStringO(r); 21257 ck_assert_str_eq(s, "[true]"); 21258 free(s); 21259 terminateO(self); 21260 21261 } 21262 21263 21264 void prependSmallBytesSmallArrayGT(void) { 21265 21266 smallArrayt* r; 21267 smallArrayt *self = allocG(rtSmallArrayt); 21268 smallBytest *value = allocSmallBytes("qwe", 3); 21269 21270 r = prependSmallBytesSmallArrayG(self, value); 21271 ck_assert_ptr_ne(r, null); 21272 finishO(value); 21273 char *s = toStringO(r); 21274 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 21275 free(s); 21276 terminateO(self); 21277 21278 } 21279 21280 21281 void prependSmallDoubleSmallArrayGT(void) { 21282 21283 smallArrayt* r; 21284 smallArrayt *self = allocG(rtSmallArrayt); 21285 smallDoublet *value = allocSmallDouble(1); 21286 21287 r = prependSmallDoubleSmallArrayG(self, value); 21288 ck_assert_ptr_ne(r, null); 21289 finishO(value); 21290 char *s = toStringO(r); 21291 ck_assert_str_eq(s, "[1.000000e+00]"); 21292 free(s); 21293 terminateO(self); 21294 21295 } 21296 21297 21298 void prependSmallIntSmallArrayGT(void) { 21299 21300 smallArrayt* r; 21301 smallArrayt *self = allocG(rtSmallArrayt); 21302 smallIntt *value = allocSmallInt(1); 21303 21304 r = prependSmallIntSmallArrayG(self, value); 21305 ck_assert_ptr_ne(r, null); 21306 finishO(value); 21307 char *s = toStringO(r); 21308 ck_assert_str_eq(s, "[1]"); 21309 free(s); 21310 terminateO(self); 21311 21312 } 21313 21314 21315 void prependSmallJsonSmallArrayGT(void) { 21316 21317 smallArrayt* r; 21318 smallArrayt *self = allocG(rtSmallArrayt); 21319 smallJsont *value = allocSmallJson(); 21320 21321 r = prependSmallJsonSmallArrayG(self, value); 21322 ck_assert_ptr_ne(r, null); 21323 finishO(value); 21324 char *s = toStringO(r); 21325 ck_assert_str_eq(s, "[{}]"); 21326 free(s); 21327 terminateO(self); 21328 21329 } 21330 21331 21332 void prependSmallStringSmallArrayGT(void) { 21333 21334 smallArrayt* r; 21335 smallArrayt *self = allocG(rtSmallArrayt); 21336 smallStringt *string = allocSmallString("qwe"); 21337 21338 r = prependSmallStringSmallArrayG(self, string); 21339 ck_assert_ptr_ne(r, null); 21340 finishO(string); 21341 char *s = toStringO(r); 21342 ck_assert_str_eq(s, "[\"qwe\"]"); 21343 free(s); 21344 terminateO(self); 21345 21346 } 21347 21348 21349 void prependSmallContainerSmallArrayGT(void) { 21350 21351 smallArrayt* r; 21352 smallArrayt *self = allocG(rtSmallArrayt); 21353 21354 createSmallContainer(c); 21355 r = prependSmallContainerSmallArrayG(self, &c); 21356 ck_assert_ptr_ne(r, null); 21357 char *s = toStringO(r); 21358 ck_assert_str_eq(s, "[\"<data container>\"]"); 21359 free(s); 21360 terminateO(self); 21361 21362 } 21363 21364 21365 void prependNFreeSmallArrayGT(void) { 21366 21367 smallArrayt* r; 21368 smallArrayt *self = allocG(rtSmallArrayt); 21369 baset *value = (baset*) allocSmallInt(1); 21370 21371 r = prependNFreeSmallArrayG(self, value); 21372 ck_assert_ptr_ne(r, null); 21373 char *s = toStringO(r); 21374 ck_assert_str_eq(s, "[1]"); 21375 free(s); 21376 terminateO(self); 21377 21378 } 21379 21380 21381 void prependNFreeUndefinedSmallArrayGT(void) { 21382 21383 smallArrayt* r; 21384 smallArrayt *self = allocG(rtSmallArrayt); 21385 undefinedt *value = allocUndefined(); 21386 21387 r = prependNFreeUndefinedSmallArrayG(self, value); 21388 ck_assert_ptr_ne(r, null); 21389 char *s = toStringO(r); 21390 ck_assert_str_eq(s, "[null]"); 21391 free(s); 21392 terminateO(self); 21393 21394 } 21395 21396 21397 void prependNFreeSSmallArrayGT(void) { 21398 21399 smallArrayt* r; 21400 smallArrayt *self = allocG(rtSmallArrayt); 21401 21402 r = prependNFreeSSmallArrayG(self, strdup("qwe")); 21403 ck_assert_ptr_ne(r, null); 21404 char *s = toStringO(r); 21405 ck_assert_str_eq(s, "[\"qwe\"]"); 21406 free(s); 21407 terminateO(self); 21408 21409 } 21410 21411 21412 void prependNFreeDictSmallArrayGT(void) { 21413 21414 smallArrayt* r; 21415 smallArrayt *self = allocG(rtSmallArrayt); 21416 smallDictt *dict = allocSmallDict(); 21417 21418 r = prependNFreeDictSmallArrayG(self, dict); 21419 ck_assert_ptr_ne(r, null); 21420 char *s = toStringO(r); 21421 ck_assert_str_eq(s, "[{}]"); 21422 free(s); 21423 terminateO(self); 21424 21425 } 21426 21427 21428 void prependNFreeArraySmallArrayGT(void) { 21429 21430 smallArrayt* r; 21431 smallArrayt *self = allocG(rtSmallArrayt); 21432 smallArrayt *array = allocSmallArray(); 21433 21434 r = prependNFreeArraySmallArrayG(self, array); 21435 ck_assert_ptr_ne(r, null); 21436 char *s = toStringO(r); 21437 ck_assert_str_eq(s, "[[]]"); 21438 free(s); 21439 terminateO(self); 21440 21441 } 21442 21443 21444 void prependNFreeArraycSmallArrayGT(void) { 21445 21446 smallArrayt* r; 21447 smallArrayt *self = allocG(rtSmallArrayt); 21448 char **array = listCreateS("a","bb"); 21449 21450 r = prependNFreeArraycSmallArrayG(self, array); 21451 ck_assert_ptr_ne(r, null); 21452 ck_assert_int_eq(lenO(r), 1); 21453 char *s = toStringO(r); 21454 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 21455 free(s); 21456 terminateO(self); 21457 21458 } 21459 21460 21461 void prependNFreeSmallBoolSmallArrayGT(void) { 21462 21463 smallArrayt* r; 21464 smallArrayt *self = allocG(rtSmallArrayt); 21465 smallBoolt *value = allocSmallBool(true); 21466 21467 r = prependNFreeSmallBoolSmallArrayG(self, value); 21468 ck_assert_ptr_ne(r, null); 21469 char *s = toStringO(r); 21470 ck_assert_str_eq(s, "[true]"); 21471 free(s); 21472 terminateO(self); 21473 21474 } 21475 21476 21477 void prependNFreeSmallBytesSmallArrayGT(void) { 21478 21479 smallArrayt* r; 21480 smallArrayt *self = allocG(rtSmallArrayt); 21481 smallBytest *value = allocSmallBytes("qwe", 3); 21482 21483 r = prependNFreeSmallBytesSmallArrayG(self, value); 21484 ck_assert_ptr_ne(r, null); 21485 char *s = toStringO(r); 21486 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 21487 free(s); 21488 terminateO(self); 21489 21490 } 21491 21492 21493 void prependNFreeSmallDoubleSmallArrayGT(void) { 21494 21495 smallArrayt* r; 21496 smallArrayt *self = allocG(rtSmallArrayt); 21497 smallDoublet *value = allocSmallDouble(1); 21498 21499 r = prependNFreeSmallDoubleSmallArrayG(self, value); 21500 ck_assert_ptr_ne(r, null); 21501 char *s = toStringO(r); 21502 ck_assert_str_eq(s, "[1.000000e+00]"); 21503 free(s); 21504 terminateO(self); 21505 21506 } 21507 21508 21509 void prependNFreeSmallIntSmallArrayGT(void) { 21510 21511 smallArrayt* r; 21512 smallArrayt *self = allocG(rtSmallArrayt); 21513 smallIntt *value = allocSmallInt(1); 21514 21515 r = prependNFreeSmallIntSmallArrayG(self, value); 21516 ck_assert_ptr_ne(r, null); 21517 char *s = toStringO(r); 21518 ck_assert_str_eq(s, "[1]"); 21519 free(s); 21520 terminateO(self); 21521 21522 } 21523 21524 21525 void prependNFreeSmallJsonSmallArrayGT(void) { 21526 21527 smallArrayt* r; 21528 smallArrayt *self = allocG(rtSmallArrayt); 21529 smallJsont *value = allocSmallJson(); 21530 21531 r = prependNFreeSmallJsonSmallArrayG(self, value); 21532 ck_assert_ptr_ne(r, null); 21533 char *s = toStringO(r); 21534 ck_assert_str_eq(s, "[{}]"); 21535 free(s); 21536 terminateO(self); 21537 21538 } 21539 21540 21541 void prependNFreeSmallStringSmallArrayGT(void) { 21542 21543 smallArrayt* r; 21544 smallArrayt *self = allocG(rtSmallArrayt); 21545 smallStringt *string = allocSmallString("qwe"); 21546 21547 r = prependNFreeSmallStringSmallArrayG(self, string); 21548 ck_assert_ptr_ne(r, null); 21549 char *s = toStringO(r); 21550 ck_assert_str_eq(s, "[\"qwe\"]"); 21551 free(s); 21552 terminateO(self); 21553 21554 } 21555 21556 21557 void prependNFreeSmallContainerSmallArrayGT(void) { 21558 21559 smallArrayt* r; 21560 smallArrayt *self = allocG(rtSmallArrayt); 21561 21562 createAllocateSmallContainer(c); 21563 r = prependNFreeSmallContainerSmallArrayG(self, c); 21564 ck_assert_ptr_ne(r, null); 21565 char *s = toStringO(r); 21566 ck_assert_str_eq(s, "[\"<data container>\"]"); 21567 free(s); 21568 terminateO(self); 21569 21570 } 21571 21572 21573 void dequeueSmallArrayGT(void) { 21574 21575 baset* r; 21576 smallArrayt *self = allocG(rtSmallArrayt); 21577 21578 smallArrayt *r2 = self->f->pushInt(self, 1); 21579 ck_assert_ptr_ne(r2, null); 21580 r = dequeueSmallArrayG(self, NULL); 21581 ck_assert_ptr_ne(r, null); 21582 char *s = toStringO(r); 21583 terminateO(r); 21584 ck_assert_str_eq(s, "1"); 21585 free(s); 21586 terminateO(self); 21587 21588 } 21589 21590 21591 void dequeueUndefinedSmallArrayGT(void) { 21592 21593 undefinedt* r; 21594 smallArrayt *self = allocG(rtSmallArrayt); 21595 21596 smallArrayt *r2 = self->f->pushUndefined(self); 21597 ck_assert_ptr_ne(r2, null); 21598 r = dequeueUndefinedSmallArrayG(self, null); 21599 ck_assert_ptr_ne(r, null); 21600 char *s = toStringO(r); 21601 terminateO(r); 21602 ck_assert_str_eq(s, "null"); 21603 free(s); 21604 terminateO(self); 21605 21606 } 21607 21608 21609 void dequeueBoolSmallArrayGT(void) { 21610 21611 bool r; 21612 smallArrayt *self = allocG(rtSmallArrayt); 21613 21614 smallArrayt *r2 = self->f->pushBool(self, TRUE); 21615 ck_assert_ptr_ne(r2, null); 21616 r = dequeueBoolSmallArrayG(self, null); 21617 ck_assert(r); 21618 terminateO(self); 21619 21620 } 21621 21622 21623 void dequeueDoubleSmallArrayGT(void) { 21624 21625 double r; 21626 smallArrayt *self = allocG(rtSmallArrayt); 21627 21628 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 21629 ck_assert_ptr_ne(r2, null); 21630 r = dequeueDoubleSmallArrayG(self, 0); 21631 ck_assert(r==2.0); 21632 terminateO(self); 21633 21634 } 21635 21636 21637 void dequeueIntSmallArrayGT(void) { 21638 21639 int64_t r; 21640 smallArrayt *self = allocG(rtSmallArrayt); 21641 21642 smallArrayt *r2 = self->f->pushInt(self, 2); 21643 ck_assert_ptr_ne(r2, null); 21644 r = dequeueIntSmallArrayG(self, 0); 21645 ck_assert_int_eq(r, 2); 21646 terminateO(self); 21647 21648 } 21649 21650 21651 void dequeueInt32SmallArrayGT(void) { 21652 21653 int32_t r; 21654 smallArrayt *self = allocG(rtSmallArrayt); 21655 21656 smallArrayt *r2 = self->f->pushInt(self, 2); 21657 ck_assert_ptr_ne(r2, null); 21658 r = dequeueInt32SmallArrayG(self, 0); 21659 ck_assert_int_eq(r, 2); 21660 terminateO(self); 21661 21662 } 21663 21664 21665 void dequeueUintSmallArrayGT(void) { 21666 21667 uint64_t r; 21668 smallArrayt *self = allocG(rtSmallArrayt); 21669 21670 smallArrayt *r2 = self->f->pushInt(self, 2); 21671 ck_assert_ptr_ne(r2, null); 21672 r = dequeueUintSmallArrayG(self, 0); 21673 ck_assert_int_eq(r, 2); 21674 terminateO(self); 21675 21676 } 21677 21678 21679 void dequeueUint32SmallArrayGT(void) { 21680 21681 uint32_t r; 21682 smallArrayt *self = allocG(rtSmallArrayt); 21683 21684 smallArrayt *r2 = self->f->pushInt(self, 2); 21685 ck_assert_ptr_ne(r2, null); 21686 r = dequeueUint32SmallArrayG(self, 0); 21687 ck_assert_int_eq(r, 2); 21688 terminateO(self); 21689 21690 } 21691 21692 21693 void dequeueSSmallArrayGT(void) { 21694 21695 char* r; 21696 smallArrayt *self = allocG(rtSmallArrayt); 21697 21698 smallArrayt *r2 = self->f->pushS(self, "2"); 21699 ck_assert_ptr_ne(r2, null); 21700 r = dequeueSSmallArrayG(self, null); 21701 ck_assert_str_eq(r, "2"); 21702 free(r); 21703 terminateO(self); 21704 21705 } 21706 21707 21708 void dequeueDictSmallArrayGT(void) { 21709 21710 smallDictt* r; 21711 smallArrayt *self = allocG(rtSmallArrayt); 21712 21713 createSmallDict(d); 21714 smallArrayt *r2 = self->f->pushDict(self, &d); 21715 ck_assert_ptr_ne(r2, null); 21716 r = dequeueDictSmallArrayG(self, null); 21717 ck_assert_ptr_ne(r, null); 21718 char *s = toStringO(r); 21719 ck_assert_str_eq(s, "{}"); 21720 free(s); 21721 terminateO(r); 21722 terminateO(self); 21723 21724 } 21725 21726 21727 void dequeueArraySmallArrayGT(void) { 21728 21729 smallArrayt* r; 21730 smallArrayt *self = allocG(rtSmallArrayt); 21731 21732 createSmallArray(a); 21733 smallArrayt *r2 = self->f->pushArray(self, &a); 21734 ck_assert_ptr_ne(r2, null); 21735 r = dequeueArraySmallArrayG(self, null); 21736 ck_assert_ptr_ne(r, null); 21737 char *s = toStringO(r); 21738 ck_assert_str_eq(s, "[]"); 21739 free(s); 21740 terminateO(r); 21741 terminateO(self); 21742 21743 } 21744 21745 21746 void dequeueSmallBoolSmallArrayGT(void) { 21747 21748 smallBoolt* r; 21749 smallArrayt *self = allocG(rtSmallArrayt); 21750 21751 smallArrayt *r2 = self->f->pushBool(self, true); 21752 ck_assert_ptr_ne(r2, null); 21753 r = dequeueSmallBoolSmallArrayG(self, null); 21754 ck_assert_ptr_ne(r, null); 21755 char *s = toStringO(r); 21756 ck_assert_str_eq(s, "true"); 21757 free(s); 21758 terminateO(r); 21759 terminateO(self); 21760 21761 } 21762 21763 21764 void dequeueSmallBytesSmallArrayGT(void) { 21765 21766 smallBytest* r; 21767 smallArrayt *self = allocG(rtSmallArrayt); 21768 21769 createSmallBytes(b); 21770 smallArrayt *r2 = self->f->pushSmallBytes(self, &b); 21771 ck_assert_ptr_ne(r2, null); 21772 r = dequeueSmallBytesSmallArrayG(self, null); 21773 ck_assert_ptr_ne(r, null); 21774 char *s = toStringO(r); 21775 ck_assert_str_eq(s, "[]"); 21776 free(s); 21777 terminateO(r); 21778 terminateO(self); 21779 21780 } 21781 21782 21783 void dequeueSmallDoubleSmallArrayGT(void) { 21784 21785 smallDoublet* r; 21786 smallArrayt *self = allocG(rtSmallArrayt); 21787 21788 smallArrayt *r2 = self->f->pushDouble(self, 1); 21789 ck_assert_ptr_ne(r2, null); 21790 r = dequeueSmallDoubleSmallArrayG(self, null); 21791 ck_assert_ptr_ne(r, null); 21792 char *s = toStringO(r); 21793 ck_assert_str_eq(s, "1.000000e+00"); 21794 free(s); 21795 terminateO(r); 21796 terminateO(self); 21797 21798 } 21799 21800 21801 void dequeueSmallIntSmallArrayGT(void) { 21802 21803 smallIntt* r; 21804 smallArrayt *self = allocG(rtSmallArrayt); 21805 21806 smallArrayt *r2 = self->f->pushInt(self, 1); 21807 ck_assert_ptr_ne(r2, null); 21808 r = dequeueSmallIntSmallArrayG(self, null); 21809 ck_assert_ptr_ne(r, null); 21810 char *s = toStringO(r); 21811 ck_assert_str_eq(s, "1"); 21812 free(s); 21813 terminateO(r); 21814 terminateO(self); 21815 21816 } 21817 21818 21819 void dequeueSmallJsonSmallArrayGT(void) { 21820 21821 smallJsont* r; 21822 smallArrayt *self = allocG(rtSmallArrayt); 21823 21824 createSmallJson(j); 21825 smallArrayt *r2 = self->f->pushSmallJson(self, &j); 21826 ck_assert_ptr_ne(r2, null); 21827 r = dequeueSmallJsonSmallArrayG(self, null); 21828 ck_assert_ptr_ne(r, null); 21829 char *s = toStringO(r); 21830 ck_assert_str_eq(s, "{}"); 21831 free(s); 21832 terminateO(r); 21833 terminateO(self); 21834 21835 } 21836 21837 21838 void dequeueSmallStringSmallArrayGT(void) { 21839 21840 smallStringt* r; 21841 smallArrayt *self = allocG(rtSmallArrayt); 21842 21843 createSmallString(S); 21844 smallArrayt *r2 = self->f->pushSmallString(self, &S); 21845 ck_assert_ptr_ne(r2, null); 21846 r = dequeueSmallStringSmallArrayG(self, null); 21847 ck_assert_ptr_ne(r, null); 21848 char *s = toStringO(r); 21849 ck_assert_str_eq(s, ""); 21850 free(s); 21851 terminateO(r); 21852 terminateO(self); 21853 21854 } 21855 21856 21857 void dequeueVoidSmallArrayGT(void) { 21858 21859 void* r; 21860 smallArrayt *self = allocG(rtSmallArrayt); 21861 21862 createSmallContainer(c); 21863 setValO(&c, &r); 21864 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 21865 ck_assert_ptr_ne(r2, null); 21866 r = dequeueVoidSmallArrayG(self, null); 21867 ck_assert_ptr_eq(r, &r); 21868 terminateO(self); 21869 21870 } 21871 21872 21873 void dequeueSmallContainerSmallArrayGT(void) { 21874 21875 smallContainert* r; 21876 smallArrayt *self = allocG(rtSmallArrayt); 21877 21878 createSmallContainer(c); 21879 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 21880 ck_assert_ptr_ne(r2, null); 21881 r = dequeueSmallContainerSmallArrayG(self, null); 21882 ck_assert_ptr_ne(r, null); 21883 char *s = toStringO(r); 21884 ck_assert_str_eq(s, "<data smallContainer>"); 21885 free(s); 21886 terminateO(r); 21887 terminateO(self); 21888 21889 } 21890 21891 21892 21893 void getAtSmallArrayGT(void) { 21894 21895 baset* r; 21896 smallArrayt *self = allocG(rtSmallArrayt); 21897 21898 smallArrayt *r2 = self->f->pushInt(self, 1); 21899 ck_assert_ptr_ne(r2, null); 21900 r = getAtSmallArrayG(self, NULL, 0); 21901 ck_assert_ptr_ne(r, null); 21902 char *s = toStringO(r); 21903 finishO(r); 21904 ck_assert_str_eq(s, "1"); 21905 free(s); 21906 terminateO(self); 21907 21908 } 21909 21910 21911 void getAtUndefinedSmallArrayGT(void) { 21912 21913 undefinedt* r; 21914 smallArrayt *self = allocG(rtSmallArrayt); 21915 21916 smallArrayt *r2 = self->f->pushUndefined(self); 21917 ck_assert_ptr_ne(r2, null); 21918 r = getAtUndefinedSmallArrayG(self, null, 0); 21919 ck_assert_ptr_ne(r, null); 21920 char *s = toStringO(r); 21921 finishO(r); 21922 ck_assert_str_eq(s, "null"); 21923 free(s); 21924 terminateO(self); 21925 21926 } 21927 21928 21929 void getAtBoolSmallArrayGT(void) { 21930 21931 bool r; 21932 smallArrayt *self = allocG(rtSmallArrayt); 21933 21934 smallArrayt *r2 = self->f->pushBool(self, TRUE); 21935 ck_assert_ptr_ne(r2, null); 21936 r = getAtBoolSmallArrayG(self, null, 0); 21937 ck_assert(r); 21938 terminateO(self); 21939 21940 } 21941 21942 21943 void getAtBoolPSmallArrayGT(void) { 21944 21945 bool* r; 21946 smallArrayt *self = allocG(rtSmallArrayt); 21947 21948 smallArrayt *r2 = self->f->pushBool(self, TRUE); 21949 ck_assert_ptr_ne(r2, null); 21950 r = getAtBoolPSmallArrayG(self, null, 0); 21951 ck_assert_ptr_ne(r, null); 21952 ck_assert(*r); 21953 terminateO(self); 21954 21955 } 21956 21957 21958 void getAtDoubleSmallArrayGT(void) { 21959 21960 double r; 21961 smallArrayt *self = allocG(rtSmallArrayt); 21962 21963 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 21964 ck_assert_ptr_ne(r2, null); 21965 r = getAtDoubleSmallArrayG(self, 0, 0); 21966 ck_assert(r==2.0); 21967 terminateO(self); 21968 21969 } 21970 21971 21972 void getAtDoublePSmallArrayGT(void) { 21973 21974 double* r; 21975 smallArrayt *self = allocG(rtSmallArrayt); 21976 21977 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 21978 ck_assert_ptr_ne(r2, null); 21979 r = getAtDoublePSmallArrayG(self, 0, 0); 21980 ck_assert_ptr_ne(r, null); 21981 ck_assert(*r==2.0); 21982 terminateO(self); 21983 21984 } 21985 21986 21987 void getAtIntSmallArrayGT(void) { 21988 21989 int64_t r; 21990 smallArrayt *self = allocG(rtSmallArrayt); 21991 21992 smallArrayt *r2 = self->f->pushInt(self, 2); 21993 ck_assert_ptr_ne(r2, null); 21994 r = getAtIntSmallArrayG(self, 0, 0); 21995 ck_assert_int_eq(r, 2); 21996 terminateO(self); 21997 21998 } 21999 22000 22001 void getAtIntPSmallArrayGT(void) { 22002 22003 int64_t* r; 22004 smallArrayt *self = allocG(rtSmallArrayt); 22005 22006 smallArrayt *r2 = self->f->pushInt(self, 2); 22007 ck_assert_ptr_ne(r2, null); 22008 r = getAtIntPSmallArrayG(self, 0, 0); 22009 ck_assert_ptr_ne(r, null); 22010 ck_assert_int_eq(*r, 2); 22011 terminateO(self); 22012 22013 } 22014 22015 22016 void getAtInt32SmallArrayGT(void) { 22017 22018 int32_t r; 22019 smallArrayt *self = allocG(rtSmallArrayt); 22020 22021 smallArrayt *r2 = self->f->pushInt(self, 2); 22022 ck_assert_ptr_ne(r2, null); 22023 r = getAtInt32SmallArrayG(self, 0, 0); 22024 ck_assert_int_eq(r, 2); 22025 terminateO(self); 22026 22027 } 22028 22029 22030 void getAtInt32PSmallArrayGT(void) { 22031 22032 int32_t* r; 22033 smallArrayt *self = allocG(rtSmallArrayt); 22034 22035 smallArrayt *r2 = self->f->pushInt(self, 2); 22036 ck_assert_ptr_ne(r2, null); 22037 r = getAtInt32PSmallArrayG(self, 0, 0); 22038 ck_assert_ptr_ne(r, null); 22039 ck_assert_int_eq(*r, 2); 22040 terminateO(self); 22041 22042 } 22043 22044 22045 void getAtUintSmallArrayGT(void) { 22046 22047 uint64_t r; 22048 smallArrayt *self = allocG(rtSmallArrayt); 22049 22050 smallArrayt *r2 = self->f->pushInt(self, 2); 22051 ck_assert_ptr_ne(r2, null); 22052 r = getAtUintSmallArrayG(self, 0, 0); 22053 ck_assert_int_eq(r, 2); 22054 terminateO(self); 22055 22056 } 22057 22058 22059 void getAtUintPSmallArrayGT(void) { 22060 22061 uint64_t* r; 22062 smallArrayt *self = allocG(rtSmallArrayt); 22063 22064 smallArrayt *r2 = self->f->pushInt(self, 2); 22065 ck_assert_ptr_ne(r2, null); 22066 r = getAtUintPSmallArrayG(self, 0, 0); 22067 ck_assert_ptr_ne(r, null); 22068 ck_assert_int_eq(*r, 2); 22069 terminateO(self); 22070 22071 } 22072 22073 22074 void getAtUint32SmallArrayGT(void) { 22075 22076 uint32_t r; 22077 smallArrayt *self = allocG(rtSmallArrayt); 22078 22079 smallArrayt *r2 = self->f->pushInt(self, 2); 22080 ck_assert_ptr_ne(r2, null); 22081 r = getAtUint32SmallArrayG(self, 0, 0); 22082 ck_assert_int_eq(r, 2); 22083 terminateO(self); 22084 22085 } 22086 22087 22088 void getAtUint32PSmallArrayGT(void) { 22089 22090 uint32_t* r; 22091 smallArrayt *self = allocG(rtSmallArrayt); 22092 22093 smallArrayt *r2 = self->f->pushInt(self, 2); 22094 ck_assert_ptr_ne(r2, null); 22095 r = getAtUint32PSmallArrayG(self, 0, 0); 22096 ck_assert_ptr_ne(r, null); 22097 ck_assert_int_eq(*r, 2); 22098 terminateO(self); 22099 22100 } 22101 22102 22103 void getAtSSmallArrayGT(void) { 22104 22105 char* r; 22106 smallArrayt *self = allocG(rtSmallArrayt); 22107 22108 smallArrayt *r2 = self->f->pushS(self, "2"); 22109 ck_assert_ptr_ne(r2, null); 22110 r = getAtSSmallArrayG(self, null, 0); 22111 ck_assert_str_eq(r, "2"); 22112 terminateO(self); 22113 22114 } 22115 22116 22117 void getAtDictSmallArrayGT(void) { 22118 22119 smallDictt* r; 22120 smallArrayt *self = allocG(rtSmallArrayt); 22121 22122 createSmallDict(d); 22123 smallArrayt *r2 = self->f->pushDict(self, &d); 22124 ck_assert_ptr_ne(r2, null); 22125 r = getAtDictSmallArrayG(self, null, 0); 22126 ck_assert_ptr_ne(r, null); 22127 char *s = toStringO(r); 22128 ck_assert_str_eq(s, "{}"); 22129 free(s); 22130 finishO(r); 22131 terminateO(self); 22132 22133 } 22134 22135 22136 void getAtArraySmallArrayGT(void) { 22137 22138 smallArrayt* r; 22139 smallArrayt *self = allocG(rtSmallArrayt); 22140 22141 createSmallArray(a); 22142 smallArrayt *r2 = self->f->pushArray(self, &a); 22143 ck_assert_ptr_ne(r2, null); 22144 r = getAtArraySmallArrayG(self, null, 0); 22145 ck_assert_ptr_ne(r, null); 22146 char *s = toStringO(r); 22147 ck_assert_str_eq(s, "[]"); 22148 free(s); 22149 finishO(r); 22150 terminateO(self); 22151 22152 } 22153 22154 22155 void getAtSmallBoolSmallArrayGT(void) { 22156 22157 smallBoolt* r; 22158 smallArrayt *self = allocG(rtSmallArrayt); 22159 22160 smallArrayt *r2 = self->f->pushBool(self, true); 22161 ck_assert_ptr_ne(r2, null); 22162 r = getAtSmallBoolSmallArrayG(self, null, 0); 22163 ck_assert_ptr_ne(r, null); 22164 char *s = toStringO(r); 22165 ck_assert_str_eq(s, "true"); 22166 free(s); 22167 finishO(r); 22168 terminateO(self); 22169 22170 } 22171 22172 22173 void getAtSmallBytesSmallArrayGT(void) { 22174 22175 smallBytest* r; 22176 smallArrayt *self = allocG(rtSmallArrayt); 22177 22178 createSmallBytes(b); 22179 smallArrayt *r2 = self->f->pushSmallBytes(self, &b); 22180 ck_assert_ptr_ne(r2, null); 22181 r = getAtSmallBytesSmallArrayG(self, null, 0); 22182 ck_assert_ptr_ne(r, null); 22183 char *s = toStringO(r); 22184 ck_assert_str_eq(s, "[]"); 22185 free(s); 22186 finishO(r); 22187 terminateO(self); 22188 22189 } 22190 22191 22192 void getAtSmallDoubleSmallArrayGT(void) { 22193 22194 smallDoublet* r; 22195 smallArrayt *self = allocG(rtSmallArrayt); 22196 22197 smallArrayt *r2 = self->f->pushDouble(self, 1); 22198 ck_assert_ptr_ne(r2, null); 22199 r = getAtSmallDoubleSmallArrayG(self, null, 0); 22200 ck_assert_ptr_ne(r, null); 22201 char *s = toStringO(r); 22202 ck_assert_str_eq(s, "1.000000e+00"); 22203 free(s); 22204 finishO(r); 22205 terminateO(self); 22206 22207 } 22208 22209 22210 void getAtSmallIntSmallArrayGT(void) { 22211 22212 smallIntt* r; 22213 smallArrayt *self = allocG(rtSmallArrayt); 22214 22215 smallArrayt *r2 = self->f->pushInt(self, 1); 22216 ck_assert_ptr_ne(r2, null); 22217 r = getAtSmallIntSmallArrayG(self, null, 0); 22218 ck_assert_ptr_ne(r, null); 22219 char *s = toStringO(r); 22220 ck_assert_str_eq(s, "1"); 22221 free(s); 22222 finishO(r); 22223 terminateO(self); 22224 22225 } 22226 22227 22228 void getAtSmallJsonSmallArrayGT(void) { 22229 22230 smallJsont* r; 22231 smallArrayt *self = allocG(rtSmallArrayt); 22232 22233 createSmallJson(j); 22234 smallArrayt *r2 = self->f->pushSmallJson(self, &j); 22235 ck_assert_ptr_ne(r2, null); 22236 r = getAtSmallJsonSmallArrayG(self, null, 0); 22237 ck_assert_ptr_ne(r, null); 22238 char *s = toStringO(r); 22239 ck_assert_str_eq(s, "{}"); 22240 free(s); 22241 finishO(r); 22242 terminateO(self); 22243 22244 } 22245 22246 22247 void getAtSmallStringSmallArrayGT(void) { 22248 22249 smallStringt* r; 22250 smallArrayt *self = allocG(rtSmallArrayt); 22251 22252 createSmallString(S); 22253 smallArrayt *r2 = self->f->pushSmallString(self, &S); 22254 ck_assert_ptr_ne(r2, null); 22255 r = getAtSmallStringSmallArrayG(self, null, 0); 22256 ck_assert_ptr_ne(r, null); 22257 char *s = toStringO(r); 22258 ck_assert_str_eq(s, ""); 22259 free(s); 22260 finishO(r); 22261 terminateO(self); 22262 22263 } 22264 22265 22266 void getAtVoidSmallArrayGT(void) { 22267 22268 void* r; 22269 smallArrayt *self = allocG(rtSmallArrayt); 22270 22271 createSmallContainer(c); 22272 setValO(&c, &r); 22273 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 22274 ck_assert_ptr_ne(r2, null); 22275 r = getAtVoidSmallArrayG(self, null, 0); 22276 ck_assert_ptr_eq(r, &r); 22277 terminateO(self); 22278 22279 } 22280 22281 22282 void getAtSmallContainerSmallArrayGT(void) { 22283 22284 smallContainert* r; 22285 smallArrayt *self = allocG(rtSmallArrayt); 22286 22287 createSmallContainer(c); 22288 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 22289 ck_assert_ptr_ne(r2, null); 22290 r = getAtSmallContainerSmallArrayG(self, null, 0); 22291 ck_assert_ptr_ne(r, null); 22292 char *s = toStringO(r); 22293 ck_assert_str_eq(s, "<data smallContainer>"); 22294 free(s); 22295 finishO(r); 22296 terminateO(self); 22297 22298 } 22299 22300 22301 void getAtNDupSmallArrayGT(void) { 22302 22303 baset* r; 22304 smallArrayt *self = allocG(rtSmallArrayt); 22305 22306 smallArrayt *r2 = self->f->pushInt(self, 1); 22307 ck_assert_ptr_ne(r2, null); 22308 r = getAtNDupSmallArrayG(self, NULL, 0); 22309 ck_assert_ptr_ne(r, null); 22310 char *s = toStringO(r); 22311 terminateO(r); 22312 ck_assert_str_eq(s, "1"); 22313 free(s); 22314 terminateO(self); 22315 22316 } 22317 22318 22319 void getAtNDupUndefinedSmallArrayGT(void) { 22320 22321 undefinedt* r; 22322 smallArrayt *self = allocG(rtSmallArrayt); 22323 22324 smallArrayt *r2 = self->f->pushUndefined(self); 22325 ck_assert_ptr_ne(r2, null); 22326 r = getAtNDupUndefinedSmallArrayG(self, null, 0); 22327 ck_assert_ptr_ne(r, null); 22328 char *s = toStringO(r); 22329 terminateO(r); 22330 ck_assert_str_eq(s, "null"); 22331 free(s); 22332 terminateO(self); 22333 22334 } 22335 22336 22337 void getAtNDupBoolSmallArrayGT(void) { 22338 22339 bool r; 22340 smallArrayt *self = allocG(rtSmallArrayt); 22341 22342 smallArrayt *r2 = self->f->pushBool(self, TRUE); 22343 ck_assert_ptr_ne(r2, null); 22344 r = getAtNDupBoolSmallArrayG(self, null, 0); 22345 ck_assert(r); 22346 terminateO(self); 22347 22348 } 22349 22350 22351 void getAtNDupDoubleSmallArrayGT(void) { 22352 22353 double r; 22354 smallArrayt *self = allocG(rtSmallArrayt); 22355 22356 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 22357 ck_assert_ptr_ne(r2, null); 22358 r = getAtNDupDoubleSmallArrayG(self, 0, 0); 22359 ck_assert(r==2.0); 22360 terminateO(self); 22361 22362 } 22363 22364 22365 void getAtNDupIntSmallArrayGT(void) { 22366 22367 int64_t r; 22368 smallArrayt *self = allocG(rtSmallArrayt); 22369 22370 smallArrayt *r2 = self->f->pushInt(self, 2); 22371 ck_assert_ptr_ne(r2, null); 22372 r = getAtNDupIntSmallArrayG(self, 0, 0); 22373 ck_assert_int_eq(r, 2); 22374 terminateO(self); 22375 22376 } 22377 22378 22379 void getAtNDupInt32SmallArrayGT(void) { 22380 22381 int32_t r; 22382 smallArrayt *self = allocG(rtSmallArrayt); 22383 22384 smallArrayt *r2 = self->f->pushInt(self, 2); 22385 ck_assert_ptr_ne(r2, null); 22386 r = getAtNDupInt32SmallArrayG(self, 0, 0); 22387 ck_assert_int_eq(r, 2); 22388 terminateO(self); 22389 22390 } 22391 22392 22393 void getAtNDupUintSmallArrayGT(void) { 22394 22395 uint64_t r; 22396 smallArrayt *self = allocG(rtSmallArrayt); 22397 22398 smallArrayt *r2 = self->f->pushInt(self, 2); 22399 ck_assert_ptr_ne(r2, null); 22400 r = getAtNDupUintSmallArrayG(self, 0, 0); 22401 ck_assert_int_eq(r, 2); 22402 terminateO(self); 22403 22404 } 22405 22406 22407 void getAtNDupUint32SmallArrayGT(void) { 22408 22409 uint32_t r; 22410 smallArrayt *self = allocG(rtSmallArrayt); 22411 22412 smallArrayt *r2 = self->f->pushInt(self, 2); 22413 ck_assert_ptr_ne(r2, null); 22414 r = getAtNDupUint32SmallArrayG(self, 0, 0); 22415 ck_assert_int_eq(r, 2); 22416 terminateO(self); 22417 22418 } 22419 22420 22421 void getAtNDupSSmallArrayGT(void) { 22422 22423 char* r; 22424 smallArrayt *self = allocG(rtSmallArrayt); 22425 22426 smallArrayt *r2 = self->f->pushS(self, "2"); 22427 ck_assert_ptr_ne(r2, null); 22428 r = getAtNDupSSmallArrayG(self, null, 0); 22429 ck_assert_str_eq(r, "2"); 22430 free(r); 22431 terminateO(self); 22432 22433 } 22434 22435 22436 void getAtNDupDictSmallArrayGT(void) { 22437 22438 smallDictt* r; 22439 smallArrayt *self = allocG(rtSmallArrayt); 22440 22441 createSmallDict(d); 22442 smallArrayt *r2 = self->f->pushDict(self, &d); 22443 ck_assert_ptr_ne(r2, null); 22444 r = getAtNDupDictSmallArrayG(self, null, 0); 22445 ck_assert_ptr_ne(r, null); 22446 char *s = toStringO(r); 22447 ck_assert_str_eq(s, "{}"); 22448 free(s); 22449 terminateO(r); 22450 terminateO(self); 22451 22452 } 22453 22454 22455 void getAtNDupArraySmallArrayGT(void) { 22456 22457 smallArrayt* r; 22458 smallArrayt *self = allocG(rtSmallArrayt); 22459 22460 createSmallArray(a); 22461 smallArrayt *r2 = self->f->pushArray(self, &a); 22462 ck_assert_ptr_ne(r2, null); 22463 r = getAtNDupArraySmallArrayG(self, null, 0); 22464 ck_assert_ptr_ne(r, null); 22465 char *s = toStringO(r); 22466 ck_assert_str_eq(s, "[]"); 22467 free(s); 22468 terminateO(r); 22469 terminateO(self); 22470 22471 } 22472 22473 22474 void getAtNDupSmallBoolSmallArrayGT(void) { 22475 22476 smallBoolt* r; 22477 smallArrayt *self = allocG(rtSmallArrayt); 22478 22479 smallArrayt *r2 = self->f->pushBool(self, true); 22480 ck_assert_ptr_ne(r2, null); 22481 r = getAtNDupSmallBoolSmallArrayG(self, null, 0); 22482 ck_assert_ptr_ne(r, null); 22483 char *s = toStringO(r); 22484 ck_assert_str_eq(s, "true"); 22485 free(s); 22486 terminateO(r); 22487 terminateO(self); 22488 22489 } 22490 22491 22492 void getAtNDupSmallBytesSmallArrayGT(void) { 22493 22494 smallBytest* r; 22495 smallArrayt *self = allocG(rtSmallArrayt); 22496 22497 createSmallBytes(b); 22498 smallArrayt *r2 = self->f->pushSmallBytes(self, &b); 22499 ck_assert_ptr_ne(r2, null); 22500 r = getAtNDupSmallBytesSmallArrayG(self, null, 0); 22501 ck_assert_ptr_ne(r, null); 22502 char *s = toStringO(r); 22503 ck_assert_str_eq(s, "[]"); 22504 free(s); 22505 terminateO(r); 22506 terminateO(self); 22507 22508 } 22509 22510 22511 void getAtNDupSmallDoubleSmallArrayGT(void) { 22512 22513 smallDoublet* r; 22514 smallArrayt *self = allocG(rtSmallArrayt); 22515 22516 smallArrayt *r2 = self->f->pushDouble(self, 1); 22517 ck_assert_ptr_ne(r2, null); 22518 r = getAtNDupSmallDoubleSmallArrayG(self, null, 0); 22519 ck_assert_ptr_ne(r, null); 22520 char *s = toStringO(r); 22521 ck_assert_str_eq(s, "1.000000e+00"); 22522 free(s); 22523 terminateO(r); 22524 terminateO(self); 22525 22526 } 22527 22528 22529 void getAtNDupSmallIntSmallArrayGT(void) { 22530 22531 smallIntt* r; 22532 smallArrayt *self = allocG(rtSmallArrayt); 22533 22534 smallArrayt *r2 = self->f->pushInt(self, 1); 22535 ck_assert_ptr_ne(r2, null); 22536 r = getAtNDupSmallIntSmallArrayG(self, null, 0); 22537 ck_assert_ptr_ne(r, null); 22538 char *s = toStringO(r); 22539 ck_assert_str_eq(s, "1"); 22540 free(s); 22541 terminateO(r); 22542 terminateO(self); 22543 22544 } 22545 22546 22547 void getAtNDupSmallJsonSmallArrayGT(void) { 22548 22549 smallJsont* r; 22550 smallArrayt *self = allocG(rtSmallArrayt); 22551 22552 createSmallJson(j); 22553 smallArrayt *r2 = self->f->pushSmallJson(self, &j); 22554 ck_assert_ptr_ne(r2, null); 22555 r = getAtNDupSmallJsonSmallArrayG(self, null, 0); 22556 ck_assert_ptr_ne(r, null); 22557 char *s = toStringO(r); 22558 ck_assert_str_eq(s, "{}"); 22559 free(s); 22560 terminateO(r); 22561 terminateO(self); 22562 22563 } 22564 22565 22566 void getAtNDupSmallStringSmallArrayGT(void) { 22567 22568 smallStringt* r; 22569 smallArrayt *self = allocG(rtSmallArrayt); 22570 22571 createSmallString(S); 22572 smallArrayt *r2 = self->f->pushSmallString(self, &S); 22573 ck_assert_ptr_ne(r2, null); 22574 r = getAtNDupSmallStringSmallArrayG(self, null, 0); 22575 ck_assert_ptr_ne(r, null); 22576 char *s = toStringO(r); 22577 ck_assert_str_eq(s, ""); 22578 free(s); 22579 terminateO(r); 22580 terminateO(self); 22581 22582 } 22583 22584 22585 void getAtNDupVoidSmallArrayGT(void) { 22586 22587 void* r; 22588 smallArrayt *self = allocG(rtSmallArrayt); 22589 22590 createSmallContainer(c); 22591 setValO(&c, &r); 22592 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 22593 ck_assert_ptr_ne(r2, null); 22594 r = getAtNDupVoidSmallArrayG(self, null, 0); 22595 ck_assert_ptr_eq(r, NULL); 22596 terminateO(self); 22597 22598 } 22599 22600 22601 void getAtNDupSmallContainerSmallArrayGT(void) { 22602 22603 smallContainert* r; 22604 smallArrayt *self = allocG(rtSmallArrayt); 22605 22606 createSmallContainer(c); 22607 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 22608 ck_assert_ptr_ne(r2, null); 22609 r = getAtNDupSmallContainerSmallArrayG(self, null, 0); 22610 ck_assert_ptr_ne(r, null); 22611 char *s = toStringO(r); 22612 ck_assert_str_eq(s, "<data smallContainer>"); 22613 free(s); 22614 terminateO(r); 22615 terminateO(self); 22616 22617 } 22618 22619 22620 void setAtSmallArrayGT(void) { 22621 22622 smallArrayt* r; 22623 smallArrayt *self = allocG(rtSmallArrayt); 22624 baset *value = (baset*) allocSmallInt(1); 22625 22626 r = pushSmallArrayG(self, value); 22627 ck_assert_ptr_ne(r, null); 22628 finishO(value); 22629 value = (baset*) allocSmallInt(2); 22630 r = setAtSmallArrayG(self, 0, value); 22631 ck_assert_ptr_ne(r, null); 22632 finishO(value); 22633 char *s = toStringO(r); 22634 ck_assert_str_eq(s, "[2]"); 22635 free(s); 22636 terminateO(self); 22637 22638 } 22639 22640 22641 void setAtUndefinedSmallArrayGT(void) { 22642 22643 smallArrayt* r; 22644 smallArrayt *self = allocG(rtSmallArrayt); 22645 baset *value = (baset*) allocSmallInt(1); 22646 22647 r = pushSmallArrayG(self, value); 22648 ck_assert_ptr_ne(r, null); 22649 finishO(value); 22650 r = setAtUndefinedSmallArrayG(self, 0, null); 22651 ck_assert_ptr_ne(r, null); 22652 char *s = toStringO(r); 22653 ck_assert_str_eq(s, "[null]"); 22654 free(s); 22655 terminateO(self); 22656 22657 } 22658 22659 22660 void setAtBoolSmallArrayGT(void) { 22661 22662 smallArrayt* r; 22663 smallArrayt *self = allocG(rtSmallArrayt); 22664 22665 r = pushBoolSmallArrayG(self, true); 22666 ck_assert_ptr_ne(r, null); 22667 r = setAtBoolSmallArrayG(self, 0, false); 22668 ck_assert_ptr_ne(r, null); 22669 char *s = toStringO(r); 22670 ck_assert_str_eq(s, "[false]"); 22671 free(s); 22672 terminateO(self); 22673 22674 } 22675 22676 22677 void setAtDoubleSmallArrayGT(void) { 22678 22679 smallArrayt* r; 22680 smallArrayt *self = allocG(rtSmallArrayt); 22681 22682 r = pushDoubleSmallArrayG(self, 1); 22683 ck_assert_ptr_ne(r, null); 22684 r = setAtDoubleSmallArrayG(self, 0, 2); 22685 ck_assert_ptr_ne(r, null); 22686 char *s = toStringO(r); 22687 ck_assert_str_eq(s, "[2.000000e+00]"); 22688 free(s); 22689 terminateO(self); 22690 22691 } 22692 22693 22694 void setAtIntSmallArrayGT(void) { 22695 22696 smallArrayt* r; 22697 smallArrayt *self = allocG(rtSmallArrayt); 22698 22699 r = pushIntSmallArrayG(self, 1); 22700 ck_assert_ptr_ne(r, null); 22701 r = setAtIntSmallArrayG(self, 0, 2); 22702 ck_assert_ptr_ne(r, null); 22703 char *s = toStringO(r); 22704 ck_assert_str_eq(s, "[2]"); 22705 free(s); 22706 terminateO(self); 22707 22708 } 22709 22710 22711 void setAtSSmallArrayGT(void) { 22712 22713 smallArrayt* r; 22714 smallArrayt *self = allocG(rtSmallArrayt); 22715 22716 r = pushSSmallArrayG(self, "qwe"); 22717 ck_assert_ptr_ne(r, null); 22718 r = setAtSSmallArrayG(self, 0, "asd"); 22719 ck_assert_ptr_ne(r, null); 22720 char *s = toStringO(r); 22721 ck_assert_str_eq(s, "[\"asd\"]"); 22722 free(s); 22723 terminateO(self); 22724 22725 } 22726 22727 22728 void setAtCharSmallArrayGT(void) { 22729 22730 smallArrayt* r; 22731 smallArrayt *self = allocG(rtSmallArrayt); 22732 22733 r = pushCharSmallArrayG(self, 'Q'); 22734 ck_assert_ptr_ne(r, null); 22735 r = setAtCharSmallArrayG(self, 0, 'x'); 22736 ck_assert_ptr_ne(r, null); 22737 char *s = toStringO(r); 22738 ck_assert_str_eq(s, "[\"x\"]"); 22739 free(s); 22740 terminateO(self); 22741 22742 } 22743 22744 22745 void setAtDictSmallArrayGT(void) { 22746 22747 smallArrayt* r; 22748 smallArrayt *self = allocG(rtSmallArrayt); 22749 smallDictt *dict = allocSmallDict(); 22750 22751 r = pushDictSmallArrayG(self, dict); 22752 ck_assert_ptr_ne(r, null); 22753 resetO(dict); 22754 dict->f->setInt(dict, "a", 1); 22755 r = setAtDictSmallArrayG(self, 0, dict); 22756 ck_assert_ptr_ne(r, null); 22757 finishO(dict); 22758 char *s = toStringO(r); 22759 ck_assert_str_eq(s, "[{\"a\":1}]"); 22760 free(s); 22761 terminateO(self); 22762 22763 } 22764 22765 22766 void setAtArraySmallArrayGT(void) { 22767 22768 smallArrayt* r; 22769 smallArrayt *self = allocG(rtSmallArrayt); 22770 smallArrayt *array = allocSmallArray(); 22771 22772 r = pushArraySmallArrayG(self, array); 22773 ck_assert_ptr_ne(r, null); 22774 resetO(array); 22775 array->f->pushInt(array, 1); 22776 r = setAtArraySmallArrayG(self, 0, array); 22777 ck_assert_ptr_ne(r, null); 22778 finishO(array); 22779 char *s = toStringO(r); 22780 ck_assert_str_eq(s, "[[1]]"); 22781 free(s); 22782 terminateO(self); 22783 22784 } 22785 22786 22787 void setAtArraycSmallArrayGT(void) { 22788 22789 smallArrayt* r; 22790 smallArrayt *self = allocG(rtSmallArrayt); 22791 char **array = listCreateS("a","bb"); 22792 22793 r = pushArraycSmallArrayG(self, array); 22794 ck_assert_ptr_ne(r, null); 22795 listFreeS(array); 22796 array = listCreateS("1","22"); 22797 r = setAtArraycSmallArrayG(self, 0, array); 22798 ck_assert_ptr_ne(r, null); 22799 ck_assert_int_eq(lenO(r), 1); 22800 listFreeS(array); 22801 char *s = toStringO(r); 22802 ck_assert_str_eq(s, "[[\"1\",\"22\"]]"); 22803 free(s); 22804 terminateO(self); 22805 22806 } 22807 22808 22809 void setAtCArraycSmallArrayGT(void) { 22810 22811 smallArrayt* r; 22812 smallArrayt *self = allocG(rtSmallArrayt); 22813 const char *array[] = {"a", "bb", NULL}; 22814 22815 r = pushCArraycSmallArrayG(self, array); 22816 ck_assert_ptr_ne(r, null); 22817 const char *array2[] = {"1", "22", NULL}; 22818 r = setAtCArraycSmallArrayG(self, 0, array2); 22819 ck_assert_ptr_ne(r, null); 22820 ck_assert_int_eq(lenO(r), 1); 22821 char *s = toStringO(r); 22822 ck_assert_str_eq(s, "[[\"1\",\"22\"]]"); 22823 free(s); 22824 terminateO(self); 22825 22826 } 22827 22828 22829 void setAtVoidSmallArrayGT(void) { 22830 22831 smallArrayt* r; 22832 smallArrayt *self = allocG(rtSmallArrayt); 22833 22834 // NULL value 22835 r = pushVoidSmallArrayG(self, NULL); 22836 ck_assert_ptr_ne(r, null); 22837 r = setAtVoidSmallArrayG(self, 0, null); 22838 ck_assert_ptr_ne(r, null); 22839 r = setAtVoidSmallArrayG(self, 0, r); 22840 ck_assert_ptr_ne(r, null); 22841 char *s = toStringO(r); 22842 ck_assert_str_eq(s, "[\"<data container>\"]"); 22843 free(s); 22844 terminateO(self); 22845 22846 } 22847 22848 22849 void setAtSmallBoolSmallArrayGT(void) { 22850 22851 smallArrayt* r; 22852 smallArrayt *self = allocG(rtSmallArrayt); 22853 smallBoolt *value = allocSmallBool(true); 22854 22855 r = pushBoolSmallArrayG(self, false); 22856 ck_assert_ptr_ne(r, null); 22857 r = setAtSmallBoolSmallArrayG(self, 0, value); 22858 ck_assert_ptr_ne(r, null); 22859 finishO(value); 22860 char *s = toStringO(r); 22861 ck_assert_str_eq(s, "[true]"); 22862 free(s); 22863 terminateO(self); 22864 22865 } 22866 22867 22868 void setAtSmallBytesSmallArrayGT(void) { 22869 22870 smallArrayt* r; 22871 smallArrayt *self = allocG(rtSmallArrayt); 22872 smallBytest *value = allocSmallBytes("qwe", 3); 22873 22874 r = pushSmallBytesSmallArrayG(self, value); 22875 ck_assert_ptr_ne(r, null); 22876 finishO(value); 22877 value = allocSmallBytes("asd", 3); 22878 r = setAtSmallBytesSmallArrayG(self, 0, value); 22879 ck_assert_ptr_ne(r, null); 22880 finishO(value); 22881 char *s = toStringO(r); 22882 ck_assert_str_eq(s, "[[0x61,0x73,0x64]]"); 22883 free(s); 22884 terminateO(self); 22885 22886 } 22887 22888 22889 void setAtSmallDoubleSmallArrayGT(void) { 22890 22891 smallArrayt* r; 22892 smallArrayt *self = allocG(rtSmallArrayt); 22893 smallDoublet *value = allocSmallDouble(1); 22894 22895 r = pushDoubleSmallArrayG(self, 2); 22896 ck_assert_ptr_ne(r, null); 22897 r = setAtSmallDoubleSmallArrayG(self, 0, value); 22898 ck_assert_ptr_ne(r, null); 22899 finishO(value); 22900 char *s = toStringO(r); 22901 ck_assert_str_eq(s, "[1.000000e+00]"); 22902 free(s); 22903 22904 terminateO(self); 22905 22906 } 22907 22908 22909 void setAtSmallIntSmallArrayGT(void) { 22910 22911 smallArrayt* r; 22912 smallArrayt *self = allocG(rtSmallArrayt); 22913 smallIntt *value = allocSmallInt(1); 22914 22915 r = pushIntSmallArrayG(self, 2); 22916 ck_assert_ptr_ne(r, null); 22917 r = setAtSmallIntSmallArrayG(self, 0, value); 22918 ck_assert_ptr_ne(r, null); 22919 finishO(value); 22920 char *s = toStringO(r); 22921 ck_assert_str_eq(s, "[1]"); 22922 free(s); 22923 terminateO(self); 22924 22925 } 22926 22927 22928 void setAtSmallJsonSmallArrayGT(void) { 22929 22930 smallArrayt* r; 22931 smallArrayt *self = allocG(rtSmallArrayt); 22932 smallJsont *value = allocSmallJson(); 22933 22934 r = pushSmallJsonSmallArrayG(self, value); 22935 ck_assert_ptr_ne(r, null); 22936 finishO(value); 22937 value = allocSmallJson(); 22938 value->f->setInt(value, "a", 1); 22939 r = setAtSmallJsonSmallArrayG(self, 0, value); 22940 ck_assert_ptr_ne(r, null); 22941 finishO(value); 22942 char *s = toStringO(r); 22943 ck_assert_str_eq(s, "[{\"a\":1}]"); 22944 free(s); 22945 terminateO(self); 22946 22947 } 22948 22949 22950 void setAtSmallStringSmallArrayGT(void) { 22951 22952 smallArrayt* r; 22953 smallArrayt *self = allocG(rtSmallArrayt); 22954 smallStringt *string = allocSmallString("qwe"); 22955 22956 r = pushSSmallArrayG(self, "asd"); 22957 ck_assert_ptr_ne(r, null); 22958 r = setAtSmallStringSmallArrayG(self, 0, string); 22959 ck_assert_ptr_ne(r, null); 22960 finishO(string); 22961 char *s = toStringO(r); 22962 ck_assert_str_eq(s, "[\"qwe\"]"); 22963 free(s); 22964 terminateO(self); 22965 22966 } 22967 22968 22969 void setAtSmallContainerSmallArrayGT(void) { 22970 22971 smallArrayt* r; 22972 smallArrayt *self = allocG(rtSmallArrayt); 22973 22974 createSmallContainer(c); 22975 r = pushSmallContainerSmallArrayG(self, &c); 22976 ck_assert_ptr_ne(r, null); 22977 createSmallContainer(c2); 22978 r = setAtSmallContainerSmallArrayG(self, 0, &c2); 22979 ck_assert_ptr_ne(r, null); 22980 char *s = toStringO(r); 22981 ck_assert_str_eq(s, "[\"<data container>\"]"); 22982 free(s); 22983 terminateO(self); 22984 22985 } 22986 22987 22988 void setAtNFreeSmallArrayGT(void) { 22989 22990 smallArrayt* r; 22991 smallArrayt *self = allocG(rtSmallArrayt); 22992 baset *value = (baset*) allocSmallInt(1); 22993 22994 r = pushSmallArrayG(self, value); 22995 ck_assert_ptr_ne(r, null); 22996 finishO(value); 22997 value = (baset*) allocSmallInt(2); 22998 r = setAtNFreeSmallArrayG(self, 0, value); 22999 ck_assert_ptr_ne(r, null); 23000 char *s = toStringO(r); 23001 ck_assert_str_eq(s, "[2]"); 23002 free(s); 23003 terminateO(self); 23004 23005 } 23006 23007 23008 void setAtNFreeUndefinedSmallArrayGT(void) { 23009 23010 smallArrayt* r; 23011 smallArrayt *self = allocG(rtSmallArrayt); 23012 baset *value = (baset*) allocSmallInt(1); 23013 23014 r = pushSmallArrayG(self, value); 23015 ck_assert_ptr_ne(r, null); 23016 finishO(value); 23017 r = setAtNFreeUndefinedSmallArrayG(self, 0, null); 23018 ck_assert_ptr_ne(r, null); 23019 char *s = toStringO(r); 23020 ck_assert_str_eq(s, "[null]"); 23021 free(s); 23022 terminateO(self); 23023 23024 } 23025 23026 23027 void setAtNFreeSSmallArrayGT(void) { 23028 23029 smallArrayt* r; 23030 smallArrayt *self = allocG(rtSmallArrayt); 23031 23032 r = pushSSmallArrayG(self, "qwe"); 23033 ck_assert_ptr_ne(r, null); 23034 r = setAtNFreeSSmallArrayG(self, 0, strdup("asd")); 23035 ck_assert_ptr_ne(r, null); 23036 char *s = toStringO(r); 23037 ck_assert_str_eq(s, "[\"asd\"]"); 23038 free(s); 23039 terminateO(self); 23040 23041 } 23042 23043 23044 void setAtNFreeDictSmallArrayGT(void) { 23045 23046 smallArrayt* r; 23047 smallArrayt *self = allocG(rtSmallArrayt); 23048 smallDictt *dict = allocSmallDict(); 23049 23050 r = pushDictSmallArrayG(self, dict); 23051 ck_assert_ptr_ne(r, null); 23052 resetO(dict); 23053 dict->f->setInt(dict, "a", 1); 23054 r = setAtNFreeDictSmallArrayG(self, 0, dict); 23055 ck_assert_ptr_ne(r, null); 23056 char *s = toStringO(r); 23057 ck_assert_str_eq(s, "[{\"a\":1}]"); 23058 free(s); 23059 terminateO(self); 23060 23061 } 23062 23063 23064 void setAtNFreeArraySmallArrayGT(void) { 23065 23066 smallArrayt* r; 23067 smallArrayt *self = allocG(rtSmallArrayt); 23068 smallArrayt *array = allocSmallArray(); 23069 23070 r = pushArraySmallArrayG(self, array); 23071 ck_assert_ptr_ne(r, null); 23072 resetO(array); 23073 array->f->pushInt(array, 1); 23074 r = setAtNFreeArraySmallArrayG(self, 0, array); 23075 ck_assert_ptr_ne(r, null); 23076 char *s = toStringO(r); 23077 ck_assert_str_eq(s, "[[1]]"); 23078 free(s); 23079 terminateO(self); 23080 23081 } 23082 23083 23084 void setAtNFreeArraycSmallArrayGT(void) { 23085 23086 smallArrayt* r; 23087 smallArrayt *self = allocG(rtSmallArrayt); 23088 char **array = listCreateS("a","bb"); 23089 23090 r = pushArraycSmallArrayG(self, array); 23091 ck_assert_ptr_ne(r, null); 23092 listFreeS(array); 23093 array = listCreateS("1","22"); 23094 r = setAtNFreeArraycSmallArrayG(self, 0, array); 23095 ck_assert_ptr_ne(r, null); 23096 ck_assert_int_eq(lenO(r), 1); 23097 char *s = toStringO(r); 23098 ck_assert_str_eq(s, "[[\"1\",\"22\"]]"); 23099 free(s); 23100 terminateO(self); 23101 23102 } 23103 23104 23105 void setAtNFreeSmallBoolSmallArrayGT(void) { 23106 23107 smallArrayt* r; 23108 smallArrayt *self = allocG(rtSmallArrayt); 23109 smallBoolt *value = allocSmallBool(true); 23110 23111 r = pushBoolSmallArrayG(self, false); 23112 ck_assert_ptr_ne(r, null); 23113 r = setAtNFreeSmallBoolSmallArrayG(self, 0, value); 23114 ck_assert_ptr_ne(r, null); 23115 char *s = toStringO(r); 23116 ck_assert_str_eq(s, "[true]"); 23117 free(s); 23118 terminateO(self); 23119 23120 } 23121 23122 23123 void setAtNFreeSmallBytesSmallArrayGT(void) { 23124 23125 smallArrayt* r; 23126 smallArrayt *self = allocG(rtSmallArrayt); 23127 smallBytest *value = allocSmallBytes("qwe", 3); 23128 23129 r = pushSmallBytesSmallArrayG(self, value); 23130 ck_assert_ptr_ne(r, null); 23131 finishO(value); 23132 value = allocSmallBytes("asd", 3); 23133 r = setAtNFreeSmallBytesSmallArrayG(self, 0, value); 23134 ck_assert_ptr_ne(r, null); 23135 char *s = toStringO(r); 23136 ck_assert_str_eq(s, "[[0x61,0x73,0x64]]"); 23137 free(s); 23138 terminateO(self); 23139 23140 } 23141 23142 23143 void setAtNFreeSmallDoubleSmallArrayGT(void) { 23144 23145 smallArrayt* r; 23146 smallArrayt *self = allocG(rtSmallArrayt); 23147 smallDoublet *value = allocSmallDouble(1); 23148 23149 r = pushDoubleSmallArrayG(self, 2); 23150 ck_assert_ptr_ne(r, null); 23151 r = setAtNFreeSmallDoubleSmallArrayG(self, 0, value); 23152 ck_assert_ptr_ne(r, null); 23153 char *s = toStringO(r); 23154 ck_assert_str_eq(s, "[1.000000e+00]"); 23155 free(s); 23156 terminateO(self); 23157 23158 } 23159 23160 23161 void setAtNFreeSmallIntSmallArrayGT(void) { 23162 23163 smallArrayt* r; 23164 smallArrayt *self = allocG(rtSmallArrayt); 23165 smallIntt *value = allocSmallInt(1); 23166 23167 r = pushIntSmallArrayG(self, 2); 23168 ck_assert_ptr_ne(r, null); 23169 r = setAtNFreeSmallIntSmallArrayG(self, 0, value); 23170 ck_assert_ptr_ne(r, null); 23171 char *s = toStringO(r); 23172 ck_assert_str_eq(s, "[1]"); 23173 free(s); 23174 terminateO(self); 23175 23176 } 23177 23178 23179 void setAtNFreeSmallJsonSmallArrayGT(void) { 23180 23181 smallArrayt* r; 23182 smallArrayt *self = allocG(rtSmallArrayt); 23183 smallJsont *value = allocSmallJson(); 23184 23185 r = pushSmallJsonSmallArrayG(self, value); 23186 ck_assert_ptr_ne(r, null); 23187 finishO(value); 23188 value = allocSmallJson(); 23189 value->f->setInt(value, "a", 1); 23190 r = setAtNFreeSmallJsonSmallArrayG(self, 0, value); 23191 ck_assert_ptr_ne(r, null); 23192 char *s = toStringO(r); 23193 ck_assert_str_eq(s, "[{\"a\":1}]"); 23194 free(s); 23195 terminateO(self); 23196 23197 } 23198 23199 23200 void setAtNFreeSmallStringSmallArrayGT(void) { 23201 23202 smallArrayt* r; 23203 smallArrayt *self = allocG(rtSmallArrayt); 23204 smallStringt *string = allocSmallString("qwe"); 23205 23206 r = pushSSmallArrayG(self, "asd"); 23207 ck_assert_ptr_ne(r, null); 23208 r = setAtNFreeSmallStringSmallArrayG(self, 0, string); 23209 ck_assert_ptr_ne(r, null); 23210 char *s = toStringO(r); 23211 ck_assert_str_eq(s, "[\"qwe\"]"); 23212 free(s); 23213 terminateO(self); 23214 23215 } 23216 23217 23218 void setAtNFreeSmallContainerSmallArrayGT(void) { 23219 23220 smallArrayt* r; 23221 smallArrayt *self = allocG(rtSmallArrayt); 23222 23223 createSmallContainer(c); 23224 r = pushSmallContainerSmallArrayG(self, &c); 23225 ck_assert_ptr_ne(r, null); 23226 createAllocateSmallContainer(c2); 23227 r = setAtNFreeSmallContainerSmallArrayG(self, 0, c2); 23228 ck_assert_ptr_ne(r, null); 23229 char *s = toStringO(r); 23230 ck_assert_str_eq(s, "[\"<data container>\"]"); 23231 free(s); 23232 terminateO(self); 23233 23234 } 23235 23236 23237 void setPAtDictSmallArrayGT(void) { 23238 23239 smallArrayt* r; 23240 smallArrayt *self = allocG(rtSmallArrayt); 23241 smallDictt *dict = allocSmallDict(); 23242 23243 r = pushDictSmallArrayG(self, dict); 23244 ck_assert_ptr_ne(r, null); 23245 finishO(dict); 23246 dict = getAtDictSmallArrayG(self, null, 0); 23247 ck_assert_ptr_ne(dict, null); 23248 dict->f->setInt(dict, "a", 1); 23249 r = setPAtDictSmallArrayG(self, 0, dict); 23250 ck_assert_ptr_ne(r, null); 23251 finishO(dict); 23252 char *s = toStringO(r); 23253 ck_assert_str_eq(s, "[{\"a\":1}]"); 23254 free(s); 23255 terminateO(self); 23256 23257 } 23258 23259 23260 void setPAtArraySmallArrayGT(void) { 23261 23262 smallArrayt* r; 23263 smallArrayt *self = allocG(rtSmallArrayt); 23264 smallArrayt *array = allocSmallArray(); 23265 23266 r = pushArraySmallArrayG(self, array); 23267 ck_assert_ptr_ne(r, null); 23268 finishO(array); 23269 array = getAtArraySmallArrayG(self, null, 0); 23270 ck_assert_ptr_ne(array, null); 23271 array->f->pushInt(array, 1); 23272 r = setPAtArraySmallArrayG(self, 0, array); 23273 ck_assert_ptr_ne(r, null); 23274 finishO(array); 23275 char *s = toStringO(r); 23276 ck_assert_str_eq(s, "[[1]]"); 23277 free(s); 23278 terminateO(self); 23279 23280 } 23281 23282 23283 void setPAtSmallJsonSmallArrayGT(void) { 23284 23285 smallArrayt* r; 23286 smallArrayt *self = allocG(rtSmallArrayt); 23287 smallJsont *value = allocSmallJson(); 23288 23289 r = pushSmallJsonSmallArrayG(self, value); 23290 ck_assert_ptr_ne(r, null); 23291 finishO(value); 23292 value = getAtSmallJsonSmallArrayG(self, null, 0); 23293 value->f->setInt(value, "a", 1); 23294 r = setPAtSmallJsonSmallArrayG(self, 0, value); 23295 ck_assert_ptr_ne(r, null); 23296 finishO(value); 23297 char *s = toStringO(r); 23298 ck_assert_str_eq(s, "[{\"a\":1}]"); 23299 free(s); 23300 terminateO(self); 23301 23302 } 23303 23304 23305 void setPAtSmallStringSmallArrayGT(void) { 23306 23307 smallArrayt* r; 23308 smallArrayt *self = allocG(rtSmallArrayt); 23309 smallStringt *string; 23310 23311 r = pushSSmallArrayG(self, "asd"); 23312 ck_assert_ptr_ne(r, null); 23313 string = getAtSmallStringSmallArrayG(self, null, 0); 23314 setValO(string, "qwe"); 23315 r = setPAtSmallStringSmallArrayG(self, 0, string); 23316 ck_assert_ptr_ne(r, null); 23317 finishO(string); 23318 char *s = toStringO(r); 23319 ck_assert_str_eq(s, "[\"qwe\"]"); 23320 free(s); 23321 terminateO(self); 23322 23323 } 23324 23325 23326 void setPAtNFreeDictSmallArrayGT(void) { 23327 23328 smallArrayt* r; 23329 smallArrayt *self = allocG(rtSmallArrayt); 23330 smallDictt *dict = allocSmallDict(); 23331 23332 r = pushDictSmallArrayG(self, dict); 23333 ck_assert_ptr_ne(r, null); 23334 finishO(dict); 23335 dict = getAtDictSmallArrayG(self, null, 0); 23336 ck_assert_ptr_ne(dict, null); 23337 dict->f->setInt(dict, "a", 1); 23338 r = setPAtNFreeDictSmallArrayG(self, 0, dict); 23339 ck_assert_ptr_ne(r, null); 23340 char *s = toStringO(r); 23341 ck_assert_str_eq(s, "[{\"a\":1}]"); 23342 free(s); 23343 terminateO(self); 23344 23345 } 23346 23347 23348 void setPAtNFreeArraySmallArrayGT(void) { 23349 23350 smallArrayt* r; 23351 smallArrayt *self = allocG(rtSmallArrayt); 23352 smallArrayt *array = allocSmallArray(); 23353 23354 r = pushArraySmallArrayG(self, array); 23355 ck_assert_ptr_ne(r, null); 23356 finishO(array); 23357 array = getAtArraySmallArrayG(self, null, 0); 23358 ck_assert_ptr_ne(array, null); 23359 array->f->pushInt(array, 1); 23360 r = setPAtNFreeArraySmallArrayG(self, 0, array); 23361 ck_assert_ptr_ne(r, null); 23362 char *s = toStringO(r); 23363 ck_assert_str_eq(s, "[[1]]"); 23364 free(s); 23365 terminateO(self); 23366 23367 } 23368 23369 23370 void setPAtNFreeSmallJsonSmallArrayGT(void) { 23371 23372 smallArrayt* r; 23373 smallArrayt *self = allocG(rtSmallArrayt); 23374 smallJsont *value = allocSmallJson(); 23375 23376 r = pushSmallJsonSmallArrayG(self, value); 23377 ck_assert_ptr_ne(r, null); 23378 finishO(value); 23379 value = getAtSmallJsonSmallArrayG(self, null, 0); 23380 value->f->setInt(value, "a", 1); 23381 r = setPAtNFreeSmallJsonSmallArrayG(self, 0, value); 23382 ck_assert_ptr_ne(r, null); 23383 char *s = toStringO(r); 23384 ck_assert_str_eq(s, "[{\"a\":1}]"); 23385 free(s); 23386 terminateO(self); 23387 23388 } 23389 23390 23391 void setPAtNFreeSmallStringSmallArrayGT(void) { 23392 23393 smallArrayt* r; 23394 smallArrayt *self = allocG(rtSmallArrayt); 23395 smallStringt *string; 23396 23397 r = pushSSmallArrayG(self, "asd"); 23398 ck_assert_ptr_ne(r, null); 23399 string = getAtSmallStringSmallArrayG(self, null, 0); 23400 setValO(string, "qwe"); 23401 r = setPAtNFreeSmallStringSmallArrayG(self, 0, string); 23402 ck_assert_ptr_ne(r, null); 23403 char *s = toStringO(r); 23404 ck_assert_str_eq(s, "[\"qwe\"]"); 23405 free(s); 23406 terminateO(self); 23407 23408 } 23409 23410 23411 void getNumSmallArrayGT(void) { 23412 23413 double r; 23414 smallArrayt *self = allocG(rtSmallArrayt); 23415 smallArrayt *r2; 23416 23417 r2 = self->f->pushDouble(self, 1); 23418 ck_assert_ptr_ne(r2, NULL); 23419 r = getNumSmallArrayG(self, 0); 23420 ck_assert(r==1); 23421 terminateO(self); 23422 23423 } 23424 23425 23426 void reverseSmallArrayGT(void) { 23427 23428 smallArrayt* r; 23429 smallArrayt *self = allocG(rtSmallArrayt); 23430 23431 self->f->pushInt(self, 1); 23432 self->f->pushInt(self, 2); 23433 r = reverseSmallArrayG(self); 23434 ck_assert_ptr_ne(r, NULL); 23435 char *s = toStringO(r); 23436 ck_assert_str_eq(s, "[2,1]"); 23437 free(s); 23438 terminateO(self); 23439 23440 } 23441 23442 23443 void appendSmallArrayGT(void) { 23444 23445 smallArrayt* r; 23446 smallArrayt *self = allocG(rtSmallArrayt); 23447 smallArrayt *array = allocSmallArray(); 23448 23449 r = self->f->pushInt(self, 1); 23450 ck_assert_ptr_ne(r, null); 23451 array->f->pushInt(array, 1); 23452 array->f->pushInt(array, 2); 23453 r = appendSmallArrayG(self, array); 23454 ck_assert_ptr_ne(r, NULL); 23455 smashO(array); 23456 char *s = toStringO(r); 23457 ck_assert_str_eq(s, "[1,1,2]"); 23458 free(s); 23459 // non smallArray object 23460 array = (smallArrayt*) allocSmallInt(0); 23461 r = appendSmallArrayG(self, array); 23462 ck_assert_ptr_eq(r, NULL); 23463 terminateO(array); 23464 terminateO(self); 23465 23466 } 23467 23468 23469 void appendSmallJsonSmallArrayGT(void) { 23470 23471 smallArrayt* r; 23472 smallArrayt *self = allocG(rtSmallArrayt); 23473 smallJsont *json = allocSmallJson(); 23474 23475 r = self->f->pushInt(self, 1); 23476 ck_assert_ptr_ne(r, null); 23477 json->f->pushInt(json, 1); 23478 json->f->pushInt(json, 2); 23479 r = appendSmallJsonSmallArrayG(self, json); 23480 ck_assert_ptr_ne(r, NULL); 23481 smashO(json); 23482 char *s = toStringO(r); 23483 ck_assert_str_eq(s, "[1,1,2]"); 23484 free(s); 23485 terminateO(self); 23486 23487 } 23488 23489 23490 void appendNSmashSmallArrayGT(void) { 23491 23492 smallArrayt* r; 23493 smallArrayt *self = allocG(rtSmallArrayt); 23494 smallArrayt *array = allocSmallArray(); 23495 23496 r = self->f->pushInt(self, 1); 23497 ck_assert_ptr_ne(r, null); 23498 array->f->pushInt(array, 1); 23499 array->f->pushInt(array, 2); 23500 r = appendNSmashSmallArrayG(self, array); 23501 ck_assert_ptr_ne(r, NULL); 23502 char *s = toStringO(r); 23503 ck_assert_str_eq(s, "[1,1,2]"); 23504 free(s); 23505 terminateO(self); 23506 23507 } 23508 23509 23510 void appendNSmashSmallJsonSmallArrayGT(void) { 23511 23512 smallArrayt* r; 23513 smallArrayt *self = allocG(rtSmallArrayt); 23514 smallJsont *json = allocSmallJson(); 23515 23516 r = self->f->pushInt(self, 1); 23517 ck_assert_ptr_ne(r, null); 23518 json->f->pushInt(json, 1); 23519 json->f->pushInt(json, 2); 23520 r = appendNSmashSmallJsonSmallArrayG(self, json); 23521 ck_assert_ptr_ne(r, NULL); 23522 char *s = toStringO(r); 23523 ck_assert_str_eq(s, "[1,1,2]"); 23524 free(s); 23525 terminateO(self); 23526 23527 } 23528 23529 23530 void appendArraySmallArrayGT(void) { 23531 23532 smallArrayt* r; 23533 smallArrayt *self = allocG(rtSmallArrayt); 23534 char **array = listCreateS("1", "2"); 23535 23536 r = self->f->pushInt(self, 1); 23537 ck_assert_ptr_ne(r, null); 23538 r = appendArraySmallArrayG(self, array); 23539 ck_assert_ptr_ne(r, NULL); 23540 listFreeS(array); 23541 char *s = toStringO(r); 23542 ck_assert_str_eq(s, "[1,\"1\",\"2\"]"); 23543 free(s); 23544 terminateO(self); 23545 23546 } 23547 23548 23549 void appendNSmashArraySmallArrayGT(void) { 23550 23551 smallArrayt* r; 23552 smallArrayt *self = allocG(rtSmallArrayt); 23553 char **array = listCreateS("1", "2"); 23554 23555 r = self->f->pushInt(self, 1); 23556 ck_assert_ptr_ne(r, null); 23557 r = appendNSmashArraySmallArrayG(self, array); 23558 ck_assert_ptr_ne(r, NULL); 23559 char *s = toStringO(r); 23560 ck_assert_str_eq(s, "[1,\"1\",\"2\"]"); 23561 free(s); 23562 terminateO(self); 23563 23564 } 23565 23566 23567 void appendCArraySmallArrayGT(void) { 23568 23569 smallArrayt* r; 23570 smallArrayt *self = allocG(rtSmallArrayt); 23571 const char *array[] = {"1", "2", null}; 23572 23573 r = self->f->pushInt(self, 1); 23574 ck_assert_ptr_ne(r, null); 23575 r = appendCArraySmallArrayG(self, array); 23576 ck_assert_ptr_ne(r, NULL); 23577 char *s = toStringO(r); 23578 ck_assert_str_eq(s, "[1,\"1\",\"2\"]"); 23579 free(s); 23580 terminateO(self); 23581 23582 } 23583 23584 23585 void shiftSmallArrayGT(void) { 23586 23587 smallArrayt* r; 23588 smallArrayt *self = allocG(rtSmallArrayt); 23589 smallArrayt *array = allocSmallArray(); 23590 23591 r = self->f->pushInt(self, 1); 23592 ck_assert_ptr_ne(r, null); 23593 array->f->pushInt(array, 1); 23594 array->f->pushInt(array, 2); 23595 r = shiftSmallArrayG(self, array); 23596 ck_assert_ptr_ne(r, NULL); 23597 smashO(array); 23598 char *s = toStringO(r); 23599 ck_assert_str_eq(s, "[1,2,1]"); 23600 free(s); 23601 terminateO(self); 23602 23603 } 23604 23605 23606 void shiftSmallJsonSmallArrayGT(void) { 23607 23608 smallArrayt* r; 23609 smallArrayt *self = allocG(rtSmallArrayt); 23610 smallJsont *json = allocSmallJson(); 23611 23612 r = self->f->pushInt(self, 1); 23613 ck_assert_ptr_ne(r, null); 23614 json->f->pushInt(json, 1); 23615 json->f->pushInt(json, 2); 23616 r = shiftSmallJsonSmallArrayG(self, json); 23617 ck_assert_ptr_ne(r, NULL); 23618 smashO(json); 23619 char *s = toStringO(r); 23620 ck_assert_str_eq(s, "[1,2,1]"); 23621 free(s); 23622 terminateO(self); 23623 23624 } 23625 23626 23627 void shiftNSmashSmallArrayGT(void) { 23628 23629 smallArrayt* r; 23630 smallArrayt *self = allocG(rtSmallArrayt); 23631 smallArrayt *array = allocSmallArray(); 23632 23633 r = self->f->pushInt(self, 1); 23634 ck_assert_ptr_ne(r, null); 23635 array->f->pushInt(array, 1); 23636 array->f->pushInt(array, 2); 23637 r = shiftNSmashSmallArrayG(self, array); 23638 ck_assert_ptr_ne(r, NULL); 23639 char *s = toStringO(r); 23640 ck_assert_str_eq(s, "[1,2,1]"); 23641 free(s); 23642 terminateO(self); 23643 23644 } 23645 23646 23647 void shiftNSmashSmallJsonSmallArrayGT(void) { 23648 23649 smallArrayt* r; 23650 smallArrayt *self = allocG(rtSmallArrayt); 23651 smallJsont *json = allocSmallJson(); 23652 23653 r = self->f->pushInt(self, 1); 23654 ck_assert_ptr_ne(r, null); 23655 json->f->pushInt(json, 1); 23656 json->f->pushInt(json, 2); 23657 r = shiftNSmashSmallJsonSmallArrayG(self, json); 23658 ck_assert_ptr_ne(r, NULL); 23659 char *s = toStringO(r); 23660 ck_assert_str_eq(s, "[1,2,1]"); 23661 free(s); 23662 terminateO(self); 23663 23664 } 23665 23666 23667 void addSmallArrayGT(void) { 23668 23669 smallArrayt* r; 23670 smallArrayt *self = allocG(rtSmallArrayt); 23671 createAllocateSmallArray(a); 23672 23673 // add an element to check that the second array is added 23674 // at the end 23675 r = self->f->pushInt(self, 1); 23676 ck_assert_ptr_ne(r, null); 23677 23678 // add array 23679 a->f->pushInt(a, 2); 23680 r = addSmallArrayG(self, a); 23681 smashO(a); 23682 ck_assert_ptr_ne(r, null); 23683 char *s = toStringO(r); 23684 terminateO(r); 23685 ck_assert_str_eq(s, "[1,2]"); 23686 free(s); 23687 // empty array 23688 initiateAllocateSmallArray(&a); 23689 r = addSmallArrayG(self, a); 23690 smashO(a); 23691 ck_assert_ptr_ne(r, null); 23692 s = toStringO(r); 23693 terminateO(r); 23694 ck_assert_str_eq(s, "[1]"); 23695 free(s); 23696 // non smallArray object 23697 a = (smallArrayt*) allocSmallInt(0); 23698 r = addSmallArrayG(self, a); 23699 ck_assert_ptr_eq(r, NULL); 23700 terminateO(a); 23701 terminateO(self); 23702 23703 } 23704 23705 23706 void sliceSmallArrayGT(void) { 23707 23708 smallArrayt* r; 23709 smallArrayt *self = allocG(rtSmallArrayt); 23710 23711 r = self->f->pushInt(self, 1); 23712 ck_assert_ptr_ne(r, null); 23713 r = self->f->pushInt(self, 2); 23714 ck_assert_ptr_ne(r, null); 23715 r = self->f->pushInt(self, 3); 23716 ck_assert_ptr_ne(r, null); 23717 r = self->f->pushInt(self, 4); 23718 ck_assert_ptr_ne(r, null); 23719 r = sliceSmallArrayG(self, 1, -1); 23720 ck_assert_ptr_ne(r, null); 23721 char *s = toStringO(r); 23722 ck_assert_str_eq(s, "[2,3]"); 23723 free(s); 23724 terminateO(self); 23725 23726 } 23727 23728 23729 void cropSmallArrayGT(void) { 23730 23731 smallArrayt* r; 23732 smallArrayt *self = allocG(rtSmallArrayt); 23733 23734 r = self->f->pushInt(self, 1); 23735 ck_assert_ptr_ne(r, null); 23736 r = self->f->pushInt(self, 2); 23737 ck_assert_ptr_ne(r, null); 23738 r = self->f->pushInt(self, 3); 23739 ck_assert_ptr_ne(r, null); 23740 r = self->f->pushInt(self, 4); 23741 ck_assert_ptr_ne(r, null); 23742 r = cropSmallArrayG(self, 1, -1); 23743 ck_assert_ptr_ne(r, null); 23744 char *s = toStringO(r); 23745 terminateO(r); 23746 ck_assert_str_eq(s, "[2,3]"); 23747 free(s); 23748 s = toStringO(self); 23749 ck_assert_str_eq(s, "[1,4]"); 23750 free(s); 23751 terminateO(self); 23752 23753 } 23754 23755 23756 void cropElemSmallArrayGT(void) { 23757 23758 baset* r; 23759 smallArrayt *self = allocG(rtSmallArrayt); 23760 23761 smallArrayt *r2 = self->f->pushInt(self, 1); 23762 ck_assert_ptr_ne(r2, null); 23763 r = cropElemSmallArrayG(self, 0); 23764 ck_assert_ptr_ne(r, null); 23765 char *s = toStringO(r); 23766 terminateO(r); 23767 ck_assert_str_eq(s, "1"); 23768 free(s); 23769 terminateO(self); 23770 23771 } 23772 23773 23774 void cropElemUndefinedSmallArrayGT(void) { 23775 23776 undefinedt* r; 23777 smallArrayt *self = allocG(rtSmallArrayt); 23778 23779 smallArrayt *r2 = self->f->pushUndefined(self); 23780 ck_assert_ptr_ne(r2, null); 23781 r = cropElemUndefinedSmallArrayG(self, 0); 23782 ck_assert_ptr_ne(r, null); 23783 char *s = toStringO(r); 23784 terminateO(r); 23785 ck_assert_str_eq(s, "null"); 23786 free(s); 23787 terminateO(self); 23788 23789 } 23790 23791 23792 void cropElemBoolSmallArrayGT(void) { 23793 23794 bool r; 23795 smallArrayt *self = allocG(rtSmallArrayt); 23796 23797 smallArrayt *r2 = self->f->pushBool(self, true); 23798 ck_assert_ptr_ne(r2, null); 23799 r = cropElemBoolSmallArrayG(self, 0); 23800 ck_assert(r); 23801 terminateO(self); 23802 23803 } 23804 23805 23806 void cropElemDoubleSmallArrayGT(void) { 23807 23808 double r; 23809 smallArrayt *self = allocG(rtSmallArrayt); 23810 23811 smallArrayt *r2 = self->f->pushDouble(self, 1); 23812 ck_assert_ptr_ne(r2, null); 23813 r = cropElemDoubleSmallArrayG(self, 0); 23814 ck_assert(r==1); 23815 terminateO(self); 23816 23817 } 23818 23819 23820 void cropElemIntSmallArrayGT(void) { 23821 23822 int64_t r; 23823 smallArrayt *self = allocG(rtSmallArrayt); 23824 23825 smallArrayt *r2 = self->f->pushInt(self, 2); 23826 ck_assert_ptr_ne(r2, null); 23827 r = cropElemIntSmallArrayG(self, 0); 23828 ck_assert_int_eq(r, 2); 23829 terminateO(self); 23830 23831 } 23832 23833 23834 void cropElemInt32SmallArrayGT(void) { 23835 23836 int32_t r; 23837 smallArrayt *self = allocG(rtSmallArrayt); 23838 23839 smallArrayt *r2 = self->f->pushInt(self, 2); 23840 ck_assert_ptr_ne(r2, null); 23841 r = cropElemInt32SmallArrayG(self, 0); 23842 ck_assert_int_eq(r, 2); 23843 terminateO(self); 23844 23845 } 23846 23847 23848 void cropElemUintSmallArrayGT(void) { 23849 23850 uint64_t r; 23851 smallArrayt *self = allocG(rtSmallArrayt); 23852 23853 smallArrayt *r2 = self->f->pushInt(self, 2); 23854 ck_assert_ptr_ne(r2, null); 23855 r = cropElemUintSmallArrayG(self, 0); 23856 ck_assert_int_eq(r, 2); 23857 terminateO(self); 23858 23859 } 23860 23861 23862 void cropElemUint32SmallArrayGT(void) { 23863 23864 uint32_t r; 23865 smallArrayt *self = allocG(rtSmallArrayt); 23866 23867 smallArrayt *r2 = self->f->pushInt(self, 2); 23868 ck_assert_ptr_ne(r2, null); 23869 r = cropElemUint32SmallArrayG(self, 0); 23870 ck_assert_int_eq(r, 2); 23871 terminateO(self); 23872 23873 } 23874 23875 23876 void cropElemSSmallArrayGT(void) { 23877 23878 char* r; 23879 smallArrayt *self = allocG(rtSmallArrayt); 23880 23881 smallArrayt *r2 = self->f->pushS(self, "qwe"); 23882 ck_assert_ptr_ne(r2, null); 23883 r = cropElemSSmallArrayG(self, 0); 23884 ck_assert_str_eq(r, "qwe"); 23885 free(r); 23886 terminateO(self); 23887 23888 } 23889 23890 23891 void cropElemDictSmallArrayGT(void) { 23892 23893 smallDictt* r; 23894 smallArrayt *self = allocG(rtSmallArrayt); 23895 23896 createSmallDict(d); 23897 (&d)->f->setInt(&d, "a", 1); 23898 smallArrayt *r2 = self->f->pushDict(self, &d); 23899 ck_assert_ptr_ne(r2, null); 23900 r = cropElemDictSmallArrayG(self, 0); 23901 ck_assert_ptr_ne(r, null); 23902 char *s = toStringO(r); 23903 terminateO(r); 23904 ck_assert_str_eq(s, "{\"a\":1}"); 23905 free(s); 23906 terminateO(self); 23907 23908 } 23909 23910 23911 void cropElemArraySmallArrayGT(void) { 23912 23913 smallArrayt* r; 23914 smallArrayt *self = allocG(rtSmallArrayt); 23915 23916 r = allocSmallArray(); 23917 r->f->pushInt(r, 1); 23918 smallArrayt *r2 = self->f->pushNFreeArray(self, r); 23919 ck_assert_ptr_ne(r2, null); 23920 r = cropElemArraySmallArrayG(self, 0); 23921 ck_assert_ptr_ne(r, null); 23922 char *s = toStringO(r); 23923 terminateO(r); 23924 ck_assert_str_eq(s, "[1]"); 23925 free(s); 23926 terminateO(self); 23927 23928 } 23929 23930 23931 void cropElemSmallBoolSmallArrayGT(void) { 23932 23933 smallBoolt* r; 23934 smallArrayt *self = allocG(rtSmallArrayt); 23935 23936 smallArrayt *r2 = self->f->pushBool(self, true); 23937 ck_assert_ptr_ne(r2, null); 23938 r = cropElemSmallBoolSmallArrayG(self, 0); 23939 ck_assert_ptr_ne(r, null); 23940 char *s = toStringO(r); 23941 terminateO(r); 23942 ck_assert_str_eq(s, "true"); 23943 free(s); 23944 terminateO(self); 23945 23946 } 23947 23948 23949 void cropElemSmallBytesSmallArrayGT(void) { 23950 23951 smallBytest* r; 23952 smallArrayt *self = allocG(rtSmallArrayt); 23953 23954 r = allocSmallBytes("qwe", 3); 23955 smallArrayt *r2 = self->f->pushNFreeSmallBytes(self, r); 23956 ck_assert_ptr_ne(r2, null); 23957 r = cropElemSmallBytesSmallArrayG(self, 0); 23958 ck_assert_ptr_ne(r, null); 23959 char *s = toStringO(r); 23960 terminateO(r); 23961 ck_assert_str_eq(s, "[0x71,0x77,0x65]"); 23962 free(s); 23963 terminateO(self); 23964 23965 } 23966 23967 23968 void cropElemSmallDoubleSmallArrayGT(void) { 23969 23970 smallDoublet* r; 23971 smallArrayt *self = allocG(rtSmallArrayt); 23972 23973 smallArrayt *r2 = self->f->pushDouble(self, 1); 23974 ck_assert_ptr_ne(r2, null); 23975 r = cropElemSmallDoubleSmallArrayG(self, 0); 23976 ck_assert_ptr_ne(r, null); 23977 char *s = toStringO(r); 23978 terminateO(r); 23979 ck_assert_str_eq(s, "1.000000e+00"); 23980 free(s); 23981 terminateO(self); 23982 23983 } 23984 23985 23986 void cropElemSmallIntSmallArrayGT(void) { 23987 23988 smallIntt* r; 23989 smallArrayt *self = allocG(rtSmallArrayt); 23990 23991 smallArrayt *r2 = self->f->pushInt(self, 1); 23992 ck_assert_ptr_ne(r2, null); 23993 r = cropElemSmallIntSmallArrayG(self, 0); 23994 ck_assert_ptr_ne(r, null); 23995 char *s = toStringO(r); 23996 terminateO(r); 23997 ck_assert_str_eq(s, "1"); 23998 free(s); 23999 terminateO(self); 24000 24001 } 24002 24003 24004 void cropElemSmallJsonSmallArrayGT(void) { 24005 24006 smallJsont* r; 24007 smallArrayt *self = allocG(rtSmallArrayt); 24008 24009 r = allocSmallJson(); 24010 r->f->setInt(r, "a", 1); 24011 smallArrayt *r2 = self->f->pushNFreeSmallJson(self, r); 24012 ck_assert_ptr_ne(r2, null); 24013 r = cropElemSmallJsonSmallArrayG(self, 0); 24014 ck_assert_ptr_ne(r, null); 24015 char *s = toStringO(r); 24016 terminateO(r); 24017 ck_assert_str_eq(s, "{\"a\":1}"); 24018 free(s); 24019 terminateO(self); 24020 24021 } 24022 24023 24024 void cropElemSmallStringSmallArrayGT(void) { 24025 24026 smallStringt* r; 24027 smallArrayt *self = allocG(rtSmallArrayt); 24028 24029 smallArrayt *r2 = self->f->pushS(self, "qwe"); 24030 ck_assert_ptr_ne(r2, null); 24031 r = cropElemSmallStringSmallArrayG(self, 0); 24032 ck_assert_ptr_ne(r, null); 24033 char *s = toStringO(r); 24034 terminateO(r); 24035 ck_assert_str_eq(s, "qwe"); 24036 free(s); 24037 terminateO(self); 24038 24039 } 24040 24041 24042 void cropElemVoidSmallArrayGT(void) { 24043 24044 void* r; 24045 smallArrayt *self = allocG(rtSmallArrayt); 24046 24047 smallArrayt *r2 = pushVoidSmallArrayG(self, &r); 24048 ck_assert_ptr_ne(r2, null); 24049 r = cropElemVoidSmallArrayG(self, 0); 24050 ck_assert_ptr_eq(r, &r); 24051 terminateO(self); 24052 24053 } 24054 24055 24056 void cropElemSmallContainerSmallArrayGT(void) { 24057 24058 smallContainert* r; 24059 smallArrayt *self = allocG(rtSmallArrayt); 24060 24061 createSmallContainer(e2); 24062 smallArrayt *r2 = self->f->pushSmallContainer(self, &e2); 24063 ck_assert_ptr_ne(r2, null); 24064 r = cropElemSmallContainerSmallArrayG(self, 0); 24065 ck_assert_ptr_ne(r, null); 24066 char *s = toStringO(r); 24067 terminateO(r); 24068 ck_assert_str_eq(s, "<data smallContainer>"); 24069 free(s); 24070 terminateO(self); 24071 24072 } 24073 24074 24075 void copySmallArrayGT(void) { 24076 24077 smallArrayt* r; 24078 smallArrayt *self = allocG(rtSmallArrayt); 24079 24080 // add elements to self 24081 r = self->f->pushInt(self, 1); 24082 ck_assert_ptr_ne(r, null); 24083 r = self->f->pushInt(self, 2); 24084 ck_assert_ptr_ne(r, null); 24085 r = self->f->pushInt(self, 3); 24086 ck_assert_ptr_ne(r, null); 24087 r = self->f->pushInt(self, 4); 24088 ck_assert_ptr_ne(r, null); 24089 r = copySmallArrayG(self, 1, -1); 24090 ck_assert_ptr_ne(r, null); 24091 ck_assert_int_eq(lenO(r), 2); 24092 char *s = toStringO(r); 24093 terminateO(r); 24094 ck_assert_str_eq(s, "[2,3]"); 24095 free(s); 24096 s = toStringO(self); 24097 ck_assert_str_eq(s, "[1,2,3,4]"); 24098 free(s); 24099 terminateO(self); 24100 24101 } 24102 24103 24104 void insertSmallArrayGT(void) { 24105 24106 smallArrayt* r; 24107 smallArrayt *self = allocG(rtSmallArrayt); 24108 smallArrayt *toInsert = allocSmallArray(); 24109 24110 toInsert->f->pushInt(toInsert, 3); 24111 r = insertSmallArrayG(self, 0, toInsert); 24112 smashO(toInsert); 24113 ck_assert_ptr_ne(r, null); 24114 char *s = toStringO(r); 24115 ck_assert_str_eq(s, "[3]"); 24116 free(s); 24117 terminateO(self); 24118 24119 } 24120 24121 24122 void insertSmallJsonSmallArrayGT(void) { 24123 24124 smallArrayt* r; 24125 smallArrayt *self = allocG(rtSmallArrayt); 24126 smallJsont *toInsert = allocSmallJson(); 24127 24128 toInsert->f->pushInt(toInsert, 3); 24129 r = insertSmallJsonSmallArrayG(self, 0, toInsert); 24130 smashO(toInsert); 24131 ck_assert_ptr_ne(r, null); 24132 char *s = toStringO(r); 24133 ck_assert_str_eq(s, "[3]"); 24134 free(s); 24135 terminateO(self); 24136 24137 } 24138 24139 24140 void insertNSmashSmallArrayGT(void) { 24141 24142 smallArrayt* r; 24143 smallArrayt *self = allocG(rtSmallArrayt); 24144 smallArrayt *toInsert = allocSmallArray(); 24145 24146 toInsert->f->pushInt(toInsert, 3); 24147 r = insertNSmashSmallArrayG(self, 0, toInsert); 24148 ck_assert_ptr_ne(r, null); 24149 char *s = toStringO(r); 24150 ck_assert_str_eq(s, "[3]"); 24151 free(s); 24152 terminateO(self); 24153 24154 } 24155 24156 24157 void insertNSmashSmallJsonSmallArrayGT(void) { 24158 24159 smallArrayt* r; 24160 smallArrayt *self = allocG(rtSmallArrayt); 24161 smallJsont *toInsert = allocSmallJson(); 24162 24163 toInsert->f->pushInt(toInsert, 3); 24164 r = insertNSmashSmallJsonSmallArrayG(self, 0, toInsert); 24165 ck_assert_ptr_ne(r, null); 24166 char *s = toStringO(r); 24167 ck_assert_str_eq(s, "[3]"); 24168 free(s); 24169 terminateO(self); 24170 24171 } 24172 24173 24174 void injectSmallArrayGT(void) { 24175 24176 smallArrayt* r; 24177 smallArrayt *self = allocG(rtSmallArrayt); 24178 baset *value = (baset*) allocSmallInt(8); 24179 24180 r = injectSmallArrayG(self, 0, value); 24181 ck_assert_ptr_ne(r, null); 24182 finishO(value); 24183 char *s = toStringO(r); 24184 ck_assert_str_eq(s, "[8]"); 24185 free(s); 24186 terminateO(self); 24187 24188 } 24189 24190 24191 void injectUndefinedSmallArrayGT(void) { 24192 24193 smallArrayt* r; 24194 smallArrayt *self = allocG(rtSmallArrayt); 24195 24196 r = injectUndefinedSmallArrayG(self, 0, null); 24197 ck_assert_ptr_ne(r, null); 24198 char *s = toStringO(r); 24199 ck_assert_str_eq(s, "[null]"); 24200 free(s); 24201 terminateO(self); 24202 24203 } 24204 24205 24206 void injectBoolSmallArrayGT(void) { 24207 24208 smallArrayt* r; 24209 smallArrayt *self = allocG(rtSmallArrayt); 24210 24211 r = injectBoolSmallArrayG(self, 0, true); 24212 ck_assert_ptr_ne(r, null); 24213 char *s = toStringO(r); 24214 ck_assert_str_eq(s, "[true]"); 24215 free(s); 24216 terminateO(self); 24217 24218 } 24219 24220 24221 void injectDoubleSmallArrayGT(void) { 24222 24223 smallArrayt* r; 24224 smallArrayt *self = allocG(rtSmallArrayt); 24225 24226 r = injectDoubleSmallArrayG(self, 0, 1); 24227 ck_assert_ptr_ne(r, null); 24228 char *s = toStringO(r); 24229 ck_assert_str_eq(s, "[1.000000e+00]"); 24230 free(s); 24231 terminateO(self); 24232 24233 } 24234 24235 24236 void injectIntSmallArrayGT(void) { 24237 24238 smallArrayt* r; 24239 smallArrayt *self = allocG(rtSmallArrayt); 24240 24241 r = injectIntSmallArrayG(self, 0, 2); 24242 ck_assert_ptr_ne(r, null); 24243 char *s = toStringO(r); 24244 ck_assert_str_eq(s, "[2]"); 24245 free(s); 24246 terminateO(self); 24247 24248 } 24249 24250 24251 void injectSSmallArrayGT(void) { 24252 24253 smallArrayt* r; 24254 smallArrayt *self = allocG(rtSmallArrayt); 24255 24256 r = injectSSmallArrayG(self, 0, "qwe"); 24257 ck_assert_ptr_ne(r, null); 24258 char *s = toStringO(r); 24259 ck_assert_str_eq(s, "[\"qwe\"]"); 24260 free(s); 24261 terminateO(self); 24262 24263 } 24264 24265 24266 void injectCharSmallArrayGT(void) { 24267 24268 smallArrayt* r; 24269 smallArrayt *self = allocG(rtSmallArrayt); 24270 24271 r = injectCharSmallArrayG(self, 0, 'a'); 24272 ck_assert_ptr_ne(r, null); 24273 char *s = toStringO(r); 24274 ck_assert_str_eq(s, "[\"a\"]"); 24275 free(s); 24276 terminateO(self); 24277 24278 } 24279 24280 24281 void injectDictSmallArrayGT(void) { 24282 24283 smallArrayt* r; 24284 smallArrayt *self = allocG(rtSmallArrayt); 24285 24286 createSmallDict(d); 24287 r = injectDictSmallArrayG(self, 0, &d); 24288 ck_assert_ptr_ne(r, null); 24289 char *s = toStringO(r); 24290 ck_assert_str_eq(s, "[{}]"); 24291 free(s); 24292 terminateO(self); 24293 24294 } 24295 24296 24297 void injectArraySmallArrayGT(void) { 24298 24299 smallArrayt* r; 24300 smallArrayt *self = allocG(rtSmallArrayt); 24301 24302 createSmallArray(a); 24303 r = injectArraySmallArrayG(self, 0, &a); 24304 ck_assert_ptr_ne(r, null); 24305 char *s = toStringO(r); 24306 ck_assert_str_eq(s, "[[]]"); 24307 free(s); 24308 terminateO(self); 24309 24310 } 24311 24312 24313 void injectArraycSmallArrayGT(void) { 24314 24315 smallArrayt* r; 24316 smallArrayt *self = allocG(rtSmallArrayt); 24317 char **array = listCreateS("a","b"); 24318 24319 r = injectArraycSmallArrayG(self, 0, array); 24320 ck_assert_ptr_ne(r, null); 24321 listFreeS(array); 24322 char *s = toStringO(r); 24323 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 24324 free(s); 24325 terminateO(self); 24326 24327 } 24328 24329 24330 void injectCArraycSmallArrayGT(void) { 24331 24332 smallArrayt* r; 24333 smallArrayt *self = allocG(rtSmallArrayt); 24334 const char *array[] = {"a","b",null}; 24335 24336 r = injectCArraycSmallArrayG(self, 0, array); 24337 ck_assert_ptr_ne(r, null); 24338 char *s = toStringO(r); 24339 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 24340 free(s); 24341 terminateO(self); 24342 24343 } 24344 24345 24346 void injectVoidSmallArrayGT(void) { 24347 24348 smallArrayt* r; 24349 smallArrayt *self = allocG(rtSmallArrayt); 24350 24351 r = injectVoidSmallArrayG(self, 0, null); 24352 ck_assert_ptr_ne(r, null); 24353 char *s = toStringO(r); 24354 ck_assert_str_eq(s, "[null]"); 24355 free(s); 24356 r = injectVoidSmallArrayG(self, 0, &r); 24357 ck_assert_ptr_ne(r, null); 24358 s = toStringO(r); 24359 ck_assert_str_eq(s, "[\"<data container>\",null]"); 24360 free(s); 24361 terminateO(self); 24362 24363 } 24364 24365 24366 void injectSmallBoolSmallArrayGT(void) { 24367 24368 smallArrayt* r; 24369 smallArrayt *self = allocG(rtSmallArrayt); 24370 24371 smallBoolt *b = allocSmallBool(true); 24372 r = injectSmallBoolSmallArrayG(self, 0, b); 24373 ck_assert_ptr_ne(r, null); 24374 finishO(b); 24375 char *s = toStringO(r); 24376 ck_assert_str_eq(s, "[true]"); 24377 free(s); 24378 terminateO(self); 24379 24380 } 24381 24382 24383 void injectSmallBytesSmallArrayGT(void) { 24384 24385 smallArrayt* r; 24386 smallArrayt *self = allocG(rtSmallArrayt); 24387 smallBytest *b = allocSmallBytes("qwe", 3); 24388 24389 r = injectSmallBytesSmallArrayG(self, 0, b); 24390 ck_assert_ptr_ne(r, null); 24391 finishO(b); 24392 char *s = toStringO(r); 24393 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 24394 free(s); 24395 terminateO(self); 24396 24397 } 24398 24399 24400 void injectSmallDoubleSmallArrayGT(void) { 24401 24402 smallArrayt* r; 24403 smallArrayt *self = allocG(rtSmallArrayt); 24404 smallDoublet *value = allocSmallDouble(1); 24405 24406 r = injectSmallDoubleSmallArrayG(self, 0, value); 24407 ck_assert_ptr_ne(r, null); 24408 finishO(value); 24409 char *s = toStringO(r); 24410 ck_assert_str_eq(s, "[1.000000e+00]"); 24411 free(s); 24412 terminateO(self); 24413 24414 } 24415 24416 24417 void injectSmallIntSmallArrayGT(void) { 24418 24419 smallArrayt* r; 24420 smallArrayt *self = allocG(rtSmallArrayt); 24421 smallIntt *value = allocSmallInt(1); 24422 24423 r = injectSmallIntSmallArrayG(self, 0, value); 24424 ck_assert_ptr_ne(r, null); 24425 finishO(value); 24426 char *s = toStringO(r); 24427 ck_assert_str_eq(s, "[1]"); 24428 free(s); 24429 terminateO(self); 24430 24431 } 24432 24433 24434 void injectSmallJsonSmallArrayGT(void) { 24435 24436 smallArrayt* r; 24437 smallArrayt *self = allocG(rtSmallArrayt); 24438 smallJsont *string = allocSmallJson(); 24439 24440 r = injectSmallJsonSmallArrayG(self, 0, string); 24441 ck_assert_ptr_ne(r, null); 24442 finishO(string); 24443 char *s = toStringO(r); 24444 ck_assert_str_eq(s, "[{}]"); 24445 free(s); 24446 terminateO(self); 24447 24448 } 24449 24450 24451 void injectSmallStringSmallArrayGT(void) { 24452 24453 smallArrayt* r; 24454 smallArrayt *self = allocG(rtSmallArrayt); 24455 smallStringt *string = allocSmallString("qwe"); 24456 24457 r = injectSmallStringSmallArrayG(self, 0, string); 24458 ck_assert_ptr_ne(r, null); 24459 finishO(string); 24460 char *s = toStringO(r); 24461 ck_assert_str_eq(s, "[\"qwe\"]"); 24462 free(s); 24463 terminateO(self); 24464 24465 } 24466 24467 24468 void injectSmallContainerSmallArrayGT(void) { 24469 24470 smallArrayt* r; 24471 smallArrayt *self = allocG(rtSmallArrayt); 24472 smallContainert *value = allocSmallContainer(null); 24473 24474 r = injectSmallContainerSmallArrayG(self, 0, value); 24475 ck_assert_ptr_ne(r, null); 24476 finishO(value); 24477 char *s = toStringO(r); 24478 ck_assert_str_eq(s, "[\"<data container>\"]"); 24479 free(s); 24480 terminateO(self); 24481 24482 } 24483 24484 24485 void injectNFreeSmallArrayGT(void) { 24486 24487 smallArrayt* r; 24488 smallArrayt *self = allocG(rtSmallArrayt); 24489 baset *value = (baset*) allocSmallInt(8); 24490 24491 r = injectNFreeSmallArrayG(self, 0, value); 24492 ck_assert_ptr_ne(r, null); 24493 char *s = toStringO(r); 24494 ck_assert_str_eq(s, "[8]"); 24495 free(s); 24496 terminateO(self); 24497 24498 } 24499 24500 24501 void injectNFreeUndefinedSmallArrayGT(void) { 24502 24503 smallArrayt* r; 24504 smallArrayt *self = allocG(rtSmallArrayt); 24505 24506 createAllocateUndefined(u); 24507 r = injectNFreeUndefinedSmallArrayG(self, 0, u); 24508 ck_assert_ptr_ne(r, null); 24509 char *s = toStringO(r); 24510 ck_assert_str_eq(s, "[null]"); 24511 free(s); 24512 terminateO(self); 24513 24514 } 24515 24516 24517 void injectNFreeSSmallArrayGT(void) { 24518 24519 smallArrayt* r; 24520 smallArrayt *self = allocG(rtSmallArrayt); 24521 char *string = strdup("qwe"); 24522 24523 r = injectNFreeSSmallArrayG(self, 0, string); 24524 ck_assert_ptr_ne(r, null); 24525 char *s = toStringO(r); 24526 ck_assert_str_eq(s, "[\"qwe\"]"); 24527 free(s); 24528 terminateO(self); 24529 24530 } 24531 24532 24533 void injectNFreeDictSmallArrayGT(void) { 24534 24535 smallArrayt* r; 24536 smallArrayt *self = allocG(rtSmallArrayt); 24537 24538 createAllocateSmallDict(d); 24539 r = injectNFreeDictSmallArrayG(self, 0, d); 24540 ck_assert_ptr_ne(r, null); 24541 char *s = toStringO(r); 24542 ck_assert_str_eq(s, "[{}]"); 24543 free(s); 24544 terminateO(self); 24545 24546 } 24547 24548 24549 void injectNFreeArraySmallArrayGT(void) { 24550 24551 smallArrayt* r; 24552 smallArrayt *self = allocG(rtSmallArrayt); 24553 24554 createAllocateSmallArray(a); 24555 r = injectNFreeArraySmallArrayG(self, 0, a); 24556 ck_assert_ptr_ne(r, null); 24557 char *s = toStringO(r); 24558 ck_assert_str_eq(s, "[[]]"); 24559 free(s); 24560 terminateO(self); 24561 24562 } 24563 24564 24565 void injectNFreeArraycSmallArrayGT(void) { 24566 24567 smallArrayt* r; 24568 smallArrayt *self = allocG(rtSmallArrayt); 24569 char **array = listCreateS("a","b"); 24570 24571 r = injectNFreeArraycSmallArrayG(self, 0, array); 24572 ck_assert_ptr_ne(r, null); 24573 char *s = toStringO(r); 24574 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 24575 free(s); 24576 terminateO(self); 24577 24578 } 24579 24580 24581 void injectNFreeSmallBoolSmallArrayGT(void) { 24582 24583 smallArrayt* r; 24584 smallArrayt *self = allocG(rtSmallArrayt); 24585 24586 smallBoolt *b = allocSmallBool(true); 24587 r = injectNFreeSmallBoolSmallArrayG(self, 0, b); 24588 ck_assert_ptr_ne(r, null); 24589 char *s = toStringO(r); 24590 ck_assert_str_eq(s, "[true]"); 24591 free(s); 24592 terminateO(self); 24593 24594 } 24595 24596 24597 void injectNFreeSmallBytesSmallArrayGT(void) { 24598 24599 smallArrayt* r; 24600 smallArrayt *self = allocG(rtSmallArrayt); 24601 smallBytest *b = allocSmallBytes("qwe", 3); 24602 24603 r = injectNFreeSmallBytesSmallArrayG(self, 0, b); 24604 ck_assert_ptr_ne(r, null); 24605 char *s = toStringO(r); 24606 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 24607 free(s); 24608 terminateO(self); 24609 24610 } 24611 24612 24613 void injectNFreeSmallDoubleSmallArrayGT(void) { 24614 24615 smallArrayt* r; 24616 smallArrayt *self = allocG(rtSmallArrayt); 24617 smallDoublet *value = allocSmallDouble(1); 24618 24619 r = injectNFreeSmallDoubleSmallArrayG(self, 0, value); 24620 ck_assert_ptr_ne(r, null); 24621 char *s = toStringO(r); 24622 ck_assert_str_eq(s, "[1.000000e+00]"); 24623 free(s); 24624 terminateO(self); 24625 24626 } 24627 24628 24629 void injectNFreeSmallIntSmallArrayGT(void) { 24630 24631 smallArrayt* r; 24632 smallArrayt *self = allocG(rtSmallArrayt); 24633 smallIntt *value = allocSmallInt(1); 24634 24635 r = injectNFreeSmallIntSmallArrayG(self, 0, value); 24636 ck_assert_ptr_ne(r, null); 24637 char *s = toStringO(r); 24638 ck_assert_str_eq(s, "[1]"); 24639 free(s); 24640 terminateO(self); 24641 24642 } 24643 24644 24645 void injectNFreeSmallJsonSmallArrayGT(void) { 24646 24647 smallArrayt* r; 24648 smallArrayt *self = allocG(rtSmallArrayt); 24649 smallJsont *string = allocSmallJson(); 24650 24651 r = injectNFreeSmallJsonSmallArrayG(self, 0, string); 24652 ck_assert_ptr_ne(r, null); 24653 char *s = toStringO(r); 24654 ck_assert_str_eq(s, "[{}]"); 24655 free(s); 24656 terminateO(self); 24657 24658 } 24659 24660 24661 void injectNFreeSmallStringSmallArrayGT(void) { 24662 24663 smallArrayt* r; 24664 smallArrayt *self = allocG(rtSmallArrayt); 24665 smallStringt *string = allocSmallString("qwe"); 24666 24667 r = injectNFreeSmallStringSmallArrayG(self, 0, string); 24668 ck_assert_ptr_ne(r, null); 24669 char *s = toStringO(r); 24670 ck_assert_str_eq(s, "[\"qwe\"]"); 24671 free(s); 24672 terminateO(self); 24673 24674 } 24675 24676 24677 void injectNFreeSmallContainerSmallArrayGT(void) { 24678 24679 smallArrayt* r; 24680 smallArrayt *self = allocG(rtSmallArrayt); 24681 smallContainert *value = allocSmallContainer(null); 24682 24683 r = injectNFreeSmallContainerSmallArrayG(self, 0, value); 24684 ck_assert_ptr_ne(r, null); 24685 char *s = toStringO(r); 24686 ck_assert_str_eq(s, "[\"<data container>\"]"); 24687 free(s); 24688 terminateO(self); 24689 24690 } 24691 24692 24693 void delSmallArrayGT(void) { 24694 24695 smallArrayt* r; 24696 smallArrayt *self = allocG(rtSmallArrayt); 24697 24698 r = self->f->pushInt(self, 1); 24699 ck_assert_ptr_ne(r, null); 24700 r = self->f->pushInt(self, 2); 24701 ck_assert_ptr_ne(r, null); 24702 r = self->f->pushInt(self, 3); 24703 ck_assert_ptr_ne(r, null); 24704 r = self->f->pushInt(self, 4); 24705 ck_assert_ptr_ne(r, null); 24706 r = delSmallArrayG(self, 1, -1); 24707 ck_assert_ptr_ne(r, null); 24708 char *s = toStringO(r); 24709 ck_assert_str_eq(s, "[1,4]"); 24710 free(s); 24711 terminateO(self); 24712 24713 } 24714 24715 24716 void delElemSmallArrayGT(void) { 24717 24718 smallArrayt* r; 24719 smallArrayt *self = allocG(rtSmallArrayt); 24720 24721 r = self->f->pushInt(self, 1); 24722 ck_assert_ptr_ne(r, null); 24723 r = self->f->pushInt(self, 2); 24724 ck_assert_ptr_ne(r, null); 24725 r = self->f->pushInt(self, 3); 24726 ck_assert_ptr_ne(r, null); 24727 r = self->f->pushInt(self, 4); 24728 ck_assert_ptr_ne(r, null); 24729 r = delElemSmallArrayG(self, 0); 24730 ck_assert_ptr_ne(r, null); 24731 char *s = toStringO(r); 24732 ck_assert_str_eq(s, "[2,3,4]"); 24733 free(s); 24734 r = delElemSmallArrayG(self, -1); 24735 ck_assert_ptr_ne(r, null); 24736 s = toStringO(r); 24737 ck_assert_str_eq(s, "[2,3]"); 24738 free(s); 24739 r = delElemSmallArrayG(self, 5); 24740 ck_assert_ptr_eq(r, null); 24741 r = delElemSmallArrayG(self, -5); 24742 ck_assert_ptr_eq(r, null); 24743 terminateO(self); 24744 24745 } 24746 24747 24748 void removeSmallArrayGT(void) { 24749 24750 smallArrayt* r; 24751 smallArrayt *self = allocG(rtSmallArrayt); 24752 24753 r = self->f->pushInt(self, 1); 24754 ck_assert_ptr_ne(r, null); 24755 r = self->f->pushInt(self, 2); 24756 ck_assert_ptr_ne(r, null); 24757 r = self->f->pushInt(self, 3); 24758 ck_assert_ptr_ne(r, null); 24759 r = self->f->pushInt(self, 4); 24760 ck_assert_ptr_ne(r, null); 24761 24762 smallIntt *e[4]; 24763 arange(i,e) { 24764 e[i] = self->f->getAtSmallInt(self, i); 24765 } 24766 24767 // negative index 24768 r = removeSmallArrayG(self, 1, -1); 24769 ck_assert_ptr_ne(r, null); 24770 char *s = toStringO(self); 24771 ck_assert_str_eq(s, "[1,4]"); 24772 free(s); 24773 r = removeSmallArrayG(self, 0, 40); 24774 ck_assert_ptr_ne(r, null); 24775 s = toStringO(self); 24776 ck_assert_str_eq(s, "[]"); 24777 free(s); 24778 arange(i,e) { 24779 terminateO(e[i]); 24780 } 24781 terminateO(self); 24782 24783 } 24784 24785 24786 void removeElemSmallArrayGT(void) { 24787 24788 smallArrayt* r; 24789 smallArrayt *self = allocG(rtSmallArrayt); 24790 24791 r = self->f->pushInt(self, 1); 24792 ck_assert_ptr_ne(r, null); 24793 r = self->f->pushInt(self, 2); 24794 ck_assert_ptr_ne(r, null); 24795 r = self->f->pushInt(self, 3); 24796 ck_assert_ptr_ne(r, null); 24797 r = self->f->pushInt(self, 4); 24798 ck_assert_ptr_ne(r, null); 24799 smallIntt *e = self->f->getAtSmallInt(self, 1);; 24800 r = removeElemSmallArrayG(self, 1); 24801 ck_assert_ptr_ne(r, null); 24802 terminateO(e); 24803 char *s = toStringO(self); 24804 ck_assert_str_eq(s, "[1,3,4]"); 24805 free(s); 24806 terminateO(self); 24807 24808 } 24809 24810 24811 void sortSmallArrayGT(void) { 24812 24813 smallArrayt* r; 24814 smallArrayt *self = allocG(rtSmallArrayt); 24815 24816 self->f->pushS(self, "bb"); 24817 self->f->pushS(self, "a"); 24818 r = sortSmallArrayG(self); 24819 ck_assert_ptr_ne(r, null); 24820 char *s = toStringO(r); 24821 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 24822 free(s); 24823 terminateO(self); 24824 24825 } 24826 24827 24828 void sortFSmallArrayGT(void) { 24829 24830 smallArrayt* r; 24831 smallArrayt *self = allocG(rtSmallArrayt); 24832 24833 // sort dict 24834 smallDictt *d[4]; 24835 arange(i,d) d[i] = allocSmallDict(); 24836 d[0]->f->setInt(d[0], "a", 1); 24837 d[1]->f->setInt(d[1], "a", 0); 24838 d[3]->f->setInt(d[3], "a", 0); 24839 d[3]->f->setInt(d[3], "b", 0); 24840 arange(i,d) self->f->pushNFreeDict(self, d[i]); 24841 r = sortFSmallArrayG(self, sortFOCmp); 24842 ck_assert_ptr_ne(r, null); 24843 char *s = toStringO(r); 24844 ck_assert_str_eq(s, "[{},{\"a\":0},{\"a\":1},{\"a\":0,\"b\":0}]"); 24845 free(s); 24846 terminateO(self); 24847 24848 } 24849 24850 24851 void icSortSmallArrayGT(void) { 24852 24853 smallArrayt* r; 24854 smallArrayt *self = allocG(rtSmallArrayt); 24855 24856 self->f->pushS(self, "bb"); 24857 self->f->pushS(self, "A"); 24858 r = icSortSmallArrayG(self); 24859 ck_assert_ptr_ne(r, null); 24860 char *s = toStringO(r); 24861 ck_assert_str_eq(s, "[\"A\",\"bb\"]"); 24862 free(s); 24863 terminateO(self); 24864 24865 } 24866 24867 24868 void equalSmallArrayGT(void) { 24869 24870 bool r; 24871 smallArrayt *self = allocG(rtSmallArrayt); 24872 smallArrayt *array = allocSmallArray(); 24873 24874 r = equalSmallArrayG(self, array); 24875 ck_assert(r); 24876 terminateO(array); 24877 terminateO(self); 24878 24879 } 24880 24881 24882 void equalSmallArraySmallJsonGT(void) { 24883 24884 bool r; 24885 smallArrayt *self = allocG(rtSmallArrayt); 24886 smallJsont *array = allocSmallJson(); 24887 24888 r = equalSmallArraySmallJsonG(self, array); 24889 // the smallJson is empty, so the result is false 24890 ck_assert(!r); 24891 terminateO(self); 24892 terminateO(array); 24893 24894 } 24895 24896 24897 void equalSmallArrayArrayGT(void) { 24898 24899 bool r; 24900 smallArrayt* self = allocG(rtSmallArrayt); 24901 24902 r = equalSmallArrayArrayG(self, null); 24903 ck_assert(r); 24904 terminateO(self); 24905 24906 } 24907 24908 24909 void equalSmallArrayCArrayGT(void) { 24910 24911 bool r; 24912 smallArrayt* self = allocG(rtSmallArrayt); 24913 24914 r = equalSmallArrayCArrayG(self, null); 24915 ck_assert(r); 24916 terminateO(self); 24917 24918 } 24919 24920 24921 void equalSmallArrayBaseGT(void) { 24922 24923 bool r; 24924 smallArrayt* self = allocG(rtSmallArrayt); 24925 baset* p2 = (baset*) allocG(1); 24926 24927 r = equalSmallArrayBaseG(self, p2); 24928 ck_assert(!r); 24929 terminateO(p2); 24930 terminateO(self); 24931 24932 } 24933 24934 24935 void icEqualSmallArrayGT(void) { 24936 24937 bool r; 24938 smallArrayt *self = allocG(rtSmallArrayt); 24939 smallArrayt *array = allocG(rtSmallArrayt); 24940 24941 self->f->pushS(self, "a"); 24942 array->f->pushS(array, "A"); 24943 r = icEqualSmallArrayG(self, array); 24944 ck_assert(r); 24945 terminateO(array); 24946 terminateO(self); 24947 24948 } 24949 24950 24951 void icEqualSmallArraySmallJsonGT(void) { 24952 24953 bool r; 24954 smallArrayt *self = allocG(rtSmallArrayt); 24955 smallJsont *array = allocSmallJson(); 24956 24957 r = icEqualSmallArraySmallJsonG(self, array); 24958 ck_assert(!r); 24959 terminateO(array); 24960 terminateO(self); 24961 24962 } 24963 24964 24965 void icEqualSmallArrayArrayGT(void) { 24966 24967 bool r; 24968 smallArrayt* self = allocG(rtSmallArrayt); 24969 24970 r = icEqualSmallArrayArrayG(self, null); 24971 ck_assert(r); 24972 terminateO(self); 24973 24974 } 24975 24976 24977 void icEqualSmallArrayCArrayGT(void) { 24978 24979 bool r; 24980 smallArrayt* self = allocG(rtSmallArrayt); 24981 24982 r = icEqualSmallArrayCArrayG(self, null); 24983 ck_assert(r); 24984 terminateO(self); 24985 24986 } 24987 24988 24989 void icEqualSmallArrayBaseGT(void) { 24990 24991 bool r; 24992 smallArrayt* self = allocG(rtSmallArrayt); 24993 24994 r = icEqualSmallArrayBaseG(self, null); 24995 ck_assert(!r); 24996 terminateO(self); 24997 24998 } 24999 25000 25001 void lenSmallArrayGT(void) { 25002 25003 size_t r; 25004 smallArrayt *self = allocG(rtSmallArrayt); 25005 25006 self->f->pushInt(self, 1); 25007 r = lenSmallArrayG(self); 25008 ck_assert_int_eq(r, 1); 25009 terminateO(self); 25010 25011 } 25012 25013 25014 void trimSmallArrayGT(void) { 25015 25016 smallArrayt* r; 25017 smallArrayt *self = allocG(rtSmallArrayt); 25018 25019 self->f->pushInt(self, 1); 25020 delElemO(self, 0); 25021 r = trimSmallArrayG(self); 25022 ck_assert_ptr_ne(r, null); 25023 ck_assert_int_eq(lenSmallArrayG(self), 0); 25024 terminateO(self); 25025 25026 } 25027 25028 25029 void hasSmallArrayGT(void) { 25030 25031 bool r; 25032 smallArrayt *self = allocG(rtSmallArrayt); 25033 25034 r = hasSmallArrayG(self, null); 25035 ck_assert(!r); 25036 terminateO(self); 25037 25038 } 25039 25040 25041 void hasUndefinedSmallArrayGT(void) { 25042 25043 bool r; 25044 smallArrayt *self = allocG(rtSmallArrayt); 25045 25046 r = hasUndefinedSmallArrayG(self, null); 25047 ck_assert(!r); 25048 terminateO(self); 25049 25050 } 25051 25052 25053 void hasBoolSmallArrayGT(void) { 25054 25055 bool r; 25056 smallArrayt *self = allocG(rtSmallArrayt); 25057 25058 r = hasBoolSmallArrayG(self, true); 25059 ck_assert(!r); 25060 terminateO(self); 25061 25062 } 25063 25064 25065 void hasDoubleSmallArrayGT(void) { 25066 25067 bool r; 25068 smallArrayt *self = allocG(rtSmallArrayt); 25069 25070 r = hasDoubleSmallArrayG(self, 1); 25071 ck_assert(!r); 25072 terminateO(self); 25073 25074 } 25075 25076 25077 void hasIntSmallArrayGT(void) { 25078 25079 bool r; 25080 smallArrayt *self = allocG(rtSmallArrayt); 25081 25082 r = hasIntSmallArrayG(self, 1); 25083 ck_assert(!r); 25084 terminateO(self); 25085 25086 } 25087 25088 25089 void hasSSmallArrayGT(void) { 25090 25091 bool r; 25092 smallArrayt *self = allocG(rtSmallArrayt); 25093 25094 r = hasSSmallArrayG(self, null); 25095 ck_assert(!r); 25096 terminateO(self); 25097 25098 } 25099 25100 25101 void hasCharSmallArrayGT(void) { 25102 25103 bool r; 25104 smallArrayt *self = allocG(rtSmallArrayt); 25105 25106 r = hasCharSmallArrayG(self, ' '); 25107 ck_assert(!r); 25108 terminateO(self); 25109 25110 } 25111 25112 25113 void hasDictSmallArrayGT(void) { 25114 25115 bool r; 25116 smallArrayt *self = allocG(rtSmallArrayt); 25117 25118 r = hasDictSmallArrayG(self, null); 25119 ck_assert(!r); 25120 terminateO(self); 25121 25122 } 25123 25124 25125 void hasArraySmallArrayGT(void) { 25126 25127 bool r; 25128 smallArrayt *self = allocG(rtSmallArrayt); 25129 25130 r = hasArraySmallArrayG(self, null); 25131 ck_assert(!r); 25132 terminateO(self); 25133 25134 } 25135 25136 25137 void hasArraycSmallArrayGT(void) { 25138 25139 bool r; 25140 smallArrayt *self = allocG(rtSmallArrayt); 25141 25142 r = hasArraycSmallArrayG(self, null); 25143 ck_assert(!r); 25144 terminateO(self); 25145 25146 } 25147 25148 25149 void hasCArraycSmallArrayGT(void) { 25150 25151 bool r; 25152 smallArrayt *self = allocG(rtSmallArrayt); 25153 25154 r = hasCArraycSmallArrayG(self, null); 25155 ck_assert(!r); 25156 terminateO(self); 25157 25158 } 25159 25160 25161 void hasSmallBoolSmallArrayGT(void) { 25162 25163 bool r; 25164 smallArrayt *self = allocG(rtSmallArrayt); 25165 25166 r = hasSmallBoolSmallArrayG(self, null); 25167 ck_assert(!r); 25168 terminateO(self); 25169 25170 } 25171 25172 25173 void hasSmallBytesSmallArrayGT(void) { 25174 25175 bool r; 25176 smallArrayt *self = allocG(rtSmallArrayt); 25177 25178 r = hasSmallBytesSmallArrayG(self, null); 25179 ck_assert(!r); 25180 terminateO(self); 25181 25182 } 25183 25184 25185 void hasSmallDoubleSmallArrayGT(void) { 25186 25187 bool r; 25188 smallArrayt *self = allocG(rtSmallArrayt); 25189 25190 r = hasSmallDoubleSmallArrayG(self, null); 25191 ck_assert(!r); 25192 terminateO(self); 25193 25194 } 25195 25196 25197 void hasSmallIntSmallArrayGT(void) { 25198 25199 bool r; 25200 smallArrayt *self = allocG(rtSmallArrayt); 25201 25202 r = hasSmallIntSmallArrayG(self, null); 25203 ck_assert(!r); 25204 terminateO(self); 25205 25206 } 25207 25208 25209 void hasSmallJsonSmallArrayGT(void) { 25210 25211 bool r; 25212 smallArrayt *self = allocG(rtSmallArrayt); 25213 25214 r = hasSmallJsonSmallArrayG(self, null); 25215 ck_assert(!r); 25216 terminateO(self); 25217 25218 } 25219 25220 25221 void hasSmallStringSmallArrayGT(void) { 25222 25223 bool r; 25224 smallArrayt *self = allocG(rtSmallArrayt); 25225 25226 r = hasSmallStringSmallArrayG(self, null); 25227 ck_assert(!r); 25228 terminateO(self); 25229 25230 } 25231 25232 25233 void hasSmallContainerSmallArrayGT(void) { 25234 25235 bool r; 25236 smallArrayt *self = allocG(rtSmallArrayt); 25237 25238 r = hasSmallContainerSmallArrayG(self, null); 25239 ck_assert(!r); 25240 terminateO(self); 25241 25242 } 25243 25244 25245 void indexOfSmallArrayGT(void) { 25246 25247 ssize_t r; 25248 smallArrayt *self = allocG(rtSmallArrayt); 25249 25250 r = indexOfSmallArrayG(self, null); 25251 ck_assert_int_eq(r, -1); 25252 terminateO(self); 25253 25254 } 25255 25256 25257 void indexOfUndefinedSmallArrayGT(void) { 25258 25259 ssize_t r; 25260 smallArrayt *self = allocG(rtSmallArrayt); 25261 25262 r = indexOfUndefinedSmallArrayG(self, null); 25263 ck_assert_int_eq(r, -1); 25264 terminateO(self); 25265 25266 } 25267 25268 25269 void indexOfBoolSmallArrayGT(void) { 25270 25271 ssize_t r; 25272 smallArrayt *self = allocG(rtSmallArrayt); 25273 25274 r = indexOfBoolSmallArrayG(self, false); 25275 ck_assert_int_eq(r, -1); 25276 terminateO(self); 25277 25278 } 25279 25280 25281 void indexOfDoubleSmallArrayGT(void) { 25282 25283 ssize_t r; 25284 smallArrayt *self = allocG(rtSmallArrayt); 25285 25286 r = indexOfDoubleSmallArrayG(self, 0); 25287 ck_assert_int_eq(r, -1); 25288 terminateO(self); 25289 25290 } 25291 25292 25293 void indexOfIntSmallArrayGT(void) { 25294 25295 ssize_t r; 25296 smallArrayt *self = allocG(rtSmallArrayt); 25297 25298 r = indexOfIntSmallArrayG(self, 0); 25299 ck_assert_int_eq(r, -1); 25300 terminateO(self); 25301 25302 } 25303 25304 25305 void indexOfSSmallArrayGT(void) { 25306 25307 ssize_t r; 25308 smallArrayt *self = allocG(rtSmallArrayt); 25309 25310 r = indexOfSSmallArrayG(self, null); 25311 ck_assert_int_eq(r, -1); 25312 terminateO(self); 25313 25314 } 25315 25316 25317 void indexOfCharSmallArrayGT(void) { 25318 25319 ssize_t r; 25320 smallArrayt *self = allocG(rtSmallArrayt); 25321 25322 r = indexOfCharSmallArrayG(self, ' '); 25323 ck_assert_int_eq(r, -1); 25324 terminateO(self); 25325 25326 } 25327 25328 25329 void indexOfDictSmallArrayGT(void) { 25330 25331 ssize_t r; 25332 smallArrayt *self = allocG(rtSmallArrayt); 25333 25334 r = indexOfDictSmallArrayG(self, null); 25335 ck_assert_int_eq(r, -1); 25336 terminateO(self); 25337 25338 } 25339 25340 25341 void indexOfArraySmallArrayGT(void) { 25342 25343 ssize_t r; 25344 smallArrayt *self = allocG(rtSmallArrayt); 25345 25346 r = indexOfArraySmallArrayG(self, null); 25347 ck_assert_int_eq(r, -1); 25348 terminateO(self); 25349 25350 } 25351 25352 25353 void indexOfArraycSmallArrayGT(void) { 25354 25355 ssize_t r; 25356 smallArrayt *self = allocG(rtSmallArrayt); 25357 25358 r = indexOfArraycSmallArrayG(self, null); 25359 ck_assert_int_eq(r, -1); 25360 terminateO(self); 25361 25362 } 25363 25364 25365 void indexOfCArraycSmallArrayGT(void) { 25366 25367 ssize_t r; 25368 smallArrayt *self = allocG(rtSmallArrayt); 25369 25370 r = indexOfCArraycSmallArrayG(self, null); 25371 ck_assert_int_eq(r, -1); 25372 terminateO(self); 25373 25374 } 25375 25376 25377 void indexOfSmallBoolSmallArrayGT(void) { 25378 25379 ssize_t r; 25380 smallArrayt *self = allocG(rtSmallArrayt); 25381 25382 r = indexOfSmallBoolSmallArrayG(self, null); 25383 ck_assert_int_eq(r, -1); 25384 terminateO(self); 25385 25386 } 25387 25388 25389 void indexOfSmallBytesSmallArrayGT(void) { 25390 25391 ssize_t r; 25392 smallArrayt *self = allocG(rtSmallArrayt); 25393 25394 r = indexOfSmallBytesSmallArrayG(self, null); 25395 ck_assert_int_eq(r, -1); 25396 terminateO(self); 25397 25398 } 25399 25400 25401 void indexOfSmallDoubleSmallArrayGT(void) { 25402 25403 ssize_t r; 25404 smallArrayt *self = allocG(rtSmallArrayt); 25405 25406 r = indexOfSmallDoubleSmallArrayG(self, null); 25407 ck_assert_int_eq(r, -1); 25408 terminateO(self); 25409 25410 } 25411 25412 25413 void indexOfSmallIntSmallArrayGT(void) { 25414 25415 ssize_t r; 25416 smallArrayt *self = allocG(rtSmallArrayt); 25417 25418 r = indexOfSmallIntSmallArrayG(self, null); 25419 ck_assert_int_eq(r, -1); 25420 terminateO(self); 25421 25422 } 25423 25424 25425 void indexOfSmallJsonSmallArrayGT(void) { 25426 25427 ssize_t r; 25428 smallArrayt *self = allocG(rtSmallArrayt); 25429 25430 r = indexOfSmallJsonSmallArrayG(self, null); 25431 ck_assert_int_eq(r, -1); 25432 terminateO(self); 25433 25434 } 25435 25436 25437 void indexOfSmallStringSmallArrayGT(void) { 25438 25439 ssize_t r; 25440 smallArrayt *self = allocG(rtSmallArrayt); 25441 25442 r = indexOfSmallStringSmallArrayG(self, null); 25443 ck_assert_int_eq(r, -1); 25444 terminateO(self); 25445 25446 } 25447 25448 25449 void indexOfSmallContainerSmallArrayGT(void) { 25450 25451 ssize_t r; 25452 smallArrayt *self = allocG(rtSmallArrayt); 25453 25454 r = indexOfSmallContainerSmallArrayG(self, null); 25455 ck_assert_int_eq(r, -1); 25456 terminateO(self); 25457 25458 } 25459 25460 25461 void binarySearchSmallArrayGT(void) { 25462 25463 ssize_t r; 25464 smallArrayt *self = allocG(rtSmallArrayt); 25465 25466 r = binarySearchSmallArrayG(self, null); 25467 ck_assert_int_eq(r, -1); 25468 terminateO(self); 25469 25470 } 25471 25472 25473 void binarySearchUndefinedSmallArrayGT(void) { 25474 25475 ssize_t r; 25476 smallArrayt *self = allocG(rtSmallArrayt); 25477 25478 r = binarySearchUndefinedSmallArrayG(self, null); 25479 ck_assert_int_eq(r, -1); 25480 terminateO(self); 25481 25482 } 25483 25484 25485 void binarySearchBoolSmallArrayGT(void) { 25486 25487 ssize_t r; 25488 smallArrayt *self = allocG(rtSmallArrayt); 25489 25490 r = binarySearchBoolSmallArrayG(self, false); 25491 ck_assert_int_eq(r, -1); 25492 terminateO(self); 25493 25494 } 25495 25496 25497 void binarySearchDoubleSmallArrayGT(void) { 25498 25499 ssize_t r; 25500 smallArrayt *self = allocG(rtSmallArrayt); 25501 25502 r = binarySearchDoubleSmallArrayG(self, 0); 25503 ck_assert_int_eq(r, -1); 25504 terminateO(self); 25505 25506 } 25507 25508 25509 void binarySearchIntSmallArrayGT(void) { 25510 25511 ssize_t r; 25512 smallArrayt *self = allocG(rtSmallArrayt); 25513 25514 r = binarySearchIntSmallArrayG(self, 0); 25515 ck_assert_int_eq(r, -1); 25516 terminateO(self); 25517 25518 } 25519 25520 25521 void binarySearchSSmallArrayGT(void) { 25522 25523 ssize_t r; 25524 smallArrayt *self = allocG(rtSmallArrayt); 25525 25526 r = binarySearchSSmallArrayG(self, null); 25527 ck_assert_int_eq(r, -1); 25528 terminateO(self); 25529 25530 } 25531 25532 25533 void binarySearchCharSmallArrayGT(void) { 25534 25535 ssize_t r; 25536 smallArrayt *self = allocG(rtSmallArrayt); 25537 25538 r = binarySearchCharSmallArrayG(self, ' '); 25539 ck_assert_int_eq(r, -1); 25540 terminateO(self); 25541 25542 } 25543 25544 25545 void binarySearchDictSmallArrayGT(void) { 25546 25547 ssize_t r; 25548 smallArrayt *self = allocG(rtSmallArrayt); 25549 25550 r = binarySearchDictSmallArrayG(self, null); 25551 ck_assert_int_eq(r, -1); 25552 terminateO(self); 25553 25554 } 25555 25556 25557 void binarySearchArraySmallArrayGT(void) { 25558 25559 ssize_t r; 25560 smallArrayt *self = allocG(rtSmallArrayt); 25561 25562 r = binarySearchArraySmallArrayG(self, null); 25563 ck_assert_int_eq(r, -1); 25564 terminateO(self); 25565 25566 } 25567 25568 25569 void binarySearchArraycSmallArrayGT(void) { 25570 25571 ssize_t r; 25572 smallArrayt *self = allocG(rtSmallArrayt); 25573 25574 r = binarySearchArraycSmallArrayG(self, null); 25575 ck_assert_int_eq(r, -1); 25576 terminateO(self); 25577 25578 } 25579 25580 25581 void binarySearchCArraycSmallArrayGT(void) { 25582 25583 ssize_t r; 25584 smallArrayt *self = allocG(rtSmallArrayt); 25585 25586 r = binarySearchCArraycSmallArrayG(self, null); 25587 ck_assert_int_eq(r, -1); 25588 terminateO(self); 25589 25590 } 25591 25592 25593 void binarySearchSmallBoolSmallArrayGT(void) { 25594 25595 ssize_t r; 25596 smallArrayt *self = allocG(rtSmallArrayt); 25597 25598 r = binarySearchSmallBoolSmallArrayG(self, null); 25599 ck_assert_int_eq(r, -1); 25600 terminateO(self); 25601 25602 } 25603 25604 25605 void binarySearchSmallBytesSmallArrayGT(void) { 25606 25607 ssize_t r; 25608 smallArrayt *self = allocG(rtSmallArrayt); 25609 25610 r = binarySearchSmallBytesSmallArrayG(self, null); 25611 ck_assert_int_eq(r, -1); 25612 terminateO(self); 25613 25614 } 25615 25616 25617 void binarySearchSmallDoubleSmallArrayGT(void) { 25618 25619 ssize_t r; 25620 smallArrayt *self = allocG(rtSmallArrayt); 25621 25622 r = binarySearchSmallDoubleSmallArrayG(self, null); 25623 ck_assert_int_eq(r, -1); 25624 terminateO(self); 25625 25626 } 25627 25628 25629 void binarySearchSmallIntSmallArrayGT(void) { 25630 25631 ssize_t r; 25632 smallArrayt *self = allocG(rtSmallArrayt); 25633 25634 r = binarySearchSmallIntSmallArrayG(self, null); 25635 ck_assert_int_eq(r, -1); 25636 terminateO(self); 25637 25638 } 25639 25640 25641 void binarySearchSmallJsonSmallArrayGT(void) { 25642 25643 ssize_t r; 25644 smallArrayt *self = allocG(rtSmallArrayt); 25645 25646 r = binarySearchSmallJsonSmallArrayG(self, null); 25647 ck_assert_int_eq(r, -1); 25648 terminateO(self); 25649 25650 } 25651 25652 25653 void binarySearchSmallStringSmallArrayGT(void) { 25654 25655 ssize_t r; 25656 smallArrayt *self = allocG(rtSmallArrayt); 25657 25658 r = binarySearchSmallStringSmallArrayG(self, null); 25659 ck_assert_int_eq(r, -1); 25660 terminateO(self); 25661 25662 } 25663 25664 25665 void binarySearchSmallContainerSmallArrayGT(void) { 25666 25667 ssize_t r; 25668 smallArrayt *self = allocG(rtSmallArrayt); 25669 25670 r = binarySearchSmallContainerSmallArrayG(self, null); 25671 ck_assert_int_eq(r, -1); 25672 terminateO(self); 25673 25674 } 25675 25676 25677 void uniqSmallArrayGT(void) { 25678 25679 smallArrayt* r; 25680 smallArrayt *self = allocG(rtSmallArrayt); 25681 25682 self->f->pushUndefined(self); 25683 self->f->pushBool(self, true); 25684 self->f->pushNFreeDict(self, allocSmallDict()); 25685 self->f->pushDouble(self, 1); 25686 self->f->pushInt(self, 2); 25687 self->f->pushS(self, ""); 25688 self->f->pushNFreeArray(self, allocSmallArray()); 25689 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 25690 self->f->pushUndefined(self); 25691 self->f->pushBool(self, true); 25692 self->f->pushNFreeDict(self, allocSmallDict()); 25693 self->f->pushDouble(self, 1); 25694 self->f->pushInt(self, 2); 25695 self->f->pushS(self, ""); 25696 self->f->pushNFreeArray(self, allocSmallArray()); 25697 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 25698 r = uniqSmallArrayG(self, 0); 25699 ck_assert_ptr_ne(r, NULL); 25700 char *s = toStringO(r); 25701 ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"\",[],[0x71,0x77,0x65,0x00]]"); 25702 free(s); 25703 terminateO(self); 25704 25705 } 25706 25707 25708 void icHasSmallArrayGT(void) { 25709 25710 bool r; 25711 smallArrayt *self = allocG(rtSmallArrayt); 25712 25713 r = icHasSmallArrayG(self, null); 25714 ck_assert(!r); 25715 terminateO(self); 25716 25717 } 25718 25719 25720 void icHasSSmallArrayGT(void) { 25721 25722 bool r; 25723 smallArrayt *self = allocG(rtSmallArrayt); 25724 25725 r = icHasSSmallArrayG(self, null); 25726 ck_assert(!r); 25727 terminateO(self); 25728 25729 } 25730 25731 25732 void icHasCharSmallArrayGT(void) { 25733 25734 bool r; 25735 smallArrayt *self = allocG(rtSmallArrayt); 25736 25737 r = icHasCharSmallArrayG(self, 'a'); 25738 ck_assert(!r); 25739 terminateO(self); 25740 25741 } 25742 25743 25744 void icHasDictSmallArrayGT(void) { 25745 25746 bool r; 25747 smallArrayt *self = allocG(rtSmallArrayt); 25748 25749 r = icHasDictSmallArrayG(self, null); 25750 ck_assert(!r); 25751 terminateO(self); 25752 25753 } 25754 25755 25756 void icHasArraySmallArrayGT(void) { 25757 25758 bool r; 25759 smallArrayt *self = allocG(rtSmallArrayt); 25760 25761 r = icHasArraySmallArrayG(self, null); 25762 ck_assert(!r); 25763 terminateO(self); 25764 25765 } 25766 25767 25768 void icHasArraycSmallArrayGT(void) { 25769 25770 bool r; 25771 smallArrayt *self = allocG(rtSmallArrayt); 25772 25773 r = icHasArraycSmallArrayG(self, null); 25774 ck_assert(!r); 25775 terminateO(self); 25776 25777 } 25778 25779 25780 void icHasCArraycSmallArrayGT(void) { 25781 25782 bool r; 25783 smallArrayt *self = allocG(rtSmallArrayt); 25784 25785 r = icHasCArraycSmallArrayG(self, null); 25786 ck_assert(!r); 25787 terminateO(self); 25788 25789 } 25790 25791 25792 void icHasSmallJsonSmallArrayGT(void) { 25793 25794 bool r; 25795 smallArrayt *self = allocG(rtSmallArrayt); 25796 25797 r = icHasSmallJsonSmallArrayG(self, null); 25798 ck_assert(!r); 25799 terminateO(self); 25800 25801 } 25802 25803 25804 void icHasSmallStringSmallArrayGT(void) { 25805 25806 bool r; 25807 smallArrayt *self = allocG(rtSmallArrayt); 25808 25809 r = icHasSmallStringSmallArrayG(self, null); 25810 ck_assert(!r); 25811 terminateO(self); 25812 25813 } 25814 25815 25816 void icIndexOfSmallArrayGT(void) { 25817 25818 ssize_t r; 25819 smallArrayt *self = allocG(rtSmallArrayt); 25820 25821 r = icIndexOfSmallArrayG(self, null); 25822 ck_assert_int_eq(r, -1); 25823 terminateO(self); 25824 25825 } 25826 25827 25828 void icIndexOfSSmallArrayGT(void) { 25829 25830 ssize_t r; 25831 smallArrayt *self = allocG(rtSmallArrayt); 25832 25833 r = icIndexOfSSmallArrayG(self, null); 25834 ck_assert_int_eq(r, -1); 25835 terminateO(self); 25836 25837 } 25838 25839 25840 void icIndexOfCharSmallArrayGT(void) { 25841 25842 ssize_t r; 25843 smallArrayt *self = allocG(rtSmallArrayt); 25844 25845 r = icIndexOfCharSmallArrayG(self, 'A'); 25846 ck_assert_int_eq(r, -1); 25847 terminateO(self); 25848 25849 } 25850 25851 25852 void icIndexOfDictSmallArrayGT(void) { 25853 25854 ssize_t r; 25855 smallArrayt *self = allocG(rtSmallArrayt); 25856 25857 r = icIndexOfDictSmallArrayG(self, null); 25858 ck_assert_int_eq(r, -1); 25859 terminateO(self); 25860 25861 } 25862 25863 25864 void icIndexOfArraySmallArrayGT(void) { 25865 25866 ssize_t r; 25867 smallArrayt *self = allocG(rtSmallArrayt); 25868 25869 r = icIndexOfArraySmallArrayG(self, null); 25870 ck_assert_int_eq(r, -1); 25871 terminateO(self); 25872 25873 } 25874 25875 25876 void icIndexOfArraycSmallArrayGT(void) { 25877 25878 ssize_t r; 25879 smallArrayt *self = allocG(rtSmallArrayt); 25880 25881 r = icIndexOfArraycSmallArrayG(self, null); 25882 ck_assert_int_eq(r, -1); 25883 terminateO(self); 25884 25885 } 25886 25887 25888 void icIndexOfCArraycSmallArrayGT(void) { 25889 25890 ssize_t r; 25891 smallArrayt *self = allocG(rtSmallArrayt); 25892 25893 r = icIndexOfCArraycSmallArrayG(self, null); 25894 ck_assert_int_eq(r, -1); 25895 terminateO(self); 25896 25897 } 25898 25899 25900 void icIndexOfSmallJsonSmallArrayGT(void) { 25901 25902 ssize_t r; 25903 smallArrayt *self = allocG(rtSmallArrayt); 25904 25905 r = icIndexOfSmallJsonSmallArrayG(self, null); 25906 ck_assert_int_eq(r, -1); 25907 terminateO(self); 25908 25909 } 25910 25911 25912 void icIndexOfSmallStringSmallArrayGT(void) { 25913 25914 ssize_t r; 25915 smallArrayt *self = allocG(rtSmallArrayt); 25916 25917 r = icIndexOfSmallStringSmallArrayG(self, null); 25918 ck_assert_int_eq(r, -1); 25919 terminateO(self); 25920 25921 } 25922 25923 25924 void icBinarySearchSmallArrayGT(void) { 25925 25926 ssize_t r; 25927 smallArrayt *self = allocG(rtSmallArrayt); 25928 25929 r = icBinarySearchSmallArrayG(self, null); 25930 ck_assert_int_eq(r, -1); 25931 terminateO(self); 25932 25933 } 25934 25935 25936 void icBinarySearchSSmallArrayGT(void) { 25937 25938 ssize_t r; 25939 smallArrayt *self = allocG(rtSmallArrayt); 25940 25941 r = icBinarySearchSSmallArrayG(self, null); 25942 ck_assert_int_eq(r, -1); 25943 terminateO(self); 25944 25945 } 25946 25947 25948 void icBinarySearchCharSmallArrayGT(void) { 25949 25950 ssize_t r; 25951 smallArrayt *self = allocG(rtSmallArrayt); 25952 25953 r = icBinarySearchCharSmallArrayG(self, 'a'); 25954 ck_assert_int_eq(r, -1); 25955 terminateO(self); 25956 25957 } 25958 25959 25960 void icBinarySearchDictSmallArrayGT(void) { 25961 25962 ssize_t r; 25963 smallArrayt *self = allocG(rtSmallArrayt); 25964 25965 r = icBinarySearchDictSmallArrayG(self, null); 25966 ck_assert_int_eq(r, -1); 25967 terminateO(self); 25968 25969 } 25970 25971 25972 void icBinarySearchArraySmallArrayGT(void) { 25973 25974 ssize_t r; 25975 smallArrayt *self = allocG(rtSmallArrayt); 25976 25977 r = icBinarySearchArraySmallArrayG(self, null); 25978 ck_assert_int_eq(r, -1); 25979 terminateO(self); 25980 25981 } 25982 25983 25984 void icBinarySearchArraycSmallArrayGT(void) { 25985 25986 ssize_t r; 25987 smallArrayt *self = allocG(rtSmallArrayt); 25988 25989 r = icBinarySearchArraycSmallArrayG(self, null); 25990 ck_assert_int_eq(r, -1); 25991 terminateO(self); 25992 25993 } 25994 25995 25996 void icBinarySearchCArraycSmallArrayGT(void) { 25997 25998 ssize_t r; 25999 smallArrayt *self = allocG(rtSmallArrayt); 26000 26001 r = icBinarySearchCArraycSmallArrayG(self, null); 26002 ck_assert_int_eq(r, -1); 26003 terminateO(self); 26004 26005 } 26006 26007 26008 void icBinarySearchSmallJsonSmallArrayGT(void) { 26009 26010 ssize_t r; 26011 smallArrayt *self = allocG(rtSmallArrayt); 26012 26013 r = icBinarySearchSmallJsonSmallArrayG(self, null); 26014 ck_assert_int_eq(r, -1); 26015 terminateO(self); 26016 26017 } 26018 26019 26020 void icBinarySearchSmallStringSmallArrayGT(void) { 26021 26022 ssize_t r; 26023 smallArrayt *self = allocG(rtSmallArrayt); 26024 26025 r = icBinarySearchSmallStringSmallArrayG(self, null); 26026 ck_assert_int_eq(r, -1); 26027 terminateO(self); 26028 26029 } 26030 26031 26032 void icUniqSmallArrayGT(void) { 26033 26034 smallArrayt* r; 26035 smallArrayt *self = allocG(rtSmallArrayt); 26036 26037 self->f->pushUndefined(self); 26038 self->f->pushBool(self, true); 26039 self->f->pushNFreeDict(self, allocSmallDict()); 26040 self->f->pushDouble(self, 1); 26041 self->f->pushInt(self, 2); 26042 self->f->pushS(self, "ASD"); 26043 self->f->pushNFreeArray(self, allocSmallArray()); 26044 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 26045 self->f->pushUndefined(self); 26046 self->f->pushBool(self, true); 26047 self->f->pushNFreeDict(self, allocSmallDict()); 26048 self->f->pushDouble(self, 1); 26049 self->f->pushInt(self, 2); 26050 self->f->pushS(self, "asd"); 26051 self->f->pushNFreeArray(self, allocSmallArray()); 26052 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 26053 r = icUniqSmallArrayG(self, 0); 26054 ck_assert_ptr_ne(r, NULL); 26055 char *s = toStringO(r); 26056 ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"ASD\",[],[0x71,0x77,0x65,0x00]]"); 26057 free(s); 26058 terminateO(self); 26059 26060 } 26061 26062 26063 void compactSmallArrayGT(void) { 26064 26065 smallArrayt* r; 26066 smallArrayt *self = allocG(rtSmallArrayt); 26067 26068 self->f->pushUndefined(self); 26069 // null element 26070 self->f->pushUndefined(self); 26071 delElemO(self, 1); 26072 self->f->pushBool(self, true); 26073 createSmallContainer(c); 26074 self->f->pushSmallContainer(self, &c); 26075 // empty dict 26076 createSmallDict(d); 26077 self->f->pushDict(self, &d); 26078 resetO(&d); 26079 (&d)->f->setInt(&d, "a", 1); 26080 self->f->pushDict(self, &d); 26081 self->f->pushDouble(self, 2); 26082 self->f->pushInt(self, 5); 26083 self->f->pushS(self, " "); 26084 self->f->pushS(self, "asd"); 26085 // empty Array 26086 createSmallArray(a); 26087 self->f->pushArray(self, &a); 26088 resetO(&a); 26089 (&a)->f->pushInt(&a, 1); 26090 self->f->pushArray(self, &a); 26091 // empty bytes 26092 createSmallBytes(b); 26093 self->f->pushSmallBytes(self, &b); 26094 smallBytest *B = allocSmallBytes("asd", 4); 26095 self->f->pushNFreeSmallBytes(self, B); 26096 r = compactSmallArrayG(self); 26097 ck_assert_ptr_ne(r, NULL); 26098 ck_assert_int_eq(lenO(r), 8); 26099 char *s = toStringO(r); 26100 ck_assert_str_eq(s, "[true,\"<data container>\",{\"a\":1},2.000000e+00,5,\"asd\",[1],[0x61,0x73,0x64,0x00]]"); 26101 free(s); 26102 terminateO(self); 26103 26104 } 26105 26106 26107 void emptySmallArrayGT(void) { 26108 26109 smallArrayt* r; 26110 smallArrayt *self = allocG(rtSmallArrayt); 26111 26112 self->f->pushInt(self, 1); 26113 r = emptySmallArrayG(self); 26114 ck_assert_ptr_ne(r, null); 26115 char *s = toStringO(r); 26116 ck_assert_str_eq(s, "[]"); 26117 free(s); 26118 terminateO(self); 26119 26120 } 26121 26122 26123 void isEmptySmallArrayGT(void) { 26124 26125 bool r; 26126 smallArrayt *self = allocG(rtSmallArrayt); 26127 26128 r = isEmptySmallArrayG(self); 26129 ck_assert(r); 26130 terminateO(self); 26131 26132 } 26133 26134 26135 void isBlankSmallArrayGT(void) { 26136 26137 bool r; 26138 smallArrayt *self = allocG(rtSmallArrayt); 26139 26140 r = isBlankSmallArrayG(self); 26141 ck_assert(r); 26142 terminateO(self); 26143 26144 } 26145 26146 26147 void joinSmallArrayGT(void) { 26148 26149 smallStringt* r; 26150 smallArrayt *self = allocG(rtSmallArrayt); 26151 26152 self->f->pushS(self, "a"); 26153 self->f->pushS(self, "b"); 26154 r = joinSmallArrayG(self, "|"); 26155 ck_assert_ptr_ne(r, null); 26156 char *s = toStringO(r); 26157 ck_assert_str_eq(s, "a|b"); 26158 free(s); 26159 terminateO(r); 26160 terminateO(self); 26161 26162 } 26163 26164 26165 void joinCharSmallArrayGT(void) { 26166 26167 smallStringt* r; 26168 smallArrayt *self = allocG(rtSmallArrayt); 26169 26170 self->f->pushS(self, "a"); 26171 self->f->pushS(self, "b"); 26172 r = joinCharSmallArrayG(self, '|'); 26173 ck_assert_ptr_ne(r, null); 26174 char *s = toStringO(r); 26175 ck_assert_str_eq(s, "a|b"); 26176 free(s); 26177 terminateO(r); 26178 terminateO(self); 26179 26180 } 26181 26182 26183 void joinSmallJsonSmallArrayGT(void) { 26184 26185 smallStringt* r; 26186 smallArrayt *self = allocG(rtSmallArrayt); 26187 26188 r = joinSmallJsonSmallArrayG(self, null); 26189 ck_assert_ptr_eq(r, null); 26190 terminateO(self); 26191 26192 } 26193 26194 26195 void joinSmallStringSmallArrayGT(void) { 26196 26197 smallStringt* r; 26198 smallArrayt *self = allocG(rtSmallArrayt); 26199 26200 r = joinSmallStringSmallArrayG(self, null); 26201 ck_assert_ptr_eq(r, null); 26202 terminateO(self); 26203 26204 } 26205 26206 26207 void joinSSmallArrayGT(void) { 26208 26209 char* r; 26210 smallArrayt *self = allocG(rtSmallArrayt); 26211 26212 r = joinSSmallArrayG(self, null); 26213 ck_assert_ptr_eq(r, null); 26214 terminateO(self); 26215 26216 } 26217 26218 26219 void joinCharSSmallArrayGT(void) { 26220 26221 char* r; 26222 smallArrayt *self = allocG(rtSmallArrayt); 26223 26224 r = joinCharSSmallArrayG(self, '#'); 26225 ck_assert_ptr_eq(r, null); 26226 terminateO(self); 26227 26228 } 26229 26230 26231 void joinSmallJsonSSmallArrayGT(void) { 26232 26233 char* r; 26234 smallArrayt *self = allocG(rtSmallArrayt); 26235 26236 r = joinSmallJsonSSmallArrayG(self, null); 26237 ck_assert_ptr_eq(r, null); 26238 terminateO(self); 26239 26240 } 26241 26242 26243 void joinSmallStringSSmallArrayGT(void) { 26244 26245 char* r; 26246 smallArrayt *self = allocG(rtSmallArrayt); 26247 26248 r = joinSmallStringSSmallArrayG(self, null); 26249 ck_assert_ptr_eq(r, null); 26250 terminateO(self); 26251 26252 } 26253 26254 26255 void zipSmallArrayGT(void) { 26256 26257 smallArrayt* r; 26258 smallArrayt *self = allocG(rtSmallArrayt); 26259 smallArrayt *array1 = allocSmallArray(); 26260 smallArrayt *array2 = allocSmallArray(); 26261 26262 // zip arrays 26263 // add an element to self 26264 // array1 has 2 elements 26265 // array2 has 3 elements 26266 // only 2 elements are zipped 26267 self->f->pushS(self, "qwe"); 26268 array1->f->pushS(array1, "a"); 26269 array1->f->pushS(array1, "b"); 26270 array2->f->pushInt(array2, 1); 26271 array2->f->pushInt(array2, 2); 26272 array2->f->pushInt(array2, 3); 26273 r = zipSmallArrayG(self, array1, array2); 26274 ck_assert_ptr_ne(r, NULL); 26275 char *s = toStringO(r); 26276 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 26277 free(s); 26278 // delete the element not in self 26279 delElemO(array2, 2); 26280 terminateO(self); 26281 smashO(array1); 26282 smashO(array2); 26283 26284 } 26285 26286 26287 void zipSmallJsonSmallArrayGT(void) { 26288 26289 smallArrayt* r; 26290 smallArrayt *self = allocG(rtSmallArrayt); 26291 smallArrayt *array1 = allocSmallArray(); 26292 smallJsont *array2 = allocSmallJson(); 26293 26294 // zip arrays 26295 // add an element to self 26296 // array1 has 2 elements 26297 // array2 has 3 elements 26298 // only 2 elements are zipped 26299 self->f->pushS(self, "qwe"); 26300 array1->f->pushS(array1, "a"); 26301 array1->f->pushS(array1, "b"); 26302 array2->f->pushInt(array2, 1); 26303 array2->f->pushInt(array2, 2); 26304 array2->f->pushInt(array2, 3); 26305 r = zipSmallJsonSmallArrayG(self, array1, array2); 26306 ck_assert_ptr_ne(r, NULL); 26307 char *s = toStringO(r); 26308 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 26309 free(s); 26310 // delete the element not in self 26311 delElemIndexO(array2, 2); 26312 terminateO(self); 26313 smashO(array1); 26314 smashO(array2); 26315 26316 } 26317 26318 26319 void zipSmallJsonSmallArraySmallArrayGT(void) { 26320 26321 smallArrayt* r; 26322 smallArrayt *self = allocG(rtSmallArrayt); 26323 smallJsont *array1 = allocSmallJson(); 26324 smallArrayt *array2 = allocSmallArray(); 26325 26326 // zip arrays 26327 // add an element to self 26328 // array1 has 2 elements 26329 // array2 has 3 elements 26330 // only 2 elements are zipped 26331 self->f->pushS(self, "qwe"); 26332 array1->f->pushS(array1, "a"); 26333 array1->f->pushS(array1, "b"); 26334 array2->f->pushInt(array2, 1); 26335 array2->f->pushInt(array2, 2); 26336 array2->f->pushInt(array2, 3); 26337 r = zipSmallJsonSmallArraySmallArrayG(self, array1, array2); 26338 ck_assert_ptr_ne(r, NULL); 26339 char *s = toStringO(r); 26340 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 26341 free(s); 26342 // delete the element not in self 26343 delElemO(array2, 2); 26344 terminateO(self); 26345 smashO(array1); 26346 smashO(array2); 26347 26348 } 26349 26350 26351 void zipSmallJsonSmallJsonSmallArrayGT(void) { 26352 26353 smallArrayt* r; 26354 smallArrayt *self = allocG(rtSmallArrayt); 26355 smallJsont *array1 = allocSmallJson(); 26356 smallJsont *array2 = allocSmallJson(); 26357 26358 // zip arrays 26359 // add an element to self 26360 // array1 has 2 elements 26361 // array2 has 3 elements 26362 // only 2 elements are zipped 26363 self->f->pushS(self, "qwe"); 26364 array1->f->pushS(array1, "a"); 26365 array1->f->pushS(array1, "b"); 26366 array2->f->pushInt(array2, 1); 26367 array2->f->pushInt(array2, 2); 26368 array2->f->pushInt(array2, 3); 26369 r = zipSmallJsonSmallJsonSmallArrayG(self, array1, array2); 26370 ck_assert_ptr_ne(r, NULL); 26371 char *s = toStringO(r); 26372 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 26373 free(s); 26374 // delete the element not in self 26375 delElemIndexO(array2, 2); 26376 terminateO(self); 26377 smashO(array1); 26378 smashO(array2); 26379 26380 } 26381 26382 26383 void zipSmallJsonCharSmallArrayGT(void) { 26384 26385 smallArrayt* r; 26386 smallArrayt *self = allocG(rtSmallArrayt); 26387 smallJsont *array1 = allocSmallJson(); 26388 char **array2; 26389 26390 // zip arrays 26391 // add an element to self 26392 // array1 has 2 elements 26393 // array2 has 3 elements 26394 // only 2 elements are zipped 26395 self->f->pushS(self, "qwe"); 26396 array1->f->pushS(array1, "a"); 26397 array1->f->pushS(array1, "b"); 26398 array2 = listCreateS("1", "2", "3"); 26399 r = zipSmallJsonCharSmallArrayG(self, array1, array2); 26400 ck_assert_ptr_ne(r, NULL); 26401 char *s = toStringO(r); 26402 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26403 free(s); 26404 // delete the element not in self 26405 iListDelElemS(&array2, 2); 26406 terminateO(self); 26407 smashO(array1); 26408 free(array2); 26409 26410 } 26411 26412 26413 void zipSmallJsonCCharSmallArrayGT(void) { 26414 26415 smallArrayt* r; 26416 smallArrayt *self = allocG(rtSmallArrayt); 26417 smallJsont *array1 = allocSmallJson(); 26418 26419 // zip arrays 26420 // add an element to self 26421 // array1 has 2 elements 26422 // array2 has 3 elements 26423 // only 2 elements are zipped 26424 self->f->pushS(self, "qwe"); 26425 array1->f->pushS(array1, "a"); 26426 array1->f->pushS(array1, "b"); 26427 const char *array2[] = {"1", "2", "3", null}; 26428 r = zipSmallJsonCCharSmallArrayG(self, array1, array2); 26429 ck_assert_ptr_ne(r, NULL); 26430 char *s = toStringO(r); 26431 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26432 free(s); 26433 terminateO(self); 26434 smashO(array1); 26435 26436 } 26437 26438 26439 void zipArraySmallArrayGT(void) { 26440 26441 smallArrayt* r; 26442 smallArrayt *self = allocG(rtSmallArrayt); 26443 char** array1; 26444 smallArrayt *array2 = allocSmallArray(); 26445 26446 self->f->pushS(self, "qwe"); 26447 array1 = listCreateS("a", "b"); 26448 array2->f->pushS(array2, "1"); 26449 array2->f->pushS(array2, "2"); 26450 r = zipArraySmallArrayG(self, array1, array2); 26451 ck_assert_ptr_ne(r, NULL); 26452 char *s = toStringO(r); 26453 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26454 free(s); 26455 terminateO(self); 26456 free(array1); 26457 smashO(array2); 26458 26459 } 26460 26461 26462 void zipCArraySmallArrayGT(void) { 26463 26464 smallArrayt* r; 26465 smallArrayt *self = allocG(rtSmallArrayt); 26466 const char* array1[] = {"a", "b", null}; 26467 smallArrayt *array2 = allocSmallArray(); 26468 26469 self->f->pushS(self, "qwe"); 26470 array2->f->pushS(array2, "1"); 26471 array2->f->pushS(array2, "2"); 26472 r = zipCArraySmallArrayG(self, array1, array2); 26473 ck_assert_ptr_ne(r, NULL); 26474 char *s = toStringO(r); 26475 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26476 free(s); 26477 terminateO(self); 26478 smashO(array2); 26479 26480 } 26481 26482 26483 void zipArraySmallJsonSmallArrayGT(void) { 26484 26485 smallArrayt* r; 26486 smallArrayt *self = allocG(rtSmallArrayt); 26487 char** array1; 26488 smallJsont *array2 = allocSmallJson(); 26489 26490 self->f->pushS(self, "qwe"); 26491 array1 = listCreateS("a", "b"); 26492 array2->f->pushS(array2, "1"); 26493 array2->f->pushS(array2, "2"); 26494 r = zipArraySmallJsonSmallArrayG(self, array1, array2); 26495 ck_assert_ptr_ne(r, NULL); 26496 char *s = toStringO(r); 26497 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26498 free(s); 26499 terminateO(self); 26500 free(array1); 26501 smashO(array2); 26502 26503 } 26504 26505 26506 void zipCArraySmallJsonSmallArrayGT(void) { 26507 26508 smallArrayt* r; 26509 smallArrayt *self = allocG(rtSmallArrayt); 26510 const char* array1[] = {"a", "b", null}; 26511 smallJsont *array2 = allocSmallJson(); 26512 26513 self->f->pushS(self, "qwe"); 26514 array2->f->pushS(array2, "1"); 26515 array2->f->pushS(array2, "2"); 26516 r = zipCArraySmallJsonSmallArrayG(self, array1, array2); 26517 ck_assert_ptr_ne(r, NULL); 26518 char *s = toStringO(r); 26519 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26520 free(s); 26521 terminateO(self); 26522 smashO(array2); 26523 26524 } 26525 26526 26527 void zipCharSmallArrayGT(void) { 26528 26529 smallArrayt* r; 26530 smallArrayt *self = allocG(rtSmallArrayt); 26531 smallArrayt *array1 = allocSmallArray(); 26532 char** array2; 26533 26534 self->f->pushS(self, "qwe"); 26535 array1->f->pushS(array1, "a"); 26536 array1->f->pushS(array1, "b"); 26537 array2 = listCreateS("1", "2"); 26538 r = zipCharSmallArrayG(self, array1, array2); 26539 ck_assert_ptr_ne(r, NULL); 26540 char *s = toStringO(r); 26541 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26542 free(s); 26543 terminateO(self); 26544 smashO(array1); 26545 free(array2); 26546 26547 } 26548 26549 26550 void zipCCharSmallArrayGT(void) { 26551 26552 smallArrayt* r; 26553 smallArrayt *self = allocG(rtSmallArrayt); 26554 smallArrayt *array1 = allocSmallArray(); 26555 const char* array2[] = {"1", "2", "3", null}; 26556 26557 self->f->pushS(self, "qwe"); 26558 array1->f->pushS(array1, "a"); 26559 array1->f->pushS(array1, "b"); 26560 r = zipCCharSmallArrayG(self, array1, array2); 26561 ck_assert_ptr_ne(r, NULL); 26562 char *s = toStringO(r); 26563 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26564 free(s); 26565 terminateO(self); 26566 smashO(array1); 26567 26568 } 26569 26570 26571 void zipArrayCharSmallArrayGT(void) { 26572 26573 smallArrayt* r; 26574 smallArrayt *self = allocG(rtSmallArrayt); 26575 char** array1; 26576 char** array2; 26577 26578 self->f->pushS(self, "qwe"); 26579 array1 = listCreateS("a", "b"); 26580 array2 = listCreateS("1", "2"); 26581 r = zipArrayCharSmallArrayG(self, array1, array2); 26582 ck_assert_ptr_ne(r, NULL); 26583 char *s = toStringO(r); 26584 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26585 free(s); 26586 terminateO(self); 26587 free(array1); 26588 free(array2); 26589 26590 } 26591 26592 26593 void zipArrayCCharSmallArrayGT(void) { 26594 26595 smallArrayt* r; 26596 smallArrayt *self = allocG(rtSmallArrayt); 26597 char** array1; 26598 const char* array2[] = {"1", "2", "3", null}; 26599 26600 self->f->pushS(self, "qwe"); 26601 array1 = listCreateS("a", "b"); 26602 r = zipArrayCCharSmallArrayG(self, array1, array2); 26603 ck_assert_ptr_ne(r, NULL); 26604 char *s = toStringO(r); 26605 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26606 free(s); 26607 terminateO(self); 26608 free(array1); 26609 26610 } 26611 26612 26613 void zipCArrayCharSmallArrayGT(void) { 26614 26615 smallArrayt* r; 26616 smallArrayt *self = allocG(rtSmallArrayt); 26617 const char* array1[] = {"a", "b", null}; 26618 char** array2; 26619 26620 self->f->pushS(self, "qwe"); 26621 array2 = listCreateS("1", "2"); 26622 r = zipCArrayCharSmallArrayG(self, array1, array2); 26623 ck_assert_ptr_ne(r, NULL); 26624 char *s = toStringO(r); 26625 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26626 free(s); 26627 terminateO(self); 26628 free(array2); 26629 26630 } 26631 26632 26633 void zipCArrayCCharSmallArrayGT(void) { 26634 26635 smallArrayt* r; 26636 smallArrayt *self = allocG(rtSmallArrayt); 26637 const char* array1[] = {"a", "b", null}; 26638 const char* array2[] = {"1", "2", "3", null}; 26639 26640 self->f->pushS(self, "qwe"); 26641 r = zipCArrayCCharSmallArrayG(self, array1, array2); 26642 ck_assert_ptr_ne(r, NULL); 26643 char *s = toStringO(r); 26644 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26645 free(s); 26646 terminateO(self); 26647 26648 } 26649 26650 26651 void logSmallArrayGT(void) { 26652 26653 smallArrayt *self = allocG(rtSmallArrayt); 26654 26655 self->f->pushS(self, "qwe"); 26656 self->f->pushS(self, "asd"); 26657 delElemO(self, 0); 26658 logSmallArrayG(self); 26659 terminateO(self); 26660 26661 } 26662 26663 26664 void readTextSmallArrayGT(void) { 26665 26666 smallArrayt* r; 26667 smallArrayt *self = allocG(rtSmallArrayt); 26668 26669 r = readTextSmallArrayG(self, "../textTest.null"); 26670 ck_assert_ptr_ne(r, NULL); 26671 char *s = toStringO(r); 26672 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26673 free(s); 26674 terminateO(self); 26675 26676 } 26677 26678 26679 void readTextSmallJsonSmallArrayGT(void) { 26680 26681 smallArrayt* r; 26682 smallArrayt *self = allocG(rtSmallArrayt); 26683 smallJsont *filePath = allocSmallJson(); 26684 26685 // text 26686 setTopSO(filePath, "../textTest.null"); 26687 r = readTextSmallJsonSmallArrayG(self, filePath); 26688 ck_assert_ptr_ne(r, NULL); 26689 char *s = toStringO(r); 26690 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26691 free(s); 26692 terminateO(self); 26693 terminateO(filePath); 26694 26695 } 26696 26697 26698 void readTextSmallStringSmallArrayGT(void) { 26699 26700 smallArrayt* r; 26701 smallArrayt *self = allocG(rtSmallArrayt); 26702 smallStringt *filePath = allocSmallString(""); 26703 26704 // text 26705 setValO(filePath, "../textTest.null"); 26706 r = readTextSmallStringSmallArrayG(self, filePath); 26707 ck_assert_ptr_ne(r, NULL); 26708 char *s = toStringO(r); 26709 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26710 free(s); 26711 terminateO(self); 26712 terminateO(filePath); 26713 26714 } 26715 26716 26717 void readStreamSmallArrayGT(void) { 26718 26719 smallArrayt* r; 26720 smallArrayt *self = allocG(rtSmallArrayt); 26721 FILE *fp; 26722 26723 fp = fopen("../textTest.null", "r"); 26724 r = readStreamSmallArrayG(self, fp); 26725 fclose(fp); 26726 ck_assert_ptr_ne(r, NULL); 26727 char *s = toStringO(r); 26728 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26729 free(s); 26730 terminateO(self); 26731 26732 } 26733 26734 26735 void writeTextSmallArrayGT(void) { 26736 26737 bool r; 26738 smallArrayt *self = allocG(rtSmallArrayt); 26739 26740 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26741 ck_assert_ptr_ne(r2, NULL); 26742 r = writeTextSmallArrayG(self, "../textOutTest.null"); 26743 ck_assert(r); 26744 // check textOutTest.null 26745 emptyO(self); 26746 r2 = readTextO(self, "../textOutTest.null"); 26747 ck_assert_ptr_ne(r2, NULL); 26748 char *s = toStringO(r2); 26749 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26750 free(s); 26751 terminateO(self); 26752 26753 } 26754 26755 26756 void writeTextSmallJsonSmallArrayGT(void) { 26757 26758 bool r; 26759 smallArrayt *self = allocG(rtSmallArrayt); 26760 smallJsont *filePath = allocSmallJson(); 26761 26762 // write textOutTest.null 26763 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26764 ck_assert_ptr_ne(r2, NULL); 26765 setTopSO(filePath, "../textOutTest.null"); 26766 r = writeTextSmallJsonSmallArrayG(self, filePath); 26767 ck_assert(r); 26768 // check textOutTest.null 26769 emptyO(self); 26770 r2 = readTextO(self, "../textOutTest.null"); 26771 ck_assert_ptr_ne(r2, NULL); 26772 char *s = toStringO(r2); 26773 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26774 free(s); 26775 terminateO(self); 26776 terminateO(filePath); 26777 26778 } 26779 26780 26781 void writeTextSmallStringSmallArrayGT(void) { 26782 26783 bool r; 26784 smallArrayt *self = allocG(rtSmallArrayt); 26785 smallStringt *filePath = allocSmallString(""); 26786 26787 // write textOutTest.null 26788 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26789 ck_assert_ptr_ne(r2, NULL); 26790 setValO(filePath, "../textOutTest.null"); 26791 r = writeTextSmallStringSmallArrayG(self, filePath); 26792 ck_assert(r); 26793 // check textOutTest.null 26794 emptyO(self); 26795 r2 = readTextO(self, "../textOutTest.null"); 26796 ck_assert_ptr_ne(r2, NULL); 26797 char *s = toStringO(r2); 26798 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26799 free(s); 26800 terminateO(self); 26801 terminateO(filePath); 26802 26803 } 26804 26805 26806 void writeStreamSmallArrayGT(void) { 26807 26808 bool r; 26809 smallArrayt *self = allocG(rtSmallArrayt); 26810 FILE *fp; 26811 26812 // write textOutTest.null 26813 fp = fopen("../textTest.null", "r"); 26814 smallArrayt *r2 = readStreamO(self, fp); 26815 fclose(fp); 26816 ck_assert_ptr_ne(r2, NULL); 26817 fp = fopen("../textOutTest.null", "w"); 26818 r = writeStreamSmallArrayG(self, fp); 26819 ck_assert(r); 26820 fclose(fp); 26821 terminateO(self); 26822 26823 } 26824 26825 26826 void appendTextSmallArrayGT(void) { 26827 26828 bool r; 26829 smallArrayt *self = allocG(rtSmallArrayt); 26830 26831 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26832 ck_assert_ptr_ne(r2, NULL); 26833 r = writeTextO(self, "../textOutTest.null"); 26834 ck_assert(r); 26835 emptyO(self); 26836 self->f->pushS(self, "A"); 26837 self->f->pushS(self, "B"); 26838 r = appendTextSmallArrayG(self, "../textOutTest.null"); 26839 // check textOutTest.null 26840 emptyO(self); 26841 r2 = readTextO(self, "../textOutTest.null"); 26842 char *s = toStringO(r2); 26843 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 26844 free(s); 26845 terminateO(self); 26846 26847 } 26848 26849 26850 void appendTextSmallStringSmallArrayGT(void) { 26851 26852 bool r; 26853 smallArrayt *self = allocG(rtSmallArrayt); 26854 smallStringt *filePath = allocSmallString(""); 26855 26856 // append to textOutTest.null 26857 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26858 ck_assert_ptr_ne(r2, NULL); 26859 r = writeTextO(self, "../textOutTest.null"); 26860 ck_assert(r); 26861 emptyO(self); 26862 self->f->pushS(self, "A"); 26863 self->f->pushS(self, "B"); 26864 setValO(filePath, "../textOutTest.null"); 26865 r = appendTextSmallStringSmallArrayG(self, filePath); 26866 // check textOutTest.null 26867 emptyO(self); 26868 r2 = readTextO(self, "../textOutTest.null"); 26869 char *s = toStringO(r2); 26870 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 26871 free(s); 26872 terminateO(self); 26873 terminateO(filePath); 26874 26875 } 26876 26877 26878 void typeSmallStringSmallArrayGT(void) { 26879 26880 smallStringt* r; 26881 smallArrayt *self = allocG(rtSmallArrayt); 26882 26883 r = typeSmallStringSmallArrayG(self, 0); 26884 char *s = toStringO(r); 26885 ck_assert_str_eq(s, "not a sheepy object"); 26886 free(s); 26887 terminateO(self); 26888 terminateO(r); 26889 26890 } 26891 26892 26893 void typeSmallStringsSmallArrayGT(void) { 26894 26895 smallArrayt* r; 26896 smallArrayt *self = allocG(rtSmallArrayt); 26897 26898 self->f->pushS(self, "qwe"); 26899 self->f->pushBool(self, true); 26900 self->f->pushDouble(self, 1); 26901 r = typeSmallStringsSmallArrayG(self); 26902 ck_assert_ptr_ne(r, NULL); 26903 char *s = toStringO(r); 26904 ck_assert_str_eq(s, "[\"string\",\"bool\",\"double\"]"); 26905 free(s); 26906 terminateO(self); 26907 terminateO(r); 26908 26909 } 26910 26911 26912 void cSmallArrayT(void) { 26913 26914 // local object 26915 createSmallArray(obj); 26916 ck_assert_str_eq(obj.type, "smallArray"); 26917 // object 26918 createAllocateSmallArray(obj2); 26919 ck_assert_str_eq(obj2->type, "smallArray"); 26920 // toString 26921 char *s = obj2->f->toString(obj2); 26922 ck_assert_str_eq(s, "[]"); 26923 free(s); 26924 createAllocateUndefined(oU); 26925 obj2->f->push(obj2, (baset *)oU); 26926 finishO(oU); 26927 createAllocateSmallInt(oInt); 26928 oInt->f->set(oInt, 123); 26929 obj2->f->push(obj2, (baset *)oInt); 26930 finishO(oInt); 26931 createAllocateSmallString(oStr); 26932 oStr->f->set(oStr, "sheepy"); 26933 obj2->f->push(obj2, (baset *)oStr); 26934 finishO(oStr); 26935 s = obj2->f->toString(obj2); 26936 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 26937 free(s); 26938 // delete an element 26939 smallArrayt *o2; 26940 o2 = obj2->f->duplicate(obj2); 26941 o2->f->delElem(o2, 0); 26942 s = o2->f->toString(o2); 26943 ck_assert_str_eq(s, "[123,\"sheepy\"]"); 26944 free(s); 26945 terminateO(o2); 26946 // duplicate 26947 smallArrayt *o; 26948 o = obj2->f->duplicate(obj2); 26949 undefinedt *u; 26950 u = (undefinedt *) o->f->getAt(o, 0); 26951 ck_assert(isOType(u, "undefined")); 26952 terminateO(u); 26953 smallIntt *in; 26954 in = (smallIntt *) o->f->getAt(o, 1); 26955 ck_assert(in->value->value == 123); 26956 smashO(in); 26957 smallStringt *st; 26958 st = (smallStringt *) o->f->getAt(o, 2); 26959 ck_assert(strEq(st->f->get(st), "sheepy")); 26960 smashO(st); 26961 terminateO(o); 26962 // delete an element 26963 o2 = obj2->f->duplicate(obj2); 26964 o2->f->delElem(o2, 0); 26965 o = o2->f->duplicate(o2); 26966 in = (smallIntt *) o->f->getAt(o, 0); 26967 ck_assert(in->value->value == 123); 26968 smashO(in); 26969 st = (smallStringt *) o->f->getAt(o, 1); 26970 ck_assert(strEq(st->f->get(st), "sheepy")); 26971 smashO(st); 26972 terminateO(o); 26973 terminateO(o2); 26974 // fromArray 26975 initiateAllocateSmallArray(&o); 26976 char *array[] = {"1", "22", "333"}; 26977 char *arrayNULL[] = {"1", NULL, "333"}; 26978 // copy array to list 26979 o->f->fromArray(o, (void *)array, 3); 26980 ck_assert_uint_eq(o->f->len(o),3); 26981 smallStringt *strFrom; 26982 strFrom = (smallStringt*) o->f->getAt(o,0); 26983 ck_assert_str_eq(strFrom->f->get(strFrom), "1"); 26984 smashO(strFrom); 26985 strFrom = (smallStringt*) o->f->getAt(o,1); 26986 ck_assert_str_eq(strFrom->f->get(strFrom), "22"); 26987 smashO(strFrom); 26988 strFrom = (smallStringt*) o->f->getAt(o,2); 26989 ck_assert_str_eq(strFrom->f->get(strFrom), "333"); 26990 smashO(strFrom); 26991 // array with NULL inside 26992 o->f->fromArray(o, (void *)arrayNULL, 3); 26993 ck_assert_uint_eq(o->f->len(o),3); 26994 strFrom = (smallStringt*) o->f->getAt(o,0); 26995 ck_assert_str_eq(strFrom->f->get(strFrom), "1"); 26996 smashO(strFrom); 26997 strFrom = (smallStringt*) o->f->getAt(o,1); 26998 ck_assert_ptr_eq(strFrom, NULL); 26999 strFrom = (smallStringt*) o->f->getAt(o,2); 27000 ck_assert_str_eq(strFrom->f->get(strFrom), "333"); 27001 smashO(strFrom); 27002 // char** list 27003 char **shpList = listCreateS("lib", "sheepy"); 27004 o->f->fromArray(o, shpList, 0); 27005 ck_assert_uint_eq(o->f->len(o),2); 27006 listFreeS(shpList); 27007 // NULL pointer to list - list not changed 27008 o->f->fromArray(o, (void *)arrayNULL, 3); 27009 o->f->fromArray(o, NULL, 3); 27010 ck_assert_uint_eq(o->f->len(o),3); 27011 strFrom = (smallStringt*) o->f->getAt(o,0); 27012 ck_assert_str_eq(strFrom->f->get(strFrom), "1"); 27013 smashO(strFrom); 27014 strFrom = (smallStringt*) o->f->getAt(o,1); 27015 ck_assert_ptr_eq(strFrom, NULL); 27016 strFrom = (smallStringt*) o->f->getAt(o,2); 27017 ck_assert_str_eq(strFrom->f->get(strFrom), "333"); 27018 smashO(strFrom); 27019 terminateO(o); 27020 // push 27021 o = obj2->f->duplicate(obj2); 27022 initiateAllocateSmallInt(&in); 27023 in->f->set(in, 654); 27024 o->f->push(o, (baset *)in); 27025 finishO(in); 27026 in = (smallIntt *) o->f->getAt(o, 3); 27027 ck_assert_uint_eq(o->f->len(o), 4); 27028 ck_assert_uint_eq(in->value->value, 654); 27029 smashO(in); 27030 // NULL 27031 o->f->push(o, NULL); 27032 ck_assert_uint_eq(o->f->len(o), 4); 27033 terminateO(o); 27034 // pop 27035 o = obj2->f->duplicate(obj2); 27036 ck_assert_uint_eq(o->f->len(o), 3); 27037 st = (smallStringt *) o->f->pop(o); 27038 ck_assert_uint_eq(o->f->len(o), 2); 27039 ck_assert_str_eq(st->f->get(st), "sheepy"); 27040 terminateO(st); 27041 in = (smallIntt *) o->f->pop(o); 27042 ck_assert_uint_eq(in->value->value, 123); 27043 terminateO(in); 27044 u = (undefinedt *) o->f->pop(o); 27045 ck_assert(isOType(u, "undefined")); 27046 terminateO(u); 27047 // empty list 27048 u = (undefinedt *) o->f->pop(o); 27049 ck_assert_ptr_eq(u,NULL); 27050 // after initialize 27051 o->f->free(o); 27052 ck_assert_uint_eq(o->f->len(o), 0); 27053 u = (undefinedt *) o->f->pop(o); 27054 ck_assert_uint_eq(o->f->len(o), 0); 27055 ck_assert_ptr_eq(u,NULL); 27056 terminateO(o); 27057 // append 27058 o = obj2->f->duplicate(obj2); 27059 o2 = obj2->f->duplicate(obj2); 27060 in = (smallIntt *) o2->f->getAt(o2, 1); 27061 in->value->value = 789; 27062 o2->f->setAt(o2, 1, (baset *)in); 27063 finishO(in); 27064 o->f->append(o, o2); 27065 s = toStringO(o); 27066 ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]"); 27067 free(s); 27068 // same list 27069 o->f->append(o, o); 27070 s = toStringO(o); 27071 ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]"); 27072 free(s); 27073 o->f->free(o); 27074 o2->f->smash(&o2); 27075 // empty list + list 27076 o2 = obj2->f->duplicate(obj2); 27077 in = (smallIntt *) o2->f->getAt(o2, 1); 27078 in->value->value = 789; 27079 o2->f->setAt(o2, 1, (baset *)in); 27080 finishO(in); 27081 o->f->append(o, o2); 27082 s = toStringO(o); 27083 ck_assert_str_eq(s, "[null,789,\"sheepy\"]"); 27084 free(s); 27085 // list + empty list 27086 o2->f->dispose(o2); 27087 o->f->append(o, o2); 27088 s = toStringO(o); 27089 ck_assert_str_eq(s, "[null,789,\"sheepy\"]"); 27090 free(s); 27091 // empty list + empty list 27092 o->f->free(o); 27093 o->f->append(o, o2); 27094 s = toStringO(o); 27095 ck_assert_str_eq(s, "[]"); 27096 free(s); 27097 terminateO(o2); 27098 // NULL list 27099 o->f->append(o, NULL); 27100 s = toStringO(o); 27101 ck_assert_str_eq(s, "[]"); 27102 free(s); 27103 terminateO(o); 27104 // slice 27105 o = obj2->f->duplicate(obj2); 27106 initiateAllocateSmallInt(&in); 27107 in->f->set(in, 5345); 27108 o->f->push(o, (baset *) in); 27109 finishO(in); 27110 o->f->slice(o,1,-1); 27111 s = toStringO(o); 27112 ck_assert_str_eq(s, "[123,\"sheepy\"]"); 27113 free(s); 27114 terminateO(o); 27115 // start outside 27116 o = obj2->f->duplicate(obj2); 27117 initiateAllocateSmallInt(&in); 27118 in->f->set(in, 5345); 27119 o->f->push(o, (baset *) in); 27120 finishO(in); 27121 o->f->slice(o,20,-1); 27122 s = toStringO(o); 27123 ck_assert_str_eq(s, "[]"); 27124 free(s); 27125 terminateO(o); 27126 // start negative and outside 27127 o = obj2->f->duplicate(obj2); 27128 initiateAllocateSmallInt(&in); 27129 in->f->set(in, 5345); 27130 o->f->push(o, (baset *) in); 27131 finishO(in); 27132 o->f->slice(o,-20,1); 27133 s = toStringO(o); 27134 ck_assert_str_eq(s, "[null]"); 27135 free(s); 27136 terminateO(o); 27137 // end outside 27138 o = obj2->f->duplicate(obj2); 27139 initiateAllocateSmallInt(&in); 27140 in->f->set(in, 5345); 27141 o->f->push(o, (baset *) in); 27142 finishO(in); 27143 o->f->slice(o,2,40); 27144 s = toStringO(o); 27145 ck_assert_str_eq(s, "[\"sheepy\",5345]"); 27146 free(s); 27147 terminateO(o); 27148 // end negative and outside 27149 o = obj2->f->duplicate(obj2); 27150 initiateAllocateSmallInt(&in); 27151 in->f->set(in, 5345); 27152 o->f->push(o, (baset *) in); 27153 finishO(in); 27154 o->f->slice(o,2,-40); 27155 s = toStringO(o); 27156 ck_assert_str_eq(s, "[]"); 27157 free(s); 27158 terminateO(o); 27159 // end before start 27160 o = obj2->f->duplicate(obj2); 27161 initiateAllocateSmallInt(&in); 27162 in->f->set(in, 5345); 27163 o->f->push(o, (baset *) in); 27164 finishO(in); 27165 o->f->slice(o,3,2); 27166 s = toStringO(o); 27167 ck_assert_str_eq(s, "[]"); 27168 free(s); 27169 terminateO(o); 27170 // negative start last element 27171 o = obj2->f->duplicate(obj2); 27172 initiateAllocateSmallInt(&in); 27173 in->f->set(in, 5345); 27174 o->f->push(o, (baset *) in); 27175 finishO(in); 27176 o->f->slice(o,-1,0); 27177 s = toStringO(o); 27178 ck_assert_str_eq(s, "[5345]"); 27179 free(s); 27180 terminateO(o); 27181 // start = end 27182 o = obj2->f->duplicate(obj2); 27183 initiateAllocateSmallInt(&in); 27184 in->f->set(in, 5345); 27185 o->f->push(o, (baset *) in); 27186 finishO(in); 27187 o->f->slice(o,1,1); 27188 s = toStringO(o); 27189 ck_assert_str_eq(s, "[]"); 27190 free(s); 27191 terminateO(o); 27192 // empty list 27193 initiateAllocateSmallArray(&o); 27194 o->f->slice(o,0,0); 27195 s = toStringO(o); 27196 ck_assert_str_eq(s, "[]"); 27197 free(s); 27198 terminateO(o); 27199 // insert 27200 o = obj2->f->duplicate(obj2); 27201 o2 = obj2->f->duplicate(obj2); 27202 in = (smallIntt *) o2->f->getAt(o2, 1); 27203 in->value->value = 789; 27204 o2->f->setAt(o2, 1, (baset *)in); 27205 finishO(in); 27206 o->f->insert(o, 0, o2); 27207 s = toStringO(o); 27208 ck_assert_str_eq(s, "[null,789,\"sheepy\",null,123,\"sheepy\"]"); 27209 free(s); 27210 terminateO(o); 27211 o2->f->smash(&o2); 27212 // negative index 27213 o = obj2->f->duplicate(obj2); 27214 o2 = obj2->f->duplicate(obj2); 27215 in = (smallIntt *) o2->f->getAt(o2, 1); 27216 in->value->value = 789; 27217 o2->f->setAt(o2, 1, (baset *)in); 27218 finishO(in); 27219 o->f->insert(o, -1, o2); 27220 s = toStringO(o); 27221 ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]"); 27222 free(s); 27223 terminateO(o); 27224 o2->f->smash(&o2); 27225 // edge 27226 o = obj2->f->duplicate(obj2); 27227 o2 = obj2->f->duplicate(obj2); 27228 in = (smallIntt *) o2->f->getAt(o2, 1); 27229 in->value->value = 789; 27230 o2->f->setAt(o2, 1, (baset *)in); 27231 finishO(in); 27232 o->f->insert(o, 3, o2); 27233 s = toStringO(o); 27234 ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]"); 27235 free(s); 27236 terminateO(o); 27237 o2->f->smash(&o2); 27238 // outside 27239 o = obj2->f->duplicate(obj2); 27240 o2 = obj2->f->duplicate(obj2); 27241 in = (smallIntt *) o2->f->getAt(o2, 1); 27242 in->value->value = 789; 27243 o2->f->setAt(o2, 1, (baset *)in); 27244 finishO(in); 27245 o->f->insert(o, 4, o2); 27246 s = toStringO(o); 27247 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27248 free(s); 27249 o->f->insert(o, -5, o2); 27250 s = toStringO(o); 27251 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27252 free(s); 27253 terminateO(o); 27254 terminateO(o2); 27255 // negative index in a one element list 27256 o = obj2->f->duplicate(obj2); 27257 o2 = obj2->f->duplicate(obj2); 27258 in = (smallIntt *) o2->f->getAt(o2, 1); 27259 in->value->value = 789; 27260 o2->f->setAt(o2, 1, (baset *)in); 27261 finishO(in); 27262 o->f->delElem(o, 1); 27263 o->f->delElem(o, 2); 27264 o->f->trim(o); 27265 o->f->insert(o, -1, o2); 27266 s = toStringO(o); 27267 ck_assert_str_eq(s, "[null,null,789,\"sheepy\"]"); 27268 free(s); 27269 terminateO(o); 27270 o2->f->smash(&o2); 27271 // empty list 27272 initiateAllocateSmallArray(&o); 27273 o2 = obj2->f->duplicate(obj2); 27274 in = (smallIntt *) o2->f->getAt(o2, 1); 27275 in->value->value = 789; 27276 o2->f->setAt(o2, 1, (baset *)in); 27277 finishO(in); 27278 o->f->insert(o, 0, o2); 27279 s = toStringO(o); 27280 ck_assert_str_eq(s, "[null,789,\"sheepy\"]"); 27281 free(s); 27282 terminateO(o); 27283 o2->f->dispose(o2); 27284 // empty insert list 27285 o = obj2->f->duplicate(obj2); 27286 o->f->insert(o, 0, o2); 27287 s = toStringO(o); 27288 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27289 free(s); 27290 terminateO(o); 27291 o2->f->smash(&o2); 27292 //NULL insert 27293 o = obj2->f->duplicate(obj2); 27294 o->f->insert(o, 0, NULL); 27295 s = toStringO(o); 27296 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27297 free(s); 27298 terminateO(o); 27299 // del 27300 o = obj2->f->duplicate(obj2); 27301 initiateAllocateSmallInt(&in); 27302 in->f->set(in, 5345); 27303 o->f->push(o, (baset *) in); 27304 finishO(in); 27305 o->f->del(o,1,-1); 27306 s = toStringO(o); 27307 ck_assert_str_eq(s, "[null,5345]"); 27308 free(s); 27309 terminateO(o); 27310 // start outside 27311 o = obj2->f->duplicate(obj2); 27312 initiateAllocateSmallInt(&in); 27313 in->f->set(in, 5345); 27314 o->f->push(o, (baset *) in); 27315 finishO(in); 27316 o->f->del(o,20,-1); 27317 s = toStringO(o); 27318 ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]"); 27319 free(s); 27320 terminateO(o); 27321 // start negative and outside 27322 o = obj2->f->duplicate(obj2); 27323 initiateAllocateSmallInt(&in); 27324 in->f->set(in, 5345); 27325 o->f->push(o, (baset *) in); 27326 finishO(in); 27327 o->f->del(o,-20,1); 27328 s = toStringO(o); 27329 ck_assert_str_eq(s, "[123,\"sheepy\",5345]"); 27330 free(s); 27331 terminateO(o); 27332 // end outside 27333 o = obj2->f->duplicate(obj2); 27334 initiateAllocateSmallInt(&in); 27335 in->f->set(in, 5345); 27336 o->f->push(o, (baset *) in); 27337 finishO(in); 27338 o->f->del(o,2,40); 27339 s = toStringO(o); 27340 ck_assert_str_eq(s, "[null,123]"); 27341 free(s); 27342 terminateO(o); 27343 // end negative and outside 27344 o = obj2->f->duplicate(obj2); 27345 initiateAllocateSmallInt(&in); 27346 in->f->set(in, 5345); 27347 o->f->push(o, (baset *) in); 27348 finishO(in); 27349 o->f->del(o,2,-40); 27350 s = toStringO(o); 27351 ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]"); 27352 free(s); 27353 terminateO(o); 27354 // end before start 27355 o = obj2->f->duplicate(obj2); 27356 initiateAllocateSmallInt(&in); 27357 in->f->set(in, 5345); 27358 o->f->push(o, (baset *) in); 27359 finishO(in); 27360 o->f->del(o,3,2); 27361 s = toStringO(o); 27362 ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]"); 27363 free(s); 27364 terminateO(o); 27365 // negative start last element 27366 o = obj2->f->duplicate(obj2); 27367 initiateAllocateSmallInt(&in); 27368 in->f->set(in, 5345); 27369 o->f->push(o, (baset *) in); 27370 finishO(in); 27371 o->f->del(o,-1,0); 27372 s = toStringO(o); 27373 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27374 free(s); 27375 terminateO(o); 27376 // start = end 27377 o = obj2->f->duplicate(obj2); 27378 initiateAllocateSmallInt(&in); 27379 in->f->set(in, 5345); 27380 o->f->push(o, (baset *) in); 27381 finishO(in); 27382 o->f->del(o,1,1); 27383 s = toStringO(o); 27384 ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]"); 27385 free(s); 27386 terminateO(o); 27387 // empty list 27388 initiateAllocateSmallArray(&o); 27389 o->f->del(o,0,0); 27390 s = toStringO(o); 27391 ck_assert_str_eq(s, "[]"); 27392 free(s); 27393 terminateO(o); 27394 // len 27395 ck_assert_uint_eq(obj2->f->len(obj2), 3); 27396 // trim 27397 o = obj2->f->duplicate(obj2); 27398 ck_assert_uint_eq(o->f->len(o), 3); 27399 st = (smallStringt *) o->f->pop(o); 27400 terminateO(st); 27401 o->f->delElem(o, 0); 27402 o->f->trim(o); 27403 ck_assert_uint_eq(o->f->len(o), 1); 27404 s = toStringO(o); 27405 ck_assert_str_eq(s, "[123]"); 27406 free(s); 27407 terminateO(o); 27408 // getAt 27409 o = obj2->f->duplicate(obj2); 27410 u = (undefinedt *) o->f->getAt(o, 0); 27411 ck_assert_str_eq(u->type, "undefined"); 27412 terminateO(u); 27413 st = (smallStringt *) o->f->getAt(o, -1); 27414 ck_assert_str_eq(st->type, "smallString"); 27415 smashO(st); 27416 // outside 27417 u = (undefinedt *) o->f->getAt(o, 4); 27418 ck_assert_ptr_eq(u, NULL); 27419 u = (undefinedt *) o->f->getAt(o, -4); 27420 ck_assert_ptr_eq(u, NULL); 27421 terminateO(o); 27422 // empty 27423 initiateAllocateSmallArray(&o); 27424 u = (undefinedt *) o->f->getAt(o, 0); 27425 ck_assert_ptr_eq(u, NULL); 27426 terminateO(o); 27427 // setAt 27428 o = obj2->f->duplicate(obj2); 27429 initiateAllocateSmallInt(&in); 27430 o->f->setAt(o, 0, (baset *) in); 27431 finishO(in); 27432 s = toStringO(o); 27433 ck_assert_str_eq(s, "[0,123,\"sheepy\"]"); 27434 free(s); 27435 initiateAllocateSmallInt(&in); 27436 o->f->setAt(o, -1, (baset *) in); 27437 finishO(in); 27438 s = toStringO(o); 27439 ck_assert_str_eq(s, "[0,123,0]"); 27440 free(s); 27441 // outside 27442 o->f->setAt(o, 4, (baset *) in); 27443 s = toStringO(o); 27444 ck_assert_str_eq(s, "[0,123,0]"); 27445 free(s); 27446 o->f->setAt(o, -4, (baset *) in); 27447 s = toStringO(o); 27448 ck_assert_str_eq(s, "[0,123,0]"); 27449 free(s); 27450 terminateO(o); 27451 // empty 27452 o = obj2->f->duplicate(obj2); 27453 o->f->empty(o); 27454 ck_assert(o->f->isEmpty(o)); 27455 terminateO(o); 27456 // isEmpty 27457 o = obj2->f->duplicate(obj2); 27458 ck_assert(!o->f->isEmpty(o)); 27459 terminateO(o); 27460 initiateAllocateSmallArray(&o); 27461 ck_assert(o->f->isEmpty(o)); 27462 terminateO(o); 27463 // typeString type typeStrings types 27464 initiateAllocateSmallArray(&o2); 27465 o = allocSmallArray(); 27466 oU = allocUndefined(); 27467 o->f->push(o, (baset *)oU); 27468 finishO(oU); 27469 oInt = allocSmallInt(123); 27470 o->f->push(o, (baset *)oInt); 27471 finishO(oInt); 27472 oStr = allocSmallString("sheepy"); 27473 o->f->push(o, (baset *)oStr); 27474 finishO(oStr); 27475 o->f->push(o, NULL); 27476 // typeString 27477 s = (char *)o->f->typeString(o, 0); 27478 ck_assert_str_eq(s, "undefined"); 27479 // type 27480 char c = o->f->type(o, 2); 27481 ck_assert_uint_eq(c, STRING); 27482 // negative index 27483 c = o->f->type(o, -2); 27484 ck_assert_uint_eq(c, INT); 27485 // outside 27486 ck_assert(!o->f->type(o, 10)); 27487 ck_assert(!o->f->type(o, -14)); 27488 // NULL element 27489 c = o->f->type(o, 0); 27490 ck_assert_uint_eq(c, UNDEFINED); 27491 // empty object 27492 ck_assert(!o2->f->type(o2, 0)); 27493 // typeStrings 27494 char **l = o->f->typeStrings(o); 27495 s = join(l, ","); 27496 ck_assert_str_eq(s, "undefined,int,string"); 27497 free(s); 27498 free(l); 27499 // empty object 27500 ck_assert_ptr_eq(o2->f->typeStrings(o2), NULL); 27501 // types 27502 smallBytest *B = o->f->types(o); 27503 s = sToStringTiny((smallt *)B->B); 27504 ck_assert_str_eq(s, "[0x01,0x07,0x08]"); 27505 free(s); 27506 // empty object 27507 ck_assert_ptr_eq(o2->f->types(o2), NULL); 27508 terminateO(B); 27509 terminateO(o); 27510 terminateO(o2); 27511 // free local object 27512 obj.f->free(&obj); 27513 ck_assert_str_eq(obj.type, "smallArray"); 27514 // free object 27515 obj2->f->terminate(&obj2); 27516 ck_assert_ptr_eq(obj2, NULL); 27517 // init NULL 27518 initiateAllocateSmallArray(NULL); 27519 27520 } 27521 27522 27523 27524 27525 int main(int n UNUSED, char**v UNUSED) { 27526 // disable btrace to make the test run faster 27527 btraceDisable(); 27528 allocArraySmallArrayT(); 27529 allocCArraySmallArrayT(); 27530 createSAFT(); 27531 getsoSmallArrayT(); 27532 setsoSmallArrayT(); 27533 mirrorSmallArrayT(); 27534 fromArrayNFreeSmallArrayT(); 27535 pushUndefinedSmallArrayT(); 27536 pushBoolSmallArrayT(); 27537 pushDoubleSmallArrayT(); 27538 pushIntSmallArrayT(); 27539 pushSSmallArrayT(); 27540 pushCharSmallArrayT(); 27541 pushDictSmallArrayT(); 27542 pushArraySmallArrayT(); 27543 pushArraycSmallArrayT(); 27544 pushSmallBoolSmallArrayT(); 27545 pushSmallBytesSmallArrayT(); 27546 pushSmallDoubleSmallArrayT(); 27547 pushSmallIntSmallArrayT(); 27548 pushSmallJsonSmallArrayT(); 27549 pushSmallStringSmallArrayT(); 27550 pushSmallContainerSmallArrayT(); 27551 pushNFreeSmallArrayT(); 27552 pushNFreeUndefinedSmallArrayT(); 27553 pushNFreeSSmallArrayT(); 27554 pushNFreeDictSmallArrayT(); 27555 pushNFreeArraySmallArrayT(); 27556 pushNFreeArraycSmallArrayT(); 27557 pushNFreeSmallBoolSmallArrayT(); 27558 pushNFreeSmallBytesSmallArrayT(); 27559 pushNFreeSmallDoubleSmallArrayT(); 27560 pushNFreeSmallIntSmallArrayT(); 27561 pushNFreeSmallJsonSmallArrayT(); 27562 pushNFreeSmallStringSmallArrayT(); 27563 pushNFreeSmallContainerSmallArrayT(); 27564 pushManySmallArrayT(); 27565 pushManySSmallArrayT(); 27566 pushNFreeManySmallArrayT(); 27567 pushNFreeManySSmallArrayT(); 27568 popSmallArrayT(); 27569 popUndefinedSmallArrayT(); 27570 popBoolSmallArrayT(); 27571 popDoubleSmallArrayT(); 27572 popIntSmallArrayT(); 27573 popInt32SmallArrayT(); 27574 popUintSmallArrayT(); 27575 popUint32SmallArrayT(); 27576 popSSmallArrayT(); 27577 popDictSmallArrayT(); 27578 popArraySmallArrayT(); 27579 popSmallBoolSmallArrayT(); 27580 popSmallBytesSmallArrayT(); 27581 popSmallDoubleSmallArrayT(); 27582 popSmallIntSmallArrayT(); 27583 popSmallJsonSmallArrayT(); 27584 popSmallStringSmallArrayT(); 27585 popVoidSmallArrayT(); 27586 popSmallContainerSmallArrayT(); 27587 popNumSmallArrayT(); 27588 prependSmallArrayT(); 27589 prependUndefinedSmallArrayT(); 27590 prependBoolSmallArrayT(); 27591 prependDoubleSmallArrayT(); 27592 prependIntSmallArrayT(); 27593 prependSSmallArrayT(); 27594 prependCharSmallArrayT(); 27595 prependDictSmallArrayT(); 27596 prependArraySmallArrayT(); 27597 prependArraycSmallArrayT(); 27598 prependSmallBoolSmallArrayT(); 27599 prependSmallBytesSmallArrayT(); 27600 prependSmallDoubleSmallArrayT(); 27601 prependSmallIntSmallArrayT(); 27602 prependSmallJsonSmallArrayT(); 27603 prependSmallStringSmallArrayT(); 27604 prependSmallContainerSmallArrayT(); 27605 prependNFreeSmallArrayT(); 27606 prependNFreeUndefinedSmallArrayT(); 27607 prependNFreeSSmallArrayT(); 27608 prependNFreeDictSmallArrayT(); 27609 prependNFreeArraySmallArrayT(); 27610 prependNFreeArraycSmallArrayT(); 27611 prependNFreeSmallBoolSmallArrayT(); 27612 prependNFreeSmallBytesSmallArrayT(); 27613 prependNFreeSmallDoubleSmallArrayT(); 27614 prependNFreeSmallIntSmallArrayT(); 27615 prependNFreeSmallJsonSmallArrayT(); 27616 prependNFreeSmallStringSmallArrayT(); 27617 prependNFreeSmallContainerSmallArrayT(); 27618 dequeueSmallArrayT(); 27619 dequeueUndefinedSmallArrayT(); 27620 dequeueBoolSmallArrayT(); 27621 dequeueDoubleSmallArrayT(); 27622 dequeueIntSmallArrayT(); 27623 dequeueInt32SmallArrayT(); 27624 dequeueUintSmallArrayT(); 27625 dequeueUint32SmallArrayT(); 27626 dequeueSSmallArrayT(); 27627 dequeueDictSmallArrayT(); 27628 dequeueArraySmallArrayT(); 27629 dequeueSmallBoolSmallArrayT(); 27630 dequeueSmallBytesSmallArrayT(); 27631 dequeueSmallDoubleSmallArrayT(); 27632 dequeueSmallIntSmallArrayT(); 27633 dequeueSmallJsonSmallArrayT(); 27634 dequeueSmallStringSmallArrayT(); 27635 dequeueVoidSmallArrayT(); 27636 dequeueSmallContainerSmallArrayT(); 27637 dequeueNumSmallArrayT(); 27638 reverseSmallArrayT(); 27639 catSmallArrayT(); 27640 appendSmallJsonSmallArrayT(); 27641 appendNSmashSmallArrayT(); 27642 appendNSmashSmallJsonSmallArrayT(); 27643 appendArraySmallArrayT(); 27644 appendNSmashArraySmallArrayT(); 27645 shiftSmallArrayT(); 27646 shiftSmallJsonSmallArrayT(); 27647 shiftNSmashSmallArrayT(); 27648 shiftNSmashSmallJsonSmallArrayT(); 27649 addSmallArrayT(); 27650 cropSmallArrayT(); 27651 cropElemSmallArrayT(); 27652 cropElemUndefinedSmallArrayT(); 27653 cropElemBoolSmallArrayT(); 27654 cropElemDoubleSmallArrayT(); 27655 cropElemIntSmallArrayT(); 27656 cropElemInt32SmallArrayT(); 27657 cropElemUintSmallArrayT(); 27658 cropElemUint32SmallArrayT(); 27659 cropElemSSmallArrayT(); 27660 cropElemDictSmallArrayT(); 27661 cropElemArraySmallArrayT(); 27662 cropElemSmallBoolSmallArrayT(); 27663 cropElemSmallBytesSmallArrayT(); 27664 cropElemSmallDoubleSmallArrayT(); 27665 cropElemSmallIntSmallArrayT(); 27666 cropElemSmallJsonSmallArrayT(); 27667 cropElemSmallStringSmallArrayT(); 27668 cropElemVoidSmallArrayT(); 27669 cropElemSmallContainerSmallArrayT(); 27670 copySmallArrayT(); 27671 insertSmallArrayT(); 27672 insertSmallJsonSmallArrayT(); 27673 insertNSmashSmallArrayT(); 27674 insertNSmashSmallJsonSmallArrayT(); 27675 injectSmallArrayT(); 27676 injectUndefinedSmallArrayT(); 27677 injectBoolSmallArrayT(); 27678 injectDoubleSmallArrayT(); 27679 injectIntSmallArrayT(); 27680 injectSSmallArrayT(); 27681 injectCharSmallArrayT(); 27682 injectDictSmallArrayT(); 27683 injectArraySmallArrayT(); 27684 injectArraycSmallArrayT(); 27685 injectSmallBoolSmallArrayT(); 27686 injectSmallBytesSmallArrayT(); 27687 injectSmallDoubleSmallArrayT(); 27688 injectSmallIntSmallArrayT(); 27689 injectSmallJsonSmallArrayT(); 27690 injectSmallStringSmallArrayT(); 27691 injectSmallContainerSmallArrayT(); 27692 injectNFreeSmallArrayT(); 27693 injectNFreeUndefinedSmallArrayT(); 27694 injectNFreeSSmallArrayT(); 27695 injectNFreeDictSmallArrayT(); 27696 injectNFreeArraySmallArrayT(); 27697 injectNFreeArraycSmallArrayT(); 27698 injectNFreeSmallBoolSmallArrayT(); 27699 injectNFreeSmallBytesSmallArrayT(); 27700 injectNFreeSmallDoubleSmallArrayT(); 27701 injectNFreeSmallIntSmallArrayT(); 27702 injectNFreeSmallJsonSmallArrayT(); 27703 injectNFreeSmallStringSmallArrayT(); 27704 injectNFreeSmallContainerSmallArrayT(); 27705 removeSmallArrayT(); 27706 removeElemSmallArrayT(); 27707 sortSmallArrayT(); 27708 icSortSmallArrayT(); 27709 sortFSmallArrayT(); 27710 equalSmallArrayT(); 27711 equalSmallArraySmallJsonT(); 27712 equalSmallArrayArrayT(); 27713 equalSmallArrayBaseT(); 27714 icEqualSmallArrayT(); 27715 icEqualSmallArraySmallJsonT(); 27716 icEqualSmallArrayArrayT(); 27717 icEqualSmallArrayBaseT(); 27718 getAtUndefinedSmallArrayT(); 27719 getAtBoolSmallArrayT(); 27720 getAtBoolPSmallArrayT(); 27721 getAtDoubleSmallArrayT(); 27722 getAtDoublePSmallArrayT(); 27723 getAtIntSmallArrayT(); 27724 getAtIntPSmallArrayT(); 27725 getAtInt32SmallArrayT(); 27726 getAtInt32PSmallArrayT(); 27727 getAtUintSmallArrayT(); 27728 getAtUintPSmallArrayT(); 27729 getAtUint32SmallArrayT(); 27730 getAtUint32PSmallArrayT(); 27731 getAtSSmallArrayT(); 27732 getAtDictSmallArrayT(); 27733 getAtArraySmallArrayT(); 27734 getAtSmallBoolSmallArrayT(); 27735 getAtSmallBytesSmallArrayT(); 27736 getAtSmallDoubleSmallArrayT(); 27737 getAtSmallIntSmallArrayT(); 27738 getAtSmallJsonSmallArrayT(); 27739 getAtSmallStringSmallArrayT(); 27740 getAtVoidSmallArrayT(); 27741 getAtSmallContainerSmallArrayT(); 27742 getAtNDupSmallArrayT(); 27743 getAtNDupUndefinedSmallArrayT(); 27744 getAtNDupBoolSmallArrayT(); 27745 getAtNDupDoubleSmallArrayT(); 27746 getAtNDupIntSmallArrayT(); 27747 getAtNDupInt32SmallArrayT(); 27748 getAtNDupUintSmallArrayT(); 27749 getAtNDupUint32SmallArrayT(); 27750 getAtNDupSSmallArrayT(); 27751 getAtNDupDictSmallArrayT(); 27752 getAtNDupArraySmallArrayT(); 27753 getAtNDupSmallBoolSmallArrayT(); 27754 getAtNDupSmallBytesSmallArrayT(); 27755 getAtNDupSmallDoubleSmallArrayT(); 27756 getAtNDupSmallIntSmallArrayT(); 27757 getAtNDupSmallJsonSmallArrayT(); 27758 getAtNDupSmallStringSmallArrayT(); 27759 getAtNDupVoidSmallArrayT(); 27760 getAtNDupSmallContainerSmallArrayT(); 27761 setAtSmallArrayT(); 27762 setAtUndefinedSmallArrayT(); 27763 setAtBoolSmallArrayT(); 27764 setAtDoubleSmallArrayT(); 27765 setAtIntSmallArrayT(); 27766 setAtSSmallArrayT(); 27767 setAtCharSmallArrayT(); 27768 setAtDictSmallArrayT(); 27769 setAtArraySmallArrayT(); 27770 setAtArraycSmallArrayT(); 27771 setAtSmallBoolSmallArrayT(); 27772 setAtSmallBytesSmallArrayT(); 27773 setAtSmallDoubleSmallArrayT(); 27774 setAtSmallIntSmallArrayT(); 27775 setAtSmallJsonSmallArrayT(); 27776 setAtSmallStringSmallArrayT(); 27777 setAtSmallContainerSmallArrayT(); 27778 setAtNFreeSmallArrayT(); 27779 setAtNFreeUndefinedSmallArrayT(); 27780 setAtNFreeSSmallArrayT(); 27781 setAtNFreeDictSmallArrayT(); 27782 setAtNFreeArraySmallArrayT(); 27783 setAtNFreeArraycSmallArrayT(); 27784 setAtNFreeSmallBoolSmallArrayT(); 27785 setAtNFreeSmallBytesSmallArrayT(); 27786 setAtNFreeSmallDoubleSmallArrayT(); 27787 setAtNFreeSmallIntSmallArrayT(); 27788 setAtNFreeSmallJsonSmallArrayT(); 27789 setAtNFreeSmallStringSmallArrayT(); 27790 setAtNFreeSmallContainerSmallArrayT(); 27791 setPAtDictSmallArrayT(); 27792 setPAtArraySmallArrayT(); 27793 setPAtSmallJsonSmallArrayT(); 27794 setPAtSmallStringSmallArrayT(); 27795 setPAtNFreeDictSmallArrayT(); 27796 setPAtNFreeArraySmallArrayT(); 27797 setPAtNFreeSmallJsonSmallArrayT(); 27798 setPAtNFreeSmallStringSmallArrayT(); 27799 getNumSmallArrayT(); 27800 hasSmallArrayT(); 27801 hasUndefinedSmallArrayT(); 27802 hasBoolSmallArrayT(); 27803 hasDoubleSmallArrayT(); 27804 hasIntSmallArrayT(); 27805 hasSSmallArrayT(); 27806 hasCharSmallArrayT(); 27807 hasDictSmallArrayT(); 27808 hasArraySmallArrayT(); 27809 hasArraycSmallArrayT(); 27810 hasSmallBoolSmallArrayT(); 27811 hasSmallBytesSmallArrayT(); 27812 hasSmallDoubleSmallArrayT(); 27813 hasSmallIntSmallArrayT(); 27814 hasSmallJsonSmallArrayT(); 27815 hasSmallStringSmallArrayT(); 27816 hasSmallContainerSmallArrayT(); 27817 indexOfSmallArrayT(); 27818 indexOfUndefinedSmallArrayT(); 27819 indexOfBoolSmallArrayT(); 27820 indexOfDoubleSmallArrayT(); 27821 indexOfIntSmallArrayT(); 27822 indexOfSSmallArrayT(); 27823 indexOfCharSmallArrayT(); 27824 indexOfDictSmallArrayT(); 27825 indexOfArraySmallArrayT(); 27826 indexOfArraycSmallArrayT(); 27827 indexOfSmallBoolSmallArrayT(); 27828 indexOfSmallBytesSmallArrayT(); 27829 indexOfSmallDoubleSmallArrayT(); 27830 indexOfSmallIntSmallArrayT(); 27831 indexOfSmallJsonSmallArrayT(); 27832 indexOfSmallStringSmallArrayT(); 27833 indexOfSmallContainerSmallArrayT(); 27834 binarySearchSmallArrayT(); 27835 binarySearchUndefinedSmallArrayT(); 27836 binarySearchBoolSmallArrayT(); 27837 binarySearchDoubleSmallArrayT(); 27838 binarySearchIntSmallArrayT(); 27839 binarySearchSSmallArrayT(); 27840 binarySearchCharSmallArrayT(); 27841 binarySearchDictSmallArrayT(); 27842 binarySearchArraySmallArrayT(); 27843 binarySearchArraycSmallArrayT(); 27844 binarySearchSmallBoolSmallArrayT(); 27845 binarySearchSmallBytesSmallArrayT(); 27846 binarySearchSmallDoubleSmallArrayT(); 27847 binarySearchSmallIntSmallArrayT(); 27848 binarySearchSmallJsonSmallArrayT(); 27849 binarySearchSmallStringSmallArrayT(); 27850 binarySearchSmallContainerSmallArrayT(); 27851 uniqSmallArrayT(); 27852 icHasSmallArrayT(); 27853 icHasSSmallArrayT(); 27854 icHasCharSmallArrayT(); 27855 icHasDictSmallArrayT(); 27856 icHasArraySmallArrayT(); 27857 icHasArraycSmallArrayT(); 27858 icHasSmallJsonSmallArrayT(); 27859 icHasSmallStringSmallArrayT(); 27860 icIndexOfSmallArrayT(); 27861 icIndexOfSSmallArrayT(); 27862 icIndexOfCharSmallArrayT(); 27863 icIndexOfDictSmallArrayT(); 27864 icIndexOfArraySmallArrayT(); 27865 icIndexOfArraycSmallArrayT(); 27866 icIndexOfSmallJsonSmallArrayT(); 27867 icIndexOfSmallStringSmallArrayT(); 27868 icBinarySearchSmallArrayT(); 27869 icBinarySearchSSmallArrayT(); 27870 icBinarySearchCharSmallArrayT(); 27871 icBinarySearchDictSmallArrayT(); 27872 icBinarySearchArraySmallArrayT(); 27873 icBinarySearchArraycSmallArrayT(); 27874 icBinarySearchSmallJsonSmallArrayT(); 27875 icBinarySearchSmallStringSmallArrayT(); 27876 icUniqSmallArrayT(); 27877 compactSmallArrayT(); 27878 isBlankSmallArrayT(); 27879 forEachSmallArrayFT(); 27880 enumerateSmallArrayFT(); 27881 iterStartSmallArrayT(); 27882 iterStartLastSmallArrayT(); 27883 iterStartFromSmallArrayT(); 27884 iterStartFromStepSmallArrayT(); 27885 iterNextSmallArrayT(); 27886 iterElementSmallArrayT(); 27887 iterIndexSmallArrayT(); 27888 iterStepSmallArrayT(); 27889 joinSmallArrayT(); 27890 joinCharSmallArrayT(); 27891 joinSmallJsonSmallArrayT(); 27892 joinSmallStringSmallArrayT(); 27893 joinSSmallArrayT(); 27894 joinCharSSmallArrayT(); 27895 joinSmallJsonSSmallArrayT(); 27896 joinSmallStringSSmallArrayT(); 27897 zipSmallArrayT(); 27898 zipSmallJsonSmallArrayT(); 27899 zipSmallJsonSmallArraySmallArrayT(); 27900 zipSmallJsonSmallJsonSmallArrayT(); 27901 zipSmallJsonCharSmallArrayT(); 27902 zipSmallJsonCCharSmallArrayT(); 27903 zipArraySmallArrayT(); 27904 zipCArraySmallArrayT(); 27905 zipArraySmallJsonSmallArrayT(); 27906 zipCArraySmallJsonSmallArrayT(); 27907 zipCharSmallArrayT(); 27908 zipCCharSmallArrayT(); 27909 zipArrayCharSmallArrayT(); 27910 zipCArrayCharSmallArrayT(); 27911 zipArrayCCharSmallArrayT(); 27912 zipCArrayCCharSmallArrayT(); 27913 logSmallArrayT(); 27914 readTextSmallArrayT(); 27915 readTextSmallJsonSmallArrayT(); 27916 readTextSmallStringSmallArrayT(); 27917 readStreamSmallArrayT(); 27918 writeTextSmallArrayT(); 27919 writeTextSmallJsonSmallArrayT(); 27920 writeTextSmallStringSmallArrayT(); 27921 writeStreamSmallArrayT(); 27922 appendTextSmallArrayT(); 27923 appendTextSmallStringSmallArrayT(); 27924 typeSmallStringSmallArrayT(); 27925 typeSmallStringsSmallArrayT(); 27926 isETypeSmallArrayT(); 27927 isEUndefinedSmallArrayT(); 27928 isEBoolSmallArrayT(); 27929 isEContainerSmallArrayT(); 27930 isEDictSmallArrayT(); 27931 isEDoubleSmallArrayT(); 27932 isEIntSmallArrayT(); 27933 isEStringSmallArrayT(); 27934 isEFaststringSmallArrayT(); 27935 isEArraySmallArrayT(); 27936 isEBytesSmallArrayT(); 27937 areAllETypeSmallArrayT(); 27938 areAllEUndefinedSmallArrayT(); 27939 areAllEBoolSmallArrayT(); 27940 areAllEContainerSmallArrayT(); 27941 areAllEDictSmallArrayT(); 27942 areAllEDoubleSmallArrayT(); 27943 areAllEIntSmallArrayT(); 27944 areAllEStringSmallArrayT(); 27945 areAllEFaststringSmallArrayT(); 27946 areAllEArraySmallArrayT(); 27947 areAllEBytesSmallArrayT(); 27948 allocSmallArrayGT(); 27949 duplicateSmallArrayGT(); 27950 freeSmallArrayGT(); 27951 fromArraySmallArrayGT(); 27952 fromCArraySmallArrayGT(); 27953 setFromSmallArrayGT(); 27954 setFromCSmallArrayGT(); 27955 pushSmallArrayGT(); 27956 pushUndefinedSmallArrayGT(); 27957 pushBoolSmallArrayGT(); 27958 pushDoubleSmallArrayGT(); 27959 pushIntSmallArrayGT(); 27960 pushSSmallArrayGT(); 27961 pushCharSmallArrayGT(); 27962 pushDictSmallArrayGT(); 27963 pushArraySmallArrayGT(); 27964 pushArraycSmallArrayGT(); 27965 pushCArraycSmallArrayGT(); 27966 pushVoidSmallArrayGT(); 27967 pushSmallBoolSmallArrayGT(); 27968 pushSmallBytesSmallArrayGT(); 27969 pushSmallDoubleSmallArrayGT(); 27970 pushSmallIntSmallArrayGT(); 27971 pushSmallJsonSmallArrayGT(); 27972 pushSmallStringSmallArrayGT(); 27973 pushSmallContainerSmallArrayGT(); 27974 pushNFreeSmallArrayGT(); 27975 pushNFreeUndefinedSmallArrayGT(); 27976 pushNFreeSSmallArrayGT(); 27977 pushNFreeDictSmallArrayGT(); 27978 pushNFreeArraySmallArrayGT(); 27979 pushNFreeArraycSmallArrayGT(); 27980 pushNFreeSmallBoolSmallArrayGT(); 27981 pushNFreeSmallBytesSmallArrayGT(); 27982 pushNFreeSmallDoubleSmallArrayGT(); 27983 pushNFreeSmallIntSmallArrayGT(); 27984 pushNFreeSmallJsonSmallArrayGT(); 27985 pushNFreeSmallStringSmallArrayGT(); 27986 pushNFreeSmallContainerSmallArrayGT(); 27987 popSmallArrayGT(); 27988 popUndefinedSmallArrayGT(); 27989 popBoolSmallArrayGT(); 27990 popDoubleSmallArrayGT(); 27991 popIntSmallArrayGT(); 27992 popInt32SmallArrayGT(); 27993 popUintSmallArrayGT(); 27994 popUint32SmallArrayGT(); 27995 popSSmallArrayGT(); 27996 popDictSmallArrayGT(); 27997 popArraySmallArrayGT(); 27998 popSmallBoolSmallArrayGT(); 27999 popSmallBytesSmallArrayGT(); 28000 popSmallDoubleSmallArrayGT(); 28001 popSmallIntSmallArrayGT(); 28002 popSmallJsonSmallArrayGT(); 28003 popSmallStringSmallArrayGT(); 28004 popVoidSmallArrayGT(); 28005 popSmallContainerSmallArrayGT(); 28006 prependSmallArrayGT(); 28007 prependUndefinedSmallArrayGT(); 28008 prependBoolSmallArrayGT(); 28009 prependDoubleSmallArrayGT(); 28010 prependIntSmallArrayGT(); 28011 prependSSmallArrayGT(); 28012 prependCharSmallArrayGT(); 28013 prependDictSmallArrayGT(); 28014 prependArraySmallArrayGT(); 28015 prependArraycSmallArrayGT(); 28016 prependCArraycSmallArrayGT(); 28017 prependVoidSmallArrayGT(); 28018 prependSmallBoolSmallArrayGT(); 28019 prependSmallBytesSmallArrayGT(); 28020 prependSmallDoubleSmallArrayGT(); 28021 prependSmallIntSmallArrayGT(); 28022 prependSmallJsonSmallArrayGT(); 28023 prependSmallStringSmallArrayGT(); 28024 prependSmallContainerSmallArrayGT(); 28025 prependNFreeSmallArrayGT(); 28026 prependNFreeUndefinedSmallArrayGT(); 28027 prependNFreeSSmallArrayGT(); 28028 prependNFreeDictSmallArrayGT(); 28029 prependNFreeArraySmallArrayGT(); 28030 prependNFreeArraycSmallArrayGT(); 28031 prependNFreeSmallBoolSmallArrayGT(); 28032 prependNFreeSmallBytesSmallArrayGT(); 28033 prependNFreeSmallDoubleSmallArrayGT(); 28034 prependNFreeSmallIntSmallArrayGT(); 28035 prependNFreeSmallJsonSmallArrayGT(); 28036 prependNFreeSmallStringSmallArrayGT(); 28037 prependNFreeSmallContainerSmallArrayGT(); 28038 dequeueSmallArrayGT(); 28039 dequeueUndefinedSmallArrayGT(); 28040 dequeueBoolSmallArrayGT(); 28041 dequeueDoubleSmallArrayGT(); 28042 dequeueIntSmallArrayGT(); 28043 dequeueInt32SmallArrayGT(); 28044 dequeueUintSmallArrayGT(); 28045 dequeueUint32SmallArrayGT(); 28046 dequeueSSmallArrayGT(); 28047 dequeueDictSmallArrayGT(); 28048 dequeueArraySmallArrayGT(); 28049 dequeueSmallBoolSmallArrayGT(); 28050 dequeueSmallBytesSmallArrayGT(); 28051 dequeueSmallDoubleSmallArrayGT(); 28052 dequeueSmallIntSmallArrayGT(); 28053 dequeueSmallJsonSmallArrayGT(); 28054 dequeueSmallStringSmallArrayGT(); 28055 dequeueVoidSmallArrayGT(); 28056 dequeueSmallContainerSmallArrayGT(); 28057 getAtSmallArrayGT(); 28058 getAtUndefinedSmallArrayGT(); 28059 getAtBoolSmallArrayGT(); 28060 getAtBoolPSmallArrayGT(); 28061 getAtDoubleSmallArrayGT(); 28062 getAtDoublePSmallArrayGT(); 28063 getAtIntSmallArrayGT(); 28064 getAtIntPSmallArrayGT(); 28065 getAtInt32SmallArrayGT(); 28066 getAtInt32PSmallArrayGT(); 28067 getAtUintSmallArrayGT(); 28068 getAtUintPSmallArrayGT(); 28069 getAtUint32SmallArrayGT(); 28070 getAtUint32PSmallArrayGT(); 28071 getAtSSmallArrayGT(); 28072 getAtDictSmallArrayGT(); 28073 getAtArraySmallArrayGT(); 28074 getAtSmallBoolSmallArrayGT(); 28075 getAtSmallBytesSmallArrayGT(); 28076 getAtSmallDoubleSmallArrayGT(); 28077 getAtSmallIntSmallArrayGT(); 28078 getAtSmallJsonSmallArrayGT(); 28079 getAtSmallStringSmallArrayGT(); 28080 getAtVoidSmallArrayGT(); 28081 getAtSmallContainerSmallArrayGT(); 28082 getAtNDupSmallArrayGT(); 28083 getAtNDupUndefinedSmallArrayGT(); 28084 getAtNDupBoolSmallArrayGT(); 28085 getAtNDupDoubleSmallArrayGT(); 28086 getAtNDupIntSmallArrayGT(); 28087 getAtNDupInt32SmallArrayGT(); 28088 getAtNDupUintSmallArrayGT(); 28089 getAtNDupUint32SmallArrayGT(); 28090 getAtNDupSSmallArrayGT(); 28091 getAtNDupDictSmallArrayGT(); 28092 getAtNDupArraySmallArrayGT(); 28093 getAtNDupSmallBoolSmallArrayGT(); 28094 getAtNDupSmallBytesSmallArrayGT(); 28095 getAtNDupSmallDoubleSmallArrayGT(); 28096 getAtNDupSmallIntSmallArrayGT(); 28097 getAtNDupSmallJsonSmallArrayGT(); 28098 getAtNDupSmallStringSmallArrayGT(); 28099 getAtNDupVoidSmallArrayGT(); 28100 getAtNDupSmallContainerSmallArrayGT(); 28101 setAtSmallArrayGT(); 28102 setAtUndefinedSmallArrayGT(); 28103 setAtBoolSmallArrayGT(); 28104 setAtDoubleSmallArrayGT(); 28105 setAtIntSmallArrayGT(); 28106 setAtSSmallArrayGT(); 28107 setAtCharSmallArrayGT(); 28108 setAtDictSmallArrayGT(); 28109 setAtArraySmallArrayGT(); 28110 setAtArraycSmallArrayGT(); 28111 setAtCArraycSmallArrayGT(); 28112 setAtVoidSmallArrayGT(); 28113 setAtSmallBoolSmallArrayGT(); 28114 setAtSmallBytesSmallArrayGT(); 28115 setAtSmallDoubleSmallArrayGT(); 28116 setAtSmallIntSmallArrayGT(); 28117 setAtSmallJsonSmallArrayGT(); 28118 setAtSmallStringSmallArrayGT(); 28119 setAtSmallContainerSmallArrayGT(); 28120 setAtNFreeSmallArrayGT(); 28121 setAtNFreeUndefinedSmallArrayGT(); 28122 setAtNFreeSSmallArrayGT(); 28123 setAtNFreeDictSmallArrayGT(); 28124 setAtNFreeArraySmallArrayGT(); 28125 setAtNFreeArraycSmallArrayGT(); 28126 setAtNFreeSmallBoolSmallArrayGT(); 28127 setAtNFreeSmallBytesSmallArrayGT(); 28128 setAtNFreeSmallDoubleSmallArrayGT(); 28129 setAtNFreeSmallIntSmallArrayGT(); 28130 setAtNFreeSmallJsonSmallArrayGT(); 28131 setAtNFreeSmallStringSmallArrayGT(); 28132 setAtNFreeSmallContainerSmallArrayGT(); 28133 setPAtDictSmallArrayGT(); 28134 setPAtArraySmallArrayGT(); 28135 setPAtSmallJsonSmallArrayGT(); 28136 setPAtSmallStringSmallArrayGT(); 28137 setPAtNFreeDictSmallArrayGT(); 28138 setPAtNFreeArraySmallArrayGT(); 28139 setPAtNFreeSmallJsonSmallArrayGT(); 28140 setPAtNFreeSmallStringSmallArrayGT(); 28141 getNumSmallArrayGT(); 28142 reverseSmallArrayGT(); 28143 appendSmallArrayGT(); 28144 appendSmallJsonSmallArrayGT(); 28145 appendNSmashSmallArrayGT(); 28146 appendNSmashSmallJsonSmallArrayGT(); 28147 appendArraySmallArrayGT(); 28148 appendNSmashArraySmallArrayGT(); 28149 appendCArraySmallArrayGT(); 28150 shiftSmallArrayGT(); 28151 shiftSmallJsonSmallArrayGT(); 28152 shiftNSmashSmallArrayGT(); 28153 shiftNSmashSmallJsonSmallArrayGT(); 28154 addSmallArrayGT(); 28155 sliceSmallArrayGT(); 28156 cropSmallArrayGT(); 28157 cropElemSmallArrayGT(); 28158 cropElemUndefinedSmallArrayGT(); 28159 cropElemBoolSmallArrayGT(); 28160 cropElemDoubleSmallArrayGT(); 28161 cropElemIntSmallArrayGT(); 28162 cropElemInt32SmallArrayGT(); 28163 cropElemUintSmallArrayGT(); 28164 cropElemUint32SmallArrayGT(); 28165 cropElemSSmallArrayGT(); 28166 cropElemDictSmallArrayGT(); 28167 cropElemArraySmallArrayGT(); 28168 cropElemSmallBoolSmallArrayGT(); 28169 cropElemSmallBytesSmallArrayGT(); 28170 cropElemSmallDoubleSmallArrayGT(); 28171 cropElemSmallIntSmallArrayGT(); 28172 cropElemSmallJsonSmallArrayGT(); 28173 cropElemSmallStringSmallArrayGT(); 28174 cropElemVoidSmallArrayGT(); 28175 cropElemSmallContainerSmallArrayGT(); 28176 copySmallArrayGT(); 28177 insertSmallArrayGT(); 28178 insertSmallJsonSmallArrayGT(); 28179 insertNSmashSmallArrayGT(); 28180 insertNSmashSmallJsonSmallArrayGT(); 28181 injectSmallArrayGT(); 28182 injectUndefinedSmallArrayGT(); 28183 injectBoolSmallArrayGT(); 28184 injectDoubleSmallArrayGT(); 28185 injectIntSmallArrayGT(); 28186 injectSSmallArrayGT(); 28187 injectCharSmallArrayGT(); 28188 injectDictSmallArrayGT(); 28189 injectArraySmallArrayGT(); 28190 injectArraycSmallArrayGT(); 28191 injectCArraycSmallArrayGT(); 28192 injectVoidSmallArrayGT(); 28193 injectSmallBoolSmallArrayGT(); 28194 injectSmallBytesSmallArrayGT(); 28195 injectSmallDoubleSmallArrayGT(); 28196 injectSmallIntSmallArrayGT(); 28197 injectSmallJsonSmallArrayGT(); 28198 injectSmallStringSmallArrayGT(); 28199 injectSmallContainerSmallArrayGT(); 28200 injectNFreeSmallArrayGT(); 28201 injectNFreeUndefinedSmallArrayGT(); 28202 injectNFreeSSmallArrayGT(); 28203 injectNFreeDictSmallArrayGT(); 28204 injectNFreeArraySmallArrayGT(); 28205 injectNFreeArraycSmallArrayGT(); 28206 injectNFreeSmallBoolSmallArrayGT(); 28207 injectNFreeSmallBytesSmallArrayGT(); 28208 injectNFreeSmallDoubleSmallArrayGT(); 28209 injectNFreeSmallIntSmallArrayGT(); 28210 injectNFreeSmallJsonSmallArrayGT(); 28211 injectNFreeSmallStringSmallArrayGT(); 28212 injectNFreeSmallContainerSmallArrayGT(); 28213 delSmallArrayGT(); 28214 delElemSmallArrayGT(); 28215 removeSmallArrayGT(); 28216 removeElemSmallArrayGT(); 28217 sortSmallArrayGT(); 28218 sortFSmallArrayGT(); 28219 icSortSmallArrayGT(); 28220 equalSmallArrayGT(); 28221 equalSmallArraySmallJsonGT(); 28222 equalSmallArrayArrayGT(); 28223 equalSmallArrayCArrayGT(); 28224 equalSmallArrayBaseGT(); 28225 icEqualSmallArrayGT(); 28226 icEqualSmallArraySmallJsonGT(); 28227 icEqualSmallArrayArrayGT(); 28228 icEqualSmallArrayCArrayGT(); 28229 icEqualSmallArrayBaseGT(); 28230 lenSmallArrayGT(); 28231 trimSmallArrayGT(); 28232 hasSmallArrayGT(); 28233 hasUndefinedSmallArrayGT(); 28234 hasBoolSmallArrayGT(); 28235 hasDoubleSmallArrayGT(); 28236 hasIntSmallArrayGT(); 28237 hasSSmallArrayGT(); 28238 hasCharSmallArrayGT(); 28239 hasDictSmallArrayGT(); 28240 hasArraySmallArrayGT(); 28241 hasArraycSmallArrayGT(); 28242 hasCArraycSmallArrayGT(); 28243 hasSmallBoolSmallArrayGT(); 28244 hasSmallBytesSmallArrayGT(); 28245 hasSmallDoubleSmallArrayGT(); 28246 hasSmallIntSmallArrayGT(); 28247 hasSmallJsonSmallArrayGT(); 28248 hasSmallStringSmallArrayGT(); 28249 hasSmallContainerSmallArrayGT(); 28250 indexOfSmallArrayGT(); 28251 indexOfUndefinedSmallArrayGT(); 28252 indexOfBoolSmallArrayGT(); 28253 indexOfDoubleSmallArrayGT(); 28254 indexOfIntSmallArrayGT(); 28255 indexOfSSmallArrayGT(); 28256 indexOfCharSmallArrayGT(); 28257 indexOfDictSmallArrayGT(); 28258 indexOfArraySmallArrayGT(); 28259 indexOfArraycSmallArrayGT(); 28260 indexOfCArraycSmallArrayGT(); 28261 indexOfSmallBoolSmallArrayGT(); 28262 indexOfSmallBytesSmallArrayGT(); 28263 indexOfSmallDoubleSmallArrayGT(); 28264 indexOfSmallIntSmallArrayGT(); 28265 indexOfSmallJsonSmallArrayGT(); 28266 indexOfSmallStringSmallArrayGT(); 28267 indexOfSmallContainerSmallArrayGT(); 28268 binarySearchSmallArrayGT(); 28269 binarySearchUndefinedSmallArrayGT(); 28270 binarySearchBoolSmallArrayGT(); 28271 binarySearchDoubleSmallArrayGT(); 28272 binarySearchIntSmallArrayGT(); 28273 binarySearchSSmallArrayGT(); 28274 binarySearchCharSmallArrayGT(); 28275 binarySearchDictSmallArrayGT(); 28276 binarySearchArraySmallArrayGT(); 28277 binarySearchArraycSmallArrayGT(); 28278 binarySearchCArraycSmallArrayGT(); 28279 binarySearchSmallBoolSmallArrayGT(); 28280 binarySearchSmallBytesSmallArrayGT(); 28281 binarySearchSmallDoubleSmallArrayGT(); 28282 binarySearchSmallIntSmallArrayGT(); 28283 binarySearchSmallJsonSmallArrayGT(); 28284 binarySearchSmallStringSmallArrayGT(); 28285 binarySearchSmallContainerSmallArrayGT(); 28286 uniqSmallArrayGT(); 28287 icHasSmallArrayGT(); 28288 icHasSSmallArrayGT(); 28289 icHasCharSmallArrayGT(); 28290 icHasDictSmallArrayGT(); 28291 icHasArraySmallArrayGT(); 28292 icHasArraycSmallArrayGT(); 28293 icHasCArraycSmallArrayGT(); 28294 icHasSmallJsonSmallArrayGT(); 28295 icHasSmallStringSmallArrayGT(); 28296 icIndexOfSmallArrayGT(); 28297 icIndexOfSSmallArrayGT(); 28298 icIndexOfCharSmallArrayGT(); 28299 icIndexOfDictSmallArrayGT(); 28300 icIndexOfArraySmallArrayGT(); 28301 icIndexOfArraycSmallArrayGT(); 28302 icIndexOfCArraycSmallArrayGT(); 28303 icIndexOfSmallJsonSmallArrayGT(); 28304 icIndexOfSmallStringSmallArrayGT(); 28305 icBinarySearchSmallArrayGT(); 28306 icBinarySearchSSmallArrayGT(); 28307 icBinarySearchCharSmallArrayGT(); 28308 icBinarySearchDictSmallArrayGT(); 28309 icBinarySearchArraySmallArrayGT(); 28310 icBinarySearchArraycSmallArrayGT(); 28311 icBinarySearchCArraycSmallArrayGT(); 28312 icBinarySearchSmallJsonSmallArrayGT(); 28313 icBinarySearchSmallStringSmallArrayGT(); 28314 icUniqSmallArrayGT(); 28315 compactSmallArrayGT(); 28316 emptySmallArrayGT(); 28317 isEmptySmallArrayGT(); 28318 isBlankSmallArrayGT(); 28319 joinSmallArrayGT(); 28320 joinCharSmallArrayGT(); 28321 joinSmallJsonSmallArrayGT(); 28322 joinSmallStringSmallArrayGT(); 28323 joinSSmallArrayGT(); 28324 joinCharSSmallArrayGT(); 28325 joinSmallJsonSSmallArrayGT(); 28326 joinSmallStringSSmallArrayGT(); 28327 zipSmallArrayGT(); 28328 zipSmallJsonSmallArrayGT(); 28329 zipSmallJsonSmallArraySmallArrayGT(); 28330 zipSmallJsonSmallJsonSmallArrayGT(); 28331 zipSmallJsonCharSmallArrayGT(); 28332 zipSmallJsonCCharSmallArrayGT(); 28333 zipArraySmallArrayGT(); 28334 zipCArraySmallArrayGT(); 28335 zipArraySmallJsonSmallArrayGT(); 28336 zipCArraySmallJsonSmallArrayGT(); 28337 zipCharSmallArrayGT(); 28338 zipCCharSmallArrayGT(); 28339 zipArrayCharSmallArrayGT(); 28340 zipArrayCCharSmallArrayGT(); 28341 zipCArrayCharSmallArrayGT(); 28342 zipCArrayCCharSmallArrayGT(); 28343 logSmallArrayGT(); 28344 readTextSmallArrayGT(); 28345 readTextSmallJsonSmallArrayGT(); 28346 readTextSmallStringSmallArrayGT(); 28347 readStreamSmallArrayGT(); 28348 writeTextSmallArrayGT(); 28349 writeTextSmallJsonSmallArrayGT(); 28350 writeTextSmallStringSmallArrayGT(); 28351 writeStreamSmallArrayGT(); 28352 appendTextSmallArrayGT(); 28353 appendTextSmallStringSmallArrayGT(); 28354 typeSmallStringSmallArrayGT(); 28355 typeSmallStringsSmallArrayGT(); 28356 cSmallArrayT(); 28357 28358 finalizeSmallDict(); 28359 finalizeSmallArray(); 28360 finalizeSmallJson(); 28361 finalizeUndefined(); 28362 finalizeSmallBytes(); 28363 finalizeSmallBool(); 28364 finalizeSmallContainer(); 28365 finalizeSmallDouble(); 28366 finalizeSmallInt(); 28367 finalizeSmallString(); 28368 }