libsheepyCSmallArrayCuTest.c (723422B)
1 #include <stdlib.h> 2 #include <stdio.h> 3 #include <string.h> 4 5 #include "CuTest/CuTest.h" 6 7 #define ck_assert_str_eq(a,b) CuAssertStrEquals(tc, b, a) 8 #define ck_assert_str_ne(a,b) CuAssertStrNotEquals(tc, b, a) 9 #define ck_assert_ptr_eq(a,b) CuAssertPtrEquals(tc, b, a) 10 #define ck_assert_ptr_ne(a,b) CuAssertPtrNotEquals(tc, b, a) 11 #define ck_assert_uint_eq(a,b) CuAssertUintEquals(tc, b, a) 12 #define ck_assert_uint_ne(a,b) CuAssertUintNotEquals(tc, b, a) 13 #define ck_assert_int_eq(a,b) CuAssertIntEquals(tc, b, a) 14 #define ck_assert_int_ne(a,b) CuAssertIntNotEquals(tc, b, a) 15 #define ck_assert(a) CuAssertTrue(tc, a) 16 17 18 #include "../libsheepy.h" 19 #include "../libsheepyObject.h" 20 21 #ifdef __GNUC__ 22 #define UNUSED __attribute__ ((unused)) 23 #else 24 #define UNUSED 25 #endif 26 27 // TODO redirect stderr 28 29 30 void allocArraySmallArrayT(CuTest *tc UNUSED) { 31 32 smallArrayt* r; 33 char *array[] = {"a", "bb", NULL}; 34 35 r = allocArraySmallArray(array); 36 ck_assert_ptr_ne(r, NULL); 37 char *s = toStringO(r); 38 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 39 free(s); 40 41 terminateO(r); 42 43 } 44 45 46 void allocCArraySmallArrayT(CuTest *tc UNUSED) { 47 48 smallArrayt* r; 49 const char *array[] = {"a", "bb", NULL}; 50 51 r = allocCArraySmallArray(array); 52 ck_assert_ptr_ne(r, NULL); 53 char *s = toStringO(r); 54 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 55 free(s); 56 57 terminateO(r); 58 59 } 60 61 62 void createSAFT(CuTest *tc UNUSED) { 63 64 smallArrayt* r; 65 66 r = createSA("a", "bb"); 67 ck_assert_ptr_ne(r, NULL); 68 char *s = toStringO(r); 69 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 70 free(s); 71 72 terminateO(r); 73 74 75 } 76 77 78 void getsoSmallArrayT(CuTest *tc UNUSED) { 79 80 sArrayt* r; 81 smallArrayt *self = allocG(rtSmallArrayt); 82 83 pushG(self, 1); 84 r = getsoO(self); 85 ck_assert_ptr_eq(r, self->a); 86 terminateO(self); 87 88 } 89 90 91 void setsoSmallArrayT(CuTest *tc UNUSED) { 92 93 smallArrayt *self = allocG(rtSmallArrayt); 94 sArrayt *so; 95 96 createSmallArray(a); 97 98 pushG(&a, 1); 99 pushG(&a, 2); 100 101 char *as = null; 102 // reset test: free iterElement in a 103 iter(&a, E) { 104 as = toStringO(E); 105 break; 106 } 107 ck_assert_str_eq(as, "1"); 108 free(as); 109 110 so = getsoO(&a); 111 resetO(&a); 112 113 setsoO(self, so); 114 ck_assert_ptr_eq(so, self->a); 115 terminateO(self); 116 117 } 118 119 120 void mirrorSmallArrayT(CuTest *tc UNUSED) { 121 122 smallArrayt* r; 123 smallArrayt *self = allocG(rtSmallArrayt); 124 125 // empty self 126 r = mirrorO(self); 127 ck_assert_ptr_eq(r->a, null); 128 finishO(r); 129 130 // non empty with iterator 131 pushG(self, 1); 132 pushG(self, 2); 133 char *as = null; 134 iter(self, E) { 135 as = toStringO(E); 136 break; 137 } 138 ck_assert_str_eq(as, "1"); 139 free(as); 140 r = mirrorO(self); 141 ck_assert_ptr_eq(r->a, self->a); 142 finishO(r); 143 144 terminateO(self); 145 146 } 147 148 149 void fromArrayNFreeSmallArrayT(CuTest *tc UNUSED) { 150 151 smallArrayt* r; 152 smallArrayt *self = allocG(rtSmallArrayt); 153 char **array; 154 size_t size = 3; 155 156 // libsheepy list 157 array = listCreateS("a", "bb", "ccc"); 158 r = fromArrayNFreeO(self, array, 0); 159 ck_assert_ptr_eq(self, r); 160 char *s = toStringO(r); 161 ck_assert_str_eq(s, "[\"a\",\"bb\",\"ccc\"]"); 162 free(s); 163 164 // array with strings 165 array = allocArray(array, size); 166 array[0] = strdup("a1"); 167 array[1] = strdup("bb1"); 168 array[2] = strdup("ccc1"); 169 r = fromArrayNFreeO(self, array, size); 170 ck_assert_ptr_eq(self, r); 171 s = toStringO(r); 172 ck_assert_str_eq(s, "[\"a1\",\"bb1\",\"ccc1\"]"); 173 free(s); 174 175 // NULL array 176 r = fromArrayNFreeO(self, null, 1); 177 ck_assert_ptr_eq(r, null); 178 terminateO(self); 179 180 } 181 182 183 void pushUndefinedSmallArrayT(CuTest *tc UNUSED) { 184 185 smallArrayt* r; 186 smallArrayt *self = allocG(rtSmallArrayt); 187 188 // add an element to check that push adds the second element 189 // at the end 190 r = self->f->pushInt(self, 1); 191 ck_assert_ptr_ne(r, null); 192 193 r = self->f->pushUndefined(self); 194 ck_assert_ptr_ne(r, null); 195 ck_assert_int_eq(lenO(r), 2); 196 char *s = toStringO(r); 197 ck_assert_str_eq(s, "[1,null]"); 198 free(s); 199 terminateO(self); 200 201 } 202 203 204 void pushBoolSmallArrayT(CuTest *tc UNUSED) { 205 206 smallArrayt* r; 207 smallArrayt *self = allocG(rtSmallArrayt); 208 209 // add an element to check that push adds the second element 210 // at the end 211 r = self->f->pushInt(self, 1); 212 ck_assert_ptr_ne(r, null); 213 214 r = self->f->pushBool(self, TRUE); 215 ck_assert_ptr_ne(r, null); 216 ck_assert_int_eq(lenO(r), 2); 217 char *s = toStringO(r); 218 ck_assert_str_eq(s, "[1,true]"); 219 free(s); 220 terminateO(self); 221 222 } 223 224 225 void pushDoubleSmallArrayT(CuTest *tc UNUSED) { 226 227 smallArrayt* r; 228 smallArrayt *self = allocG(rtSmallArrayt); 229 230 // add an element to check that push adds the second element 231 // at the end 232 r = self->f->pushInt(self, 1); 233 ck_assert_ptr_ne(r, null); 234 235 r = self->f->pushDouble(self, 1.0); 236 ck_assert_ptr_ne(r, null); 237 ck_assert_int_eq(lenO(r), 2); 238 char *s = toStringO(r); 239 ck_assert_str_eq(s, "[1,1.000000e+00]"); 240 free(s); 241 terminateO(self); 242 243 } 244 245 246 void pushIntSmallArrayT(CuTest *tc UNUSED) { 247 248 smallArrayt* r; 249 smallArrayt *self = allocG(rtSmallArrayt); 250 251 // add an element to check that push adds the second element 252 // at the end 253 r = self->f->pushInt(self, 1); 254 ck_assert_ptr_ne(r, null); 255 256 r = self->f->pushInt(self, 1); 257 ck_assert_ptr_ne(r, null); 258 ck_assert_int_eq(lenO(r), 2); 259 char *s = toStringO(r); 260 ck_assert_str_eq(s, "[1,1]"); 261 free(s); 262 terminateO(self); 263 264 } 265 266 267 void pushSSmallArrayT(CuTest *tc UNUSED) { 268 269 smallArrayt* r; 270 smallArrayt *self = allocG(rtSmallArrayt); 271 272 // add an element to check that push adds the second element 273 // at the end 274 r = self->f->pushInt(self, 1); 275 ck_assert_ptr_ne(r, null); 276 277 r = self->f->pushS(self, null); 278 ck_assert_ptr_eq(r, null); 279 ck_assert_int_eq(lenO(self), 1); 280 char *s = toStringO(self); 281 ck_assert_str_eq(s, "[1]"); 282 free(s); 283 284 char *str = "poi"; 285 r = self->f->pushS(self, str); 286 ck_assert_ptr_ne(r, null); 287 ck_assert_int_eq(lenO(self), 2); 288 s = toStringO(r); 289 ck_assert_str_eq(s, "[1,\"poi\"]"); 290 free(s); 291 292 terminateO(self); 293 294 } 295 296 297 void pushCharSmallArrayT(CuTest *tc UNUSED) { 298 299 smallArrayt* r; 300 smallArrayt *self = allocG(rtSmallArrayt); 301 302 // add an element to check that push adds the second element 303 // at the end 304 r = self->f->pushInt(self, 1); 305 ck_assert_ptr_ne(r, null); 306 307 r = self->f->pushChar(self, 'a'); 308 ck_assert_ptr_ne(r, null); 309 ck_assert_int_eq(lenO(r), 2); 310 char *s = toStringO(r); 311 ck_assert_str_eq(s, "[1,\"a\"]"); 312 free(s); 313 terminateO(self); 314 315 } 316 317 318 void pushDictSmallArrayT(CuTest *tc UNUSED) { 319 320 smallArrayt* r; 321 smallArrayt *self = allocG(rtSmallArrayt); 322 smallDictt *dict = allocG(rtSmallDictt); 323 324 // add an element to check that push adds the second element 325 // at the end 326 r = self->f->pushInt(self, 1); 327 ck_assert_ptr_ne(r, null); 328 329 // push dict 330 r = self->f->pushDict(self, dict); 331 ck_assert_ptr_ne(r, null); 332 ck_assert_int_eq(lenO(r), 2); 333 finishO(dict); 334 ck_assert_ptr_ne(r, null); 335 char *s = toStringO(r); 336 ck_assert_str_eq(s, "[1,{}]"); 337 free(s); 338 // non smallDict object 339 dict = (smallDictt*) allocSmallInt(2); 340 r = self->f->pushDict(self, dict); 341 ck_assert_ptr_eq(r, null); 342 terminateO(dict); 343 // null 344 r = self->f->pushDict(self, null); 345 ck_assert_ptr_eq(r, null); 346 ck_assert_int_eq(lenO(self), 2); 347 s = toStringO(self); 348 ck_assert_str_eq(s, "[1,{}]"); 349 free(s); 350 terminateO(self); 351 352 } 353 354 355 void pushArraySmallArrayT(CuTest *tc UNUSED) { 356 357 smallArrayt* r; 358 smallArrayt *self = allocG(rtSmallArrayt); 359 smallArrayt *array = allocG(rtSmallArrayt); 360 361 // add an element to check that push adds the second element 362 // at the end 363 r = self->f->pushInt(self, 1); 364 ck_assert_ptr_ne(r, null); 365 366 r = self->f->pushArray(self, array); 367 ck_assert_ptr_ne(r, null); 368 ck_assert_int_eq(lenO(r), 2); 369 finishO(array); 370 char *s = toStringO(r); 371 ck_assert_str_eq(s, "[1,[]]"); 372 free(s); 373 // non smallArray object 374 array = (smallArrayt*) allocSmallInt(2); 375 r = self->f->pushArray(self, array); 376 ck_assert_ptr_eq(r, null); 377 terminateO(array); 378 // null 379 r = self->f->pushArray(self, null); 380 ck_assert_ptr_eq(r, null); 381 ck_assert_int_eq(lenO(self), 2); 382 s = toStringO(self); 383 ck_assert_str_eq(s, "[1,[]]"); 384 free(s); 385 terminateO(self); 386 387 } 388 389 390 void pushArraycSmallArrayT(CuTest *tc UNUSED) { 391 392 smallArrayt* r; 393 smallArrayt *self = allocG(rtSmallArrayt); 394 char **array = listCreateS("a","bb"); 395 396 // add an element to check that push adds the second element 397 // at the end 398 r = self->f->pushInt(self, 1); 399 ck_assert_ptr_ne(r, null); 400 401 r = self->f->pushArrayc(self, array); 402 ck_assert_ptr_ne(r, null); 403 ck_assert_int_eq(lenO(r), 2); 404 listFreeS(array); 405 char *s = toStringO(r); 406 ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]"); 407 free(s); 408 // null 409 r = self->f->pushArrayc(self, null); 410 ck_assert_ptr_eq(r, null); 411 ck_assert_int_eq(lenO(self), 2); 412 s = toStringO(self); 413 ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]"); 414 free(s); 415 terminateO(self); 416 417 } 418 419 420 void pushSmallBoolSmallArrayT(CuTest *tc UNUSED) { 421 422 smallArrayt* r; 423 smallArrayt *self = allocG(rtSmallArrayt); 424 smallBoolt *value = allocG(TRUE); 425 426 // add an element to check that push adds the second element 427 // at the end 428 r = self->f->pushInt(self, 1); 429 ck_assert_ptr_ne(r, null); 430 431 r = self->f->pushSmallBool(self, value); 432 ck_assert_ptr_ne(r, null); 433 ck_assert_int_eq(lenO(r), 2); 434 finishO(value); 435 char *s = toStringO(r); 436 ck_assert_str_eq(s, "[1,true]"); 437 free(s); 438 // non smallBool object 439 value = (smallBoolt*) allocSmallInt(2); 440 r = self->f->pushSmallBool(self, value); 441 ck_assert_ptr_eq(r, null); 442 terminateO(value); 443 // bool object with no data 444 createAllocateSmallBool(b); 445 r = self->f->pushSmallBool(self, b); 446 ck_assert_ptr_ne(r, null); 447 ck_assert_int_eq(lenO(r), 3); 448 finishO(b); 449 s = toStringO(r); 450 ck_assert_str_eq(s, "[1,true,false]"); 451 free(s); 452 // null 453 r = self->f->pushSmallBool(self, null); 454 ck_assert_ptr_eq(r, null); 455 ck_assert_int_eq(lenO(self), 3); 456 s = toStringO(self); 457 ck_assert_str_eq(s, "[1,true,false]"); 458 free(s); 459 terminateO(self); 460 461 } 462 463 464 void pushSmallBytesSmallArrayT(CuTest *tc UNUSED) { 465 466 smallArrayt* r; 467 smallArrayt *self = allocG(rtSmallArrayt); 468 createAllocateSmallBytes(value); 469 470 // add an element to check that push adds the second element 471 // at the end 472 r = self->f->pushInt(self, 1); 473 ck_assert_ptr_ne(r, null); 474 // the smallBytes container is empty 475 r = self->f->pushSmallBytes(self, value); 476 ck_assert_ptr_ne(r, null); 477 ck_assert_int_eq(lenO(r), 2); 478 char *s = toStringO(r); 479 ck_assert_str_eq(s, "[1,[]]"); 480 free(s); 481 // reuse value 482 value->B = null; 483 char *buffer = "poi"; 484 pushBufferO(value, buffer, strlen(buffer)); 485 r = self->f->pushSmallBytes(self, value); 486 finishO(value); 487 ck_assert_ptr_ne(r, null); 488 ck_assert_int_eq(lenO(r), 3); 489 s = toStringO(r); 490 ck_assert_str_eq(s, "[1,[],[0x70,0x6f,0x69]]"); 491 free(s); 492 // non smallBytes object 493 value = (smallBytest*) allocSmallInt(2); 494 r = self->f->pushSmallBytes(self, value); 495 ck_assert_ptr_eq(r, null); 496 terminateO(value); 497 // null 498 r = self->f->pushSmallBytes(self, null); 499 ck_assert_ptr_eq(r, null); 500 ck_assert_int_eq(lenO(self), 3); 501 s = toStringO(self); 502 ck_assert_str_eq(s, "[1,[],[0x70,0x6f,0x69]]"); 503 free(s); 504 terminateO(self); 505 506 } 507 508 509 void pushSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 510 511 smallArrayt* r; 512 smallArrayt *self = allocG(rtSmallArrayt); 513 smallDoublet *value = allocG(1.0); 514 515 // add an element to check that push adds the second element 516 // at the end 517 r = self->f->pushInt(self, 1); 518 ck_assert_ptr_ne(r, null); 519 520 r = self->f->pushSmallDouble(self, value); 521 ck_assert_ptr_ne(r, null); 522 ck_assert_int_eq(lenO(r), 2); 523 finishO(value); 524 char *s = toStringO(r); 525 ck_assert_str_eq(s, "[1,1.000000e+00]"); 526 free(s); 527 // object with no data 528 createAllocateSmallDouble(b); 529 r = self->f->pushSmallDouble(self, b); 530 ck_assert_ptr_ne(r, null); 531 ck_assert_int_eq(lenO(r), 3); 532 finishO(b); 533 s = toStringO(r); 534 ck_assert_str_eq(s, "[1,1.000000e+00,0.000000e+00]"); 535 free(s); 536 // non smallDouble object 537 value = (smallDoublet*) allocSmallInt(2); 538 r = self->f->pushSmallDouble(self, value); 539 ck_assert_ptr_eq(r, null); 540 terminateO(value); 541 // null 542 r = self->f->pushSmallDouble(self, null); 543 ck_assert_ptr_eq(r, null); 544 ck_assert_int_eq(lenO(self), 3); 545 s = toStringO(self); 546 ck_assert_str_eq(s, "[1,1.000000e+00,0.000000e+00]"); 547 free(s); 548 terminateO(self); 549 550 } 551 552 553 void pushSmallIntSmallArrayT(CuTest *tc UNUSED) { 554 555 smallArrayt* r; 556 smallArrayt *self = allocG(rtSmallArrayt); 557 smallIntt *value = allocG(1); 558 559 // add an element to check that push adds the second element 560 // at the end 561 r = self->f->pushInt(self, 1); 562 ck_assert_ptr_ne(r, null); 563 564 r = self->f->pushSmallInt(self, value); 565 ck_assert_ptr_ne(r, null); 566 ck_assert_int_eq(lenO(r), 2); 567 finishO(value); 568 char *s = toStringO(r); 569 ck_assert_str_eq(s, "[1,1]"); 570 free(s); 571 // int object with no data 572 createAllocateSmallInt(b); 573 r = self->f->pushSmallInt(self, b); 574 ck_assert_ptr_ne(r, null); 575 ck_assert_int_eq(lenO(r), 3); 576 finishO(b); 577 s = toStringO(r); 578 ck_assert_str_eq(s, "[1,1,0]"); 579 free(s); 580 // non smallInt object 581 value = (smallIntt*) allocSmallBool(true); 582 r = self->f->pushSmallInt(self, value); 583 ck_assert_ptr_eq(r, null); 584 terminateO(value); 585 // null 586 r = self->f->pushSmallInt(self, null); 587 ck_assert_ptr_eq(r, null); 588 ck_assert_int_eq(lenO(self), 3); 589 s = toStringO(self); 590 ck_assert_str_eq(s, "[1,1,0]"); 591 free(s); 592 terminateO(self); 593 594 } 595 596 597 void pushSmallJsonSmallArrayT(CuTest *tc UNUSED) { 598 599 smallArrayt* r; 600 smallArrayt *self = allocG(rtSmallArrayt); 601 smallJsont *value = allocG(rtSmallJsont); 602 603 // add an element to check that push adds the second element 604 // at the end 605 r = self->f->pushInt(self, 1); 606 ck_assert_ptr_ne(r, null); 607 608 // the smallJson container is empty 609 r = self->f->pushSmallJson(self, value); 610 ck_assert_ptr_ne(r, null); 611 ck_assert_int_eq(lenO(r), 2); 612 char *s = toStringO(r); 613 ck_assert_str_eq(s, "[1,{}]"); 614 free(s); 615 resetO(value); 616 parseO(value, "{}"); 617 r = self->f->pushSmallJson(self, value); 618 finishO(value); 619 ck_assert_ptr_ne(r, null); 620 ck_assert_int_eq(lenO(r), 3); 621 s = toStringO(r); 622 ck_assert_str_eq(s, "[1,{},{}]"); 623 free(s); 624 // non smallJson object 625 value = (smallJsont*) allocSmallInt(2); 626 r = self->f->pushSmallJson(self, value); 627 ck_assert_ptr_eq(r, null); 628 terminateO(value); 629 // null 630 r = self->f->pushSmallJson(self, null); 631 ck_assert_ptr_eq(r, null); 632 ck_assert_int_eq(lenO(self), 3); 633 s = toStringO(self); 634 ck_assert_str_eq(s, "[1,{},{}]"); 635 free(s); 636 terminateO(self); 637 638 } 639 640 641 void pushSmallStringSmallArrayT(CuTest *tc UNUSED) { 642 643 smallArrayt* r; 644 smallArrayt *self = allocG(rtSmallArrayt); 645 createAllocateSmallString(string); 646 647 // add an element to check that push adds the second element 648 // at the end 649 r = self->f->pushInt(self, 1); 650 ck_assert_ptr_ne(r, null); 651 652 r = self->f->pushSmallString(self, string); 653 ck_assert_ptr_ne(r, null); 654 ck_assert_int_eq(lenO(r), 2); 655 finishO(string); 656 char *s = toStringO(r); 657 ck_assert_str_eq(s, "[1,\"\"]"); 658 free(s); 659 // non smallString object 660 string = (smallStringt*) allocSmallInt(2); 661 r = self->f->pushSmallString(self, string); 662 ck_assert_ptr_eq(r, null); 663 terminateO(string); 664 // null 665 r = self->f->pushSmallString(self, null); 666 ck_assert_ptr_eq(r, null); 667 ck_assert_int_eq(lenO(self), 2); 668 s = toStringO(self); 669 ck_assert_str_eq(s, "[1,\"\"]"); 670 free(s); 671 terminateO(self); 672 673 } 674 675 676 void pushSmallContainerSmallArrayT(CuTest *tc UNUSED) { 677 678 smallArrayt* r; 679 smallArrayt *self = allocG(rtSmallArrayt); 680 createAllocateSmallContainer(container); 681 682 // add an element to check that push adds the second element 683 // at the end 684 r = self->f->pushInt(self, 1); 685 ck_assert_ptr_ne(r, null); 686 687 r = self->f->pushSmallContainer(self, container); 688 ck_assert_ptr_ne(r, null); 689 ck_assert_int_eq(lenO(r), 2); 690 finishO(container); 691 char *s = toStringO(r); 692 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 693 free(s); 694 // non smallContainer object 695 container = (smallContainert*) allocSmallInt(2); 696 r = self->f->pushSmallContainer(self, container); 697 ck_assert_ptr_eq(r, null); 698 terminateO(container); 699 // null 700 r = self->f->pushSmallContainer(self, null); 701 ck_assert_ptr_eq(r, null); 702 ck_assert_int_eq(lenO(self), 2); 703 s = toStringO(self); 704 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 705 free(s); 706 terminateO(self); 707 708 } 709 710 711 void pushNFreeSmallArrayT(CuTest *tc UNUSED) { 712 713 smallArrayt* r; 714 smallArrayt *self = allocG(rtSmallArrayt); 715 baset *value = (baset*) allocG(2); 716 717 // add an element to check that push adds the second element 718 // at the end 719 r = self->f->pushInt(self, 1); 720 ck_assert_ptr_ne(r, null); 721 722 r = self->f->pushNFree(self, value); 723 ck_assert_ptr_ne(r, null); 724 ck_assert_int_eq(lenO(r), 2); 725 char *s = toStringO(r); 726 ck_assert_str_eq(s, "[1,2]"); 727 free(s); 728 // null 729 r = self->f->pushNFree(self, null); 730 ck_assert_ptr_eq(r, null); 731 ck_assert_int_eq(lenO(self), 2); 732 s = toStringO(self); 733 ck_assert_str_eq(s, "[1,2]"); 734 free(s); 735 terminateO(self); 736 737 } 738 739 740 void pushNFreeUndefinedSmallArrayT(CuTest *tc UNUSED) { 741 742 smallArrayt* r; 743 smallArrayt *self = allocG(rtSmallArrayt); 744 745 // add an element to check that push adds the second element 746 // at the end 747 r = self->f->pushInt(self, 1); 748 ck_assert_ptr_ne(r, null); 749 750 createAllocateUndefined(value); 751 r = self->f->pushNFreeUndefined(self, value); 752 ck_assert_ptr_ne(r, null); 753 ck_assert_int_eq(lenO(r), 2); 754 char *s = toStringO(r); 755 ck_assert_str_eq(s, "[1,null]"); 756 free(s); 757 terminateO(self); 758 759 } 760 761 762 void pushNFreeSSmallArrayT(CuTest *tc UNUSED) { 763 764 smallArrayt* r; 765 smallArrayt *self = allocG(rtSmallArrayt); 766 767 // add an element to check that push adds the second element 768 // at the end 769 r = self->f->pushInt(self, 1); 770 ck_assert_ptr_ne(r, null); 771 772 r = self->f->pushNFreeS(self, null); 773 ck_assert_ptr_eq(r, null); 774 ck_assert_int_eq(lenO(self), 1); 775 char *s = toStringO(self); 776 ck_assert_str_eq(s, "[1]"); 777 free(s); 778 779 char *str = strdup("poi"); 780 r = self->f->pushNFreeS(self, str); 781 ck_assert_ptr_ne(r, null); 782 ck_assert_int_eq(lenO(self), 2); 783 s = toStringO(r); 784 ck_assert_str_eq(s, "[1,\"poi\"]"); 785 free(s); 786 787 terminateO(self); 788 789 } 790 791 792 void pushNFreeDictSmallArrayT(CuTest *tc UNUSED) { 793 794 smallArrayt* r; 795 smallArrayt *self = allocG(rtSmallArrayt); 796 smallDictt *dict = allocG(rtSmallDictt); 797 798 // add an element to check that push adds the second element 799 // at the end 800 r = self->f->pushInt(self, 1); 801 ck_assert_ptr_ne(r, null); 802 803 // push dict 804 r = self->f->pushNFreeDict(self, dict); 805 ck_assert_ptr_ne(r, null); 806 ck_assert_int_eq(lenO(r), 2); 807 ck_assert_ptr_ne(r, null); 808 char *s = toStringO(r); 809 ck_assert_str_eq(s, "[1,{}]"); 810 free(s); 811 // null 812 r = self->f->pushNFreeDict(self, null); 813 ck_assert_ptr_eq(r, null); 814 ck_assert_int_eq(lenO(self), 2); 815 s = toStringO(self); 816 ck_assert_str_eq(s, "[1,{}]"); 817 free(s); 818 terminateO(self); 819 820 } 821 822 823 void pushNFreeArraySmallArrayT(CuTest *tc UNUSED) { 824 825 smallArrayt* r; 826 smallArrayt *self = allocG(rtSmallArrayt); 827 smallArrayt *array = allocG(rtSmallArrayt); 828 829 // add an element to check that push adds the second element 830 // at the end 831 r = self->f->pushInt(self, 1); 832 ck_assert_ptr_ne(r, null); 833 834 r = self->f->pushNFreeArray(self, array); 835 ck_assert_ptr_ne(r, null); 836 ck_assert_int_eq(lenO(r), 2); 837 char *s = toStringO(r); 838 ck_assert_str_eq(s, "[1,[]]"); 839 free(s); 840 // null 841 r = self->f->pushNFreeArray(self, null); 842 ck_assert_ptr_eq(r, null); 843 ck_assert_int_eq(lenO(self), 2); 844 s = toStringO(self); 845 ck_assert_str_eq(s, "[1,[]]"); 846 free(s); 847 terminateO(self); 848 849 } 850 851 852 void pushNFreeArraycSmallArrayT(CuTest *tc UNUSED) { 853 854 smallArrayt* r; 855 smallArrayt *self = allocG(rtSmallArrayt); 856 char **array = listCreateS("a","bb"); 857 858 // add an element to check that push adds the second element 859 // at the end 860 r = self->f->pushInt(self, 1); 861 ck_assert_ptr_ne(r, null); 862 863 r = self->f->pushNFreeArrayc(self, array); 864 ck_assert_ptr_ne(r, null); 865 ck_assert_int_eq(lenO(r), 2); 866 char *s = toStringO(r); 867 ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]"); 868 free(s); 869 // null 870 r = self->f->pushNFreeArrayc(self, null); 871 ck_assert_ptr_eq(r, null); 872 ck_assert_int_eq(lenO(self), 2); 873 s = toStringO(self); 874 ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]"); 875 free(s); 876 terminateO(self); 877 878 } 879 880 881 void pushNFreeSmallBoolSmallArrayT(CuTest *tc UNUSED) { 882 883 smallArrayt* r; 884 smallArrayt *self = allocG(rtSmallArrayt); 885 smallBoolt *value = allocG(TRUE); 886 887 // add an element to check that push adds the second element 888 // at the end 889 r = self->f->pushInt(self, 1); 890 ck_assert_ptr_ne(r, null); 891 892 r = self->f->pushNFreeSmallBool(self, value); 893 ck_assert_ptr_ne(r, null); 894 ck_assert_int_eq(lenO(r), 2); 895 char *s = toStringO(r); 896 ck_assert_str_eq(s, "[1,true]"); 897 free(s); 898 // bool object with no data 899 createAllocateSmallBool(b); 900 r = self->f->pushNFreeSmallBool(self, b); 901 ck_assert_ptr_ne(r, null); 902 ck_assert_int_eq(lenO(r), 3); 903 s = toStringO(r); 904 ck_assert_str_eq(s, "[1,true,false]"); 905 free(s); 906 // null 907 r = self->f->pushNFreeSmallBool(self, null); 908 ck_assert_ptr_eq(r, null); 909 ck_assert_int_eq(lenO(self), 3); 910 s = toStringO(self); 911 ck_assert_str_eq(s, "[1,true,false]"); 912 free(s); 913 terminateO(self); 914 915 } 916 917 918 void pushNFreeSmallBytesSmallArrayT(CuTest *tc UNUSED) { 919 920 smallArrayt* r; 921 smallArrayt *self = allocG(rtSmallArrayt); 922 createAllocateSmallBytes(value); 923 924 // add an element to check that push adds the second element 925 // at the end 926 r = self->f->pushInt(self, 1); 927 ck_assert_ptr_ne(r, null); 928 929 // the smallBytes container is empty 930 r = self->f->pushNFreeSmallBytes(self, value); 931 ck_assert_ptr_ne(r, null); 932 ck_assert_int_eq(lenO(r), 2); 933 char *s = toStringO(r); 934 ck_assert_str_eq(s, "[1,[]]"); 935 free(s); 936 937 char *buffer = "poi"; 938 value = allocSmallBytes(buffer, strlen(buffer)); 939 r = self->f->pushNFreeSmallBytes(self, value); 940 ck_assert_ptr_ne(r, null); 941 ck_assert_int_eq(lenO(r), 3); 942 s = toStringO(r); 943 ck_assert_str_eq(s, "[1,[],[0x70,0x6f,0x69]]"); 944 free(s); 945 // null 946 r = self->f->pushNFreeSmallBytes(self, null); 947 ck_assert_ptr_eq(r, null); 948 ck_assert_int_eq(lenO(self), 3); 949 s = toStringO(self); 950 ck_assert_str_eq(s, "[1,[],[0x70,0x6f,0x69]]"); 951 free(s); 952 terminateO(self); 953 954 } 955 956 957 void pushNFreeSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 958 959 smallArrayt* r; 960 smallArrayt *self = allocG(rtSmallArrayt); 961 smallDoublet *value = allocG(1.0); 962 963 // add an element to check that push adds the second element 964 // at the end 965 r = self->f->pushInt(self, 1); 966 ck_assert_ptr_ne(r, null); 967 968 r = self->f->pushNFreeSmallDouble(self, value); 969 ck_assert_ptr_ne(r, null); 970 ck_assert_int_eq(lenO(r), 2); 971 char *s = toStringO(r); 972 ck_assert_str_eq(s, "[1,1.000000e+00]"); 973 free(s); 974 // object with no data 975 createAllocateSmallDouble(b); 976 r = self->f->pushNFreeSmallDouble(self, b); 977 ck_assert_ptr_ne(r, null); 978 ck_assert_int_eq(lenO(r), 3); 979 s = toStringO(r); 980 ck_assert_str_eq(s, "[1,1.000000e+00,0.000000e+00]"); 981 free(s); 982 // null 983 r = self->f->pushNFreeSmallDouble(self, null); 984 ck_assert_ptr_eq(r, null); 985 ck_assert_int_eq(lenO(self), 3); 986 s = toStringO(self); 987 ck_assert_str_eq(s, "[1,1.000000e+00,0.000000e+00]"); 988 free(s); 989 terminateO(self); 990 991 } 992 993 994 void pushNFreeSmallIntSmallArrayT(CuTest *tc UNUSED) { 995 996 smallArrayt* r; 997 smallArrayt *self = allocG(rtSmallArrayt); 998 smallIntt *value = allocG(1); 999 1000 // add an element to check that push adds the second element 1001 // at the end 1002 r = self->f->pushInt(self, 1); 1003 ck_assert_ptr_ne(r, null); 1004 1005 r = self->f->pushNFreeSmallInt(self, value); 1006 ck_assert_ptr_ne(r, null); 1007 ck_assert_int_eq(lenO(r), 2); 1008 char *s = toStringO(r); 1009 ck_assert_str_eq(s, "[1,1]"); 1010 free(s); 1011 // bool object with no data 1012 createAllocateSmallInt(b); 1013 r = self->f->pushNFreeSmallInt(self, b); 1014 ck_assert_ptr_ne(r, null); 1015 ck_assert_int_eq(lenO(r), 3); 1016 s = toStringO(r); 1017 ck_assert_str_eq(s, "[1,1,0]"); 1018 free(s); 1019 // null 1020 r = self->f->pushNFreeSmallInt(self, null); 1021 ck_assert_ptr_eq(r, null); 1022 ck_assert_int_eq(lenO(self), 3); 1023 s = toStringO(self); 1024 ck_assert_str_eq(s, "[1,1,0]"); 1025 free(s); 1026 terminateO(self); 1027 1028 } 1029 1030 1031 void pushNFreeSmallJsonSmallArrayT(CuTest *tc UNUSED) { 1032 1033 smallArrayt* r; 1034 smallArrayt *self = allocG(rtSmallArrayt); 1035 smallJsont *value = allocG(rtSmallJsont); 1036 1037 // add an element to check that push adds the second element 1038 // at the end 1039 r = self->f->pushInt(self, 1); 1040 ck_assert_ptr_ne(r, null); 1041 1042 // the smallJson container is empty 1043 r = self->f->pushNFreeSmallJson(self, value); 1044 ck_assert_ptr_ne(r, null); 1045 ck_assert_int_eq(lenO(r), 2); 1046 char *s = toStringO(r); 1047 ck_assert_str_eq(s, "[1,{}]"); 1048 free(s); 1049 1050 value = allocG(rtSmallJsont); 1051 parseO(value, "{}"); 1052 r = self->f->pushNFreeSmallJson(self, value); 1053 ck_assert_ptr_ne(r, null); 1054 ck_assert_int_eq(lenO(r), 3); 1055 s = toStringO(r); 1056 ck_assert_str_eq(s, "[1,{},{}]"); 1057 free(s); 1058 // null 1059 r = self->f->pushNFreeSmallJson(self, null); 1060 ck_assert_ptr_eq(r, null); 1061 ck_assert_int_eq(lenO(self), 3); 1062 s = toStringO(self); 1063 ck_assert_str_eq(s, "[1,{},{}]"); 1064 free(s); 1065 terminateO(self); 1066 1067 } 1068 1069 1070 void pushNFreeSmallStringSmallArrayT(CuTest *tc UNUSED) { 1071 1072 smallArrayt* r; 1073 smallArrayt *self = allocG(rtSmallArrayt); 1074 createAllocateSmallString(string); 1075 1076 // add an element to check that push adds the second element 1077 // at the end 1078 r = self->f->pushInt(self, 1); 1079 ck_assert_ptr_ne(r, null); 1080 1081 r = self->f->pushNFreeSmallString(self, string); 1082 ck_assert_ptr_ne(r, null); 1083 ck_assert_int_eq(lenO(r), 2); 1084 char *s = toStringO(r); 1085 ck_assert_str_eq(s, "[1,\"\"]"); 1086 free(s); 1087 // null 1088 r = self->f->pushNFreeSmallString(self, null); 1089 ck_assert_ptr_eq(r, null); 1090 ck_assert_int_eq(lenO(self), 2); 1091 s = toStringO(self); 1092 ck_assert_str_eq(s, "[1,\"\"]"); 1093 free(s); 1094 terminateO(self); 1095 1096 } 1097 1098 1099 void pushNFreeSmallContainerSmallArrayT(CuTest *tc UNUSED) { 1100 1101 smallArrayt* r; 1102 smallArrayt *self = allocG(rtSmallArrayt); 1103 createAllocateSmallContainer(container); 1104 1105 // add an element to check that push adds the second element 1106 // at the end 1107 r = self->f->pushInt(self, 1); 1108 ck_assert_ptr_ne(r, null); 1109 1110 r = self->f->pushNFreeSmallContainer(self, container); 1111 ck_assert_ptr_ne(r, null); 1112 ck_assert_int_eq(lenO(r), 2); 1113 char *s = toStringO(r); 1114 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 1115 free(s); 1116 // null 1117 r = self->f->pushNFreeSmallContainer(self, null); 1118 ck_assert_ptr_eq(r, null); 1119 ck_assert_int_eq(lenO(self), 2); 1120 s = toStringO(self); 1121 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 1122 free(s); 1123 terminateO(self); 1124 1125 } 1126 1127 1128 void pushManySmallArrayT(CuTest *tc UNUSED) { 1129 1130 smallArrayt* r; 1131 smallArrayt *self = allocG(rtSmallArrayt); 1132 smallIntt *v1 = allocG(1); 1133 smallIntt *v2 = allocG(2); 1134 1135 r = self->f->pushMany(self, v1, v2, null); 1136 finishO(v1); 1137 finishO(v2); 1138 ck_assert_ptr_ne(r, null); 1139 ck_assert_int_eq(lenO(r), 2); 1140 char *s = toStringO(r); 1141 ck_assert_str_eq(s, "[1,2]"); 1142 free(s); 1143 terminateO(self); 1144 1145 } 1146 1147 1148 void pushManySSmallArrayT(CuTest *tc UNUSED) { 1149 1150 smallArrayt* r; 1151 smallArrayt *self = allocG(rtSmallArrayt); 1152 char *v1 = "a"; 1153 char *v2 = "bb"; 1154 1155 r = self->f->pushManyS(self, v1, v2, null); 1156 ck_assert_ptr_ne(r, null); 1157 ck_assert_int_eq(lenO(r), 2); 1158 char *s = toStringO(r); 1159 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 1160 free(s); 1161 terminateO(self); 1162 1163 } 1164 1165 1166 void pushNFreeManySmallArrayT(CuTest *tc UNUSED) { 1167 1168 smallArrayt* r; 1169 smallArrayt *self = allocG(rtSmallArrayt); 1170 smallIntt *v1 = allocG(1); 1171 smallIntt *v2 = allocG(2); 1172 1173 r = self->f->pushNFreeMany(self, v1, v2, null); 1174 ck_assert_ptr_ne(r, null); 1175 ck_assert_int_eq(lenO(r), 2); 1176 char *s = toStringO(r); 1177 ck_assert_str_eq(s, "[1,2]"); 1178 free(s); 1179 terminateO(self); 1180 1181 } 1182 1183 1184 void pushNFreeManySSmallArrayT(CuTest *tc UNUSED) { 1185 1186 smallArrayt* r; 1187 smallArrayt *self = allocG(rtSmallArrayt); 1188 char *v1 = strdup("a"); 1189 char *v2 = strdup("bb"); 1190 1191 r = self->f->pushNFreeManyS(self, v1, v2, null); 1192 ck_assert_ptr_ne(r, null); 1193 ck_assert_int_eq(lenO(r), 2); 1194 char *s = toStringO(r); 1195 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 1196 free(s); 1197 terminateO(self); 1198 1199 } 1200 1201 1202 void popSmallArrayT(CuTest *tc UNUSED) { 1203 1204 baset* r; 1205 smallArrayt *self = allocG(rtSmallArrayt); 1206 smallArrayt *r2; 1207 1208 // add an element to check that the second element is poped 1209 // at the end 1210 r2 = self->f->pushInt(self, 1); 1211 ck_assert_ptr_ne(r2, null); 1212 1213 // push a base object of unknown type 1214 smallIntt *o = allocSmallInt(2); 1215 o->type = "newType"; 1216 r2 = self->f->pushNFree(self, (baset*)o); 1217 ck_assert_ptr_ne(r2, null); 1218 1219 r = self->f->pop(self); 1220 ck_assert_ptr_ne(r, null); 1221 ck_assert_str_eq(r->type, "newType"); 1222 char *s = toStringO(r); 1223 terminateO(r); 1224 ck_assert_str_eq(s, "2"); 1225 free(s); 1226 ck_assert_int_eq(lenO(self), 1); 1227 s = toStringO(self); 1228 ck_assert_str_eq(s, "[1]"); 1229 free(s); 1230 1231 // empty array 1232 r = self->f->pop(self); 1233 ck_assert_ptr_ne(r, null); 1234 terminateO(r); 1235 s = toStringO(self); 1236 ck_assert_str_eq(s, "[]"); 1237 free(s); 1238 r = self->f->pop(self); 1239 ck_assert_ptr_eq(r, null); 1240 s = toStringO(self); 1241 ck_assert_str_eq(s, "[]"); 1242 free(s); 1243 terminateO(self); 1244 1245 } 1246 1247 1248 void popUndefinedSmallArrayT(CuTest *tc UNUSED) { 1249 1250 undefinedt* r; 1251 smallArrayt *self = allocG(rtSmallArrayt); 1252 smallArrayt *r2; 1253 baset *r3; 1254 1255 // add an element to check that the second element is poped 1256 // at the end 1257 r2 = self->f->pushInt(self, 1); 1258 ck_assert_ptr_ne(r2, null); 1259 // add second element 1260 r2 = self->f->pushUndefined(self); 1261 ck_assert_ptr_ne(r2, null); 1262 r2 = self->f->pushUndefined(self); 1263 ck_assert_ptr_ne(r2, null); 1264 delElemO(self, -1); 1265 // pop 1266 r = self->f->popUndefined(self); 1267 ck_assert_ptr_ne(r, null); 1268 char *s = toStringO(r); 1269 terminateO(r); 1270 ck_assert_str_eq(s, "null"); 1271 free(s); 1272 ck_assert_int_eq(lenO(self), 1); 1273 s = toStringO(self); 1274 ck_assert_str_eq(s, "[1]"); 1275 free(s); 1276 // pop element of unexpected type 1277 r = self->f->popUndefined(self); 1278 ck_assert_ptr_eq(r, null); 1279 ck_assert_int_eq(lenO(self), 1); 1280 s = toStringO(self); 1281 ck_assert_str_eq(s, "[1]"); 1282 free(s); 1283 // empty array 1284 r3 = self->f->pop(self); 1285 ck_assert_ptr_ne(r3, null); 1286 terminateO(r3); 1287 s = toStringO(self); 1288 ck_assert_str_eq(s, "[]"); 1289 free(s); 1290 r = self->f->popUndefined(self); 1291 ck_assert_ptr_eq(r, null); 1292 s = toStringO(self); 1293 ck_assert_str_eq(s, "[]"); 1294 free(s); 1295 r2 = self->f->pushUndefined(self); 1296 ck_assert_ptr_ne(r2, null); 1297 delElemO(self,-1); 1298 r = self->f->popUndefined(self); 1299 ck_assert_ptr_eq(r, null); 1300 terminateO(self); 1301 1302 } 1303 1304 1305 void popBoolSmallArrayT(CuTest *tc UNUSED) { 1306 1307 bool r; 1308 smallArrayt *self = allocG(rtSmallArrayt); 1309 smallArrayt *r2; 1310 baset *r3; 1311 1312 // add an element to check that the second element is poped 1313 // at the end 1314 r2 = self->f->pushInt(self, 1); 1315 ck_assert_ptr_ne(r2, null); 1316 1317 // add second element 1318 r2 = self->f->pushBool(self, TRUE); 1319 ck_assert_ptr_ne(r2, null); 1320 1321 // pop 1322 r = self->f->popBool(self); 1323 ck_assert(r); 1324 ck_assert_int_eq(lenO(self), 1); 1325 char *s = toStringO(self); 1326 ck_assert_str_eq(s, "[1]"); 1327 free(s); 1328 1329 // pop element of unexpected type 1330 r = self->f->popBool(self); 1331 ck_assert(!r); 1332 ck_assert_int_eq(lenO(self), 1); 1333 s = toStringO(self); 1334 ck_assert_str_eq(s, "[1]"); 1335 free(s); 1336 1337 // empty array 1338 r3 = self->f->pop(self); 1339 ck_assert_ptr_ne(r3, null); 1340 terminateO(r3); 1341 s = toStringO(self); 1342 ck_assert_str_eq(s, "[]"); 1343 free(s); 1344 r = self->f->popBool(self); 1345 ck_assert(!r); 1346 s = toStringO(self); 1347 ck_assert_str_eq(s, "[]"); 1348 free(s); 1349 terminateO(self); 1350 1351 } 1352 1353 1354 void popDoubleSmallArrayT(CuTest *tc UNUSED) { 1355 1356 double r; 1357 smallArrayt *self = allocG(rtSmallArrayt); 1358 smallArrayt *r2; 1359 baset *r3; 1360 1361 // add an element to check that the second element is poped 1362 // at the end 1363 r2 = self->f->pushInt(self, 1); 1364 ck_assert_ptr_ne(r2, null); 1365 1366 // add second element 1367 r2 = self->f->pushDouble(self, 2.0); 1368 ck_assert_ptr_ne(r2, null); 1369 1370 // pop 1371 r = self->f->popDouble(self); 1372 ck_assert(r==2.0); 1373 ck_assert_int_eq(lenO(self), 1); 1374 char *s = toStringO(self); 1375 ck_assert_str_eq(s, "[1]"); 1376 free(s); 1377 1378 // pop element of unexpected type 1379 r = self->f->popDouble(self); 1380 ck_assert(!r); 1381 ck_assert_int_eq(lenO(self), 1); 1382 s = toStringO(self); 1383 ck_assert_str_eq(s, "[1]"); 1384 free(s); 1385 1386 // empty array 1387 r3 = self->f->pop(self); 1388 ck_assert_ptr_ne(r3, null); 1389 terminateO(r3); 1390 s = toStringO(self); 1391 ck_assert_str_eq(s, "[]"); 1392 free(s); 1393 r = self->f->popDouble(self); 1394 ck_assert(!r); 1395 s = toStringO(self); 1396 ck_assert_str_eq(s, "[]"); 1397 free(s); 1398 terminateO(self); 1399 1400 } 1401 1402 1403 void popIntSmallArrayT(CuTest *tc UNUSED) { 1404 1405 int64_t r; 1406 smallArrayt *self = allocG(rtSmallArrayt); 1407 smallArrayt *r2; 1408 baset *r3; 1409 1410 // add an element to check that the second element is poped 1411 // at the end 1412 r2 = self->f->pushBool(self, FALSE); 1413 ck_assert_ptr_ne(r2, null); 1414 1415 // add second element 1416 r2 = self->f->pushInt(self, 2); 1417 ck_assert_ptr_ne(r2, null); 1418 1419 // pop 1420 r = self->f->popInt(self); 1421 ck_assert_int_eq(r, 2); 1422 ck_assert_int_eq(lenO(self), 1); 1423 char *s = toStringO(self); 1424 ck_assert_str_eq(s, "[false]"); 1425 free(s); 1426 1427 // pop element of unexpected type 1428 r = self->f->popInt(self); 1429 ck_assert(!r); 1430 ck_assert_int_eq(lenO(self), 1); 1431 s = toStringO(self); 1432 ck_assert_str_eq(s, "[false]"); 1433 free(s); 1434 1435 // empty array 1436 r3 = self->f->pop(self); 1437 ck_assert_ptr_ne(r3, null); 1438 terminateO(r3); 1439 s = toStringO(self); 1440 ck_assert_str_eq(s, "[]"); 1441 free(s); 1442 r = self->f->popInt(self); 1443 ck_assert(!r); 1444 s = toStringO(self); 1445 ck_assert_str_eq(s, "[]"); 1446 free(s); 1447 terminateO(self); 1448 1449 } 1450 1451 1452 void popInt32SmallArrayT(CuTest *tc UNUSED) { 1453 1454 int32_t r; 1455 smallArrayt *self = allocG(rtSmallArrayt); 1456 smallArrayt *r2; 1457 baset *r3; 1458 1459 // add an element to check that the second element is poped 1460 // at the end 1461 r2 = self->f->pushBool(self, FALSE); 1462 ck_assert_ptr_ne(r2, null); 1463 1464 // add second element 1465 r2 = self->f->pushInt(self, 2); 1466 ck_assert_ptr_ne(r2, null); 1467 1468 // pop 1469 r = self->f->popInt32(self); 1470 ck_assert_int_eq(r, 2); 1471 ck_assert_int_eq(lenO(self), 1); 1472 char *s = toStringO(self); 1473 ck_assert_str_eq(s, "[false]"); 1474 free(s); 1475 1476 // pop element of unexpected type 1477 r = self->f->popInt32(self); 1478 ck_assert(!r); 1479 ck_assert_int_eq(lenO(self), 1); 1480 s = toStringO(self); 1481 ck_assert_str_eq(s, "[false]"); 1482 free(s); 1483 1484 // empty array 1485 r3 = self->f->pop(self); 1486 ck_assert_ptr_ne(r3, null); 1487 terminateO(r3); 1488 s = toStringO(self); 1489 ck_assert_str_eq(s, "[]"); 1490 free(s); 1491 r = self->f->popInt32(self); 1492 ck_assert(!r); 1493 s = toStringO(self); 1494 ck_assert_str_eq(s, "[]"); 1495 free(s); 1496 terminateO(self); 1497 1498 } 1499 1500 1501 void popUintSmallArrayT(CuTest *tc UNUSED) { 1502 1503 uint64_t r; 1504 smallArrayt *self = allocG(rtSmallArrayt); 1505 smallArrayt *r2; 1506 baset *r3; 1507 1508 // add an element to check that the second element is poped 1509 // at the end 1510 r2 = self->f->pushBool(self, FALSE); 1511 ck_assert_ptr_ne(r2, null); 1512 1513 // add second element 1514 r2 = self->f->pushInt(self, 2); 1515 ck_assert_ptr_ne(r2, null); 1516 1517 // pop 1518 r = self->f->popUint(self); 1519 ck_assert_int_eq(r, 2); 1520 ck_assert_int_eq(lenO(self), 1); 1521 char *s = toStringO(self); 1522 ck_assert_str_eq(s, "[false]"); 1523 free(s); 1524 1525 // pop element of unexpected type 1526 r = self->f->popUint(self); 1527 ck_assert(!r); 1528 ck_assert_int_eq(lenO(self), 1); 1529 s = toStringO(self); 1530 ck_assert_str_eq(s, "[false]"); 1531 free(s); 1532 1533 // empty array 1534 r3 = self->f->pop(self); 1535 ck_assert_ptr_ne(r3, null); 1536 terminateO(r3); 1537 s = toStringO(self); 1538 ck_assert_str_eq(s, "[]"); 1539 free(s); 1540 r = self->f->popUint(self); 1541 ck_assert(!r); 1542 s = toStringO(self); 1543 ck_assert_str_eq(s, "[]"); 1544 free(s); 1545 terminateO(self); 1546 1547 } 1548 1549 1550 void popUint32SmallArrayT(CuTest *tc UNUSED) { 1551 1552 uint32_t r; 1553 smallArrayt *self = allocG(rtSmallArrayt); 1554 smallArrayt *r2; 1555 baset *r3; 1556 1557 // add an element to check that the second element is poped 1558 // at the end 1559 r2 = self->f->pushBool(self, FALSE); 1560 ck_assert_ptr_ne(r2, null); 1561 1562 // add second element 1563 r2 = self->f->pushInt(self, 2); 1564 ck_assert_ptr_ne(r2, null); 1565 1566 // pop 1567 r = self->f->popUint32(self); 1568 ck_assert_int_eq(r, 2); 1569 ck_assert_int_eq(lenO(self), 1); 1570 char *s = toStringO(self); 1571 ck_assert_str_eq(s, "[false]"); 1572 free(s); 1573 1574 // pop element of unexpected type 1575 r = self->f->popUint32(self); 1576 ck_assert(!r); 1577 ck_assert_int_eq(lenO(self), 1); 1578 s = toStringO(self); 1579 ck_assert_str_eq(s, "[false]"); 1580 free(s); 1581 1582 // empty array 1583 r3 = self->f->pop(self); 1584 ck_assert_ptr_ne(r3, null); 1585 terminateO(r3); 1586 s = toStringO(self); 1587 ck_assert_str_eq(s, "[]"); 1588 free(s); 1589 r = self->f->popUint32(self); 1590 ck_assert(!r); 1591 s = toStringO(self); 1592 ck_assert_str_eq(s, "[]"); 1593 free(s); 1594 terminateO(self); 1595 1596 } 1597 1598 1599 void popSSmallArrayT(CuTest *tc UNUSED) { 1600 1601 char* r; 1602 smallArrayt *self = allocG(rtSmallArrayt); 1603 smallArrayt *r2; 1604 baset *r3; 1605 1606 // add an element to check that the second element is poped 1607 // at the end 1608 r2 = self->f->pushInt(self, 1); 1609 ck_assert_ptr_ne(r2, null); 1610 1611 // add second element 1612 r2 = self->f->pushS(self, "bb"); 1613 ck_assert_ptr_ne(r2, null); 1614 1615 // pop 1616 r = self->f->popS(self); 1617 ck_assert_str_eq(r, "bb"); 1618 free(r); 1619 ck_assert_int_eq(lenO(self), 1); 1620 char *s = toStringO(self); 1621 ck_assert_str_eq(s, "[1]"); 1622 free(s); 1623 1624 // pop element of unexpected type 1625 r = self->f->popS(self); 1626 ck_assert(!r); 1627 ck_assert_int_eq(lenO(self), 1); 1628 s = toStringO(self); 1629 ck_assert_str_eq(s, "[1]"); 1630 free(s); 1631 1632 // empty array 1633 r3 = self->f->pop(self); 1634 ck_assert_ptr_ne(r3, null); 1635 terminateO(r3); 1636 s = toStringO(self); 1637 ck_assert_str_eq(s, "[]"); 1638 free(s); 1639 r = self->f->popS(self); 1640 ck_assert(!r); 1641 s = toStringO(self); 1642 ck_assert_str_eq(s, "[]"); 1643 free(s); 1644 terminateO(self); 1645 1646 } 1647 1648 1649 void popDictSmallArrayT(CuTest *tc UNUSED) { 1650 1651 smallDictt* r; 1652 smallArrayt *self = allocG(rtSmallArrayt); 1653 smallArrayt *r2; 1654 baset *r3; 1655 1656 // add an element to check that the second element is poped 1657 // at the end 1658 r2 = self->f->pushInt(self, 1); 1659 ck_assert_ptr_ne(r2, null); 1660 // add second element 1661 createSmallDict(e); 1662 r2 = self->f->pushDict(self, &e); 1663 ck_assert_ptr_ne(r2, null); 1664 r2 = self->f->pushUndefined(self); 1665 ck_assert_ptr_ne(r2, null); 1666 delElemO(self, -1); 1667 // pop 1668 r = self->f->popDict(self); 1669 ck_assert_ptr_ne(r, null); 1670 char *s = toStringO(r); 1671 terminateO(r); 1672 ck_assert_str_eq(s, "{}"); 1673 free(s); 1674 ck_assert_int_eq(lenO(self), 1); 1675 s = toStringO(self); 1676 ck_assert_str_eq(s, "[1]"); 1677 free(s); 1678 // pop element of unexpected type 1679 r = self->f->popDict(self); 1680 ck_assert(!r); 1681 ck_assert_int_eq(lenO(self), 1); 1682 s = toStringO(self); 1683 ck_assert_str_eq(s, "[1]"); 1684 free(s); 1685 // empty array 1686 r3 = self->f->pop(self); 1687 ck_assert_ptr_ne(r3, null); 1688 terminateO(r3); 1689 s = toStringO(self); 1690 ck_assert_str_eq(s, "[]"); 1691 free(s); 1692 r = self->f->popDict(self); 1693 ck_assert(!r); 1694 s = toStringO(self); 1695 ck_assert_str_eq(s, "[]"); 1696 free(s); 1697 r2 = self->f->pushUndefined(self); 1698 ck_assert_ptr_ne(r2, null); 1699 delElemO(self,-1); 1700 r = self->f->popDict(self); 1701 ck_assert_ptr_eq(r, null); 1702 terminateO(self); 1703 1704 } 1705 1706 1707 void popArraySmallArrayT(CuTest *tc UNUSED) { 1708 1709 smallArrayt* r; 1710 smallArrayt *self = allocG(rtSmallArrayt); 1711 smallArrayt *r2; 1712 baset *r3; 1713 1714 // add an element to check that the second element is poped 1715 // at the end 1716 r2 = self->f->pushInt(self, 1); 1717 ck_assert_ptr_ne(r2, null); 1718 // add second element 1719 createSmallArray(e); 1720 r2 = self->f->pushArray(self, &e); 1721 ck_assert_ptr_ne(r2, null); 1722 r2 = self->f->pushUndefined(self); 1723 ck_assert_ptr_ne(r2, null); 1724 delElemO(self, -1); 1725 // pop 1726 r = self->f->popArray(self); 1727 ck_assert_ptr_ne(r, null); 1728 char *s = toStringO(r); 1729 terminateO(r); 1730 ck_assert_str_eq(s, "[]"); 1731 free(s); 1732 ck_assert_int_eq(lenO(self), 1); 1733 s = toStringO(self); 1734 ck_assert_str_eq(s, "[1]"); 1735 free(s); 1736 // pop element of unexpected type 1737 r = self->f->popArray(self); 1738 ck_assert(!r); 1739 ck_assert_int_eq(lenO(self), 1); 1740 s = toStringO(self); 1741 ck_assert_str_eq(s, "[1]"); 1742 free(s); 1743 // empty array 1744 r3 = self->f->pop(self); 1745 ck_assert_ptr_ne(r3, null); 1746 terminateO(r3); 1747 s = toStringO(self); 1748 ck_assert_str_eq(s, "[]"); 1749 free(s); 1750 r = self->f->popArray(self); 1751 ck_assert(!r); 1752 s = toStringO(self); 1753 ck_assert_str_eq(s, "[]"); 1754 free(s); 1755 r2 = self->f->pushUndefined(self); 1756 ck_assert_ptr_ne(r2, null); 1757 delElemO(self,-1); 1758 r = self->f->popArray(self); 1759 ck_assert_ptr_eq(r, null); 1760 terminateO(self); 1761 1762 } 1763 1764 1765 void popSmallBoolSmallArrayT(CuTest *tc UNUSED) { 1766 1767 smallBoolt* r; 1768 smallArrayt *self = allocG(rtSmallArrayt); 1769 smallArrayt *r2; 1770 baset *r3; 1771 1772 // add an element to check that the second element is poped 1773 // at the end 1774 r2 = self->f->pushInt(self, 1); 1775 ck_assert_ptr_ne(r2, null); 1776 // add second element 1777 createSmallBool(e); 1778 r2 = self->f->pushSmallBool(self, &e); 1779 ck_assert_ptr_ne(r2, null); 1780 r2 = self->f->pushUndefined(self); 1781 ck_assert_ptr_ne(r2, null); 1782 delElemO(self, -1); 1783 // pop 1784 r = self->f->popSmallBool(self); 1785 ck_assert_ptr_ne(r, null); 1786 char *s = toStringO(r); 1787 terminateO(r); 1788 ck_assert_str_eq(s, "false"); 1789 free(s); 1790 ck_assert_int_eq(lenO(self), 1); 1791 s = toStringO(self); 1792 ck_assert_str_eq(s, "[1]"); 1793 free(s); 1794 // pop element of unexpected type 1795 r = self->f->popSmallBool(self); 1796 ck_assert(!r); 1797 ck_assert_int_eq(lenO(self), 1); 1798 s = toStringO(self); 1799 ck_assert_str_eq(s, "[1]"); 1800 free(s); 1801 // empty array 1802 r3 = self->f->pop(self); 1803 ck_assert_ptr_ne(r3, null); 1804 terminateO(r3); 1805 s = toStringO(self); 1806 ck_assert_str_eq(s, "[]"); 1807 free(s); 1808 r = self->f->popSmallBool(self); 1809 ck_assert(!r); 1810 s = toStringO(self); 1811 ck_assert_str_eq(s, "[]"); 1812 free(s); 1813 r2 = self->f->pushUndefined(self); 1814 ck_assert_ptr_ne(r2, null); 1815 delElemO(self,-1); 1816 r = self->f->popSmallBool(self); 1817 ck_assert_ptr_eq(r, null); 1818 terminateO(self); 1819 1820 } 1821 1822 1823 void popSmallBytesSmallArrayT(CuTest *tc UNUSED) { 1824 1825 smallBytest* r; 1826 smallArrayt *self = allocG(rtSmallArrayt); 1827 smallArrayt *r2; 1828 baset *r3; 1829 1830 // add an element to check that the second element is poped 1831 // at the end 1832 r2 = self->f->pushInt(self, 1); 1833 ck_assert_ptr_ne(r2, null); 1834 // add second element 1835 createSmallBytes(e); 1836 r2 = self->f->pushSmallBytes(self, &e); 1837 ck_assert_ptr_ne(r2, null); 1838 r2 = self->f->pushUndefined(self); 1839 ck_assert_ptr_ne(r2, null); 1840 delElemO(self, -1); 1841 // pop 1842 r = self->f->popSmallBytes(self); 1843 ck_assert_ptr_ne(r, null); 1844 char *s = toStringO(r); 1845 terminateO(r); 1846 ck_assert_str_eq(s, "[]"); 1847 free(s); 1848 ck_assert_int_eq(lenO(self), 1); 1849 s = toStringO(self); 1850 ck_assert_str_eq(s, "[1]"); 1851 free(s); 1852 // pop element of unexpected type 1853 r = self->f->popSmallBytes(self); 1854 ck_assert(!r); 1855 ck_assert_int_eq(lenO(self), 1); 1856 s = toStringO(self); 1857 ck_assert_str_eq(s, "[1]"); 1858 free(s); 1859 // empty array 1860 r3 = self->f->pop(self); 1861 ck_assert_ptr_ne(r3, null); 1862 terminateO(r3); 1863 s = toStringO(self); 1864 ck_assert_str_eq(s, "[]"); 1865 free(s); 1866 r = self->f->popSmallBytes(self); 1867 ck_assert(!r); 1868 s = toStringO(self); 1869 ck_assert_str_eq(s, "[]"); 1870 free(s); 1871 r2 = self->f->pushUndefined(self); 1872 ck_assert_ptr_ne(r2, null); 1873 delElemO(self,-1); 1874 r = self->f->popSmallBytes(self); 1875 ck_assert_ptr_eq(r, null); 1876 terminateO(self); 1877 1878 } 1879 1880 1881 void popSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 1882 1883 smallDoublet* r; 1884 smallArrayt *self = allocG(rtSmallArrayt); 1885 smallArrayt *r2; 1886 baset *r3; 1887 1888 // add an element to check that the second element is poped 1889 // at the end 1890 r2 = self->f->pushInt(self, 1); 1891 ck_assert_ptr_ne(r2, null); 1892 // add second element 1893 createSmallDouble(e); 1894 r2 = self->f->pushSmallDouble(self, &e); 1895 ck_assert_ptr_ne(r2, null); 1896 r2 = self->f->pushUndefined(self); 1897 ck_assert_ptr_ne(r2, null); 1898 delElemO(self, -1); 1899 // pop 1900 r = self->f->popSmallDouble(self); 1901 ck_assert_ptr_ne(r, null); 1902 char *s = toStringO(r); 1903 terminateO(r); 1904 ck_assert_str_eq(s, "0.000000e+00"); 1905 free(s); 1906 ck_assert_int_eq(lenO(self), 1); 1907 s = toStringO(self); 1908 ck_assert_str_eq(s, "[1]"); 1909 free(s); 1910 // pop element of unexpected type 1911 r = self->f->popSmallDouble(self); 1912 ck_assert(!r); 1913 ck_assert_int_eq(lenO(self), 1); 1914 s = toStringO(self); 1915 ck_assert_str_eq(s, "[1]"); 1916 free(s); 1917 // empty array 1918 r3 = self->f->pop(self); 1919 ck_assert_ptr_ne(r3, null); 1920 terminateO(r3); 1921 s = toStringO(self); 1922 ck_assert_str_eq(s, "[]"); 1923 free(s); 1924 r = self->f->popSmallDouble(self); 1925 ck_assert(!r); 1926 s = toStringO(self); 1927 ck_assert_str_eq(s, "[]"); 1928 free(s); 1929 r2 = self->f->pushUndefined(self); 1930 ck_assert_ptr_ne(r2, null); 1931 delElemO(self,-1); 1932 r = self->f->popSmallDouble(self); 1933 ck_assert_ptr_eq(r, null); 1934 terminateO(self); 1935 1936 } 1937 1938 1939 void popSmallIntSmallArrayT(CuTest *tc UNUSED) { 1940 1941 smallIntt* r; 1942 smallArrayt *self = allocG(rtSmallArrayt); 1943 smallArrayt *r2; 1944 baset *r3; 1945 1946 // add an element to check that the second element is poped 1947 // at the end 1948 r2 = self->f->pushBool(self, TRUE); 1949 ck_assert_ptr_ne(r2, null); 1950 // add second element 1951 createSmallInt(e); 1952 r2 = self->f->pushSmallInt(self, &e); 1953 ck_assert_ptr_ne(r2, null); 1954 r2 = self->f->pushUndefined(self); 1955 ck_assert_ptr_ne(r2, null); 1956 delElemO(self, -1); 1957 // pop 1958 r = self->f->popSmallInt(self); 1959 ck_assert_ptr_ne(r, null); 1960 char *s = toStringO(r); 1961 terminateO(r); 1962 ck_assert_str_eq(s, "0"); 1963 free(s); 1964 ck_assert_int_eq(lenO(self), 1); 1965 s = toStringO(self); 1966 ck_assert_str_eq(s, "[true]"); 1967 free(s); 1968 // pop element of unexpected type 1969 r = self->f->popSmallInt(self); 1970 ck_assert(!r); 1971 ck_assert_int_eq(lenO(self), 1); 1972 s = toStringO(self); 1973 ck_assert_str_eq(s, "[true]"); 1974 free(s); 1975 // empty array 1976 r3 = self->f->pop(self); 1977 ck_assert_ptr_ne(r3, null); 1978 terminateO(r3); 1979 s = toStringO(self); 1980 ck_assert_str_eq(s, "[]"); 1981 free(s); 1982 r = self->f->popSmallInt(self); 1983 ck_assert(!r); 1984 s = toStringO(self); 1985 ck_assert_str_eq(s, "[]"); 1986 free(s); 1987 r2 = self->f->pushUndefined(self); 1988 ck_assert_ptr_ne(r2, null); 1989 delElemO(self,-1); 1990 r = self->f->popSmallInt(self); 1991 ck_assert_ptr_eq(r, null); 1992 terminateO(self); 1993 1994 } 1995 1996 1997 void popSmallJsonSmallArrayT(CuTest *tc UNUSED) { 1998 1999 smallJsont* r; 2000 smallArrayt *self = allocG(rtSmallArrayt); 2001 smallArrayt *r2; 2002 baset *r3; 2003 2004 // add an element to check that the second element is poped 2005 // at the end 2006 createSmallBytes(B); 2007 r2 = self->f->pushSmallBytes(self, &B); 2008 ck_assert_ptr_ne(r2, null); 2009 // add second element 2010 createSmallJson(e); 2011 r2 = self->f->pushSmallJson(self, &e); 2012 ck_assert_ptr_ne(r2, null); 2013 r2 = self->f->pushUndefined(self); 2014 ck_assert_ptr_ne(r2, null); 2015 delElemO(self, -1); 2016 // pop 2017 r = self->f->popSmallJson(self); 2018 ck_assert_ptr_ne(r, null); 2019 char *s = toStringO(r); 2020 terminateO(r); 2021 ck_assert_str_eq(s, "{}"); 2022 free(s); 2023 ck_assert_int_eq(lenO(self), 1); 2024 s = toStringO(self); 2025 ck_assert_str_eq(s, "[[]]"); 2026 free(s); 2027 // pop element of unexpected type 2028 r = self->f->popSmallJson(self); 2029 ck_assert(!r); 2030 ck_assert_int_eq(lenO(self), 1); 2031 s = toStringO(self); 2032 ck_assert_str_eq(s, "[[]]"); 2033 free(s); 2034 // empty array 2035 r3 = self->f->pop(self); 2036 ck_assert_ptr_ne(r3, null); 2037 terminateO(r3); 2038 s = toStringO(self); 2039 ck_assert_str_eq(s, "[]"); 2040 free(s); 2041 r = self->f->popSmallJson(self); 2042 ck_assert(!r); 2043 s = toStringO(self); 2044 ck_assert_str_eq(s, "[]"); 2045 free(s); 2046 r2 = self->f->pushUndefined(self); 2047 ck_assert_ptr_ne(r2, null); 2048 delElemO(self,-1); 2049 r = self->f->popSmallJson(self); 2050 ck_assert_ptr_eq(r, null); 2051 terminateO(self); 2052 2053 } 2054 2055 2056 void popSmallStringSmallArrayT(CuTest *tc UNUSED) { 2057 2058 smallStringt* r; 2059 smallArrayt *self = allocG(rtSmallArrayt); 2060 smallArrayt *r2; 2061 baset *r3; 2062 2063 // add an element to check that the second element is poped 2064 // at the end 2065 r2 = self->f->pushInt(self, 1); 2066 ck_assert_ptr_ne(r2, null); 2067 // add second element 2068 createSmallString(e); 2069 r2 = self->f->pushSmallString(self, &e); 2070 ck_assert_ptr_ne(r2, null); 2071 r2 = self->f->pushUndefined(self); 2072 ck_assert_ptr_ne(r2, null); 2073 delElemO(self, -1); 2074 // pop 2075 r = self->f->popSmallString(self); 2076 ck_assert_ptr_ne(r, null); 2077 char *s = toStringO(r); 2078 terminateO(r); 2079 ck_assert_str_eq(s, ""); 2080 free(s); 2081 ck_assert_int_eq(lenO(self), 1); 2082 s = toStringO(self); 2083 ck_assert_str_eq(s, "[1]"); 2084 free(s); 2085 // pop element of unexpected type 2086 r = self->f->popSmallString(self); 2087 ck_assert(!r); 2088 ck_assert_int_eq(lenO(self), 1); 2089 s = toStringO(self); 2090 ck_assert_str_eq(s, "[1]"); 2091 free(s); 2092 // empty array 2093 r3 = self->f->pop(self); 2094 ck_assert_ptr_ne(r3, null); 2095 terminateO(r3); 2096 s = toStringO(self); 2097 ck_assert_str_eq(s, "[]"); 2098 free(s); 2099 r = self->f->popSmallString(self); 2100 ck_assert(!r); 2101 s = toStringO(self); 2102 ck_assert_str_eq(s, "[]"); 2103 free(s); 2104 r2 = self->f->pushUndefined(self); 2105 ck_assert_ptr_ne(r2, null); 2106 delElemO(self,-1); 2107 r = self->f->popSmallString(self); 2108 ck_assert_ptr_eq(r, null); 2109 terminateO(self); 2110 2111 } 2112 2113 2114 void popVoidSmallArrayT(CuTest *tc UNUSED) { 2115 2116 void* r; 2117 smallArrayt *self = allocG(rtSmallArrayt); 2118 smallArrayt *r2; 2119 baset *r3; 2120 2121 // add an element to check that the second element is poped 2122 // at the end 2123 r2 = self->f->pushInt(self, 1); 2124 ck_assert_ptr_ne(r2, null); 2125 // add second element 2126 createSmallContainer(e); 2127 setValO(&e, &r); 2128 r2 = self->f->pushSmallContainer(self, &e); 2129 ck_assert_ptr_ne(r2, null); 2130 // pop 2131 r = self->f->popVoid(self); 2132 ck_assert_ptr_eq(r, &r); 2133 ck_assert_int_eq(lenO(self), 1); 2134 char *s = toStringO(self); 2135 ck_assert_str_eq(s, "[1]"); 2136 free(s); 2137 // pop element of unexpected type 2138 r = self->f->popVoid(self); 2139 ck_assert(!r); 2140 ck_assert_int_eq(lenO(self), 1); 2141 s = toStringO(self); 2142 ck_assert_str_eq(s, "[1]"); 2143 free(s); 2144 // empty array 2145 r3 = self->f->pop(self); 2146 ck_assert_ptr_ne(r3, null); 2147 terminateO(r3); 2148 s = toStringO(self); 2149 ck_assert_str_eq(s, "[]"); 2150 free(s); 2151 r = self->f->popVoid(self); 2152 ck_assert(!r); 2153 s = toStringO(self); 2154 ck_assert_str_eq(s, "[]"); 2155 free(s); 2156 terminateO(self); 2157 2158 } 2159 2160 2161 void popSmallContainerSmallArrayT(CuTest *tc UNUSED) { 2162 2163 smallContainert* r; 2164 smallArrayt *self = allocG(rtSmallArrayt); 2165 smallArrayt *r2; 2166 baset *r3; 2167 2168 // add an element to check that the second element is poped 2169 // at the end 2170 r2 = self->f->pushInt(self, 1); 2171 ck_assert_ptr_ne(r2, null); 2172 // add second element 2173 createSmallContainer(e); 2174 r2 = self->f->pushSmallContainer(self, &e); 2175 ck_assert_ptr_ne(r2, null); 2176 r2 = self->f->pushUndefined(self); 2177 ck_assert_ptr_ne(r2, null); 2178 delElemO(self, -1); 2179 // pop 2180 r = self->f->popSmallContainer(self); 2181 ck_assert_ptr_ne(r, null); 2182 char *s = toStringO(r); 2183 terminateO(r); 2184 ck_assert_str_eq(s, "<data smallContainer>"); 2185 free(s); 2186 ck_assert_int_eq(lenO(self), 1); 2187 s = toStringO(self); 2188 ck_assert_str_eq(s, "[1]"); 2189 free(s); 2190 // container with baset object 2191 // push a base object of unknown type 2192 smallIntt *o = allocSmallInt(2); 2193 o->type = "newType"; 2194 r2 = self->f->pushNFree(self, (baset*)o); 2195 ck_assert_ptr_ne(r2, null); 2196 r = self->f->popSmallContainer(self); 2197 ck_assert_ptr_eq(r, NULL); 2198 ck_assert_int_eq(lenO(self), 2); 2199 s = toStringO(self); 2200 ck_assert_str_eq(s, "[1,\"<data container>\"]"); 2201 free(s); 2202 r3 = self->f->pop(self); 2203 ck_assert_ptr_ne(r3, null); 2204 terminateO(r3); 2205 // pop element of unexpected type 2206 r = self->f->popSmallContainer(self); 2207 ck_assert_ptr_eq(r, NULL); 2208 ck_assert_int_eq(lenO(self), 1); 2209 s = toStringO(self); 2210 ck_assert_str_eq(s, "[1]"); 2211 free(s); 2212 // empty array 2213 r3 = self->f->pop(self); 2214 ck_assert_ptr_ne(r3, null); 2215 terminateO(r3); 2216 s = toStringO(self); 2217 ck_assert_str_eq(s, "[]"); 2218 free(s); 2219 r = self->f->popSmallContainer(self); 2220 ck_assert(!r); 2221 s = toStringO(self); 2222 ck_assert_str_eq(s, "[]"); 2223 free(s); 2224 r2 = self->f->pushUndefined(self); 2225 ck_assert_ptr_ne(r2, null); 2226 delElemO(self,-1); 2227 r = self->f->popSmallContainer(self); 2228 ck_assert_ptr_eq(r, null); 2229 terminateO(self); 2230 2231 } 2232 2233 2234 void popNumSmallArrayT(CuTest *tc UNUSED) { 2235 2236 double r; 2237 smallArrayt *self = allocG(rtSmallArrayt); 2238 smallArrayt *r2; 2239 baset *r3; 2240 2241 // add an element to check that the second element is poped 2242 // at the end 2243 r2 = self->f->pushBool(self, TRUE); 2244 ck_assert_ptr_ne(r2, null); 2245 // add second element 2246 r2 = self->f->pushInt(self, 2); 2247 ck_assert_ptr_ne(r2, null); 2248 r2 = self->f->pushDouble(self, 2.5); 2249 ck_assert_ptr_ne(r2, null); 2250 r2 = self->f->pushUndefined(self); 2251 ck_assert_ptr_ne(r2, null); 2252 delElemO(self, -1); 2253 // pop 2254 r = self->f->popNum(self); 2255 ck_assert(r==2.5); 2256 ck_assert_int_eq(lenO(self), 2); 2257 char *s = toStringO(self); 2258 ck_assert_str_eq(s, "[true,2]"); 2259 free(s); 2260 r = self->f->popNum(self); 2261 ck_assert_int_eq(r, 2); 2262 ck_assert_int_eq(lenO(self), 1); 2263 s = toStringO(self); 2264 ck_assert_str_eq(s, "[true]"); 2265 free(s); 2266 // pop element of unexpected type 2267 r = self->f->popNum(self); 2268 ck_assert(!r); 2269 ck_assert_int_eq(lenO(self), 1); 2270 s = toStringO(self); 2271 ck_assert_str_eq(s, "[true]"); 2272 free(s); 2273 // empty array 2274 r3 = self->f->pop(self); 2275 ck_assert_ptr_ne(r3, null); 2276 terminateO(r3); 2277 s = toStringO(self); 2278 ck_assert_str_eq(s, "[]"); 2279 free(s); 2280 r = self->f->popNum(self); 2281 ck_assert(!r); 2282 s = toStringO(self); 2283 ck_assert_str_eq(s, "[]"); 2284 free(s); 2285 r2 = self->f->pushUndefined(self); 2286 ck_assert_ptr_ne(r2, null); 2287 delElemO(self,-1); 2288 r = self->f->popNum(self); 2289 ck_assert(!r); 2290 terminateO(self); 2291 2292 } 2293 2294 2295 void prependSmallArrayT(CuTest *tc UNUSED) { 2296 2297 smallArrayt* r; 2298 smallArrayt *self = allocG(rtSmallArrayt); 2299 baset *value = (baset*) allocG(2); 2300 2301 // add an element to check that prepend adds the second element 2302 // at the start 2303 r = self->f->pushInt(self, 1); 2304 ck_assert_ptr_ne(r, null); 2305 2306 r = self->f->prepend(self, value); 2307 ck_assert_ptr_ne(r, null); 2308 ck_assert_int_eq(lenO(r), 2); 2309 finishO(value); 2310 char *s = toStringO(r); 2311 ck_assert_str_eq(s, "[2,1]"); 2312 free(s); 2313 // null 2314 r = self->f->prepend(self, null); 2315 ck_assert_ptr_eq(r, null); 2316 ck_assert_int_eq(lenO(self), 2); 2317 s = toStringO(self); 2318 ck_assert_str_eq(s, "[2,1]"); 2319 free(s); 2320 2321 //r = prependO(self); 2322 terminateO(self); 2323 2324 } 2325 2326 2327 void prependUndefinedSmallArrayT(CuTest *tc UNUSED) { 2328 2329 smallArrayt* r; 2330 smallArrayt *self = allocG(rtSmallArrayt); 2331 2332 // add an element to check that push adds the second element 2333 // at the end 2334 r = self->f->pushInt(self, 1); 2335 ck_assert_ptr_ne(r, null); 2336 2337 r = self->f->prependUndefined(self); 2338 ck_assert_ptr_ne(r, null); 2339 ck_assert_int_eq(lenO(r), 2); 2340 char *s = toStringO(r); 2341 ck_assert_str_eq(s, "[null,1]"); 2342 free(s); 2343 terminateO(self); 2344 2345 } 2346 2347 2348 void prependBoolSmallArrayT(CuTest *tc UNUSED) { 2349 2350 smallArrayt* r; 2351 smallArrayt *self = allocG(rtSmallArrayt); 2352 2353 // add an element to check that push adds the second element 2354 // at the end 2355 r = self->f->pushInt(self, 1); 2356 ck_assert_ptr_ne(r, null); 2357 2358 r = self->f->prependBool(self, TRUE); 2359 ck_assert_ptr_ne(r, null); 2360 ck_assert_int_eq(lenO(r), 2); 2361 char *s = toStringO(r); 2362 ck_assert_str_eq(s, "[true,1]"); 2363 free(s); 2364 terminateO(self); 2365 2366 } 2367 2368 2369 void prependDoubleSmallArrayT(CuTest *tc UNUSED) { 2370 2371 smallArrayt* r; 2372 smallArrayt *self = allocG(rtSmallArrayt); 2373 2374 // add an element to check that push adds the second element 2375 // at the end 2376 r = self->f->pushInt(self, 1); 2377 ck_assert_ptr_ne(r, null); 2378 2379 r = self->f->prependDouble(self, 1.0); 2380 ck_assert_ptr_ne(r, null); 2381 ck_assert_int_eq(lenO(r), 2); 2382 char *s = toStringO(r); 2383 ck_assert_str_eq(s, "[1.000000e+00,1]"); 2384 free(s); 2385 terminateO(self); 2386 2387 } 2388 2389 2390 void prependIntSmallArrayT(CuTest *tc UNUSED) { 2391 2392 smallArrayt* r; 2393 smallArrayt *self = allocG(rtSmallArrayt); 2394 2395 // add an element to check that push adds the second element 2396 // at the end 2397 r = self->f->prependInt(self, 1); 2398 ck_assert_ptr_ne(r, null); 2399 2400 r = self->f->prependInt(self, 1); 2401 ck_assert_ptr_ne(r, null); 2402 ck_assert_int_eq(lenO(r), 2); 2403 char *s = toStringO(r); 2404 ck_assert_str_eq(s, "[1,1]"); 2405 free(s); 2406 terminateO(self); 2407 2408 } 2409 2410 2411 void prependSSmallArrayT(CuTest *tc UNUSED) { 2412 2413 smallArrayt* r; 2414 smallArrayt *self = allocG(rtSmallArrayt); 2415 2416 // add an element to check that push adds the second element 2417 // at the end 2418 r = self->f->pushInt(self, 1); 2419 ck_assert_ptr_ne(r, null); 2420 2421 r = self->f->prependS(self, null); 2422 ck_assert_ptr_eq(r, null); 2423 ck_assert_int_eq(lenO(self), 1); 2424 char *s = toStringO(self); 2425 ck_assert_str_eq(s, "[1]"); 2426 free(s); 2427 2428 char *str = "poi"; 2429 r = self->f->prependS(self, str); 2430 ck_assert_ptr_ne(r, null); 2431 ck_assert_int_eq(lenO(self), 2); 2432 s = toStringO(r); 2433 ck_assert_str_eq(s, "[\"poi\",1]"); 2434 free(s); 2435 2436 terminateO(self); 2437 2438 } 2439 2440 2441 void prependCharSmallArrayT(CuTest *tc UNUSED) { 2442 2443 smallArrayt* r; 2444 smallArrayt *self = allocG(rtSmallArrayt); 2445 2446 // add an element to check that push adds the second element 2447 // at the end 2448 r = self->f->pushInt(self, 1); 2449 ck_assert_ptr_ne(r, null); 2450 2451 r = self->f->prependChar(self, 'a'); 2452 ck_assert_ptr_ne(r, null); 2453 ck_assert_int_eq(lenO(r), 2); 2454 char *s = toStringO(r); 2455 ck_assert_str_eq(s, "[\"a\",1]"); 2456 free(s); 2457 terminateO(self); 2458 2459 } 2460 2461 2462 void prependDictSmallArrayT(CuTest *tc UNUSED) { 2463 2464 smallArrayt* r; 2465 smallArrayt *self = allocG(rtSmallArrayt); 2466 smallDictt *dict = allocG(rtSmallDictt); 2467 2468 // add an element to check that push adds the second element 2469 // at the end 2470 r = self->f->pushInt(self, 1); 2471 ck_assert_ptr_ne(r, null); 2472 2473 // push dict 2474 r = self->f->prependDict(self, dict); 2475 ck_assert_ptr_ne(r, null); 2476 ck_assert_int_eq(lenO(r), 2); 2477 finishO(dict); 2478 ck_assert_ptr_ne(r, null); 2479 char *s = toStringO(r); 2480 ck_assert_str_eq(s, "[{},1]"); 2481 free(s); 2482 // non smallDict object 2483 dict = (smallDictt*) allocSmallInt(2); 2484 r = self->f->prependDict(self, dict); 2485 ck_assert_ptr_eq(r, null); 2486 terminateO(dict); 2487 // null 2488 r = self->f->prependDict(self, null); 2489 ck_assert_ptr_eq(r, null); 2490 ck_assert_int_eq(lenO(self), 2); 2491 s = toStringO(self); 2492 ck_assert_str_eq(s, "[{},1]"); 2493 free(s); 2494 terminateO(self); 2495 2496 } 2497 2498 2499 void prependArraySmallArrayT(CuTest *tc UNUSED) { 2500 2501 smallArrayt* r; 2502 smallArrayt *self = allocG(rtSmallArrayt); 2503 smallArrayt *array = allocG(rtSmallArrayt); 2504 2505 // add an element to check that push adds the second element 2506 // at the end 2507 r = self->f->pushInt(self, 1); 2508 ck_assert_ptr_ne(r, null); 2509 2510 r = self->f->prependArray(self, array); 2511 ck_assert_ptr_ne(r, null); 2512 ck_assert_int_eq(lenO(r), 2); 2513 finishO(array); 2514 char *s = toStringO(r); 2515 ck_assert_str_eq(s, "[[],1]"); 2516 free(s); 2517 // non smallArray object 2518 array = (smallArrayt*) allocSmallInt(2); 2519 r = self->f->prependArray(self, array); 2520 ck_assert_ptr_eq(r, null); 2521 terminateO(array); 2522 // null 2523 r = self->f->prependArray(self, null); 2524 ck_assert_ptr_eq(r, null); 2525 ck_assert_int_eq(lenO(self), 2); 2526 s = toStringO(self); 2527 ck_assert_str_eq(s, "[[],1]"); 2528 free(s); 2529 terminateO(self); 2530 2531 } 2532 2533 2534 void prependArraycSmallArrayT(CuTest *tc UNUSED) { 2535 2536 smallArrayt* r; 2537 smallArrayt *self = allocG(rtSmallArrayt); 2538 char **array = listCreateS("a","bb"); 2539 2540 // add an element to check that push adds the second element 2541 // at the end 2542 r = self->f->pushInt(self, 1); 2543 ck_assert_ptr_ne(r, null); 2544 2545 r = self->f->prependArrayc(self, array); 2546 ck_assert_ptr_ne(r, null); 2547 ck_assert_int_eq(lenO(r), 2); 2548 listFreeS(array); 2549 char *s = toStringO(r); 2550 ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]"); 2551 free(s); 2552 // null 2553 r = self->f->prependArrayc(self, null); 2554 ck_assert_ptr_eq(r, null); 2555 ck_assert_int_eq(lenO(self), 2); 2556 s = toStringO(self); 2557 ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]"); 2558 free(s); 2559 terminateO(self); 2560 2561 } 2562 2563 2564 void prependSmallBoolSmallArrayT(CuTest *tc UNUSED) { 2565 2566 smallArrayt* r; 2567 smallArrayt *self = allocG(rtSmallArrayt); 2568 smallBoolt *value = allocG(TRUE); 2569 2570 // add an element to check that push adds the second element 2571 // at the end 2572 r = self->f->pushInt(self, 1); 2573 ck_assert_ptr_ne(r, null); 2574 2575 r = self->f->prependSmallBool(self, value); 2576 ck_assert_ptr_ne(r, null); 2577 ck_assert_int_eq(lenO(r), 2); 2578 finishO(value); 2579 char *s = toStringO(r); 2580 ck_assert_str_eq(s, "[true,1]"); 2581 free(s); 2582 // bool object with no data 2583 createAllocateSmallBool(b); 2584 r = self->f->prependSmallBool(self, b); 2585 ck_assert_ptr_ne(r, null); 2586 ck_assert_int_eq(lenO(r), 3); 2587 finishO(b); 2588 s = toStringO(r); 2589 ck_assert_str_eq(s, "[false,true,1]"); 2590 free(s); 2591 // non smallBool object 2592 value = (smallBoolt*) allocSmallInt(2); 2593 r = self->f->prependSmallBool(self, value); 2594 ck_assert_ptr_eq(r, null); 2595 terminateO(value); 2596 // null 2597 r = self->f->prependSmallBool(self, null); 2598 ck_assert_ptr_eq(r, null); 2599 ck_assert_int_eq(lenO(self), 3); 2600 s = toStringO(self); 2601 ck_assert_str_eq(s, "[false,true,1]"); 2602 free(s); 2603 terminateO(self); 2604 2605 } 2606 2607 2608 void prependSmallBytesSmallArrayT(CuTest *tc UNUSED) { 2609 2610 smallArrayt* r; 2611 smallArrayt *self = allocG(rtSmallArrayt); 2612 createAllocateSmallBytes(value); 2613 2614 // add an element to check that push adds the second element 2615 // at the end 2616 r = self->f->pushInt(self, 1); 2617 ck_assert_ptr_ne(r, null); 2618 2619 // the smallBytes container is empty 2620 r = self->f->prependSmallBytes(self, value); 2621 ck_assert_ptr_ne(r, null); 2622 ck_assert_int_eq(lenO(r), 2); 2623 char *s = toStringO(r); 2624 ck_assert_str_eq(s, "[[],1]"); 2625 free(s); 2626 // reuse value 2627 value->B = null; 2628 char *buffer = "poi"; 2629 pushBufferO(value, buffer, strlen(buffer)); 2630 r = self->f->prependSmallBytes(self, value); 2631 finishO(value); 2632 ck_assert_ptr_ne(r, null); 2633 ck_assert_int_eq(lenO(r), 3); 2634 s = toStringO(r); 2635 ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]"); 2636 free(s); 2637 // non smallBytes object 2638 value = (smallBytest*) allocSmallInt(2); 2639 r = self->f->prependSmallBytes(self, value); 2640 ck_assert_ptr_eq(r, null); 2641 terminateO(value); 2642 // null 2643 r = self->f->prependSmallBytes(self, null); 2644 ck_assert_ptr_eq(r, null); 2645 ck_assert_int_eq(lenO(self), 3); 2646 s = toStringO(self); 2647 ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]"); 2648 free(s); 2649 terminateO(self); 2650 2651 } 2652 2653 2654 void prependSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 2655 2656 smallArrayt* r; 2657 smallArrayt *self = allocG(rtSmallArrayt); 2658 smallDoublet *value = allocG(1.0); 2659 2660 // add an element to check that push adds the second element 2661 // at the end 2662 r = self->f->pushInt(self, 1); 2663 ck_assert_ptr_ne(r, null); 2664 2665 r = self->f->prependSmallDouble(self, value); 2666 ck_assert_ptr_ne(r, null); 2667 ck_assert_int_eq(lenO(r), 2); 2668 finishO(value); 2669 char *s = toStringO(r); 2670 ck_assert_str_eq(s, "[1.000000e+00,1]"); 2671 free(s); 2672 // object with no data 2673 createAllocateSmallDouble(b); 2674 r = self->f->prependSmallDouble(self, b); 2675 ck_assert_ptr_ne(r, null); 2676 ck_assert_int_eq(lenO(r), 3); 2677 finishO(b); 2678 s = toStringO(r); 2679 ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]"); 2680 free(s); 2681 // non smallDouble object 2682 value = (smallDoublet*) allocSmallInt(2); 2683 r = self->f->prependSmallDouble(self, value); 2684 ck_assert_ptr_eq(r, null); 2685 terminateO(value); 2686 // null 2687 r = self->f->prependSmallDouble(self, null); 2688 ck_assert_ptr_eq(r, null); 2689 ck_assert_int_eq(lenO(self), 3); 2690 s = toStringO(self); 2691 ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]"); 2692 free(s); 2693 terminateO(self); 2694 2695 } 2696 2697 2698 void prependSmallIntSmallArrayT(CuTest *tc UNUSED) { 2699 2700 smallArrayt* r; 2701 smallArrayt *self = allocG(rtSmallArrayt); 2702 smallIntt *value = allocG(1); 2703 2704 // add an element to check that push adds the second element 2705 // at the end 2706 r = self->f->pushInt(self, 1); 2707 ck_assert_ptr_ne(r, null); 2708 2709 r = self->f->prependSmallInt(self, value); 2710 ck_assert_ptr_ne(r, null); 2711 ck_assert_int_eq(lenO(r), 2); 2712 finishO(value); 2713 char *s = toStringO(r); 2714 ck_assert_str_eq(s, "[1,1]"); 2715 free(s); 2716 // bool object with no data 2717 createAllocateSmallInt(b); 2718 r = self->f->prependSmallInt(self, b); 2719 ck_assert_ptr_ne(r, null); 2720 ck_assert_int_eq(lenO(r), 3); 2721 finishO(b); 2722 s = toStringO(r); 2723 ck_assert_str_eq(s, "[0,1,1]"); 2724 free(s); 2725 // non smallInt object 2726 value = (smallIntt*) allocSmallBool(true); 2727 r = self->f->prependSmallInt(self, value); 2728 ck_assert_ptr_eq(r, null); 2729 terminateO(value); 2730 // null 2731 r = self->f->prependSmallInt(self, null); 2732 ck_assert_ptr_eq(r, null); 2733 ck_assert_int_eq(lenO(self), 3); 2734 s = toStringO(self); 2735 ck_assert_str_eq(s, "[0,1,1]"); 2736 free(s); 2737 terminateO(self); 2738 2739 } 2740 2741 2742 void prependSmallJsonSmallArrayT(CuTest *tc UNUSED) { 2743 2744 smallArrayt* r; 2745 smallArrayt *self = allocG(rtSmallArrayt); 2746 smallJsont *value = allocG(rtSmallJsont); 2747 2748 // add an element to check that push adds the second element 2749 // at the end 2750 r = self->f->pushInt(self, 1); 2751 ck_assert_ptr_ne(r, null); 2752 2753 // the smallJson container is empty 2754 r = self->f->prependSmallJson(self, value); 2755 ck_assert_ptr_ne(r, null); 2756 ck_assert_int_eq(lenO(r), 2); 2757 char *s = toStringO(r); 2758 ck_assert_str_eq(s, "[{},1]"); 2759 free(s); 2760 resetO(value); 2761 parseO(value, "{}"); 2762 r = self->f->prependSmallJson(self, value); 2763 finishO(value); 2764 ck_assert_ptr_ne(r, null); 2765 ck_assert_int_eq(lenO(r), 3); 2766 s = toStringO(r); 2767 ck_assert_str_eq(s, "[{},{},1]"); 2768 free(s); 2769 // non smallJson object 2770 value = (smallJsont*) allocSmallInt(2); 2771 r = self->f->prependSmallJson(self, value); 2772 ck_assert_ptr_eq(r, null); 2773 terminateO(value); 2774 // null 2775 r = self->f->prependSmallJson(self, null); 2776 ck_assert_ptr_eq(r, null); 2777 ck_assert_int_eq(lenO(self), 3); 2778 s = toStringO(self); 2779 ck_assert_str_eq(s, "[{},{},1]"); 2780 free(s); 2781 terminateO(self); 2782 2783 } 2784 2785 2786 void prependSmallStringSmallArrayT(CuTest *tc UNUSED) { 2787 2788 smallArrayt* r; 2789 smallArrayt *self = allocG(rtSmallArrayt); 2790 createAllocateSmallString(string); 2791 2792 // add an element to check that push adds the second element 2793 // at the end 2794 r = self->f->pushInt(self, 1); 2795 ck_assert_ptr_ne(r, null); 2796 2797 r = self->f->prependSmallString(self, string); 2798 ck_assert_ptr_ne(r, null); 2799 ck_assert_int_eq(lenO(r), 2); 2800 finishO(string); 2801 char *s = toStringO(r); 2802 ck_assert_str_eq(s, "[\"\",1]"); 2803 free(s); 2804 // non smallString object 2805 string = (smallStringt*) allocSmallInt(2); 2806 r = self->f->prependSmallString(self, string); 2807 ck_assert_ptr_eq(r, null); 2808 terminateO(string); 2809 // null 2810 r = self->f->prependSmallString(self, null); 2811 ck_assert_ptr_eq(r, null); 2812 ck_assert_int_eq(lenO(self), 2); 2813 s = toStringO(self); 2814 ck_assert_str_eq(s, "[\"\",1]"); 2815 free(s); 2816 terminateO(self); 2817 2818 } 2819 2820 2821 void prependSmallContainerSmallArrayT(CuTest *tc UNUSED) { 2822 2823 smallArrayt* r; 2824 smallArrayt *self = allocG(rtSmallArrayt); 2825 createAllocateSmallContainer(container); 2826 2827 // add an element to check that push adds the second element 2828 // at the end 2829 r = self->f->pushInt(self, 1); 2830 ck_assert_ptr_ne(r, null); 2831 2832 r = self->f->prependSmallContainer(self, container); 2833 ck_assert_ptr_ne(r, null); 2834 ck_assert_int_eq(lenO(r), 2); 2835 finishO(container); 2836 char *s = toStringO(r); 2837 ck_assert_str_eq(s, "[\"<data container>\",1]"); 2838 free(s); 2839 // non smallContainer object 2840 container = (smallContainert*) allocSmallInt(2); 2841 r = self->f->prependSmallContainer(self, container); 2842 ck_assert_ptr_eq(r, null); 2843 terminateO(container); 2844 // null 2845 r = self->f->prependSmallContainer(self, null); 2846 ck_assert_ptr_eq(r, null); 2847 ck_assert_int_eq(lenO(self), 2); 2848 s = toStringO(self); 2849 ck_assert_str_eq(s, "[\"<data container>\",1]"); 2850 free(s); 2851 terminateO(self); 2852 2853 } 2854 2855 2856 void prependNFreeSmallArrayT(CuTest *tc UNUSED) { 2857 2858 smallArrayt* r; 2859 smallArrayt *self = allocG(rtSmallArrayt); 2860 baset *value = (baset*) allocG(2); 2861 2862 // add an element to check that prepend adds the second element 2863 // at the start 2864 r = self->f->pushInt(self, 1); 2865 ck_assert_ptr_ne(r, null); 2866 2867 r = self->f->prependNFree(self, value); 2868 ck_assert_ptr_ne(r, null); 2869 ck_assert_int_eq(lenO(r), 2); 2870 char *s = toStringO(r); 2871 ck_assert_str_eq(s, "[2,1]"); 2872 free(s); 2873 // null 2874 r = self->f->prependNFree(self, null); 2875 ck_assert_ptr_eq(r, null); 2876 ck_assert_int_eq(lenO(self), 2); 2877 s = toStringO(self); 2878 ck_assert_str_eq(s, "[2,1]"); 2879 free(s); 2880 2881 //r = prependO(self); 2882 terminateO(self); 2883 2884 } 2885 2886 2887 void prependNFreeUndefinedSmallArrayT(CuTest *tc UNUSED) { 2888 2889 smallArrayt* r; 2890 smallArrayt *self = allocG(rtSmallArrayt); 2891 2892 // add an element to check that push adds the second element 2893 // at the end 2894 r = self->f->pushInt(self, 1); 2895 ck_assert_ptr_ne(r, null); 2896 2897 createAllocateUndefined(value); 2898 r = self->f->prependNFreeUndefined(self, value); 2899 ck_assert_ptr_ne(r, null); 2900 ck_assert_int_eq(lenO(r), 2); 2901 char *s = toStringO(r); 2902 ck_assert_str_eq(s, "[null,1]"); 2903 free(s); 2904 terminateO(self); 2905 2906 } 2907 2908 2909 void prependNFreeSSmallArrayT(CuTest *tc UNUSED) { 2910 2911 smallArrayt* r; 2912 smallArrayt *self = allocG(rtSmallArrayt); 2913 2914 // add an element to check that push adds the second element 2915 // at the end 2916 r = self->f->pushInt(self, 1); 2917 ck_assert_ptr_ne(r, null); 2918 2919 r = self->f->prependNFreeS(self, null); 2920 ck_assert_ptr_eq(r, null); 2921 ck_assert_int_eq(lenO(self), 1); 2922 char *s = toStringO(self); 2923 ck_assert_str_eq(s, "[1]"); 2924 free(s); 2925 2926 char *str = strdup("poi"); 2927 r = self->f->prependNFreeS(self, str); 2928 ck_assert_ptr_ne(r, null); 2929 ck_assert_int_eq(lenO(self), 2); 2930 s = toStringO(r); 2931 ck_assert_str_eq(s, "[\"poi\",1]"); 2932 free(s); 2933 2934 terminateO(self); 2935 2936 } 2937 2938 2939 void prependNFreeDictSmallArrayT(CuTest *tc UNUSED) { 2940 2941 smallArrayt* r; 2942 smallArrayt *self = allocG(rtSmallArrayt); 2943 smallDictt *dict = allocG(rtSmallDictt); 2944 2945 // add an element to check that push adds the second element 2946 // at the end 2947 r = self->f->pushInt(self, 1); 2948 ck_assert_ptr_ne(r, null); 2949 2950 // push dict 2951 r = self->f->prependNFreeDict(self, dict); 2952 ck_assert_ptr_ne(r, null); 2953 ck_assert_int_eq(lenO(r), 2); 2954 ck_assert_ptr_ne(r, null); 2955 char *s = toStringO(r); 2956 ck_assert_str_eq(s, "[{},1]"); 2957 free(s); 2958 // null 2959 r = self->f->prependNFreeDict(self, null); 2960 ck_assert_ptr_eq(r, null); 2961 ck_assert_int_eq(lenO(self), 2); 2962 s = toStringO(self); 2963 ck_assert_str_eq(s, "[{},1]"); 2964 free(s); 2965 terminateO(self); 2966 2967 } 2968 2969 2970 void prependNFreeArraySmallArrayT(CuTest *tc UNUSED) { 2971 2972 smallArrayt* r; 2973 smallArrayt *self = allocG(rtSmallArrayt); 2974 smallArrayt *array = allocG(rtSmallArrayt); 2975 2976 // add an element to check that push adds the second element 2977 // at the end 2978 r = self->f->pushInt(self, 1); 2979 ck_assert_ptr_ne(r, null); 2980 2981 r = self->f->prependNFreeArray(self, array); 2982 ck_assert_ptr_ne(r, null); 2983 ck_assert_int_eq(lenO(r), 2); 2984 char *s = toStringO(r); 2985 ck_assert_str_eq(s, "[[],1]"); 2986 free(s); 2987 // null 2988 r = self->f->prependNFreeArray(self, null); 2989 ck_assert_ptr_eq(r, null); 2990 ck_assert_int_eq(lenO(self), 2); 2991 s = toStringO(self); 2992 ck_assert_str_eq(s, "[[],1]"); 2993 free(s); 2994 terminateO(self); 2995 2996 } 2997 2998 2999 void prependNFreeArraycSmallArrayT(CuTest *tc UNUSED) { 3000 3001 smallArrayt* r; 3002 smallArrayt *self = allocG(rtSmallArrayt); 3003 char **array = listCreateS("a","bb"); 3004 3005 // add an element to check that push adds the second element 3006 // at the end 3007 r = self->f->pushInt(self, 1); 3008 ck_assert_ptr_ne(r, null); 3009 3010 r = self->f->prependNFreeArrayc(self, array); 3011 ck_assert_ptr_ne(r, null); 3012 ck_assert_int_eq(lenO(r), 2); 3013 char *s = toStringO(r); 3014 ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]"); 3015 free(s); 3016 // null 3017 r = self->f->prependNFreeArrayc(self, null); 3018 ck_assert_ptr_eq(r, null); 3019 ck_assert_int_eq(lenO(self), 2); 3020 s = toStringO(self); 3021 ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]"); 3022 free(s); 3023 terminateO(self); 3024 3025 } 3026 3027 3028 void prependNFreeSmallBoolSmallArrayT(CuTest *tc UNUSED) { 3029 3030 smallArrayt* r; 3031 smallArrayt *self = allocG(rtSmallArrayt); 3032 smallBoolt *value = allocG(TRUE); 3033 3034 // add an element to check that push adds the second element 3035 // at the end 3036 r = self->f->pushInt(self, 1); 3037 ck_assert_ptr_ne(r, null); 3038 3039 r = self->f->prependNFreeSmallBool(self, value); 3040 ck_assert_ptr_ne(r, null); 3041 ck_assert_int_eq(lenO(r), 2); 3042 char *s = toStringO(r); 3043 ck_assert_str_eq(s, "[true,1]"); 3044 free(s); 3045 // bool object with no data 3046 createAllocateSmallBool(b); 3047 r = self->f->prependNFreeSmallBool(self, b); 3048 ck_assert_ptr_ne(r, null); 3049 ck_assert_int_eq(lenO(r), 3); 3050 s = toStringO(r); 3051 ck_assert_str_eq(s, "[false,true,1]"); 3052 free(s); 3053 // null 3054 r = self->f->prependNFreeSmallBool(self, null); 3055 ck_assert_ptr_eq(r, null); 3056 ck_assert_int_eq(lenO(self), 3); 3057 s = toStringO(self); 3058 ck_assert_str_eq(s, "[false,true,1]"); 3059 free(s); 3060 terminateO(self); 3061 3062 } 3063 3064 3065 void prependNFreeSmallBytesSmallArrayT(CuTest *tc UNUSED) { 3066 3067 smallArrayt* r; 3068 smallArrayt *self = allocG(rtSmallArrayt); 3069 createAllocateSmallBytes(value); 3070 3071 // add an element to check that push adds the second element 3072 // at the end 3073 r = self->f->pushInt(self, 1); 3074 ck_assert_ptr_ne(r, null); 3075 3076 // the smallBytes container is empty 3077 r = self->f->prependNFreeSmallBytes(self, value); 3078 ck_assert_ptr_ne(r, null); 3079 ck_assert_int_eq(lenO(r), 2); 3080 char *s = toStringO(r); 3081 ck_assert_str_eq(s, "[[],1]"); 3082 free(s); 3083 3084 char *buffer = "poi"; 3085 value = allocSmallBytes(buffer, strlen(buffer)); 3086 r = self->f->prependNFreeSmallBytes(self, value); 3087 ck_assert_ptr_ne(r, null); 3088 ck_assert_int_eq(lenO(r), 3); 3089 s = toStringO(r); 3090 ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]"); 3091 free(s); 3092 // null 3093 r = self->f->prependNFreeSmallBytes(self, null); 3094 ck_assert_ptr_eq(r, null); 3095 ck_assert_int_eq(lenO(self), 3); 3096 s = toStringO(self); 3097 ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]"); 3098 free(s); 3099 terminateO(self); 3100 3101 } 3102 3103 3104 void prependNFreeSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 3105 3106 smallArrayt* r; 3107 smallArrayt *self = allocG(rtSmallArrayt); 3108 smallDoublet *value = allocG(1.0); 3109 3110 // add an element to check that push adds the second element 3111 // at the end 3112 r = self->f->pushInt(self, 1); 3113 ck_assert_ptr_ne(r, null); 3114 3115 r = self->f->prependNFreeSmallDouble(self, value); 3116 ck_assert_ptr_ne(r, null); 3117 ck_assert_int_eq(lenO(r), 2); 3118 char *s = toStringO(r); 3119 ck_assert_str_eq(s, "[1.000000e+00,1]"); 3120 free(s); 3121 // object with no data 3122 createAllocateSmallDouble(b); 3123 r = self->f->prependNFreeSmallDouble(self, b); 3124 ck_assert_ptr_ne(r, null); 3125 ck_assert_int_eq(lenO(r), 3); 3126 s = toStringO(r); 3127 ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]"); 3128 free(s); 3129 // null 3130 r = self->f->prependNFreeSmallDouble(self, null); 3131 ck_assert_ptr_eq(r, null); 3132 ck_assert_int_eq(lenO(self), 3); 3133 s = toStringO(self); 3134 ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]"); 3135 free(s); 3136 terminateO(self); 3137 3138 } 3139 3140 3141 void prependNFreeSmallIntSmallArrayT(CuTest *tc UNUSED) { 3142 3143 smallArrayt* r; 3144 smallArrayt *self = allocG(rtSmallArrayt); 3145 smallIntt *value = allocG(1); 3146 3147 // add an element to check that push adds the second element 3148 // at the end 3149 r = self->f->pushInt(self, 1); 3150 ck_assert_ptr_ne(r, null); 3151 3152 r = self->f->prependNFreeSmallInt(self, value); 3153 ck_assert_ptr_ne(r, null); 3154 ck_assert_int_eq(lenO(r), 2); 3155 char *s = toStringO(r); 3156 ck_assert_str_eq(s, "[1,1]"); 3157 free(s); 3158 // bool object with no data 3159 createAllocateSmallInt(b); 3160 r = self->f->prependNFreeSmallInt(self, b); 3161 ck_assert_ptr_ne(r, null); 3162 ck_assert_int_eq(lenO(r), 3); 3163 s = toStringO(r); 3164 ck_assert_str_eq(s, "[0,1,1]"); 3165 free(s); 3166 // null 3167 r = self->f->prependNFreeSmallInt(self, null); 3168 ck_assert_ptr_eq(r, null); 3169 ck_assert_int_eq(lenO(self), 3); 3170 s = toStringO(self); 3171 ck_assert_str_eq(s, "[0,1,1]"); 3172 free(s); 3173 terminateO(self); 3174 3175 } 3176 3177 3178 void prependNFreeSmallJsonSmallArrayT(CuTest *tc UNUSED) { 3179 3180 smallArrayt* r; 3181 smallArrayt *self = allocG(rtSmallArrayt); 3182 smallJsont *value = allocG(rtSmallJsont); 3183 3184 // add an element to check that push adds the second element 3185 // at the end 3186 r = self->f->pushInt(self, 1); 3187 ck_assert_ptr_ne(r, null); 3188 3189 // the smallJson container is empty 3190 r = self->f->prependNFreeSmallJson(self, value); 3191 ck_assert_ptr_ne(r, null); 3192 ck_assert_int_eq(lenO(r), 2); 3193 char *s = toStringO(r); 3194 ck_assert_str_eq(s, "[{},1]"); 3195 free(s); 3196 3197 value = allocG(rtSmallJsont); 3198 parseO(value, "{}"); 3199 r = self->f->prependNFreeSmallJson(self, value); 3200 ck_assert_ptr_ne(r, null); 3201 ck_assert_int_eq(lenO(r), 3); 3202 s = toStringO(r); 3203 ck_assert_str_eq(s, "[{},{},1]"); 3204 free(s); 3205 // null 3206 r = self->f->prependNFreeSmallJson(self, null); 3207 ck_assert_ptr_eq(r, null); 3208 ck_assert_int_eq(lenO(self), 3); 3209 s = toStringO(self); 3210 ck_assert_str_eq(s, "[{},{},1]"); 3211 free(s); 3212 terminateO(self); 3213 3214 } 3215 3216 3217 void prependNFreeSmallStringSmallArrayT(CuTest *tc UNUSED) { 3218 3219 smallArrayt* r; 3220 smallArrayt *self = allocG(rtSmallArrayt); 3221 createAllocateSmallString(string); 3222 3223 // add an element to check that push adds the second element 3224 // at the end 3225 r = self->f->pushInt(self, 1); 3226 ck_assert_ptr_ne(r, null); 3227 3228 r = self->f->prependNFreeSmallString(self, string); 3229 ck_assert_ptr_ne(r, null); 3230 ck_assert_int_eq(lenO(r), 2); 3231 char *s = toStringO(r); 3232 ck_assert_str_eq(s, "[\"\",1]"); 3233 free(s); 3234 // null 3235 r = self->f->prependNFreeSmallString(self, null); 3236 ck_assert_ptr_eq(r, null); 3237 ck_assert_int_eq(lenO(self), 2); 3238 s = toStringO(self); 3239 ck_assert_str_eq(s, "[\"\",1]"); 3240 free(s); 3241 terminateO(self); 3242 3243 } 3244 3245 3246 void prependNFreeSmallContainerSmallArrayT(CuTest *tc UNUSED) { 3247 3248 smallArrayt* r; 3249 smallArrayt *self = allocG(rtSmallArrayt); 3250 createAllocateSmallContainer(container); 3251 3252 // add an element to check that push adds the second element 3253 // at the end 3254 r = self->f->pushInt(self, 1); 3255 ck_assert_ptr_ne(r, null); 3256 3257 r = self->f->prependNFreeSmallContainer(self, container); 3258 ck_assert_ptr_ne(r, null); 3259 ck_assert_int_eq(lenO(r), 2); 3260 char *s = toStringO(r); 3261 ck_assert_str_eq(s, "[\"<data container>\",1]"); 3262 free(s); 3263 // null 3264 r = self->f->prependNFreeSmallContainer(self, null); 3265 ck_assert_ptr_eq(r, null); 3266 ck_assert_int_eq(lenO(self), 2); 3267 s = toStringO(self); 3268 ck_assert_str_eq(s, "[\"<data container>\",1]"); 3269 free(s); 3270 terminateO(self); 3271 3272 } 3273 3274 3275 void dequeueSmallArrayT(CuTest *tc UNUSED) { 3276 3277 baset* r; 3278 smallArrayt *self = allocG(rtSmallArrayt); 3279 smallArrayt *r2; 3280 3281 // add an element to check that the second element is dequeueed 3282 // at the end 3283 r2 = self->f->prependInt(self, 1); 3284 ck_assert_ptr_ne(r2, null); 3285 // prepend a base object of unknown type 3286 smallIntt *o = allocSmallInt(2); 3287 o->type = "newType"; 3288 r2 = self->f->prependNFree(self, (baset*)o); 3289 ck_assert_ptr_ne(r2, null); 3290 r2 = self->f->prependUndefined(self); 3291 ck_assert_ptr_ne(r2, null); 3292 r = self->f->dequeue(self); 3293 ck_assert_ptr_ne(r, null); 3294 ck_assert(isOUndefined(r)); 3295 terminateO(r); 3296 r = self->f->dequeue(self); 3297 ck_assert_ptr_ne(r, null); 3298 ck_assert_str_eq(r->type, "newType"); 3299 char *s = toStringO(r); 3300 terminateO(r); 3301 ck_assert_str_eq(s, "2"); 3302 free(s); 3303 ck_assert_int_eq(lenO(self), 1); 3304 s = toStringO(self); 3305 ck_assert_str_eq(s, "[1]"); 3306 free(s); 3307 // empty array 3308 r = self->f->dequeue(self); 3309 ck_assert_ptr_ne(r, null); 3310 terminateO(r); 3311 s = toStringO(self); 3312 ck_assert_str_eq(s, "[]"); 3313 free(s); 3314 r = self->f->dequeue(self); 3315 ck_assert_ptr_eq(r, null); 3316 s = toStringO(self); 3317 ck_assert_str_eq(s, "[]"); 3318 free(s); 3319 r2 = self->f->pushUndefined(self); 3320 ck_assert_ptr_ne(r2, null); 3321 delElemO(self,-1); 3322 r = self->f->dequeue(self); 3323 ck_assert_ptr_eq(r, null); 3324 terminateO(self); 3325 3326 } 3327 3328 3329 void dequeueUndefinedSmallArrayT(CuTest *tc UNUSED) { 3330 3331 undefinedt* r; 3332 smallArrayt *self = allocG(rtSmallArrayt); 3333 smallArrayt *r2; 3334 baset *r3; 3335 3336 // add an element to check that the second element is poped 3337 // at the end 3338 r2 = self->f->pushInt(self, 1); 3339 ck_assert_ptr_ne(r2, null); 3340 // add second element 3341 r2 = self->f->prependUndefined(self); 3342 ck_assert_ptr_ne(r2, null); 3343 // pop 3344 r = self->f->dequeueUndefined(self); 3345 ck_assert_ptr_ne(r, null); 3346 char *s = toStringO(r); 3347 terminateO(r); 3348 ck_assert_str_eq(s, "null"); 3349 free(s); 3350 ck_assert_int_eq(lenO(self), 1); 3351 s = toStringO(self); 3352 ck_assert_str_eq(s, "[1]"); 3353 free(s); 3354 // pop element of unexpected type 3355 r = self->f->dequeueUndefined(self); 3356 ck_assert_ptr_eq(r, null); 3357 ck_assert_int_eq(lenO(self), 1); 3358 s = toStringO(self); 3359 ck_assert_str_eq(s, "[1]"); 3360 free(s); 3361 // empty array 3362 r3 = self->f->pop(self); 3363 ck_assert_ptr_ne(r3, null); 3364 terminateO(r3); 3365 s = toStringO(self); 3366 ck_assert_str_eq(s, "[]"); 3367 free(s); 3368 r = self->f->dequeueUndefined(self); 3369 ck_assert_ptr_eq(r, null); 3370 s = toStringO(self); 3371 ck_assert_str_eq(s, "[]"); 3372 free(s); 3373 r2 = self->f->pushUndefined(self); 3374 ck_assert_ptr_ne(r2, null); 3375 delElemO(self,-1); 3376 r = self->f->dequeueUndefined(self); 3377 ck_assert_ptr_eq(r, null); 3378 terminateO(self); 3379 3380 } 3381 3382 3383 void dequeueBoolSmallArrayT(CuTest *tc UNUSED) { 3384 3385 bool r; 3386 smallArrayt *self = allocG(rtSmallArrayt); 3387 smallArrayt *r2; 3388 baset *r3; 3389 3390 // add an element to check that the second element is poped 3391 // at the end 3392 r2 = self->f->pushInt(self, 1); 3393 ck_assert_ptr_ne(r2, null); 3394 3395 // add second element 3396 r2 = self->f->prependBool(self, TRUE); 3397 ck_assert_ptr_ne(r2, null); 3398 3399 // pop 3400 r = self->f->dequeueBool(self); 3401 ck_assert(r); 3402 ck_assert_int_eq(lenO(self), 1); 3403 char *s = toStringO(self); 3404 ck_assert_str_eq(s, "[1]"); 3405 free(s); 3406 3407 // pop element of unexpected type 3408 r = self->f->dequeueBool(self); 3409 ck_assert(!r); 3410 ck_assert_int_eq(lenO(self), 1); 3411 s = toStringO(self); 3412 ck_assert_str_eq(s, "[1]"); 3413 free(s); 3414 3415 // empty array 3416 r3 = self->f->pop(self); 3417 ck_assert_ptr_ne(r3, null); 3418 terminateO(r3); 3419 s = toStringO(self); 3420 ck_assert_str_eq(s, "[]"); 3421 free(s); 3422 r = self->f->dequeueBool(self); 3423 ck_assert(!r); 3424 s = toStringO(self); 3425 ck_assert_str_eq(s, "[]"); 3426 free(s); 3427 terminateO(self); 3428 3429 } 3430 3431 3432 void dequeueDoubleSmallArrayT(CuTest *tc UNUSED) { 3433 3434 double r; 3435 smallArrayt *self = allocG(rtSmallArrayt); 3436 smallArrayt *r2; 3437 baset *r3; 3438 3439 // add an element to check that the second element is poped 3440 // at the end 3441 r2 = self->f->pushInt(self, 1); 3442 ck_assert_ptr_ne(r2, null); 3443 3444 // add second element 3445 r2 = self->f->prependDouble(self, 2.0); 3446 ck_assert_ptr_ne(r2, null); 3447 3448 // pop 3449 r = self->f->dequeueDouble(self); 3450 ck_assert(r==2.0); 3451 ck_assert_int_eq(lenO(self), 1); 3452 char *s = toStringO(self); 3453 ck_assert_str_eq(s, "[1]"); 3454 free(s); 3455 3456 // pop element of unexpected type 3457 r = self->f->dequeueDouble(self); 3458 ck_assert(!r); 3459 ck_assert_int_eq(lenO(self), 1); 3460 s = toStringO(self); 3461 ck_assert_str_eq(s, "[1]"); 3462 free(s); 3463 3464 // empty array 3465 r3 = self->f->pop(self); 3466 ck_assert_ptr_ne(r3, null); 3467 terminateO(r3); 3468 s = toStringO(self); 3469 ck_assert_str_eq(s, "[]"); 3470 free(s); 3471 r = self->f->dequeueDouble(self); 3472 ck_assert(!r); 3473 s = toStringO(self); 3474 ck_assert_str_eq(s, "[]"); 3475 free(s); 3476 terminateO(self); 3477 3478 } 3479 3480 3481 void dequeueIntSmallArrayT(CuTest *tc UNUSED) { 3482 3483 int64_t r; 3484 smallArrayt *self = allocG(rtSmallArrayt); 3485 smallArrayt *r2; 3486 baset *r3; 3487 3488 // add an element to check that the second element is poped 3489 // at the end 3490 r2 = self->f->pushBool(self, FALSE); 3491 ck_assert_ptr_ne(r2, null); 3492 3493 // add second element 3494 r2 = self->f->prependInt(self, 2); 3495 ck_assert_ptr_ne(r2, null); 3496 3497 // pop 3498 r = self->f->dequeueInt(self); 3499 ck_assert_int_eq(r, 2); 3500 ck_assert_int_eq(lenO(self), 1); 3501 char *s = toStringO(self); 3502 ck_assert_str_eq(s, "[false]"); 3503 free(s); 3504 3505 // pop element of unexpected type 3506 r = self->f->dequeueInt(self); 3507 ck_assert(!r); 3508 ck_assert_int_eq(lenO(self), 1); 3509 s = toStringO(self); 3510 ck_assert_str_eq(s, "[false]"); 3511 free(s); 3512 3513 // empty array 3514 r3 = self->f->pop(self); 3515 ck_assert_ptr_ne(r3, null); 3516 terminateO(r3); 3517 s = toStringO(self); 3518 ck_assert_str_eq(s, "[]"); 3519 free(s); 3520 r = self->f->dequeueInt(self); 3521 ck_assert(!r); 3522 s = toStringO(self); 3523 ck_assert_str_eq(s, "[]"); 3524 free(s); 3525 terminateO(self); 3526 3527 } 3528 3529 3530 void dequeueInt32SmallArrayT(CuTest *tc UNUSED) { 3531 3532 int32_t r; 3533 smallArrayt *self = allocG(rtSmallArrayt); 3534 smallArrayt *r2; 3535 baset *r3; 3536 3537 // add an element to check that the second element is poped 3538 // at the end 3539 r2 = self->f->pushBool(self, FALSE); 3540 ck_assert_ptr_ne(r2, null); 3541 3542 // add second element 3543 r2 = self->f->prependInt(self, 2); 3544 ck_assert_ptr_ne(r2, null); 3545 3546 // pop 3547 r = self->f->dequeueInt32(self); 3548 ck_assert_int_eq(r, 2); 3549 ck_assert_int_eq(lenO(self), 1); 3550 char *s = toStringO(self); 3551 ck_assert_str_eq(s, "[false]"); 3552 free(s); 3553 3554 // pop element of unexpected type 3555 r = self->f->dequeueInt32(self); 3556 ck_assert(!r); 3557 ck_assert_int_eq(lenO(self), 1); 3558 s = toStringO(self); 3559 ck_assert_str_eq(s, "[false]"); 3560 free(s); 3561 3562 // empty array 3563 r3 = self->f->pop(self); 3564 ck_assert_ptr_ne(r3, null); 3565 terminateO(r3); 3566 s = toStringO(self); 3567 ck_assert_str_eq(s, "[]"); 3568 free(s); 3569 r = self->f->dequeueInt32(self); 3570 ck_assert(!r); 3571 s = toStringO(self); 3572 ck_assert_str_eq(s, "[]"); 3573 free(s); 3574 terminateO(self); 3575 3576 } 3577 3578 3579 void dequeueUintSmallArrayT(CuTest *tc UNUSED) { 3580 3581 uint64_t r; 3582 smallArrayt *self = allocG(rtSmallArrayt); 3583 smallArrayt *r2; 3584 baset *r3; 3585 3586 // add an element to check that the second element is poped 3587 // at the end 3588 r2 = self->f->pushBool(self, FALSE); 3589 ck_assert_ptr_ne(r2, null); 3590 3591 // add second element 3592 r2 = self->f->prependInt(self, 2); 3593 ck_assert_ptr_ne(r2, null); 3594 3595 // pop 3596 r = self->f->dequeueUint(self); 3597 ck_assert_int_eq(r, 2); 3598 ck_assert_int_eq(lenO(self), 1); 3599 char *s = toStringO(self); 3600 ck_assert_str_eq(s, "[false]"); 3601 free(s); 3602 3603 // pop element of unexpected type 3604 r = self->f->dequeueUint(self); 3605 ck_assert(!r); 3606 ck_assert_int_eq(lenO(self), 1); 3607 s = toStringO(self); 3608 ck_assert_str_eq(s, "[false]"); 3609 free(s); 3610 3611 // empty array 3612 r3 = self->f->pop(self); 3613 ck_assert_ptr_ne(r3, null); 3614 terminateO(r3); 3615 s = toStringO(self); 3616 ck_assert_str_eq(s, "[]"); 3617 free(s); 3618 r = self->f->dequeueUint(self); 3619 ck_assert(!r); 3620 s = toStringO(self); 3621 ck_assert_str_eq(s, "[]"); 3622 free(s); 3623 terminateO(self); 3624 3625 } 3626 3627 3628 void dequeueUint32SmallArrayT(CuTest *tc UNUSED) { 3629 3630 uint32_t r; 3631 smallArrayt *self = allocG(rtSmallArrayt); 3632 smallArrayt *r2; 3633 baset *r3; 3634 3635 // add an element to check that the second element is poped 3636 // at the end 3637 r2 = self->f->pushBool(self, FALSE); 3638 ck_assert_ptr_ne(r2, null); 3639 3640 // add second element 3641 r2 = self->f->prependInt(self, 2); 3642 ck_assert_ptr_ne(r2, null); 3643 3644 // pop 3645 r = self->f->dequeueUint32(self); 3646 ck_assert_int_eq(r, 2); 3647 ck_assert_int_eq(lenO(self), 1); 3648 char *s = toStringO(self); 3649 ck_assert_str_eq(s, "[false]"); 3650 free(s); 3651 3652 // pop element of unexpected type 3653 r = self->f->dequeueUint32(self); 3654 ck_assert(!r); 3655 ck_assert_int_eq(lenO(self), 1); 3656 s = toStringO(self); 3657 ck_assert_str_eq(s, "[false]"); 3658 free(s); 3659 3660 // empty array 3661 r3 = self->f->pop(self); 3662 ck_assert_ptr_ne(r3, null); 3663 terminateO(r3); 3664 s = toStringO(self); 3665 ck_assert_str_eq(s, "[]"); 3666 free(s); 3667 r = self->f->dequeueUint32(self); 3668 ck_assert(!r); 3669 s = toStringO(self); 3670 ck_assert_str_eq(s, "[]"); 3671 free(s); 3672 terminateO(self); 3673 3674 } 3675 3676 3677 void dequeueSSmallArrayT(CuTest *tc UNUSED) { 3678 3679 char* r; 3680 smallArrayt *self = allocG(rtSmallArrayt); 3681 smallArrayt *r2; 3682 baset *r3; 3683 3684 // add an element to check that the second element is poped 3685 // at the end 3686 r2 = self->f->pushInt(self, 1); 3687 ck_assert_ptr_ne(r2, null); 3688 3689 // add second element 3690 r2 = self->f->prependS(self, "bb"); 3691 ck_assert_ptr_ne(r2, null); 3692 3693 // pop 3694 r = self->f->dequeueS(self); 3695 ck_assert_str_eq(r, "bb"); 3696 free(r); 3697 ck_assert_int_eq(lenO(self), 1); 3698 char *s = toStringO(self); 3699 ck_assert_str_eq(s, "[1]"); 3700 free(s); 3701 3702 // pop element of unexpected type 3703 r = self->f->dequeueS(self); 3704 ck_assert(!r); 3705 ck_assert_int_eq(lenO(self), 1); 3706 s = toStringO(self); 3707 ck_assert_str_eq(s, "[1]"); 3708 free(s); 3709 3710 // empty array 3711 r3 = self->f->pop(self); 3712 ck_assert_ptr_ne(r3, null); 3713 terminateO(r3); 3714 s = toStringO(self); 3715 ck_assert_str_eq(s, "[]"); 3716 free(s); 3717 r = self->f->dequeueS(self); 3718 ck_assert(!r); 3719 s = toStringO(self); 3720 ck_assert_str_eq(s, "[]"); 3721 free(s); 3722 terminateO(self); 3723 3724 } 3725 3726 3727 void dequeueDictSmallArrayT(CuTest *tc UNUSED) { 3728 3729 smallDictt* r; 3730 smallArrayt *self = allocG(rtSmallArrayt); 3731 smallArrayt *r2; 3732 baset *r3; 3733 3734 // add an element to check that the second element is poped 3735 // at the end 3736 r2 = self->f->pushInt(self, 1); 3737 ck_assert_ptr_ne(r2, null); 3738 // add second element 3739 createSmallDict(e); 3740 r2 = self->f->prependDict(self, &e); 3741 ck_assert_ptr_ne(r2, null); 3742 // pop 3743 r = self->f->dequeueDict(self); 3744 ck_assert_ptr_ne(r, null); 3745 char *s = toStringO(r); 3746 terminateO(r); 3747 ck_assert_str_eq(s, "{}"); 3748 free(s); 3749 ck_assert_int_eq(lenO(self), 1); 3750 s = toStringO(self); 3751 ck_assert_str_eq(s, "[1]"); 3752 free(s); 3753 // pop element of unexpected type 3754 r = self->f->dequeueDict(self); 3755 ck_assert(!r); 3756 ck_assert_int_eq(lenO(self), 1); 3757 s = toStringO(self); 3758 ck_assert_str_eq(s, "[1]"); 3759 free(s); 3760 // empty array 3761 r3 = self->f->pop(self); 3762 ck_assert_ptr_ne(r3, null); 3763 terminateO(r3); 3764 s = toStringO(self); 3765 ck_assert_str_eq(s, "[]"); 3766 free(s); 3767 r = self->f->dequeueDict(self); 3768 ck_assert(!r); 3769 s = toStringO(self); 3770 ck_assert_str_eq(s, "[]"); 3771 free(s); 3772 r2 = self->f->pushUndefined(self); 3773 ck_assert_ptr_ne(r2, null); 3774 delElemO(self,-1); 3775 r = self->f->dequeueDict(self); 3776 ck_assert_ptr_eq(r, null); 3777 terminateO(self); 3778 3779 } 3780 3781 3782 void dequeueArraySmallArrayT(CuTest *tc UNUSED) { 3783 3784 smallArrayt* r; 3785 smallArrayt *self = allocG(rtSmallArrayt); 3786 smallArrayt *r2; 3787 baset *r3; 3788 3789 // add an element to check that the second element is poped 3790 // at the end 3791 r2 = self->f->pushInt(self, 1); 3792 ck_assert_ptr_ne(r2, null); 3793 // add second element 3794 createSmallArray(e); 3795 r2 = self->f->prependArray(self, &e); 3796 ck_assert_ptr_ne(r2, null); 3797 // pop 3798 r = self->f->dequeueArray(self); 3799 ck_assert_ptr_ne(r, null); 3800 char *s = toStringO(r); 3801 terminateO(r); 3802 ck_assert_str_eq(s, "[]"); 3803 free(s); 3804 ck_assert_int_eq(lenO(self), 1); 3805 s = toStringO(self); 3806 ck_assert_str_eq(s, "[1]"); 3807 free(s); 3808 // pop element of unexpected type 3809 r = self->f->dequeueArray(self); 3810 ck_assert(!r); 3811 ck_assert_int_eq(lenO(self), 1); 3812 s = toStringO(self); 3813 ck_assert_str_eq(s, "[1]"); 3814 free(s); 3815 // empty array 3816 r3 = self->f->pop(self); 3817 ck_assert_ptr_ne(r3, null); 3818 terminateO(r3); 3819 s = toStringO(self); 3820 ck_assert_str_eq(s, "[]"); 3821 free(s); 3822 r = self->f->dequeueArray(self); 3823 ck_assert(!r); 3824 s = toStringO(self); 3825 ck_assert_str_eq(s, "[]"); 3826 free(s); 3827 r2 = self->f->pushUndefined(self); 3828 ck_assert_ptr_ne(r2, null); 3829 delElemO(self,-1); 3830 r = self->f->dequeueArray(self); 3831 ck_assert_ptr_eq(r, null); 3832 terminateO(self); 3833 3834 } 3835 3836 3837 void dequeueSmallBoolSmallArrayT(CuTest *tc UNUSED) { 3838 3839 smallBoolt* r; 3840 smallArrayt *self = allocG(rtSmallArrayt); 3841 smallArrayt *r2; 3842 baset *r3; 3843 3844 // add an element to check that the second element is poped 3845 // at the end 3846 r2 = self->f->pushInt(self, 1); 3847 ck_assert_ptr_ne(r2, null); 3848 3849 // add second element 3850 createSmallBool(e); 3851 r2 = self->f->prependSmallBool(self, &e); 3852 ck_assert_ptr_ne(r2, null); 3853 // pop 3854 r = self->f->dequeueSmallBool(self); 3855 ck_assert_ptr_ne(r, null); 3856 char *s = toStringO(r); 3857 terminateO(r); 3858 ck_assert_str_eq(s, "false"); 3859 free(s); 3860 ck_assert_int_eq(lenO(self), 1); 3861 s = toStringO(self); 3862 ck_assert_str_eq(s, "[1]"); 3863 free(s); 3864 // pop element of unexpected type 3865 r = self->f->dequeueSmallBool(self); 3866 ck_assert(!r); 3867 ck_assert_int_eq(lenO(self), 1); 3868 s = toStringO(self); 3869 ck_assert_str_eq(s, "[1]"); 3870 free(s); 3871 // empty array 3872 r3 = self->f->pop(self); 3873 ck_assert_ptr_ne(r3, null); 3874 terminateO(r3); 3875 s = toStringO(self); 3876 ck_assert_str_eq(s, "[]"); 3877 free(s); 3878 r = self->f->dequeueSmallBool(self); 3879 ck_assert(!r); 3880 s = toStringO(self); 3881 ck_assert_str_eq(s, "[]"); 3882 free(s); 3883 r2 = self->f->pushUndefined(self); 3884 ck_assert_ptr_ne(r2, null); 3885 delElemO(self,-1); 3886 r = self->f->dequeueSmallBool(self); 3887 ck_assert_ptr_eq(r, null); 3888 terminateO(self); 3889 3890 } 3891 3892 3893 void dequeueSmallBytesSmallArrayT(CuTest *tc UNUSED) { 3894 3895 smallBytest* r; 3896 smallArrayt *self = allocG(rtSmallArrayt); 3897 smallArrayt *r2; 3898 baset *r3; 3899 3900 // add an element to check that the second element is poped 3901 // at the end 3902 r2 = self->f->pushInt(self, 1); 3903 ck_assert_ptr_ne(r2, null); 3904 // add second element 3905 createSmallBytes(e); 3906 r2 = self->f->prependSmallBytes(self, &e); 3907 ck_assert_ptr_ne(r2, null); 3908 // pop 3909 r = self->f->dequeueSmallBytes(self); 3910 ck_assert_ptr_ne(r, null); 3911 char *s = toStringO(r); 3912 terminateO(r); 3913 ck_assert_str_eq(s, "[]"); 3914 free(s); 3915 ck_assert_int_eq(lenO(self), 1); 3916 s = toStringO(self); 3917 ck_assert_str_eq(s, "[1]"); 3918 free(s); 3919 // pop element of unexpected type 3920 r = self->f->dequeueSmallBytes(self); 3921 ck_assert(!r); 3922 ck_assert_int_eq(lenO(self), 1); 3923 s = toStringO(self); 3924 ck_assert_str_eq(s, "[1]"); 3925 free(s); 3926 // empty array 3927 r3 = self->f->pop(self); 3928 ck_assert_ptr_ne(r3, null); 3929 terminateO(r3); 3930 s = toStringO(self); 3931 ck_assert_str_eq(s, "[]"); 3932 free(s); 3933 r = self->f->dequeueSmallBytes(self); 3934 ck_assert(!r); 3935 s = toStringO(self); 3936 ck_assert_str_eq(s, "[]"); 3937 free(s); 3938 r2 = self->f->pushUndefined(self); 3939 ck_assert_ptr_ne(r2, null); 3940 delElemO(self,-1); 3941 r = self->f->dequeueSmallBytes(self); 3942 ck_assert_ptr_eq(r, null); 3943 terminateO(self); 3944 3945 } 3946 3947 3948 void dequeueSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 3949 3950 smallDoublet* r; 3951 smallArrayt *self = allocG(rtSmallArrayt); 3952 smallArrayt *r2; 3953 baset *r3; 3954 3955 // add an element to check that the second element is poped 3956 // at the end 3957 r2 = self->f->pushInt(self, 1); 3958 ck_assert_ptr_ne(r2, null); 3959 // add second element 3960 createSmallDouble(e); 3961 r2 = self->f->prependSmallDouble(self, &e); 3962 ck_assert_ptr_ne(r2, null); 3963 // pop 3964 r = self->f->dequeueSmallDouble(self); 3965 ck_assert_ptr_ne(r, null); 3966 char *s = toStringO(r); 3967 terminateO(r); 3968 ck_assert_str_eq(s, "0.000000e+00"); 3969 free(s); 3970 ck_assert_int_eq(lenO(self), 1); 3971 s = toStringO(self); 3972 ck_assert_str_eq(s, "[1]"); 3973 free(s); 3974 // pop element of unexpected type 3975 r = self->f->dequeueSmallDouble(self); 3976 ck_assert(!r); 3977 ck_assert_int_eq(lenO(self), 1); 3978 s = toStringO(self); 3979 ck_assert_str_eq(s, "[1]"); 3980 free(s); 3981 // empty array 3982 r3 = self->f->pop(self); 3983 ck_assert_ptr_ne(r3, null); 3984 terminateO(r3); 3985 s = toStringO(self); 3986 ck_assert_str_eq(s, "[]"); 3987 free(s); 3988 r = self->f->dequeueSmallDouble(self); 3989 ck_assert(!r); 3990 s = toStringO(self); 3991 ck_assert_str_eq(s, "[]"); 3992 free(s); 3993 r2 = self->f->pushUndefined(self); 3994 ck_assert_ptr_ne(r2, null); 3995 delElemO(self,-1); 3996 r = self->f->dequeueSmallDouble(self); 3997 ck_assert_ptr_eq(r, null); 3998 terminateO(self); 3999 4000 } 4001 4002 4003 void dequeueSmallIntSmallArrayT(CuTest *tc UNUSED) { 4004 4005 smallIntt* r; 4006 smallArrayt *self = allocG(rtSmallArrayt); 4007 smallArrayt *r2; 4008 baset *r3; 4009 4010 // add an element to check that the second element is poped 4011 // at the end 4012 r2 = self->f->pushBool(self, TRUE); 4013 ck_assert_ptr_ne(r2, null); 4014 // add second element 4015 createSmallInt(e); 4016 r2 = self->f->prependSmallInt(self, &e); 4017 ck_assert_ptr_ne(r2, null); 4018 // pop 4019 r = self->f->dequeueSmallInt(self); 4020 ck_assert_ptr_ne(r, null); 4021 char *s = toStringO(r); 4022 terminateO(r); 4023 ck_assert_str_eq(s, "0"); 4024 free(s); 4025 ck_assert_int_eq(lenO(self), 1); 4026 s = toStringO(self); 4027 ck_assert_str_eq(s, "[true]"); 4028 free(s); 4029 // pop element of unexpected type 4030 r = self->f->dequeueSmallInt(self); 4031 ck_assert(!r); 4032 ck_assert_int_eq(lenO(self), 1); 4033 s = toStringO(self); 4034 ck_assert_str_eq(s, "[true]"); 4035 free(s); 4036 // empty array 4037 r3 = self->f->pop(self); 4038 ck_assert_ptr_ne(r3, null); 4039 terminateO(r3); 4040 s = toStringO(self); 4041 ck_assert_str_eq(s, "[]"); 4042 free(s); 4043 r = self->f->dequeueSmallInt(self); 4044 ck_assert(!r); 4045 s = toStringO(self); 4046 ck_assert_str_eq(s, "[]"); 4047 free(s); 4048 r2 = self->f->pushUndefined(self); 4049 ck_assert_ptr_ne(r2, null); 4050 delElemO(self,-1); 4051 r = self->f->dequeueSmallInt(self); 4052 ck_assert_ptr_eq(r, null); 4053 terminateO(self); 4054 4055 } 4056 4057 4058 void dequeueSmallJsonSmallArrayT(CuTest *tc UNUSED) { 4059 4060 smallJsont* r; 4061 smallArrayt *self = allocG(rtSmallArrayt); 4062 smallArrayt *r2; 4063 baset *r3; 4064 4065 // add an element to check that the second element is poped 4066 // at the end 4067 createSmallBytes(B); 4068 r2 = self->f->pushSmallBytes(self, &B); 4069 ck_assert_ptr_ne(r2, null); 4070 // add second element 4071 createSmallJson(e); 4072 r2 = self->f->prependSmallJson(self, &e); 4073 ck_assert_ptr_ne(r2, null); 4074 // pop 4075 r = self->f->dequeueSmallJson(self); 4076 ck_assert_ptr_ne(r, null); 4077 char *s = toStringO(r); 4078 terminateO(r); 4079 ck_assert_str_eq(s, "{}"); 4080 free(s); 4081 ck_assert_int_eq(lenO(self), 1); 4082 s = toStringO(self); 4083 ck_assert_str_eq(s, "[[]]"); 4084 free(s); 4085 // pop element of unexpected type 4086 r = self->f->dequeueSmallJson(self); 4087 ck_assert(!r); 4088 ck_assert_int_eq(lenO(self), 1); 4089 s = toStringO(self); 4090 ck_assert_str_eq(s, "[[]]"); 4091 free(s); 4092 // empty array 4093 r3 = self->f->pop(self); 4094 ck_assert_ptr_ne(r3, null); 4095 terminateO(r3); 4096 s = toStringO(self); 4097 ck_assert_str_eq(s, "[]"); 4098 free(s); 4099 r = self->f->dequeueSmallJson(self); 4100 ck_assert(!r); 4101 s = toStringO(self); 4102 ck_assert_str_eq(s, "[]"); 4103 free(s); 4104 r2 = self->f->pushUndefined(self); 4105 ck_assert_ptr_ne(r2, null); 4106 delElemO(self,-1); 4107 r = self->f->dequeueSmallJson(self); 4108 ck_assert_ptr_eq(r, null); 4109 terminateO(self); 4110 4111 } 4112 4113 4114 void dequeueSmallStringSmallArrayT(CuTest *tc UNUSED) { 4115 4116 smallStringt* r; 4117 smallArrayt *self = allocG(rtSmallArrayt); 4118 smallArrayt *r2; 4119 baset *r3; 4120 4121 // add an element to check that the second element is poped 4122 // at the end 4123 r2 = self->f->pushInt(self, 1); 4124 ck_assert_ptr_ne(r2, null); 4125 // add second element 4126 createSmallString(e); 4127 r2 = self->f->prependSmallString(self, &e); 4128 ck_assert_ptr_ne(r2, null); 4129 // pop 4130 r = self->f->dequeueSmallString(self); 4131 ck_assert_ptr_ne(r, null); 4132 char *s = toStringO(r); 4133 terminateO(r); 4134 ck_assert_str_eq(s, ""); 4135 free(s); 4136 ck_assert_int_eq(lenO(self), 1); 4137 s = toStringO(self); 4138 ck_assert_str_eq(s, "[1]"); 4139 free(s); 4140 // pop element of unexpected type 4141 r = self->f->dequeueSmallString(self); 4142 ck_assert(!r); 4143 ck_assert_int_eq(lenO(self), 1); 4144 s = toStringO(self); 4145 ck_assert_str_eq(s, "[1]"); 4146 free(s); 4147 // empty array 4148 r3 = self->f->pop(self); 4149 ck_assert_ptr_ne(r3, null); 4150 terminateO(r3); 4151 s = toStringO(self); 4152 ck_assert_str_eq(s, "[]"); 4153 free(s); 4154 r = self->f->dequeueSmallString(self); 4155 ck_assert(!r); 4156 s = toStringO(self); 4157 ck_assert_str_eq(s, "[]"); 4158 free(s); 4159 r2 = self->f->pushUndefined(self); 4160 ck_assert_ptr_ne(r2, null); 4161 delElemO(self,-1); 4162 r = self->f->dequeueSmallString(self); 4163 ck_assert_ptr_eq(r, null); 4164 terminateO(self); 4165 4166 } 4167 4168 4169 void dequeueVoidSmallArrayT(CuTest *tc UNUSED) { 4170 4171 void* r; 4172 smallArrayt *self = allocG(rtSmallArrayt); 4173 smallArrayt *r2; 4174 baset *r3; 4175 4176 // add an element to check that the second element is poped 4177 // at the end 4178 r2 = self->f->pushInt(self, 1); 4179 ck_assert_ptr_ne(r2, null); 4180 4181 // add second element 4182 createSmallContainer(e); 4183 setValO(&e, &r); 4184 r2 = self->f->prependSmallContainer(self, &e); 4185 ck_assert_ptr_ne(r2, null); 4186 4187 // pop 4188 r = self->f->dequeueVoid(self); 4189 ck_assert_ptr_eq(r, &r); 4190 ck_assert_int_eq(lenO(self), 1); 4191 char *s = toStringO(self); 4192 ck_assert_str_eq(s, "[1]"); 4193 free(s); 4194 4195 // pop element of unexpected type 4196 r = self->f->dequeueVoid(self); 4197 ck_assert(!r); 4198 ck_assert_int_eq(lenO(self), 1); 4199 s = toStringO(self); 4200 ck_assert_str_eq(s, "[1]"); 4201 free(s); 4202 4203 // empty array 4204 r3 = self->f->pop(self); 4205 ck_assert_ptr_ne(r3, null); 4206 terminateO(r3); 4207 s = toStringO(self); 4208 ck_assert_str_eq(s, "[]"); 4209 free(s); 4210 r = self->f->dequeueVoid(self); 4211 ck_assert(!r); 4212 s = toStringO(self); 4213 ck_assert_str_eq(s, "[]"); 4214 free(s); 4215 terminateO(self); 4216 4217 } 4218 4219 4220 void dequeueSmallContainerSmallArrayT(CuTest *tc UNUSED) { 4221 4222 smallContainert* r; 4223 smallArrayt *self = allocG(rtSmallArrayt); 4224 smallArrayt *r2; 4225 baset *r3; 4226 4227 // add an element to check that the second element is poped 4228 // at the end 4229 r2 = self->f->pushInt(self, 1); 4230 ck_assert_ptr_ne(r2, null); 4231 // add second element 4232 createSmallContainer(e); 4233 r2 = self->f->prependSmallContainer(self, &e); 4234 ck_assert_ptr_ne(r2, null); 4235 // pop 4236 r = self->f->dequeueSmallContainer(self); 4237 ck_assert_ptr_ne(r, null); 4238 char *s = toStringO(r); 4239 terminateO(r); 4240 ck_assert_str_eq(s, "<data smallContainer>"); 4241 free(s); 4242 ck_assert_int_eq(lenO(self), 1); 4243 s = toStringO(self); 4244 ck_assert_str_eq(s, "[1]"); 4245 free(s); 4246 // container with baset object 4247 // push a base object of unknown type 4248 smallIntt *o = allocSmallInt(2); 4249 o->type = "newType"; 4250 r2 = self->f->prependNFree(self, (baset*)o); 4251 ck_assert_ptr_ne(r2, null); 4252 r = self->f->dequeueSmallContainer(self); 4253 ck_assert_ptr_eq(r, NULL); 4254 ck_assert_int_eq(lenO(self), 2); 4255 s = toStringO(self); 4256 ck_assert_str_eq(s, "[\"<data container>\",1]"); 4257 free(s); 4258 r3 = self->f->dequeue(self); 4259 ck_assert_ptr_ne(r3, null); 4260 terminateO(r3); 4261 // pop element of unexpected type 4262 r = self->f->dequeueSmallContainer(self); 4263 ck_assert_ptr_eq(r, NULL); 4264 ck_assert_int_eq(lenO(self), 1); 4265 s = toStringO(self); 4266 ck_assert_str_eq(s, "[1]"); 4267 free(s); 4268 // empty array 4269 r3 = self->f->pop(self); 4270 ck_assert_ptr_ne(r3, null); 4271 terminateO(r3); 4272 s = toStringO(self); 4273 ck_assert_str_eq(s, "[]"); 4274 free(s); 4275 r = self->f->dequeueSmallContainer(self); 4276 ck_assert(!r); 4277 s = toStringO(self); 4278 ck_assert_str_eq(s, "[]"); 4279 free(s); 4280 r2 = self->f->pushUndefined(self); 4281 ck_assert_ptr_ne(r2, null); 4282 delElemO(self,-1); 4283 r = self->f->dequeueSmallContainer(self); 4284 ck_assert_ptr_eq(r, null); 4285 terminateO(self); 4286 4287 } 4288 4289 4290 void dequeueNumSmallArrayT(CuTest *tc UNUSED) { 4291 4292 double r; 4293 smallArrayt *self = allocG(rtSmallArrayt); 4294 smallArrayt *r2; 4295 baset *r3; 4296 4297 // add an element to check that the second element is poped 4298 // at the end 4299 r2 = self->f->pushBool(self, TRUE); 4300 ck_assert_ptr_ne(r2, null); 4301 // add second element 4302 r2 = self->f->prependInt(self, 2); 4303 ck_assert_ptr_ne(r2, null); 4304 r2 = self->f->prependDouble(self, 2.5); 4305 ck_assert_ptr_ne(r2, null); 4306 // pop 4307 r = self->f->dequeueNum(self); 4308 ck_assert(r==2.5); 4309 ck_assert_int_eq(lenO(self), 2); 4310 char *s = toStringO(self); 4311 ck_assert_str_eq(s, "[2,true]"); 4312 free(s); 4313 r = self->f->dequeueNum(self); 4314 ck_assert_int_eq(r, 2); 4315 ck_assert_int_eq(lenO(self), 1); 4316 s = toStringO(self); 4317 ck_assert_str_eq(s, "[true]"); 4318 free(s); 4319 // pop element of unexpected type 4320 r = self->f->dequeueNum(self); 4321 ck_assert(!r); 4322 ck_assert_int_eq(lenO(self), 1); 4323 s = toStringO(self); 4324 ck_assert_str_eq(s, "[true]"); 4325 free(s); 4326 // empty array 4327 r3 = self->f->pop(self); 4328 ck_assert_ptr_ne(r3, null); 4329 terminateO(r3); 4330 s = toStringO(self); 4331 ck_assert_str_eq(s, "[]"); 4332 free(s); 4333 r = self->f->dequeueNum(self); 4334 ck_assert(!r); 4335 s = toStringO(self); 4336 ck_assert_str_eq(s, "[]"); 4337 free(s); 4338 r2 = self->f->pushUndefined(self); 4339 ck_assert_ptr_ne(r2, null); 4340 delElemO(self,-1); 4341 r = self->f->dequeueNum(self); 4342 ck_assert(!r); 4343 terminateO(self); 4344 4345 } 4346 4347 4348 void reverseSmallArrayT(CuTest *tc UNUSED) { 4349 4350 smallArrayt* r; 4351 smallArrayt *self = allocG(rtSmallArrayt); 4352 4353 // empty array 4354 r = reverseO(self); 4355 ck_assert_ptr_ne(r, NULL); 4356 char *s = toStringO(r); 4357 ck_assert_str_eq(s, "[]"); 4358 free(s); 4359 // 1 element array 4360 self->f->pushInt(self,1); 4361 r = reverseO(self); 4362 ck_assert_ptr_ne(r, NULL); 4363 s = toStringO(r); 4364 ck_assert_str_eq(s, "[1]"); 4365 free(s); 4366 // 2 elements array 4367 self->f->pushInt(self,2); 4368 r = reverseO(self); 4369 ck_assert_ptr_ne(r, NULL); 4370 s = toStringO(r); 4371 ck_assert_str_eq(s, "[2,1]"); 4372 free(s); 4373 terminateO(self); 4374 4375 } 4376 4377 4378 void catSmallArrayT(CuTest *tc UNUSED) { 4379 4380 smallArrayt* r; 4381 smallArrayt *self = allocG(rtSmallArrayt); 4382 4383 // cat arrays 4384 self->f->pushInt(self,1); 4385 createAllocateSmallArray(a); 4386 createAllocateSmallArray(a2); 4387 a2->f->pushInt(a2,2); 4388 r = catO(self, a, a2); 4389 char *s = toStringO(r); 4390 ck_assert_str_eq(s, "[1,2]"); 4391 free(s); 4392 smashManyO(a,a2); 4393 emptyO(self); 4394 4395 // null parameter 4396 r = catO(self, null); 4397 s = toStringO(r); 4398 ck_assert_str_eq(s, "[]"); 4399 free(s); 4400 terminateO(self); 4401 4402 } 4403 4404 4405 void appendSmallJsonSmallArrayT(CuTest *tc UNUSED) { 4406 4407 smallArrayt* r; 4408 smallArrayt *self = allocG(rtSmallArrayt); 4409 createAllocateSmallJson(json); 4410 4411 // add an element to check that the second array is appended 4412 // at the end 4413 r = self->f->pushInt(self, 1); 4414 ck_assert_ptr_ne(r, null); 4415 4416 // append json array 4417 json->f->pushInt(json, 2); 4418 r = self->f->appendSmallJson(self, json); 4419 smashO(json); 4420 ck_assert_ptr_ne(r, null); 4421 char *s = toStringO(r); 4422 ck_assert_str_eq(s, "[1,2]"); 4423 free(s); 4424 // length 0 4425 json = allocSmallJson(); 4426 json->f->pushInt(json, 2); 4427 baset *o = json->f->pop(json); 4428 terminateO(o); 4429 r = self->f->appendSmallJson(self, json); 4430 smashO(json); 4431 ck_assert_ptr_ne(r, null); 4432 s = toStringO(r); 4433 ck_assert_str_eq(s, "[1,2]"); 4434 free(s); 4435 // same sArray in both self and json 4436 json = allocSmallJson(); 4437 setsoO(json, (smallt*) getsoO(self)); 4438 r = self->f->appendSmallJson(self, json); 4439 ck_assert_ptr_eq(r, null); 4440 finishO(json); 4441 s = toStringO(self); 4442 ck_assert_str_eq(s, "[1,2]"); 4443 free(s); 4444 // json of type not array 4445 json = allocSmallJson(); 4446 setTopIntO(json, 1); 4447 r = self->f->appendSmallJson(self, json); 4448 ck_assert_ptr_eq(r, null); 4449 terminateO(json); 4450 s = toStringO(self); 4451 ck_assert_str_eq(s, "[1,2]"); 4452 free(s); 4453 // non smallJson object 4454 json = (smallJsont*) allocSmallInt(2); 4455 r = self->f->appendSmallJson(self, json); 4456 ck_assert_ptr_eq(r, null); 4457 terminateO(json); 4458 // null 4459 r = self->f->appendSmallJson(self, null); 4460 ck_assert_ptr_eq(r, null); 4461 s = toStringO(self); 4462 ck_assert_str_eq(s, "[1,2]"); 4463 free(s); 4464 terminateO(self); 4465 4466 } 4467 4468 4469 void appendNSmashSmallArrayT(CuTest *tc UNUSED) { 4470 4471 smallArrayt* r; 4472 smallArrayt *self = allocG(rtSmallArrayt); 4473 createAllocateSmallArray(a); 4474 4475 // add an element to check that the second array is appended 4476 // at the end 4477 r = self->f->pushInt(self, 1); 4478 ck_assert_ptr_ne(r, null); 4479 4480 // append array 4481 a->f->pushInt(a, 2); 4482 r = self->f->appendNSmash(self, a); 4483 ck_assert_ptr_ne(r, null); 4484 char *s = toStringO(r); 4485 ck_assert_str_eq(s, "[1,2]"); 4486 free(s); 4487 // length 0 4488 a = allocSmallArray(); 4489 a->f->pushInt(a, 2); 4490 delElemO(a,0); 4491 r = self->f->appendNSmash(self, a); 4492 ck_assert_ptr_ne(r, null); 4493 s = toStringO(r); 4494 ck_assert_str_eq(s, "[1,2]"); 4495 free(s); 4496 // same sArray in both self and a 4497 a = allocSmallArray(); 4498 setsoO(a, getsoO(self)); 4499 r = self->f->appendNSmash(self, a); 4500 ck_assert_ptr_eq(r, null); 4501 finishO(a); 4502 s = toStringO(self); 4503 ck_assert_str_eq(s, "[1,2]"); 4504 free(s); 4505 // null 4506 r = self->f->appendNSmash(self, null); 4507 ck_assert_ptr_eq(r, null); 4508 s = toStringO(self); 4509 ck_assert_str_eq(s, "[1,2]"); 4510 free(s); 4511 terminateO(self); 4512 4513 } 4514 4515 4516 void appendNSmashSmallJsonSmallArrayT(CuTest *tc UNUSED) { 4517 4518 smallArrayt* r; 4519 smallArrayt *self = allocG(rtSmallArrayt); 4520 createAllocateSmallJson(json); 4521 4522 // add an element to check that the second array is appended 4523 // at the end 4524 r = self->f->pushInt(self, 1); 4525 ck_assert_ptr_ne(r, null); 4526 4527 // append json array 4528 json->f->pushInt(json, 2); 4529 r = self->f->appendNSmashSmallJson(self, json); 4530 ck_assert_ptr_ne(r, null); 4531 char *s = toStringO(r); 4532 ck_assert_str_eq(s, "[1,2]"); 4533 free(s); 4534 // null 4535 r = self->f->appendNSmashSmallJson(self, null); 4536 ck_assert_ptr_eq(r, null); 4537 s = toStringO(self); 4538 ck_assert_str_eq(s, "[1,2]"); 4539 free(s); 4540 terminateO(self); 4541 4542 } 4543 4544 4545 void appendArraySmallArrayT(CuTest *tc UNUSED) { 4546 4547 smallArrayt* r; 4548 smallArrayt *self = allocG(rtSmallArrayt); 4549 char **array; 4550 4551 // add an element to check that the second array is appended 4552 // at the end 4553 r = self->f->pushInt(self, 1); 4554 ck_assert_ptr_ne(r, null); 4555 4556 // append array 4557 array = null; 4558 listPushS(&array, "2"); 4559 r = self->f->appendArray(self, array); 4560 listFreeS(array); 4561 ck_assert_ptr_ne(r, null); 4562 char *s = toStringO(r); 4563 ck_assert_str_eq(s, "[1,\"2\"]"); 4564 free(s); 4565 // length 0 4566 listEmptyS(array); 4567 r = self->f->appendArray(self, array); 4568 free(array); 4569 ck_assert_ptr_ne(r, null); 4570 s = toStringO(r); 4571 ck_assert_str_eq(s, "[1,\"2\"]"); 4572 free(s); 4573 // null 4574 r = self->f->appendArray(self, null); 4575 ck_assert_ptr_eq(r, null); 4576 s = toStringO(self); 4577 ck_assert_str_eq(s, "[1,\"2\"]"); 4578 free(s); 4579 terminateO(self); 4580 4581 } 4582 4583 4584 void appendNSmashArraySmallArrayT(CuTest *tc UNUSED) { 4585 4586 smallArrayt* r; 4587 smallArrayt *self = allocG(rtSmallArrayt); 4588 char **array; 4589 4590 // add an element to check that the second array is appended 4591 // at the end 4592 r = self->f->pushInt(self, 1); 4593 ck_assert_ptr_ne(r, null); 4594 4595 // append array 4596 array = null; 4597 listPushS(&array, "2"); 4598 r = self->f->appendNSmashArray(self, array); 4599 ck_assert_ptr_ne(r, null); 4600 char *s = toStringO(r); 4601 ck_assert_str_eq(s, "[1,\"2\"]"); 4602 free(s); 4603 // length 0 4604 listEmptyS(array); 4605 r = self->f->appendNSmashArray(self, array); 4606 ck_assert_ptr_ne(r, null); 4607 s = toStringO(r); 4608 ck_assert_str_eq(s, "[1,\"2\"]"); 4609 free(s); 4610 // null 4611 r = self->f->appendNSmashArray(self, null); 4612 ck_assert_ptr_eq(r, null); 4613 s = toStringO(self); 4614 ck_assert_str_eq(s, "[1,\"2\"]"); 4615 free(s); 4616 terminateO(self); 4617 4618 } 4619 4620 4621 void shiftSmallArrayT(CuTest *tc UNUSED) { 4622 4623 smallArrayt* r; 4624 smallArrayt *self = allocG(rtSmallArrayt); 4625 createAllocateSmallArray(a); 4626 4627 // add an element to check that the second array is appended 4628 // at the end 4629 r = self->f->pushInt(self, 1); 4630 ck_assert_ptr_ne(r, null); 4631 4632 // append array 4633 a->f->pushInt(a, 2); 4634 r = self->f->shift(self, a); 4635 smashO(a); 4636 ck_assert_ptr_ne(r, null); 4637 char *s = toStringO(r); 4638 ck_assert_str_eq(s, "[2,1]"); 4639 free(s); 4640 // length 0 4641 a = allocSmallArray(); 4642 a->f->pushInt(a, 2); 4643 delElemO(a,0); 4644 r = self->f->shift(self, a); 4645 smashO(a); 4646 ck_assert_ptr_ne(r, null); 4647 s = toStringO(r); 4648 ck_assert_str_eq(s, "[2,1]"); 4649 free(s); 4650 // same sArray in both self and a 4651 a = allocSmallArray(); 4652 setsoO(a, getsoO(self)); 4653 r = self->f->shift(self, a); 4654 ck_assert_ptr_eq(r, null); 4655 finishO(a); 4656 s = toStringO(self); 4657 ck_assert_str_eq(s, "[2,1]"); 4658 free(s); 4659 // null 4660 r = self->f->shift(self, null); 4661 ck_assert_ptr_eq(r, null); 4662 s = toStringO(self); 4663 ck_assert_str_eq(s, "[2,1]"); 4664 free(s); 4665 terminateO(self); 4666 4667 } 4668 4669 4670 void shiftSmallJsonSmallArrayT(CuTest *tc UNUSED) { 4671 4672 smallArrayt* r; 4673 smallArrayt *self = allocG(rtSmallArrayt); 4674 createAllocateSmallJson(json); 4675 4676 // add an element to check that the second array is shifted 4677 // at the end 4678 r = self->f->pushInt(self, 1); 4679 ck_assert_ptr_ne(r, null); 4680 4681 // shift json array 4682 json->f->pushInt(json, 2); 4683 r = self->f->shiftSmallJson(self, json); 4684 smashO(json); 4685 ck_assert_ptr_ne(r, null); 4686 char *s = toStringO(r); 4687 ck_assert_str_eq(s, "[2,1]"); 4688 free(s); 4689 // length 0 4690 json = allocSmallJson(); 4691 json->f->pushInt(json, 2); 4692 baset *o = json->f->pop(json); 4693 terminateO(o); 4694 r = self->f->shiftSmallJson(self, json); 4695 smashO(json); 4696 ck_assert_ptr_ne(r, null); 4697 s = toStringO(r); 4698 ck_assert_str_eq(s, "[2,1]"); 4699 free(s); 4700 // same sArray in both self and json 4701 json = allocSmallJson(); 4702 setsoO(json, (smallt*) getsoO(self)); 4703 r = self->f->shiftSmallJson(self, json); 4704 ck_assert_ptr_eq(r, null); 4705 finishO(json); 4706 s = toStringO(self); 4707 ck_assert_str_eq(s, "[2,1]"); 4708 free(s); 4709 // json of type not array 4710 json = allocSmallJson(); 4711 setTopIntO(json, 1); 4712 r = self->f->shiftSmallJson(self, json); 4713 ck_assert_ptr_eq(r, null); 4714 terminateO(json); 4715 s = toStringO(self); 4716 ck_assert_str_eq(s, "[2,1]"); 4717 free(s); 4718 // null 4719 r = self->f->shiftSmallJson(self, null); 4720 ck_assert_ptr_eq(r, null); 4721 s = toStringO(self); 4722 ck_assert_str_eq(s, "[2,1]"); 4723 free(s); 4724 terminateO(self); 4725 4726 } 4727 4728 4729 void shiftNSmashSmallArrayT(CuTest *tc UNUSED) { 4730 4731 smallArrayt* r; 4732 smallArrayt *self = allocG(rtSmallArrayt); 4733 createAllocateSmallArray(a); 4734 4735 // add an element to check that the second array is appended 4736 // at the end 4737 r = self->f->pushInt(self, 1); 4738 ck_assert_ptr_ne(r, null); 4739 4740 // append array 4741 a->f->pushInt(a, 2); 4742 r = self->f->shiftNSmash(self, a); 4743 ck_assert_ptr_ne(r, null); 4744 char *s = toStringO(r); 4745 ck_assert_str_eq(s, "[2,1]"); 4746 free(s); 4747 // length 0 4748 a = allocSmallArray(); 4749 a->f->pushInt(a, 2); 4750 delElemO(a,0); 4751 r = self->f->shiftNSmash(self, a); 4752 ck_assert_ptr_ne(r, null); 4753 s = toStringO(r); 4754 ck_assert_str_eq(s, "[2,1]"); 4755 free(s); 4756 // same sArray in both self and a 4757 a = allocSmallArray(); 4758 setsoO(a, getsoO(self)); 4759 r = self->f->shiftNSmash(self, a); 4760 ck_assert_ptr_eq(r, null); 4761 finishO(a); 4762 s = toStringO(self); 4763 ck_assert_str_eq(s, "[2,1]"); 4764 free(s); 4765 // null 4766 r = self->f->shiftNSmash(self, null); 4767 ck_assert_ptr_eq(r, null); 4768 s = toStringO(self); 4769 ck_assert_str_eq(s, "[2,1]"); 4770 free(s); 4771 terminateO(self); 4772 4773 } 4774 4775 4776 void shiftNSmashSmallJsonSmallArrayT(CuTest *tc UNUSED) { 4777 4778 smallArrayt* r; 4779 smallArrayt *self = allocG(rtSmallArrayt); 4780 createAllocateSmallJson(json); 4781 4782 // add an element to check that the second array is shifted 4783 // at the end 4784 r = self->f->pushInt(self, 1); 4785 ck_assert_ptr_ne(r, null); 4786 4787 // shift json array 4788 json->f->pushInt(json, 2); 4789 r = self->f->shiftNSmashSmallJson(self, json); 4790 ck_assert_ptr_ne(r, null); 4791 char *s = toStringO(r); 4792 ck_assert_str_eq(s, "[2,1]"); 4793 free(s); 4794 // length 0 4795 json = allocSmallJson(); 4796 json->f->pushInt(json, 2); 4797 baset *o = json->f->pop(json); 4798 terminateO(o); 4799 r = self->f->shiftNSmashSmallJson(self, json); 4800 ck_assert_ptr_ne(r, null); 4801 s = toStringO(r); 4802 ck_assert_str_eq(s, "[2,1]"); 4803 free(s); 4804 // same sArray in both self and json 4805 json = allocSmallJson(); 4806 setsoO(json, (smallt*) getsoO(self)); 4807 r = self->f->shiftNSmashSmallJson(self, json); 4808 ck_assert_ptr_eq(r, null); 4809 finishO(json); 4810 s = toStringO(self); 4811 ck_assert_str_eq(s, "[2,1]"); 4812 free(s); 4813 // json of type not array 4814 json = allocSmallJson(); 4815 setTopIntO(json, 1); 4816 r = self->f->shiftNSmashSmallJson(self, json); 4817 ck_assert_ptr_eq(r, null); 4818 terminateO(json); 4819 s = toStringO(self); 4820 ck_assert_str_eq(s, "[2,1]"); 4821 free(s); 4822 // null 4823 r = self->f->shiftNSmashSmallJson(self, null); 4824 ck_assert_ptr_eq(r, null); 4825 s = toStringO(self); 4826 ck_assert_str_eq(s, "[2,1]"); 4827 free(s); 4828 terminateO(self); 4829 4830 } 4831 4832 4833 void addSmallArrayT(CuTest *tc UNUSED) { 4834 4835 smallArrayt* r; 4836 smallArrayt *self = allocG(rtSmallArrayt); 4837 createAllocateSmallArray(a); 4838 4839 // add an element to check that the second array is added 4840 // at the end 4841 r = self->f->pushInt(self, 1); 4842 ck_assert_ptr_ne(r, null); 4843 4844 // add array 4845 a->f->pushInt(a, 2); 4846 r = addO(self, a); 4847 smashO(a); 4848 ck_assert_ptr_ne(r, null); 4849 char *s = toStringO(r); 4850 terminateO(r); 4851 ck_assert_str_eq(s, "[1,2]"); 4852 free(s); 4853 // length 0 4854 a = allocSmallArray(); 4855 a->f->pushInt(a, 2); 4856 delElemO(a,0); 4857 r = addO(self, a); 4858 smashO(a); 4859 ck_assert_ptr_ne(r, null); 4860 s = toStringO(r); 4861 terminateO(r); 4862 ck_assert_str_eq(s, "[1]"); 4863 free(s); 4864 // same sArray in both self and a 4865 a = allocSmallArray(); 4866 setsoO(a, getsoO(self)); 4867 r = addO(self, a); 4868 ck_assert_ptr_eq(r, null); 4869 finishO(a); 4870 s = toStringO(self); 4871 ck_assert_str_eq(s, "[1]"); 4872 free(s); 4873 // null 4874 r = addO(self, null); 4875 ck_assert_ptr_eq(r, null); 4876 s = toStringO(self); 4877 ck_assert_str_eq(s, "[1]"); 4878 free(s); 4879 terminateO(self); 4880 4881 } 4882 4883 4884 void cropSmallArrayT(CuTest *tc UNUSED) { 4885 4886 smallArrayt* r; 4887 smallArrayt *self = allocG(rtSmallArrayt); 4888 4889 // add elements to self 4890 r = self->f->pushInt(self, 1); 4891 ck_assert_ptr_ne(r, null); 4892 r = self->f->pushInt(self, 2); 4893 ck_assert_ptr_ne(r, null); 4894 r = self->f->pushInt(self, 3); 4895 ck_assert_ptr_ne(r, null); 4896 r = self->f->pushInt(self, 4); 4897 ck_assert_ptr_ne(r, null); 4898 4899 // negative index 4900 r = cropO(self, 1, -1); 4901 ck_assert_ptr_ne(r, null); 4902 ck_assert_int_eq(lenO(r), 2); 4903 char *s = toStringO(r); 4904 terminateO(r); 4905 ck_assert_str_eq(s, "[2,3]"); 4906 free(s); 4907 s = toStringO(self); 4908 ck_assert_str_eq(s, "[1,4]"); 4909 free(s); 4910 // start outside 4911 ck_assert_ptr_eq(cropO(self, 20, -4), NULL); 4912 // end outside 4913 r = cropO(self, 0, 40); 4914 ck_assert_ptr_ne(r, null); 4915 ck_assert_int_eq(lenO(r), 2); 4916 s = toStringO(r); 4917 terminateO(r); 4918 ck_assert_str_eq(s, "[1,4]"); 4919 free(s); 4920 s = toStringO(self); 4921 ck_assert_str_eq(s, "[]"); 4922 free(s); 4923 // end negative and outside 4924 // add elements to self 4925 r = self->f->pushInt(self, 1); 4926 ck_assert_ptr_ne(r, null); 4927 r = self->f->pushInt(self, 2); 4928 ck_assert_ptr_ne(r, null); 4929 r = self->f->pushInt(self, 3); 4930 ck_assert_ptr_ne(r, null); 4931 r = self->f->pushInt(self, 4); 4932 ck_assert_ptr_ne(r, null); 4933 ck_assert_ptr_eq(cropO(self, 2, -40), NULL); 4934 s = toStringO(self); 4935 ck_assert_str_eq(s, "[1,2,3,4]"); 4936 free(s); 4937 // end before start 4938 ck_assert_ptr_eq(cropO(self, 3, 2), NULL); 4939 s = toStringO(self); 4940 ck_assert_str_eq(s, "[1,2,3,4]"); 4941 free(s); 4942 // negative start last element 4943 r = cropO(self, -1, 0); 4944 ck_assert_ptr_ne(r, null); 4945 ck_assert_int_eq(lenO(r), 1); 4946 s = toStringO(r); 4947 terminateO(r); 4948 ck_assert_str_eq(s, "[4]"); 4949 free(s); 4950 s = toStringO(self); 4951 ck_assert_str_eq(s, "[1,2,3]"); 4952 free(s); 4953 // negative start and outside 4954 r = cropO(self, -10, 1); 4955 ck_assert_ptr_ne(r, null); 4956 ck_assert_int_eq(lenO(r), 1); 4957 s = toStringO(r); 4958 terminateO(r); 4959 ck_assert_str_eq(s, "[1]"); 4960 free(s); 4961 s = toStringO(self); 4962 ck_assert_str_eq(s, "[2,3]"); 4963 free(s); 4964 // start = end 4965 r = cropO(self, 1, 1); 4966 ck_assert_ptr_ne(r, null); 4967 ck_assert_int_eq(lenO(r), 0); 4968 terminateO(r); 4969 s = toStringO(self); 4970 ck_assert_str_eq(s, "[2,3]"); 4971 free(s); 4972 // empty list 4973 emptyO(self); 4974 ck_assert_ptr_eq(cropO(self, 0, 0), NULL); 4975 ck_assert_ptr_eq(cropO(self, -1, 0), NULL); 4976 terminateO(self); 4977 4978 } 4979 4980 4981 void cropElemSmallArrayT(CuTest *tc UNUSED) { 4982 4983 baset* r; 4984 smallArrayt *self = allocG(rtSmallArrayt); 4985 smallArrayt *r2; 4986 4987 // add elements to self 4988 r2 = self->f->pushInt(self, 1); 4989 ck_assert_ptr_ne(r2, null); 4990 r2 = self->f->pushInt(self, 2); 4991 ck_assert_ptr_ne(r2, null); 4992 r2 = self->f->pushInt(self, 3); 4993 ck_assert_ptr_ne(r2, null); 4994 r2 = self->f->pushInt(self, 4); 4995 ck_assert_ptr_ne(r2, null); 4996 4997 // positive index 4998 r = cropElemO(self,1); 4999 ck_assert_ptr_ne(r, null); 5000 char *s = toStringO(r); 5001 terminateO(r); 5002 ck_assert_str_eq(s, "2"); 5003 free(s); 5004 s = toStringO(self); 5005 ck_assert_str_eq(s, "[1,3,4]"); 5006 free(s); 5007 // negative index 5008 r = cropElemO(self,-1); 5009 ck_assert_ptr_ne(r, null); 5010 s = toStringO(r); 5011 terminateO(r); 5012 ck_assert_str_eq(s, "4"); 5013 free(s); 5014 s = toStringO(self); 5015 ck_assert_str_eq(s, "[1,3]"); 5016 free(s); 5017 // undefined object 5018 r2 = self->f->pushUndefined(self); 5019 ck_assert_ptr_ne(r2, null); 5020 r = cropElemO(self,2); 5021 ck_assert_ptr_ne(r, null); 5022 s = toStringO(r); 5023 terminateO(r); 5024 ck_assert_str_eq(s, "null"); 5025 free(s); 5026 s = toStringO(self); 5027 ck_assert_str_eq(s, "[1,3]"); 5028 free(s); 5029 // container 5030 createSmallContainer(c); 5031 r2 = self->f->pushSmallContainer(self, &c); 5032 r = cropElemO(self,2); 5033 ck_assert_ptr_ne(r, null); 5034 s = toStringO(r); 5035 terminateO(r); 5036 ck_assert_str_eq(s, "<data smallContainer>"); 5037 free(s); 5038 s = toStringO(self); 5039 ck_assert_str_eq(s, "[1,3]"); 5040 free(s); 5041 // base object in container 5042 createAllocateSmallInt(I); 5043 setValG(I, 11); 5044 I->type = "anothertype"; 5045 r2 = self->f->push(self, (baset*)I); 5046 r = cropElemO(self,2); 5047 ck_assert_ptr_ne(r, null); 5048 ck_assert_str_eq(r->type, "anothertype"); 5049 s = toStringO(r); 5050 terminateO(r); 5051 ck_assert_str_eq(s, "11"); 5052 free(s); 5053 s = toStringO(self); 5054 ck_assert_str_eq(s, "[1,3]"); 5055 free(s); 5056 // index outside 5057 ck_assert_ptr_eq(cropElemO(self, 20), NULL); 5058 ck_assert_ptr_eq(cropElemO(self, -4), NULL); 5059 // empty list 5060 emptyO(self); 5061 ck_assert_ptr_eq(cropElemO(self, 0), NULL); 5062 ck_assert_ptr_eq(cropElemO(self, -1), NULL); 5063 // crop empty slot in array 5064 r2 = self->f->pushUndefined(self); 5065 ck_assert_ptr_ne(r2, null); 5066 delElemO(self,0); 5067 ck_assert_ptr_eq(cropElemO(self, 0), NULL); 5068 terminateO(self); 5069 5070 } 5071 5072 5073 void cropElemUndefinedSmallArrayT(CuTest *tc UNUSED) { 5074 5075 undefinedt* r; 5076 smallArrayt *self = allocG(rtSmallArrayt); 5077 smallArrayt *r2; 5078 5079 // add elements to self 5080 r2 = self->f->pushInt(self, 1); 5081 ck_assert_ptr_ne(r2, null); 5082 r2 = self->f->pushUndefined(self); 5083 ck_assert_ptr_ne(r2, null); 5084 r2 = self->f->pushInt(self, 3); 5085 ck_assert_ptr_ne(r2, null); 5086 r2 = self->f->pushUndefined(self); 5087 ck_assert_ptr_ne(r2, null); 5088 5089 // positive index 5090 r = cropElemUndefinedO(self,1); 5091 ck_assert_ptr_ne(r, null); 5092 char *s = toStringO(r); 5093 terminateO(r); 5094 ck_assert_str_eq(s, "null"); 5095 free(s); 5096 s = toStringO(self); 5097 ck_assert_str_eq(s, "[1,3,null]"); 5098 free(s); 5099 // negative index 5100 r = cropElemUndefinedO(self,-1); 5101 ck_assert_ptr_ne(r, null); 5102 s = toStringO(r); 5103 terminateO(r); 5104 ck_assert_str_eq(s, "null"); 5105 free(s); 5106 s = toStringO(self); 5107 ck_assert_str_eq(s, "[1,3]"); 5108 free(s); 5109 // wrong object type 5110 createSmallInt(I); 5111 setValG(&I, 11); 5112 r2 = self->f->pushSmallInt(self, &I); 5113 ck_assert_ptr_ne(r2, null); 5114 r = cropElemUndefinedO(self,2); 5115 ck_assert_ptr_eq(r, null); 5116 s = toStringO(self); 5117 ck_assert_str_eq(s, "[1,3,11]"); 5118 free(s); 5119 // index outside 5120 ck_assert_ptr_eq(cropElemUndefinedO(self, 20), NULL); 5121 ck_assert_ptr_eq(cropElemUndefinedO(self, -4), NULL); 5122 // empty list 5123 emptyO(self); 5124 ck_assert_ptr_eq(cropElemUndefinedO(self, 0), NULL); 5125 ck_assert_ptr_eq(cropElemUndefinedO(self, -1), NULL); 5126 // crop empty slot in array 5127 r2 = self->f->pushUndefined(self); 5128 ck_assert_ptr_ne(r2, null); 5129 delElemO(self,0); 5130 ck_assert_ptr_eq(cropElemUndefinedO(self, 0), NULL); 5131 terminateO(self); 5132 5133 } 5134 5135 5136 void cropElemBoolSmallArrayT(CuTest *tc UNUSED) { 5137 5138 bool r; 5139 smallArrayt *self = allocG(rtSmallArrayt); 5140 smallArrayt *r2; 5141 5142 // add elements to self 5143 r2 = self->f->pushInt(self, 1); 5144 ck_assert_ptr_ne(r2, null); 5145 r2 = self->f->pushBool(self, TRUE); 5146 ck_assert_ptr_ne(r2, null); 5147 r2 = self->f->pushInt(self, 3); 5148 ck_assert_ptr_ne(r2, null); 5149 r2 = self->f->pushBool(self, TRUE); 5150 ck_assert_ptr_ne(r2, null); 5151 5152 // positive index 5153 r = cropElemBoolO(self,1); 5154 ck_assert(r); 5155 char *s = toStringO(self); 5156 ck_assert_str_eq(s, "[1,3,true]"); 5157 free(s); 5158 // negative index 5159 r = cropElemBoolO(self,-1); 5160 ck_assert(r); 5161 s = toStringO(self); 5162 ck_assert_str_eq(s, "[1,3]"); 5163 free(s); 5164 // wrong object type 5165 createSmallInt(I); 5166 setValG(&I, 11); 5167 r2 = self->f->pushSmallInt(self, &I); 5168 r = cropElemBoolO(self,2); 5169 ck_assert(!r); 5170 s = toStringO(self); 5171 ck_assert_str_eq(s, "[1,3,11]"); 5172 free(s); 5173 // wrong object type of another user class 5174 // User classes are stored in containers transparently 5175 createAllocateSmallInt(ip); 5176 ip->type = "anothertype"; 5177 setValG(ip, 11); 5178 r2 = self->f->push(self, (baset*)ip); 5179 ck_assert_ptr_ne(r2, null); 5180 r = cropElemBoolO(self,3); 5181 ck_assert(!r); 5182 s = toStringO(self); 5183 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5184 free(s); 5185 // index outside 5186 ck_assert(!cropElemBoolO(self, 20)); 5187 ck_assert(!cropElemBoolO(self, -5)); 5188 // empty list 5189 emptyO(self); 5190 ck_assert(!cropElemBoolO(self, 0)); 5191 ck_assert(!cropElemBoolO(self, -1)); 5192 // crop empty slot in array 5193 r2 = self->f->pushUndefined(self); 5194 ck_assert_ptr_ne(r2, null); 5195 delElemO(self,0); 5196 ck_assert(!cropElemBoolO(self, 0)); 5197 terminateO(self); 5198 5199 } 5200 5201 5202 void cropElemDoubleSmallArrayT(CuTest *tc UNUSED) { 5203 5204 double r; 5205 smallArrayt *self = allocG(rtSmallArrayt); 5206 smallArrayt *r2; 5207 5208 // add elements to self 5209 r2 = self->f->pushInt(self, 1); 5210 ck_assert_ptr_ne(r2, null); 5211 r2 = self->f->pushDouble(self, 2); 5212 ck_assert_ptr_ne(r2, null); 5213 r2 = self->f->pushInt(self, 3); 5214 ck_assert_ptr_ne(r2, null); 5215 r2 = self->f->pushDouble(self, 4); 5216 ck_assert_ptr_ne(r2, null); 5217 5218 // positive index 5219 r = cropElemDoubleO(self,1); 5220 ck_assert(r==2); 5221 char *s = toStringO(self); 5222 ck_assert_str_eq(s, "[1,3,4.000000e+00]"); 5223 free(s); 5224 // negative index 5225 r = cropElemDoubleO(self,-1); 5226 ck_assert(r==4); 5227 s = toStringO(self); 5228 ck_assert_str_eq(s, "[1,3]"); 5229 free(s); 5230 // wrong object type 5231 createSmallInt(I); 5232 setValG(&I, 11); 5233 r2 = self->f->pushSmallInt(self, &I); 5234 r = cropElemDoubleO(self,2); 5235 ck_assert(!r); 5236 s = toStringO(self); 5237 ck_assert_str_eq(s, "[1,3,11]"); 5238 free(s); 5239 // wrong object type of another user class 5240 // User classes are stored in containers transparently 5241 createAllocateSmallInt(ip); 5242 ip->type = "anothertype"; 5243 setValG(ip, 11); 5244 r2 = self->f->push(self, (baset*)ip); 5245 ck_assert_ptr_ne(r2, null); 5246 r = cropElemDoubleO(self,3); 5247 ck_assert(!r); 5248 s = toStringO(self); 5249 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5250 free(s); 5251 // index outside 5252 ck_assert(!cropElemDoubleO(self, 20)); 5253 ck_assert(!cropElemDoubleO(self, -5)); 5254 // empty list 5255 emptyO(self); 5256 ck_assert(!cropElemDoubleO(self, 0)); 5257 ck_assert(!cropElemDoubleO(self, -1)); 5258 // crop empty slot in array 5259 r2 = self->f->pushUndefined(self); 5260 ck_assert_ptr_ne(r2, null); 5261 delElemO(self,0); 5262 ck_assert(!cropElemDoubleO(self, 0)); 5263 terminateO(self); 5264 5265 } 5266 5267 5268 void cropElemIntSmallArrayT(CuTest *tc UNUSED) { 5269 5270 int64_t r; 5271 smallArrayt *self = allocG(rtSmallArrayt); 5272 smallArrayt *r2; 5273 5274 // add elements to self 5275 r2 = self->f->pushInt(self, 1); 5276 ck_assert_ptr_ne(r2, null); 5277 r2 = self->f->pushInt(self, 2); 5278 ck_assert_ptr_ne(r2, null); 5279 r2 = self->f->pushInt(self, 3); 5280 ck_assert_ptr_ne(r2, null); 5281 r2 = self->f->pushInt(self, 4); 5282 ck_assert_ptr_ne(r2, null); 5283 5284 // positive index 5285 r = cropElemIntO(self,1); 5286 ck_assert(r==2); 5287 char *s = toStringO(self); 5288 ck_assert_str_eq(s, "[1,3,4]"); 5289 free(s); 5290 // negative index 5291 r = cropElemIntO(self,-1); 5292 ck_assert(r==4); 5293 s = toStringO(self); 5294 ck_assert_str_eq(s, "[1,3]"); 5295 free(s); 5296 // wrong object type 5297 createSmallDouble(I); 5298 setValG(&I, 11); 5299 r2 = self->f->pushSmallDouble(self, &I); 5300 r = cropElemIntO(self,2); 5301 ck_assert(!r); 5302 s = toStringO(self); 5303 ck_assert_str_eq(s, "[1,3,1.100000e+01]"); 5304 free(s); 5305 // wrong object type of another user class 5306 // User classes are stored in containers transparently 5307 createAllocateSmallInt(ip); 5308 ip->type = "anothertype"; 5309 setValG(ip, 11); 5310 r2 = self->f->push(self, (baset*)ip); 5311 ck_assert_ptr_ne(r2, null); 5312 r = cropElemIntO(self,3); 5313 ck_assert(!r); 5314 s = toStringO(self); 5315 ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]"); 5316 free(s); 5317 // index outside 5318 ck_assert(!cropElemIntO(self, 20)); 5319 ck_assert(!cropElemIntO(self, -5)); 5320 // empty list 5321 emptyO(self); 5322 ck_assert(!cropElemIntO(self, 0)); 5323 ck_assert(!cropElemIntO(self, -1)); 5324 // crop empty slot in array 5325 r2 = self->f->pushUndefined(self); 5326 ck_assert_ptr_ne(r2, null); 5327 delElemO(self,0); 5328 ck_assert_int_eq(cropElemIntO(self, 0), 0); 5329 terminateO(self); 5330 5331 } 5332 5333 5334 void cropElemInt32SmallArrayT(CuTest *tc UNUSED) { 5335 5336 int32_t r; 5337 smallArrayt *self = allocG(rtSmallArrayt); 5338 smallArrayt *r2; 5339 5340 // add elements to self 5341 r2 = self->f->pushInt(self, 1); 5342 ck_assert_ptr_ne(r2, null); 5343 r2 = self->f->pushInt(self, 2); 5344 ck_assert_ptr_ne(r2, null); 5345 r2 = self->f->pushInt(self, 3); 5346 ck_assert_ptr_ne(r2, null); 5347 r2 = self->f->pushInt(self, 4); 5348 ck_assert_ptr_ne(r2, null); 5349 5350 // positive index 5351 r = cropElemInt32O(self,1); 5352 ck_assert(r==2); 5353 char *s = toStringO(self); 5354 ck_assert_str_eq(s, "[1,3,4]"); 5355 free(s); 5356 // negative index 5357 r = cropElemInt32O(self,-1); 5358 ck_assert(r==4); 5359 s = toStringO(self); 5360 ck_assert_str_eq(s, "[1,3]"); 5361 free(s); 5362 // wrong object type 5363 createSmallDouble(I); 5364 setValG(&I, 11); 5365 r2 = self->f->pushSmallDouble(self, &I); 5366 r = cropElemInt32O(self,2); 5367 ck_assert(!r); 5368 s = toStringO(self); 5369 ck_assert_str_eq(s, "[1,3,1.100000e+01]"); 5370 free(s); 5371 // wrong object type of another user class 5372 // User classes are stored in containers transparently 5373 createAllocateSmallInt(ip); 5374 ip->type = "anothertype"; 5375 setValG(ip, 11); 5376 r2 = self->f->push(self, (baset*)ip); 5377 ck_assert_ptr_ne(r2, null); 5378 r = cropElemInt32O(self,3); 5379 ck_assert(!r); 5380 s = toStringO(self); 5381 ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]"); 5382 free(s); 5383 // index outside 5384 ck_assert(!cropElemInt32O(self, 20)); 5385 ck_assert(!cropElemInt32O(self, -5)); 5386 // empty list 5387 emptyO(self); 5388 ck_assert(!cropElemInt32O(self, 0)); 5389 ck_assert(!cropElemInt32O(self, -1)); 5390 // crop empty slot in array 5391 r2 = self->f->pushUndefined(self); 5392 ck_assert_ptr_ne(r2, null); 5393 delElemO(self,0); 5394 ck_assert_int_eq(cropElemInt32O(self, 0), 0); 5395 terminateO(self); 5396 5397 } 5398 5399 5400 void cropElemUintSmallArrayT(CuTest *tc UNUSED) { 5401 5402 uint64_t r; 5403 smallArrayt *self = allocG(rtSmallArrayt); 5404 smallArrayt *r2; 5405 5406 // add elements to self 5407 r2 = self->f->pushInt(self, 1); 5408 ck_assert_ptr_ne(r2, null); 5409 r2 = self->f->pushInt(self, 2); 5410 ck_assert_ptr_ne(r2, null); 5411 r2 = self->f->pushInt(self, 3); 5412 ck_assert_ptr_ne(r2, null); 5413 r2 = self->f->pushInt(self, 4); 5414 ck_assert_ptr_ne(r2, null); 5415 5416 // positive index 5417 r = cropElemUintO(self,1); 5418 ck_assert(r==2); 5419 char *s = toStringO(self); 5420 ck_assert_str_eq(s, "[1,3,4]"); 5421 free(s); 5422 // negative index 5423 r = cropElemUintO(self,-1); 5424 ck_assert(r==4); 5425 s = toStringO(self); 5426 ck_assert_str_eq(s, "[1,3]"); 5427 free(s); 5428 // wrong object type 5429 createSmallDouble(I); 5430 setValG(&I, 11); 5431 r2 = self->f->pushSmallDouble(self, &I); 5432 r = cropElemUintO(self,2); 5433 ck_assert(!r); 5434 s = toStringO(self); 5435 ck_assert_str_eq(s, "[1,3,1.100000e+01]"); 5436 free(s); 5437 // wrong object type of another user class 5438 // User classes are stored in containers transparently 5439 createAllocateSmallInt(ip); 5440 ip->type = "anothertype"; 5441 setValG(ip, 11); 5442 r2 = self->f->push(self, (baset*)ip); 5443 ck_assert_ptr_ne(r2, null); 5444 r = cropElemUintO(self,3); 5445 ck_assert(!r); 5446 s = toStringO(self); 5447 ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]"); 5448 free(s); 5449 // index outside 5450 ck_assert(!cropElemUintO(self, 20)); 5451 ck_assert(!cropElemUintO(self, -5)); 5452 // empty list 5453 emptyO(self); 5454 ck_assert(!cropElemUintO(self, 0)); 5455 ck_assert(!cropElemUintO(self, -1)); 5456 // crop empty slot in array 5457 r2 = self->f->pushUndefined(self); 5458 ck_assert_ptr_ne(r2, null); 5459 delElemO(self,0); 5460 ck_assert_int_eq(cropElemUintO(self, 0), 0); 5461 terminateO(self); 5462 5463 } 5464 5465 5466 void cropElemUint32SmallArrayT(CuTest *tc UNUSED) { 5467 5468 uint32_t r; 5469 smallArrayt *self = allocG(rtSmallArrayt); 5470 smallArrayt *r2; 5471 5472 // add elements to self 5473 r2 = self->f->pushInt(self, 1); 5474 ck_assert_ptr_ne(r2, null); 5475 r2 = self->f->pushInt(self, 2); 5476 ck_assert_ptr_ne(r2, null); 5477 r2 = self->f->pushInt(self, 3); 5478 ck_assert_ptr_ne(r2, null); 5479 r2 = self->f->pushInt(self, 4); 5480 ck_assert_ptr_ne(r2, null); 5481 5482 // positive index 5483 r = cropElemUint32O(self,1); 5484 ck_assert(r==2); 5485 char *s = toStringO(self); 5486 ck_assert_str_eq(s, "[1,3,4]"); 5487 free(s); 5488 // negative index 5489 r = cropElemUint32O(self,-1); 5490 ck_assert(r==4); 5491 s = toStringO(self); 5492 ck_assert_str_eq(s, "[1,3]"); 5493 free(s); 5494 // wrong object type 5495 createSmallDouble(I); 5496 setValG(&I, 11); 5497 r2 = self->f->pushSmallDouble(self, &I); 5498 r = cropElemUint32O(self,2); 5499 ck_assert(!r); 5500 s = toStringO(self); 5501 ck_assert_str_eq(s, "[1,3,1.100000e+01]"); 5502 free(s); 5503 // wrong object type of another user class 5504 // User classes are stored in containers transparently 5505 createAllocateSmallInt(ip); 5506 ip->type = "anothertype"; 5507 setValG(ip, 11); 5508 r2 = self->f->push(self, (baset*)ip); 5509 ck_assert_ptr_ne(r2, null); 5510 r = cropElemUint32O(self,3); 5511 ck_assert(!r); 5512 s = toStringO(self); 5513 ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]"); 5514 free(s); 5515 // index outside 5516 ck_assert(!cropElemUint32O(self, 20)); 5517 ck_assert(!cropElemUint32O(self, -5)); 5518 // empty list 5519 emptyO(self); 5520 ck_assert(!cropElemUint32O(self, 0)); 5521 ck_assert(!cropElemUint32O(self, -1)); 5522 // crop empty slot in array 5523 r2 = self->f->pushUndefined(self); 5524 ck_assert_ptr_ne(r2, null); 5525 delElemO(self,0); 5526 ck_assert_int_eq(cropElemUint32O(self, 0), 0); 5527 terminateO(self); 5528 5529 } 5530 5531 5532 void cropElemSSmallArrayT(CuTest *tc UNUSED) { 5533 5534 char* r; 5535 smallArrayt *self = allocG(rtSmallArrayt); 5536 smallArrayt *r2; 5537 5538 // add elements to self 5539 r2 = self->f->pushInt(self, 1); 5540 ck_assert_ptr_ne(r2, null); 5541 r2 = self->f->pushS(self, "2"); 5542 ck_assert_ptr_ne(r2, null); 5543 r2 = self->f->pushInt(self, 3); 5544 ck_assert_ptr_ne(r2, null); 5545 r2 = self->f->pushS(self, "4"); 5546 ck_assert_ptr_ne(r2, null); 5547 5548 // positive index 5549 r = cropElemSO(self,1); 5550 ck_assert_ptr_ne(r, null); 5551 ck_assert_str_eq(r, "2"); 5552 free(r); 5553 char *s = toStringO(self); 5554 ck_assert_str_eq(s, "[1,3,\"4\"]"); 5555 free(s); 5556 // negative index 5557 r = cropElemSO(self,-1); 5558 ck_assert_ptr_ne(r, null); 5559 ck_assert_str_eq(r, "4"); 5560 free(r); 5561 s = toStringO(self); 5562 ck_assert_str_eq(s, "[1,3]"); 5563 free(s); 5564 // wrong object type 5565 createSmallInt(I); 5566 setValG(&I, 11); 5567 r2 = self->f->pushSmallInt(self, &I); 5568 r = cropElemSO(self,2); 5569 ck_assert_ptr_eq(r, NULL); 5570 s = toStringO(self); 5571 ck_assert_str_eq(s, "[1,3,11]"); 5572 free(s); 5573 // wrong object type of another user class 5574 // User classes are stored in containers transparently 5575 createAllocateSmallInt(ip); 5576 ip->type = "anothertype"; 5577 setValG(ip, 11); 5578 r2 = self->f->push(self, (baset*)ip); 5579 ck_assert_ptr_ne(r2, null); 5580 r = cropElemSO(self,3); 5581 ck_assert_ptr_eq(r, NULL); 5582 s = toStringO(self); 5583 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5584 free(s); 5585 // index outside 5586 ck_assert_ptr_eq(cropElemSO(self, 20), NULL); 5587 ck_assert_ptr_eq(cropElemSO(self, -5), NULL); 5588 // empty list 5589 emptyO(self); 5590 ck_assert_ptr_eq(cropElemSO(self, 0), NULL); 5591 ck_assert_ptr_eq(cropElemSO(self, -1), NULL); 5592 // crop empty slot in array 5593 r2 = self->f->pushUndefined(self); 5594 ck_assert_ptr_ne(r2, null); 5595 delElemO(self,0); 5596 ck_assert_ptr_eq(cropElemSO(self, 0), NULL); 5597 terminateO(self); 5598 5599 } 5600 5601 5602 void cropElemDictSmallArrayT(CuTest *tc UNUSED) { 5603 5604 smallDictt* r; 5605 smallArrayt *self = allocG(rtSmallArrayt); 5606 smallArrayt *r2; 5607 5608 // add elements to self 5609 r2 = self->f->pushInt(self, 1); 5610 ck_assert_ptr_ne(r2, null); 5611 createSmallDict(e2); 5612 r2 = self->f->pushDict(self, &e2); 5613 ck_assert_ptr_ne(r2, null); 5614 r2 = self->f->pushInt(self, 3); 5615 ck_assert_ptr_ne(r2, null); 5616 createSmallDict(e4); 5617 r2 = self->f->pushDict(self, &e4); 5618 ck_assert_ptr_ne(r2, null); 5619 5620 // positive index 5621 r = cropElemDictO(self,1); 5622 ck_assert_ptr_ne(r, null); 5623 char *s = toStringO(r); 5624 terminateO(r); 5625 ck_assert_str_eq(s, "{}"); 5626 free(s); 5627 s = toStringO(self); 5628 ck_assert_str_eq(s, "[1,3,{}]"); 5629 free(s); 5630 // negative index 5631 r = cropElemDictO(self,-1); 5632 ck_assert_ptr_ne(r, null); 5633 s = toStringO(r); 5634 terminateO(r); 5635 ck_assert_str_eq(s, "{}"); 5636 free(s); 5637 s = toStringO(self); 5638 ck_assert_str_eq(s, "[1,3]"); 5639 free(s); 5640 // wrong object type 5641 createSmallInt(I); 5642 setValG(&I, 11); 5643 r2 = self->f->pushSmallInt(self, &I); 5644 r = cropElemDictO(self,2); 5645 ck_assert_ptr_eq(r, NULL); 5646 s = toStringO(self); 5647 ck_assert_str_eq(s, "[1,3,11]"); 5648 free(s); 5649 // wrong object type of another user class 5650 // User classes are stored in containers transparently 5651 createAllocateSmallInt(ip); 5652 ip->type = "anothertype"; 5653 setValG(ip, 11); 5654 r2 = self->f->push(self, (baset*)ip); 5655 ck_assert_ptr_ne(r2, null); 5656 r = cropElemDictO(self,3); 5657 ck_assert_ptr_eq(r, NULL); 5658 s = toStringO(self); 5659 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5660 free(s); 5661 // index outside 5662 ck_assert_ptr_eq(cropElemDictO(self, 20), NULL); 5663 ck_assert_ptr_eq(cropElemDictO(self, -5), NULL); 5664 // empty list 5665 emptyO(self); 5666 ck_assert_ptr_eq(cropElemDictO(self, 0), NULL); 5667 ck_assert_ptr_eq(cropElemDictO(self, -1), NULL); 5668 // crop empty slot in array 5669 r2 = self->f->pushUndefined(self); 5670 ck_assert_ptr_ne(r2, null); 5671 delElemO(self,0); 5672 ck_assert_ptr_eq(cropElemDictO(self, 0), NULL); 5673 terminateO(self); 5674 5675 } 5676 5677 5678 void cropElemArraySmallArrayT(CuTest *tc UNUSED) { 5679 5680 smallArrayt* r; 5681 smallArrayt *self = allocG(rtSmallArrayt); 5682 smallArrayt *r2; 5683 5684 // add elements to self 5685 r2 = self->f->pushInt(self, 1); 5686 ck_assert_ptr_ne(r2, null); 5687 createSmallArray(e2); 5688 r2 = self->f->pushArray(self, &e2); 5689 ck_assert_ptr_ne(r2, null); 5690 r2 = self->f->pushInt(self, 3); 5691 ck_assert_ptr_ne(r2, null); 5692 createSmallArray(e4); 5693 r2 = self->f->pushArray(self, &e4); 5694 ck_assert_ptr_ne(r2, null); 5695 5696 // positive index 5697 r = cropElemArrayO(self,1); 5698 ck_assert_ptr_ne(r, null); 5699 char *s = toStringO(r); 5700 terminateO(r); 5701 ck_assert_str_eq(s, "[]"); 5702 free(s); 5703 s = toStringO(self); 5704 ck_assert_str_eq(s, "[1,3,[]]"); 5705 free(s); 5706 // negative index 5707 r = cropElemArrayO(self,-1); 5708 ck_assert_ptr_ne(r, null); 5709 s = toStringO(r); 5710 terminateO(r); 5711 ck_assert_str_eq(s, "[]"); 5712 free(s); 5713 s = toStringO(self); 5714 ck_assert_str_eq(s, "[1,3]"); 5715 free(s); 5716 // wrong object type 5717 createSmallInt(I); 5718 setValG(&I, 11); 5719 r2 = self->f->pushSmallInt(self, &I); 5720 r = cropElemArrayO(self,2); 5721 ck_assert_ptr_eq(r, NULL); 5722 s = toStringO(self); 5723 ck_assert_str_eq(s, "[1,3,11]"); 5724 free(s); 5725 // wrong object type of another user class 5726 // User classes are stored in containers transparently 5727 createAllocateSmallInt(ip); 5728 ip->type = "anothertype"; 5729 setValG(ip, 11); 5730 r2 = self->f->push(self, (baset*)ip); 5731 ck_assert_ptr_ne(r2, null); 5732 r = cropElemArrayO(self,3); 5733 ck_assert_ptr_eq(r, NULL); 5734 s = toStringO(self); 5735 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5736 free(s); 5737 // index outside 5738 ck_assert_ptr_eq(cropElemArrayO(self, 20), NULL); 5739 ck_assert_ptr_eq(cropElemArrayO(self, -5), NULL); 5740 // empty list 5741 emptyO(self); 5742 ck_assert_ptr_eq(cropElemArrayO(self, 0), NULL); 5743 ck_assert_ptr_eq(cropElemArrayO(self, -1), NULL); 5744 // crop empty slot in array 5745 r2 = self->f->pushUndefined(self); 5746 ck_assert_ptr_ne(r2, null); 5747 delElemO(self,0); 5748 ck_assert_ptr_eq(cropElemArrayO(self, 0), NULL); 5749 terminateO(self); 5750 5751 } 5752 5753 5754 void cropElemSmallBoolSmallArrayT(CuTest *tc UNUSED) { 5755 5756 smallBoolt* r; 5757 smallArrayt *self = allocG(rtSmallArrayt); 5758 smallArrayt *r2; 5759 5760 // add elements to self 5761 r2 = self->f->pushInt(self, 1); 5762 ck_assert_ptr_ne(r2, null); 5763 createSmallBool(e2); 5764 r2 = self->f->pushBool(self, true); 5765 ck_assert_ptr_ne(r2, null); 5766 r2 = self->f->pushInt(self, 3); 5767 ck_assert_ptr_ne(r2, null); 5768 createSmallBool(e4); 5769 r2 = self->f->pushBool(self, true); 5770 ck_assert_ptr_ne(r2, null); 5771 5772 // positive index 5773 r = cropElemSmallBoolO(self,1); 5774 ck_assert_ptr_ne(r, null); 5775 char *s = toStringO(r); 5776 terminateO(r); 5777 ck_assert_str_eq(s, "true"); 5778 free(s); 5779 s = toStringO(self); 5780 ck_assert_str_eq(s, "[1,3,true]"); 5781 free(s); 5782 // negative index 5783 r = cropElemSmallBoolO(self,-1); 5784 ck_assert_ptr_ne(r, null); 5785 s = toStringO(r); 5786 terminateO(r); 5787 ck_assert_str_eq(s, "true"); 5788 free(s); 5789 s = toStringO(self); 5790 ck_assert_str_eq(s, "[1,3]"); 5791 free(s); 5792 // wrong object type 5793 createSmallInt(I); 5794 setValG(&I, 11); 5795 r2 = self->f->pushSmallInt(self, &I); 5796 r = cropElemSmallBoolO(self,2); 5797 ck_assert_ptr_eq(r, NULL); 5798 s = toStringO(self); 5799 ck_assert_str_eq(s, "[1,3,11]"); 5800 free(s); 5801 // wrong object type of another user class 5802 // User classes are stored in containers transparently 5803 createAllocateSmallInt(ip); 5804 ip->type = "anothertype"; 5805 setValG(ip, 11); 5806 r2 = self->f->push(self, (baset*)ip); 5807 ck_assert_ptr_ne(r2, null); 5808 r = cropElemSmallBoolO(self,3); 5809 ck_assert_ptr_eq(r, NULL); 5810 s = toStringO(self); 5811 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5812 free(s); 5813 // index outside 5814 ck_assert_ptr_eq(cropElemSmallBoolO(self, 20), NULL); 5815 ck_assert_ptr_eq(cropElemSmallBoolO(self, -5), NULL); 5816 // empty list 5817 emptyO(self); 5818 ck_assert_ptr_eq(cropElemSmallBoolO(self, 0), NULL); 5819 ck_assert_ptr_eq(cropElemSmallBoolO(self, -1), NULL); 5820 // crop empty slot in array 5821 r2 = self->f->pushUndefined(self); 5822 ck_assert_ptr_ne(r2, null); 5823 delElemO(self,0); 5824 ck_assert_ptr_eq(cropElemSmallBoolO(self, 0), NULL); 5825 terminateO(self); 5826 5827 } 5828 5829 5830 void cropElemSmallBytesSmallArrayT(CuTest *tc UNUSED) { 5831 5832 smallBytest* r; 5833 smallArrayt *self = allocG(rtSmallArrayt); 5834 smallArrayt *r2; 5835 5836 // add elements to self 5837 r2 = self->f->pushInt(self, 1); 5838 ck_assert_ptr_ne(r2, null); 5839 createSmallBytes(e2); 5840 r2 = self->f->pushSmallBytes(self, &e2); 5841 ck_assert_ptr_ne(r2, null); 5842 r2 = self->f->pushInt(self, 3); 5843 ck_assert_ptr_ne(r2, null); 5844 createSmallBytes(e4); 5845 r2 = self->f->pushSmallBytes(self, &e4); 5846 ck_assert_ptr_ne(r2, null); 5847 5848 // positive index 5849 r = cropElemSmallBytesO(self,1); 5850 ck_assert_ptr_ne(r, null); 5851 char *s = toStringO(r); 5852 terminateO(r); 5853 ck_assert_str_eq(s, "[]"); 5854 free(s); 5855 s = toStringO(self); 5856 ck_assert_str_eq(s, "[1,3,[]]"); 5857 free(s); 5858 // negative index 5859 r = cropElemSmallBytesO(self,-1); 5860 ck_assert_ptr_ne(r, null); 5861 s = toStringO(r); 5862 terminateO(r); 5863 ck_assert_str_eq(s, "[]"); 5864 free(s); 5865 s = toStringO(self); 5866 ck_assert_str_eq(s, "[1,3]"); 5867 free(s); 5868 // wrong object type 5869 createSmallInt(I); 5870 setValG(&I, 11); 5871 r2 = self->f->pushSmallInt(self, &I); 5872 r = cropElemSmallBytesO(self,2); 5873 ck_assert_ptr_eq(r, NULL); 5874 s = toStringO(self); 5875 ck_assert_str_eq(s, "[1,3,11]"); 5876 free(s); 5877 // wrong object type of another user class 5878 // User classes are stored in containers transparently 5879 createAllocateSmallInt(ip); 5880 ip->type = "anothertype"; 5881 setValG(ip, 11); 5882 r2 = self->f->push(self, (baset*)ip); 5883 ck_assert_ptr_ne(r2, null); 5884 r = cropElemSmallBytesO(self,3); 5885 ck_assert_ptr_eq(r, NULL); 5886 s = toStringO(self); 5887 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5888 free(s); 5889 // index outside 5890 ck_assert_ptr_eq(cropElemSmallBytesO(self, 20), NULL); 5891 ck_assert_ptr_eq(cropElemSmallBytesO(self, -5), NULL); 5892 // empty list 5893 emptyO(self); 5894 ck_assert_ptr_eq(cropElemSmallBytesO(self, 0), NULL); 5895 ck_assert_ptr_eq(cropElemSmallBytesO(self, -1), NULL); 5896 // crop empty slot in array 5897 r2 = self->f->pushUndefined(self); 5898 ck_assert_ptr_ne(r2, null); 5899 delElemO(self,0); 5900 ck_assert_ptr_eq(cropElemSmallBytesO(self, 0), NULL); 5901 terminateO(self); 5902 5903 } 5904 5905 5906 void cropElemSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 5907 5908 smallDoublet* r; 5909 smallArrayt *self = allocG(rtSmallArrayt); 5910 smallArrayt *r2; 5911 5912 // add elements to self 5913 r2 = self->f->pushInt(self, 1); 5914 ck_assert_ptr_ne(r2, null); 5915 createSmallDouble(e2); 5916 r2 = self->f->pushSmallDouble(self, &e2); 5917 ck_assert_ptr_ne(r2, null); 5918 r2 = self->f->pushInt(self, 3); 5919 ck_assert_ptr_ne(r2, null); 5920 createSmallDouble(e4); 5921 r2 = self->f->pushSmallDouble(self, &e4); 5922 ck_assert_ptr_ne(r2, null); 5923 5924 // positive index 5925 r = cropElemSmallDoubleO(self,1); 5926 ck_assert_ptr_ne(r, null); 5927 char *s = toStringO(r); 5928 terminateO(r); 5929 ck_assert_str_eq(s, "0.000000e+00"); 5930 free(s); 5931 s = toStringO(self); 5932 ck_assert_str_eq(s, "[1,3,0.000000e+00]"); 5933 free(s); 5934 // negative index 5935 r = cropElemSmallDoubleO(self,-1); 5936 ck_assert_ptr_ne(r, null); 5937 s = toStringO(r); 5938 terminateO(r); 5939 ck_assert_str_eq(s, "0.000000e+00"); 5940 free(s); 5941 s = toStringO(self); 5942 ck_assert_str_eq(s, "[1,3]"); 5943 free(s); 5944 // wrong object type 5945 createSmallInt(I); 5946 setValG(&I, 11); 5947 r2 = self->f->pushSmallInt(self, &I); 5948 r = cropElemSmallDoubleO(self,2); 5949 ck_assert_ptr_eq(r, NULL); 5950 s = toStringO(self); 5951 ck_assert_str_eq(s, "[1,3,11]"); 5952 free(s); 5953 // wrong object type of another user class 5954 // User classes are stored in containers transparently 5955 createAllocateSmallInt(ip); 5956 ip->type = "anothertype"; 5957 setValG(ip, 11); 5958 r2 = self->f->push(self, (baset*)ip); 5959 ck_assert_ptr_ne(r2, null); 5960 r = cropElemSmallDoubleO(self,3); 5961 ck_assert_ptr_eq(r, NULL); 5962 s = toStringO(self); 5963 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 5964 free(s); 5965 // index outside 5966 ck_assert_ptr_eq(cropElemSmallDoubleO(self, 20), NULL); 5967 ck_assert_ptr_eq(cropElemSmallDoubleO(self, -5), NULL); 5968 // empty list 5969 emptyO(self); 5970 ck_assert_ptr_eq(cropElemSmallDoubleO(self, 0), NULL); 5971 ck_assert_ptr_eq(cropElemSmallDoubleO(self, -1), NULL); 5972 // crop empty slot in array 5973 r2 = self->f->pushUndefined(self); 5974 ck_assert_ptr_ne(r2, null); 5975 delElemO(self,0); 5976 ck_assert_ptr_eq(cropElemSmallDoubleO(self, 0), NULL); 5977 terminateO(self); 5978 5979 } 5980 5981 5982 void cropElemSmallIntSmallArrayT(CuTest *tc UNUSED) { 5983 5984 smallIntt* r; 5985 smallArrayt *self = allocG(rtSmallArrayt); 5986 smallArrayt *r2; 5987 5988 // add elements to self 5989 r2 = self->f->pushBool(self, true); 5990 ck_assert_ptr_ne(r2, null); 5991 createSmallInt(e2); 5992 r2 = self->f->pushSmallInt(self, &e2); 5993 ck_assert_ptr_ne(r2, null); 5994 r2 = self->f->pushBool(self, true); 5995 ck_assert_ptr_ne(r2, null); 5996 createSmallInt(e4); 5997 r2 = self->f->pushSmallInt(self, &e4); 5998 ck_assert_ptr_ne(r2, null); 5999 6000 // positive index 6001 r = cropElemSmallIntO(self,1); 6002 ck_assert_ptr_ne(r, null); 6003 char *s = toStringO(r); 6004 terminateO(r); 6005 ck_assert_str_eq(s, "0"); 6006 free(s); 6007 s = toStringO(self); 6008 ck_assert_str_eq(s, "[true,true,0]"); 6009 free(s); 6010 // negative index 6011 r = cropElemSmallIntO(self,-1); 6012 ck_assert_ptr_ne(r, null); 6013 s = toStringO(r); 6014 terminateO(r); 6015 ck_assert_str_eq(s, "0"); 6016 free(s); 6017 s = toStringO(self); 6018 ck_assert_str_eq(s, "[true,true]"); 6019 free(s); 6020 // wrong object type 6021 createSmallDouble(I); 6022 setValG(&I, 11); 6023 r2 = self->f->pushSmallDouble(self, &I); 6024 r = cropElemSmallIntO(self,2); 6025 ck_assert_ptr_eq(r, NULL); 6026 s = toStringO(self); 6027 ck_assert_str_eq(s, "[true,true,1.100000e+01]"); 6028 free(s); 6029 // wrong object type of another user class 6030 // User classes are stored in containers transparently 6031 createAllocateSmallInt(ip); 6032 ip->type = "anothertype"; 6033 setValG(ip, 11); 6034 r2 = self->f->push(self, (baset*)ip); 6035 ck_assert_ptr_ne(r2, null); 6036 r = cropElemSmallIntO(self,3); 6037 ck_assert_ptr_eq(r, NULL); 6038 s = toStringO(self); 6039 ck_assert_str_eq(s, "[true,true,1.100000e+01,\"<data container>\"]"); 6040 free(s); 6041 // index outside 6042 ck_assert_ptr_eq(cropElemSmallIntO(self, 20), NULL); 6043 ck_assert_ptr_eq(cropElemSmallIntO(self, -5), NULL); 6044 // empty list 6045 emptyO(self); 6046 ck_assert_ptr_eq(cropElemSmallIntO(self, 0), NULL); 6047 ck_assert_ptr_eq(cropElemSmallIntO(self, -1), NULL); 6048 // crop empty slot in array 6049 r2 = self->f->pushUndefined(self); 6050 ck_assert_ptr_ne(r2, null); 6051 delElemO(self,0); 6052 ck_assert_ptr_eq(cropElemSmallIntO(self, 0), NULL); 6053 terminateO(self); 6054 6055 } 6056 6057 6058 void cropElemSmallJsonSmallArrayT(CuTest *tc UNUSED) { 6059 6060 smallJsont* r; 6061 smallArrayt *self = allocG(rtSmallArrayt); 6062 smallArrayt *r2; 6063 6064 // add elements to self 6065 r2 = self->f->pushInt(self, 1); 6066 ck_assert_ptr_ne(r2, null); 6067 createSmallJson(e2); 6068 r2 = self->f->pushSmallJson(self, &e2); 6069 ck_assert_ptr_ne(r2, null); 6070 r2 = self->f->pushInt(self, 3); 6071 ck_assert_ptr_ne(r2, null); 6072 createSmallJson(e4); 6073 r2 = self->f->pushSmallJson(self, &e4); 6074 ck_assert_ptr_ne(r2, null); 6075 6076 // positive index 6077 r = cropElemSmallJsonO(self,1); 6078 ck_assert_ptr_ne(r, null); 6079 char *s = toStringO(r); 6080 terminateO(r); 6081 ck_assert_str_eq(s, "{}"); 6082 free(s); 6083 s = toStringO(self); 6084 ck_assert_str_eq(s, "[1,3,{}]"); 6085 free(s); 6086 // negative index 6087 r = cropElemSmallJsonO(self,-1); 6088 ck_assert_ptr_ne(r, null); 6089 s = toStringO(r); 6090 terminateO(r); 6091 ck_assert_str_eq(s, "{}"); 6092 free(s); 6093 s = toStringO(self); 6094 ck_assert_str_eq(s, "[1,3]"); 6095 free(s); 6096 // wrong object type 6097 createSmallBytes(I); 6098 r2 = self->f->pushSmallBytes(self, &I); 6099 r = cropElemSmallJsonO(self,2); 6100 ck_assert_ptr_eq(r, NULL); 6101 s = toStringO(self); 6102 ck_assert_str_eq(s, "[1,3,[]]"); 6103 free(s); 6104 // wrong object type of another user class 6105 // User classes are stored in containers transparently 6106 createAllocateSmallInt(ip); 6107 ip->type = "anothertype"; 6108 setValG(ip, 11); 6109 r2 = self->f->push(self, (baset*)ip); 6110 ck_assert_ptr_ne(r2, null); 6111 r = cropElemSmallJsonO(self,3); 6112 ck_assert_ptr_eq(r, NULL); 6113 s = toStringO(self); 6114 ck_assert_str_eq(s, "[1,3,[],\"<data container>\"]"); 6115 free(s); 6116 // index outside 6117 ck_assert_ptr_eq(cropElemSmallJsonO(self, 20), NULL); 6118 ck_assert_ptr_eq(cropElemSmallJsonO(self, -5), NULL); 6119 // empty list 6120 emptyO(self); 6121 ck_assert_ptr_eq(cropElemSmallJsonO(self, 0), NULL); 6122 ck_assert_ptr_eq(cropElemSmallJsonO(self, -1), NULL); 6123 // crop empty slot in array 6124 r2 = self->f->pushUndefined(self); 6125 ck_assert_ptr_ne(r2, null); 6126 delElemO(self,0); 6127 ck_assert_ptr_eq(cropElemSmallJsonO(self, 0), NULL); 6128 terminateO(self); 6129 6130 } 6131 6132 6133 void cropElemSmallStringSmallArrayT(CuTest *tc UNUSED) { 6134 6135 smallStringt* r; 6136 smallArrayt *self = allocG(rtSmallArrayt); 6137 smallArrayt *r2; 6138 6139 // add elements to self 6140 r2 = self->f->pushInt(self, 1); 6141 ck_assert_ptr_ne(r2, null); 6142 createSmallString(e2); 6143 r2 = self->f->pushSmallString(self, &e2); 6144 ck_assert_ptr_ne(r2, null); 6145 r2 = self->f->pushInt(self, 3); 6146 ck_assert_ptr_ne(r2, null); 6147 createSmallString(e4); 6148 r2 = self->f->pushSmallString(self, &e4); 6149 ck_assert_ptr_ne(r2, null); 6150 6151 // positive index 6152 r = cropElemSmallStringO(self,1); 6153 ck_assert_ptr_ne(r, null); 6154 char *s = toStringO(r); 6155 terminateO(r); 6156 ck_assert_str_eq(s, ""); 6157 free(s); 6158 s = toStringO(self); 6159 ck_assert_str_eq(s, "[1,3,\"\"]"); 6160 free(s); 6161 // negative index 6162 r = cropElemSmallStringO(self,-1); 6163 ck_assert_ptr_ne(r, null); 6164 s = toStringO(r); 6165 terminateO(r); 6166 ck_assert_str_eq(s, ""); 6167 free(s); 6168 s = toStringO(self); 6169 ck_assert_str_eq(s, "[1,3]"); 6170 free(s); 6171 // wrong object type 6172 createSmallInt(I); 6173 setValG(&I, 11); 6174 r2 = self->f->pushSmallInt(self, &I); 6175 r = cropElemSmallStringO(self,2); 6176 ck_assert_ptr_eq(r, NULL); 6177 s = toStringO(self); 6178 ck_assert_str_eq(s, "[1,3,11]"); 6179 free(s); 6180 // wrong object type of another user class 6181 // User classes are stored in containers transparently 6182 createAllocateSmallInt(ip); 6183 ip->type = "anothertype"; 6184 setValG(ip, 11); 6185 r2 = self->f->push(self, (baset*)ip); 6186 ck_assert_ptr_ne(r2, null); 6187 r = cropElemSmallStringO(self,3); 6188 ck_assert_ptr_eq(r, NULL); 6189 s = toStringO(self); 6190 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 6191 free(s); 6192 // index outside 6193 ck_assert_ptr_eq(cropElemSmallStringO(self, 20), NULL); 6194 ck_assert_ptr_eq(cropElemSmallStringO(self, -5), NULL); 6195 // empty list 6196 emptyO(self); 6197 ck_assert_ptr_eq(cropElemSmallStringO(self, 0), NULL); 6198 ck_assert_ptr_eq(cropElemSmallStringO(self, -1), NULL); 6199 // crop empty slot in array 6200 r2 = self->f->pushUndefined(self); 6201 ck_assert_ptr_ne(r2, null); 6202 delElemO(self,0); 6203 ck_assert_ptr_eq(cropElemSmallStringO(self, 0), NULL); 6204 terminateO(self); 6205 6206 } 6207 6208 6209 void cropElemVoidSmallArrayT(CuTest *tc UNUSED) { 6210 6211 void* r; 6212 smallArrayt *self = allocG(rtSmallArrayt); 6213 smallArrayt *r2; 6214 6215 // add elements to self 6216 r2 = self->f->pushInt(self, 1); 6217 ck_assert_ptr_ne(r2, null); 6218 r2 = pushVoidSmallArrayG(self, &r); 6219 ck_assert_ptr_ne(r2, null); 6220 r2 = self->f->pushInt(self, 3); 6221 ck_assert_ptr_ne(r2, null); 6222 r2 = pushVoidSmallArrayG(self, &self); 6223 ck_assert_ptr_ne(r2, null); 6224 6225 // positive index 6226 r = cropElemVoidO(self,1); 6227 ck_assert_ptr_eq(r, &r); 6228 char *s = toStringO(self); 6229 ck_assert_str_eq(s, "[1,3,\"<data container>\"]"); 6230 free(s); 6231 // negative index 6232 r = cropElemVoidO(self,-1); 6233 ck_assert_ptr_eq(r, &self); 6234 s = toStringO(self); 6235 ck_assert_str_eq(s, "[1,3]"); 6236 free(s); 6237 // wrong object type 6238 createSmallInt(I); 6239 setValG(&I, 11); 6240 r2 = self->f->pushSmallInt(self, &I); 6241 r = cropElemVoidO(self,2); 6242 ck_assert_ptr_eq(r, NULL); 6243 s = toStringO(self); 6244 ck_assert_str_eq(s, "[1,3,11]"); 6245 free(s); 6246 // wrong object type of another user class 6247 // User classes are stored in containers transparently 6248 createAllocateSmallInt(ip); 6249 ip->type = "anothertype"; 6250 setValG(ip, 11); 6251 r2 = self->f->push(self, (baset*)ip); 6252 ck_assert_ptr_ne(r2, null); 6253 r = cropElemVoidO(self,3); 6254 ck_assert_ptr_eq(r, NULL); 6255 s = toStringO(self); 6256 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 6257 free(s); 6258 // index outside 6259 ck_assert_ptr_eq(cropElemVoidO(self, 20), NULL); 6260 ck_assert_ptr_eq(cropElemVoidO(self, -5), NULL); 6261 // empty list 6262 emptyO(self); 6263 ck_assert_ptr_eq(cropElemVoidO(self, 0), NULL); 6264 ck_assert_ptr_eq(cropElemVoidO(self, -1), NULL); 6265 // crop empty slot in array 6266 r2 = self->f->pushUndefined(self); 6267 ck_assert_ptr_ne(r2, null); 6268 delElemO(self,0); 6269 ck_assert_ptr_eq(cropElemVoidO(self, 0), NULL); 6270 terminateO(self); 6271 6272 } 6273 6274 6275 void cropElemSmallContainerSmallArrayT(CuTest *tc UNUSED) { 6276 6277 smallContainert* r; 6278 smallArrayt *self = allocG(rtSmallArrayt); 6279 smallArrayt *r2; 6280 6281 // add elements to self 6282 r2 = self->f->pushInt(self, 1); 6283 ck_assert_ptr_ne(r2, null); 6284 createSmallContainer(e2); 6285 r2 = self->f->pushSmallContainer(self, &e2); 6286 ck_assert_ptr_ne(r2, null); 6287 r2 = self->f->pushInt(self, 3); 6288 ck_assert_ptr_ne(r2, null); 6289 createSmallContainer(e4); 6290 r2 = self->f->pushSmallContainer(self, &e4); 6291 ck_assert_ptr_ne(r2, null); 6292 6293 // positive index 6294 r = cropElemSmallContainerO(self,1); 6295 ck_assert_ptr_ne(r, null); 6296 char *s = toStringO(r); 6297 terminateO(r); 6298 ck_assert_str_eq(s, "<data smallContainer>"); 6299 free(s); 6300 s = toStringO(self); 6301 ck_assert_str_eq(s, "[1,3,\"<data container>\"]"); 6302 free(s); 6303 // negative index 6304 r = cropElemSmallContainerO(self,-1); 6305 ck_assert_ptr_ne(r, null); 6306 s = toStringO(r); 6307 terminateO(r); 6308 ck_assert_str_eq(s, "<data smallContainer>"); 6309 free(s); 6310 s = toStringO(self); 6311 ck_assert_str_eq(s, "[1,3]"); 6312 free(s); 6313 // wrong object type 6314 createSmallInt(I); 6315 setValG(&I, 11); 6316 r2 = self->f->pushSmallInt(self, &I); 6317 r = cropElemSmallContainerO(self,2); 6318 ck_assert_ptr_eq(r, NULL); 6319 s = toStringO(self); 6320 ck_assert_str_eq(s, "[1,3,11]"); 6321 free(s); 6322 // wrong object type of another user class 6323 // User classes are stored in containers transparently 6324 createAllocateSmallInt(ip); 6325 ip->type = "anothertype"; 6326 setValG(ip, 11); 6327 r2 = self->f->push(self, (baset*)ip); 6328 ck_assert_ptr_ne(r2, null); 6329 r = cropElemSmallContainerO(self,3); 6330 ck_assert_ptr_eq(r, NULL); 6331 s = toStringO(self); 6332 ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]"); 6333 free(s); 6334 // index outside 6335 ck_assert_ptr_eq(cropElemSmallContainerO(self, 20), NULL); 6336 ck_assert_ptr_eq(cropElemSmallContainerO(self, -5), NULL); 6337 // empty list 6338 emptyO(self); 6339 ck_assert_ptr_eq(cropElemSmallContainerO(self, 0), NULL); 6340 ck_assert_ptr_eq(cropElemSmallContainerO(self, -1), NULL); 6341 // crop empty slot in array 6342 r2 = self->f->pushUndefined(self); 6343 ck_assert_ptr_ne(r2, null); 6344 delElemO(self,0); 6345 ck_assert_ptr_eq(cropElemSmallContainerO(self, 0), NULL); 6346 terminateO(self); 6347 6348 } 6349 6350 6351 void copySmallArrayT(CuTest *tc UNUSED) { 6352 6353 smallArrayt* r; 6354 smallArrayt *self = allocG(rtSmallArrayt); 6355 6356 // add elements to self 6357 r = self->f->pushInt(self, 1); 6358 ck_assert_ptr_ne(r, null); 6359 r = self->f->pushInt(self, 2); 6360 ck_assert_ptr_ne(r, null); 6361 r = self->f->pushInt(self, 3); 6362 ck_assert_ptr_ne(r, null); 6363 r = self->f->pushInt(self, 4); 6364 ck_assert_ptr_ne(r, null); 6365 6366 // negative index 6367 r = copyRngO(self, 1, -1); 6368 ck_assert_ptr_ne(r, null); 6369 ck_assert_int_eq(lenO(r), 2); 6370 char *s = toStringO(r); 6371 terminateO(r); 6372 ck_assert_str_eq(s, "[2,3]"); 6373 free(s); 6374 s = toStringO(self); 6375 ck_assert_str_eq(s, "[1,2,3,4]"); 6376 free(s); 6377 // start outside 6378 ck_assert_ptr_eq(copyRngO(self, 20, -3), NULL); 6379 // end outside 6380 r = copyRngO(self, 0, 40); 6381 ck_assert_ptr_ne(r, null); 6382 ck_assert_int_eq(lenO(r), 4); 6383 s = toStringO(r); 6384 terminateO(r); 6385 ck_assert_str_eq(s, "[1,2,3,4]"); 6386 free(s); 6387 s = toStringO(self); 6388 ck_assert_str_eq(s, "[1,2,3,4]"); 6389 free(s); 6390 // end negative and outside 6391 ck_assert_ptr_eq(copyRngO(self, 2, -40), NULL); 6392 s = toStringO(self); 6393 ck_assert_str_eq(s, "[1,2,3,4]"); 6394 free(s); 6395 // end before start 6396 ck_assert_ptr_eq(copyRngO(self, 3, 2), NULL); 6397 s = toStringO(self); 6398 ck_assert_str_eq(s, "[1,2,3,4]"); 6399 free(s); 6400 // negative start last element 6401 r = copyRngO(self, -1, 0); 6402 ck_assert_ptr_ne(r, null); 6403 ck_assert_int_eq(lenO(r), 1); 6404 s = toStringO(r); 6405 terminateO(r); 6406 ck_assert_str_eq(s, "[4]"); 6407 free(s); 6408 s = toStringO(self); 6409 ck_assert_str_eq(s, "[1,2,3,4]"); 6410 free(s); 6411 // negative start and outside 6412 r = copyRngO(self, -10, 1); 6413 ck_assert_ptr_ne(r, null); 6414 ck_assert_int_eq(lenO(r), 1); 6415 s = toStringO(r); 6416 terminateO(r); 6417 ck_assert_str_eq(s, "[1]"); 6418 free(s); 6419 s = toStringO(self); 6420 ck_assert_str_eq(s, "[1,2,3,4]"); 6421 free(s); 6422 // start = end 6423 r = copyRngO(self, 1, 1); 6424 ck_assert_ptr_ne(r, null); 6425 ck_assert_int_eq(lenO(r), 0); 6426 terminateO(r); 6427 s = toStringO(self); 6428 ck_assert_str_eq(s, "[1,2,3,4]"); 6429 free(s); 6430 // empty list 6431 emptyO(self); 6432 ck_assert_ptr_eq(copyRngO(self, 0, 0), NULL); 6433 ck_assert_ptr_eq(copyRngO(self, -1, 0), NULL); 6434 terminateO(self); 6435 6436 } 6437 6438 6439 void insertSmallArrayT(CuTest *tc UNUSED) { 6440 6441 smallArrayt* r; 6442 smallArrayt *self = allocG(rtSmallArrayt); 6443 smallArrayt *toInsert; 6444 6445 // add elements to self 6446 r = self->f->pushInt(self, 1); 6447 ck_assert_ptr_ne(r, null); 6448 r = self->f->pushInt(self, 2); 6449 ck_assert_ptr_ne(r, null); 6450 6451 // positive index 6452 toInsert = allocSmallArray(); 6453 toInsert->f->pushInt(toInsert, 3); 6454 r = self->f->insert(self, 1, toInsert); 6455 smashO(toInsert); 6456 ck_assert_ptr_ne(r, null); 6457 char *s = toStringO(r); 6458 ck_assert_str_eq(s, "[1,3,2]"); 6459 free(s); 6460 // negative index 6461 toInsert = allocSmallArray(); 6462 toInsert->f->pushInt(toInsert, 4); 6463 r = self->f->insert(self, -1, toInsert); 6464 smashO(toInsert); 6465 ck_assert_ptr_ne(r, null); 6466 s = toStringO(r); 6467 ck_assert_str_eq(s, "[1,3,2,4]"); 6468 free(s); 6469 // empty list 6470 emptyO(self); 6471 toInsert = allocSmallArray(); 6472 toInsert->f->pushInt(toInsert, 3); 6473 r = self->f->insert(self, 0, toInsert); 6474 smashO(toInsert); 6475 ck_assert_ptr_ne(r, null); 6476 s = toStringO(r); 6477 ck_assert_str_eq(s, "[3]"); 6478 free(s); 6479 emptyO(self); 6480 toInsert = allocSmallArray(); 6481 toInsert->f->pushInt(toInsert, 3); 6482 r = self->f->insert(self, -1, toInsert); 6483 smashO(toInsert); 6484 ck_assert_ptr_ne(r, null); 6485 s = toStringO(r); 6486 ck_assert_str_eq(s, "[3]"); 6487 free(s); 6488 // Array array length 0 6489 toInsert = allocSmallArray(); 6490 r = self->f->insert(self, -1, toInsert); 6491 smashO(toInsert); 6492 ck_assert_ptr_ne(r, null); 6493 s = toStringO(r); 6494 ck_assert_str_eq(s, "[3]"); 6495 free(s); 6496 // index outside 6497 toInsert = allocSmallArray(); 6498 ck_assert_ptr_eq(self->f->insert(self, 20, toInsert), NULL); 6499 ck_assert_ptr_eq(self->f->insert(self, -5, toInsert), NULL); 6500 smashO(toInsert); 6501 // non smallArray toInsert 6502 toInsert = (smallArrayt*) allocSmallInt(1); 6503 ck_assert_ptr_eq(self->f->insert(self, 0, toInsert), NULL); 6504 terminateO(toInsert); 6505 // insert NULL 6506 ck_assert_ptr_eq(self->f->insert(self, 0, NULL), NULL); 6507 terminateO(self); 6508 6509 } 6510 6511 6512 void insertSmallJsonSmallArrayT(CuTest *tc UNUSED) { 6513 6514 smallArrayt* r; 6515 smallArrayt *self = allocG(rtSmallArrayt); 6516 smallJsont *toInsert; 6517 6518 // add elements to self 6519 r = self->f->pushInt(self, 1); 6520 ck_assert_ptr_ne(r, null); 6521 r = self->f->pushInt(self, 2); 6522 ck_assert_ptr_ne(r, null); 6523 6524 // positive index 6525 toInsert = allocSmallJson(); 6526 toInsert->f->pushInt(toInsert, 3); 6527 r = self->f->insertSmallJson(self, 1, toInsert); 6528 smashO(toInsert); 6529 ck_assert_ptr_ne(r, null); 6530 char *s = toStringO(r); 6531 ck_assert_str_eq(s, "[1,3,2]"); 6532 free(s); 6533 // negative index 6534 toInsert = allocSmallJson(); 6535 toInsert->f->pushInt(toInsert, 4); 6536 r = self->f->insertSmallJson(self, -1, toInsert); 6537 smashO(toInsert); 6538 ck_assert_ptr_ne(r, null); 6539 s = toStringO(r); 6540 ck_assert_str_eq(s, "[1,3,2,4]"); 6541 free(s); 6542 // empty list 6543 emptyO(self); 6544 toInsert = allocSmallJson(); 6545 toInsert->f->pushInt(toInsert, 3); 6546 r = self->f->insertSmallJson(self, 0, toInsert); 6547 smashO(toInsert); 6548 ck_assert_ptr_ne(r, null); 6549 s = toStringO(r); 6550 ck_assert_str_eq(s, "[3]"); 6551 free(s); 6552 emptyO(self); 6553 toInsert = allocSmallJson(); 6554 toInsert->f->pushInt(toInsert, 3); 6555 r = self->f->insertSmallJson(self, -1, toInsert); 6556 smashO(toInsert); 6557 ck_assert_ptr_ne(r, null); 6558 s = toStringO(r); 6559 ck_assert_str_eq(s, "[3]"); 6560 free(s); 6561 // json array length 0 6562 toInsert = allocSmallJson(); 6563 setTypeArrayG(toInsert); 6564 r = self->f->insertSmallJson(self, -1, toInsert); 6565 smashO(toInsert); 6566 ck_assert_ptr_ne(r, null); 6567 s = toStringO(r); 6568 ck_assert_str_eq(s, "[3]"); 6569 free(s); 6570 // json with no type 6571 toInsert = allocSmallJson(); 6572 r = self->f->insertSmallJson(self, -1, toInsert); 6573 smashO(toInsert); 6574 ck_assert_ptr_eq(r, null); 6575 s = toStringO(self); 6576 ck_assert_str_eq(s, "[3]"); 6577 free(s); 6578 // non smallJson object 6579 toInsert = (smallJsont*) allocSmallInt(2); 6580 r = self->f->insertSmallJson(self, -1, toInsert); 6581 ck_assert_ptr_eq(r, null); 6582 terminateO(toInsert); 6583 // index outside 6584 toInsert = allocSmallJson(); 6585 ck_assert_ptr_eq(self->f->insertSmallJson(self, 20, toInsert), NULL); 6586 ck_assert_ptr_eq(self->f->insertSmallJson(self, -5, toInsert), NULL); 6587 smashO(toInsert); 6588 // insert NULL 6589 ck_assert_ptr_eq(self->f->insertSmallJson(self, 0, NULL), NULL); 6590 terminateO(self); 6591 6592 } 6593 6594 6595 void insertNSmashSmallArrayT(CuTest *tc UNUSED) { 6596 6597 smallArrayt* r; 6598 smallArrayt *self = allocG(rtSmallArrayt); 6599 smallArrayt *toInsert; 6600 6601 // add elements to self 6602 r = self->f->pushInt(self, 1); 6603 ck_assert_ptr_ne(r, null); 6604 r = self->f->pushInt(self, 2); 6605 ck_assert_ptr_ne(r, null); 6606 6607 // positive index 6608 toInsert = allocSmallArray(); 6609 toInsert->f->pushInt(toInsert, 3); 6610 r = self->f->insertNSmash(self, 1, toInsert); 6611 ck_assert_ptr_ne(r, null); 6612 char *s = toStringO(r); 6613 ck_assert_str_eq(s, "[1,3,2]"); 6614 free(s); 6615 // negative index 6616 toInsert = allocSmallArray(); 6617 toInsert->f->pushInt(toInsert, 4); 6618 r = self->f->insertNSmash(self, -1, toInsert); 6619 ck_assert_ptr_ne(r, null); 6620 s = toStringO(r); 6621 ck_assert_str_eq(s, "[1,3,2,4]"); 6622 free(s); 6623 // empty list 6624 emptyO(self); 6625 toInsert = allocSmallArray(); 6626 toInsert->f->pushInt(toInsert, 3); 6627 r = self->f->insertNSmash(self, 0, toInsert); 6628 ck_assert_ptr_ne(r, null); 6629 s = toStringO(r); 6630 ck_assert_str_eq(s, "[3]"); 6631 free(s); 6632 emptyO(self); 6633 toInsert = allocSmallArray(); 6634 toInsert->f->pushInt(toInsert, 3); 6635 r = self->f->insertNSmash(self, -1, toInsert); 6636 ck_assert_ptr_ne(r, null); 6637 s = toStringO(r); 6638 ck_assert_str_eq(s, "[3]"); 6639 free(s); 6640 // Array array length 0 6641 toInsert = allocSmallArray(); 6642 r = self->f->insertNSmash(self, -1, toInsert); 6643 ck_assert_ptr_ne(r, null); 6644 s = toStringO(r); 6645 ck_assert_str_eq(s, "[3]"); 6646 free(s); 6647 // index outside 6648 toInsert = allocSmallArray(); 6649 ck_assert_ptr_eq(self->f->insertNSmash(self, 20, toInsert), NULL); 6650 ck_assert_ptr_eq(self->f->insertNSmash(self, -5, toInsert), NULL); 6651 smashO(toInsert); 6652 // insert NULL 6653 ck_assert_ptr_eq(self->f->insertNSmash(self, 0, NULL), NULL); 6654 terminateO(self); 6655 6656 } 6657 6658 6659 void insertNSmashSmallJsonSmallArrayT(CuTest *tc UNUSED) { 6660 6661 smallArrayt* r; 6662 smallArrayt *self = allocG(rtSmallArrayt); 6663 smallJsont *toInsert; 6664 6665 // add elements to self 6666 r = self->f->pushInt(self, 1); 6667 ck_assert_ptr_ne(r, null); 6668 r = self->f->pushInt(self, 2); 6669 ck_assert_ptr_ne(r, null); 6670 6671 // positive index 6672 toInsert = allocSmallJson(); 6673 toInsert->f->pushInt(toInsert, 3); 6674 r = self->f->insertNSmashSmallJson(self, 1, toInsert); 6675 ck_assert_ptr_ne(r, null); 6676 char *s = toStringO(r); 6677 ck_assert_str_eq(s, "[1,3,2]"); 6678 free(s); 6679 // negative index 6680 toInsert = allocSmallJson(); 6681 toInsert->f->pushInt(toInsert, 4); 6682 r = self->f->insertNSmashSmallJson(self, -1, toInsert); 6683 ck_assert_ptr_ne(r, null); 6684 s = toStringO(r); 6685 ck_assert_str_eq(s, "[1,3,2,4]"); 6686 free(s); 6687 // empty list 6688 emptyO(self); 6689 toInsert = allocSmallJson(); 6690 toInsert->f->pushInt(toInsert, 3); 6691 r = self->f->insertNSmashSmallJson(self, 0, toInsert); 6692 ck_assert_ptr_ne(r, null); 6693 s = toStringO(r); 6694 ck_assert_str_eq(s, "[3]"); 6695 free(s); 6696 emptyO(self); 6697 toInsert = allocSmallJson(); 6698 toInsert->f->pushInt(toInsert, 3); 6699 r = self->f->insertNSmashSmallJson(self, -1, toInsert); 6700 ck_assert_ptr_ne(r, null); 6701 s = toStringO(r); 6702 ck_assert_str_eq(s, "[3]"); 6703 free(s); 6704 // json array length 0 6705 toInsert = allocSmallJson(); 6706 setTypeArrayG(toInsert); 6707 r = self->f->insertNSmashSmallJson(self, -1, toInsert); 6708 ck_assert_ptr_ne(r, null); 6709 s = toStringO(r); 6710 ck_assert_str_eq(s, "[3]"); 6711 free(s); 6712 // json with no type 6713 toInsert = allocSmallJson(); 6714 r = self->f->insertNSmashSmallJson(self, -1, toInsert); 6715 smashO(toInsert); 6716 ck_assert_ptr_eq(r, null); 6717 s = toStringO(self); 6718 ck_assert_str_eq(s, "[3]"); 6719 free(s); 6720 // index outside 6721 toInsert = allocSmallJson(); 6722 ck_assert_ptr_eq(self->f->insertNSmashSmallJson(self, 20, toInsert), NULL); 6723 ck_assert_ptr_eq(self->f->insertNSmashSmallJson(self, -5, toInsert), NULL); 6724 smashO(toInsert); 6725 // insert NULL 6726 ck_assert_ptr_eq(self->f->insertNSmashSmallJson(self, 0, NULL), NULL); 6727 terminateO(self); 6728 6729 } 6730 6731 6732 void injectSmallArrayT(CuTest *tc UNUSED) { 6733 6734 smallArrayt* r; 6735 smallArrayt *self = allocG(rtSmallArrayt); 6736 baset *toInject; 6737 6738 // add elements to self 6739 r = self->f->pushInt(self, 1); 6740 ck_assert_ptr_ne(r, null); 6741 r = self->f->pushInt(self, 2); 6742 ck_assert_ptr_ne(r, null); 6743 r = self->f->pushInt(self, 3); 6744 ck_assert_ptr_ne(r, null); 6745 r = self->f->pushInt(self, 4); 6746 ck_assert_ptr_ne(r, null); 6747 6748 // positive index 6749 toInject = (baset*) allocSmallInt(8); 6750 r = self->f->inject(self, 1, toInject); 6751 ck_assert_ptr_ne(r, null); 6752 finishO(toInject); 6753 char *s = toStringO(r); 6754 ck_assert_str_eq(s, "[1,8,2,3,4]"); 6755 free(s); 6756 // negative index 6757 toInject = (baset*) allocSmallInt(9); 6758 r = self->f->inject(self,-1, toInject); 6759 ck_assert_ptr_ne(r, null); 6760 finishO(toInject); 6761 s = toStringO(r); 6762 ck_assert_str_eq(s, "[1,8,2,3,4,9]"); 6763 free(s); 6764 // index 0 6765 toInject = (baset*) allocSmallInt(6); 6766 r = self->f->inject(self,0, toInject); 6767 ck_assert_ptr_ne(r, null); 6768 finishO(toInject); 6769 s = toStringO(r); 6770 ck_assert_str_eq(s, "[6,1,8,2,3,4,9]"); 6771 free(s); 6772 // index outside 6773 toInject = (baset*) allocSmallInt(7); 6774 ck_assert_ptr_eq(self->f->inject(self, 20, toInject), NULL); 6775 ck_assert_ptr_eq(self->f->inject(self, -9, toInject), NULL); 6776 terminateO(toInject); 6777 // empty list 6778 emptyO(self); 6779 toInject = (baset*) allocSmallInt(7); 6780 ck_assert_ptr_ne(self->f->inject(self, 0, toInject), NULL); 6781 finishO(toInject); 6782 s = toStringO(r); 6783 ck_assert_str_eq(s, "[7]"); 6784 free(s); 6785 emptyO(self); 6786 toInject = (baset*) allocSmallInt(7); 6787 ck_assert_ptr_ne(self->f->inject(self, -1, toInject), NULL); 6788 finishO(toInject); 6789 s = toStringO(r); 6790 ck_assert_str_eq(s, "[7]"); 6791 free(s); 6792 // null toInsert 6793 ck_assert_ptr_eq(self->f->inject(self, 0, NULL), NULL); 6794 terminateO(self); 6795 6796 } 6797 6798 6799 void injectUndefinedSmallArrayT(CuTest *tc UNUSED) { 6800 6801 smallArrayt* r; 6802 smallArrayt *self = allocG(rtSmallArrayt); 6803 6804 // add elements to self 6805 r = self->f->pushInt(self, 1); 6806 ck_assert_ptr_ne(r, null); 6807 r = self->f->pushInt(self, 2); 6808 ck_assert_ptr_ne(r, null); 6809 r = self->f->pushInt(self, 3); 6810 ck_assert_ptr_ne(r, null); 6811 r = self->f->pushInt(self, 4); 6812 ck_assert_ptr_ne(r, null); 6813 6814 // positive index 6815 r = self->f->injectUndefined(self, 1); 6816 ck_assert_ptr_ne(r, null); 6817 char *s = toStringO(r); 6818 ck_assert_str_eq(s, "[1,null,2,3,4]"); 6819 free(s); 6820 // negative index 6821 r = self->f->injectUndefined(self,-1); 6822 ck_assert_ptr_ne(r, null); 6823 s = toStringO(r); 6824 ck_assert_str_eq(s, "[1,null,2,3,4,null]"); 6825 free(s); 6826 // index 0 6827 r = self->f->injectUndefined(self,0); 6828 ck_assert_ptr_ne(r, null); 6829 s = toStringO(r); 6830 ck_assert_str_eq(s, "[null,1,null,2,3,4,null]"); 6831 free(s); 6832 // index outside 6833 ck_assert_ptr_eq(self->f->injectUndefined(self, 20), NULL); 6834 ck_assert_ptr_eq(self->f->injectUndefined(self, -9), NULL); 6835 // empty list 6836 emptyO(self); 6837 ck_assert_ptr_ne(self->f->injectUndefined(self, 0), NULL); 6838 s = toStringO(r); 6839 ck_assert_str_eq(s, "[null]"); 6840 free(s); 6841 emptyO(self); 6842 ck_assert_ptr_ne(self->f->injectUndefined(self, -1), NULL); 6843 s = toStringO(r); 6844 ck_assert_str_eq(s, "[null]"); 6845 free(s); 6846 terminateO(self); 6847 6848 } 6849 6850 6851 void injectBoolSmallArrayT(CuTest *tc UNUSED) { 6852 6853 smallArrayt* r; 6854 smallArrayt *self = allocG(rtSmallArrayt); 6855 6856 // add elements to self 6857 r = self->f->pushInt(self, 1); 6858 ck_assert_ptr_ne(r, null); 6859 r = self->f->pushInt(self, 2); 6860 ck_assert_ptr_ne(r, null); 6861 r = self->f->pushInt(self, 3); 6862 ck_assert_ptr_ne(r, null); 6863 r = self->f->pushInt(self, 4); 6864 ck_assert_ptr_ne(r, null); 6865 6866 // positive index 6867 r = self->f->injectBool(self, 1, true); 6868 ck_assert_ptr_ne(r, null); 6869 char *s = toStringO(r); 6870 ck_assert_str_eq(s, "[1,true,2,3,4]"); 6871 free(s); 6872 // negative index 6873 r = self->f->injectBool(self,-1, true); 6874 ck_assert_ptr_ne(r, null); 6875 s = toStringO(r); 6876 ck_assert_str_eq(s, "[1,true,2,3,4,true]"); 6877 free(s); 6878 // index 0 6879 r = self->f->injectBool(self,0, true); 6880 ck_assert_ptr_ne(r, null); 6881 s = toStringO(r); 6882 ck_assert_str_eq(s, "[true,1,true,2,3,4,true]"); 6883 free(s); 6884 // index outside 6885 ck_assert_ptr_eq(self->f->injectBool(self, 20, true), NULL); 6886 ck_assert_ptr_eq(self->f->injectBool(self, -9, true), NULL); 6887 // empty list 6888 emptyO(self); 6889 ck_assert_ptr_ne(self->f->injectBool(self, 0, true), NULL); 6890 s = toStringO(r); 6891 ck_assert_str_eq(s, "[true]"); 6892 free(s); 6893 emptyO(self); 6894 ck_assert_ptr_ne(self->f->injectBool(self, -1, true), NULL); 6895 s = toStringO(r); 6896 ck_assert_str_eq(s, "[true]"); 6897 free(s); 6898 terminateO(self); 6899 6900 } 6901 6902 6903 void injectDoubleSmallArrayT(CuTest *tc UNUSED) { 6904 6905 smallArrayt* r; 6906 smallArrayt *self = allocG(rtSmallArrayt); 6907 6908 // add elements to self 6909 r = self->f->pushInt(self, 1); 6910 ck_assert_ptr_ne(r, null); 6911 r = self->f->pushInt(self, 2); 6912 ck_assert_ptr_ne(r, null); 6913 r = self->f->pushInt(self, 3); 6914 ck_assert_ptr_ne(r, null); 6915 r = self->f->pushInt(self, 4); 6916 ck_assert_ptr_ne(r, null); 6917 6918 // positive index 6919 r = self->f->injectDouble(self, 1, 7); 6920 ck_assert_ptr_ne(r, null); 6921 char *s = toStringO(r); 6922 ck_assert_str_eq(s, "[1,7.000000e+00,2,3,4]"); 6923 free(s); 6924 // negative index 6925 r = self->f->injectDouble(self,-1, 8); 6926 ck_assert_ptr_ne(r, null); 6927 s = toStringO(r); 6928 ck_assert_str_eq(s, "[1,7.000000e+00,2,3,4,8.000000e+00]"); 6929 free(s); 6930 // index 0 6931 r = self->f->injectDouble(self,0, 9); 6932 ck_assert_ptr_ne(r, null); 6933 s = toStringO(r); 6934 ck_assert_str_eq(s, "[9.000000e+00,1,7.000000e+00,2,3,4,8.000000e+00]"); 6935 free(s); 6936 // index outside 6937 ck_assert_ptr_eq(self->f->injectDouble(self, 20, 7.000000e+00), NULL); 6938 ck_assert_ptr_eq(self->f->injectDouble(self, -9, 7.000000e+00), NULL); 6939 // empty list 6940 emptyO(self); 6941 ck_assert_ptr_ne(self->f->injectDouble(self, 0, 9), NULL); 6942 s = toStringO(r); 6943 ck_assert_str_eq(s, "[9.000000e+00]"); 6944 free(s); 6945 emptyO(self); 6946 ck_assert_ptr_ne(self->f->injectDouble(self, -1, 9), NULL); 6947 s = toStringO(r); 6948 ck_assert_str_eq(s, "[9.000000e+00]"); 6949 free(s); 6950 terminateO(self); 6951 6952 } 6953 6954 6955 void injectIntSmallArrayT(CuTest *tc UNUSED) { 6956 6957 smallArrayt* r; 6958 smallArrayt *self = allocG(rtSmallArrayt); 6959 6960 // add elements to self 6961 r = self->f->pushInt(self, 1); 6962 ck_assert_ptr_ne(r, null); 6963 r = self->f->pushInt(self, 2); 6964 ck_assert_ptr_ne(r, null); 6965 r = self->f->pushInt(self, 3); 6966 ck_assert_ptr_ne(r, null); 6967 r = self->f->pushInt(self, 4); 6968 ck_assert_ptr_ne(r, null); 6969 6970 // positive index 6971 r = self->f->injectInt(self, 1, 5); 6972 ck_assert_ptr_ne(r, null); 6973 char *s = toStringO(r); 6974 ck_assert_str_eq(s, "[1,5,2,3,4]"); 6975 free(s); 6976 // negative index 6977 r = self->f->injectInt(self,-1, 6); 6978 ck_assert_ptr_ne(r, null); 6979 s = toStringO(r); 6980 ck_assert_str_eq(s, "[1,5,2,3,4,6]"); 6981 free(s); 6982 // index 0 6983 r = self->f->injectInt(self,0, 7); 6984 ck_assert_ptr_ne(r, null); 6985 s = toStringO(r); 6986 ck_assert_str_eq(s, "[7,1,5,2,3,4,6]"); 6987 free(s); 6988 // index outside 6989 ck_assert_ptr_eq(self->f->injectInt(self, 20, true), NULL); 6990 ck_assert_ptr_eq(self->f->injectInt(self, -9, true), NULL); 6991 // empty list 6992 emptyO(self); 6993 ck_assert_ptr_ne(self->f->injectInt(self, 0, 7), NULL); 6994 s = toStringO(r); 6995 ck_assert_str_eq(s, "[7]"); 6996 free(s); 6997 emptyO(self); 6998 ck_assert_ptr_ne(self->f->injectInt(self, -1, 7), NULL); 6999 s = toStringO(r); 7000 ck_assert_str_eq(s, "[7]"); 7001 free(s); 7002 terminateO(self); 7003 7004 } 7005 7006 7007 void injectSSmallArrayT(CuTest *tc UNUSED) { 7008 7009 smallArrayt* r; 7010 smallArrayt *self = allocG(rtSmallArrayt); 7011 7012 // add elements to self 7013 r = self->f->pushInt(self, 1); 7014 ck_assert_ptr_ne(r, null); 7015 r = self->f->pushInt(self, 2); 7016 ck_assert_ptr_ne(r, null); 7017 r = self->f->pushInt(self, 3); 7018 ck_assert_ptr_ne(r, null); 7019 r = self->f->pushInt(self, 4); 7020 ck_assert_ptr_ne(r, null); 7021 // positive index 7022 r = self->f->injectS(self, 1, "5"); 7023 ck_assert_ptr_ne(r, null); 7024 char *s = toStringO(r); 7025 ck_assert_str_eq(s, "[1,\"5\",2,3,4]"); 7026 free(s); 7027 // negative index 7028 r = self->f->injectS(self,-1, "6"); 7029 ck_assert_ptr_ne(r, null); 7030 s = toStringO(r); 7031 ck_assert_str_eq(s, "[1,\"5\",2,3,4,\"6\"]"); 7032 free(s); 7033 // index 0 7034 r = self->f->injectS(self,0, "7"); 7035 ck_assert_ptr_ne(r, null); 7036 s = toStringO(r); 7037 ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]"); 7038 free(s); 7039 // null toInject 7040 r = self->f->injectS(self,0, null); 7041 ck_assert_ptr_eq(r, null); 7042 s = toStringO(self); 7043 ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]"); 7044 free(s); 7045 // index outside 7046 ck_assert_ptr_eq(self->f->injectS(self, 20, ""), NULL); 7047 ck_assert_ptr_eq(self->f->injectS(self, -9, ""), NULL); 7048 // empty list 7049 emptyO(self); 7050 ck_assert_ptr_ne(self->f->injectS(self, 0, "7"), NULL); 7051 s = toStringO(self); 7052 ck_assert_str_eq(s, "[\"7\"]"); 7053 free(s); 7054 emptyO(self); 7055 ck_assert_ptr_ne(self->f->injectS(self, -1, "7"), NULL); 7056 s = toStringO(self); 7057 ck_assert_str_eq(s, "[\"7\"]"); 7058 free(s); 7059 terminateO(self); 7060 7061 } 7062 7063 7064 void injectCharSmallArrayT(CuTest *tc UNUSED) { 7065 7066 smallArrayt* r; 7067 smallArrayt *self = allocG(rtSmallArrayt); 7068 7069 // add elements to self 7070 r = self->f->pushInt(self, 1); 7071 ck_assert_ptr_ne(r, null); 7072 r = self->f->pushInt(self, 2); 7073 ck_assert_ptr_ne(r, null); 7074 r = self->f->pushInt(self, 3); 7075 ck_assert_ptr_ne(r, null); 7076 r = self->f->pushInt(self, 4); 7077 ck_assert_ptr_ne(r, null); 7078 7079 // positive index 7080 r = self->f->injectChar(self, 1, '5'); 7081 ck_assert_ptr_ne(r, null); 7082 char *s = toStringO(r); 7083 ck_assert_str_eq(s, "[1,\"5\",2,3,4]"); 7084 free(s); 7085 // negative index 7086 r = self->f->injectChar(self,-1, '6'); 7087 ck_assert_ptr_ne(r, null); 7088 s = toStringO(r); 7089 ck_assert_str_eq(s, "[1,\"5\",2,3,4,\"6\"]"); 7090 free(s); 7091 // index 0 7092 r = self->f->injectChar(self,0, '7'); 7093 ck_assert_ptr_ne(r, null); 7094 s = toStringO(r); 7095 ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]"); 7096 free(s); 7097 // index outside 7098 ck_assert_ptr_eq(self->f->injectChar(self, 20, 'y'), NULL); 7099 ck_assert_ptr_eq(self->f->injectChar(self, -9, 'y'), NULL); 7100 // empty list 7101 emptyO(self); 7102 ck_assert_ptr_ne(self->f->injectChar(self, 0, '7'), NULL); 7103 s = toStringO(r); 7104 ck_assert_str_eq(s, "[\"7\"]"); 7105 free(s); 7106 emptyO(self); 7107 ck_assert_ptr_ne(self->f->injectChar(self, -1, '7'), NULL); 7108 s = toStringO(r); 7109 ck_assert_str_eq(s, "[\"7\"]"); 7110 free(s); 7111 terminateO(self); 7112 7113 } 7114 7115 7116 void injectDictSmallArrayT(CuTest *tc UNUSED) { 7117 7118 smallArrayt* r; 7119 smallArrayt *self = allocG(rtSmallArrayt); 7120 smallDictt *toInject; 7121 7122 // add elements to self 7123 r = self->f->pushInt(self, 1); 7124 ck_assert_ptr_ne(r, null); 7125 r = self->f->pushInt(self, 2); 7126 ck_assert_ptr_ne(r, null); 7127 r = self->f->pushInt(self, 3); 7128 ck_assert_ptr_ne(r, null); 7129 r = self->f->pushInt(self, 4); 7130 ck_assert_ptr_ne(r, null); 7131 7132 // positive index 7133 toInject = allocSmallDict(); 7134 r = self->f->injectDict(self, 1, toInject); 7135 ck_assert_ptr_ne(r, null); 7136 finishO(toInject); 7137 char *s = toStringO(r); 7138 ck_assert_str_eq(s, "[1,{},2,3,4]"); 7139 free(s); 7140 // negative index 7141 toInject = allocSmallDict(); 7142 r = self->f->injectDict(self,-1, toInject); 7143 ck_assert_ptr_ne(r, null); 7144 finishO(toInject); 7145 s = toStringO(r); 7146 ck_assert_str_eq(s, "[1,{},2,3,4,{}]"); 7147 free(s); 7148 // index 0 7149 toInject = allocSmallDict(); 7150 r = self->f->injectDict(self,0, toInject); 7151 ck_assert_ptr_ne(r, null); 7152 finishO(toInject); 7153 s = toStringO(r); 7154 ck_assert_str_eq(s, "[{},1,{},2,3,4,{}]"); 7155 free(s); 7156 // index outside 7157 toInject = allocSmallDict(); 7158 ck_assert_ptr_eq(self->f->injectDict(self, 20, toInject), NULL); 7159 ck_assert_ptr_eq(self->f->injectDict(self, -9, toInject), NULL); 7160 terminateO(toInject); 7161 // empty list 7162 emptyO(self); 7163 toInject = allocSmallDict(); 7164 ck_assert_ptr_ne(self->f->injectDict(self, 0, toInject), NULL); 7165 finishO(toInject); 7166 s = toStringO(r); 7167 ck_assert_str_eq(s, "[{}]"); 7168 free(s); 7169 emptyO(self); 7170 toInject = allocSmallDict(); 7171 ck_assert_ptr_ne(self->f->injectDict(self, -1, toInject), NULL); 7172 finishO(toInject); 7173 s = toStringO(r); 7174 ck_assert_str_eq(s, "[{}]"); 7175 free(s); 7176 // non smallDict object 7177 toInject = (smallDictt*) allocSmallInt(2); 7178 r = self->f->injectDict(self, 0, toInject); 7179 ck_assert_ptr_eq(r, null); 7180 terminateO(toInject); 7181 // null toInsert 7182 ck_assert_ptr_eq(self->f->injectDict(self, 0, NULL), NULL); 7183 terminateO(self); 7184 7185 } 7186 7187 7188 void injectArraySmallArrayT(CuTest *tc UNUSED) { 7189 7190 smallArrayt* r; 7191 smallArrayt *self = allocG(rtSmallArrayt); 7192 smallArrayt *toInject; 7193 7194 // add elements to self 7195 r = self->f->pushInt(self, 1); 7196 ck_assert_ptr_ne(r, null); 7197 r = self->f->pushInt(self, 2); 7198 ck_assert_ptr_ne(r, null); 7199 r = self->f->pushInt(self, 3); 7200 ck_assert_ptr_ne(r, null); 7201 r = self->f->pushInt(self, 4); 7202 ck_assert_ptr_ne(r, null); 7203 7204 // positive index 7205 toInject = allocSmallArray(); 7206 r = self->f->injectArray(self, 1, toInject); 7207 ck_assert_ptr_ne(r, null); 7208 finishO(toInject); 7209 char *s = toStringO(r); 7210 ck_assert_str_eq(s, "[1,[],2,3,4]"); 7211 free(s); 7212 // negative index 7213 toInject = allocSmallArray(); 7214 r = self->f->injectArray(self,-1, toInject); 7215 ck_assert_ptr_ne(r, null); 7216 finishO(toInject); 7217 s = toStringO(r); 7218 ck_assert_str_eq(s, "[1,[],2,3,4,[]]"); 7219 free(s); 7220 // index 0 7221 toInject = allocSmallArray(); 7222 r = self->f->injectArray(self,0, toInject); 7223 ck_assert_ptr_ne(r, null); 7224 finishO(toInject); 7225 s = toStringO(r); 7226 ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]"); 7227 free(s); 7228 // index outside 7229 toInject = allocSmallArray(); 7230 ck_assert_ptr_eq(self->f->injectArray(self, 20, toInject), NULL); 7231 ck_assert_ptr_eq(self->f->injectArray(self, -9, toInject), NULL); 7232 terminateO(toInject); 7233 // empty list 7234 emptyO(self); 7235 toInject = allocSmallArray(); 7236 ck_assert_ptr_ne(self->f->injectArray(self, 0, toInject), NULL); 7237 finishO(toInject); 7238 s = toStringO(r); 7239 ck_assert_str_eq(s, "[[]]"); 7240 free(s); 7241 emptyO(self); 7242 toInject = allocSmallArray(); 7243 ck_assert_ptr_ne(self->f->injectArray(self, -1, toInject), NULL); 7244 finishO(toInject); 7245 s = toStringO(r); 7246 ck_assert_str_eq(s, "[[]]"); 7247 free(s); 7248 // non smallArray object 7249 toInject = (smallArrayt*) allocSmallInt(2); 7250 r = self->f->injectArray(self, 0, toInject); 7251 ck_assert_ptr_eq(r, null); 7252 terminateO(toInject); 7253 // null toInsert 7254 ck_assert_ptr_eq(self->f->injectArray(self, 0, NULL), NULL); 7255 terminateO(self); 7256 7257 } 7258 7259 7260 void injectArraycSmallArrayT(CuTest *tc UNUSED) { 7261 7262 smallArrayt* r; 7263 smallArrayt *self = allocG(rtSmallArrayt); 7264 char **toInject; 7265 7266 // add elements to self 7267 r = self->f->pushInt(self, 1); 7268 ck_assert_ptr_ne(r, null); 7269 r = self->f->pushInt(self, 2); 7270 ck_assert_ptr_ne(r, null); 7271 r = self->f->pushInt(self, 3); 7272 ck_assert_ptr_ne(r, null); 7273 r = self->f->pushInt(self, 4); 7274 ck_assert_ptr_ne(r, null); 7275 7276 // positive index 7277 toInject = listCreateS("a","b"); 7278 r = self->f->injectArrayc(self, 1, toInject); 7279 listFreeS(toInject); 7280 ck_assert_ptr_ne(r, null); 7281 char *s = toStringO(r); 7282 ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4]"); 7283 free(s); 7284 // negative index 7285 toInject = listCreateS("c","d"); 7286 r = self->f->injectArrayc(self,-1, toInject); 7287 listFreeS(toInject); 7288 ck_assert_ptr_ne(r, null); 7289 s = toStringO(r); 7290 ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]"); 7291 free(s); 7292 // index 0 7293 toInject = listCreateS("e","ff"); 7294 r = self->f->injectArrayc(self,0, toInject); 7295 listFreeS(toInject); 7296 ck_assert_ptr_ne(r, null); 7297 s = toStringO(r); 7298 ck_assert_str_eq(s, "[[\"e\",\"ff\"],1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]"); 7299 free(s); 7300 // index outside 7301 toInject = listCreateS("a","b"); 7302 ck_assert_ptr_eq(self->f->injectArrayc(self, 20, toInject), NULL); 7303 ck_assert_ptr_eq(self->f->injectArrayc(self, -9, toInject), NULL); 7304 listFreeS(toInject); 7305 // empty list 7306 emptyO(self); 7307 toInject = listCreateS("a","b"); 7308 ck_assert_ptr_ne(self->f->injectArrayc(self, 0, toInject), NULL); 7309 listFreeS(toInject); 7310 s = toStringO(r); 7311 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 7312 free(s); 7313 emptyO(self); 7314 toInject = listCreateS("a","b"); 7315 ck_assert_ptr_ne(self->f->injectArrayc(self, -1, toInject), NULL); 7316 listFreeS(toInject); 7317 s = toStringO(r); 7318 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 7319 free(s); 7320 // null toInsert 7321 ck_assert_ptr_eq(self->f->injectArrayc(self, 0, NULL), NULL); 7322 terminateO(self); 7323 7324 } 7325 7326 7327 void injectSmallBoolSmallArrayT(CuTest *tc UNUSED) { 7328 7329 smallArrayt* r; 7330 smallArrayt *self = allocG(rtSmallArrayt); 7331 smallBoolt *toInject; 7332 7333 // add elements to self 7334 r = self->f->pushInt(self, 1); 7335 ck_assert_ptr_ne(r, null); 7336 r = self->f->pushInt(self, 2); 7337 ck_assert_ptr_ne(r, null); 7338 r = self->f->pushInt(self, 3); 7339 ck_assert_ptr_ne(r, null); 7340 r = self->f->pushInt(self, 4); 7341 ck_assert_ptr_ne(r, null); 7342 7343 // positive index 7344 toInject = allocSmallBool(true); 7345 r = self->f->injectSmallBool(self, 1, toInject); 7346 ck_assert_ptr_ne(r, null); 7347 finishO(toInject); 7348 char *s = toStringO(r); 7349 ck_assert_str_eq(s, "[1,true,2,3,4]"); 7350 free(s); 7351 // negative index 7352 toInject = allocSmallBool(true); 7353 r = self->f->injectSmallBool(self,-1, toInject); 7354 ck_assert_ptr_ne(r, null); 7355 finishO(toInject); 7356 s = toStringO(r); 7357 ck_assert_str_eq(s, "[1,true,2,3,4,true]"); 7358 free(s); 7359 // index 0 7360 toInject = allocSmallBool(true); 7361 r = self->f->injectSmallBool(self,0, toInject); 7362 ck_assert_ptr_ne(r, null); 7363 finishO(toInject); 7364 s = toStringO(r); 7365 ck_assert_str_eq(s, "[true,1,true,2,3,4,true]"); 7366 free(s); 7367 // index outside 7368 toInject = allocSmallBool(true); 7369 ck_assert_ptr_eq(self->f->injectSmallBool(self, 20, toInject), NULL); 7370 ck_assert_ptr_eq(self->f->injectSmallBool(self, -9, toInject), NULL); 7371 terminateO(toInject); 7372 // empty object 7373 emptyO(self); 7374 toInject = allocSmallBool(true); 7375 freeO(toInject); 7376 ck_assert_ptr_ne(self->f->injectSmallBool(self, 0, toInject), NULL); 7377 finishO(toInject); 7378 s = toStringO(r); 7379 ck_assert_str_eq(s, "[false]"); 7380 free(s); 7381 // empty list 7382 emptyO(self); 7383 toInject = allocSmallBool(true); 7384 ck_assert_ptr_ne(self->f->injectSmallBool(self, 0, toInject), NULL); 7385 finishO(toInject); 7386 s = toStringO(r); 7387 ck_assert_str_eq(s, "[true]"); 7388 free(s); 7389 emptyO(self); 7390 toInject = allocSmallBool(true); 7391 ck_assert_ptr_ne(self->f->injectSmallBool(self, -1, toInject), NULL); 7392 finishO(toInject); 7393 s = toStringO(r); 7394 ck_assert_str_eq(s, "[true]"); 7395 free(s); 7396 // non smallBool object 7397 toInject = (smallBoolt*) allocSmallInt(2); 7398 r = self->f->injectSmallBool(self, 0, toInject); 7399 ck_assert_ptr_eq(r, null); 7400 terminateO(toInject); 7401 // null toInsert 7402 ck_assert_ptr_eq(self->f->injectSmallBool(self, 0, NULL), NULL); 7403 terminateO(self); 7404 7405 } 7406 7407 7408 void injectSmallBytesSmallArrayT(CuTest *tc UNUSED) { 7409 7410 smallArrayt* r; 7411 smallArrayt *self = allocG(rtSmallArrayt); 7412 smallBytest *toInject; 7413 7414 // add elements to self 7415 r = self->f->pushInt(self, 1); 7416 ck_assert_ptr_ne(r, null); 7417 r = self->f->pushInt(self, 2); 7418 ck_assert_ptr_ne(r, null); 7419 r = self->f->pushInt(self, 3); 7420 ck_assert_ptr_ne(r, null); 7421 r = self->f->pushInt(self, 4); 7422 ck_assert_ptr_ne(r, null); 7423 7424 // positive index 7425 toInject = allocSmallBytes(null, 0); 7426 r = self->f->injectSmallBytes(self, 1, toInject); 7427 ck_assert_ptr_ne(r, null); 7428 finishO(toInject); 7429 char *s = toStringO(r); 7430 ck_assert_str_eq(s, "[1,[],2,3,4]"); 7431 free(s); 7432 // negative index 7433 toInject = allocSmallBytes(null, 0); 7434 r = self->f->injectSmallBytes(self,-1, toInject); 7435 ck_assert_ptr_ne(r, null); 7436 finishO(toInject); 7437 s = toStringO(r); 7438 ck_assert_str_eq(s, "[1,[],2,3,4,[]]"); 7439 free(s); 7440 // index 0 7441 toInject = allocSmallBytes(null, 0); 7442 r = self->f->injectSmallBytes(self,0, toInject); 7443 ck_assert_ptr_ne(r, null); 7444 finishO(toInject); 7445 s = toStringO(r); 7446 ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]"); 7447 free(s); 7448 // index outside 7449 toInject = allocSmallBytes(null, 0); 7450 ck_assert_ptr_eq(self->f->injectSmallBytes(self, 20, toInject), NULL); 7451 ck_assert_ptr_eq(self->f->injectSmallBytes(self, -9, toInject), NULL); 7452 terminateO(toInject); 7453 // empty object 7454 emptyO(self); 7455 toInject = allocSmallBytes(null, 0); 7456 freeO(toInject); 7457 ck_assert_ptr_ne(self->f->injectSmallBytes(self, 0, toInject), NULL); 7458 finishO(toInject); 7459 s = toStringO(r); 7460 ck_assert_str_eq(s, "[[]]"); 7461 free(s); 7462 // empty list 7463 emptyO(self); 7464 toInject = allocSmallBytes(null, 0); 7465 ck_assert_ptr_ne(self->f->injectSmallBytes(self, 0, toInject), NULL); 7466 finishO(toInject); 7467 s = toStringO(r); 7468 ck_assert_str_eq(s, "[[]]"); 7469 free(s); 7470 emptyO(self); 7471 toInject = allocSmallBytes(null, 0); 7472 ck_assert_ptr_ne(self->f->injectSmallBytes(self, -1, toInject), NULL); 7473 finishO(toInject); 7474 s = toStringO(r); 7475 ck_assert_str_eq(s, "[[]]"); 7476 free(s); 7477 // non smallBytes object 7478 toInject = (smallBytest*) allocSmallInt(2); 7479 r = self->f->injectSmallBytes(self, 0, toInject); 7480 ck_assert_ptr_eq(r, null); 7481 terminateO(toInject); 7482 // null toInsert 7483 ck_assert_ptr_eq(self->f->injectSmallBytes(self, 0, NULL), NULL); 7484 terminateO(self); 7485 7486 } 7487 7488 7489 void injectSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 7490 7491 smallArrayt* r; 7492 smallArrayt *self = allocG(rtSmallArrayt); 7493 smallDoublet *toInject; 7494 7495 // add elements to self 7496 r = self->f->pushInt(self, 1); 7497 ck_assert_ptr_ne(r, null); 7498 r = self->f->pushInt(self, 2); 7499 ck_assert_ptr_ne(r, null); 7500 r = self->f->pushInt(self, 3); 7501 ck_assert_ptr_ne(r, null); 7502 r = self->f->pushInt(self, 4); 7503 ck_assert_ptr_ne(r, null); 7504 7505 // positive index 7506 toInject = allocSmallDouble(2); 7507 r = self->f->injectSmallDouble(self, 1, toInject); 7508 ck_assert_ptr_ne(r, null); 7509 finishO(toInject); 7510 char *s = toStringO(r); 7511 ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4]"); 7512 free(s); 7513 // negative index 7514 toInject = allocSmallDouble(3); 7515 r = self->f->injectSmallDouble(self,-1, toInject); 7516 ck_assert_ptr_ne(r, null); 7517 finishO(toInject); 7518 s = toStringO(r); 7519 ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4,3.000000e+00]"); 7520 free(s); 7521 // index 0 7522 toInject = allocSmallDouble(1); 7523 r = self->f->injectSmallDouble(self,0, toInject); 7524 ck_assert_ptr_ne(r, null); 7525 finishO(toInject); 7526 s = toStringO(r); 7527 ck_assert_str_eq(s, "[1.000000e+00,1,2.000000e+00,2,3,4,3.000000e+00]"); 7528 free(s); 7529 // index outside 7530 toInject = allocSmallDouble(1); 7531 ck_assert_ptr_eq(self->f->injectSmallDouble(self, 20, toInject), NULL); 7532 ck_assert_ptr_eq(self->f->injectSmallDouble(self, -9, toInject), NULL); 7533 terminateO(toInject); 7534 // empty object 7535 emptyO(self); 7536 toInject = allocSmallDouble(1); 7537 freeO(toInject); 7538 ck_assert_ptr_ne(self->f->injectSmallDouble(self, 0, toInject), NULL); 7539 finishO(toInject); 7540 s = toStringO(r); 7541 ck_assert_str_eq(s, "[0.000000e+00]"); 7542 free(s); 7543 // empty list 7544 emptyO(self); 7545 toInject = allocSmallDouble(1); 7546 ck_assert_ptr_ne(self->f->injectSmallDouble(self, 0, toInject), NULL); 7547 finishO(toInject); 7548 s = toStringO(r); 7549 ck_assert_str_eq(s, "[1.000000e+00]"); 7550 free(s); 7551 emptyO(self); 7552 toInject = allocSmallDouble(1); 7553 ck_assert_ptr_ne(self->f->injectSmallDouble(self, -1, toInject), NULL); 7554 finishO(toInject); 7555 s = toStringO(r); 7556 ck_assert_str_eq(s, "[1.000000e+00]"); 7557 free(s); 7558 // non smallDouble object 7559 toInject = (smallDoublet*) allocSmallInt(2); 7560 r = self->f->injectSmallDouble(self, 0, toInject); 7561 ck_assert_ptr_eq(r, null); 7562 terminateO(toInject); 7563 // null toInsert 7564 ck_assert_ptr_eq(self->f->injectSmallDouble(self, 0, NULL), NULL); 7565 terminateO(self); 7566 7567 } 7568 7569 7570 void injectSmallIntSmallArrayT(CuTest *tc UNUSED) { 7571 7572 smallArrayt* r; 7573 smallArrayt *self = allocG(rtSmallArrayt); 7574 smallIntt *toInject; 7575 7576 // add elements to self 7577 r = self->f->pushInt(self, 1); 7578 ck_assert_ptr_ne(r, null); 7579 r = self->f->pushInt(self, 2); 7580 ck_assert_ptr_ne(r, null); 7581 r = self->f->pushInt(self, 3); 7582 ck_assert_ptr_ne(r, null); 7583 r = self->f->pushInt(self, 4); 7584 ck_assert_ptr_ne(r, null); 7585 7586 // positive index 7587 toInject = allocSmallInt(10); 7588 r = self->f->injectSmallInt(self, 1, toInject); 7589 ck_assert_ptr_ne(r, null); 7590 finishO(toInject); 7591 char *s = toStringO(r); 7592 ck_assert_str_eq(s, "[1,10,2,3,4]"); 7593 free(s); 7594 // negative index 7595 toInject = allocSmallInt(11); 7596 r = self->f->injectSmallInt(self,-1, toInject); 7597 ck_assert_ptr_ne(r, null); 7598 finishO(toInject); 7599 s = toStringO(r); 7600 ck_assert_str_eq(s, "[1,10,2,3,4,11]"); 7601 free(s); 7602 // index 0 7603 toInject = allocSmallInt(12); 7604 r = self->f->injectSmallInt(self,0, toInject); 7605 ck_assert_ptr_ne(r, null); 7606 finishO(toInject); 7607 s = toStringO(r); 7608 ck_assert_str_eq(s, "[12,1,10,2,3,4,11]"); 7609 free(s); 7610 // index outside 7611 toInject = allocSmallInt(10); 7612 ck_assert_ptr_eq(self->f->injectSmallInt(self, 20, toInject), NULL); 7613 ck_assert_ptr_eq(self->f->injectSmallInt(self, -9, toInject), NULL); 7614 terminateO(toInject); 7615 // empty object 7616 emptyO(self); 7617 toInject = allocSmallInt(10); 7618 freeO(toInject); 7619 ck_assert_ptr_ne(self->f->injectSmallInt(self, 0, toInject), NULL); 7620 finishO(toInject); 7621 s = toStringO(r); 7622 ck_assert_str_eq(s, "[0]"); 7623 free(s); 7624 // empty list 7625 emptyO(self); 7626 toInject = allocSmallInt(10); 7627 ck_assert_ptr_ne(self->f->injectSmallInt(self, 0, toInject), NULL); 7628 finishO(toInject); 7629 s = toStringO(r); 7630 ck_assert_str_eq(s, "[10]"); 7631 free(s); 7632 emptyO(self); 7633 toInject = allocSmallInt(10); 7634 ck_assert_ptr_ne(self->f->injectSmallInt(self, -1, toInject), NULL); 7635 finishO(toInject); 7636 s = toStringO(r); 7637 ck_assert_str_eq(s, "[10]"); 7638 free(s); 7639 // non smallInt object 7640 toInject = (smallIntt*) allocSmallBool(true); 7641 r = self->f->injectSmallInt(self, 0, toInject); 7642 ck_assert_ptr_eq(r, null); 7643 terminateO(toInject); 7644 // null toInsert 7645 ck_assert_ptr_eq(self->f->injectSmallInt(self, 0, NULL), NULL); 7646 terminateO(self); 7647 7648 } 7649 7650 7651 void injectSmallJsonSmallArrayT(CuTest *tc UNUSED) { 7652 7653 smallArrayt* r; 7654 smallArrayt *self = allocG(rtSmallArrayt); 7655 smallJsont *toInject; 7656 7657 // add elements to self 7658 r = self->f->pushInt(self, 1); 7659 ck_assert_ptr_ne(r, null); 7660 r = self->f->pushInt(self, 2); 7661 ck_assert_ptr_ne(r, null); 7662 r = self->f->pushInt(self, 3); 7663 ck_assert_ptr_ne(r, null); 7664 r = self->f->pushInt(self, 4); 7665 ck_assert_ptr_ne(r, null); 7666 7667 // positive index 7668 toInject = allocSmallJson(); 7669 r = self->f->injectSmallJson(self, 1, toInject); 7670 ck_assert_ptr_ne(r, null); 7671 finishO(toInject); 7672 char *s = toStringO(r); 7673 ck_assert_str_eq(s, "[1,{},2,3,4]"); 7674 free(s); 7675 // negative index 7676 toInject = allocSmallJson(); 7677 r = self->f->injectSmallJson(self,-1, toInject); 7678 ck_assert_ptr_ne(r, null); 7679 finishO(toInject); 7680 s = toStringO(r); 7681 ck_assert_str_eq(s, "[1,{},2,3,4,{}]"); 7682 free(s); 7683 // index 0 7684 toInject = allocSmallJson(); 7685 toInject->f->setS(toInject, "key", "value"); 7686 r = self->f->injectSmallJson(self,0, toInject); 7687 ck_assert_ptr_ne(r, null); 7688 finishO(toInject); 7689 s = toStringO(r); 7690 ck_assert_str_eq(s, "[{\"key\":\"value\"},1,{},2,3,4,{}]"); 7691 free(s); 7692 // index outside 7693 toInject = allocSmallJson(); 7694 ck_assert_ptr_eq(self->f->injectSmallJson(self, 20, toInject), NULL); 7695 ck_assert_ptr_eq(self->f->injectSmallJson(self, -9, toInject), NULL); 7696 terminateO(toInject); 7697 // empty object 7698 emptyO(self); 7699 toInject = allocSmallJson(); 7700 freeO(toInject); 7701 ck_assert_ptr_ne(self->f->injectSmallJson(self, 0, toInject), NULL); 7702 finishO(toInject); 7703 s = toStringO(r); 7704 ck_assert_str_eq(s, "[{}]"); 7705 free(s); 7706 // empty list 7707 emptyO(self); 7708 toInject = allocSmallJson(); 7709 ck_assert_ptr_ne(self->f->injectSmallJson(self, 0, toInject), NULL); 7710 finishO(toInject); 7711 s = toStringO(r); 7712 ck_assert_str_eq(s, "[{}]"); 7713 free(s); 7714 emptyO(self); 7715 toInject = allocSmallJson(); 7716 ck_assert_ptr_ne(self->f->injectSmallJson(self, -1, toInject), NULL); 7717 finishO(toInject); 7718 s = toStringO(r); 7719 ck_assert_str_eq(s, "[{}]"); 7720 free(s); 7721 // non smallJson object 7722 toInject = (smallJsont*) allocSmallInt(2); 7723 r = self->f->injectSmallJson(self, 0, toInject); 7724 ck_assert_ptr_eq(r, null); 7725 terminateO(toInject); 7726 // null toInsert 7727 ck_assert_ptr_eq(self->f->injectSmallJson(self, 0, NULL), NULL); 7728 terminateO(self); 7729 7730 } 7731 7732 7733 void injectSmallStringSmallArrayT(CuTest *tc UNUSED) { 7734 7735 smallArrayt* r; 7736 smallArrayt *self = allocG(rtSmallArrayt); 7737 smallStringt *toInject; 7738 7739 // add elements to self 7740 r = self->f->pushInt(self, 1); 7741 ck_assert_ptr_ne(r, null); 7742 r = self->f->pushInt(self, 2); 7743 ck_assert_ptr_ne(r, null); 7744 r = self->f->pushInt(self, 3); 7745 ck_assert_ptr_ne(r, null); 7746 r = self->f->pushInt(self, 4); 7747 ck_assert_ptr_ne(r, null); 7748 7749 // positive index 7750 toInject = allocSmallString("1"); 7751 r = self->f->injectSmallString(self, 1, toInject); 7752 ck_assert_ptr_ne(r, null); 7753 finishO(toInject); 7754 char *s = toStringO(r); 7755 ck_assert_str_eq(s, "[1,\"1\",2,3,4]"); 7756 free(s); 7757 // negative index 7758 toInject = allocSmallString("2"); 7759 r = self->f->injectSmallString(self,-1, toInject); 7760 ck_assert_ptr_ne(r, null); 7761 finishO(toInject); 7762 s = toStringO(r); 7763 ck_assert_str_eq(s, "[1,\"1\",2,3,4,\"2\"]"); 7764 free(s); 7765 // index 0 7766 toInject = allocSmallString("3"); 7767 r = self->f->injectSmallString(self,0, toInject); 7768 ck_assert_ptr_ne(r, null); 7769 finishO(toInject); 7770 s = toStringO(r); 7771 ck_assert_str_eq(s, "[\"3\",1,\"1\",2,3,4,\"2\"]"); 7772 free(s); 7773 // index outside 7774 toInject = allocSmallString("1"); 7775 ck_assert_ptr_eq(self->f->injectSmallString(self, 20, toInject), NULL); 7776 ck_assert_ptr_eq(self->f->injectSmallString(self, -9, toInject), NULL); 7777 terminateO(toInject); 7778 // empty object 7779 emptyO(self); 7780 toInject = allocSmallString("1"); 7781 freeO(toInject); 7782 ck_assert_ptr_ne(self->f->injectSmallString(self, 0, toInject), NULL); 7783 finishO(toInject); 7784 s = toStringO(r); 7785 ck_assert_str_eq(s, "[\"\"]"); 7786 free(s); 7787 // empty list 7788 emptyO(self); 7789 toInject = allocSmallString("1"); 7790 ck_assert_ptr_ne(self->f->injectSmallString(self, 0, toInject), NULL); 7791 finishO(toInject); 7792 s = toStringO(r); 7793 ck_assert_str_eq(s, "[\"1\"]"); 7794 free(s); 7795 emptyO(self); 7796 toInject = allocSmallString("1"); 7797 ck_assert_ptr_ne(self->f->injectSmallString(self, -1, toInject), NULL); 7798 finishO(toInject); 7799 s = toStringO(r); 7800 ck_assert_str_eq(s, "[\"1\"]"); 7801 free(s); 7802 // non smallString object 7803 toInject = (smallStringt*) allocSmallInt(2); 7804 r = self->f->injectSmallString(self, 0, toInject); 7805 ck_assert_ptr_eq(r, null); 7806 terminateO(toInject); 7807 // null toInsert 7808 ck_assert_ptr_eq(self->f->injectSmallString(self, 0, NULL), NULL); 7809 terminateO(self); 7810 7811 } 7812 7813 7814 void injectSmallContainerSmallArrayT(CuTest *tc UNUSED) { 7815 7816 smallArrayt* r; 7817 smallArrayt *self = allocG(rtSmallArrayt); 7818 smallContainert *toInject; 7819 7820 // add elements to self 7821 r = self->f->pushInt(self, 1); 7822 ck_assert_ptr_ne(r, null); 7823 r = self->f->pushInt(self, 2); 7824 ck_assert_ptr_ne(r, null); 7825 r = self->f->pushInt(self, 3); 7826 ck_assert_ptr_ne(r, null); 7827 r = self->f->pushInt(self, 4); 7828 ck_assert_ptr_ne(r, null); 7829 7830 // positive index 7831 toInject = allocSmallContainer(NULL); 7832 r = self->f->injectSmallContainer(self, 1, toInject); 7833 ck_assert_ptr_ne(r, null); 7834 finishO(toInject); 7835 char *s = toStringO(r); 7836 ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4]"); 7837 free(s); 7838 // negative index 7839 toInject = allocSmallContainer(NULL); 7840 r = self->f->injectSmallContainer(self,-1, toInject); 7841 ck_assert_ptr_ne(r, null); 7842 finishO(toInject); 7843 s = toStringO(r); 7844 ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4,\"<data container>\"]"); 7845 free(s); 7846 // index 0 7847 toInject = allocSmallContainer(NULL); 7848 r = self->f->injectSmallContainer(self,0, toInject); 7849 ck_assert_ptr_ne(r, null); 7850 finishO(toInject); 7851 s = toStringO(r); 7852 ck_assert_str_eq(s, "[\"<data container>\",1,\"<data container>\",2,3,4,\"<data container>\"]"); 7853 free(s); 7854 // index outside 7855 toInject = allocSmallContainer(NULL); 7856 ck_assert_ptr_eq(self->f->injectSmallContainer(self, 20, toInject), NULL); 7857 ck_assert_ptr_eq(self->f->injectSmallContainer(self, -9, toInject), NULL); 7858 terminateO(toInject); 7859 // empty object 7860 emptyO(self); 7861 toInject = allocSmallContainer(NULL); 7862 freeO(toInject); 7863 ck_assert_ptr_ne(self->f->injectSmallContainer(self, 0, toInject), NULL); 7864 finishO(toInject); 7865 s = toStringO(r); 7866 ck_assert_str_eq(s, "[\"<data container>\"]"); 7867 free(s); 7868 // empty list 7869 emptyO(self); 7870 toInject = allocSmallContainer(NULL); 7871 ck_assert_ptr_ne(self->f->injectSmallContainer(self, 0, toInject), NULL); 7872 finishO(toInject); 7873 s = toStringO(r); 7874 ck_assert_str_eq(s, "[\"<data container>\"]"); 7875 free(s); 7876 emptyO(self); 7877 toInject = allocSmallContainer(NULL); 7878 ck_assert_ptr_ne(self->f->injectSmallContainer(self, -1, toInject), NULL); 7879 finishO(toInject); 7880 s = toStringO(r); 7881 ck_assert_str_eq(s, "[\"<data container>\"]"); 7882 free(s); 7883 // non smallContainer object 7884 toInject = (smallContainert*) allocSmallInt(2); 7885 r = self->f->injectSmallContainer(self, 0, toInject); 7886 ck_assert_ptr_eq(r, null); 7887 terminateO(toInject); 7888 // null toInsert 7889 ck_assert_ptr_eq(self->f->injectSmallContainer(self, 0, NULL), NULL); 7890 terminateO(self); 7891 7892 } 7893 7894 7895 void injectNFreeSmallArrayT(CuTest *tc UNUSED) { 7896 7897 smallArrayt* r; 7898 smallArrayt *self = allocG(rtSmallArrayt); 7899 baset *toInject; 7900 7901 // add elements to self 7902 r = self->f->pushInt(self, 1); 7903 ck_assert_ptr_ne(r, null); 7904 r = self->f->pushInt(self, 2); 7905 ck_assert_ptr_ne(r, null); 7906 r = self->f->pushInt(self, 3); 7907 ck_assert_ptr_ne(r, null); 7908 r = self->f->pushInt(self, 4); 7909 ck_assert_ptr_ne(r, null); 7910 7911 // positive index 7912 toInject = (baset*) allocSmallInt(8); 7913 r = self->f->injectNFree(self, 1, toInject); 7914 ck_assert_ptr_ne(r, null); 7915 char *s = toStringO(r); 7916 ck_assert_str_eq(s, "[1,8,2,3,4]"); 7917 free(s); 7918 // negative index 7919 toInject = (baset*) allocSmallInt(9); 7920 r = self->f->injectNFree(self,-1, toInject); 7921 ck_assert_ptr_ne(r, null); 7922 s = toStringO(r); 7923 ck_assert_str_eq(s, "[1,8,2,3,4,9]"); 7924 free(s); 7925 // index 0 7926 toInject = (baset*) allocSmallInt(6); 7927 r = self->f->injectNFree(self,0, toInject); 7928 ck_assert_ptr_ne(r, null); 7929 s = toStringO(r); 7930 ck_assert_str_eq(s, "[6,1,8,2,3,4,9]"); 7931 free(s); 7932 // index outside 7933 toInject = (baset*) allocSmallInt(7); 7934 ck_assert_ptr_eq(self->f->injectNFree(self, 20, toInject), NULL); 7935 ck_assert_ptr_eq(self->f->injectNFree(self, -9, toInject), NULL); 7936 terminateO(toInject); 7937 // empty list 7938 emptyO(self); 7939 toInject = (baset*) allocSmallInt(7); 7940 ck_assert_ptr_ne(self->f->injectNFree(self, 0, toInject), NULL); 7941 s = toStringO(r); 7942 ck_assert_str_eq(s, "[7]"); 7943 free(s); 7944 emptyO(self); 7945 toInject = (baset*) allocSmallInt(7); 7946 ck_assert_ptr_ne(self->f->injectNFree(self, -1, toInject), NULL); 7947 s = toStringO(r); 7948 ck_assert_str_eq(s, "[7]"); 7949 free(s); 7950 // null toInsert 7951 ck_assert_ptr_eq(self->f->injectNFree(self, 0, NULL), NULL); 7952 terminateO(self); 7953 7954 } 7955 7956 7957 void injectNFreeUndefinedSmallArrayT(CuTest *tc UNUSED) { 7958 7959 smallArrayt* r; 7960 smallArrayt *self = allocG(rtSmallArrayt); 7961 undefinedt *value = NULL; 7962 7963 7964 // add elements to self 7965 r = self->f->pushInt(self, 1); 7966 ck_assert_ptr_ne(r, null); 7967 r = self->f->pushInt(self, 2); 7968 ck_assert_ptr_ne(r, null); 7969 r = self->f->pushInt(self, 3); 7970 ck_assert_ptr_ne(r, null); 7971 r = self->f->pushInt(self, 4); 7972 ck_assert_ptr_ne(r, null); 7973 7974 // positive index 7975 value = allocUndefined(); 7976 r = self->f->injectNFreeUndefined(self, 1, value); 7977 ck_assert_ptr_ne(r, null); 7978 char *s = toStringO(r); 7979 ck_assert_str_eq(s, "[1,null,2,3,4]"); 7980 free(s); 7981 // negative index 7982 value = allocUndefined(); 7983 r = self->f->injectNFreeUndefined(self,-1, value); 7984 ck_assert_ptr_ne(r, null); 7985 s = toStringO(r); 7986 ck_assert_str_eq(s, "[1,null,2,3,4,null]"); 7987 free(s); 7988 // index 0 7989 value = allocUndefined(); 7990 r = self->f->injectNFreeUndefined(self,0, value); 7991 ck_assert_ptr_ne(r, null); 7992 s = toStringO(r); 7993 ck_assert_str_eq(s, "[null,1,null,2,3,4,null]"); 7994 free(s); 7995 // index outside 7996 value = allocUndefined(); 7997 ck_assert_ptr_eq(self->f->injectNFreeUndefined(self, 20, value), NULL); 7998 terminateO(value); 7999 8000 value = allocUndefined(); 8001 ck_assert_ptr_eq(self->f->injectNFreeUndefined(self, -9, value), NULL); 8002 terminateO(value); 8003 8004 // empty list 8005 emptyO(self); 8006 value = allocUndefined(); 8007 ck_assert_ptr_ne(self->f->injectNFreeUndefined(self, 0, value), NULL); 8008 s = toStringO(r); 8009 ck_assert_str_eq(s, "[null]"); 8010 free(s); 8011 emptyO(self); 8012 value = allocUndefined(); 8013 ck_assert_ptr_ne(self->f->injectNFreeUndefined(self, -1, value), NULL); 8014 s = toStringO(r); 8015 ck_assert_str_eq(s, "[null]"); 8016 free(s); 8017 terminateO(self); 8018 8019 } 8020 8021 8022 void injectNFreeSSmallArrayT(CuTest *tc UNUSED) { 8023 8024 smallArrayt* r; 8025 smallArrayt *self = allocG(rtSmallArrayt); 8026 8027 // add elements to self 8028 r = self->f->pushInt(self, 1); 8029 ck_assert_ptr_ne(r, null); 8030 r = self->f->pushInt(self, 2); 8031 ck_assert_ptr_ne(r, null); 8032 r = self->f->pushInt(self, 3); 8033 ck_assert_ptr_ne(r, null); 8034 r = self->f->pushInt(self, 4); 8035 ck_assert_ptr_ne(r, null); 8036 8037 // positive index 8038 r = self->f->injectNFreeS(self, 1, strdup("5")); 8039 ck_assert_ptr_ne(r, null); 8040 char *s = toStringO(r); 8041 ck_assert_str_eq(s, "[1,\"5\",2,3,4]"); 8042 free(s); 8043 // negative index 8044 r = self->f->injectNFreeS(self,-1, strdup("6")); 8045 ck_assert_ptr_ne(r, null); 8046 s = toStringO(r); 8047 ck_assert_str_eq(s, "[1,\"5\",2,3,4,\"6\"]"); 8048 free(s); 8049 // index 0 8050 r = self->f->injectNFreeS(self,0, strdup("7")); 8051 ck_assert_ptr_ne(r, null); 8052 s = toStringO(r); 8053 ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]"); 8054 free(s); 8055 // index outside 8056 ck_assert_ptr_eq(self->f->injectNFreeS(self, 20, ""), NULL); 8057 ck_assert_ptr_eq(self->f->injectNFreeS(self, -9, ""), NULL); 8058 // empty list 8059 emptyO(self); 8060 ck_assert_ptr_ne(self->f->injectNFreeS(self, 0, strdup("7")), NULL); 8061 s = toStringO(r); 8062 ck_assert_str_eq(s, "[\"7\"]"); 8063 free(s); 8064 emptyO(self); 8065 ck_assert_ptr_ne(self->f->injectNFreeS(self, -1, strdup("7")), NULL); 8066 s = toStringO(r); 8067 ck_assert_str_eq(s, "[\"7\"]"); 8068 free(s); 8069 terminateO(self); 8070 8071 } 8072 8073 8074 void injectNFreeDictSmallArrayT(CuTest *tc UNUSED) { 8075 8076 smallArrayt* r; 8077 smallArrayt *self = allocG(rtSmallArrayt); 8078 smallDictt *toInject; 8079 8080 // add elements to self 8081 r = self->f->pushInt(self, 1); 8082 ck_assert_ptr_ne(r, null); 8083 r = self->f->pushInt(self, 2); 8084 ck_assert_ptr_ne(r, null); 8085 r = self->f->pushInt(self, 3); 8086 ck_assert_ptr_ne(r, null); 8087 r = self->f->pushInt(self, 4); 8088 ck_assert_ptr_ne(r, null); 8089 8090 // positive index 8091 toInject = allocSmallDict(); 8092 r = self->f->injectNFreeDict(self, 1, toInject); 8093 ck_assert_ptr_ne(r, null); 8094 char *s = toStringO(r); 8095 ck_assert_str_eq(s, "[1,{},2,3,4]"); 8096 free(s); 8097 // negative index 8098 toInject = allocSmallDict(); 8099 r = self->f->injectNFreeDict(self,-1, toInject); 8100 ck_assert_ptr_ne(r, null); 8101 s = toStringO(r); 8102 ck_assert_str_eq(s, "[1,{},2,3,4,{}]"); 8103 free(s); 8104 // index 0 8105 toInject = allocSmallDict(); 8106 r = self->f->injectNFreeDict(self,0, toInject); 8107 ck_assert_ptr_ne(r, null); 8108 s = toStringO(r); 8109 ck_assert_str_eq(s, "[{},1,{},2,3,4,{}]"); 8110 free(s); 8111 // index outside 8112 toInject = allocSmallDict(); 8113 ck_assert_ptr_eq(self->f->injectNFreeDict(self, 20, toInject), NULL); 8114 ck_assert_ptr_eq(self->f->injectNFreeDict(self, -9, toInject), NULL); 8115 terminateO(toInject); 8116 // empty list 8117 emptyO(self); 8118 toInject = allocSmallDict(); 8119 ck_assert_ptr_ne(self->f->injectNFreeDict(self, 0, toInject), NULL); 8120 s = toStringO(r); 8121 ck_assert_str_eq(s, "[{}]"); 8122 free(s); 8123 emptyO(self); 8124 toInject = allocSmallDict(); 8125 ck_assert_ptr_ne(self->f->injectNFreeDict(self, -1, toInject), NULL); 8126 s = toStringO(r); 8127 ck_assert_str_eq(s, "[{}]"); 8128 free(s); 8129 // null toInsert 8130 ck_assert_ptr_eq(self->f->injectNFreeDict(self, 0, NULL), NULL); 8131 terminateO(self); 8132 8133 } 8134 8135 8136 void injectNFreeArraySmallArrayT(CuTest *tc UNUSED) { 8137 8138 smallArrayt* r; 8139 smallArrayt *self = allocG(rtSmallArrayt); 8140 smallArrayt *toInject; 8141 8142 // add elements to self 8143 r = self->f->pushInt(self, 1); 8144 ck_assert_ptr_ne(r, null); 8145 r = self->f->pushInt(self, 2); 8146 ck_assert_ptr_ne(r, null); 8147 r = self->f->pushInt(self, 3); 8148 ck_assert_ptr_ne(r, null); 8149 r = self->f->pushInt(self, 4); 8150 ck_assert_ptr_ne(r, null); 8151 8152 // positive index 8153 toInject = allocSmallArray(); 8154 r = self->f->injectNFreeArray(self, 1, toInject); 8155 ck_assert_ptr_ne(r, null); 8156 char *s = toStringO(r); 8157 ck_assert_str_eq(s, "[1,[],2,3,4]"); 8158 free(s); 8159 // negative index 8160 toInject = allocSmallArray(); 8161 r = self->f->injectNFreeArray(self,-1, toInject); 8162 ck_assert_ptr_ne(r, null); 8163 s = toStringO(r); 8164 ck_assert_str_eq(s, "[1,[],2,3,4,[]]"); 8165 free(s); 8166 // index 0 8167 toInject = allocSmallArray(); 8168 r = self->f->injectNFreeArray(self,0, toInject); 8169 ck_assert_ptr_ne(r, null); 8170 s = toStringO(r); 8171 ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]"); 8172 free(s); 8173 // index outside 8174 toInject = allocSmallArray(); 8175 ck_assert_ptr_eq(self->f->injectNFreeArray(self, 20, toInject), NULL); 8176 ck_assert_ptr_eq(self->f->injectNFreeArray(self, -9, toInject), NULL); 8177 terminateO(toInject); 8178 // empty list 8179 emptyO(self); 8180 toInject = allocSmallArray(); 8181 ck_assert_ptr_ne(self->f->injectNFreeArray(self, 0, toInject), NULL); 8182 s = toStringO(r); 8183 ck_assert_str_eq(s, "[[]]"); 8184 free(s); 8185 emptyO(self); 8186 toInject = allocSmallArray(); 8187 ck_assert_ptr_ne(self->f->injectNFreeArray(self, -1, toInject), NULL); 8188 s = toStringO(r); 8189 ck_assert_str_eq(s, "[[]]"); 8190 free(s); 8191 // null toInsert 8192 ck_assert_ptr_eq(self->f->injectNFreeArray(self, 0, NULL), NULL); 8193 terminateO(self); 8194 8195 } 8196 8197 8198 void injectNFreeArraycSmallArrayT(CuTest *tc UNUSED) { 8199 8200 smallArrayt* r; 8201 smallArrayt *self = allocG(rtSmallArrayt); 8202 char **toInject; 8203 8204 // add elements to self 8205 r = self->f->pushInt(self, 1); 8206 ck_assert_ptr_ne(r, null); 8207 r = self->f->pushInt(self, 2); 8208 ck_assert_ptr_ne(r, null); 8209 r = self->f->pushInt(self, 3); 8210 ck_assert_ptr_ne(r, null); 8211 r = self->f->pushInt(self, 4); 8212 ck_assert_ptr_ne(r, null); 8213 8214 // positive index 8215 toInject = listCreateS("a","b"); 8216 r = self->f->injectNFreeArrayc(self, 1, toInject); 8217 ck_assert_ptr_ne(r, null); 8218 char *s = toStringO(r); 8219 ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4]"); 8220 free(s); 8221 // negative index 8222 toInject = listCreateS("c","d"); 8223 r = self->f->injectNFreeArrayc(self,-1, toInject); 8224 ck_assert_ptr_ne(r, null); 8225 s = toStringO(r); 8226 ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]"); 8227 free(s); 8228 // index 0 8229 toInject = listCreateS("e","ff"); 8230 r = self->f->injectNFreeArrayc(self,0, toInject); 8231 ck_assert_ptr_ne(r, null); 8232 s = toStringO(r); 8233 ck_assert_str_eq(s, "[[\"e\",\"ff\"],1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]"); 8234 free(s); 8235 // index outside 8236 toInject = listCreateS("a","b"); 8237 ck_assert_ptr_eq(self->f->injectNFreeArrayc(self, 20, toInject), NULL); 8238 ck_assert_ptr_eq(self->f->injectNFreeArrayc(self, -9, toInject), NULL); 8239 listFreeS(toInject); 8240 // empty list 8241 emptyO(self); 8242 toInject = listCreateS("a","b"); 8243 ck_assert_ptr_ne(self->f->injectNFreeArrayc(self, 0, toInject), NULL); 8244 s = toStringO(r); 8245 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 8246 free(s); 8247 emptyO(self); 8248 toInject = listCreateS("a","b"); 8249 ck_assert_ptr_ne(self->f->injectNFreeArrayc(self, -1, toInject), NULL); 8250 s = toStringO(r); 8251 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 8252 free(s); 8253 // null toInsert 8254 ck_assert_ptr_eq(self->f->injectNFreeArrayc(self, 0, NULL), NULL); 8255 terminateO(self); 8256 8257 } 8258 8259 8260 void injectNFreeSmallBoolSmallArrayT(CuTest *tc UNUSED) { 8261 8262 smallArrayt* r; 8263 smallArrayt *self = allocG(rtSmallArrayt); 8264 smallBoolt *toInject; 8265 8266 // add elements to self 8267 r = self->f->pushInt(self, 1); 8268 ck_assert_ptr_ne(r, null); 8269 r = self->f->pushInt(self, 2); 8270 ck_assert_ptr_ne(r, null); 8271 r = self->f->pushInt(self, 3); 8272 ck_assert_ptr_ne(r, null); 8273 r = self->f->pushInt(self, 4); 8274 ck_assert_ptr_ne(r, null); 8275 8276 // positive index 8277 toInject = allocSmallBool(true); 8278 r = self->f->injectNFreeSmallBool(self, 1, toInject); 8279 ck_assert_ptr_ne(r, null); 8280 char *s = toStringO(r); 8281 ck_assert_str_eq(s, "[1,true,2,3,4]"); 8282 free(s); 8283 // negative index 8284 toInject = allocSmallBool(true); 8285 r = self->f->injectNFreeSmallBool(self,-1, toInject); 8286 ck_assert_ptr_ne(r, null); 8287 s = toStringO(r); 8288 ck_assert_str_eq(s, "[1,true,2,3,4,true]"); 8289 free(s); 8290 // index 0 8291 toInject = allocSmallBool(true); 8292 r = self->f->injectNFreeSmallBool(self,0, toInject); 8293 ck_assert_ptr_ne(r, null); 8294 s = toStringO(r); 8295 ck_assert_str_eq(s, "[true,1,true,2,3,4,true]"); 8296 free(s); 8297 // index outside 8298 toInject = allocSmallBool(true); 8299 ck_assert_ptr_eq(self->f->injectNFreeSmallBool(self, 20, toInject), NULL); 8300 ck_assert_ptr_eq(self->f->injectNFreeSmallBool(self, -9, toInject), NULL); 8301 terminateO(toInject); 8302 // empty object 8303 emptyO(self); 8304 toInject = allocSmallBool(true); 8305 freeO(toInject); 8306 ck_assert_ptr_ne(self->f->injectNFreeSmallBool(self, 0, toInject), NULL); 8307 s = toStringO(r); 8308 ck_assert_str_eq(s, "[false]"); 8309 free(s); 8310 // empty list 8311 emptyO(self); 8312 toInject = allocSmallBool(true); 8313 ck_assert_ptr_ne(self->f->injectNFreeSmallBool(self, 0, toInject), NULL); 8314 s = toStringO(r); 8315 ck_assert_str_eq(s, "[true]"); 8316 free(s); 8317 emptyO(self); 8318 toInject = allocSmallBool(true); 8319 ck_assert_ptr_ne(self->f->injectNFreeSmallBool(self, -1, toInject), NULL); 8320 s = toStringO(r); 8321 ck_assert_str_eq(s, "[true]"); 8322 free(s); 8323 // null toInsert 8324 ck_assert_ptr_eq(self->f->injectNFreeSmallBool(self, 0, NULL), NULL); 8325 terminateO(self); 8326 8327 } 8328 8329 8330 void injectNFreeSmallBytesSmallArrayT(CuTest *tc UNUSED) { 8331 8332 smallArrayt* r; 8333 smallArrayt *self = allocG(rtSmallArrayt); 8334 smallBytest *toInject; 8335 8336 // add elements to self 8337 r = self->f->pushInt(self, 1); 8338 ck_assert_ptr_ne(r, null); 8339 r = self->f->pushInt(self, 2); 8340 ck_assert_ptr_ne(r, null); 8341 r = self->f->pushInt(self, 3); 8342 ck_assert_ptr_ne(r, null); 8343 r = self->f->pushInt(self, 4); 8344 ck_assert_ptr_ne(r, null); 8345 8346 // positive index 8347 toInject = allocSmallBytes(null, 0); 8348 r = self->f->injectNFreeSmallBytes(self, 1, toInject); 8349 ck_assert_ptr_ne(r, null); 8350 char *s = toStringO(r); 8351 ck_assert_str_eq(s, "[1,[],2,3,4]"); 8352 free(s); 8353 // negative index 8354 toInject = allocSmallBytes(null, 0); 8355 r = self->f->injectNFreeSmallBytes(self,-1, toInject); 8356 ck_assert_ptr_ne(r, null); 8357 s = toStringO(r); 8358 ck_assert_str_eq(s, "[1,[],2,3,4,[]]"); 8359 free(s); 8360 // index 0 8361 toInject = allocSmallBytes(null, 0); 8362 r = self->f->injectNFreeSmallBytes(self,0, toInject); 8363 ck_assert_ptr_ne(r, null); 8364 s = toStringO(r); 8365 ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]"); 8366 free(s); 8367 // index outside 8368 toInject = allocSmallBytes(null, 0); 8369 ck_assert_ptr_eq(self->f->injectNFreeSmallBytes(self, 20, toInject), NULL); 8370 ck_assert_ptr_eq(self->f->injectNFreeSmallBytes(self, -9, toInject), NULL); 8371 terminateO(toInject); 8372 // empty object 8373 emptyO(self); 8374 toInject = allocSmallBytes(null, 0); 8375 freeO(toInject); 8376 ck_assert_ptr_ne(self->f->injectNFreeSmallBytes(self, 0, toInject), NULL); 8377 s = toStringO(r); 8378 ck_assert_str_eq(s, "[[]]"); 8379 free(s); 8380 // empty list 8381 emptyO(self); 8382 toInject = allocSmallBytes(null, 0); 8383 ck_assert_ptr_ne(self->f->injectNFreeSmallBytes(self, 0, toInject), NULL); 8384 s = toStringO(r); 8385 ck_assert_str_eq(s, "[[]]"); 8386 free(s); 8387 emptyO(self); 8388 toInject = allocSmallBytes(null, 0); 8389 ck_assert_ptr_ne(self->f->injectNFreeSmallBytes(self, -1, toInject), NULL); 8390 s = toStringO(r); 8391 ck_assert_str_eq(s, "[[]]"); 8392 free(s); 8393 // null toInsert 8394 ck_assert_ptr_eq(self->f->injectNFreeSmallBytes(self, 0, NULL), NULL); 8395 terminateO(self); 8396 8397 } 8398 8399 8400 void injectNFreeSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 8401 8402 smallArrayt* r; 8403 smallArrayt *self = allocG(rtSmallArrayt); 8404 smallDoublet *toInject; 8405 8406 // add elements to self 8407 r = self->f->pushInt(self, 1); 8408 ck_assert_ptr_ne(r, null); 8409 r = self->f->pushInt(self, 2); 8410 ck_assert_ptr_ne(r, null); 8411 r = self->f->pushInt(self, 3); 8412 ck_assert_ptr_ne(r, null); 8413 r = self->f->pushInt(self, 4); 8414 ck_assert_ptr_ne(r, null); 8415 8416 // positive index 8417 toInject = allocSmallDouble(2); 8418 r = self->f->injectNFreeSmallDouble(self, 1, toInject); 8419 ck_assert_ptr_ne(r, null); 8420 char *s = toStringO(r); 8421 ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4]"); 8422 free(s); 8423 // negative index 8424 toInject = allocSmallDouble(3); 8425 r = self->f->injectNFreeSmallDouble(self,-1, toInject); 8426 ck_assert_ptr_ne(r, null); 8427 s = toStringO(r); 8428 ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4,3.000000e+00]"); 8429 free(s); 8430 // index 0 8431 toInject = allocSmallDouble(1); 8432 r = self->f->injectNFreeSmallDouble(self,0, toInject); 8433 ck_assert_ptr_ne(r, null); 8434 s = toStringO(r); 8435 ck_assert_str_eq(s, "[1.000000e+00,1,2.000000e+00,2,3,4,3.000000e+00]"); 8436 free(s); 8437 // index outside 8438 toInject = allocSmallDouble(1); 8439 ck_assert_ptr_eq(self->f->injectNFreeSmallDouble(self, 20, toInject), NULL); 8440 ck_assert_ptr_eq(self->f->injectNFreeSmallDouble(self, -9, toInject), NULL); 8441 terminateO(toInject); 8442 // empty object 8443 emptyO(self); 8444 toInject = allocSmallDouble(1); 8445 freeO(toInject); 8446 ck_assert_ptr_ne(self->f->injectNFreeSmallDouble(self, 0, toInject), NULL); 8447 s = toStringO(r); 8448 ck_assert_str_eq(s, "[0.000000e+00]"); 8449 free(s); 8450 // empty list 8451 emptyO(self); 8452 toInject = allocSmallDouble(1); 8453 ck_assert_ptr_ne(self->f->injectNFreeSmallDouble(self, 0, toInject), NULL); 8454 s = toStringO(r); 8455 ck_assert_str_eq(s, "[1.000000e+00]"); 8456 free(s); 8457 emptyO(self); 8458 toInject = allocSmallDouble(1); 8459 ck_assert_ptr_ne(self->f->injectNFreeSmallDouble(self, -1, toInject), NULL); 8460 s = toStringO(r); 8461 ck_assert_str_eq(s, "[1.000000e+00]"); 8462 free(s); 8463 // null toInsert 8464 ck_assert_ptr_eq(self->f->injectNFreeSmallDouble(self, 0, NULL), NULL); 8465 terminateO(self); 8466 8467 } 8468 8469 8470 void injectNFreeSmallIntSmallArrayT(CuTest *tc UNUSED) { 8471 8472 smallArrayt* r; 8473 smallArrayt *self = allocG(rtSmallArrayt); 8474 smallIntt *toInject; 8475 8476 // add elements to self 8477 r = self->f->pushInt(self, 1); 8478 ck_assert_ptr_ne(r, null); 8479 r = self->f->pushInt(self, 2); 8480 ck_assert_ptr_ne(r, null); 8481 r = self->f->pushInt(self, 3); 8482 ck_assert_ptr_ne(r, null); 8483 r = self->f->pushInt(self, 4); 8484 ck_assert_ptr_ne(r, null); 8485 8486 // positive index 8487 toInject = allocSmallInt(10); 8488 r = self->f->injectNFreeSmallInt(self, 1, toInject); 8489 ck_assert_ptr_ne(r, null); 8490 char *s = toStringO(r); 8491 ck_assert_str_eq(s, "[1,10,2,3,4]"); 8492 free(s); 8493 // negative index 8494 toInject = allocSmallInt(11); 8495 r = self->f->injectNFreeSmallInt(self,-1, toInject); 8496 ck_assert_ptr_ne(r, null); 8497 s = toStringO(r); 8498 ck_assert_str_eq(s, "[1,10,2,3,4,11]"); 8499 free(s); 8500 // index 0 8501 toInject = allocSmallInt(12); 8502 r = self->f->injectNFreeSmallInt(self,0, toInject); 8503 ck_assert_ptr_ne(r, null); 8504 s = toStringO(r); 8505 ck_assert_str_eq(s, "[12,1,10,2,3,4,11]"); 8506 free(s); 8507 // index outside 8508 toInject = allocSmallInt(10); 8509 ck_assert_ptr_eq(self->f->injectNFreeSmallInt(self, 20, toInject), NULL); 8510 ck_assert_ptr_eq(self->f->injectNFreeSmallInt(self, -9, toInject), NULL); 8511 terminateO(toInject); 8512 // empty object 8513 emptyO(self); 8514 toInject = allocSmallInt(10); 8515 freeO(toInject); 8516 ck_assert_ptr_ne(self->f->injectNFreeSmallInt(self, 0, toInject), NULL); 8517 s = toStringO(r); 8518 ck_assert_str_eq(s, "[0]"); 8519 free(s); 8520 // empty list 8521 emptyO(self); 8522 toInject = allocSmallInt(10); 8523 ck_assert_ptr_ne(self->f->injectNFreeSmallInt(self, 0, toInject), NULL); 8524 s = toStringO(r); 8525 ck_assert_str_eq(s, "[10]"); 8526 free(s); 8527 emptyO(self); 8528 toInject = allocSmallInt(10); 8529 ck_assert_ptr_ne(self->f->injectNFreeSmallInt(self, -1, toInject), NULL); 8530 s = toStringO(r); 8531 ck_assert_str_eq(s, "[10]"); 8532 free(s); 8533 // null toInsert 8534 ck_assert_ptr_eq(self->f->injectNFreeSmallInt(self, 0, NULL), NULL); 8535 terminateO(self); 8536 8537 } 8538 8539 8540 void injectNFreeSmallJsonSmallArrayT(CuTest *tc UNUSED) { 8541 8542 smallArrayt* r; 8543 smallArrayt *self = allocG(rtSmallArrayt); 8544 smallJsont *toInject; 8545 8546 // add elements to self 8547 r = self->f->pushInt(self, 1); 8548 ck_assert_ptr_ne(r, null); 8549 r = self->f->pushInt(self, 2); 8550 ck_assert_ptr_ne(r, null); 8551 r = self->f->pushInt(self, 3); 8552 ck_assert_ptr_ne(r, null); 8553 r = self->f->pushInt(self, 4); 8554 ck_assert_ptr_ne(r, null); 8555 8556 // positive index 8557 toInject = allocSmallJson(); 8558 r = self->f->injectNFreeSmallJson(self, 1, toInject); 8559 ck_assert_ptr_ne(r, null); 8560 char *s = toStringO(r); 8561 ck_assert_str_eq(s, "[1,{},2,3,4]"); 8562 free(s); 8563 // negative index 8564 toInject = allocSmallJson(); 8565 r = self->f->injectNFreeSmallJson(self,-1, toInject); 8566 ck_assert_ptr_ne(r, null); 8567 s = toStringO(r); 8568 ck_assert_str_eq(s, "[1,{},2,3,4,{}]"); 8569 free(s); 8570 // index 0 8571 toInject = allocSmallJson(); 8572 toInject->f->setS(toInject, "key", "value"); 8573 r = self->f->injectNFreeSmallJson(self,0, toInject); 8574 ck_assert_ptr_ne(r, null); 8575 s = toStringO(r); 8576 ck_assert_str_eq(s, "[{\"key\":\"value\"},1,{},2,3,4,{}]"); 8577 free(s); 8578 // index outside 8579 toInject = allocSmallJson(); 8580 ck_assert_ptr_eq(self->f->injectNFreeSmallJson(self, 20, toInject), NULL); 8581 ck_assert_ptr_eq(self->f->injectNFreeSmallJson(self, -9, toInject), NULL); 8582 terminateO(toInject); 8583 // empty object 8584 emptyO(self); 8585 toInject = allocSmallJson(); 8586 freeO(toInject); 8587 ck_assert_ptr_ne(self->f->injectNFreeSmallJson(self, 0, toInject), NULL); 8588 s = toStringO(r); 8589 ck_assert_str_eq(s, "[{}]"); 8590 free(s); 8591 // empty list 8592 emptyO(self); 8593 toInject = allocSmallJson(); 8594 ck_assert_ptr_ne(self->f->injectNFreeSmallJson(self, 0, toInject), NULL); 8595 s = toStringO(r); 8596 ck_assert_str_eq(s, "[{}]"); 8597 free(s); 8598 emptyO(self); 8599 toInject = allocSmallJson(); 8600 ck_assert_ptr_ne(self->f->injectNFreeSmallJson(self, -1, toInject), NULL); 8601 s = toStringO(r); 8602 ck_assert_str_eq(s, "[{}]"); 8603 free(s); 8604 // null toInsert 8605 ck_assert_ptr_eq(self->f->injectNFreeSmallJson(self, 0, NULL), NULL); 8606 terminateO(self); 8607 8608 } 8609 8610 8611 void injectNFreeSmallStringSmallArrayT(CuTest *tc UNUSED) { 8612 8613 smallArrayt* r; 8614 smallArrayt *self = allocG(rtSmallArrayt); 8615 smallStringt *toInject; 8616 8617 // add elements to self 8618 r = self->f->pushInt(self, 1); 8619 ck_assert_ptr_ne(r, null); 8620 r = self->f->pushInt(self, 2); 8621 ck_assert_ptr_ne(r, null); 8622 r = self->f->pushInt(self, 3); 8623 ck_assert_ptr_ne(r, null); 8624 r = self->f->pushInt(self, 4); 8625 ck_assert_ptr_ne(r, null); 8626 8627 // positive index 8628 toInject = allocSmallString("1"); 8629 r = self->f->injectNFreeSmallString(self, 1, toInject); 8630 ck_assert_ptr_ne(r, null); 8631 char *s = toStringO(r); 8632 ck_assert_str_eq(s, "[1,\"1\",2,3,4]"); 8633 free(s); 8634 // negative index 8635 toInject = allocSmallString("2"); 8636 r = self->f->injectNFreeSmallString(self,-1, toInject); 8637 ck_assert_ptr_ne(r, null); 8638 s = toStringO(r); 8639 ck_assert_str_eq(s, "[1,\"1\",2,3,4,\"2\"]"); 8640 free(s); 8641 // index 0 8642 toInject = allocSmallString("3"); 8643 r = self->f->injectNFreeSmallString(self,0, toInject); 8644 ck_assert_ptr_ne(r, null); 8645 s = toStringO(r); 8646 ck_assert_str_eq(s, "[\"3\",1,\"1\",2,3,4,\"2\"]"); 8647 free(s); 8648 // index outside 8649 toInject = allocSmallString("1"); 8650 ck_assert_ptr_eq(self->f->injectNFreeSmallString(self, 20, toInject), NULL); 8651 ck_assert_ptr_eq(self->f->injectNFreeSmallString(self, -9, toInject), NULL); 8652 terminateO(toInject); 8653 // empty object 8654 emptyO(self); 8655 toInject = allocSmallString("1"); 8656 freeO(toInject); 8657 ck_assert_ptr_ne(self->f->injectNFreeSmallString(self, 0, toInject), NULL); 8658 s = toStringO(r); 8659 ck_assert_str_eq(s, "[\"\"]"); 8660 free(s); 8661 // empty list 8662 emptyO(self); 8663 toInject = allocSmallString("1"); 8664 ck_assert_ptr_ne(self->f->injectNFreeSmallString(self, 0, toInject), NULL); 8665 s = toStringO(r); 8666 ck_assert_str_eq(s, "[\"1\"]"); 8667 free(s); 8668 emptyO(self); 8669 toInject = allocSmallString("1"); 8670 ck_assert_ptr_ne(self->f->injectNFreeSmallString(self, -1, toInject), NULL); 8671 s = toStringO(r); 8672 ck_assert_str_eq(s, "[\"1\"]"); 8673 free(s); 8674 // null toInsert 8675 ck_assert_ptr_eq(self->f->injectNFreeSmallString(self, 0, NULL), NULL); 8676 terminateO(self); 8677 8678 } 8679 8680 8681 void injectNFreeSmallContainerSmallArrayT(CuTest *tc UNUSED) { 8682 8683 smallArrayt* r; 8684 smallArrayt *self = allocG(rtSmallArrayt); 8685 smallContainert *toInject; 8686 8687 // add elements to self 8688 r = self->f->pushInt(self, 1); 8689 ck_assert_ptr_ne(r, null); 8690 r = self->f->pushInt(self, 2); 8691 ck_assert_ptr_ne(r, null); 8692 r = self->f->pushInt(self, 3); 8693 ck_assert_ptr_ne(r, null); 8694 r = self->f->pushInt(self, 4); 8695 ck_assert_ptr_ne(r, null); 8696 8697 // positive index 8698 toInject = allocSmallContainer(NULL); 8699 r = self->f->injectNFreeSmallContainer(self, 1, toInject); 8700 ck_assert_ptr_ne(r, null); 8701 char *s = toStringO(r); 8702 ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4]"); 8703 free(s); 8704 // negative index 8705 toInject = allocSmallContainer(NULL); 8706 r = self->f->injectNFreeSmallContainer(self,-1, toInject); 8707 ck_assert_ptr_ne(r, null); 8708 s = toStringO(r); 8709 ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4,\"<data container>\"]"); 8710 free(s); 8711 // index 0 8712 toInject = allocSmallContainer(NULL); 8713 r = self->f->injectNFreeSmallContainer(self,0, toInject); 8714 ck_assert_ptr_ne(r, null); 8715 s = toStringO(r); 8716 ck_assert_str_eq(s, "[\"<data container>\",1,\"<data container>\",2,3,4,\"<data container>\"]"); 8717 free(s); 8718 // index outside 8719 toInject = allocSmallContainer(NULL); 8720 ck_assert_ptr_eq(self->f->injectNFreeSmallContainer(self, 20, toInject), NULL); 8721 ck_assert_ptr_eq(self->f->injectNFreeSmallContainer(self, -9, toInject), NULL); 8722 terminateO(toInject); 8723 // empty object 8724 emptyO(self); 8725 toInject = allocSmallContainer(NULL); 8726 freeO(toInject); 8727 ck_assert_ptr_ne(self->f->injectNFreeSmallContainer(self, 0, toInject), NULL); 8728 s = toStringO(r); 8729 ck_assert_str_eq(s, "[\"<data container>\"]"); 8730 free(s); 8731 // empty list 8732 emptyO(self); 8733 toInject = allocSmallContainer(NULL); 8734 ck_assert_ptr_ne(self->f->injectNFreeSmallContainer(self, 0, toInject), NULL); 8735 s = toStringO(r); 8736 ck_assert_str_eq(s, "[\"<data container>\"]"); 8737 free(s); 8738 emptyO(self); 8739 toInject = allocSmallContainer(NULL); 8740 ck_assert_ptr_ne(self->f->injectNFreeSmallContainer(self, -1, toInject), NULL); 8741 s = toStringO(r); 8742 ck_assert_str_eq(s, "[\"<data container>\"]"); 8743 free(s); 8744 // null toInsert 8745 ck_assert_ptr_eq(self->f->injectNFreeSmallContainer(self, 0, NULL), NULL); 8746 terminateO(self); 8747 8748 } 8749 8750 8751 void removeSmallArrayT(CuTest *tc UNUSED) { 8752 8753 smallArrayt* r; 8754 smallArrayt *self = allocG(rtSmallArrayt); 8755 8756 // add elements to self 8757 r = self->f->pushInt(self, 1); 8758 ck_assert_ptr_ne(r, null); 8759 r = self->f->pushInt(self, 2); 8760 ck_assert_ptr_ne(r, null); 8761 r = self->f->pushInt(self, 3); 8762 ck_assert_ptr_ne(r, null); 8763 r = self->f->pushInt(self, 4); 8764 ck_assert_ptr_ne(r, null); 8765 8766 smallIntt *e[4]; 8767 arange(i,e) { 8768 e[i] = self->f->getAtSmallInt(self, i); 8769 } 8770 8771 // negative index 8772 r = removeO(self, 1, -1); 8773 ck_assert_ptr_ne(r, null); 8774 char *s = toStringO(self); 8775 ck_assert_str_eq(s, "[1,4]"); 8776 free(s); 8777 // start outside 8778 ck_assert_ptr_eq(removeO(self, 20, -4), NULL); 8779 // end outside 8780 r = removeO(self, 0, 40); 8781 ck_assert_ptr_ne(r, null); 8782 s = toStringO(self); 8783 ck_assert_str_eq(s, "[]"); 8784 free(s); 8785 arange(i,e) { 8786 terminateO(e[i]); 8787 } 8788 // end negative and outside 8789 // remove elements with NULL (set by removeO) 8790 trimO(self); 8791 // add elements to self 8792 r = self->f->pushInt(self, 1); 8793 ck_assert_ptr_ne(r, null); 8794 r = self->f->pushInt(self, 2); 8795 ck_assert_ptr_ne(r, null); 8796 r = self->f->pushInt(self, 3); 8797 ck_assert_ptr_ne(r, null); 8798 r = self->f->pushInt(self, 4); 8799 ck_assert_ptr_ne(r, null); 8800 arange(i,e) { 8801 e[i] = self->f->getAtSmallInt(self, i); 8802 } 8803 ck_assert_ptr_eq(removeO(self, 2, -40), NULL); 8804 s = toStringO(self); 8805 ck_assert_str_eq(s, "[1,2,3,4]"); 8806 free(s); 8807 // end before start 8808 ck_assert_ptr_eq(removeO(self, 3, 2), NULL); 8809 s = toStringO(self); 8810 ck_assert_str_eq(s, "[1,2,3,4]"); 8811 free(s); 8812 // negative start last element 8813 r = removeO(self, -1, 0); 8814 ck_assert_ptr_ne(r, null); 8815 s = toStringO(self); 8816 ck_assert_str_eq(s, "[1,2,3]"); 8817 free(s); 8818 // negative start and outside 8819 r = removeO(self, -10, 1); 8820 ck_assert_ptr_ne(r, null); 8821 s = toStringO(self); 8822 ck_assert_str_eq(s, "[2,3]"); 8823 free(s); 8824 // start = end 8825 r = removeO(self, 1, 1); 8826 ck_assert_ptr_ne(r, null); 8827 s = toStringO(self); 8828 ck_assert_str_eq(s, "[2,3]"); 8829 free(s); 8830 // remove all 8831 r = removeO(self, 0, 0); 8832 ck_assert_ptr_ne(r, null); 8833 s = toStringO(self); 8834 ck_assert_str_eq(s, "[]"); 8835 free(s); 8836 arange(i,e) { 8837 terminateO(e[i]); 8838 } 8839 // empty list 8840 emptyO(self); 8841 ck_assert_ptr_eq(removeO(self, 0, 0), NULL); 8842 ck_assert_ptr_eq(removeO(self, -1, 0), NULL); 8843 terminateO(self); 8844 8845 } 8846 8847 8848 void removeElemSmallArrayT(CuTest *tc UNUSED) { 8849 8850 smallArrayt* r; 8851 smallArrayt *self = allocG(rtSmallArrayt); 8852 8853 // add elements to self 8854 r = self->f->pushInt(self, 1); 8855 ck_assert_ptr_ne(r, null); 8856 r = self->f->pushInt(self, 2); 8857 ck_assert_ptr_ne(r, null); 8858 r = self->f->pushInt(self, 3); 8859 ck_assert_ptr_ne(r, null); 8860 r = self->f->pushInt(self, 4); 8861 ck_assert_ptr_ne(r, null); 8862 8863 smallIntt *e[2]; 8864 e[0] = self->f->getAtSmallInt(self, 1); 8865 e[1] = self->f->getAtSmallInt(self, 3); 8866 8867 // positive index 8868 r = removeElemO(self,1); 8869 ck_assert_ptr_ne(r, null); 8870 char *s = toStringO(self); 8871 ck_assert_str_eq(s, "[1,3,4]"); 8872 free(s); 8873 // negative index 8874 r = removeElemO(self,-1); 8875 ck_assert_ptr_ne(r, null); 8876 s = toStringO(self); 8877 ck_assert_str_eq(s, "[1,3]"); 8878 free(s); 8879 terminateO(e[0]); 8880 terminateO(e[1]); 8881 // index outside 8882 ck_assert_ptr_eq(removeElemO(self, 20), NULL); 8883 ck_assert_ptr_eq(removeElemO(self, -5), NULL); 8884 // empty list 8885 emptyO(self); 8886 ck_assert_ptr_eq(removeElemO(self, 0), NULL); 8887 ck_assert_ptr_eq(removeElemO(self, -1), NULL); 8888 terminateO(self); 8889 8890 } 8891 8892 8893 void sortSmallArrayT(CuTest *tc UNUSED) { 8894 8895 smallArrayt* r; 8896 smallArrayt *self = allocG(rtSmallArrayt); 8897 8898 // sort undefined 8899 self->f->pushInt(self, 0); 8900 self->f->pushUndefined(self); 8901 self->f->pushUndefined(self); 8902 self->f->pushUndefined(self); 8903 self->f->pushUndefined(self); 8904 r = sortO(self); 8905 ck_assert_ptr_ne(r, null); 8906 char *s = toStringO(r); 8907 ck_assert_str_eq(s, "[null,null,null,null,0]"); 8908 free(s); 8909 // sort bool 8910 emptyO(self); 8911 self->f->pushBool(self, false); 8912 self->f->pushBool(self, true); 8913 r = sortO(self); 8914 ck_assert_ptr_ne(r, null); 8915 s = toStringO(r); 8916 ck_assert_str_eq(s, "[false,true]"); 8917 free(s); 8918 // sort container 8919 emptyO(self); 8920 pushVoidSmallArrayG(self, &r); 8921 pushVoidSmallArrayG(self, &r); 8922 r = sortO(self); 8923 ck_assert_ptr_ne(r, null); 8924 s = toStringO(r); 8925 ck_assert_str_eq(s, "[\"<data container>\",\"<data container>\"]"); 8926 free(s); 8927 // sort dict 8928 emptyO(self); 8929 smallDictt *d[4]; 8930 arange(i,d) d[i] = allocSmallDict(); 8931 d[0]->f->setInt(d[0], "a", 1); 8932 d[1]->f->setInt(d[1], "a", 0); 8933 d[3]->f->setInt(d[3], "a", 0); 8934 d[3]->f->setInt(d[3], "b", 0); 8935 arange(i,d) self->f->pushNFreeDict(self, d[i]); 8936 r = sortO(self); 8937 ck_assert_ptr_ne(r, null); 8938 s = toStringO(r); 8939 ck_assert_str_eq(s, "[{},{\"a\":0},{\"a\":1},{\"a\":0,\"b\":0}]"); 8940 free(s); 8941 // sort double 8942 emptyO(self); 8943 self->f->pushDouble(self, 0); 8944 self->f->pushDouble(self, 0); 8945 self->f->pushDouble(self, 1); 8946 self->f->pushDouble(self, -1); 8947 r = sortO(self); 8948 ck_assert_ptr_ne(r, null); 8949 s = toStringO(r); 8950 ck_assert_str_eq(s, "[-1.000000e+00,0.000000e+00,0.000000e+00,1.000000e+00]"); 8951 free(s); 8952 // sort Int 8953 emptyO(self); 8954 self->f->pushInt(self, 0); 8955 self->f->pushInt(self, 0); 8956 self->f->pushInt(self, 1); 8957 self->f->pushInt(self, -1); 8958 r = sortO(self); 8959 ck_assert_ptr_ne(r, null); 8960 s = toStringO(r); 8961 ck_assert_str_eq(s, "[-1,0,0,1]"); 8962 free(s); 8963 // sort strings 8964 emptyO(self); 8965 self->f->pushS(self, "bb"); 8966 self->f->pushS(self, "a"); 8967 r = sortO(self); 8968 ck_assert_ptr_ne(r, null); 8969 s = toStringO(r); 8970 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 8971 free(s); 8972 // sort Array 8973 emptyO(self); 8974 smallArrayt *a[4]; 8975 arange(i,a) a[i] = allocSmallArray(); 8976 a[0]->f->pushInt(a[0], 1); 8977 a[1]->f->pushInt(a[1], 0); 8978 a[3]->f->pushInt(a[3], 0); 8979 a[3]->f->pushInt(a[3], 0); 8980 arange(i,a) self->f->pushNFreeArray(self, a[i]); 8981 r = sortO(self); 8982 ck_assert_ptr_ne(r, null); 8983 s = toStringO(r); 8984 ck_assert_str_eq(s, "[[],[0],[1],[0,0]]"); 8985 free(s); 8986 // sort bytes 8987 emptyO(self); 8988 smallBytest *B[4]; 8989 range(i,3) B[i] = allocSmallBytes("12345678", i); 8990 B[3] = allocSmallBytes("0", 1); 8991 arange(i,B) self->f->pushNFreeSmallBytes(self, B[i]); 8992 r = sortO(self); 8993 ck_assert_ptr_ne(r, null); 8994 s = toStringO(r); 8995 ck_assert_str_eq(s, "[[],[0x30],[0x31],[0x31,0x32]]"); 8996 free(s); 8997 // TODO add element and remove some elements 8998 emptyO(self); 8999 self->f->pushInt(self, 0); 9000 self->f->pushInt(self, 0); 9001 self->f->pushInt(self, 1); 9002 self->f->pushInt(self, -1); 9003 smallIntt *i1 = self->f->getAtSmallInt(self, 1); 9004 smallIntt *i2 = self->f->getAtSmallInt(self, 2); 9005 removeO(self, 1, 3); 9006 terminateO(i1); 9007 terminateO(i2); 9008 r = sortO(self); 9009 ck_assert_ptr_ne(r, null); 9010 s = toStringO(r); 9011 ck_assert_str_eq(s, "[-1,0]"); 9012 free(s); 9013 // length 0 9014 emptyO(self); 9015 r = sortO(self); 9016 ck_assert_ptr_eq(r, null); 9017 terminateO(self); 9018 9019 } 9020 9021 9022 void icSortSmallArrayT(CuTest *tc UNUSED) { 9023 9024 smallArrayt* r; 9025 smallArrayt *self = allocG(rtSmallArrayt); 9026 9027 // sort undefined 9028 self->f->pushInt(self, 0); 9029 self->f->pushUndefined(self); 9030 self->f->pushUndefined(self); 9031 self->f->pushUndefined(self); 9032 self->f->pushUndefined(self); 9033 r = icSortO(self); 9034 ck_assert_ptr_ne(r, null); 9035 char *s = toStringO(r); 9036 ck_assert_str_eq(s, "[null,null,null,null,0]"); 9037 free(s); 9038 // sort bool 9039 emptyO(self); 9040 self->f->pushBool(self, false); 9041 self->f->pushBool(self, true); 9042 r = icSortO(self); 9043 ck_assert_ptr_ne(r, null); 9044 s = toStringO(r); 9045 ck_assert_str_eq(s, "[false,true]"); 9046 free(s); 9047 // sort container 9048 emptyO(self); 9049 pushVoidSmallArrayG(self, &r); 9050 pushVoidSmallArrayG(self, &r); 9051 r = icSortO(self); 9052 ck_assert_ptr_ne(r, null); 9053 s = toStringO(r); 9054 ck_assert_str_eq(s, "[\"<data container>\",\"<data container>\"]"); 9055 free(s); 9056 // sort dict 9057 emptyO(self); 9058 smallDictt *d[4]; 9059 arange(i,d) d[i] = allocSmallDict(); 9060 d[0]->f->setInt(d[0], "a", 1); 9061 d[1]->f->setInt(d[1], "A", 0); 9062 d[3]->f->setInt(d[3], "a", 0); 9063 d[3]->f->setInt(d[3], "b", 0); 9064 arange(i,d) self->f->pushNFreeDict(self, d[i]); 9065 r = icSortO(self); 9066 ck_assert_ptr_ne(r, null); 9067 s = toStringO(r); 9068 ck_assert_str_eq(s, "[{},{\"A\":0},{\"a\":1},{\"a\":0,\"b\":0}]"); 9069 free(s); 9070 // sort double 9071 emptyO(self); 9072 self->f->pushDouble(self, 0); 9073 self->f->pushDouble(self, 0); 9074 self->f->pushDouble(self, 1); 9075 self->f->pushDouble(self, -1); 9076 r = icSortO(self); 9077 ck_assert_ptr_ne(r, null); 9078 s = toStringO(r); 9079 ck_assert_str_eq(s, "[-1.000000e+00,0.000000e+00,0.000000e+00,1.000000e+00]"); 9080 free(s); 9081 // sort Int 9082 emptyO(self); 9083 self->f->pushInt(self, 0); 9084 self->f->pushInt(self, 0); 9085 self->f->pushInt(self, 1); 9086 self->f->pushInt(self, -1); 9087 r = icSortO(self); 9088 ck_assert_ptr_ne(r, null); 9089 s = toStringO(r); 9090 ck_assert_str_eq(s, "[-1,0,0,1]"); 9091 free(s); 9092 // sort strings 9093 emptyO(self); 9094 self->f->pushS(self, "bb"); 9095 self->f->pushS(self, "B"); 9096 r = icSortO(self); 9097 ck_assert_ptr_ne(r, null); 9098 s = toStringO(r); 9099 ck_assert_str_eq(s, "[\"B\",\"bb\"]"); 9100 free(s); 9101 // sort Array 9102 emptyO(self); 9103 smallArrayt *a[4]; 9104 arange(i,a) a[i] = allocSmallArray(); 9105 a[0]->f->pushInt(a[0], 1); 9106 a[1]->f->pushInt(a[1], 0); 9107 a[3]->f->pushInt(a[3], 0); 9108 a[3]->f->pushInt(a[3], 0); 9109 arange(i,a) self->f->pushNFreeArray(self, a[i]); 9110 r = icSortO(self); 9111 ck_assert_ptr_ne(r, null); 9112 s = toStringO(r); 9113 ck_assert_str_eq(s, "[[],[0],[1],[0,0]]"); 9114 free(s); 9115 // sort bytes 9116 emptyO(self); 9117 smallBytest *B[4]; 9118 range(i,3) B[i] = allocSmallBytes("12345678", i); 9119 B[3] = allocSmallBytes("0", 1); 9120 arange(i,B) self->f->pushNFreeSmallBytes(self, B[i]); 9121 r = icSortO(self); 9122 ck_assert_ptr_ne(r, null); 9123 s = toStringO(r); 9124 ck_assert_str_eq(s, "[[],[0x30],[0x31],[0x31,0x32]]"); 9125 free(s); 9126 // TODO add element and remove some elements 9127 emptyO(self); 9128 self->f->pushInt(self, 0); 9129 self->f->pushInt(self, 0); 9130 self->f->pushInt(self, 1); 9131 self->f->pushInt(self, -1); 9132 smallIntt *i1 = self->f->getAtSmallInt(self, 1); 9133 smallIntt *i2 = self->f->getAtSmallInt(self, 2); 9134 removeO(self, 1, 3); 9135 terminateO(i1); 9136 terminateO(i2); 9137 r = icSortO(self); 9138 ck_assert_ptr_ne(r, null); 9139 s = toStringO(r); 9140 ck_assert_str_eq(s, "[-1,0]"); 9141 free(s); 9142 // length 0 9143 emptyO(self); 9144 r = icSortO(self); 9145 ck_assert_ptr_eq(r, null); 9146 terminateO(self); 9147 9148 } 9149 9150 int sortFOCmp(const void *A, const void *B) { 9151 cast(smallDictt*, a, A); 9152 cast(smallDictt*, b, B); 9153 9154 if (lenO(a) < lenO(b)) 9155 return -1; 9156 else if (lenO(a) == lenO(b)) { 9157 var As = toStringO(a); 9158 var Bs = toStringO(b); 9159 int r = strcmp(As,Bs); 9160 freeManyS(As,Bs); 9161 return r; 9162 } 9163 else 9164 return 1; 9165 } 9166 9167 void sortFSmallArrayT(CuTest *tc UNUSED) { 9168 9169 smallArrayt* r; 9170 smallArrayt *self = allocG(rtSmallArrayt); 9171 9172 // sort dict 9173 smallDictt *d[4]; 9174 arange(i,d) d[i] = allocSmallDict(); 9175 d[0]->f->setInt(d[0], "a", 1); 9176 d[1]->f->setInt(d[1], "a", 0); 9177 d[3]->f->setInt(d[3], "a", 0); 9178 d[3]->f->setInt(d[3], "b", 0); 9179 arange(i,d) self->f->pushNFreeDict(self, d[i]); 9180 r = sortFO(self, sortFOCmp); 9181 ck_assert_ptr_ne(r, null); 9182 char *s = toStringO(r); 9183 ck_assert_str_eq(s, "[{},{\"a\":0},{\"a\":1},{\"a\":0,\"b\":0}]"); 9184 free(s); 9185 // no compare function 9186 r = sortFO(self, NULL); 9187 ck_assert_ptr_eq(r, null); 9188 // empty array 9189 emptyO(self); 9190 r = sortFO(self, sortFOCmp); 9191 ck_assert_ptr_eq(r, null); 9192 terminateO(self); 9193 9194 } 9195 9196 9197 void equalSmallArrayT(CuTest *tc UNUSED) { 9198 9199 bool r; 9200 smallArrayt *self = allocG(rtSmallArrayt); 9201 smallArrayt *array = allocG(rtSmallArrayt); 9202 9203 // empty arrays 9204 r = equalO(self, array); 9205 ck_assert(r); 9206 // empty self, non empty array 9207 array->f->pushInt(array, 1); 9208 r = equalO(self, array); 9209 ck_assert(!r); 9210 // non empty self, empty array 9211 emptyO(array); 9212 self->f->pushInt(self, 1); 9213 r = equalO(self, array); 9214 ck_assert(!r); 9215 // different lengths 9216 array->f->pushInt(array, 1); 9217 self->f->pushInt(self, 1); 9218 r = equalO(self, array); 9219 ck_assert(!r); 9220 // equal arrays 9221 array->f->pushInt(array, 1); 9222 r = equalO(self, array); 9223 ck_assert(r); 9224 // different int value 9225 array->f->setAtInt(array, 1, 2); 9226 r = equalO(self, array); 9227 ck_assert(!r); 9228 // array same length with a null element in self 9229 smallIntt *i = self->f->getAtSmallInt(self, 1); 9230 removeElemO(self, 1); 9231 terminateO(i); 9232 r = equalO(self, array); 9233 ck_assert(!r); 9234 // array same length with a null element in both arrays 9235 i = array->f->getAtSmallInt(array, 1); 9236 removeElemO(array, 1); 9237 terminateO(i); 9238 r = equalO(self, array); 9239 ck_assert(r); 9240 // elements of different types 9241 self->f->setAtBool(self, 1, true); 9242 array->f->setAtInt(array, 1, 1); 9243 r = equalO(self, array); 9244 ck_assert(!r); 9245 // compare bool 9246 array->f->setAtBool(array, 1, true); 9247 r = equalO(self, array); 9248 ck_assert(r); 9249 array->f->setAtBool(array, 1, false); 9250 r = equalO(self, array); 9251 ck_assert(!r); 9252 // compare dict 9253 createSmallDict(d1); 9254 createSmallDict(d2); 9255 self->f->setAtDict(self, 1, &d1); 9256 array->f->setAtDict(array, 1, &d2); 9257 r = equalO(self, array); 9258 ck_assert(r); 9259 // reuse dict container, the data is in self already 9260 resetO(&d1); 9261 (&d1)->f->setInt(&d1, "a", 1); 9262 self->f->setAtDict(self, 1, &d1); 9263 r = equalO(self, array); 9264 ck_assert(!r); 9265 // compare double 9266 self->f->setAtDouble(self, 1, 0); 9267 array->f->setAtDouble(array, 1, 0); 9268 r = equalO(self, array); 9269 ck_assert(r); 9270 array->f->setAtDouble(array, 1, 10.5); 9271 r = equalO(self, array); 9272 ck_assert(!r); 9273 // compare string 9274 self->f->setAtS(self, 1, ""); 9275 array->f->setAtS(array, 1, ""); 9276 r = equalO(self, array); 9277 ck_assert(r); 9278 array->f->setAtS(array, 1, "NO"); 9279 r = equalO(self, array); 9280 ck_assert(!r); 9281 // compare array elements 9282 createSmallArray(a1); 9283 createSmallArray(a2); 9284 self->f->setAtArray(self, 1, &a1); 9285 array->f->setAtArray(array, 1, &a2); 9286 r = equalO(self, array); 9287 ck_assert(r); 9288 // reuse Array container, the data is in self already 9289 resetO(&a1); 9290 (&a1)->f->pushInt(&a1, 1); 9291 self->f->setAtArray(self, 1, &a1); 9292 r = equalO(self, array); 9293 ck_assert(!r); 9294 // compare bytes 9295 createSmallBytes(b1); 9296 createSmallBytes(b2); 9297 self->f->setAtSmallBytes(self, 1, &b1); 9298 array->f->setAtSmallBytes(array, 1, &b2); 9299 r = equalO(self, array); 9300 ck_assert(r); 9301 // reuse SmallBytes container, the data is in self already 9302 b1.B = null; 9303 pushBufferO(&b1, &self, 2); 9304 self->f->setAtSmallBytes(self, 1, &b1); 9305 r = equalO(self, array); 9306 ck_assert(!r); 9307 // compare data in both smallBytes elements 9308 b2.B = null; 9309 pushBufferO(&b2, (char*)(&self) + 4, 2); 9310 array->f->setAtSmallBytes(array, 1, &b2); 9311 r = equalO(self, array); 9312 ck_assert(!r); 9313 // non smallArray object 9314 terminateO(array); 9315 array = (smallArrayt*) allocSmallInt(2); 9316 r = equalO(self, array); 9317 ck_assert(!r); 9318 // NULL array 9319 r = equalO(self, NULL); 9320 ck_assert(!r); 9321 terminateO(self); 9322 terminateO(array); 9323 9324 } 9325 9326 9327 void equalSmallArraySmallJsonT(CuTest *tc UNUSED) { 9328 9329 bool r; 9330 smallArrayt *self = allocG(rtSmallArrayt); 9331 smallJsont *array = allocG(rtSmallJsont); 9332 9333 // NULL array 9334 r = self->f->equalSmallJson(self, NULL); 9335 ck_assert(!r); 9336 // compare 9337 r = self->f->equalSmallJson(self, array); 9338 // the smallJson is empty, so the result is false 9339 ck_assert(!r); 9340 // non smallJson object 9341 terminateO(array); 9342 array = (smallJsont*) allocSmallInt(2); 9343 r = self->f->equalSmallJson(self, array); 9344 ck_assert(!r); 9345 terminateO(self); 9346 terminateO(array); 9347 9348 } 9349 9350 9351 void equalSmallArrayArrayT(CuTest *tc UNUSED) { 9352 9353 bool r; 9354 smallArrayt* self = allocG(rtSmallArrayt); 9355 char ** p2 = NULL; 9356 9357 // empty arrays 9358 r = self->f->equalArray(self, NULL); 9359 ck_assert(r); 9360 // empty self, non empty array 9361 p2 = listCreateS("a"); 9362 r = self->f->equalArray(self, p2); 9363 ck_assert(!r); 9364 // non empty self, empty array 9365 self->f->pushInt(self, 1); 9366 listFreeS(p2); 9367 listEmptyS(p2); 9368 r = self->f->equalArray(self, p2); 9369 ck_assert(!r); 9370 // different lengths 9371 listPushS(&p2, "a"); 9372 self->f->pushInt(self, 2); 9373 r = self->f->equalArray(self, p2); 9374 ck_assert(!r); 9375 // equal arrays 9376 emptyO(self); 9377 self->f->pushS(self, "a"); 9378 r = self->f->equalArray(self, p2); 9379 ck_assert(r); 9380 // not string type in self 9381 self->f->setAtInt(self, 0, 0); 9382 r = self->f->equalArray(self, p2); 9383 ck_assert(!r); 9384 // array same length with a null element in self 9385 smallIntt *i = self->f->getAtSmallInt(self, 0); 9386 terminateO(i); 9387 removeElemO(self, 0); 9388 r = self->f->equalArray(self, p2); 9389 ck_assert(!r); 9390 // different strings 9391 self->f->setAtS(self, 0, "bb"); 9392 r = self->f->equalArray(self, p2); 9393 ck_assert(!r); 9394 terminateO(self); 9395 listFreeS(p2); 9396 9397 9398 } 9399 9400 9401 void equalSmallArrayBaseT(CuTest *tc UNUSED) { 9402 9403 bool r; 9404 smallArrayt* self = allocG(rtSmallArrayt); 9405 baset* p2 = (baset*) allocG(1); 9406 9407 // empty self array 9408 r = self->f->equalBase(self, p2); 9409 ck_assert(!r); 9410 // NULL 9411 r = self->f->equalBase(self, NULL); 9412 ck_assert(!r); 9413 // not array type 9414 self->f->pushInt(self, 1); 9415 r = self->f->equalBase(self, p2); 9416 ck_assert(!r); 9417 // equal 9418 terminateO(p2); 9419 p2 = (baset*) allocG(rtSmallArrayt); 9420 r = self->f->equalBase(self, p2); 9421 ck_assert(!r); 9422 terminateO(self); 9423 terminateO(p2); 9424 9425 } 9426 9427 9428 void icEqualSmallArrayT(CuTest *tc UNUSED) { 9429 9430 bool r; 9431 smallArrayt *self = allocG(rtSmallArrayt); 9432 smallArrayt *array = allocG(rtSmallArrayt); 9433 9434 // empty arrays 9435 r = icEqualO(self, array); 9436 ck_assert(r); 9437 // empty self, non empty array 9438 array->f->pushInt(array, 1); 9439 r = icEqualO(self, array); 9440 ck_assert(!r); 9441 // non empty self, empty array 9442 emptyO(array); 9443 self->f->pushInt(self, 1); 9444 r = icEqualO(self, array); 9445 ck_assert(!r); 9446 // different lengths 9447 array->f->pushInt(array, 1); 9448 self->f->pushInt(self, 1); 9449 r = icEqualO(self, array); 9450 ck_assert(!r); 9451 // equal arrays 9452 array->f->pushInt(array, 1); 9453 r = icEqualO(self, array); 9454 ck_assert(r); 9455 // different int value 9456 array->f->setAtInt(array, 1, 2); 9457 r = icEqualO(self, array); 9458 ck_assert(!r); 9459 // array same length with a null element in self 9460 smallIntt *i = self->f->getAtSmallInt(self, 1); 9461 removeElemO(self, 1); 9462 terminateO(i); 9463 r = icEqualO(self, array); 9464 ck_assert(!r); 9465 // array same length with a null element in both arrays 9466 i = array->f->getAtSmallInt(array, 1); 9467 removeElemO(array, 1); 9468 terminateO(i); 9469 r = icEqualO(self, array); 9470 ck_assert(r); 9471 // elements of different types 9472 self->f->setAtBool(self, 1, true); 9473 array->f->setAtInt(array, 1, 1); 9474 r = icEqualO(self, array); 9475 ck_assert(!r); 9476 // compare bool 9477 array->f->setAtBool(array, 1, true); 9478 r = icEqualO(self, array); 9479 ck_assert(r); 9480 array->f->setAtBool(array, 1, false); 9481 r = icEqualO(self, array); 9482 ck_assert(!r); 9483 // compare dict 9484 createSmallDict(d1); 9485 createSmallDict(d2); 9486 self->f->setAtDict(self, 1, &d1); 9487 array->f->setAtDict(array, 1, &d2); 9488 r = icEqualO(self, array); 9489 ck_assert(r); 9490 // reuse dict container, the data is in self already 9491 resetO(&d1); 9492 (&d1)->f->setInt(&d1, "a", 1); 9493 self->f->setAtDict(self, 1, &d1); 9494 r = icEqualO(self, array); 9495 ck_assert(!r); 9496 // compare double 9497 self->f->setAtDouble(self, 1, 0); 9498 array->f->setAtDouble(array, 1, 0); 9499 r = icEqualO(self, array); 9500 ck_assert(r); 9501 array->f->setAtDouble(array, 1, 10.5); 9502 r = icEqualO(self, array); 9503 ck_assert(!r); 9504 // compare string 9505 self->f->setAtS(self, 1, "a"); 9506 array->f->setAtS(array, 1, "A"); 9507 r = icEqualO(self, array); 9508 ck_assert(r); 9509 array->f->setAtS(array, 1, "NO"); 9510 r = icEqualO(self, array); 9511 ck_assert(!r); 9512 // compare array elements 9513 createSmallArray(a1); 9514 createSmallArray(a2); 9515 self->f->setAtArray(self, 1, &a1); 9516 array->f->setAtArray(array, 1, &a2); 9517 r = icEqualO(self, array); 9518 ck_assert(r); 9519 // reuse Array container, the data is in self already 9520 resetO(&a1); 9521 (&a1)->f->pushInt(&a1, 1); 9522 self->f->setAtArray(self, 1, &a1); 9523 r = icEqualO(self, array); 9524 ck_assert(!r); 9525 // compare bytes 9526 createSmallBytes(b1); 9527 createSmallBytes(b2); 9528 self->f->setAtSmallBytes(self, 1, &b1); 9529 array->f->setAtSmallBytes(array, 1, &b2); 9530 r = icEqualO(self, array); 9531 ck_assert(r); 9532 // reuse SmallBytes container, the data is in self already 9533 b1.B = null; 9534 pushBufferO(&b1, &self, 2); 9535 self->f->setAtSmallBytes(self, 1, &b1); 9536 r = icEqualO(self, array); 9537 ck_assert(!r); 9538 // compare data in both smallBytes elements 9539 b2.B = null; 9540 pushBufferO(&b2, &self + 4, 2); 9541 array->f->setAtSmallBytes(array, 1, &b2); 9542 r = icEqualO(self, array); 9543 ck_assert(!r); 9544 // non smallArray object 9545 terminateO(array); 9546 array = (smallArrayt*) allocSmallInt(2); 9547 r = icEqualO(self, array); 9548 ck_assert(!r); 9549 // NULL array 9550 r = icEqualO(self, NULL); 9551 ck_assert(!r); 9552 terminateO(self); 9553 terminateO(array); 9554 9555 } 9556 9557 9558 void icEqualSmallArraySmallJsonT(CuTest *tc UNUSED) { 9559 9560 bool r; 9561 smallArrayt *self = allocG(rtSmallArrayt); 9562 smallJsont *array = allocG(rtSmallJsont); 9563 9564 // NULL array 9565 r = self->f->icEqualSmallJson(self, NULL); 9566 ck_assert(!r); 9567 // json is not array 9568 r = self->f->icEqualSmallJson(self, array); 9569 ck_assert(!r); 9570 // compare 9571 self->f->pushS(self, "A"); 9572 array->f->pushS(array, "a"); 9573 r = self->f->icEqualSmallJson(self, array); 9574 ck_assert(r); 9575 // non smallJson object 9576 terminateO(array); 9577 array = (smallJsont*) allocSmallInt(2); 9578 r = self->f->icEqualSmallJson(self, array); 9579 ck_assert(!r); 9580 terminateO(self); 9581 terminateO(array); 9582 9583 } 9584 9585 9586 void icEqualSmallArrayArrayT(CuTest *tc UNUSED) { 9587 9588 bool r; 9589 smallArrayt* self = allocG(rtSmallArrayt); 9590 char ** p2 = NULL; 9591 9592 // empty arrays 9593 r = self->f->icEqualArray(self, NULL); 9594 ck_assert(r); 9595 // empty self, non empty array 9596 p2 = listCreateS("a"); 9597 r = self->f->icEqualArray(self, p2); 9598 ck_assert(!r); 9599 // non empty self, empty array 9600 self->f->pushInt(self, 1); 9601 listFreeS(p2); 9602 listEmptyS(p2); 9603 r = self->f->icEqualArray(self, p2); 9604 ck_assert(!r); 9605 // different lengths 9606 listPushS(&p2, "a"); 9607 self->f->pushInt(self, 2); 9608 r = self->f->icEqualArray(self, p2); 9609 ck_assert(!r); 9610 // equal arrays 9611 emptyO(self); 9612 self->f->pushS(self, "A"); 9613 r = self->f->icEqualArray(self, p2); 9614 ck_assert(r); 9615 // not string type in self 9616 self->f->setAtInt(self, 0, 0); 9617 r = self->f->icEqualArray(self, p2); 9618 ck_assert(!r); 9619 // array same length with a null element in self 9620 smallIntt *i = self->f->getAtSmallInt(self, 0); 9621 terminateO(i); 9622 removeElemO(self, 0); 9623 r = self->f->icEqualArray(self, p2); 9624 ck_assert(!r); 9625 // different strings 9626 self->f->setAtS(self, 0, "bb"); 9627 r = self->f->icEqualArray(self, p2); 9628 ck_assert(!r); 9629 terminateO(self); 9630 listFreeS(p2); 9631 9632 } 9633 9634 9635 void icEqualSmallArrayBaseT(CuTest *tc UNUSED) { 9636 9637 bool r; 9638 smallArrayt* self = allocG(rtSmallArrayt); 9639 baset* p2 = (baset*) allocG(1); 9640 9641 // empty self array 9642 r = self->f->icEqualBase(self, p2); 9643 ck_assert(!r); 9644 // NULL 9645 r = self->f->icEqualBase(self, NULL); 9646 ck_assert(!r); 9647 // not array type 9648 self->f->pushInt(self, 1); 9649 r = self->f->icEqualBase(self, p2); 9650 ck_assert(!r); 9651 // equal 9652 terminateO(p2); 9653 self->f->setAtS(self, 0, "a"); 9654 smallArrayt *a = allocG(rtSmallArrayt); 9655 a->f->pushS(a, "A"); 9656 p2 = (baset*) a; 9657 r = self->f->icEqualBase(self, p2); 9658 ck_assert(r); 9659 terminateO(self); 9660 terminateO(p2); 9661 9662 } 9663 9664 9665 void getAtUndefinedSmallArrayT(CuTest *tc UNUSED) { 9666 9667 undefinedt* r; 9668 smallArrayt *self = allocG(rtSmallArrayt); 9669 smallArrayt *r2; 9670 9671 // add elements to self 9672 r2 = self->f->pushInt(self, 1); 9673 ck_assert_ptr_ne(r2, null); 9674 r2 = self->f->pushUndefined(self); 9675 ck_assert_ptr_ne(r2, null); 9676 r2 = self->f->pushInt(self, 3); 9677 ck_assert_ptr_ne(r2, null); 9678 r2 = self->f->pushUndefined(self); 9679 ck_assert_ptr_ne(r2, null); 9680 9681 // positive index 9682 r = self->f->getAtUndefined(self,1); 9683 ck_assert_ptr_ne(r, null); 9684 char *s = toStringO(r); 9685 finishO(r); 9686 ck_assert_str_eq(s, "null"); 9687 free(s); 9688 s = toStringO(self); 9689 ck_assert_str_eq(s, "[1,null,3,null]"); 9690 free(s); 9691 // negative index 9692 r = self->f->getAtUndefined(self,-1); 9693 ck_assert_ptr_ne(r, null); 9694 s = toStringO(r); 9695 finishO(r); 9696 ck_assert_str_eq(s, "null"); 9697 free(s); 9698 s = toStringO(self); 9699 ck_assert_str_eq(s, "[1,null,3,null]"); 9700 free(s); 9701 // wrong object type 9702 createSmallInt(I); 9703 setValG(&I, 11); 9704 r2 = self->f->pushSmallInt(self, &I); 9705 ck_assert_ptr_ne(r2, null); 9706 r = self->f->getAtUndefined(self,-1); 9707 ck_assert_ptr_eq(r, null); 9708 s = toStringO(self); 9709 ck_assert_str_eq(s, "[1,null,3,null,11]"); 9710 free(s); 9711 // index outside 9712 ck_assert_ptr_eq(self->f->getAtUndefined(self, 20), NULL); 9713 ck_assert_ptr_eq(self->f->getAtUndefined(self, -6), NULL); 9714 // empty list 9715 emptyO(self); 9716 ck_assert_ptr_eq(self->f->getAtUndefined(self, 0), NULL); 9717 ck_assert_ptr_eq(self->f->getAtUndefined(self, -1), NULL); 9718 // get empty slot in array 9719 r2 = self->f->pushUndefined(self); 9720 ck_assert_ptr_ne(r2, null); 9721 delElemO(self,0); 9722 ck_assert_ptr_eq(self->f->getAtUndefined(self, 0), NULL); 9723 terminateO(self); 9724 9725 } 9726 9727 9728 void getAtBoolSmallArrayT(CuTest *tc UNUSED) { 9729 9730 bool r; 9731 smallArrayt *self = allocG(rtSmallArrayt); 9732 smallArrayt *r2; 9733 9734 // add elements to self 9735 r2 = self->f->pushInt(self, 1); 9736 ck_assert_ptr_ne(r2, null); 9737 r2 = self->f->pushBool(self, TRUE); 9738 ck_assert_ptr_ne(r2, null); 9739 r2 = self->f->pushInt(self, 3); 9740 ck_assert_ptr_ne(r2, null); 9741 r2 = self->f->pushBool(self, TRUE); 9742 ck_assert_ptr_ne(r2, null); 9743 9744 // positive index 9745 r = self->f->getAtBool(self,1); 9746 ck_assert(r); 9747 char *s = toStringO(self); 9748 ck_assert_str_eq(s, "[1,true,3,true]"); 9749 free(s); 9750 // negative index 9751 r = self->f->getAtBool(self,-1); 9752 ck_assert(r); 9753 s = toStringO(self); 9754 ck_assert_str_eq(s, "[1,true,3,true]"); 9755 free(s); 9756 // wrong object type 9757 createSmallInt(I); 9758 setValG(&I, 11); 9759 r2 = self->f->pushSmallInt(self, &I); 9760 r = self->f->getAtBool(self,-1); 9761 ck_assert(!r); 9762 s = toStringO(self); 9763 ck_assert_str_eq(s, "[1,true,3,true,11]"); 9764 free(s); 9765 // wrong object type of another user class 9766 // User classes are stored in containers transparently 9767 createAllocateSmallInt(ip); 9768 ip->type = "anothertype"; 9769 setValG(ip, 11); 9770 r2 = self->f->push(self, (baset*)ip); 9771 ck_assert_ptr_ne(r2, null); 9772 r = self->f->getAtBool(self,-1); 9773 ck_assert(!r); 9774 s = toStringO(self); 9775 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 9776 free(s); 9777 // index outside 9778 ck_assert(!self->f->getAtBool(self, 20)); 9779 ck_assert(!self->f->getAtBool(self, -7)); 9780 // empty list 9781 emptyO(self); 9782 ck_assert(!self->f->getAtBool(self, 0)); 9783 ck_assert(!self->f->getAtBool(self, -1)); 9784 terminateO(self); 9785 9786 } 9787 9788 9789 void getAtBoolPSmallArrayT(CuTest *tc UNUSED) { 9790 9791 bool* r; 9792 smallArrayt *self = allocG(rtSmallArrayt); 9793 smallArrayt *r2; 9794 9795 // add elements to self 9796 r2 = self->f->pushInt(self, 1); 9797 ck_assert_ptr_ne(r2, null); 9798 r2 = self->f->pushBool(self, TRUE); 9799 ck_assert_ptr_ne(r2, null); 9800 r2 = self->f->pushInt(self, 3); 9801 ck_assert_ptr_ne(r2, null); 9802 r2 = self->f->pushBool(self, TRUE); 9803 ck_assert_ptr_ne(r2, null); 9804 9805 // positive index 9806 r = self->f->getAtBoolP(self,1); 9807 ck_assert_ptr_ne(r, null); 9808 ck_assert(*r); 9809 char *s = toStringO(self); 9810 ck_assert_str_eq(s, "[1,true,3,true]"); 9811 free(s); 9812 // negative index 9813 r = self->f->getAtBoolP(self,-1); 9814 ck_assert_ptr_ne(r, null); 9815 ck_assert(*r); 9816 s = toStringO(self); 9817 ck_assert_str_eq(s, "[1,true,3,true]"); 9818 free(s); 9819 // wrong object type 9820 createSmallInt(I); 9821 setValG(&I, 11); 9822 r2 = self->f->pushSmallInt(self, &I); 9823 r = self->f->getAtBoolP(self,-1); 9824 ck_assert_ptr_eq(r, null); 9825 s = toStringO(self); 9826 ck_assert_str_eq(s, "[1,true,3,true,11]"); 9827 free(s); 9828 // wrong object type of another user class 9829 // User classes are stored in containers transparently 9830 createAllocateSmallInt(ip); 9831 ip->type = "anothertype"; 9832 setValG(ip, 11); 9833 r2 = self->f->push(self, (baset*)ip); 9834 ck_assert_ptr_ne(r2, null); 9835 r = self->f->getAtBoolP(self,-1); 9836 ck_assert_ptr_eq(r, null); 9837 s = toStringO(self); 9838 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 9839 free(s); 9840 // index outside 9841 ck_assert(!self->f->getAtBoolP(self, 20)); 9842 ck_assert(!self->f->getAtBoolP(self, -7)); 9843 // empty list 9844 emptyO(self); 9845 ck_assert(!self->f->getAtBoolP(self, 0)); 9846 ck_assert(!self->f->getAtBoolP(self, -1)); 9847 terminateO(self); 9848 9849 } 9850 9851 9852 void getAtDoubleSmallArrayT(CuTest *tc UNUSED) { 9853 9854 double r; 9855 smallArrayt *self = allocG(rtSmallArrayt); 9856 smallArrayt *r2; 9857 9858 // add elements to self 9859 r2 = self->f->pushInt(self, 1); 9860 ck_assert_ptr_ne(r2, null); 9861 r2 = self->f->pushDouble(self, 2); 9862 ck_assert_ptr_ne(r2, null); 9863 r2 = self->f->pushInt(self, 3); 9864 ck_assert_ptr_ne(r2, null); 9865 r2 = self->f->pushDouble(self, 4); 9866 ck_assert_ptr_ne(r2, null); 9867 9868 // positive index 9869 r = self->f->getAtDouble(self,1); 9870 ck_assert(r==2); 9871 char *s = toStringO(self); 9872 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 9873 free(s); 9874 // negative index 9875 r = self->f->getAtDouble(self,-1); 9876 ck_assert(r==4); 9877 s = toStringO(self); 9878 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 9879 free(s); 9880 // wrong object type 9881 createSmallInt(I); 9882 setValG(&I, 11); 9883 r2 = self->f->pushSmallInt(self, &I); 9884 r = self->f->getAtDouble(self,-1); 9885 ck_assert(!r); 9886 s = toStringO(self); 9887 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11]"); 9888 free(s); 9889 // wrong object type of another user class 9890 // User classes are stored in containers transparently 9891 createAllocateSmallInt(ip); 9892 ip->type = "anothertype"; 9893 setValG(ip, 11); 9894 r2 = self->f->push(self, (baset*)ip); 9895 ck_assert_ptr_ne(r2, null); 9896 r = self->f->getAtDouble(self,-1); 9897 ck_assert(!r); 9898 s = toStringO(self); 9899 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11,\"<data container>\"]"); 9900 free(s); 9901 // index outside 9902 ck_assert(!self->f->getAtDouble(self, 20)); 9903 ck_assert(!self->f->getAtDouble(self, -7)); 9904 // empty list 9905 emptyO(self); 9906 ck_assert(!self->f->getAtDouble(self, 0)); 9907 ck_assert(!self->f->getAtDouble(self, -1)); 9908 terminateO(self); 9909 9910 } 9911 9912 9913 void getAtDoublePSmallArrayT(CuTest *tc UNUSED) { 9914 9915 double* r; 9916 smallArrayt *self = allocG(rtSmallArrayt); 9917 smallArrayt *r2; 9918 9919 // add elements to self 9920 r2 = self->f->pushInt(self, 1); 9921 ck_assert_ptr_ne(r2, null); 9922 r2 = self->f->pushDouble(self, 2); 9923 ck_assert_ptr_ne(r2, null); 9924 r2 = self->f->pushInt(self, 3); 9925 ck_assert_ptr_ne(r2, null); 9926 r2 = self->f->pushDouble(self, 4); 9927 ck_assert_ptr_ne(r2, null); 9928 9929 // positive index 9930 r = self->f->getAtDoubleP(self,1); 9931 ck_assert_ptr_ne(r, null); 9932 ck_assert(*r==2); 9933 char *s = toStringO(self); 9934 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 9935 free(s); 9936 // negative index 9937 r = self->f->getAtDoubleP(self,-1); 9938 ck_assert_ptr_ne(r, null); 9939 ck_assert(*r==4); 9940 s = toStringO(self); 9941 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 9942 free(s); 9943 // wrong object type 9944 createSmallInt(I); 9945 setValG(&I, 11); 9946 r2 = self->f->pushSmallInt(self, &I); 9947 r = self->f->getAtDoubleP(self,-1); 9948 ck_assert_ptr_eq(r, null); 9949 s = toStringO(self); 9950 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11]"); 9951 free(s); 9952 // wrong object type of another user class 9953 // User classes are stored in containers transparently 9954 createAllocateSmallInt(ip); 9955 ip->type = "anothertype"; 9956 setValG(ip, 11); 9957 r2 = self->f->push(self, (baset*)ip); 9958 ck_assert_ptr_ne(r2, null); 9959 r = self->f->getAtDoubleP(self,-1); 9960 ck_assert_ptr_eq(r, null); 9961 s = toStringO(self); 9962 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11,\"<data container>\"]"); 9963 free(s); 9964 // index outside 9965 ck_assert(!self->f->getAtDoubleP(self, 20)); 9966 ck_assert(!self->f->getAtDoubleP(self, -7)); 9967 // empty list 9968 emptyO(self); 9969 ck_assert(!self->f->getAtDoubleP(self, 0)); 9970 ck_assert(!self->f->getAtDoubleP(self, -1)); 9971 terminateO(self); 9972 9973 } 9974 9975 9976 void getAtIntSmallArrayT(CuTest *tc UNUSED) { 9977 9978 int64_t r; 9979 smallArrayt *self = allocG(rtSmallArrayt); 9980 smallArrayt *r2; 9981 9982 // add elements to self 9983 r2 = self->f->pushInt(self, 1); 9984 ck_assert_ptr_ne(r2, null); 9985 r2 = self->f->pushInt(self, 2); 9986 ck_assert_ptr_ne(r2, null); 9987 r2 = self->f->pushInt(self, 3); 9988 ck_assert_ptr_ne(r2, null); 9989 r2 = self->f->pushInt(self, 4); 9990 ck_assert_ptr_ne(r2, null); 9991 9992 // positive index 9993 r = self->f->getAtInt(self,1); 9994 ck_assert(r==2); 9995 char *s = toStringO(self); 9996 ck_assert_str_eq(s, "[1,2,3,4]"); 9997 free(s); 9998 // negative index 9999 r = self->f->getAtInt(self,-1); 10000 ck_assert(r==4); 10001 s = toStringO(self); 10002 ck_assert_str_eq(s, "[1,2,3,4]"); 10003 free(s); 10004 // wrong object type 10005 createSmallDouble(I); 10006 setValG(&I, 11); 10007 r2 = self->f->pushSmallDouble(self, &I); 10008 r = self->f->getAtInt(self,-1); 10009 ck_assert(!r); 10010 s = toStringO(self); 10011 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10012 free(s); 10013 // wrong object type of another user class 10014 // User classes are stored in containers transparently 10015 createAllocateSmallInt(ip); 10016 ip->type = "anothertype"; 10017 setValG(ip, 11); 10018 r2 = self->f->push(self, (baset*)ip); 10019 ck_assert_ptr_ne(r2, null); 10020 r = self->f->getAtInt(self,-1); 10021 ck_assert(!r); 10022 s = toStringO(self); 10023 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10024 free(s); 10025 // index outside 10026 ck_assert(!self->f->getAtInt(self, 20)); 10027 ck_assert(!self->f->getAtInt(self, -7)); 10028 // empty list 10029 emptyO(self); 10030 ck_assert(!self->f->getAtInt(self, 0)); 10031 ck_assert(!self->f->getAtInt(self, -1)); 10032 terminateO(self); 10033 10034 } 10035 10036 10037 void getAtIntPSmallArrayT(CuTest *tc UNUSED) { 10038 10039 int64_t* r; 10040 smallArrayt *self = allocG(rtSmallArrayt); 10041 smallArrayt *r2; 10042 10043 // add elements to self 10044 r2 = self->f->pushInt(self, 1); 10045 ck_assert_ptr_ne(r2, null); 10046 r2 = self->f->pushInt(self, 2); 10047 ck_assert_ptr_ne(r2, null); 10048 r2 = self->f->pushInt(self, 3); 10049 ck_assert_ptr_ne(r2, null); 10050 r2 = self->f->pushInt(self, 4); 10051 ck_assert_ptr_ne(r2, null); 10052 10053 // positive index 10054 r = self->f->getAtIntP(self,1); 10055 ck_assert_ptr_ne(r, null); 10056 ck_assert(*r==2); 10057 char *s = toStringO(self); 10058 ck_assert_str_eq(s, "[1,2,3,4]"); 10059 free(s); 10060 // negative index 10061 r = self->f->getAtIntP(self,-1); 10062 ck_assert_ptr_ne(r, null); 10063 ck_assert(*r==4); 10064 s = toStringO(self); 10065 ck_assert_str_eq(s, "[1,2,3,4]"); 10066 free(s); 10067 // wrong object type 10068 createSmallDouble(I); 10069 setValG(&I, 11); 10070 r2 = self->f->pushSmallDouble(self, &I); 10071 r = self->f->getAtIntP(self,-1); 10072 ck_assert_ptr_eq(r, null); 10073 s = toStringO(self); 10074 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10075 free(s); 10076 // wrong object type of another user class 10077 // User classes are stored in containers transparently 10078 createAllocateSmallInt(ip); 10079 ip->type = "anothertype"; 10080 setValG(ip, 11); 10081 r2 = self->f->push(self, (baset*)ip); 10082 ck_assert_ptr_ne(r2, null); 10083 r = self->f->getAtIntP(self,-1); 10084 ck_assert_ptr_eq(r, null); 10085 s = toStringO(self); 10086 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10087 free(s); 10088 // index outside 10089 ck_assert(!self->f->getAtIntP(self, 20)); 10090 ck_assert(!self->f->getAtIntP(self, -7)); 10091 // empty list 10092 emptyO(self); 10093 ck_assert(!self->f->getAtIntP(self, 0)); 10094 ck_assert(!self->f->getAtIntP(self, -1)); 10095 terminateO(self); 10096 10097 } 10098 10099 10100 void getAtInt32SmallArrayT(CuTest *tc UNUSED) { 10101 10102 int32_t r; 10103 smallArrayt *self = allocG(rtSmallArrayt); 10104 smallArrayt *r2; 10105 10106 // add elements to self 10107 r2 = self->f->pushInt(self, 1); 10108 ck_assert_ptr_ne(r2, null); 10109 r2 = self->f->pushInt(self, 2); 10110 ck_assert_ptr_ne(r2, null); 10111 r2 = self->f->pushInt(self, 3); 10112 ck_assert_ptr_ne(r2, null); 10113 r2 = self->f->pushInt(self, 4); 10114 ck_assert_ptr_ne(r2, null); 10115 10116 // positive index 10117 r = self->f->getAtInt32(self,1); 10118 ck_assert(r==2); 10119 char *s = toStringO(self); 10120 ck_assert_str_eq(s, "[1,2,3,4]"); 10121 free(s); 10122 // negative index 10123 r = self->f->getAtInt32(self,-1); 10124 ck_assert(r==4); 10125 s = toStringO(self); 10126 ck_assert_str_eq(s, "[1,2,3,4]"); 10127 free(s); 10128 // wrong object type 10129 createSmallDouble(I); 10130 setValG(&I, 11); 10131 r2 = self->f->pushSmallDouble(self, &I); 10132 r = self->f->getAtInt32(self,-1); 10133 ck_assert(!r); 10134 s = toStringO(self); 10135 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10136 free(s); 10137 // wrong object type of another user class 10138 // User classes are stored in containers transparently 10139 createAllocateSmallInt(ip); 10140 ip->type = "anothertype"; 10141 setValG(ip, 11); 10142 r2 = self->f->push(self, (baset*)ip); 10143 ck_assert_ptr_ne(r2, null); 10144 r = self->f->getAtInt32(self,-1); 10145 ck_assert(!r); 10146 s = toStringO(self); 10147 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10148 free(s); 10149 // index outside 10150 ck_assert(!self->f->getAtInt32(self, 20)); 10151 ck_assert(!self->f->getAtInt32(self, -7)); 10152 // empty list 10153 emptyO(self); 10154 ck_assert(!self->f->getAtInt32(self, 0)); 10155 ck_assert(!self->f->getAtInt32(self, -1)); 10156 terminateO(self); 10157 10158 } 10159 10160 10161 void getAtInt32PSmallArrayT(CuTest *tc UNUSED) { 10162 10163 int32_t* r; 10164 smallArrayt *self = allocG(rtSmallArrayt); 10165 smallArrayt *r2; 10166 10167 // add elements to self 10168 r2 = self->f->pushInt(self, 1); 10169 ck_assert_ptr_ne(r2, null); 10170 r2 = self->f->pushInt(self, 2); 10171 ck_assert_ptr_ne(r2, null); 10172 r2 = self->f->pushInt(self, 3); 10173 ck_assert_ptr_ne(r2, null); 10174 r2 = self->f->pushInt(self, 4); 10175 ck_assert_ptr_ne(r2, null); 10176 10177 // positive index 10178 r = self->f->getAtInt32P(self,1); 10179 ck_assert_ptr_ne(r, null); 10180 ck_assert(*r==2); 10181 char *s = toStringO(self); 10182 ck_assert_str_eq(s, "[1,2,3,4]"); 10183 free(s); 10184 // negative index 10185 r = self->f->getAtInt32P(self,-1); 10186 ck_assert_ptr_ne(r, null); 10187 ck_assert(*r==4); 10188 s = toStringO(self); 10189 ck_assert_str_eq(s, "[1,2,3,4]"); 10190 free(s); 10191 // wrong object type 10192 createSmallDouble(I); 10193 setValG(&I, 11); 10194 r2 = self->f->pushSmallDouble(self, &I); 10195 r = self->f->getAtInt32P(self,-1); 10196 ck_assert_ptr_eq(r, null); 10197 s = toStringO(self); 10198 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10199 free(s); 10200 // wrong object type of another user class 10201 // User classes are stored in containers transparently 10202 createAllocateSmallInt(ip); 10203 ip->type = "anothertype"; 10204 setValG(ip, 11); 10205 r2 = self->f->push(self, (baset*)ip); 10206 ck_assert_ptr_ne(r2, null); 10207 r = self->f->getAtInt32P(self,-1); 10208 ck_assert_ptr_eq(r, null); 10209 s = toStringO(self); 10210 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10211 free(s); 10212 // index outside 10213 ck_assert(!self->f->getAtInt32P(self, 20)); 10214 ck_assert(!self->f->getAtInt32P(self, -7)); 10215 // empty list 10216 emptyO(self); 10217 ck_assert(!self->f->getAtInt32P(self, 0)); 10218 ck_assert(!self->f->getAtInt32P(self, -1)); 10219 terminateO(self); 10220 10221 } 10222 10223 10224 void getAtUintSmallArrayT(CuTest *tc UNUSED) { 10225 10226 uint64_t r; 10227 smallArrayt *self = allocG(rtSmallArrayt); 10228 smallArrayt *r2; 10229 10230 // add elements to self 10231 r2 = self->f->pushInt(self, 1); 10232 ck_assert_ptr_ne(r2, null); 10233 r2 = self->f->pushInt(self, 2); 10234 ck_assert_ptr_ne(r2, null); 10235 r2 = self->f->pushInt(self, 3); 10236 ck_assert_ptr_ne(r2, null); 10237 r2 = self->f->pushInt(self, 4); 10238 ck_assert_ptr_ne(r2, null); 10239 10240 // positive index 10241 r = self->f->getAtUint(self,1); 10242 ck_assert(r==2); 10243 char *s = toStringO(self); 10244 ck_assert_str_eq(s, "[1,2,3,4]"); 10245 free(s); 10246 // negative index 10247 r = self->f->getAtUint(self,-1); 10248 ck_assert(r==4); 10249 s = toStringO(self); 10250 ck_assert_str_eq(s, "[1,2,3,4]"); 10251 free(s); 10252 // wrong object type 10253 createSmallDouble(I); 10254 setValG(&I, 11); 10255 r2 = self->f->pushSmallDouble(self, &I); 10256 r = self->f->getAtUint(self,-1); 10257 ck_assert(!r); 10258 s = toStringO(self); 10259 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10260 free(s); 10261 // wrong object type of another user class 10262 // User classes are stored in containers transparently 10263 createAllocateSmallInt(ip); 10264 ip->type = "anothertype"; 10265 setValG(ip, 11); 10266 r2 = self->f->push(self, (baset*)ip); 10267 ck_assert_ptr_ne(r2, null); 10268 r = self->f->getAtUint(self,-1); 10269 ck_assert(!r); 10270 s = toStringO(self); 10271 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10272 free(s); 10273 // index outside 10274 ck_assert(!self->f->getAtUint(self, 20)); 10275 ck_assert(!self->f->getAtUint(self, -7)); 10276 // empty list 10277 emptyO(self); 10278 ck_assert(!self->f->getAtUint(self, 0)); 10279 ck_assert(!self->f->getAtUint(self, -1)); 10280 terminateO(self); 10281 10282 } 10283 10284 10285 void getAtUintPSmallArrayT(CuTest *tc UNUSED) { 10286 10287 uint64_t* r; 10288 smallArrayt *self = allocG(rtSmallArrayt); 10289 smallArrayt *r2; 10290 10291 // add elements to self 10292 r2 = self->f->pushInt(self, 1); 10293 ck_assert_ptr_ne(r2, null); 10294 r2 = self->f->pushInt(self, 2); 10295 ck_assert_ptr_ne(r2, null); 10296 r2 = self->f->pushInt(self, 3); 10297 ck_assert_ptr_ne(r2, null); 10298 r2 = self->f->pushInt(self, 4); 10299 ck_assert_ptr_ne(r2, null); 10300 10301 // positive index 10302 r = self->f->getAtUintP(self,1); 10303 ck_assert_ptr_ne(r, null); 10304 ck_assert(*r==2); 10305 char *s = toStringO(self); 10306 ck_assert_str_eq(s, "[1,2,3,4]"); 10307 free(s); 10308 // negative index 10309 r = self->f->getAtUintP(self,-1); 10310 ck_assert_ptr_ne(r, null); 10311 ck_assert(*r==4); 10312 s = toStringO(self); 10313 ck_assert_str_eq(s, "[1,2,3,4]"); 10314 free(s); 10315 // wrong object type 10316 createSmallDouble(I); 10317 setValG(&I, 11); 10318 r2 = self->f->pushSmallDouble(self, &I); 10319 r = self->f->getAtUintP(self,-1); 10320 ck_assert_ptr_eq(r, null); 10321 s = toStringO(self); 10322 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10323 free(s); 10324 // wrong object type of another user class 10325 // User classes are stored in containers transparently 10326 createAllocateSmallInt(ip); 10327 ip->type = "anothertype"; 10328 setValG(ip, 11); 10329 r2 = self->f->push(self, (baset*)ip); 10330 ck_assert_ptr_ne(r2, null); 10331 r = self->f->getAtUintP(self,-1); 10332 ck_assert_ptr_eq(r, null); 10333 s = toStringO(self); 10334 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10335 free(s); 10336 // index outside 10337 ck_assert(!self->f->getAtUintP(self, 20)); 10338 ck_assert(!self->f->getAtUintP(self, -7)); 10339 // empty list 10340 emptyO(self); 10341 ck_assert(!self->f->getAtUintP(self, 0)); 10342 ck_assert(!self->f->getAtUintP(self, -1)); 10343 terminateO(self); 10344 10345 } 10346 10347 10348 void getAtUint32SmallArrayT(CuTest *tc UNUSED) { 10349 10350 uint32_t r; 10351 smallArrayt *self = allocG(rtSmallArrayt); 10352 smallArrayt *r2; 10353 10354 // add elements to self 10355 r2 = self->f->pushInt(self, 1); 10356 ck_assert_ptr_ne(r2, null); 10357 r2 = self->f->pushInt(self, 2); 10358 ck_assert_ptr_ne(r2, null); 10359 r2 = self->f->pushInt(self, 3); 10360 ck_assert_ptr_ne(r2, null); 10361 r2 = self->f->pushInt(self, 4); 10362 ck_assert_ptr_ne(r2, null); 10363 10364 // positive index 10365 r = self->f->getAtUint32(self,1); 10366 ck_assert(r==2); 10367 char *s = toStringO(self); 10368 ck_assert_str_eq(s, "[1,2,3,4]"); 10369 free(s); 10370 // negative index 10371 r = self->f->getAtUint32(self,-1); 10372 ck_assert(r==4); 10373 s = toStringO(self); 10374 ck_assert_str_eq(s, "[1,2,3,4]"); 10375 free(s); 10376 // wrong object type 10377 createSmallDouble(I); 10378 setValG(&I, 11); 10379 r2 = self->f->pushSmallDouble(self, &I); 10380 r = self->f->getAtUint32(self,-1); 10381 ck_assert(!r); 10382 s = toStringO(self); 10383 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10384 free(s); 10385 // wrong object type of another user class 10386 // User classes are stored in containers transparently 10387 createAllocateSmallInt(ip); 10388 ip->type = "anothertype"; 10389 setValG(ip, 11); 10390 r2 = self->f->push(self, (baset*)ip); 10391 ck_assert_ptr_ne(r2, null); 10392 r = self->f->getAtUint32(self,-1); 10393 ck_assert(!r); 10394 s = toStringO(self); 10395 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10396 free(s); 10397 // index outside 10398 ck_assert(!self->f->getAtUint32(self, 20)); 10399 ck_assert(!self->f->getAtUint32(self, -7)); 10400 // empty list 10401 emptyO(self); 10402 ck_assert(!self->f->getAtUint32(self, 0)); 10403 ck_assert(!self->f->getAtUint32(self, -1)); 10404 terminateO(self); 10405 10406 } 10407 10408 10409 void getAtUint32PSmallArrayT(CuTest *tc UNUSED) { 10410 10411 uint32_t* r; 10412 smallArrayt *self = allocG(rtSmallArrayt); 10413 smallArrayt *r2; 10414 10415 // add elements to self 10416 r2 = self->f->pushInt(self, 1); 10417 ck_assert_ptr_ne(r2, null); 10418 r2 = self->f->pushInt(self, 2); 10419 ck_assert_ptr_ne(r2, null); 10420 r2 = self->f->pushInt(self, 3); 10421 ck_assert_ptr_ne(r2, null); 10422 r2 = self->f->pushInt(self, 4); 10423 ck_assert_ptr_ne(r2, null); 10424 10425 // positive index 10426 r = self->f->getAtUint32P(self,1); 10427 ck_assert_ptr_ne(r, null); 10428 ck_assert(*r==2); 10429 char *s = toStringO(self); 10430 ck_assert_str_eq(s, "[1,2,3,4]"); 10431 free(s); 10432 // negative index 10433 r = self->f->getAtUint32P(self,-1); 10434 ck_assert_ptr_ne(r, null); 10435 ck_assert(*r==4); 10436 s = toStringO(self); 10437 ck_assert_str_eq(s, "[1,2,3,4]"); 10438 free(s); 10439 // wrong object type 10440 createSmallDouble(I); 10441 setValG(&I, 11); 10442 r2 = self->f->pushSmallDouble(self, &I); 10443 r = self->f->getAtUint32P(self,-1); 10444 ck_assert_ptr_eq(r, null); 10445 s = toStringO(self); 10446 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 10447 free(s); 10448 // wrong object type of another user class 10449 // User classes are stored in containers transparently 10450 createAllocateSmallInt(ip); 10451 ip->type = "anothertype"; 10452 setValG(ip, 11); 10453 r2 = self->f->push(self, (baset*)ip); 10454 ck_assert_ptr_ne(r2, null); 10455 r = self->f->getAtUint32P(self,-1); 10456 ck_assert_ptr_eq(r, null); 10457 s = toStringO(self); 10458 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 10459 free(s); 10460 // index outside 10461 ck_assert(!self->f->getAtUint32P(self, 20)); 10462 ck_assert(!self->f->getAtUint32P(self, -7)); 10463 // empty list 10464 emptyO(self); 10465 ck_assert(!self->f->getAtUint32P(self, 0)); 10466 ck_assert(!self->f->getAtUint32P(self, -1)); 10467 terminateO(self); 10468 10469 } 10470 10471 10472 void getAtSSmallArrayT(CuTest *tc UNUSED) { 10473 10474 char* r; 10475 smallArrayt *self = allocG(rtSmallArrayt); 10476 smallArrayt *r2; 10477 10478 // add elements to self 10479 r2 = self->f->pushInt(self, 1); 10480 ck_assert_ptr_ne(r2, null); 10481 r2 = self->f->pushS(self, "2"); 10482 ck_assert_ptr_ne(r2, null); 10483 r2 = self->f->pushInt(self, 3); 10484 ck_assert_ptr_ne(r2, null); 10485 r2 = self->f->pushS(self, "4"); 10486 ck_assert_ptr_ne(r2, null); 10487 10488 // positive index 10489 r = self->f->getAtS(self,1); 10490 ck_assert_ptr_ne(r, null); 10491 ck_assert_str_eq(r, "2"); 10492 char *s = toStringO(self); 10493 ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]"); 10494 free(s); 10495 // negative index 10496 r = self->f->getAtS(self,-1); 10497 ck_assert_ptr_ne(r, null); 10498 ck_assert_str_eq(r, "4"); 10499 s = toStringO(self); 10500 ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]"); 10501 free(s); 10502 // wrong object type 10503 createSmallInt(I); 10504 setValG(&I, 11); 10505 r2 = self->f->pushSmallInt(self, &I); 10506 r = self->f->getAtS(self,-1); 10507 ck_assert_ptr_eq(r, NULL); 10508 s = toStringO(self); 10509 ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11]"); 10510 free(s); 10511 // wrong object type of another user class 10512 // User classes are stored in containers transparently 10513 createAllocateSmallInt(ip); 10514 ip->type = "anothertype"; 10515 setValG(ip, 11); 10516 r2 = self->f->push(self, (baset*)ip); 10517 ck_assert_ptr_ne(r2, null); 10518 r = self->f->getAtS(self,-1); 10519 ck_assert_ptr_eq(r, NULL); 10520 s = toStringO(self); 10521 ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11,\"<data container>\"]"); 10522 free(s); 10523 // index outside 10524 ck_assert_ptr_eq(self->f->getAtS(self, 20), NULL); 10525 ck_assert_ptr_eq(self->f->getAtS(self, -7), NULL); 10526 // empty list 10527 emptyO(self); 10528 ck_assert_ptr_eq(self->f->getAtS(self, 0), NULL); 10529 ck_assert_ptr_eq(self->f->getAtS(self, -1), NULL); 10530 terminateO(self); 10531 10532 } 10533 10534 10535 void getAtDictSmallArrayT(CuTest *tc UNUSED) { 10536 10537 smallDictt* r; 10538 smallArrayt *self = allocG(rtSmallArrayt); 10539 smallArrayt *r2; 10540 10541 // add elements to self 10542 r2 = self->f->pushInt(self, 1); 10543 ck_assert_ptr_ne(r2, null); 10544 createSmallDict(e2); 10545 r2 = self->f->pushDict(self, &e2); 10546 ck_assert_ptr_ne(r2, null); 10547 r2 = self->f->pushInt(self, 3); 10548 ck_assert_ptr_ne(r2, null); 10549 createSmallDict(e4); 10550 r2 = self->f->pushDict(self, &e4); 10551 ck_assert_ptr_ne(r2, null); 10552 10553 // positive index 10554 r = self->f->getAtDict(self,1); 10555 ck_assert_ptr_ne(r, null); 10556 char *s = toStringO(r); 10557 finishO(r); 10558 ck_assert_str_eq(s, "{}"); 10559 free(s); 10560 s = toStringO(self); 10561 ck_assert_str_eq(s, "[1,{},3,{}]"); 10562 free(s); 10563 // negative index 10564 r = self->f->getAtDict(self,-1); 10565 ck_assert_ptr_ne(r, null); 10566 s = toStringO(r); 10567 finishO(r); 10568 ck_assert_str_eq(s, "{}"); 10569 free(s); 10570 s = toStringO(self); 10571 ck_assert_str_eq(s, "[1,{},3,{}]"); 10572 free(s); 10573 // wrong object type 10574 createSmallInt(I); 10575 setValG(&I, 11); 10576 r2 = self->f->pushSmallInt(self, &I); 10577 r = self->f->getAtDict(self,-1); 10578 ck_assert_ptr_eq(r, NULL); 10579 s = toStringO(self); 10580 ck_assert_str_eq(s, "[1,{},3,{},11]"); 10581 free(s); 10582 // wrong object type of another user class 10583 // User classes are stored in containers transparently 10584 createAllocateSmallInt(ip); 10585 ip->type = "anothertype"; 10586 setValG(ip, 11); 10587 r2 = self->f->push(self, (baset*)ip); 10588 ck_assert_ptr_ne(r2, null); 10589 r = self->f->getAtDict(self,-1); 10590 ck_assert_ptr_eq(r, NULL); 10591 s = toStringO(self); 10592 ck_assert_str_eq(s, "[1,{},3,{},11,\"<data container>\"]"); 10593 free(s); 10594 // index outside 10595 ck_assert_ptr_eq(self->f->getAtDict(self, 20), NULL); 10596 ck_assert_ptr_eq(self->f->getAtDict(self, -7), NULL); 10597 // empty list 10598 emptyO(self); 10599 ck_assert_ptr_eq(self->f->getAtDict(self, 0), NULL); 10600 ck_assert_ptr_eq(self->f->getAtDict(self, -1), NULL); 10601 // get empty slot in array 10602 r2 = self->f->pushUndefined(self); 10603 ck_assert_ptr_ne(r2, null); 10604 delElemO(self,0); 10605 ck_assert_ptr_eq(self->f->getAtDict(self, 0), NULL); 10606 terminateO(self); 10607 10608 } 10609 10610 10611 void getAtArraySmallArrayT(CuTest *tc UNUSED) { 10612 10613 smallArrayt* r; 10614 smallArrayt *self = allocG(rtSmallArrayt); 10615 smallArrayt *r2; 10616 10617 // add elements to self 10618 r2 = self->f->pushInt(self, 1); 10619 ck_assert_ptr_ne(r2, null); 10620 createSmallArray(e2); 10621 r2 = self->f->pushArray(self, &e2); 10622 ck_assert_ptr_ne(r2, null); 10623 r2 = self->f->pushInt(self, 3); 10624 ck_assert_ptr_ne(r2, null); 10625 createSmallArray(e4); 10626 r2 = self->f->pushArray(self, &e4); 10627 ck_assert_ptr_ne(r2, null); 10628 10629 // positive index 10630 r = self->f->getAtArray(self,1); 10631 ck_assert_ptr_ne(r, null); 10632 char *s = toStringO(r); 10633 finishO(r); 10634 ck_assert_str_eq(s, "[]"); 10635 free(s); 10636 s = toStringO(self); 10637 ck_assert_str_eq(s, "[1,[],3,[]]"); 10638 free(s); 10639 // negative index 10640 r = self->f->getAtArray(self,-1); 10641 ck_assert_ptr_ne(r, null); 10642 s = toStringO(r); 10643 finishO(r); 10644 ck_assert_str_eq(s, "[]"); 10645 free(s); 10646 s = toStringO(self); 10647 ck_assert_str_eq(s, "[1,[],3,[]]"); 10648 free(s); 10649 // wrong object type 10650 createSmallInt(I); 10651 setValG(&I, 11); 10652 r2 = self->f->pushSmallInt(self, &I); 10653 r = self->f->getAtArray(self,-1); 10654 ck_assert_ptr_eq(r, NULL); 10655 s = toStringO(self); 10656 ck_assert_str_eq(s, "[1,[],3,[],11]"); 10657 free(s); 10658 // wrong object type of another user class 10659 // User classes are stored in containers transparently 10660 createAllocateSmallInt(ip); 10661 ip->type = "anothertype"; 10662 setValG(ip, 11); 10663 r2 = self->f->push(self, (baset*)ip); 10664 ck_assert_ptr_ne(r2, null); 10665 r = self->f->getAtArray(self,-1); 10666 ck_assert_ptr_eq(r, NULL); 10667 s = toStringO(self); 10668 ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]"); 10669 free(s); 10670 // index outside 10671 ck_assert_ptr_eq(self->f->getAtArray(self, 20), NULL); 10672 ck_assert_ptr_eq(self->f->getAtArray(self, -7), NULL); 10673 // empty list 10674 emptyO(self); 10675 ck_assert_ptr_eq(self->f->getAtArray(self, 0), NULL); 10676 ck_assert_ptr_eq(self->f->getAtArray(self, -1), NULL); 10677 // get empty slot in array 10678 r2 = self->f->pushUndefined(self); 10679 ck_assert_ptr_ne(r2, null); 10680 delElemO(self,0); 10681 ck_assert_ptr_eq(self->f->getAtArray(self, 0), NULL); 10682 terminateO(self); 10683 10684 } 10685 10686 10687 void getAtSmallBoolSmallArrayT(CuTest *tc UNUSED) { 10688 10689 smallBoolt* r; 10690 smallArrayt *self = allocG(rtSmallArrayt); 10691 smallArrayt *r2; 10692 10693 // add elements to self 10694 r2 = self->f->pushInt(self, 1); 10695 ck_assert_ptr_ne(r2, null); 10696 createSmallBool(e2); 10697 r2 = self->f->pushBool(self, true); 10698 ck_assert_ptr_ne(r2, null); 10699 r2 = self->f->pushInt(self, 3); 10700 ck_assert_ptr_ne(r2, null); 10701 createSmallBool(e4); 10702 r2 = self->f->pushBool(self, true); 10703 ck_assert_ptr_ne(r2, null); 10704 10705 // positive index 10706 r = self->f->getAtSmallBool(self,1); 10707 ck_assert_ptr_ne(r, null); 10708 char *s = toStringO(r); 10709 finishO(r); 10710 ck_assert_str_eq(s, "true"); 10711 free(s); 10712 s = toStringO(self); 10713 ck_assert_str_eq(s, "[1,true,3,true]"); 10714 free(s); 10715 // negative index 10716 r = self->f->getAtSmallBool(self,-1); 10717 ck_assert_ptr_ne(r, null); 10718 s = toStringO(r); 10719 finishO(r); 10720 ck_assert_str_eq(s, "true"); 10721 free(s); 10722 s = toStringO(self); 10723 ck_assert_str_eq(s, "[1,true,3,true]"); 10724 free(s); 10725 // wrong object type 10726 createSmallInt(I); 10727 setValG(&I, 11); 10728 r2 = self->f->pushSmallInt(self, &I); 10729 r = self->f->getAtSmallBool(self,2); 10730 ck_assert_ptr_eq(r, NULL); 10731 s = toStringO(self); 10732 ck_assert_str_eq(s, "[1,true,3,true,11]"); 10733 free(s); 10734 // wrong object type of another user class 10735 // User classes are stored in containers transparently 10736 createAllocateSmallInt(ip); 10737 ip->type = "anothertype"; 10738 setValG(ip, 11); 10739 r2 = self->f->push(self, (baset*)ip); 10740 ck_assert_ptr_ne(r2, null); 10741 r = self->f->getAtSmallBool(self,-1); 10742 ck_assert_ptr_eq(r, NULL); 10743 s = toStringO(self); 10744 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 10745 free(s); 10746 // index outside 10747 ck_assert_ptr_eq(self->f->getAtSmallBool(self, 20), NULL); 10748 ck_assert_ptr_eq(self->f->getAtSmallBool(self, -7), NULL); 10749 // empty list 10750 emptyO(self); 10751 ck_assert_ptr_eq(self->f->getAtSmallBool(self, 0), NULL); 10752 ck_assert_ptr_eq(self->f->getAtSmallBool(self, -1), NULL); 10753 // get empty slot in array 10754 r2 = self->f->pushUndefined(self); 10755 ck_assert_ptr_ne(r2, null); 10756 delElemO(self,0); 10757 ck_assert_ptr_eq(self->f->getAtSmallBool(self, 0), NULL); 10758 terminateO(self); 10759 10760 } 10761 10762 10763 void getAtSmallBytesSmallArrayT(CuTest *tc UNUSED) { 10764 10765 smallBytest* r; 10766 smallArrayt *self = allocG(rtSmallArrayt); 10767 smallArrayt *r2; 10768 10769 // add elements to self 10770 r2 = self->f->pushInt(self, 1); 10771 ck_assert_ptr_ne(r2, null); 10772 createSmallBytes(e2); 10773 r2 = self->f->pushSmallBytes(self, &e2); 10774 ck_assert_ptr_ne(r2, null); 10775 r2 = self->f->pushInt(self, 3); 10776 ck_assert_ptr_ne(r2, null); 10777 createSmallBytes(e4); 10778 r2 = self->f->pushSmallBytes(self, &e4); 10779 ck_assert_ptr_ne(r2, null); 10780 10781 // positive index 10782 r = self->f->getAtSmallBytes(self,1); 10783 ck_assert_ptr_ne(r, null); 10784 char *s = toStringO(r); 10785 finishO(r); 10786 ck_assert_str_eq(s, "[]"); 10787 free(s); 10788 s = toStringO(self); 10789 ck_assert_str_eq(s, "[1,[],3,[]]"); 10790 free(s); 10791 // negative index 10792 r = self->f->getAtSmallBytes(self,-1); 10793 ck_assert_ptr_ne(r, null); 10794 s = toStringO(r); 10795 finishO(r); 10796 ck_assert_str_eq(s, "[]"); 10797 free(s); 10798 s = toStringO(self); 10799 ck_assert_str_eq(s, "[1,[],3,[]]"); 10800 free(s); 10801 // wrong object type 10802 createSmallInt(I); 10803 setValG(&I, 11); 10804 r2 = self->f->pushSmallInt(self, &I); 10805 r = self->f->getAtSmallBytes(self,-1); 10806 ck_assert_ptr_eq(r, NULL); 10807 s = toStringO(self); 10808 ck_assert_str_eq(s, "[1,[],3,[],11]"); 10809 free(s); 10810 // wrong object type of another user class 10811 // User classes are stored in containers transparently 10812 createAllocateSmallInt(ip); 10813 ip->type = "anothertype"; 10814 setValG(ip, 11); 10815 r2 = self->f->push(self, (baset*)ip); 10816 ck_assert_ptr_ne(r2, null); 10817 r = self->f->getAtSmallBytes(self,-1); 10818 ck_assert_ptr_eq(r, NULL); 10819 s = toStringO(self); 10820 ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]"); 10821 free(s); 10822 // index outside 10823 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, 20), NULL); 10824 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, -7), NULL); 10825 // empty list 10826 emptyO(self); 10827 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, 0), NULL); 10828 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, -1), NULL); 10829 // get empty slot in array 10830 r2 = self->f->pushUndefined(self); 10831 ck_assert_ptr_ne(r2, null); 10832 delElemO(self,0); 10833 ck_assert_ptr_eq(self->f->getAtSmallBytes(self, 0), NULL); 10834 terminateO(self); 10835 10836 } 10837 10838 10839 void getAtSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 10840 10841 smallDoublet* r; 10842 smallArrayt *self = allocG(rtSmallArrayt); 10843 smallArrayt *r2; 10844 10845 // add elements to self 10846 r2 = self->f->pushInt(self, 1); 10847 ck_assert_ptr_ne(r2, null); 10848 createSmallDouble(e2); 10849 r2 = self->f->pushSmallDouble(self, &e2); 10850 ck_assert_ptr_ne(r2, null); 10851 r2 = self->f->pushInt(self, 3); 10852 ck_assert_ptr_ne(r2, null); 10853 createSmallDouble(e4); 10854 r2 = self->f->pushSmallDouble(self, &e4); 10855 ck_assert_ptr_ne(r2, null); 10856 10857 // positive index 10858 r = self->f->getAtSmallDouble(self,1); 10859 ck_assert_ptr_ne(r, null); 10860 char *s = toStringO(r); 10861 finishO(r); 10862 ck_assert_str_eq(s, "0.000000e+00"); 10863 free(s); 10864 s = toStringO(self); 10865 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]"); 10866 free(s); 10867 // negative index 10868 r = self->f->getAtSmallDouble(self,-1); 10869 ck_assert_ptr_ne(r, null); 10870 s = toStringO(r); 10871 finishO(r); 10872 ck_assert_str_eq(s, "0.000000e+00"); 10873 free(s); 10874 s = toStringO(self); 10875 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]"); 10876 free(s); 10877 // wrong object type 10878 createSmallInt(I); 10879 setValG(&I, 11); 10880 r2 = self->f->pushSmallInt(self, &I); 10881 r = self->f->getAtSmallDouble(self,-1); 10882 ck_assert_ptr_eq(r, NULL); 10883 s = toStringO(self); 10884 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11]"); 10885 free(s); 10886 // wrong object type of another user class 10887 // User classes are stored in containers transparently 10888 createAllocateSmallInt(ip); 10889 ip->type = "anothertype"; 10890 setValG(ip, 11); 10891 r2 = self->f->push(self, (baset*)ip); 10892 ck_assert_ptr_ne(r2, null); 10893 r = self->f->getAtSmallDouble(self,-1); 10894 ck_assert_ptr_eq(r, NULL); 10895 s = toStringO(self); 10896 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11,\"<data container>\"]"); 10897 free(s); 10898 // index outside 10899 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, 20), NULL); 10900 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, -7), NULL); 10901 // empty list 10902 emptyO(self); 10903 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, 0), NULL); 10904 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, -1), NULL); 10905 // get empty slot in array 10906 r2 = self->f->pushUndefined(self); 10907 ck_assert_ptr_ne(r2, null); 10908 delElemO(self,0); 10909 ck_assert_ptr_eq(self->f->getAtSmallDouble(self, 0), NULL); 10910 terminateO(self); 10911 10912 } 10913 10914 10915 void getAtSmallIntSmallArrayT(CuTest *tc UNUSED) { 10916 10917 smallIntt* r; 10918 smallArrayt *self = allocG(rtSmallArrayt); 10919 smallArrayt *r2; 10920 10921 // add elements to self 10922 r2 = self->f->pushBool(self, true); 10923 ck_assert_ptr_ne(r2, null); 10924 createSmallInt(e2); 10925 r2 = self->f->pushSmallInt(self, &e2); 10926 ck_assert_ptr_ne(r2, null); 10927 r2 = self->f->pushBool(self, true); 10928 ck_assert_ptr_ne(r2, null); 10929 createSmallInt(e4); 10930 r2 = self->f->pushSmallInt(self, &e4); 10931 ck_assert_ptr_ne(r2, null); 10932 10933 // positive index 10934 r = self->f->getAtSmallInt(self,1); 10935 ck_assert_ptr_ne(r, null); 10936 char *s = toStringO(r); 10937 finishO(r); 10938 ck_assert_str_eq(s, "0"); 10939 free(s); 10940 s = toStringO(self); 10941 ck_assert_str_eq(s, "[true,0,true,0]"); 10942 free(s); 10943 // negative index 10944 r = self->f->getAtSmallInt(self,-1); 10945 ck_assert_ptr_ne(r, null); 10946 s = toStringO(r); 10947 finishO(r); 10948 ck_assert_str_eq(s, "0"); 10949 free(s); 10950 s = toStringO(self); 10951 ck_assert_str_eq(s, "[true,0,true,0]"); 10952 free(s); 10953 // wrong object type 10954 createSmallDouble(I); 10955 setValG(&I, 11); 10956 r2 = self->f->pushSmallDouble(self, &I); 10957 r = self->f->getAtSmallInt(self,-1); 10958 ck_assert_ptr_eq(r, NULL); 10959 s = toStringO(self); 10960 ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01]"); 10961 free(s); 10962 // wrong object type of another user class 10963 // User classes are stored in containers transparently 10964 createAllocateSmallInt(ip); 10965 ip->type = "anothertype"; 10966 setValG(ip, 11); 10967 r2 = self->f->push(self, (baset*)ip); 10968 ck_assert_ptr_ne(r2, null); 10969 r = self->f->getAtSmallInt(self,-1); 10970 ck_assert_ptr_eq(r, NULL); 10971 s = toStringO(self); 10972 ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01,\"<data container>\"]"); 10973 free(s); 10974 // index outside 10975 ck_assert_ptr_eq(self->f->getAtSmallInt(self, 20), NULL); 10976 ck_assert_ptr_eq(self->f->getAtSmallInt(self, -7), NULL); 10977 // empty list 10978 emptyO(self); 10979 ck_assert_ptr_eq(self->f->getAtSmallInt(self, 0), NULL); 10980 ck_assert_ptr_eq(self->f->getAtSmallInt(self, -1), NULL); 10981 // get empty slot in array 10982 r2 = self->f->pushUndefined(self); 10983 ck_assert_ptr_ne(r2, null); 10984 delElemO(self,0); 10985 ck_assert_ptr_eq(self->f->getAtSmallInt(self, 0), NULL); 10986 terminateO(self); 10987 10988 } 10989 10990 10991 void getAtSmallJsonSmallArrayT(CuTest *tc UNUSED) { 10992 10993 smallJsont* r; 10994 smallArrayt *self = allocG(rtSmallArrayt); 10995 smallArrayt *r2; 10996 10997 // add elements to self 10998 r2 = self->f->pushInt(self, 1); 10999 ck_assert_ptr_ne(r2, null); 11000 createSmallJson(e2); 11001 r2 = self->f->pushSmallJson(self, &e2); 11002 ck_assert_ptr_ne(r2, null); 11003 r2 = self->f->pushInt(self, 3); 11004 ck_assert_ptr_ne(r2, null); 11005 createSmallJson(e4); 11006 r2 = self->f->pushSmallJson(self, &e4); 11007 ck_assert_ptr_ne(r2, null); 11008 11009 // positive index 11010 r = self->f->getAtSmallJson(self,1); 11011 ck_assert_ptr_ne(r, null); 11012 char *s = toStringO(r); 11013 finishO(r); 11014 ck_assert_str_eq(s, "{}"); 11015 free(s); 11016 s = toStringO(self); 11017 ck_assert_str_eq(s, "[1,{},3,{}]"); 11018 free(s); 11019 // negative index 11020 r = self->f->getAtSmallJson(self,-1); 11021 ck_assert_ptr_ne(r, null); 11022 s = toStringO(r); 11023 finishO(r); 11024 ck_assert_str_eq(s, "{}"); 11025 free(s); 11026 s = toStringO(self); 11027 ck_assert_str_eq(s, "[1,{},3,{}]"); 11028 free(s); 11029 // wrong object type 11030 createSmallBytes(I); 11031 r2 = self->f->pushSmallBytes(self, &I); 11032 r = self->f->getAtSmallJson(self,-1); 11033 ck_assert_ptr_eq(r, NULL); 11034 s = toStringO(self); 11035 ck_assert_str_eq(s, "[1,{},3,{},[]]"); 11036 free(s); 11037 // wrong object type of another user class 11038 // User classes are stored in containers transparently 11039 createAllocateSmallInt(ip); 11040 ip->type = "anothertype"; 11041 setValG(ip, 11); 11042 r2 = self->f->push(self, (baset*)ip); 11043 ck_assert_ptr_ne(r2, null); 11044 r = self->f->getAtSmallJson(self,-1); 11045 ck_assert_ptr_eq(r, NULL); 11046 s = toStringO(self); 11047 ck_assert_str_eq(s, "[1,{},3,{},[],\"<data container>\"]"); 11048 free(s); 11049 // index outside 11050 ck_assert_ptr_eq(self->f->getAtSmallJson(self, 20), NULL); 11051 ck_assert_ptr_eq(self->f->getAtSmallJson(self, -7), NULL); 11052 // empty list 11053 emptyO(self); 11054 ck_assert_ptr_eq(self->f->getAtSmallJson(self, 0), NULL); 11055 ck_assert_ptr_eq(self->f->getAtSmallJson(self, -1), NULL); 11056 // get empty slot in array 11057 r2 = self->f->pushUndefined(self); 11058 ck_assert_ptr_ne(r2, null); 11059 delElemO(self,0); 11060 ck_assert_ptr_eq(self->f->getAtSmallJson(self, 0), NULL); 11061 terminateO(self); 11062 11063 } 11064 11065 11066 void getAtSmallStringSmallArrayT(CuTest *tc UNUSED) { 11067 11068 smallStringt* r; 11069 smallArrayt *self = allocG(rtSmallArrayt); 11070 smallArrayt *r2; 11071 11072 // add elements to self 11073 r2 = self->f->pushInt(self, 1); 11074 ck_assert_ptr_ne(r2, null); 11075 createSmallString(e2); 11076 r2 = self->f->pushSmallString(self, &e2); 11077 ck_assert_ptr_ne(r2, null); 11078 r2 = self->f->pushInt(self, 3); 11079 ck_assert_ptr_ne(r2, null); 11080 createSmallString(e4); 11081 r2 = self->f->pushSmallString(self, &e4); 11082 ck_assert_ptr_ne(r2, null); 11083 11084 // positive index 11085 r = self->f->getAtSmallString(self,1); 11086 ck_assert_ptr_ne(r, null); 11087 char *s = toStringO(r); 11088 finishO(r); 11089 ck_assert_str_eq(s, ""); 11090 free(s); 11091 s = toStringO(self); 11092 ck_assert_str_eq(s, "[1,\"\",3,\"\"]"); 11093 free(s); 11094 // negative index 11095 r = self->f->getAtSmallString(self,-1); 11096 ck_assert_ptr_ne(r, null); 11097 s = toStringO(r); 11098 finishO(r); 11099 ck_assert_str_eq(s, ""); 11100 free(s); 11101 s = toStringO(self); 11102 ck_assert_str_eq(s, "[1,\"\",3,\"\"]"); 11103 free(s); 11104 // wrong object type 11105 createSmallInt(I); 11106 setValG(&I, 11); 11107 r2 = self->f->pushSmallInt(self, &I); 11108 r = self->f->getAtSmallString(self,-1); 11109 ck_assert_ptr_eq(r, NULL); 11110 s = toStringO(self); 11111 ck_assert_str_eq(s, "[1,\"\",3,\"\",11]"); 11112 free(s); 11113 // wrong object type of another user class 11114 // User classes are stored in containers transparently 11115 createAllocateSmallInt(ip); 11116 ip->type = "anothertype"; 11117 setValG(ip, 11); 11118 r2 = self->f->push(self, (baset*)ip); 11119 ck_assert_ptr_ne(r2, null); 11120 r = self->f->getAtSmallString(self,-1); 11121 ck_assert_ptr_eq(r, NULL); 11122 s = toStringO(self); 11123 ck_assert_str_eq(s, "[1,\"\",3,\"\",11,\"<data container>\"]"); 11124 free(s); 11125 // index outside 11126 ck_assert_ptr_eq(self->f->getAtSmallString(self, 20), NULL); 11127 ck_assert_ptr_eq(self->f->getAtSmallString(self, -7), NULL); 11128 // empty list 11129 emptyO(self); 11130 ck_assert_ptr_eq(self->f->getAtSmallString(self, 0), NULL); 11131 ck_assert_ptr_eq(self->f->getAtSmallString(self, -1), NULL); 11132 // get empty slot in array 11133 r2 = self->f->pushUndefined(self); 11134 ck_assert_ptr_ne(r2, null); 11135 delElemO(self,0); 11136 ck_assert_ptr_eq(self->f->getAtSmallString(self, 0), NULL); 11137 terminateO(self); 11138 11139 } 11140 11141 11142 void getAtVoidSmallArrayT(CuTest *tc UNUSED) { 11143 11144 void* r; 11145 smallArrayt *self = allocG(rtSmallArrayt); 11146 smallArrayt *r2; 11147 11148 // add elements to self 11149 r2 = self->f->pushInt(self, 1); 11150 ck_assert_ptr_ne(r2, null); 11151 r2 = pushVoidSmallArrayG(self, &r); 11152 ck_assert_ptr_ne(r2, null); 11153 r2 = self->f->pushInt(self, 3); 11154 ck_assert_ptr_ne(r2, null); 11155 r2 = pushVoidSmallArrayG(self, &self); 11156 ck_assert_ptr_ne(r2, null); 11157 11158 // positive index 11159 r = self->f->getAtVoid(self,1); 11160 ck_assert_ptr_eq(r, &r); 11161 char *s = toStringO(self); 11162 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 11163 free(s); 11164 // negative index 11165 r = self->f->getAtVoid(self,-1); 11166 ck_assert_ptr_eq(r, &self); 11167 s = toStringO(self); 11168 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 11169 free(s); 11170 // wrong object type 11171 createSmallInt(I); 11172 setValG(&I, 11); 11173 r2 = self->f->pushSmallInt(self, &I); 11174 r = self->f->getAtVoid(self,-1); 11175 ck_assert_ptr_eq(r, NULL); 11176 s = toStringO(self); 11177 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]"); 11178 free(s); 11179 // wrong object type of another user class 11180 // User classes are stored in containers transparently 11181 createAllocateSmallInt(ip); 11182 ip->type = "anothertype"; 11183 setValG(ip, 11); 11184 r2 = self->f->push(self, (baset*)ip); 11185 ck_assert_ptr_ne(r2, null); 11186 r = self->f->getAtVoid(self,-1); 11187 ck_assert_ptr_eq(r, NULL); 11188 s = toStringO(self); 11189 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]"); 11190 free(s); 11191 // index outside 11192 ck_assert_ptr_eq(self->f->getAtVoid(self, 20), NULL); 11193 ck_assert_ptr_eq(self->f->getAtVoid(self, -7), NULL); 11194 // empty list 11195 emptyO(self); 11196 ck_assert_ptr_eq(self->f->getAtVoid(self, 0), NULL); 11197 ck_assert_ptr_eq(self->f->getAtVoid(self, -1), NULL); 11198 terminateO(self); 11199 11200 } 11201 11202 11203 void getAtSmallContainerSmallArrayT(CuTest *tc UNUSED) { 11204 11205 smallContainert* r; 11206 smallArrayt *self = allocG(rtSmallArrayt); 11207 smallArrayt *r2; 11208 11209 // add elements to self 11210 r2 = self->f->pushInt(self, 1); 11211 ck_assert_ptr_ne(r2, null); 11212 createSmallContainer(e2); 11213 r2 = self->f->pushSmallContainer(self, &e2); 11214 ck_assert_ptr_ne(r2, null); 11215 r2 = self->f->pushInt(self, 3); 11216 ck_assert_ptr_ne(r2, null); 11217 createSmallContainer(e4); 11218 r2 = self->f->pushSmallContainer(self, &e4); 11219 ck_assert_ptr_ne(r2, null); 11220 11221 // positive index 11222 r = self->f->getAtSmallContainer(self,1); 11223 ck_assert_ptr_ne(r, null); 11224 char *s = toStringO(r); 11225 finishO(r); 11226 ck_assert_str_eq(s, "<data smallContainer>"); 11227 free(s); 11228 s = toStringO(self); 11229 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 11230 free(s); 11231 // negative index 11232 r = self->f->getAtSmallContainer(self,-1); 11233 ck_assert_ptr_ne(r, null); 11234 s = toStringO(r); 11235 finishO(r); 11236 ck_assert_str_eq(s, "<data smallContainer>"); 11237 free(s); 11238 s = toStringO(self); 11239 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 11240 free(s); 11241 // wrong object type 11242 createSmallInt(I); 11243 setValG(&I, 11); 11244 r2 = self->f->pushSmallInt(self, &I); 11245 r = self->f->getAtSmallContainer(self,-1); 11246 ck_assert_ptr_eq(r, NULL); 11247 s = toStringO(self); 11248 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]"); 11249 free(s); 11250 // wrong object type of another user class 11251 // User classes are stored in containers transparently 11252 createAllocateSmallInt(ip); 11253 ip->type = "anothertype"; 11254 setValG(ip, 11); 11255 r2 = self->f->push(self, (baset*)ip); 11256 ck_assert_ptr_ne(r2, null); 11257 r = self->f->getAtSmallContainer(self,-1); 11258 ck_assert_ptr_eq(r, NULL); 11259 s = toStringO(self); 11260 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]"); 11261 free(s); 11262 // index outside 11263 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, 20), NULL); 11264 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, -7), NULL); 11265 // empty list 11266 emptyO(self); 11267 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, 0), NULL); 11268 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, -1), NULL); 11269 // get empty slot in array 11270 r2 = self->f->pushUndefined(self); 11271 ck_assert_ptr_ne(r2, null); 11272 delElemO(self,0); 11273 ck_assert_ptr_eq(self->f->getAtSmallContainer(self, 0), NULL); 11274 terminateO(self); 11275 11276 } 11277 11278 11279 void getAtNDupSmallArrayT(CuTest *tc UNUSED) { 11280 11281 baset* r; 11282 smallArrayt *self = allocG(rtSmallArrayt); 11283 smallArrayt *r2; 11284 11285 // add elements to self 11286 r2 = self->f->pushInt(self, 1); 11287 ck_assert_ptr_ne(r2, null); 11288 r2 = self->f->pushInt(self, 2); 11289 ck_assert_ptr_ne(r2, null); 11290 r2 = self->f->pushInt(self, 3); 11291 ck_assert_ptr_ne(r2, null); 11292 r2 = self->f->pushInt(self, 4); 11293 ck_assert_ptr_ne(r2, null); 11294 11295 // positive index 11296 r = self->f->getAtNDup(self,1); 11297 ck_assert_ptr_ne(r, null); 11298 char *s = toStringO(r); 11299 terminateO(r); 11300 ck_assert_str_eq(s, "2"); 11301 free(s); 11302 s = toStringO(self); 11303 ck_assert_str_eq(s, "[1,2,3,4]"); 11304 free(s); 11305 // negative index 11306 r = self->f->getAtNDup(self,-1); 11307 ck_assert_ptr_ne(r, null); 11308 s = toStringO(r); 11309 terminateO(r); 11310 ck_assert_str_eq(s, "4"); 11311 free(s); 11312 s = toStringO(self); 11313 ck_assert_str_eq(s, "[1,2,3,4]"); 11314 free(s); 11315 // undefined object 11316 r2 = self->f->pushUndefined(self); 11317 ck_assert_ptr_ne(r2, null); 11318 r = self->f->getAtNDup(self,-1); 11319 ck_assert_ptr_ne(r, null); 11320 s = toStringO(r); 11321 terminateO(r); 11322 ck_assert_str_eq(s, "null"); 11323 free(s); 11324 s = toStringO(self); 11325 ck_assert_str_eq(s, "[1,2,3,4,null]"); 11326 free(s); 11327 // container 11328 createSmallContainer(c); 11329 r2 = self->f->pushSmallContainer(self, &c); 11330 r = self->f->getAtNDup(self,-1); 11331 ck_assert_ptr_ne(r, null); 11332 s = toStringO(r); 11333 terminateO(r); 11334 ck_assert_str_eq(s, "<data smallContainer>"); 11335 free(s); 11336 s = toStringO(self); 11337 ck_assert_str_eq(s, "[1,2,3,4,null,\"<data container>\"]"); 11338 free(s); 11339 // base object in container 11340 createAllocateSmallInt(I); 11341 setValG(I, 11); 11342 I->type = "anothertype"; 11343 r2 = self->f->push(self, (baset*)I); 11344 r = self->f->getAtNDup(self,-1); 11345 ck_assert_ptr_ne(r, null); 11346 // r->type is not anothertype, because the duplicate function is from the smallInt class 11347 ck_assert_str_eq(r->type, "smallInt"); 11348 s = toStringO(r); 11349 terminateO(r); 11350 ck_assert_str_eq(s, "11"); 11351 free(s); 11352 s = toStringO(self); 11353 ck_assert_str_eq(s, "[1,2,3,4,null,\"<data container>\",\"<data container>\"]"); 11354 free(s); 11355 // index outside 11356 ck_assert_ptr_eq(self->f->getAtNDup(self, 20), NULL); 11357 ck_assert_ptr_eq(self->f->getAtNDup(self, -8), NULL); 11358 // empty list 11359 emptyO(self); 11360 ck_assert_ptr_eq(self->f->getAtNDup(self, 0), NULL); 11361 ck_assert_ptr_eq(self->f->getAtNDup(self, -1), NULL); 11362 // get empty slot in array 11363 r2 = self->f->pushUndefined(self); 11364 ck_assert_ptr_ne(r2, null); 11365 delElemO(self,0); 11366 ck_assert_ptr_eq(self->f->getAtNDup(self, 0), NULL); 11367 terminateO(self); 11368 11369 } 11370 11371 11372 void getAtNDupUndefinedSmallArrayT(CuTest *tc UNUSED) { 11373 11374 undefinedt* r; 11375 smallArrayt *self = allocG(rtSmallArrayt); 11376 smallArrayt *r2; 11377 11378 // add elements to self 11379 r2 = self->f->pushInt(self, 1); 11380 ck_assert_ptr_ne(r2, null); 11381 r2 = self->f->pushUndefined(self); 11382 ck_assert_ptr_ne(r2, null); 11383 r2 = self->f->pushInt(self, 3); 11384 ck_assert_ptr_ne(r2, null); 11385 r2 = self->f->pushUndefined(self); 11386 ck_assert_ptr_ne(r2, null); 11387 11388 // positive index 11389 r = self->f->getAtNDupUndefined(self,1); 11390 ck_assert_ptr_ne(r, null); 11391 char *s = toStringO(r); 11392 terminateO(r); 11393 ck_assert_str_eq(s, "null"); 11394 free(s); 11395 s = toStringO(self); 11396 ck_assert_str_eq(s, "[1,null,3,null]"); 11397 free(s); 11398 // negative index 11399 r = self->f->getAtNDupUndefined(self,-1); 11400 ck_assert_ptr_ne(r, null); 11401 s = toStringO(r); 11402 terminateO(r); 11403 ck_assert_str_eq(s, "null"); 11404 free(s); 11405 s = toStringO(self); 11406 ck_assert_str_eq(s, "[1,null,3,null]"); 11407 free(s); 11408 // wrong object type 11409 createSmallInt(I); 11410 setValG(&I, 11); 11411 r2 = self->f->pushSmallInt(self, &I); 11412 ck_assert_ptr_ne(r2, null); 11413 r = self->f->getAtNDupUndefined(self,-1); 11414 ck_assert_ptr_eq(r, null); 11415 s = toStringO(self); 11416 ck_assert_str_eq(s, "[1,null,3,null,11]"); 11417 free(s); 11418 // index outside 11419 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, 20), NULL); 11420 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, -6), NULL); 11421 // empty list 11422 emptyO(self); 11423 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, 0), NULL); 11424 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, -1), NULL); 11425 // get empty slot in array 11426 r2 = self->f->pushUndefined(self); 11427 ck_assert_ptr_ne(r2, null); 11428 delElemO(self,0); 11429 ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, 0), NULL); 11430 terminateO(self); 11431 11432 } 11433 11434 11435 void getAtNDupBoolSmallArrayT(CuTest *tc UNUSED) { 11436 11437 bool r; 11438 smallArrayt *self = allocG(rtSmallArrayt); 11439 smallArrayt *r2; 11440 11441 // add elements to self 11442 r2 = self->f->pushInt(self, 1); 11443 ck_assert_ptr_ne(r2, null); 11444 r2 = self->f->pushBool(self, TRUE); 11445 ck_assert_ptr_ne(r2, null); 11446 r2 = self->f->pushInt(self, 3); 11447 ck_assert_ptr_ne(r2, null); 11448 r2 = self->f->pushBool(self, TRUE); 11449 ck_assert_ptr_ne(r2, null); 11450 11451 // positive index 11452 r = self->f->getAtNDupBool(self,1); 11453 ck_assert(r); 11454 char *s = toStringO(self); 11455 ck_assert_str_eq(s, "[1,true,3,true]"); 11456 free(s); 11457 // negative index 11458 r = self->f->getAtNDupBool(self,-1); 11459 ck_assert(r); 11460 s = toStringO(self); 11461 ck_assert_str_eq(s, "[1,true,3,true]"); 11462 free(s); 11463 // wrong object type 11464 createSmallInt(I); 11465 setValG(&I, 11); 11466 r2 = self->f->pushSmallInt(self, &I); 11467 r = self->f->getAtNDupBool(self,-1); 11468 ck_assert(!r); 11469 s = toStringO(self); 11470 ck_assert_str_eq(s, "[1,true,3,true,11]"); 11471 free(s); 11472 // wrong object type of another user class 11473 // User classes are stored in containers transparently 11474 createAllocateSmallInt(ip); 11475 ip->type = "anothertype"; 11476 setValG(ip, 11); 11477 r2 = self->f->push(self, (baset*)ip); 11478 ck_assert_ptr_ne(r2, null); 11479 r = self->f->getAtNDupBool(self,-1); 11480 ck_assert(!r); 11481 s = toStringO(self); 11482 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 11483 free(s); 11484 // index outside 11485 ck_assert(!self->f->getAtNDupBool(self, 20)); 11486 ck_assert(!self->f->getAtNDupBool(self, -7)); 11487 // empty list 11488 emptyO(self); 11489 ck_assert(!self->f->getAtNDupBool(self, 0)); 11490 ck_assert(!self->f->getAtNDupBool(self, -1)); 11491 terminateO(self); 11492 11493 } 11494 11495 11496 void getAtNDupDoubleSmallArrayT(CuTest *tc UNUSED) { 11497 11498 double r; 11499 smallArrayt *self = allocG(rtSmallArrayt); 11500 smallArrayt *r2; 11501 11502 // add elements to self 11503 r2 = self->f->pushInt(self, 1); 11504 ck_assert_ptr_ne(r2, null); 11505 r2 = self->f->pushDouble(self, 2); 11506 ck_assert_ptr_ne(r2, null); 11507 r2 = self->f->pushInt(self, 3); 11508 ck_assert_ptr_ne(r2, null); 11509 r2 = self->f->pushDouble(self, 4); 11510 ck_assert_ptr_ne(r2, null); 11511 11512 // positive index 11513 r = self->f->getAtNDupDouble(self,1); 11514 ck_assert(r==2); 11515 char *s = toStringO(self); 11516 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 11517 free(s); 11518 // negative index 11519 r = self->f->getAtNDupDouble(self,-1); 11520 ck_assert(r==4); 11521 s = toStringO(self); 11522 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]"); 11523 free(s); 11524 // wrong object type 11525 createSmallInt(I); 11526 setValG(&I, 11); 11527 r2 = self->f->pushSmallInt(self, &I); 11528 r = self->f->getAtNDupDouble(self,-1); 11529 ck_assert(!r); 11530 s = toStringO(self); 11531 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11]"); 11532 free(s); 11533 // wrong object type of another user class 11534 // User classes are stored in containers transparently 11535 createAllocateSmallInt(ip); 11536 ip->type = "anothertype"; 11537 setValG(ip, 11); 11538 r2 = self->f->push(self, (baset*)ip); 11539 ck_assert_ptr_ne(r2, null); 11540 r = self->f->getAtNDupDouble(self,-1); 11541 ck_assert(!r); 11542 s = toStringO(self); 11543 ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11,\"<data container>\"]"); 11544 free(s); 11545 // index outside 11546 ck_assert(!self->f->getAtNDupDouble(self, 20)); 11547 ck_assert(!self->f->getAtNDupDouble(self, -7)); 11548 // empty list 11549 emptyO(self); 11550 ck_assert(!self->f->getAtNDupDouble(self, 0)); 11551 ck_assert(!self->f->getAtNDupDouble(self, -1)); 11552 terminateO(self); 11553 11554 } 11555 11556 11557 void getAtNDupIntSmallArrayT(CuTest *tc UNUSED) { 11558 11559 int64_t r; 11560 smallArrayt *self = allocG(rtSmallArrayt); 11561 smallArrayt *r2; 11562 11563 // add elements to self 11564 r2 = self->f->pushInt(self, 1); 11565 ck_assert_ptr_ne(r2, null); 11566 r2 = self->f->pushInt(self, 2); 11567 ck_assert_ptr_ne(r2, null); 11568 r2 = self->f->pushInt(self, 3); 11569 ck_assert_ptr_ne(r2, null); 11570 r2 = self->f->pushInt(self, 4); 11571 ck_assert_ptr_ne(r2, null); 11572 11573 // positive index 11574 r = self->f->getAtNDupInt(self,1); 11575 ck_assert(r==2); 11576 char *s = toStringO(self); 11577 ck_assert_str_eq(s, "[1,2,3,4]"); 11578 free(s); 11579 // negative index 11580 r = self->f->getAtNDupInt(self,-1); 11581 ck_assert(r==4); 11582 s = toStringO(self); 11583 ck_assert_str_eq(s, "[1,2,3,4]"); 11584 free(s); 11585 // wrong object type 11586 createSmallDouble(I); 11587 setValG(&I, 11); 11588 r2 = self->f->pushSmallDouble(self, &I); 11589 r = self->f->getAtNDupInt(self,-1); 11590 ck_assert(!r); 11591 s = toStringO(self); 11592 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 11593 free(s); 11594 // wrong object type of another user class 11595 // User classes are stored in containers transparently 11596 createAllocateSmallInt(ip); 11597 ip->type = "anothertype"; 11598 setValG(ip, 11); 11599 r2 = self->f->push(self, (baset*)ip); 11600 ck_assert_ptr_ne(r2, null); 11601 r = self->f->getAtNDupInt(self,-1); 11602 ck_assert(!r); 11603 s = toStringO(self); 11604 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 11605 free(s); 11606 // index outside 11607 ck_assert(!self->f->getAtNDupInt(self, 20)); 11608 ck_assert(!self->f->getAtNDupInt(self, -7)); 11609 // empty list 11610 emptyO(self); 11611 ck_assert(!self->f->getAtNDupInt(self, 0)); 11612 ck_assert(!self->f->getAtNDupInt(self, -1)); 11613 terminateO(self); 11614 11615 } 11616 11617 11618 void getAtNDupInt32SmallArrayT(CuTest *tc UNUSED) { 11619 11620 int32_t r; 11621 smallArrayt *self = allocG(rtSmallArrayt); 11622 smallArrayt *r2; 11623 11624 // add elements to self 11625 r2 = self->f->pushInt(self, 1); 11626 ck_assert_ptr_ne(r2, null); 11627 r2 = self->f->pushInt(self, 2); 11628 ck_assert_ptr_ne(r2, null); 11629 r2 = self->f->pushInt(self, 3); 11630 ck_assert_ptr_ne(r2, null); 11631 r2 = self->f->pushInt(self, 4); 11632 ck_assert_ptr_ne(r2, null); 11633 11634 // positive index 11635 r = self->f->getAtNDupInt32(self,1); 11636 ck_assert(r==2); 11637 char *s = toStringO(self); 11638 ck_assert_str_eq(s, "[1,2,3,4]"); 11639 free(s); 11640 // negative index 11641 r = self->f->getAtNDupInt32(self,-1); 11642 ck_assert(r==4); 11643 s = toStringO(self); 11644 ck_assert_str_eq(s, "[1,2,3,4]"); 11645 free(s); 11646 // wrong object type 11647 createSmallDouble(I); 11648 setValG(&I, 11); 11649 r2 = self->f->pushSmallDouble(self, &I); 11650 r = self->f->getAtNDupInt32(self,-1); 11651 ck_assert(!r); 11652 s = toStringO(self); 11653 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 11654 free(s); 11655 // wrong object type of another user class 11656 // User classes are stored in containers transparently 11657 createAllocateSmallInt(ip); 11658 ip->type = "anothertype"; 11659 setValG(ip, 11); 11660 r2 = self->f->push(self, (baset*)ip); 11661 ck_assert_ptr_ne(r2, null); 11662 r = self->f->getAtNDupInt32(self,-1); 11663 ck_assert(!r); 11664 s = toStringO(self); 11665 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 11666 free(s); 11667 // index outside 11668 ck_assert(!self->f->getAtNDupInt32(self, 20)); 11669 ck_assert(!self->f->getAtNDupInt32(self, -7)); 11670 // empty list 11671 emptyO(self); 11672 ck_assert(!self->f->getAtNDupInt32(self, 0)); 11673 ck_assert(!self->f->getAtNDupInt32(self, -1)); 11674 terminateO(self); 11675 11676 } 11677 11678 11679 void getAtNDupUintSmallArrayT(CuTest *tc UNUSED) { 11680 11681 uint64_t r; 11682 smallArrayt *self = allocG(rtSmallArrayt); 11683 smallArrayt *r2; 11684 11685 // add elements to self 11686 r2 = self->f->pushInt(self, 1); 11687 ck_assert_ptr_ne(r2, null); 11688 r2 = self->f->pushInt(self, 2); 11689 ck_assert_ptr_ne(r2, null); 11690 r2 = self->f->pushInt(self, 3); 11691 ck_assert_ptr_ne(r2, null); 11692 r2 = self->f->pushInt(self, 4); 11693 ck_assert_ptr_ne(r2, null); 11694 11695 // positive index 11696 r = self->f->getAtNDupUint(self,1); 11697 ck_assert(r==2); 11698 char *s = toStringO(self); 11699 ck_assert_str_eq(s, "[1,2,3,4]"); 11700 free(s); 11701 // negative index 11702 r = self->f->getAtNDupUint(self,-1); 11703 ck_assert(r==4); 11704 s = toStringO(self); 11705 ck_assert_str_eq(s, "[1,2,3,4]"); 11706 free(s); 11707 // wrong object type 11708 createSmallDouble(I); 11709 setValG(&I, 11); 11710 r2 = self->f->pushSmallDouble(self, &I); 11711 r = self->f->getAtNDupUint(self,-1); 11712 ck_assert(!r); 11713 s = toStringO(self); 11714 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 11715 free(s); 11716 // wrong object type of another user class 11717 // User classes are stored in containers transparently 11718 createAllocateSmallInt(ip); 11719 ip->type = "anothertype"; 11720 setValG(ip, 11); 11721 r2 = self->f->push(self, (baset*)ip); 11722 ck_assert_ptr_ne(r2, null); 11723 r = self->f->getAtNDupUint(self,-1); 11724 ck_assert(!r); 11725 s = toStringO(self); 11726 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 11727 free(s); 11728 // index outside 11729 ck_assert(!self->f->getAtNDupUint(self, 20)); 11730 ck_assert(!self->f->getAtNDupUint(self, -7)); 11731 // empty list 11732 emptyO(self); 11733 ck_assert(!self->f->getAtNDupUint(self, 0)); 11734 ck_assert(!self->f->getAtNDupUint(self, -1)); 11735 terminateO(self); 11736 11737 } 11738 11739 11740 void getAtNDupUint32SmallArrayT(CuTest *tc UNUSED) { 11741 11742 uint32_t r; 11743 smallArrayt *self = allocG(rtSmallArrayt); 11744 smallArrayt *r2; 11745 11746 // add elements to self 11747 r2 = self->f->pushInt(self, 1); 11748 ck_assert_ptr_ne(r2, null); 11749 r2 = self->f->pushInt(self, 2); 11750 ck_assert_ptr_ne(r2, null); 11751 r2 = self->f->pushInt(self, 3); 11752 ck_assert_ptr_ne(r2, null); 11753 r2 = self->f->pushInt(self, 4); 11754 ck_assert_ptr_ne(r2, null); 11755 11756 // positive index 11757 r = self->f->getAtNDupUint32(self,1); 11758 ck_assert(r==2); 11759 char *s = toStringO(self); 11760 ck_assert_str_eq(s, "[1,2,3,4]"); 11761 free(s); 11762 // negative index 11763 r = self->f->getAtNDupUint32(self,-1); 11764 ck_assert(r==4); 11765 s = toStringO(self); 11766 ck_assert_str_eq(s, "[1,2,3,4]"); 11767 free(s); 11768 // wrong object type 11769 createSmallDouble(I); 11770 setValG(&I, 11); 11771 r2 = self->f->pushSmallDouble(self, &I); 11772 r = self->f->getAtNDupUint32(self,-1); 11773 ck_assert(!r); 11774 s = toStringO(self); 11775 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]"); 11776 free(s); 11777 // wrong object type of another user class 11778 // User classes are stored in containers transparently 11779 createAllocateSmallInt(ip); 11780 ip->type = "anothertype"; 11781 setValG(ip, 11); 11782 r2 = self->f->push(self, (baset*)ip); 11783 ck_assert_ptr_ne(r2, null); 11784 r = self->f->getAtNDupUint32(self,-1); 11785 ck_assert(!r); 11786 s = toStringO(self); 11787 ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]"); 11788 free(s); 11789 // index outside 11790 ck_assert(!self->f->getAtNDupUint32(self, 20)); 11791 ck_assert(!self->f->getAtNDupUint32(self, -7)); 11792 // empty list 11793 emptyO(self); 11794 ck_assert(!self->f->getAtNDupUint32(self, 0)); 11795 ck_assert(!self->f->getAtNDupUint32(self, -1)); 11796 terminateO(self); 11797 11798 } 11799 11800 11801 void getAtNDupSSmallArrayT(CuTest *tc UNUSED) { 11802 11803 char* r; 11804 smallArrayt *self = allocG(rtSmallArrayt); 11805 smallArrayt *r2; 11806 11807 // add elements to self 11808 r2 = self->f->pushInt(self, 1); 11809 ck_assert_ptr_ne(r2, null); 11810 r2 = self->f->pushS(self, "2"); 11811 ck_assert_ptr_ne(r2, null); 11812 r2 = self->f->pushInt(self, 3); 11813 ck_assert_ptr_ne(r2, null); 11814 r2 = self->f->pushS(self, "4"); 11815 ck_assert_ptr_ne(r2, null); 11816 11817 // positive index 11818 r = self->f->getAtNDupS(self,1); 11819 ck_assert_ptr_ne(r, null); 11820 ck_assert_str_eq(r, "2"); 11821 free(r); 11822 char *s = toStringO(self); 11823 ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]"); 11824 free(s); 11825 // negative index 11826 r = self->f->getAtNDupS(self,-1); 11827 ck_assert_ptr_ne(r, null); 11828 ck_assert_str_eq(r, "4"); 11829 free(r); 11830 s = toStringO(self); 11831 ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]"); 11832 free(s); 11833 // wrong object type 11834 createSmallInt(I); 11835 setValG(&I, 11); 11836 r2 = self->f->pushSmallInt(self, &I); 11837 r = self->f->getAtNDupS(self,-1); 11838 ck_assert_ptr_eq(r, NULL); 11839 s = toStringO(self); 11840 ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11]"); 11841 free(s); 11842 // wrong object type of another user class 11843 // User classes are stored in containers transparently 11844 createAllocateSmallInt(ip); 11845 ip->type = "anothertype"; 11846 setValG(ip, 11); 11847 r2 = self->f->push(self, (baset*)ip); 11848 ck_assert_ptr_ne(r2, null); 11849 r = self->f->getAtNDupS(self,-1); 11850 ck_assert_ptr_eq(r, NULL); 11851 s = toStringO(self); 11852 ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11,\"<data container>\"]"); 11853 free(s); 11854 // index outside 11855 ck_assert_ptr_eq(self->f->getAtNDupS(self, 20), NULL); 11856 ck_assert_ptr_eq(self->f->getAtNDupS(self, -7), NULL); 11857 // empty list 11858 emptyO(self); 11859 ck_assert_ptr_eq(self->f->getAtNDupS(self, 0), NULL); 11860 ck_assert_ptr_eq(self->f->getAtNDupS(self, -1), NULL); 11861 terminateO(self); 11862 11863 } 11864 11865 11866 void getAtNDupDictSmallArrayT(CuTest *tc UNUSED) { 11867 11868 smallDictt* r; 11869 smallArrayt *self = allocG(rtSmallArrayt); 11870 smallArrayt *r2; 11871 11872 // add elements to self 11873 r2 = self->f->pushInt(self, 1); 11874 ck_assert_ptr_ne(r2, null); 11875 createSmallDict(e2); 11876 r2 = self->f->pushDict(self, &e2); 11877 ck_assert_ptr_ne(r2, null); 11878 r2 = self->f->pushInt(self, 3); 11879 ck_assert_ptr_ne(r2, null); 11880 createSmallDict(e4); 11881 r2 = self->f->pushDict(self, &e4); 11882 ck_assert_ptr_ne(r2, null); 11883 11884 // positive index 11885 r = self->f->getAtNDupDict(self,1); 11886 ck_assert_ptr_ne(r, null); 11887 char *s = toStringO(r); 11888 terminateO(r); 11889 ck_assert_str_eq(s, "{}"); 11890 free(s); 11891 s = toStringO(self); 11892 ck_assert_str_eq(s, "[1,{},3,{}]"); 11893 free(s); 11894 // negative index 11895 r = self->f->getAtNDupDict(self,-1); 11896 ck_assert_ptr_ne(r, null); 11897 s = toStringO(r); 11898 terminateO(r); 11899 ck_assert_str_eq(s, "{}"); 11900 free(s); 11901 s = toStringO(self); 11902 ck_assert_str_eq(s, "[1,{},3,{}]"); 11903 free(s); 11904 // wrong object type 11905 createSmallInt(I); 11906 setValG(&I, 11); 11907 r2 = self->f->pushSmallInt(self, &I); 11908 r = self->f->getAtNDupDict(self,-1); 11909 ck_assert_ptr_eq(r, NULL); 11910 s = toStringO(self); 11911 ck_assert_str_eq(s, "[1,{},3,{},11]"); 11912 free(s); 11913 // wrong object type of another user class 11914 // User classes are stored in containers transparently 11915 createAllocateSmallInt(ip); 11916 ip->type = "anothertype"; 11917 setValG(ip, 11); 11918 r2 = self->f->push(self, (baset*)ip); 11919 ck_assert_ptr_ne(r2, null); 11920 r = self->f->getAtNDupDict(self,-1); 11921 ck_assert_ptr_eq(r, NULL); 11922 s = toStringO(self); 11923 ck_assert_str_eq(s, "[1,{},3,{},11,\"<data container>\"]"); 11924 free(s); 11925 // index outside 11926 ck_assert_ptr_eq(self->f->getAtNDupDict(self, 20), NULL); 11927 ck_assert_ptr_eq(self->f->getAtNDupDict(self, -7), NULL); 11928 // empty list 11929 emptyO(self); 11930 ck_assert_ptr_eq(self->f->getAtNDupDict(self, 0), NULL); 11931 ck_assert_ptr_eq(self->f->getAtNDupDict(self, -1), NULL); 11932 // get empty slot in array 11933 r2 = self->f->pushUndefined(self); 11934 ck_assert_ptr_ne(r2, null); 11935 delElemO(self,0); 11936 ck_assert_ptr_eq(self->f->getAtNDupDict(self, 0), NULL); 11937 terminateO(self); 11938 11939 } 11940 11941 11942 void getAtNDupArraySmallArrayT(CuTest *tc UNUSED) { 11943 11944 smallArrayt* r; 11945 smallArrayt *self = allocG(rtSmallArrayt); 11946 smallArrayt *r2; 11947 11948 // add elements to self 11949 r2 = self->f->pushInt(self, 1); 11950 ck_assert_ptr_ne(r2, null); 11951 createSmallArray(e2); 11952 r2 = self->f->pushArray(self, &e2); 11953 ck_assert_ptr_ne(r2, null); 11954 r2 = self->f->pushInt(self, 3); 11955 ck_assert_ptr_ne(r2, null); 11956 createSmallArray(e4); 11957 r2 = self->f->pushArray(self, &e4); 11958 ck_assert_ptr_ne(r2, null); 11959 11960 // positive index 11961 r = self->f->getAtNDupArray(self,1); 11962 ck_assert_ptr_ne(r, null); 11963 char *s = toStringO(r); 11964 terminateO(r); 11965 ck_assert_str_eq(s, "[]"); 11966 free(s); 11967 s = toStringO(self); 11968 ck_assert_str_eq(s, "[1,[],3,[]]"); 11969 free(s); 11970 // negative index 11971 r = self->f->getAtNDupArray(self,-1); 11972 ck_assert_ptr_ne(r, null); 11973 s = toStringO(r); 11974 terminateO(r); 11975 ck_assert_str_eq(s, "[]"); 11976 free(s); 11977 s = toStringO(self); 11978 ck_assert_str_eq(s, "[1,[],3,[]]"); 11979 free(s); 11980 // wrong object type 11981 createSmallInt(I); 11982 setValG(&I, 11); 11983 r2 = self->f->pushSmallInt(self, &I); 11984 r = self->f->getAtNDupArray(self,-1); 11985 ck_assert_ptr_eq(r, NULL); 11986 s = toStringO(self); 11987 ck_assert_str_eq(s, "[1,[],3,[],11]"); 11988 free(s); 11989 // wrong object type of another user class 11990 // User classes are stored in containers transparently 11991 createAllocateSmallInt(ip); 11992 ip->type = "anothertype"; 11993 setValG(ip, 11); 11994 r2 = self->f->push(self, (baset*)ip); 11995 ck_assert_ptr_ne(r2, null); 11996 r = self->f->getAtNDupArray(self,-1); 11997 ck_assert_ptr_eq(r, NULL); 11998 s = toStringO(self); 11999 ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]"); 12000 free(s); 12001 // index outside 12002 ck_assert_ptr_eq(self->f->getAtNDupArray(self, 20), NULL); 12003 ck_assert_ptr_eq(self->f->getAtNDupArray(self, -7), NULL); 12004 // empty list 12005 emptyO(self); 12006 ck_assert_ptr_eq(self->f->getAtNDupArray(self, 0), NULL); 12007 ck_assert_ptr_eq(self->f->getAtNDupArray(self, -1), NULL); 12008 // get empty slot in array 12009 r2 = self->f->pushUndefined(self); 12010 ck_assert_ptr_ne(r2, null); 12011 delElemO(self,0); 12012 ck_assert_ptr_eq(self->f->getAtNDupArray(self, 0), NULL); 12013 terminateO(self); 12014 12015 } 12016 12017 12018 void getAtNDupSmallBoolSmallArrayT(CuTest *tc UNUSED) { 12019 12020 smallBoolt* r; 12021 smallArrayt *self = allocG(rtSmallArrayt); 12022 smallArrayt *r2; 12023 12024 // add elements to self 12025 r2 = self->f->pushInt(self, 1); 12026 ck_assert_ptr_ne(r2, null); 12027 createSmallBool(e2); 12028 r2 = self->f->pushBool(self, true); 12029 ck_assert_ptr_ne(r2, null); 12030 r2 = self->f->pushInt(self, 3); 12031 ck_assert_ptr_ne(r2, null); 12032 createSmallBool(e4); 12033 r2 = self->f->pushBool(self, true); 12034 ck_assert_ptr_ne(r2, null); 12035 12036 // positive index 12037 r = self->f->getAtNDupSmallBool(self,1); 12038 ck_assert_ptr_ne(r, null); 12039 char *s = toStringO(r); 12040 terminateO(r); 12041 ck_assert_str_eq(s, "true"); 12042 free(s); 12043 s = toStringO(self); 12044 ck_assert_str_eq(s, "[1,true,3,true]"); 12045 free(s); 12046 // negative index 12047 r = self->f->getAtNDupSmallBool(self,-1); 12048 ck_assert_ptr_ne(r, null); 12049 s = toStringO(r); 12050 terminateO(r); 12051 ck_assert_str_eq(s, "true"); 12052 free(s); 12053 s = toStringO(self); 12054 ck_assert_str_eq(s, "[1,true,3,true]"); 12055 free(s); 12056 // wrong object type 12057 createSmallInt(I); 12058 setValG(&I, 11); 12059 r2 = self->f->pushSmallInt(self, &I); 12060 r = self->f->getAtNDupSmallBool(self,2); 12061 ck_assert_ptr_eq(r, NULL); 12062 s = toStringO(self); 12063 ck_assert_str_eq(s, "[1,true,3,true,11]"); 12064 free(s); 12065 // wrong object type of another user class 12066 // User classes are stored in containers transparently 12067 createAllocateSmallInt(ip); 12068 ip->type = "anothertype"; 12069 setValG(ip, 11); 12070 r2 = self->f->push(self, (baset*)ip); 12071 ck_assert_ptr_ne(r2, null); 12072 r = self->f->getAtNDupSmallBool(self,-1); 12073 ck_assert_ptr_eq(r, NULL); 12074 s = toStringO(self); 12075 ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]"); 12076 free(s); 12077 // index outside 12078 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, 20), NULL); 12079 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, -7), NULL); 12080 // empty list 12081 emptyO(self); 12082 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, 0), NULL); 12083 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, -1), NULL); 12084 // get empty slot in array 12085 r2 = self->f->pushUndefined(self); 12086 ck_assert_ptr_ne(r2, null); 12087 delElemO(self,0); 12088 ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, 0), NULL); 12089 terminateO(self); 12090 12091 } 12092 12093 12094 void getAtNDupSmallBytesSmallArrayT(CuTest *tc UNUSED) { 12095 12096 smallBytest* r; 12097 smallArrayt *self = allocG(rtSmallArrayt); 12098 smallArrayt *r2; 12099 12100 // add elements to self 12101 r2 = self->f->pushInt(self, 1); 12102 ck_assert_ptr_ne(r2, null); 12103 createSmallBytes(e2); 12104 r2 = self->f->pushSmallBytes(self, &e2); 12105 ck_assert_ptr_ne(r2, null); 12106 r2 = self->f->pushInt(self, 3); 12107 ck_assert_ptr_ne(r2, null); 12108 createSmallBytes(e4); 12109 r2 = self->f->pushSmallBytes(self, &e4); 12110 ck_assert_ptr_ne(r2, null); 12111 12112 // positive index 12113 r = self->f->getAtNDupSmallBytes(self,1); 12114 ck_assert_ptr_ne(r, null); 12115 char *s = toStringO(r); 12116 terminateO(r); 12117 ck_assert_str_eq(s, "[]"); 12118 free(s); 12119 s = toStringO(self); 12120 ck_assert_str_eq(s, "[1,[],3,[]]"); 12121 free(s); 12122 // negative index 12123 r = self->f->getAtNDupSmallBytes(self,-1); 12124 ck_assert_ptr_ne(r, null); 12125 s = toStringO(r); 12126 terminateO(r); 12127 ck_assert_str_eq(s, "[]"); 12128 free(s); 12129 s = toStringO(self); 12130 ck_assert_str_eq(s, "[1,[],3,[]]"); 12131 free(s); 12132 // wrong object type 12133 createSmallInt(I); 12134 setValG(&I, 11); 12135 r2 = self->f->pushSmallInt(self, &I); 12136 r = self->f->getAtNDupSmallBytes(self,-1); 12137 ck_assert_ptr_eq(r, NULL); 12138 s = toStringO(self); 12139 ck_assert_str_eq(s, "[1,[],3,[],11]"); 12140 free(s); 12141 // wrong object type of another user class 12142 // User classes are stored in containers transparently 12143 createAllocateSmallInt(ip); 12144 ip->type = "anothertype"; 12145 setValG(ip, 11); 12146 r2 = self->f->push(self, (baset*)ip); 12147 ck_assert_ptr_ne(r2, null); 12148 r = self->f->getAtNDupSmallBytes(self,-1); 12149 ck_assert_ptr_eq(r, NULL); 12150 s = toStringO(self); 12151 ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]"); 12152 free(s); 12153 // index outside 12154 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, 20), NULL); 12155 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, -7), NULL); 12156 // empty list 12157 emptyO(self); 12158 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, 0), NULL); 12159 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, -1), NULL); 12160 // get empty slot in array 12161 r2 = self->f->pushUndefined(self); 12162 ck_assert_ptr_ne(r2, null); 12163 delElemO(self,0); 12164 ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, 0), NULL); 12165 terminateO(self); 12166 12167 } 12168 12169 12170 void getAtNDupSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 12171 12172 smallDoublet* r; 12173 smallArrayt *self = allocG(rtSmallArrayt); 12174 smallArrayt *r2; 12175 12176 // add elements to self 12177 r2 = self->f->pushInt(self, 1); 12178 ck_assert_ptr_ne(r2, null); 12179 createSmallDouble(e2); 12180 r2 = self->f->pushSmallDouble(self, &e2); 12181 ck_assert_ptr_ne(r2, null); 12182 r2 = self->f->pushInt(self, 3); 12183 ck_assert_ptr_ne(r2, null); 12184 createSmallDouble(e4); 12185 r2 = self->f->pushSmallDouble(self, &e4); 12186 ck_assert_ptr_ne(r2, null); 12187 12188 // positive index 12189 r = self->f->getAtNDupSmallDouble(self,1); 12190 ck_assert_ptr_ne(r, null); 12191 char *s = toStringO(r); 12192 terminateO(r); 12193 ck_assert_str_eq(s, "0.000000e+00"); 12194 free(s); 12195 s = toStringO(self); 12196 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]"); 12197 free(s); 12198 // negative index 12199 r = self->f->getAtNDupSmallDouble(self,-1); 12200 ck_assert_ptr_ne(r, null); 12201 s = toStringO(r); 12202 terminateO(r); 12203 ck_assert_str_eq(s, "0.000000e+00"); 12204 free(s); 12205 s = toStringO(self); 12206 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]"); 12207 free(s); 12208 // wrong object type 12209 createSmallInt(I); 12210 setValG(&I, 11); 12211 r2 = self->f->pushSmallInt(self, &I); 12212 r = self->f->getAtNDupSmallDouble(self,-1); 12213 ck_assert_ptr_eq(r, NULL); 12214 s = toStringO(self); 12215 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11]"); 12216 free(s); 12217 // wrong object type of another user class 12218 // User classes are stored in containers transparently 12219 createAllocateSmallInt(ip); 12220 ip->type = "anothertype"; 12221 setValG(ip, 11); 12222 r2 = self->f->push(self, (baset*)ip); 12223 ck_assert_ptr_ne(r2, null); 12224 r = self->f->getAtNDupSmallDouble(self,-1); 12225 ck_assert_ptr_eq(r, NULL); 12226 s = toStringO(self); 12227 ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11,\"<data container>\"]"); 12228 free(s); 12229 // index outside 12230 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, 20), NULL); 12231 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, -7), NULL); 12232 // empty list 12233 emptyO(self); 12234 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, 0), NULL); 12235 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, -1), NULL); 12236 // get empty slot in array 12237 r2 = self->f->pushUndefined(self); 12238 ck_assert_ptr_ne(r2, null); 12239 delElemO(self,0); 12240 ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, 0), NULL); 12241 terminateO(self); 12242 12243 } 12244 12245 12246 void getAtNDupSmallIntSmallArrayT(CuTest *tc UNUSED) { 12247 12248 smallIntt* r; 12249 smallArrayt *self = allocG(rtSmallArrayt); 12250 smallArrayt *r2; 12251 12252 // add elements to self 12253 r2 = self->f->pushBool(self, true); 12254 ck_assert_ptr_ne(r2, null); 12255 createSmallInt(e2); 12256 r2 = self->f->pushSmallInt(self, &e2); 12257 ck_assert_ptr_ne(r2, null); 12258 r2 = self->f->pushBool(self, true); 12259 ck_assert_ptr_ne(r2, null); 12260 createSmallInt(e4); 12261 r2 = self->f->pushSmallInt(self, &e4); 12262 ck_assert_ptr_ne(r2, null); 12263 12264 // positive index 12265 r = self->f->getAtNDupSmallInt(self,1); 12266 ck_assert_ptr_ne(r, null); 12267 char *s = toStringO(r); 12268 terminateO(r); 12269 ck_assert_str_eq(s, "0"); 12270 free(s); 12271 s = toStringO(self); 12272 ck_assert_str_eq(s, "[true,0,true,0]"); 12273 free(s); 12274 // negative index 12275 r = self->f->getAtNDupSmallInt(self,-1); 12276 ck_assert_ptr_ne(r, null); 12277 s = toStringO(r); 12278 terminateO(r); 12279 ck_assert_str_eq(s, "0"); 12280 free(s); 12281 s = toStringO(self); 12282 ck_assert_str_eq(s, "[true,0,true,0]"); 12283 free(s); 12284 // wrong object type 12285 createSmallDouble(I); 12286 setValG(&I, 11); 12287 r2 = self->f->pushSmallDouble(self, &I); 12288 r = self->f->getAtNDupSmallInt(self,-1); 12289 ck_assert_ptr_eq(r, NULL); 12290 s = toStringO(self); 12291 ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01]"); 12292 free(s); 12293 // wrong object type of another user class 12294 // User classes are stored in containers transparently 12295 createAllocateSmallInt(ip); 12296 ip->type = "anothertype"; 12297 setValG(ip, 11); 12298 r2 = self->f->push(self, (baset*)ip); 12299 ck_assert_ptr_ne(r2, null); 12300 r = self->f->getAtNDupSmallInt(self,-1); 12301 ck_assert_ptr_eq(r, NULL); 12302 s = toStringO(self); 12303 ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01,\"<data container>\"]"); 12304 free(s); 12305 // index outside 12306 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, 20), NULL); 12307 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, -7), NULL); 12308 // empty list 12309 emptyO(self); 12310 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, 0), NULL); 12311 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, -1), NULL); 12312 // get empty slot in array 12313 r2 = self->f->pushUndefined(self); 12314 ck_assert_ptr_ne(r2, null); 12315 delElemO(self,0); 12316 ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, 0), NULL); 12317 terminateO(self); 12318 12319 } 12320 12321 12322 void getAtNDupSmallJsonSmallArrayT(CuTest *tc UNUSED) { 12323 12324 smallJsont* r; 12325 smallArrayt *self = allocG(rtSmallArrayt); 12326 smallArrayt *r2; 12327 12328 // add elements to self 12329 r2 = self->f->pushInt(self, 1); 12330 ck_assert_ptr_ne(r2, null); 12331 createSmallJson(e2); 12332 r2 = self->f->pushSmallJson(self, &e2); 12333 ck_assert_ptr_ne(r2, null); 12334 r2 = self->f->pushInt(self, 3); 12335 ck_assert_ptr_ne(r2, null); 12336 createSmallJson(e4); 12337 r2 = self->f->pushSmallJson(self, &e4); 12338 ck_assert_ptr_ne(r2, null); 12339 12340 // positive index 12341 r = self->f->getAtNDupSmallJson(self,1); 12342 ck_assert_ptr_ne(r, null); 12343 char *s = toStringO(r); 12344 terminateO(r); 12345 ck_assert_str_eq(s, "{}"); 12346 free(s); 12347 s = toStringO(self); 12348 ck_assert_str_eq(s, "[1,{},3,{}]"); 12349 free(s); 12350 // negative index 12351 r = self->f->getAtNDupSmallJson(self,-1); 12352 ck_assert_ptr_ne(r, null); 12353 s = toStringO(r); 12354 terminateO(r); 12355 ck_assert_str_eq(s, "{}"); 12356 free(s); 12357 s = toStringO(self); 12358 ck_assert_str_eq(s, "[1,{},3,{}]"); 12359 free(s); 12360 // wrong object type 12361 createSmallBytes(I); 12362 r2 = self->f->pushSmallBytes(self, &I); 12363 r = self->f->getAtNDupSmallJson(self,-1); 12364 ck_assert_ptr_eq(r, NULL); 12365 s = toStringO(self); 12366 ck_assert_str_eq(s, "[1,{},3,{},[]]"); 12367 free(s); 12368 // wrong object type of another user class 12369 // User classes are stored in containers transparently 12370 createAllocateSmallInt(ip); 12371 ip->type = "anothertype"; 12372 setValG(ip, 11); 12373 r2 = self->f->push(self, (baset*)ip); 12374 ck_assert_ptr_ne(r2, null); 12375 r = self->f->getAtNDupSmallJson(self,-1); 12376 ck_assert_ptr_eq(r, NULL); 12377 s = toStringO(self); 12378 ck_assert_str_eq(s, "[1,{},3,{},[],\"<data container>\"]"); 12379 free(s); 12380 // index outside 12381 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, 20), NULL); 12382 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, -7), NULL); 12383 // empty list 12384 emptyO(self); 12385 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, 0), NULL); 12386 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, -1), NULL); 12387 // get empty slot in array 12388 r2 = self->f->pushUndefined(self); 12389 ck_assert_ptr_ne(r2, null); 12390 delElemO(self,0); 12391 ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, 0), NULL); 12392 terminateO(self); 12393 12394 } 12395 12396 12397 void getAtNDupSmallStringSmallArrayT(CuTest *tc UNUSED) { 12398 12399 smallStringt* r; 12400 smallArrayt *self = allocG(rtSmallArrayt); 12401 smallArrayt *r2; 12402 12403 // add elements to self 12404 r2 = self->f->pushInt(self, 1); 12405 ck_assert_ptr_ne(r2, null); 12406 createSmallString(e2); 12407 r2 = self->f->pushSmallString(self, &e2); 12408 ck_assert_ptr_ne(r2, null); 12409 r2 = self->f->pushInt(self, 3); 12410 ck_assert_ptr_ne(r2, null); 12411 createSmallString(e4); 12412 r2 = self->f->pushSmallString(self, &e4); 12413 ck_assert_ptr_ne(r2, null); 12414 12415 // positive index 12416 r = self->f->getAtNDupSmallString(self,1); 12417 ck_assert_ptr_ne(r, null); 12418 char *s = toStringO(r); 12419 terminateO(r); 12420 ck_assert_str_eq(s, ""); 12421 free(s); 12422 s = toStringO(self); 12423 ck_assert_str_eq(s, "[1,\"\",3,\"\"]"); 12424 free(s); 12425 // negative index 12426 r = self->f->getAtNDupSmallString(self,-1); 12427 ck_assert_ptr_ne(r, null); 12428 s = toStringO(r); 12429 terminateO(r); 12430 ck_assert_str_eq(s, ""); 12431 free(s); 12432 s = toStringO(self); 12433 ck_assert_str_eq(s, "[1,\"\",3,\"\"]"); 12434 free(s); 12435 // wrong object type 12436 createSmallInt(I); 12437 setValG(&I, 11); 12438 r2 = self->f->pushSmallInt(self, &I); 12439 r = self->f->getAtNDupSmallString(self,-1); 12440 ck_assert_ptr_eq(r, NULL); 12441 s = toStringO(self); 12442 ck_assert_str_eq(s, "[1,\"\",3,\"\",11]"); 12443 free(s); 12444 // wrong object type of another user class 12445 // User classes are stored in containers transparently 12446 createAllocateSmallInt(ip); 12447 ip->type = "anothertype"; 12448 setValG(ip, 11); 12449 r2 = self->f->push(self, (baset*)ip); 12450 ck_assert_ptr_ne(r2, null); 12451 r = self->f->getAtNDupSmallString(self,-1); 12452 ck_assert_ptr_eq(r, NULL); 12453 s = toStringO(self); 12454 ck_assert_str_eq(s, "[1,\"\",3,\"\",11,\"<data container>\"]"); 12455 free(s); 12456 // index outside 12457 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, 20), NULL); 12458 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, -7), NULL); 12459 // empty list 12460 emptyO(self); 12461 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, 0), NULL); 12462 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, -1), NULL); 12463 // get empty slot in array 12464 r2 = self->f->pushUndefined(self); 12465 ck_assert_ptr_ne(r2, null); 12466 delElemO(self,0); 12467 ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, 0), NULL); 12468 terminateO(self); 12469 12470 } 12471 12472 12473 void getAtNDupVoidSmallArrayT(CuTest *tc UNUSED) { 12474 12475 void* r; 12476 smallArrayt *self = allocG(rtSmallArrayt); 12477 smallArrayt *r2; 12478 12479 // add elements to self 12480 r2 = self->f->pushInt(self, 1); 12481 ck_assert_ptr_ne(r2, null); 12482 r2 = pushVoidSmallArrayG(self, &r); 12483 ck_assert_ptr_ne(r2, null); 12484 r2 = self->f->pushInt(self, 3); 12485 ck_assert_ptr_ne(r2, null); 12486 r2 = pushVoidSmallArrayG(self, &self); 12487 ck_assert_ptr_ne(r2, null); 12488 12489 // positive index 12490 r = self->f->getAtNDupVoid(self,1); 12491 // duplicate function is not set so the data is not duplicated 12492 ck_assert_ptr_eq(r, NULL); 12493 char *s = toStringO(self); 12494 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 12495 free(s); 12496 // negative index 12497 r = self->f->getAtNDupVoid(self,-1); 12498 // duplicate function is not set so the data is not duplicated 12499 ck_assert_ptr_eq(r, NULL); 12500 s = toStringO(self); 12501 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 12502 free(s); 12503 // wrong object type 12504 createSmallInt(I); 12505 setValG(&I, 11); 12506 r2 = self->f->pushSmallInt(self, &I); 12507 r = self->f->getAtNDupVoid(self,-1); 12508 ck_assert_ptr_eq(r, NULL); 12509 s = toStringO(self); 12510 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]"); 12511 free(s); 12512 // wrong object type of another user class 12513 // User classes are stored in containers transparently 12514 createAllocateSmallInt(ip); 12515 ip->type = "anothertype"; 12516 setValG(ip, 11); 12517 r2 = self->f->push(self, (baset*)ip); 12518 ck_assert_ptr_ne(r2, null); 12519 r = self->f->getAtNDupVoid(self,-1); 12520 ck_assert_ptr_eq(r, NULL); 12521 s = toStringO(self); 12522 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]"); 12523 free(s); 12524 // index outside 12525 ck_assert_ptr_eq(self->f->getAtNDupVoid(self, 20), NULL); 12526 ck_assert_ptr_eq(self->f->getAtNDupVoid(self, -7), NULL); 12527 // empty list 12528 emptyO(self); 12529 ck_assert_ptr_eq(self->f->getAtNDupVoid(self, 0), NULL); 12530 ck_assert_ptr_eq(self->f->getAtNDupVoid(self, -1), NULL); 12531 terminateO(self); 12532 12533 } 12534 12535 12536 void getAtNDupSmallContainerSmallArrayT(CuTest *tc UNUSED) { 12537 12538 smallContainert* r; 12539 smallArrayt *self = allocG(rtSmallArrayt); 12540 smallArrayt *r2; 12541 12542 // add elements to self 12543 r2 = self->f->pushInt(self, 1); 12544 ck_assert_ptr_ne(r2, null); 12545 createSmallContainer(e2); 12546 r2 = self->f->pushSmallContainer(self, &e2); 12547 ck_assert_ptr_ne(r2, null); 12548 r2 = self->f->pushInt(self, 3); 12549 ck_assert_ptr_ne(r2, null); 12550 createSmallContainer(e4); 12551 r2 = self->f->pushSmallContainer(self, &e4); 12552 ck_assert_ptr_ne(r2, null); 12553 12554 // positive index 12555 r = self->f->getAtNDupSmallContainer(self,1); 12556 ck_assert_ptr_ne(r, null); 12557 char *s = toStringO(r); 12558 terminateO(r); 12559 ck_assert_str_eq(s, "<data smallContainer>"); 12560 free(s); 12561 s = toStringO(self); 12562 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 12563 free(s); 12564 // negative index 12565 r = self->f->getAtNDupSmallContainer(self,-1); 12566 ck_assert_ptr_ne(r, null); 12567 s = toStringO(r); 12568 terminateO(r); 12569 ck_assert_str_eq(s, "<data smallContainer>"); 12570 free(s); 12571 s = toStringO(self); 12572 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 12573 free(s); 12574 // wrong object type 12575 createSmallInt(I); 12576 setValG(&I, 11); 12577 r2 = self->f->pushSmallInt(self, &I); 12578 r = self->f->getAtNDupSmallContainer(self,-1); 12579 ck_assert_ptr_eq(r, NULL); 12580 s = toStringO(self); 12581 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]"); 12582 free(s); 12583 // wrong object type of another user class 12584 // User classes are stored in containers transparently 12585 createAllocateSmallInt(ip); 12586 ip->type = "anothertype"; 12587 setValG(ip, 11); 12588 r2 = self->f->push(self, (baset*)ip); 12589 ck_assert_ptr_ne(r2, null); 12590 r = self->f->getAtNDupSmallContainer(self,-1); 12591 ck_assert_ptr_eq(r, NULL); 12592 s = toStringO(self); 12593 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]"); 12594 free(s); 12595 // index outside 12596 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, 20), NULL); 12597 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, -7), NULL); 12598 // empty list 12599 emptyO(self); 12600 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, 0), NULL); 12601 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, -1), NULL); 12602 // get empty slot in array 12603 r2 = self->f->pushUndefined(self); 12604 ck_assert_ptr_ne(r2, null); 12605 delElemO(self,0); 12606 ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, 0), NULL); 12607 terminateO(self); 12608 12609 } 12610 12611 12612 void setAtSmallArrayT(CuTest *tc UNUSED) { 12613 12614 smallArrayt* r; 12615 smallArrayt *self = allocG(rtSmallArrayt); 12616 baset *value; 12617 12618 // add elements to self 12619 r = self->f->pushInt(self, 1); 12620 ck_assert_ptr_ne(r, null); 12621 r = self->f->pushInt(self, 2); 12622 ck_assert_ptr_ne(r, null); 12623 r = self->f->pushInt(self, 3); 12624 ck_assert_ptr_ne(r, null); 12625 r = self->f->pushInt(self, 4); 12626 ck_assert_ptr_ne(r, null); 12627 12628 // positive index 12629 value = (baset*)allocSmallInt(123); 12630 r = self->f->setAt(self, 1, value); 12631 ck_assert_ptr_ne(r, null); 12632 finishO(value); 12633 char *s = toStringO(r); 12634 ck_assert_str_eq(s, "[1,123,3,4]"); 12635 free(s); 12636 // negative index 12637 value = (baset*)allocSmallInt(234); 12638 r = self->f->setAt(self, -1, value); 12639 ck_assert_ptr_ne(r, null); 12640 finishO(value); 12641 s = toStringO(r); 12642 ck_assert_str_eq(s, "[1,123,3,234]"); 12643 free(s); 12644 // undefined object 12645 value = (baset*)allocUndefined(); 12646 r = self->f->setAt(self, -1, value); 12647 ck_assert_ptr_ne(r, null); 12648 finishO(value); 12649 s = toStringO(r); 12650 ck_assert_str_eq(s, "[1,123,3,null]"); 12651 free(s); 12652 // container 12653 createAllocateSmallContainer(c); 12654 r = self->f->setAt(self, -1, (baset*)c); 12655 ck_assert_ptr_ne(r, null); 12656 finishO(c); 12657 s = toStringO(r); 12658 ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]"); 12659 free(s); 12660 // base object in container 12661 createAllocateSmallInt(I); 12662 setValG(I, 11); 12663 I->type = "anothertype"; 12664 r = self->f->setAt(self, -1, (baset*)I); 12665 ck_assert_ptr_ne(r, null); 12666 s = toStringO(r); 12667 ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]"); 12668 free(s); 12669 // index outside 12670 value = (baset*)allocSmallInt(123); 12671 ck_assert_ptr_eq(self->f->setAt(self, 20, value), NULL); 12672 ck_assert_ptr_eq(self->f->setAt(self, -8, value), NULL); 12673 // empty list 12674 emptyO(self); 12675 ck_assert_ptr_eq(self->f->setAt(self, 0, value), NULL); 12676 ck_assert_ptr_eq(self->f->setAt(self, -1, value), NULL); 12677 terminateO(value); 12678 // NULL value 12679 ck_assert_ptr_eq(self->f->setAt(self, 0, NULL), NULL); 12680 terminateO(self); 12681 12682 } 12683 12684 12685 void setAtUndefinedSmallArrayT(CuTest *tc UNUSED) { 12686 12687 smallArrayt* r; 12688 smallArrayt *self = allocG(rtSmallArrayt); 12689 12690 // add elements to self 12691 r = self->f->pushInt(self, 1); 12692 ck_assert_ptr_ne(r, null); 12693 r = self->f->pushInt(self, 2); 12694 ck_assert_ptr_ne(r, null); 12695 r = self->f->pushInt(self, 3); 12696 ck_assert_ptr_ne(r, null); 12697 r = self->f->pushInt(self, 4); 12698 ck_assert_ptr_ne(r, null); 12699 12700 // positive index 12701 r = self->f->setAtUndefined(self, 1); 12702 ck_assert_ptr_ne(r, null); 12703 char *s = toStringO(r); 12704 ck_assert_str_eq(s, "[1,null,3,4]"); 12705 free(s); 12706 // negative index 12707 r = self->f->setAtUndefined(self, -1); 12708 ck_assert_ptr_ne(r, null); 12709 s = toStringO(r); 12710 ck_assert_str_eq(s, "[1,null,3,null]"); 12711 free(s); 12712 // index outside 12713 ck_assert_ptr_eq(self->f->setAtUndefined(self, 20), NULL); 12714 ck_assert_ptr_eq(self->f->setAtUndefined(self, -8), NULL); 12715 // empty list 12716 emptyO(self); 12717 ck_assert_ptr_eq(self->f->setAtUndefined(self, 0), NULL); 12718 ck_assert_ptr_eq(self->f->setAtUndefined(self, -1), NULL); 12719 terminateO(self); 12720 12721 } 12722 12723 12724 void setAtBoolSmallArrayT(CuTest *tc UNUSED) { 12725 12726 smallArrayt* r; 12727 smallArrayt *self = allocG(rtSmallArrayt); 12728 12729 // add elements to self 12730 r = self->f->pushInt(self, 1); 12731 ck_assert_ptr_ne(r, null); 12732 r = self->f->pushInt(self, 2); 12733 ck_assert_ptr_ne(r, null); 12734 r = self->f->pushInt(self, 3); 12735 ck_assert_ptr_ne(r, null); 12736 r = self->f->pushInt(self, 4); 12737 ck_assert_ptr_ne(r, null); 12738 12739 // positive index 12740 r = self->f->setAtBool(self, 1, true); 12741 ck_assert_ptr_ne(r, null); 12742 char *s = toStringO(r); 12743 ck_assert_str_eq(s, "[1,true,3,4]"); 12744 free(s); 12745 // negative index 12746 r = self->f->setAtBool(self, -1, true); 12747 ck_assert_ptr_ne(r, null); 12748 s = toStringO(r); 12749 ck_assert_str_eq(s, "[1,true,3,true]"); 12750 free(s); 12751 // index outside 12752 ck_assert_ptr_eq(self->f->setAtBool(self, 20, true), NULL); 12753 ck_assert_ptr_eq(self->f->setAtBool(self, -8, true), NULL); 12754 // empty list 12755 emptyO(self); 12756 ck_assert_ptr_eq(self->f->setAtBool(self, 0, true), NULL); 12757 ck_assert_ptr_eq(self->f->setAtBool(self, -1, true), NULL); 12758 terminateO(self); 12759 12760 } 12761 12762 12763 void setAtDoubleSmallArrayT(CuTest *tc UNUSED) { 12764 12765 smallArrayt* r; 12766 smallArrayt *self = allocG(rtSmallArrayt); 12767 12768 // add elements to self 12769 r = self->f->pushInt(self, 1); 12770 ck_assert_ptr_ne(r, null); 12771 r = self->f->pushInt(self, 2); 12772 ck_assert_ptr_ne(r, null); 12773 r = self->f->pushInt(self, 3); 12774 ck_assert_ptr_ne(r, null); 12775 r = self->f->pushInt(self, 4); 12776 ck_assert_ptr_ne(r, null); 12777 12778 // positive index 12779 r = self->f->setAtDouble(self, 1, 12); 12780 ck_assert_ptr_ne(r, null); 12781 char *s = toStringO(r); 12782 ck_assert_str_eq(s, "[1,1.200000e+01,3,4]"); 12783 free(s); 12784 // negative index 12785 r = self->f->setAtDouble(self, -1, 14); 12786 ck_assert_ptr_ne(r, null); 12787 s = toStringO(r); 12788 ck_assert_str_eq(s, "[1,1.200000e+01,3,1.400000e+01]"); 12789 free(s); 12790 // index outside 12791 ck_assert_ptr_eq(self->f->setAtDouble(self, 20, 1), NULL); 12792 ck_assert_ptr_eq(self->f->setAtDouble(self, -8, 1), NULL); 12793 // empty list 12794 emptyO(self); 12795 ck_assert_ptr_eq(self->f->setAtDouble(self, 0, 1), NULL); 12796 ck_assert_ptr_eq(self->f->setAtDouble(self, -1, 1), NULL); 12797 terminateO(self); 12798 12799 } 12800 12801 12802 void setAtIntSmallArrayT(CuTest *tc UNUSED) { 12803 12804 smallArrayt* r; 12805 smallArrayt *self = allocG(rtSmallArrayt); 12806 12807 // add elements to self 12808 r = self->f->pushInt(self, 1); 12809 ck_assert_ptr_ne(r, null); 12810 r = self->f->pushInt(self, 2); 12811 ck_assert_ptr_ne(r, null); 12812 r = self->f->pushInt(self, 3); 12813 ck_assert_ptr_ne(r, null); 12814 r = self->f->pushInt(self, 4); 12815 ck_assert_ptr_ne(r, null); 12816 12817 // positive index 12818 r = self->f->setAtInt(self, 1, 12); 12819 ck_assert_ptr_ne(r, null); 12820 char *s = toStringO(r); 12821 ck_assert_str_eq(s, "[1,12,3,4]"); 12822 free(s); 12823 // negative index 12824 r = self->f->setAtInt(self, -1, 14); 12825 ck_assert_ptr_ne(r, null); 12826 s = toStringO(r); 12827 ck_assert_str_eq(s, "[1,12,3,14]"); 12828 free(s); 12829 // index outside 12830 ck_assert_ptr_eq(self->f->setAtInt(self, 20, 1), NULL); 12831 ck_assert_ptr_eq(self->f->setAtInt(self, -8, 1), NULL); 12832 // empty list 12833 emptyO(self); 12834 ck_assert_ptr_eq(self->f->setAtInt(self, 0, 1), NULL); 12835 ck_assert_ptr_eq(self->f->setAtInt(self, -1, 1), NULL); 12836 terminateO(self); 12837 12838 } 12839 12840 12841 void setAtSSmallArrayT(CuTest *tc UNUSED) { 12842 12843 smallArrayt* r; 12844 smallArrayt *self = allocG(rtSmallArrayt); 12845 12846 // add elements to self 12847 r = self->f->pushInt(self, 1); 12848 ck_assert_ptr_ne(r, null); 12849 r = self->f->pushInt(self, 2); 12850 ck_assert_ptr_ne(r, null); 12851 r = self->f->pushInt(self, 3); 12852 ck_assert_ptr_ne(r, null); 12853 r = self->f->pushInt(self, 4); 12854 ck_assert_ptr_ne(r, null); 12855 12856 // positive index 12857 r = self->f->setAtS(self, 1, "a"); 12858 ck_assert_ptr_ne(r, null); 12859 char *s = toStringO(r); 12860 ck_assert_str_eq(s, "[1,\"a\",3,4]"); 12861 free(s); 12862 // negative index 12863 r = self->f->setAtS(self, -1, "b"); 12864 ck_assert_ptr_ne(r, null); 12865 s = toStringO(r); 12866 ck_assert_str_eq(s, "[1,\"a\",3,\"b\"]"); 12867 free(s); 12868 // NULL string 12869 r = self->f->setAtS(self, -1, NULL); 12870 ck_assert_ptr_eq(r, null); 12871 // index outside 12872 ck_assert_ptr_eq(self->f->setAtS(self, 20, ""), NULL); 12873 ck_assert_ptr_eq(self->f->setAtS(self, -8, ""), NULL); 12874 // empty list 12875 emptyO(self); 12876 ck_assert_ptr_eq(self->f->setAtS(self, 0, ""), NULL); 12877 ck_assert_ptr_eq(self->f->setAtS(self, -1, ""), NULL); 12878 terminateO(self); 12879 12880 } 12881 12882 12883 void setAtCharSmallArrayT(CuTest *tc UNUSED) { 12884 12885 smallArrayt* r; 12886 smallArrayt *self = allocG(rtSmallArrayt); 12887 12888 // add elements to self 12889 r = self->f->pushInt(self, 1); 12890 ck_assert_ptr_ne(r, null); 12891 r = self->f->pushInt(self, 2); 12892 ck_assert_ptr_ne(r, null); 12893 r = self->f->pushInt(self, 3); 12894 ck_assert_ptr_ne(r, null); 12895 r = self->f->pushInt(self, 4); 12896 ck_assert_ptr_ne(r, null); 12897 12898 // positive index 12899 r = self->f->setAtChar(self, 1, 'a'); 12900 ck_assert_ptr_ne(r, null); 12901 char *s = toStringO(r); 12902 ck_assert_str_eq(s, "[1,\"a\",3,4]"); 12903 free(s); 12904 // negative index 12905 r = self->f->setAtChar(self, -1, 'b'); 12906 ck_assert_ptr_ne(r, null); 12907 s = toStringO(r); 12908 ck_assert_str_eq(s, "[1,\"a\",3,\"b\"]"); 12909 free(s); 12910 // index outside 12911 ck_assert_ptr_eq(self->f->setAtChar(self, 20, 'a'), NULL); 12912 ck_assert_ptr_eq(self->f->setAtChar(self, -8, 's'), NULL); 12913 // empty list 12914 emptyO(self); 12915 ck_assert_ptr_eq(self->f->setAtChar(self, 0, 'a'), NULL); 12916 ck_assert_ptr_eq(self->f->setAtChar(self, -1, 's'), NULL); 12917 terminateO(self); 12918 12919 } 12920 12921 12922 void setAtDictSmallArrayT(CuTest *tc UNUSED) { 12923 12924 smallArrayt* r; 12925 smallArrayt *self = allocG(rtSmallArrayt); 12926 smallDictt *value; 12927 12928 // add elements to self 12929 r = self->f->pushInt(self, 1); 12930 ck_assert_ptr_ne(r, null); 12931 r = self->f->pushInt(self, 2); 12932 ck_assert_ptr_ne(r, null); 12933 r = self->f->pushInt(self, 3); 12934 ck_assert_ptr_ne(r, null); 12935 r = self->f->pushInt(self, 4); 12936 ck_assert_ptr_ne(r, null); 12937 12938 // positive index 12939 value = allocSmallDict(); 12940 r = self->f->setAtDict(self, 1, value); 12941 ck_assert_ptr_ne(r, null); 12942 finishO(value); 12943 char *s = toStringO(r); 12944 ck_assert_str_eq(s, "[1,{},3,4]"); 12945 free(s); 12946 // negative index 12947 value = allocSmallDict(); 12948 r = self->f->setAtDict(self, -1, value); 12949 ck_assert_ptr_ne(r, null); 12950 finishO(value); 12951 s = toStringO(r); 12952 ck_assert_str_eq(s, "[1,{},3,{}]"); 12953 free(s); 12954 // index outside 12955 value = allocSmallDict(); 12956 ck_assert_ptr_eq(self->f->setAtDict(self, 20, value), NULL); 12957 ck_assert_ptr_eq(self->f->setAtDict(self, -8, value), NULL); 12958 // empty list 12959 emptyO(self); 12960 ck_assert_ptr_eq(self->f->setAtDict(self, 0, value), NULL); 12961 ck_assert_ptr_eq(self->f->setAtDict(self, -1, value), NULL); 12962 terminateO(value); 12963 // non smallDict object 12964 value = (smallDictt*) allocSmallInt(2); 12965 r = self->f->setAtDict(self, 0, value); 12966 ck_assert_ptr_eq(r, null); 12967 terminateO(value); 12968 // NULL value 12969 ck_assert_ptr_eq(self->f->setAtDict(self, 0, NULL), NULL); 12970 terminateO(self); 12971 12972 } 12973 12974 12975 void setAtArraySmallArrayT(CuTest *tc UNUSED) { 12976 12977 smallArrayt* r; 12978 smallArrayt *self = allocG(rtSmallArrayt); 12979 smallArrayt *value; 12980 12981 // add elements to self 12982 r = self->f->pushInt(self, 1); 12983 ck_assert_ptr_ne(r, null); 12984 r = self->f->pushInt(self, 2); 12985 ck_assert_ptr_ne(r, null); 12986 r = self->f->pushInt(self, 3); 12987 ck_assert_ptr_ne(r, null); 12988 r = self->f->pushInt(self, 4); 12989 ck_assert_ptr_ne(r, null); 12990 12991 // positive index 12992 value = allocSmallArray(); 12993 r = self->f->setAtArray(self, 1, value); 12994 ck_assert_ptr_ne(r, null); 12995 finishO(value); 12996 char *s = toStringO(r); 12997 ck_assert_str_eq(s, "[1,[],3,4]"); 12998 free(s); 12999 // negative index 13000 value = allocSmallArray(); 13001 r = self->f->setAtArray(self, -1, value); 13002 ck_assert_ptr_ne(r, null); 13003 finishO(value); 13004 s = toStringO(r); 13005 ck_assert_str_eq(s, "[1,[],3,[]]"); 13006 free(s); 13007 // index outside 13008 value = allocSmallArray(); 13009 ck_assert_ptr_eq(self->f->setAtArray(self, 20, value), NULL); 13010 ck_assert_ptr_eq(self->f->setAtArray(self, -8, value), NULL); 13011 // empty list 13012 emptyO(self); 13013 ck_assert_ptr_eq(self->f->setAtArray(self, 0, value), NULL); 13014 ck_assert_ptr_eq(self->f->setAtArray(self, -1, value), NULL); 13015 terminateO(value); 13016 // non smallArray object 13017 value = (smallArrayt*) allocSmallInt(2); 13018 r = self->f->setAtArray(self, 0, value); 13019 ck_assert_ptr_eq(r, null); 13020 terminateO(value); 13021 // NULL value 13022 ck_assert_ptr_eq(self->f->setAtArray(self, 0, NULL), NULL); 13023 terminateO(self); 13024 13025 } 13026 13027 13028 void setAtArraycSmallArrayT(CuTest *tc UNUSED) { 13029 13030 smallArrayt* r; 13031 smallArrayt *self = allocG(rtSmallArrayt); 13032 char **value; 13033 13034 // add elements to self 13035 r = self->f->pushInt(self, 1); 13036 ck_assert_ptr_ne(r, null); 13037 r = self->f->pushInt(self, 2); 13038 ck_assert_ptr_ne(r, null); 13039 r = self->f->pushInt(self, 3); 13040 ck_assert_ptr_ne(r, null); 13041 r = self->f->pushInt(self, 4); 13042 ck_assert_ptr_ne(r, null); 13043 13044 // positive index 13045 value = listCreateS("a"); 13046 r = self->f->setAtArrayc(self, 1, value); 13047 ck_assert_ptr_ne(r, null); 13048 listFreeS(value); 13049 char *s = toStringO(r); 13050 ck_assert_str_eq(s, "[1,[\"a\"],3,4]"); 13051 free(s); 13052 // negative index 13053 value = listCreateS("b"); 13054 r = self->f->setAtArrayc(self, -1, value); 13055 ck_assert_ptr_ne(r, null); 13056 listFreeS(value); 13057 s = toStringO(r); 13058 ck_assert_str_eq(s, "[1,[\"a\"],3,[\"b\"]]"); 13059 free(s); 13060 // index outside 13061 value = (char**)r; 13062 ck_assert_ptr_eq(self->f->setAtArrayc(self, 20, value), NULL); 13063 ck_assert_ptr_eq(self->f->setAtArrayc(self, -8, value), NULL); 13064 // empty list 13065 emptyO(self); 13066 ck_assert_ptr_eq(self->f->setAtArrayc(self, 0, value), NULL); 13067 ck_assert_ptr_eq(self->f->setAtArrayc(self, -1, value), NULL); 13068 // NULL value 13069 ck_assert_ptr_eq(self->f->setAtArrayc(self, 0, NULL), NULL); 13070 terminateO(self); 13071 13072 } 13073 13074 13075 void setAtSmallBoolSmallArrayT(CuTest *tc UNUSED) { 13076 13077 smallArrayt* r; 13078 smallArrayt *self = allocG(rtSmallArrayt); 13079 smallBoolt *value; 13080 13081 // add elements to self 13082 r = self->f->pushInt(self, 1); 13083 ck_assert_ptr_ne(r, null); 13084 r = self->f->pushInt(self, 2); 13085 ck_assert_ptr_ne(r, null); 13086 r = self->f->pushInt(self, 3); 13087 ck_assert_ptr_ne(r, null); 13088 r = self->f->pushInt(self, 4); 13089 ck_assert_ptr_ne(r, null); 13090 13091 // positive index 13092 value = allocSmallBool(true); 13093 r = self->f->setAtSmallBool(self, 1, value); 13094 ck_assert_ptr_ne(r, null); 13095 finishO(value); 13096 char *s = toStringO(r); 13097 ck_assert_str_eq(s, "[1,true,3,4]"); 13098 free(s); 13099 // negative index 13100 value = allocSmallBool(true); 13101 r = self->f->setAtSmallBool(self, -1, value); 13102 ck_assert_ptr_ne(r, null); 13103 finishO(value); 13104 s = toStringO(r); 13105 ck_assert_str_eq(s, "[1,true,3,true]"); 13106 free(s); 13107 // empty smallBool 13108 value = allocSmallBool(true); 13109 freeO(value); 13110 r = self->f->setAtSmallBool(self, -1, value); 13111 ck_assert_ptr_ne(r, null); 13112 finishO(value); 13113 s = toStringO(r); 13114 ck_assert_str_eq(s, "[1,true,3,false]"); 13115 free(s); 13116 // index outside 13117 value = allocSmallBool(true); 13118 ck_assert_ptr_eq(self->f->setAtSmallBool(self, 20, value), NULL); 13119 ck_assert_ptr_eq(self->f->setAtSmallBool(self, -8, value), NULL); 13120 // empty list 13121 emptyO(self); 13122 ck_assert_ptr_eq(self->f->setAtSmallBool(self, 0, value), NULL); 13123 ck_assert_ptr_eq(self->f->setAtSmallBool(self, -1, value), NULL); 13124 terminateO(value); 13125 // non smallBool object 13126 value = (smallBoolt*) allocSmallInt(2); 13127 r = self->f->setAtSmallBool(self, 0, value); 13128 ck_assert_ptr_eq(r, null); 13129 terminateO(value); 13130 // NULL value 13131 ck_assert_ptr_eq(self->f->setAtSmallBool(self, 0, NULL), NULL); 13132 terminateO(self); 13133 13134 } 13135 13136 13137 void setAtSmallBytesSmallArrayT(CuTest *tc UNUSED) { 13138 13139 smallArrayt* r; 13140 smallArrayt *self = allocG(rtSmallArrayt); 13141 smallBytest *value; 13142 13143 // add elements to self 13144 r = self->f->pushInt(self, 1); 13145 ck_assert_ptr_ne(r, null); 13146 r = self->f->pushInt(self, 2); 13147 ck_assert_ptr_ne(r, null); 13148 r = self->f->pushInt(self, 3); 13149 ck_assert_ptr_ne(r, null); 13150 r = self->f->pushInt(self, 4); 13151 ck_assert_ptr_ne(r, null); 13152 13153 // positive index 13154 value = allocSmallBytes(NULL, 0); 13155 r = self->f->setAtSmallBytes(self, 1, value); 13156 ck_assert_ptr_ne(r, null); 13157 finishO(value); 13158 char *s = toStringO(r); 13159 ck_assert_str_eq(s, "[1,[],3,4]"); 13160 free(s); 13161 // negative index 13162 value = allocSmallBytes(NULL, 0); 13163 r = self->f->setAtSmallBytes(self, -1, value); 13164 ck_assert_ptr_ne(r, null); 13165 finishO(value); 13166 s = toStringO(r); 13167 ck_assert_str_eq(s, "[1,[],3,[]]"); 13168 free(s); 13169 // index outside 13170 value = allocSmallBytes(NULL, 0); 13171 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, 20, value), NULL); 13172 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, -5, value), NULL); 13173 // empty list 13174 emptyO(self); 13175 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, 0, value), NULL); 13176 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, -1, value), NULL); 13177 terminateO(value); 13178 // non smallBytes object 13179 value = (smallBytest*) allocSmallInt(2); 13180 r = self->f->setAtSmallBytes(self, 0, value); 13181 ck_assert_ptr_eq(r, null); 13182 terminateO(value); 13183 // NULL value 13184 ck_assert_ptr_eq(self->f->setAtSmallBytes(self, 0, NULL), NULL); 13185 terminateO(self); 13186 13187 } 13188 13189 13190 void setAtSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 13191 13192 smallArrayt* r; 13193 smallArrayt *self = allocG(rtSmallArrayt); 13194 smallDoublet *value; 13195 13196 // add elements to self 13197 r = self->f->pushInt(self, 1); 13198 ck_assert_ptr_ne(r, null); 13199 r = self->f->pushInt(self, 2); 13200 ck_assert_ptr_ne(r, null); 13201 r = self->f->pushInt(self, 3); 13202 ck_assert_ptr_ne(r, null); 13203 r = self->f->pushInt(self, 4); 13204 ck_assert_ptr_ne(r, null); 13205 13206 // positive index 13207 value = allocSmallDouble(5); 13208 r = self->f->setAtSmallDouble(self, 1, value); 13209 ck_assert_ptr_ne(r, null); 13210 finishO(value); 13211 char *s = toStringO(r); 13212 ck_assert_str_eq(s, "[1,5.000000e+00,3,4]"); 13213 free(s); 13214 // negative index 13215 value = allocSmallDouble(6); 13216 r = self->f->setAtSmallDouble(self, -1, value); 13217 ck_assert_ptr_ne(r, null); 13218 finishO(value); 13219 s = toStringO(r); 13220 ck_assert_str_eq(s, "[1,5.000000e+00,3,6.000000e+00]"); 13221 free(s); 13222 // empty smallDouble 13223 value = allocSmallDouble(0); 13224 freeO(value); 13225 r = self->f->setAtSmallDouble(self, -1, value); 13226 ck_assert_ptr_ne(r, null); 13227 finishO(value); 13228 s = toStringO(r); 13229 ck_assert_str_eq(s, "[1,5.000000e+00,3,0.000000e+00]"); 13230 free(s); 13231 // index outside 13232 value = allocSmallDouble(1); 13233 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, 20, value), NULL); 13234 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, -8, value), NULL); 13235 // empty list 13236 emptyO(self); 13237 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, 0, value), NULL); 13238 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, -1, value), NULL); 13239 terminateO(value); 13240 // non smallDouble object 13241 value = (smallDoublet*) allocSmallInt(2); 13242 r = self->f->setAtSmallDouble(self, 0, value); 13243 ck_assert_ptr_eq(r, null); 13244 terminateO(value); 13245 // NULL value 13246 ck_assert_ptr_eq(self->f->setAtSmallDouble(self, 0, NULL), NULL); 13247 terminateO(self); 13248 13249 } 13250 13251 13252 void setAtSmallIntSmallArrayT(CuTest *tc UNUSED) { 13253 13254 smallArrayt* r; 13255 smallArrayt *self = allocG(rtSmallArrayt); 13256 smallIntt *value; 13257 13258 // add elements to self 13259 r = self->f->pushInt(self, 1); 13260 ck_assert_ptr_ne(r, null); 13261 r = self->f->pushInt(self, 2); 13262 ck_assert_ptr_ne(r, null); 13263 r = self->f->pushInt(self, 3); 13264 ck_assert_ptr_ne(r, null); 13265 r = self->f->pushInt(self, 4); 13266 ck_assert_ptr_ne(r, null); 13267 13268 // positive index 13269 value = allocSmallInt(5); 13270 r = self->f->setAtSmallInt(self, 1, value); 13271 ck_assert_ptr_ne(r, null); 13272 finishO(value); 13273 char *s = toStringO(r); 13274 ck_assert_str_eq(s, "[1,5,3,4]"); 13275 free(s); 13276 // negative index 13277 value = allocSmallInt(6); 13278 r = self->f->setAtSmallInt(self, -1, value); 13279 ck_assert_ptr_ne(r, null); 13280 finishO(value); 13281 s = toStringO(r); 13282 ck_assert_str_eq(s, "[1,5,3,6]"); 13283 free(s); 13284 // empty SmallInt 13285 value = allocSmallInt(0); 13286 freeO(value); 13287 r = self->f->setAtSmallInt(self, -1, value); 13288 ck_assert_ptr_ne(r, null); 13289 finishO(value); 13290 s = toStringO(r); 13291 ck_assert_str_eq(s, "[1,5,3,0]"); 13292 free(s); 13293 // index outside 13294 value = allocSmallInt(1); 13295 ck_assert_ptr_eq(self->f->setAtSmallInt(self, 20, value), NULL); 13296 ck_assert_ptr_eq(self->f->setAtSmallInt(self, -8, value), NULL); 13297 // empty list 13298 emptyO(self); 13299 ck_assert_ptr_eq(self->f->setAtSmallInt(self, 0, value), NULL); 13300 ck_assert_ptr_eq(self->f->setAtSmallInt(self, -1, value), NULL); 13301 terminateO(value); 13302 // non smallInt object 13303 value = (smallIntt*) allocSmallBool(true); 13304 r = self->f->setAtSmallInt(self, 0, value); 13305 ck_assert_ptr_eq(r, null); 13306 terminateO(value); 13307 // NULL value 13308 ck_assert_ptr_eq(self->f->setAtSmallInt(self, 0, NULL), NULL); 13309 terminateO(self); 13310 13311 } 13312 13313 13314 void setAtSmallJsonSmallArrayT(CuTest *tc UNUSED) { 13315 13316 smallArrayt* r; 13317 smallArrayt *self = allocG(rtSmallArrayt); 13318 smallJsont *value; 13319 13320 // add elements to self 13321 r = self->f->pushInt(self, 1); 13322 ck_assert_ptr_ne(r, null); 13323 r = self->f->pushInt(self, 2); 13324 ck_assert_ptr_ne(r, null); 13325 r = self->f->pushInt(self, 3); 13326 ck_assert_ptr_ne(r, null); 13327 r = self->f->pushInt(self, 4); 13328 ck_assert_ptr_ne(r, null); 13329 13330 // positive index 13331 value = allocSmallJson(); 13332 r = self->f->setAtSmallJson(self, 1, value); 13333 ck_assert_ptr_ne(r, null); 13334 finishO(value); 13335 char *s = toStringO(r); 13336 ck_assert_str_eq(s, "[1,{},3,4]"); 13337 free(s); 13338 // negative index 13339 value = allocSmallJson(); 13340 r = self->f->setAtSmallJson(self, -1, value); 13341 ck_assert_ptr_ne(r, null); 13342 finishO(value); 13343 s = toStringO(r); 13344 ck_assert_str_eq(s, "[1,{},3,{}]"); 13345 free(s); 13346 // index outside 13347 value = allocSmallJson(); 13348 ck_assert_ptr_eq(self->f->setAtSmallJson(self, 20, value), NULL); 13349 ck_assert_ptr_eq(self->f->setAtSmallJson(self, -8, value), NULL); 13350 // empty list 13351 emptyO(self); 13352 ck_assert_ptr_eq(self->f->setAtSmallJson(self, 0, value), NULL); 13353 ck_assert_ptr_eq(self->f->setAtSmallJson(self, -1, value), NULL); 13354 terminateO(value); 13355 // non smallJson object 13356 value = (smallJsont*) allocSmallInt(2); 13357 r = self->f->setAtSmallJson(self, 0, value); 13358 ck_assert_ptr_eq(r, null); 13359 terminateO(value); 13360 // NULL value 13361 ck_assert_ptr_eq(self->f->setAtSmallJson(self, 0, NULL), NULL); 13362 terminateO(self); 13363 13364 } 13365 13366 13367 void setAtSmallStringSmallArrayT(CuTest *tc UNUSED) { 13368 13369 smallArrayt* r; 13370 smallArrayt *self = allocG(rtSmallArrayt); 13371 smallStringt *value; 13372 13373 // add elements to self 13374 r = self->f->pushInt(self, 1); 13375 ck_assert_ptr_ne(r, null); 13376 r = self->f->pushInt(self, 2); 13377 ck_assert_ptr_ne(r, null); 13378 r = self->f->pushInt(self, 3); 13379 ck_assert_ptr_ne(r, null); 13380 r = self->f->pushInt(self, 4); 13381 ck_assert_ptr_ne(r, null); 13382 13383 // positive index 13384 initiateAllocateSmallString(&value); 13385 r = self->f->setAtSmallString(self, 1, value); 13386 ck_assert_ptr_ne(r, null); 13387 finishO(value); 13388 char *s = toStringO(r); 13389 ck_assert_str_eq(s, "[1,\"\",3,4]"); 13390 free(s); 13391 // negative index 13392 value = allocSmallString("a"); 13393 r = self->f->setAtSmallString(self, -1, value); 13394 ck_assert_ptr_ne(r, null); 13395 finishO(value); 13396 s = toStringO(r); 13397 ck_assert_str_eq(s, "[1,\"\",3,\"a\"]"); 13398 free(s); 13399 // index outside 13400 value = allocSmallString("asd"); 13401 ck_assert_ptr_eq(self->f->setAtSmallString(self, 20, value), NULL); 13402 ck_assert_ptr_eq(self->f->setAtSmallString(self, -8, value), NULL); 13403 // empty list 13404 emptyO(self); 13405 ck_assert_ptr_eq(self->f->setAtSmallString(self, 0, value), NULL); 13406 ck_assert_ptr_eq(self->f->setAtSmallString(self, -1, value), NULL); 13407 terminateO(value); 13408 // non smallString object 13409 value = (smallStringt*) allocSmallInt(2); 13410 r = self->f->setAtSmallString(self, 0, value); 13411 ck_assert_ptr_eq(r, null); 13412 terminateO(value); 13413 // NULL value 13414 ck_assert_ptr_eq(self->f->setAtSmallString(self, 0, NULL), NULL); 13415 terminateO(self); 13416 13417 } 13418 13419 13420 void setAtSmallContainerSmallArrayT(CuTest *tc UNUSED) { 13421 13422 smallArrayt* r; 13423 smallArrayt *self = allocG(rtSmallArrayt); 13424 smallContainert *value; 13425 13426 // add elements to self 13427 r = self->f->pushInt(self, 1); 13428 ck_assert_ptr_ne(r, null); 13429 r = self->f->pushInt(self, 2); 13430 ck_assert_ptr_ne(r, null); 13431 r = self->f->pushInt(self, 3); 13432 ck_assert_ptr_ne(r, null); 13433 r = self->f->pushInt(self, 4); 13434 ck_assert_ptr_ne(r, null); 13435 13436 // positive index 13437 initiateAllocateSmallContainer(&value); 13438 r = self->f->setAtSmallContainer(self, 1, value); 13439 ck_assert_ptr_ne(r, null); 13440 finishO(value); 13441 char *s = toStringO(r); 13442 ck_assert_str_eq(s, "[1,\"<data container>\",3,4]"); 13443 free(s); 13444 // negative index 13445 initiateAllocateSmallContainer(&value); 13446 r = self->f->setAtSmallContainer(self, -1, value); 13447 ck_assert_ptr_ne(r, null); 13448 finishO(value); 13449 s = toStringO(r); 13450 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 13451 free(s); 13452 // index outside 13453 initiateAllocateSmallContainer(&value); 13454 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, 20, value), NULL); 13455 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, -8, value), NULL); 13456 // empty list 13457 emptyO(self); 13458 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, 0, value), NULL); 13459 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, -1, value), NULL); 13460 terminateO(value); 13461 // non smallContainer object 13462 value = (smallContainert*) allocSmallInt(2); 13463 r = self->f->setAtSmallContainer(self, 0, value); 13464 ck_assert_ptr_eq(r, null); 13465 terminateO(value); 13466 // NULL value 13467 ck_assert_ptr_eq(self->f->setAtSmallContainer(self, 0, NULL), NULL); 13468 terminateO(self); 13469 13470 } 13471 13472 13473 void setAtNFreeSmallArrayT(CuTest *tc UNUSED) { 13474 13475 smallArrayt* r; 13476 smallArrayt *self = allocG(rtSmallArrayt); 13477 baset *value; 13478 13479 // add elements to self 13480 r = self->f->pushInt(self, 1); 13481 ck_assert_ptr_ne(r, null); 13482 r = self->f->pushInt(self, 2); 13483 ck_assert_ptr_ne(r, null); 13484 r = self->f->pushInt(self, 3); 13485 ck_assert_ptr_ne(r, null); 13486 r = self->f->pushInt(self, 4); 13487 ck_assert_ptr_ne(r, null); 13488 13489 // positive index 13490 value = (baset*)allocSmallInt(123); 13491 r = self->f->setAtNFree(self, 1, value); 13492 ck_assert_ptr_ne(r, null); 13493 char *s = toStringO(r); 13494 ck_assert_str_eq(s, "[1,123,3,4]"); 13495 free(s); 13496 // negative index 13497 value = (baset*)allocSmallInt(234); 13498 r = self->f->setAtNFree(self, -1, value); 13499 ck_assert_ptr_ne(r, null); 13500 s = toStringO(r); 13501 ck_assert_str_eq(s, "[1,123,3,234]"); 13502 free(s); 13503 // undefined object 13504 value = (baset*)allocUndefined(); 13505 r = self->f->setAtNFree(self, -1, value); 13506 ck_assert_ptr_ne(r, null); 13507 s = toStringO(r); 13508 ck_assert_str_eq(s, "[1,123,3,null]"); 13509 free(s); 13510 // container 13511 createAllocateSmallContainer(c); 13512 r = self->f->setAtNFree(self, -1, (baset*)c); 13513 ck_assert_ptr_ne(r, null); 13514 s = toStringO(r); 13515 ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]"); 13516 free(s); 13517 // base object in container 13518 createAllocateSmallInt(I); 13519 setValG(I, 11); 13520 I->type = "anothertype"; 13521 r = self->f->setAtNFree(self, -1, (baset*)I); 13522 ck_assert_ptr_ne(r, null); 13523 s = toStringO(r); 13524 ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]"); 13525 free(s); 13526 // index outside 13527 value = (baset*)allocSmallInt(123); 13528 ck_assert_ptr_eq(self->f->setAtNFree(self, 20, value), NULL); 13529 ck_assert_ptr_eq(self->f->setAtNFree(self, -8, value), NULL); 13530 // empty list 13531 emptyO(self); 13532 ck_assert_ptr_eq(self->f->setAtNFree(self, 0, value), NULL); 13533 ck_assert_ptr_eq(self->f->setAtNFree(self, -1, value), NULL); 13534 terminateO(value); 13535 // NULL value 13536 ck_assert_ptr_eq(self->f->setAtNFree(self, 0, NULL), NULL); 13537 terminateO(self); 13538 13539 } 13540 13541 13542 void setAtNFreeUndefinedSmallArrayT(CuTest *tc UNUSED) { 13543 13544 smallArrayt* r; 13545 smallArrayt *self = allocG(rtSmallArrayt); 13546 undefinedt *value = NULL; 13547 13548 13549 // add elements to self 13550 r = self->f->pushInt(self, 1); 13551 ck_assert_ptr_ne(r, null); 13552 r = self->f->pushInt(self, 2); 13553 ck_assert_ptr_ne(r, null); 13554 r = self->f->pushInt(self, 3); 13555 ck_assert_ptr_ne(r, null); 13556 r = self->f->pushInt(self, 4); 13557 ck_assert_ptr_ne(r, null); 13558 13559 // positive index 13560 value = allocUndefined(); 13561 r = self->f->setAtNFreeUndefined(self, 1, value); 13562 ck_assert_ptr_ne(r, null); 13563 char *s = toStringO(r); 13564 ck_assert_str_eq(s, "[1,null,3,4]"); 13565 free(s); 13566 // negative index 13567 value = allocUndefined(); 13568 r = self->f->setAtNFreeUndefined(self, -1, value); 13569 ck_assert_ptr_ne(r, null); 13570 s = toStringO(r); 13571 ck_assert_str_eq(s, "[1,null,3,null]"); 13572 free(s); 13573 // index outside 13574 value = allocUndefined(); 13575 ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, 20, value), NULL); 13576 terminateO(value); 13577 13578 value = allocUndefined(); 13579 ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, -8, value), NULL); 13580 terminateO(value); 13581 13582 // empty list 13583 emptyO(self); 13584 value = allocUndefined(); 13585 ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, 0, value), NULL); 13586 terminateO(value); 13587 13588 value = allocUndefined(); 13589 ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, -1, value), NULL); 13590 terminateO(value); 13591 13592 terminateO(self); 13593 13594 } 13595 13596 13597 void setAtNFreeSSmallArrayT(CuTest *tc UNUSED) { 13598 13599 smallArrayt* r; 13600 smallArrayt *self = allocG(rtSmallArrayt); 13601 13602 // add elements to self 13603 r = self->f->pushInt(self, 1); 13604 ck_assert_ptr_ne(r, null); 13605 r = self->f->pushInt(self, 2); 13606 ck_assert_ptr_ne(r, null); 13607 r = self->f->pushInt(self, 3); 13608 ck_assert_ptr_ne(r, null); 13609 r = self->f->pushInt(self, 4); 13610 ck_assert_ptr_ne(r, null); 13611 13612 // positive index 13613 r = self->f->setAtNFreeS(self, 1, strdup("a")); 13614 ck_assert_ptr_ne(r, null); 13615 char *s = toStringO(r); 13616 ck_assert_str_eq(s, "[1,\"a\",3,4]"); 13617 free(s); 13618 // negative index 13619 r = self->f->setAtNFreeS(self, -1, strdup("b")); 13620 ck_assert_ptr_ne(r, null); 13621 s = toStringO(r); 13622 ck_assert_str_eq(s, "[1,\"a\",3,\"b\"]"); 13623 free(s); 13624 // NULL string 13625 r = self->f->setAtNFreeS(self, -1, NULL); 13626 ck_assert_ptr_eq(r, null); 13627 // index outside 13628 ck_assert_ptr_eq(self->f->setAtNFreeS(self, 20, ""), NULL); 13629 ck_assert_ptr_eq(self->f->setAtNFreeS(self, -8, ""), NULL); 13630 // empty list 13631 emptyO(self); 13632 ck_assert_ptr_eq(self->f->setAtNFreeS(self, 0, ""), NULL); 13633 ck_assert_ptr_eq(self->f->setAtNFreeS(self, -1, ""), NULL); 13634 terminateO(self); 13635 13636 } 13637 13638 13639 void setAtNFreeDictSmallArrayT(CuTest *tc UNUSED) { 13640 13641 smallArrayt* r; 13642 smallArrayt *self = allocG(rtSmallArrayt); 13643 smallDictt *value; 13644 13645 // add elements to self 13646 r = self->f->pushInt(self, 1); 13647 ck_assert_ptr_ne(r, null); 13648 r = self->f->pushInt(self, 2); 13649 ck_assert_ptr_ne(r, null); 13650 r = self->f->pushInt(self, 3); 13651 ck_assert_ptr_ne(r, null); 13652 r = self->f->pushInt(self, 4); 13653 ck_assert_ptr_ne(r, null); 13654 13655 // positive index 13656 value = allocSmallDict(); 13657 r = self->f->setAtNFreeDict(self, 1, value); 13658 ck_assert_ptr_ne(r, null); 13659 char *s = toStringO(r); 13660 ck_assert_str_eq(s, "[1,{},3,4]"); 13661 free(s); 13662 // negative index 13663 value = allocSmallDict(); 13664 r = self->f->setAtNFreeDict(self, -1, value); 13665 ck_assert_ptr_ne(r, null); 13666 s = toStringO(r); 13667 ck_assert_str_eq(s, "[1,{},3,{}]"); 13668 free(s); 13669 // index outside 13670 value = allocSmallDict(); 13671 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, 20, value), NULL); 13672 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, -8, value), NULL); 13673 // empty list 13674 emptyO(self); 13675 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, 0, value), NULL); 13676 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, -1, value), NULL); 13677 terminateO(value); 13678 // NULL value 13679 ck_assert_ptr_eq(self->f->setAtNFreeDict(self, 0, NULL), NULL); 13680 terminateO(self); 13681 13682 } 13683 13684 13685 void setAtNFreeArraySmallArrayT(CuTest *tc UNUSED) { 13686 13687 smallArrayt* r; 13688 smallArrayt *self = allocG(rtSmallArrayt); 13689 smallArrayt *value; 13690 13691 // add elements to self 13692 r = self->f->pushInt(self, 1); 13693 ck_assert_ptr_ne(r, null); 13694 r = self->f->pushInt(self, 2); 13695 ck_assert_ptr_ne(r, null); 13696 r = self->f->pushInt(self, 3); 13697 ck_assert_ptr_ne(r, null); 13698 r = self->f->pushInt(self, 4); 13699 ck_assert_ptr_ne(r, null); 13700 13701 // positive index 13702 value = allocSmallArray(); 13703 r = self->f->setAtNFreeArray(self, 1, value); 13704 ck_assert_ptr_ne(r, null); 13705 char *s = toStringO(r); 13706 ck_assert_str_eq(s, "[1,[],3,4]"); 13707 free(s); 13708 // negative index 13709 value = allocSmallArray(); 13710 r = self->f->setAtNFreeArray(self, -1, value); 13711 ck_assert_ptr_ne(r, null); 13712 s = toStringO(r); 13713 ck_assert_str_eq(s, "[1,[],3,[]]"); 13714 free(s); 13715 // index outside 13716 value = allocSmallArray(); 13717 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, 20, value), NULL); 13718 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, -8, value), NULL); 13719 // empty list 13720 emptyO(self); 13721 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, 0, value), NULL); 13722 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, -1, value), NULL); 13723 terminateO(value); 13724 // NULL value 13725 ck_assert_ptr_eq(self->f->setAtNFreeArray(self, 0, NULL), NULL); 13726 terminateO(self); 13727 13728 } 13729 13730 13731 void setAtNFreeArraycSmallArrayT(CuTest *tc UNUSED) { 13732 13733 smallArrayt* r; 13734 smallArrayt *self = allocG(rtSmallArrayt); 13735 char **value; 13736 13737 // add elements to self 13738 r = self->f->pushInt(self, 1); 13739 ck_assert_ptr_ne(r, null); 13740 r = self->f->pushInt(self, 2); 13741 ck_assert_ptr_ne(r, null); 13742 r = self->f->pushInt(self, 3); 13743 ck_assert_ptr_ne(r, null); 13744 r = self->f->pushInt(self, 4); 13745 ck_assert_ptr_ne(r, null); 13746 13747 // positive index 13748 value = listCreateS("a"); 13749 r = self->f->setAtNFreeArrayc(self, 1, value); 13750 ck_assert_ptr_ne(r, null); 13751 char *s = toStringO(r); 13752 ck_assert_str_eq(s, "[1,[\"a\"],3,4]"); 13753 free(s); 13754 // negative index 13755 value = listCreateS("b"); 13756 r = self->f->setAtNFreeArrayc(self, -1, value); 13757 ck_assert_ptr_ne(r, null); 13758 s = toStringO(r); 13759 ck_assert_str_eq(s, "[1,[\"a\"],3,[\"b\"]]"); 13760 free(s); 13761 // index outside 13762 value = (char**)r; 13763 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, 20, value), NULL); 13764 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, -8, value), NULL); 13765 // empty list 13766 emptyO(self); 13767 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, 0, value), NULL); 13768 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, -1, value), NULL); 13769 // NULL value 13770 ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, 0, NULL), NULL); 13771 terminateO(self); 13772 13773 } 13774 13775 13776 void setAtNFreeSmallBoolSmallArrayT(CuTest *tc UNUSED) { 13777 13778 smallArrayt* r; 13779 smallArrayt *self = allocG(rtSmallArrayt); 13780 smallBoolt *value; 13781 13782 // add elements to self 13783 r = self->f->pushInt(self, 1); 13784 ck_assert_ptr_ne(r, null); 13785 r = self->f->pushInt(self, 2); 13786 ck_assert_ptr_ne(r, null); 13787 r = self->f->pushInt(self, 3); 13788 ck_assert_ptr_ne(r, null); 13789 r = self->f->pushInt(self, 4); 13790 ck_assert_ptr_ne(r, null); 13791 13792 // positive index 13793 value = allocSmallBool(true); 13794 r = self->f->setAtNFreeSmallBool(self, 1, value); 13795 ck_assert_ptr_ne(r, null); 13796 char *s = toStringO(r); 13797 ck_assert_str_eq(s, "[1,true,3,4]"); 13798 free(s); 13799 // negative index 13800 value = allocSmallBool(true); 13801 r = self->f->setAtNFreeSmallBool(self, -1, value); 13802 ck_assert_ptr_ne(r, null); 13803 s = toStringO(r); 13804 ck_assert_str_eq(s, "[1,true,3,true]"); 13805 free(s); 13806 // index outside 13807 value = allocSmallBool(true); 13808 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, 20, value), NULL); 13809 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, -8, value), NULL); 13810 // empty list 13811 emptyO(self); 13812 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, 0, value), NULL); 13813 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, -1, value), NULL); 13814 terminateO(value); 13815 // NULL value 13816 ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, 0, NULL), NULL); 13817 terminateO(self); 13818 13819 } 13820 13821 13822 void setAtNFreeSmallBytesSmallArrayT(CuTest *tc UNUSED) { 13823 13824 smallArrayt* r; 13825 smallArrayt *self = allocG(rtSmallArrayt); 13826 smallBytest *value; 13827 13828 // add elements to self 13829 r = self->f->pushInt(self, 1); 13830 ck_assert_ptr_ne(r, null); 13831 r = self->f->pushInt(self, 2); 13832 ck_assert_ptr_ne(r, null); 13833 r = self->f->pushInt(self, 3); 13834 ck_assert_ptr_ne(r, null); 13835 r = self->f->pushInt(self, 4); 13836 ck_assert_ptr_ne(r, null); 13837 13838 // positive index 13839 value = allocSmallBytes(NULL, 0); 13840 r = self->f->setAtNFreeSmallBytes(self, 1, value); 13841 ck_assert_ptr_ne(r, null); 13842 char *s = toStringO(r); 13843 ck_assert_str_eq(s, "[1,[],3,4]"); 13844 free(s); 13845 // negative index 13846 value = allocSmallBytes(NULL, 0); 13847 r = self->f->setAtNFreeSmallBytes(self, -1, value); 13848 ck_assert_ptr_ne(r, null); 13849 s = toStringO(r); 13850 ck_assert_str_eq(s, "[1,[],3,[]]"); 13851 free(s); 13852 // index outside 13853 value = allocSmallBytes(NULL, 0); 13854 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, 20, value), NULL); 13855 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, -5, value), NULL); 13856 // empty list 13857 emptyO(self); 13858 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, 0, value), NULL); 13859 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, -1, value), NULL); 13860 terminateO(value); 13861 // NULL value 13862 ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, 0, NULL), NULL); 13863 terminateO(self); 13864 13865 } 13866 13867 13868 void setAtNFreeSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 13869 13870 smallArrayt* r; 13871 smallArrayt *self = allocG(rtSmallArrayt); 13872 smallDoublet *value; 13873 13874 // add elements to self 13875 r = self->f->pushInt(self, 1); 13876 ck_assert_ptr_ne(r, null); 13877 r = self->f->pushInt(self, 2); 13878 ck_assert_ptr_ne(r, null); 13879 r = self->f->pushInt(self, 3); 13880 ck_assert_ptr_ne(r, null); 13881 r = self->f->pushInt(self, 4); 13882 ck_assert_ptr_ne(r, null); 13883 13884 // positive index 13885 value = allocSmallDouble(5); 13886 r = self->f->setAtNFreeSmallDouble(self, 1, value); 13887 ck_assert_ptr_ne(r, null); 13888 char *s = toStringO(r); 13889 ck_assert_str_eq(s, "[1,5.000000e+00,3,4]"); 13890 free(s); 13891 // negative index 13892 value = allocSmallDouble(6); 13893 r = self->f->setAtNFreeSmallDouble(self, -1, value); 13894 ck_assert_ptr_ne(r, null); 13895 s = toStringO(r); 13896 ck_assert_str_eq(s, "[1,5.000000e+00,3,6.000000e+00]"); 13897 free(s); 13898 // index outside 13899 value = allocSmallDouble(1); 13900 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, 20, value), NULL); 13901 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, -8, value), NULL); 13902 // empty list 13903 emptyO(self); 13904 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, 0, value), NULL); 13905 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, -1, value), NULL); 13906 terminateO(value); 13907 // NULL value 13908 ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, 0, NULL), NULL); 13909 terminateO(self); 13910 13911 } 13912 13913 13914 void setAtNFreeSmallIntSmallArrayT(CuTest *tc UNUSED) { 13915 13916 smallArrayt* r; 13917 smallArrayt *self = allocG(rtSmallArrayt); 13918 smallIntt *value; 13919 13920 // add elements to self 13921 r = self->f->pushInt(self, 1); 13922 ck_assert_ptr_ne(r, null); 13923 r = self->f->pushInt(self, 2); 13924 ck_assert_ptr_ne(r, null); 13925 r = self->f->pushInt(self, 3); 13926 ck_assert_ptr_ne(r, null); 13927 r = self->f->pushInt(self, 4); 13928 ck_assert_ptr_ne(r, null); 13929 13930 // positive index 13931 value = allocSmallInt(5); 13932 r = self->f->setAtNFreeSmallInt(self, 1, value); 13933 ck_assert_ptr_ne(r, null); 13934 char *s = toStringO(r); 13935 ck_assert_str_eq(s, "[1,5,3,4]"); 13936 free(s); 13937 // negative index 13938 value = allocSmallInt(6); 13939 r = self->f->setAtNFreeSmallInt(self, -1, value); 13940 ck_assert_ptr_ne(r, null); 13941 s = toStringO(r); 13942 ck_assert_str_eq(s, "[1,5,3,6]"); 13943 free(s); 13944 // index outside 13945 value = allocSmallInt(1); 13946 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, 20, value), NULL); 13947 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, -8, value), NULL); 13948 // empty list 13949 emptyO(self); 13950 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, 0, value), NULL); 13951 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, -1, value), NULL); 13952 terminateO(value); 13953 // NULL value 13954 ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, 0, NULL), NULL); 13955 terminateO(self); 13956 13957 } 13958 13959 13960 void setAtNFreeSmallJsonSmallArrayT(CuTest *tc UNUSED) { 13961 13962 smallArrayt* r; 13963 smallArrayt *self = allocG(rtSmallArrayt); 13964 smallJsont *value; 13965 13966 // add elements to self 13967 r = self->f->pushInt(self, 1); 13968 ck_assert_ptr_ne(r, null); 13969 r = self->f->pushInt(self, 2); 13970 ck_assert_ptr_ne(r, null); 13971 r = self->f->pushInt(self, 3); 13972 ck_assert_ptr_ne(r, null); 13973 r = self->f->pushInt(self, 4); 13974 ck_assert_ptr_ne(r, null); 13975 13976 // positive index 13977 value = allocSmallJson(); 13978 r = self->f->setAtNFreeSmallJson(self, 1, value); 13979 ck_assert_ptr_ne(r, null); 13980 char *s = toStringO(r); 13981 ck_assert_str_eq(s, "[1,{},3,4]"); 13982 free(s); 13983 // negative index 13984 value = allocSmallJson(); 13985 r = self->f->setAtNFreeSmallJson(self, -1, value); 13986 ck_assert_ptr_ne(r, null); 13987 s = toStringO(r); 13988 ck_assert_str_eq(s, "[1,{},3,{}]"); 13989 free(s); 13990 // index outside 13991 value = allocSmallJson(); 13992 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, 20, value), NULL); 13993 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, -8, value), NULL); 13994 // empty list 13995 emptyO(self); 13996 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, 0, value), NULL); 13997 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, -1, value), NULL); 13998 terminateO(value); 13999 // NULL value 14000 ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, 0, NULL), NULL); 14001 terminateO(self); 14002 14003 } 14004 14005 14006 void setAtNFreeSmallStringSmallArrayT(CuTest *tc UNUSED) { 14007 14008 smallArrayt* r; 14009 smallArrayt *self = allocG(rtSmallArrayt); 14010 smallStringt *value; 14011 14012 // add elements to self 14013 r = self->f->pushInt(self, 1); 14014 ck_assert_ptr_ne(r, null); 14015 r = self->f->pushInt(self, 2); 14016 ck_assert_ptr_ne(r, null); 14017 r = self->f->pushInt(self, 3); 14018 ck_assert_ptr_ne(r, null); 14019 r = self->f->pushInt(self, 4); 14020 ck_assert_ptr_ne(r, null); 14021 14022 // positive index 14023 initiateAllocateSmallString(&value); 14024 r = self->f->setAtNFreeSmallString(self, 1, value); 14025 ck_assert_ptr_ne(r, null); 14026 char *s = toStringO(r); 14027 ck_assert_str_eq(s, "[1,\"\",3,4]"); 14028 free(s); 14029 // negative index 14030 value = allocSmallString("a"); 14031 r = self->f->setAtNFreeSmallString(self, -1, value); 14032 ck_assert_ptr_ne(r, null); 14033 s = toStringO(r); 14034 ck_assert_str_eq(s, "[1,\"\",3,\"a\"]"); 14035 free(s); 14036 // index outside 14037 value = allocSmallString("asd"); 14038 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, 20, value), NULL); 14039 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, -8, value), NULL); 14040 // empty list 14041 emptyO(self); 14042 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, 0, value), NULL); 14043 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, -1, value), NULL); 14044 terminateO(value); 14045 // NULL value 14046 ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, 0, NULL), NULL); 14047 terminateO(self); 14048 14049 } 14050 14051 14052 void setAtNFreeSmallContainerSmallArrayT(CuTest *tc UNUSED) { 14053 14054 smallArrayt* r; 14055 smallArrayt *self = allocG(rtSmallArrayt); 14056 smallContainert *value; 14057 14058 // add elements to self 14059 r = self->f->pushInt(self, 1); 14060 ck_assert_ptr_ne(r, null); 14061 r = self->f->pushInt(self, 2); 14062 ck_assert_ptr_ne(r, null); 14063 r = self->f->pushInt(self, 3); 14064 ck_assert_ptr_ne(r, null); 14065 r = self->f->pushInt(self, 4); 14066 ck_assert_ptr_ne(r, null); 14067 14068 // positive index 14069 initiateAllocateSmallContainer(&value); 14070 r = self->f->setAtNFreeSmallContainer(self, 1, value); 14071 ck_assert_ptr_ne(r, null); 14072 char *s = toStringO(r); 14073 ck_assert_str_eq(s, "[1,\"<data container>\",3,4]"); 14074 free(s); 14075 // negative index 14076 initiateAllocateSmallContainer(&value); 14077 r = self->f->setAtNFreeSmallContainer(self, -1, value); 14078 ck_assert_ptr_ne(r, null); 14079 s = toStringO(r); 14080 ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]"); 14081 free(s); 14082 // index outside 14083 initiateAllocateSmallContainer(&value); 14084 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, 20, value), NULL); 14085 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, -8, value), NULL); 14086 // empty list 14087 emptyO(self); 14088 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, 0, value), NULL); 14089 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, -1, value), NULL); 14090 terminateO(value); 14091 // NULL value 14092 ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, 0, NULL), NULL); 14093 terminateO(self); 14094 14095 } 14096 14097 14098 void setPAtDictSmallArrayT(CuTest *tc UNUSED) { 14099 14100 smallArrayt* r; 14101 smallArrayt *self = allocG(rtSmallArrayt); 14102 smallDictt *value; 14103 14104 // add elements to self 14105 r = self->f->pushInt(self, 1); 14106 ck_assert_ptr_ne(r, null); 14107 r = self->f->pushInt(self, 2); 14108 ck_assert_ptr_ne(r, null); 14109 r = self->f->pushInt(self, 3); 14110 ck_assert_ptr_ne(r, null); 14111 r = self->f->pushInt(self, 4); 14112 ck_assert_ptr_ne(r, null); 14113 14114 // positive index 14115 value = allocSmallDict(); 14116 r = self->f->setAtDict(self, 1, value); 14117 ck_assert_ptr_ne(r, null); 14118 value->f->setInt(value, "a", 1); 14119 r = self->f->setPAtDict(self, 1, value); 14120 ck_assert_ptr_ne(r, null); 14121 finishO(value); 14122 char *s = toStringO(r); 14123 ck_assert_str_eq(s, "[1,{\"a\":1},3,4]"); 14124 free(s); 14125 // negative index 14126 value = allocSmallDict(); 14127 r = self->f->setAtDict(self, -1, value); 14128 ck_assert_ptr_ne(r, null); 14129 value->f->setInt(value, "a", 2); 14130 r = self->f->setPAtDict(self, -1, value); 14131 ck_assert_ptr_ne(r, null); 14132 finishO(value); 14133 s = toStringO(r); 14134 ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]"); 14135 free(s); 14136 // empty smallDict 14137 value = allocSmallDict(); 14138 r = self->f->setPAtDict(self, -1, value); 14139 ck_assert_ptr_eq(r, null); 14140 terminateO(value); 14141 // non smallDict object 14142 value = (smallDictt*) allocSmallInt(2); 14143 r = self->f->setPAtDict(self, 0, value); 14144 ck_assert_ptr_eq(r, null); 14145 terminateO(value); 14146 // index outside 14147 value = allocSmallDict(); 14148 ck_assert_ptr_eq(self->f->setPAtDict(self, 20, value), NULL); 14149 ck_assert_ptr_eq(self->f->setPAtDict(self, -8, value), NULL); 14150 // empty list 14151 emptyO(self); 14152 ck_assert_ptr_eq(self->f->setPAtDict(self, 0, value), NULL); 14153 ck_assert_ptr_eq(self->f->setPAtDict(self, -1, value), NULL); 14154 terminateO(value); 14155 // NULL value 14156 ck_assert_ptr_eq(self->f->setPAtDict(self, 0, NULL), NULL); 14157 terminateO(self); 14158 14159 } 14160 14161 14162 void setPAtArraySmallArrayT(CuTest *tc UNUSED) { 14163 14164 smallArrayt* r; 14165 smallArrayt *self = allocG(rtSmallArrayt); 14166 smallArrayt *value; 14167 14168 // add elements to self 14169 r = self->f->pushInt(self, 1); 14170 ck_assert_ptr_ne(r, null); 14171 r = self->f->pushInt(self, 2); 14172 ck_assert_ptr_ne(r, null); 14173 r = self->f->pushInt(self, 3); 14174 ck_assert_ptr_ne(r, null); 14175 r = self->f->pushInt(self, 4); 14176 ck_assert_ptr_ne(r, null); 14177 14178 // positive index 14179 value = allocSmallArray(); 14180 r = self->f->setAtArray(self, 1, value); 14181 ck_assert_ptr_ne(r, null); 14182 value->f->pushInt(value, 1); 14183 r = self->f->setPAtArray(self, 1, value); 14184 ck_assert_ptr_ne(r, null); 14185 finishO(value); 14186 char *s = toStringO(r); 14187 ck_assert_str_eq(s, "[1,[1],3,4]"); 14188 free(s); 14189 // negative index 14190 value = allocSmallArray(); 14191 r = self->f->setAtArray(self, -1, value); 14192 ck_assert_ptr_ne(r, null); 14193 value->f->pushInt(value, 2); 14194 r = self->f->setPAtArray(self, -1, value); 14195 ck_assert_ptr_ne(r, null); 14196 finishO(value); 14197 s = toStringO(r); 14198 ck_assert_str_eq(s, "[1,[1],3,[2]]"); 14199 free(s); 14200 // empty smallArray 14201 value = allocSmallArray(); 14202 r = self->f->setPAtArray(self, -1, value); 14203 ck_assert_ptr_eq(r, null); 14204 terminateO(value); 14205 // non smallArray object 14206 value = (smallArrayt*) allocSmallInt(2); 14207 r = self->f->setPAtArray(self, 0, value); 14208 ck_assert_ptr_eq(r, null); 14209 terminateO(value); 14210 // index outside 14211 value = allocSmallArray(); 14212 ck_assert_ptr_eq(self->f->setPAtArray(self, 20, value), NULL); 14213 ck_assert_ptr_eq(self->f->setPAtArray(self, -8, value), NULL); 14214 // empty list 14215 emptyO(self); 14216 ck_assert_ptr_eq(self->f->setPAtArray(self, 0, value), NULL); 14217 ck_assert_ptr_eq(self->f->setPAtArray(self, -1, value), NULL); 14218 terminateO(value); 14219 // NULL value 14220 ck_assert_ptr_eq(self->f->setPAtArray(self, 0, NULL), NULL); 14221 terminateO(self); 14222 14223 } 14224 14225 14226 void setPAtSmallJsonSmallArrayT(CuTest *tc UNUSED) { 14227 14228 smallArrayt* r; 14229 smallArrayt *self = allocG(rtSmallArrayt); 14230 smallJsont *value; 14231 14232 // add elements to self 14233 r = self->f->pushInt(self, 1); 14234 ck_assert_ptr_ne(r, null); 14235 r = self->f->pushInt(self, 2); 14236 ck_assert_ptr_ne(r, null); 14237 r = self->f->pushInt(self, 3); 14238 ck_assert_ptr_ne(r, null); 14239 r = self->f->pushInt(self, 4); 14240 ck_assert_ptr_ne(r, null); 14241 14242 // positive index 14243 value = allocSmallJson(); 14244 r = self->f->setAtSmallJson(self, 1, value); 14245 ck_assert_ptr_ne(r, null); 14246 value->f->setInt(value, "a", 1); 14247 r = self->f->setPAtSmallJson(self, 1, value); 14248 ck_assert_ptr_ne(r, null); 14249 finishO(value); 14250 char *s = toStringO(r); 14251 ck_assert_str_eq(s, "[1,{\"a\":1},3,4]"); 14252 free(s); 14253 // negative index 14254 value = allocSmallJson(); 14255 r = self->f->setAtSmallJson(self, -1, value); 14256 ck_assert_ptr_ne(r, null); 14257 value->f->setInt(value, "a", 2); 14258 r = self->f->setPAtSmallJson(self, -1, value); 14259 ck_assert_ptr_ne(r, null); 14260 finishO(value); 14261 s = toStringO(r); 14262 ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]"); 14263 free(s); 14264 // empty smallJson 14265 value = allocSmallJson(); 14266 r = self->f->setPAtSmallJson(self, -1, value); 14267 ck_assert_ptr_eq(r, null); 14268 terminateO(value); 14269 // non smallJson object 14270 value = (smallJsont*) allocSmallInt(2); 14271 r = self->f->setPAtSmallJson(self, 0, value); 14272 ck_assert_ptr_eq(r, null); 14273 terminateO(value); 14274 // index outside 14275 value = allocSmallJson(); 14276 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, 20, value), NULL); 14277 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, -8, value), NULL); 14278 // empty list 14279 emptyO(self); 14280 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, 0, value), NULL); 14281 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, -1, value), NULL); 14282 terminateO(value); 14283 // NULL value 14284 ck_assert_ptr_eq(self->f->setPAtSmallJson(self, 0, NULL), NULL); 14285 terminateO(self); 14286 14287 } 14288 14289 14290 void setPAtSmallStringSmallArrayT(CuTest *tc UNUSED) { 14291 14292 smallArrayt* r; 14293 smallArrayt *self = allocG(rtSmallArrayt); 14294 smallStringt *value; 14295 14296 // add elements to self 14297 r = self->f->pushInt(self, 1); 14298 ck_assert_ptr_ne(r, null); 14299 r = self->f->pushInt(self, 2); 14300 ck_assert_ptr_ne(r, null); 14301 r = self->f->pushInt(self, 3); 14302 ck_assert_ptr_ne(r, null); 14303 r = self->f->pushInt(self, 4); 14304 ck_assert_ptr_ne(r, null); 14305 14306 // positive index 14307 initiateAllocateSmallString(&value); 14308 r = self->f->setAtSmallString(self, 1, value); 14309 ck_assert_ptr_ne(r, null); 14310 value->f->appendS(value, "1"); 14311 r = self->f->setPAtSmallString(self, 1, value); 14312 ck_assert_ptr_ne(r, null); 14313 finishO(value); 14314 char *s = toStringO(r); 14315 ck_assert_str_eq(s, "[1,\"1\",3,4]"); 14316 free(s); 14317 // negative index 14318 value = allocSmallString("a"); 14319 r = self->f->setAtSmallString(self, -1, value); 14320 ck_assert_ptr_ne(r, null); 14321 value->f->appendS(value, "2"); 14322 r = self->f->setPAtSmallString(self, -1, value); 14323 ck_assert_ptr_ne(r, null); 14324 finishO(value); 14325 s = toStringO(r); 14326 ck_assert_str_eq(s, "[1,\"1\",3,\"a2\"]"); 14327 free(s); 14328 // empty SmallString 14329 value = allocSmallString(""); 14330 freeO(value); 14331 r = self->f->setPAtSmallString(self, -1, value); 14332 ck_assert_ptr_eq(r, null); 14333 terminateO(value); 14334 // non smallString object 14335 value = (smallStringt*) allocSmallInt(2); 14336 r = self->f->setPAtSmallString(self, 0, value); 14337 ck_assert_ptr_eq(r, null); 14338 terminateO(value); 14339 // index outside 14340 value = allocSmallString("asd"); 14341 ck_assert_ptr_eq(self->f->setPAtSmallString(self, 20, value), NULL); 14342 ck_assert_ptr_eq(self->f->setPAtSmallString(self, -8, value), NULL); 14343 // empty list 14344 emptyO(self); 14345 ck_assert_ptr_eq(self->f->setPAtSmallString(self, 0, value), NULL); 14346 ck_assert_ptr_eq(self->f->setPAtSmallString(self, -1, value), NULL); 14347 terminateO(value); 14348 // NULL value 14349 ck_assert_ptr_eq(self->f->setPAtSmallString(self, 0, NULL), NULL); 14350 terminateO(self); 14351 14352 } 14353 14354 14355 void setPAtNFreeDictSmallArrayT(CuTest *tc UNUSED) { 14356 14357 smallArrayt* r; 14358 smallArrayt *self = allocG(rtSmallArrayt); 14359 smallDictt *value; 14360 14361 // add elements to self 14362 r = self->f->pushInt(self, 1); 14363 ck_assert_ptr_ne(r, null); 14364 r = self->f->pushInt(self, 2); 14365 ck_assert_ptr_ne(r, null); 14366 r = self->f->pushInt(self, 3); 14367 ck_assert_ptr_ne(r, null); 14368 r = self->f->pushInt(self, 4); 14369 ck_assert_ptr_ne(r, null); 14370 14371 // positive index 14372 value = allocSmallDict(); 14373 r = self->f->setAtDict(self, 1, value); 14374 ck_assert_ptr_ne(r, null); 14375 value->f->setInt(value, "a", 1); 14376 r = self->f->setPAtNFreeDict(self, 1, value); 14377 ck_assert_ptr_ne(r, null); 14378 char *s = toStringO(r); 14379 ck_assert_str_eq(s, "[1,{\"a\":1},3,4]"); 14380 free(s); 14381 // negative index 14382 value = allocSmallDict(); 14383 r = self->f->setAtDict(self, -1, value); 14384 ck_assert_ptr_ne(r, null); 14385 value->f->setInt(value, "a", 2); 14386 r = self->f->setPAtNFreeDict(self, -1, value); 14387 ck_assert_ptr_ne(r, null); 14388 s = toStringO(r); 14389 ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]"); 14390 free(s); 14391 // empty smallDict 14392 value = allocSmallDict(); 14393 r = self->f->setPAtNFreeDict(self, -1, value); 14394 ck_assert_ptr_eq(r, null); 14395 terminateO(value); 14396 // non smallDict object 14397 value = (smallDictt*) allocSmallInt(2); 14398 r = self->f->setPAtNFreeDict(self, 0, value); 14399 ck_assert_ptr_eq(r, null); 14400 terminateO(value); 14401 // index outside 14402 value = allocSmallDict(); 14403 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, 20, value), NULL); 14404 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, -8, value), NULL); 14405 // empty list 14406 emptyO(self); 14407 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, 0, value), NULL); 14408 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, -1, value), NULL); 14409 terminateO(value); 14410 // NULL value 14411 ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, 0, NULL), NULL); 14412 terminateO(self); 14413 14414 } 14415 14416 14417 void setPAtNFreeArraySmallArrayT(CuTest *tc UNUSED) { 14418 14419 smallArrayt* r; 14420 smallArrayt *self = allocG(rtSmallArrayt); 14421 smallArrayt *value; 14422 14423 // add elements to self 14424 r = self->f->pushInt(self, 1); 14425 ck_assert_ptr_ne(r, null); 14426 r = self->f->pushInt(self, 2); 14427 ck_assert_ptr_ne(r, null); 14428 r = self->f->pushInt(self, 3); 14429 ck_assert_ptr_ne(r, null); 14430 r = self->f->pushInt(self, 4); 14431 ck_assert_ptr_ne(r, null); 14432 14433 // positive index 14434 value = allocSmallArray(); 14435 r = self->f->setAtArray(self, 1, value); 14436 ck_assert_ptr_ne(r, null); 14437 value->f->pushInt(value, 1); 14438 r = self->f->setPAtNFreeArray(self, 1, value); 14439 ck_assert_ptr_ne(r, null); 14440 char *s = toStringO(r); 14441 ck_assert_str_eq(s, "[1,[1],3,4]"); 14442 free(s); 14443 // negative index 14444 value = allocSmallArray(); 14445 r = self->f->setAtArray(self, -1, value); 14446 ck_assert_ptr_ne(r, null); 14447 value->f->pushInt(value, 2); 14448 r = self->f->setPAtNFreeArray(self, -1, value); 14449 ck_assert_ptr_ne(r, null); 14450 s = toStringO(r); 14451 ck_assert_str_eq(s, "[1,[1],3,[2]]"); 14452 free(s); 14453 // empty smallArray 14454 value = allocSmallArray(); 14455 r = self->f->setPAtNFreeArray(self, -1, value); 14456 ck_assert_ptr_eq(r, null); 14457 terminateO(value); 14458 // non smallArray object 14459 value = (smallArrayt*) allocSmallInt(2); 14460 r = self->f->setPAtNFreeArray(self, 0, value); 14461 ck_assert_ptr_eq(r, null); 14462 terminateO(value); 14463 // index outside 14464 value = allocSmallArray(); 14465 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, 20, value), NULL); 14466 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, -8, value), NULL); 14467 // empty list 14468 emptyO(self); 14469 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, 0, value), NULL); 14470 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, -1, value), NULL); 14471 terminateO(value); 14472 // NULL value 14473 ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, 0, NULL), NULL); 14474 terminateO(self); 14475 14476 } 14477 14478 14479 void setPAtNFreeSmallJsonSmallArrayT(CuTest *tc UNUSED) { 14480 14481 smallArrayt* r; 14482 smallArrayt *self = allocG(rtSmallArrayt); 14483 smallJsont *value; 14484 14485 // add elements to self 14486 r = self->f->pushInt(self, 1); 14487 ck_assert_ptr_ne(r, null); 14488 r = self->f->pushInt(self, 2); 14489 ck_assert_ptr_ne(r, null); 14490 r = self->f->pushInt(self, 3); 14491 ck_assert_ptr_ne(r, null); 14492 r = self->f->pushInt(self, 4); 14493 ck_assert_ptr_ne(r, null); 14494 14495 // positive index 14496 value = allocSmallJson(); 14497 r = self->f->setAtSmallJson(self, 1, value); 14498 ck_assert_ptr_ne(r, null); 14499 value->f->setInt(value, "a", 1); 14500 r = self->f->setPAtNFreeSmallJson(self, 1, value); 14501 ck_assert_ptr_ne(r, null); 14502 char *s = toStringO(r); 14503 ck_assert_str_eq(s, "[1,{\"a\":1},3,4]"); 14504 free(s); 14505 // negative index 14506 value = allocSmallJson(); 14507 r = self->f->setAtSmallJson(self, -1, value); 14508 ck_assert_ptr_ne(r, null); 14509 value->f->setInt(value, "a", 2); 14510 r = self->f->setPAtNFreeSmallJson(self, -1, value); 14511 ck_assert_ptr_ne(r, null); 14512 s = toStringO(r); 14513 ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]"); 14514 free(s); 14515 // empty smallJson 14516 value = allocSmallJson(); 14517 r = self->f->setPAtNFreeSmallJson(self, -1, value); 14518 ck_assert_ptr_eq(r, null); 14519 terminateO(value); 14520 // non smallJson object 14521 value = (smallJsont*) allocSmallInt(2); 14522 r = self->f->setPAtNFreeSmallJson(self, 0, value); 14523 ck_assert_ptr_eq(r, null); 14524 terminateO(value); 14525 // index outside 14526 value = allocSmallJson(); 14527 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, 20, value), NULL); 14528 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, -8, value), NULL); 14529 // empty list 14530 emptyO(self); 14531 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, 0, value), NULL); 14532 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, -1, value), NULL); 14533 terminateO(value); 14534 // NULL value 14535 ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, 0, NULL), NULL); 14536 terminateO(self); 14537 14538 } 14539 14540 14541 void setPAtNFreeSmallStringSmallArrayT(CuTest *tc UNUSED) { 14542 14543 smallArrayt* r; 14544 smallArrayt *self = allocG(rtSmallArrayt); 14545 smallStringt *value; 14546 14547 // add elements to self 14548 r = self->f->pushInt(self, 1); 14549 ck_assert_ptr_ne(r, null); 14550 r = self->f->pushInt(self, 2); 14551 ck_assert_ptr_ne(r, null); 14552 r = self->f->pushInt(self, 3); 14553 ck_assert_ptr_ne(r, null); 14554 r = self->f->pushInt(self, 4); 14555 ck_assert_ptr_ne(r, null); 14556 14557 // positive index 14558 initiateAllocateSmallString(&value); 14559 r = self->f->setAtSmallString(self, 1, value); 14560 ck_assert_ptr_ne(r, null); 14561 value->f->appendS(value, "1"); 14562 r = self->f->setPAtNFreeSmallString(self, 1, value); 14563 ck_assert_ptr_ne(r, null); 14564 char *s = toStringO(r); 14565 ck_assert_str_eq(s, "[1,\"1\",3,4]"); 14566 free(s); 14567 // negative index 14568 value = allocSmallString("a"); 14569 r = self->f->setAtSmallString(self, -1, value); 14570 ck_assert_ptr_ne(r, null); 14571 value->f->appendS(value, "2"); 14572 r = self->f->setPAtNFreeSmallString(self, -1, value); 14573 ck_assert_ptr_ne(r, null); 14574 s = toStringO(r); 14575 ck_assert_str_eq(s, "[1,\"1\",3,\"a2\"]"); 14576 free(s); 14577 // empty SmallString 14578 value = allocSmallString(""); 14579 freeO(value); 14580 r = self->f->setPAtNFreeSmallString(self, -1, value); 14581 ck_assert_ptr_eq(r, null); 14582 terminateO(value); 14583 // non smallString object 14584 value = (smallStringt*) allocSmallInt(2); 14585 r = self->f->setPAtNFreeSmallString(self, 0, value); 14586 ck_assert_ptr_eq(r, null); 14587 terminateO(value); 14588 // index outside 14589 value = allocSmallString("asd"); 14590 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, 20, value), NULL); 14591 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, -8, value), NULL); 14592 // empty list 14593 emptyO(self); 14594 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, 0, value), NULL); 14595 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, -1, value), NULL); 14596 terminateO(value); 14597 // NULL value 14598 ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, 0, NULL), NULL); 14599 terminateO(self); 14600 14601 } 14602 14603 14604 void getNumSmallArrayT(CuTest *tc UNUSED) { 14605 14606 double r; 14607 smallArrayt *self = allocG(rtSmallArrayt); 14608 smallArrayt *r2; 14609 14610 // add elements to self 14611 r2 = self->f->pushInt(self, 1); 14612 ck_assert_ptr_ne(r2, null); 14613 r2 = self->f->pushDouble(self, 2); 14614 ck_assert_ptr_ne(r2, null); 14615 r2 = self->f->pushInt(self, 3); 14616 ck_assert_ptr_ne(r2, null); 14617 r2 = self->f->pushInt(self, 4); 14618 ck_assert_ptr_ne(r2, null); 14619 14620 // positive index 14621 r = self->f->getNum(self,1); 14622 ck_assert(r==2); 14623 char *s = toStringO(self); 14624 ck_assert_str_eq(s, "[1,2.000000e+00,3,4]"); 14625 free(s); 14626 // negative index 14627 r = self->f->getNum(self,-1); 14628 ck_assert(r==4); 14629 s = toStringO(self); 14630 ck_assert_str_eq(s, "[1,2.000000e+00,3,4]"); 14631 free(s); 14632 // wrong object type of another user class 14633 // User classes are stored in containers transparently 14634 createAllocateSmallInt(ip); 14635 ip->type = "anothertype"; 14636 setValG(ip, 11); 14637 r2 = self->f->push(self, (baset*)ip); 14638 ck_assert_ptr_ne(r2, null); 14639 r = self->f->getNum(self,-1); 14640 ck_assert(!r); 14641 s = toStringO(self); 14642 ck_assert_str_eq(s, "[1,2.000000e+00,3,4,\"<data container>\"]"); 14643 free(s); 14644 // index outside 14645 ck_assert(!self->f->getNum(self, 20)); 14646 ck_assert(!self->f->getNum(self, -7)); 14647 // empty list 14648 emptyO(self); 14649 ck_assert(!self->f->getNum(self, 0)); 14650 ck_assert(!self->f->getNum(self, -1)); 14651 terminateO(self); 14652 14653 } 14654 14655 14656 void hasSmallArrayT(CuTest *tc UNUSED) { 14657 14658 bool r; 14659 smallArrayt *self = allocG(rtSmallArrayt); 14660 baset *value = (baset*)allocSmallInt(1); 14661 14662 // has 14663 self->f->pushInt(self, 1); 14664 r = hasO(self, value); 14665 ck_assert(r); 14666 // not has 14667 emptyO(self); 14668 r = hasO(self, value); 14669 ck_assert(!r); 14670 // NULL value 14671 r = hasO(self, NULL); 14672 ck_assert(!r); 14673 terminateO(self); 14674 terminateO(value); 14675 14676 } 14677 14678 14679 void hasUndefinedSmallArrayT(CuTest *tc UNUSED) { 14680 14681 bool r; 14682 smallArrayt *self = allocG(rtSmallArrayt); 14683 undefinedt *value = allocUndefined(); 14684 14685 // has 14686 self->f->pushUndefined(self); 14687 r = hasUndefinedO(self, value); 14688 ck_assert(r); 14689 // not has 14690 emptyO(self); 14691 r = hasUndefinedO(self, value); 14692 ck_assert(!r); 14693 // non undefined object 14694 terminateO(value); 14695 value = (undefinedt*) allocSmallInt(2); 14696 r = hasUndefinedO(self, value); 14697 ck_assert(!r); 14698 // NULL value 14699 r = hasUndefinedO(self, NULL); 14700 ck_assert(!r); 14701 terminateO(self); 14702 terminateO(value); 14703 14704 } 14705 14706 14707 void hasBoolSmallArrayT(CuTest *tc UNUSED) { 14708 14709 bool r; 14710 smallArrayt *self = allocG(rtSmallArrayt); 14711 bool value = true; 14712 14713 // has 14714 self->f->pushBool(self, true); 14715 r = hasBoolO(self, value); 14716 ck_assert(r); 14717 // not has 14718 emptyO(self); 14719 r = hasBoolO(self, value); 14720 ck_assert(!r); 14721 terminateO(self); 14722 14723 } 14724 14725 14726 void hasDoubleSmallArrayT(CuTest *tc UNUSED) { 14727 14728 bool r; 14729 smallArrayt *self = allocG(rtSmallArrayt); 14730 double value = 2; 14731 14732 // has 14733 self->f->pushDouble(self, 2); 14734 r = hasDoubleO(self, value); 14735 ck_assert(r); 14736 // not has 14737 emptyO(self); 14738 r = hasDoubleO(self, value); 14739 ck_assert(!r); 14740 terminateO(self); 14741 14742 } 14743 14744 14745 void hasIntSmallArrayT(CuTest *tc UNUSED) { 14746 14747 bool r; 14748 smallArrayt *self = allocG(rtSmallArrayt); 14749 int64_t value = 1000; 14750 14751 // has 14752 self->f->pushInt(self, 1000); 14753 r = hasIntO(self, value); 14754 ck_assert(r); 14755 // not has 14756 emptyO(self); 14757 r = hasIntO(self, value); 14758 ck_assert(!r); 14759 terminateO(self); 14760 14761 } 14762 14763 14764 void hasSSmallArrayT(CuTest *tc UNUSED) { 14765 14766 bool r; 14767 smallArrayt *self = allocG(rtSmallArrayt); 14768 const char *value = "asd"; 14769 14770 // has 14771 self->f->pushS(self, "asd"); 14772 r = hasSO(self, value); 14773 ck_assert(r); 14774 // not has 14775 emptyO(self); 14776 r = hasSO(self, value); 14777 ck_assert(!r); 14778 // NULL value 14779 r = hasSO(self, NULL); 14780 ck_assert(!r); 14781 terminateO(self); 14782 14783 } 14784 14785 14786 void hasCharSmallArrayT(CuTest *tc UNUSED) { 14787 14788 bool r; 14789 smallArrayt *self = allocG(rtSmallArrayt); 14790 char value = 'a'; 14791 14792 // has 14793 self->f->pushS(self, "a"); 14794 r = hasCharO(self, value); 14795 ck_assert(r); 14796 // not has 14797 emptyO(self); 14798 r = hasCharO(self, value); 14799 ck_assert(!r); 14800 terminateO(self); 14801 14802 } 14803 14804 14805 void hasDictSmallArrayT(CuTest *tc UNUSED) { 14806 14807 bool r; 14808 smallArrayt *self = allocG(rtSmallArrayt); 14809 smallDictt *value = allocSmallDict(); 14810 14811 // has 14812 self->f->pushNFreeDict(self, allocSmallDict()); 14813 r = hasDictO(self, value); 14814 ck_assert(r); 14815 // not has 14816 emptyO(self); 14817 r = hasDictO(self, value); 14818 ck_assert(!r); 14819 // non smallDict object 14820 terminateO(value); 14821 value = (smallDictt*) allocSmallInt(2); 14822 r = hasDictO(self, value); 14823 ck_assert(!r); 14824 // NULL value 14825 r = hasDictO(self, NULL); 14826 ck_assert(!r); 14827 terminateO(self); 14828 terminateO(value); 14829 14830 } 14831 14832 14833 void hasArraySmallArrayT(CuTest *tc UNUSED) { 14834 14835 bool r; 14836 smallArrayt *self = allocG(rtSmallArrayt); 14837 smallArrayt *value = allocSmallArray(); 14838 14839 // has 14840 self->f->pushNFreeArray(self, allocSmallArray()); 14841 r = hasArrayO(self, value); 14842 ck_assert(r); 14843 // not has 14844 emptyO(self); 14845 r = hasArrayO(self, value); 14846 ck_assert(!r); 14847 // non smallArray object 14848 terminateO(value); 14849 value = (smallArrayt*) allocSmallInt(2); 14850 r = hasArrayO(self, value); 14851 ck_assert(!r); 14852 // NULL value 14853 r = hasArrayO(self, NULL); 14854 ck_assert(!r); 14855 terminateO(self); 14856 terminateO(value); 14857 14858 } 14859 14860 14861 void hasArraycSmallArrayT(CuTest *tc UNUSED) { 14862 14863 bool r; 14864 smallArrayt *self = allocG(rtSmallArrayt); 14865 char **value = listCreateS("a","bb"); 14866 14867 // has 14868 self->f->pushNFreeArrayc(self, listCreateS("a","bb")); 14869 r = hasArraycO(self, value); 14870 ck_assert(r); 14871 // not has 14872 emptyO(self); 14873 r = hasArraycO(self, value); 14874 ck_assert(!r); 14875 // NULL value 14876 r = hasArraycO(self, NULL); 14877 ck_assert(!r); 14878 terminateO(self); 14879 listFreeS(value); 14880 14881 } 14882 14883 14884 void hasSmallBoolSmallArrayT(CuTest *tc UNUSED) { 14885 14886 bool r; 14887 smallArrayt *self = allocG(rtSmallArrayt); 14888 smallBoolt *value = allocSmallBool(true); 14889 14890 // has 14891 self->f->pushBool(self, true); 14892 r = hasSmallBoolO(self, value); 14893 ck_assert(r); 14894 // not has 14895 emptyO(self); 14896 r = hasSmallBoolO(self, value); 14897 ck_assert(!r); 14898 // non smallBool object 14899 terminateO(value); 14900 value = (smallBoolt*) allocSmallInt(2); 14901 r = hasSmallBoolO(self, value); 14902 ck_assert(!r); 14903 // NULL value 14904 r = hasSmallBoolO(self, NULL); 14905 ck_assert(!r); 14906 terminateO(self); 14907 terminateO(value); 14908 14909 } 14910 14911 14912 void hasSmallBytesSmallArrayT(CuTest *tc UNUSED) { 14913 14914 bool r; 14915 smallArrayt *self = allocG(rtSmallArrayt); 14916 createAllocateSmallBytes(value); 14917 pushBufferO(value, &self, 8); 14918 14919 // has 14920 createAllocateSmallBytes(elem); 14921 pushBufferO(elem, &self, 8); 14922 self->f->pushNFreeSmallBytes(self, elem); 14923 r = hasSmallBytesO(self, value); 14924 ck_assert(r); 14925 // not has 14926 emptyO(self); 14927 r = hasSmallBytesO(self, value); 14928 ck_assert(!r); 14929 // non smallBytes object 14930 terminateO(value); 14931 value = (smallBytest*) allocSmallInt(2); 14932 r = hasSmallBytesO(self, value); 14933 ck_assert(!r); 14934 // NULL value 14935 r = hasSmallBytesO(self, NULL); 14936 ck_assert(!r); 14937 terminateO(self); 14938 terminateO(value); 14939 14940 } 14941 14942 14943 void hasSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 14944 14945 bool r; 14946 smallArrayt *self = allocG(rtSmallArrayt); 14947 smallDoublet *value = allocSmallDouble(2); 14948 14949 // has 14950 self->f->pushDouble(self, 2); 14951 r = hasSmallDoubleO(self, value); 14952 ck_assert(r); 14953 // not has 14954 emptyO(self); 14955 r = hasSmallDoubleO(self, value); 14956 ck_assert(!r); 14957 // non smallDouble object 14958 terminateO(value); 14959 value = (smallDoublet*) allocSmallInt(2); 14960 r = hasSmallDoubleO(self, value); 14961 ck_assert(!r); 14962 // NULL value 14963 r = hasSmallDoubleO(self, NULL); 14964 ck_assert(!r); 14965 terminateO(self); 14966 terminateO(value); 14967 14968 } 14969 14970 14971 void hasSmallIntSmallArrayT(CuTest *tc UNUSED) { 14972 14973 bool r; 14974 smallArrayt *self = allocG(rtSmallArrayt); 14975 smallIntt *value = allocSmallInt(12); 14976 14977 // has 14978 self->f->pushInt(self, 12); 14979 r = hasSmallIntO(self, value); 14980 ck_assert(r); 14981 // not has 14982 emptyO(self); 14983 r = hasSmallIntO(self, value); 14984 ck_assert(!r); 14985 // non smallInt object 14986 terminateO(value); 14987 value = (smallIntt*) allocSmallBool(true); 14988 r = hasSmallIntO(self, value); 14989 ck_assert(!r); 14990 // NULL value 14991 r = hasSmallIntO(self, NULL); 14992 ck_assert(!r); 14993 terminateO(self); 14994 terminateO(value); 14995 14996 } 14997 14998 14999 void hasSmallJsonSmallArrayT(CuTest *tc UNUSED) { 15000 15001 bool r; 15002 smallArrayt *self = allocG(rtSmallArrayt); 15003 smallJsont *value = allocSmallJson(); 15004 value->f->pushInt(value, 1); 15005 15006 // has 15007 createAllocateSmallJson(elem); 15008 elem->f->pushInt(elem, 1); 15009 self->f->pushNFreeSmallJson(self, elem); 15010 r = self->f->hasSmallJson(self, value); 15011 ck_assert(r); 15012 // not has 15013 emptyO(self); 15014 r = self->f->hasSmallJson(self, value); 15015 ck_assert(!r); 15016 // non smallJson object 15017 terminateO(value); 15018 value = (smallJsont*) allocSmallInt(2); 15019 r = self->f->hasSmallJson(self, value); 15020 ck_assert(!r); 15021 // NULL value 15022 r = self->f->hasSmallJson(self, NULL); 15023 ck_assert(!r); 15024 terminateO(self); 15025 terminateO(value); 15026 15027 } 15028 15029 15030 void hasSmallStringSmallArrayT(CuTest *tc UNUSED) { 15031 15032 bool r; 15033 smallArrayt *self = allocG(rtSmallArrayt); 15034 smallStringt *value = allocSmallString("qwe"); 15035 15036 // has 15037 self->f->pushS(self, "qwe"); 15038 r = self->f->hasSmallString(self, value); 15039 ck_assert(r); 15040 // not has 15041 emptyO(self); 15042 r = self->f->hasSmallString(self, value); 15043 ck_assert(!r); 15044 // non smallString object 15045 terminateO(value); 15046 value = (smallStringt*) allocSmallInt(2); 15047 r = self->f->hasSmallString(self, value); 15048 ck_assert(!r); 15049 // NULL value 15050 r = self->f->hasSmallString(self, NULL); 15051 ck_assert(!r); 15052 terminateO(self); 15053 terminateO(value); 15054 15055 } 15056 15057 15058 void hasSmallContainerSmallArrayT(CuTest *tc UNUSED) { 15059 15060 bool r; 15061 smallArrayt *self = allocG(rtSmallArrayt); 15062 createAllocateSmallContainer(value); 15063 15064 // has 15065 createAllocateSmallContainer(elem); 15066 self->f->pushNFreeSmallContainer(self, elem); 15067 r = hasSmallContainerO(self, value); 15068 ck_assert(!r); 15069 // not has 15070 emptyO(self); 15071 r = hasSmallContainerO(self, value); 15072 ck_assert(!r); 15073 // non smallContainer object 15074 terminateO(value); 15075 value = (smallContainert*) allocSmallInt(2); 15076 r = self->f->hasSmallContainer(self, value); 15077 ck_assert(!r); 15078 // NULL value 15079 r = hasSmallContainerO(self, NULL); 15080 ck_assert(!r); 15081 terminateO(self); 15082 terminateO(value); 15083 15084 } 15085 15086 15087 void indexOfSmallArrayT(CuTest *tc UNUSED) { 15088 15089 ssize_t r; 15090 smallArrayt *self = allocG(rtSmallArrayt); 15091 baset *value = (baset*)allocSmallInt(1); 15092 15093 // index 15094 self->f->pushInt(self, 2); 15095 self->f->pushInt(self, 0); 15096 delElemO(self, 1); 15097 self->f->pushInt(self, 1); 15098 r = indexOfO(self, value); 15099 ck_assert_int_eq(r, 2); 15100 // not index 15101 smallIntt *v = (smallIntt*) value; 15102 setValO(v, 0); 15103 r = indexOfO(self, value); 15104 ck_assert_int_eq(r, -1); 15105 // NULL value 15106 r = indexOfO(self, NULL); 15107 ck_assert_int_eq(r, -1); 15108 terminateO(self); 15109 terminateO(value); 15110 15111 } 15112 15113 15114 void indexOfUndefinedSmallArrayT(CuTest *tc UNUSED) { 15115 15116 ssize_t r; 15117 smallArrayt *self = allocG(rtSmallArrayt); 15118 undefinedt *value = allocUndefined(); 15119 15120 // indexOf 15121 self->f->pushInt(self, 1); 15122 self->f->pushUndefined(self); 15123 delElemO(self, 1); 15124 self->f->pushUndefined(self); 15125 r = indexOfUndefinedO(self, value); 15126 ck_assert_int_eq(r, 2); 15127 // not indexOf 15128 delElemO(self, 2); 15129 r = indexOfUndefinedO(self, value); 15130 ck_assert_int_eq(r, -1); 15131 // non undefined object 15132 terminateO(value); 15133 value = (undefinedt*) allocSmallInt(2); 15134 r = indexOfUndefinedO(self, value); 15135 ck_assert_int_eq(r, -1); 15136 // NULL value 15137 r = indexOfUndefinedO(self, NULL); 15138 ck_assert_int_eq(r, -1); 15139 terminateO(self); 15140 terminateO(value); 15141 15142 } 15143 15144 15145 void indexOfBoolSmallArrayT(CuTest *tc UNUSED) { 15146 15147 ssize_t r; 15148 smallArrayt *self = allocG(rtSmallArrayt); 15149 bool value = true; 15150 15151 // indexOf 15152 self->f->pushInt(self, 1); 15153 self->f->pushUndefined(self); 15154 delElemO(self, 1); 15155 self->f->pushBool(self, true); 15156 r = indexOfBoolO(self, value); 15157 ck_assert_int_eq(r, 2); 15158 // not indexOf 15159 delElemO(self, 2); 15160 r = indexOfBoolO(self, value); 15161 ck_assert_int_eq(r, -1); 15162 terminateO(self); 15163 15164 } 15165 15166 15167 void indexOfDoubleSmallArrayT(CuTest *tc UNUSED) { 15168 15169 ssize_t r; 15170 smallArrayt *self = allocG(rtSmallArrayt); 15171 double value = 2; 15172 15173 // indexOf 15174 self->f->pushInt(self, 1); 15175 self->f->pushUndefined(self); 15176 delElemO(self, 1); 15177 self->f->pushDouble(self, 2); 15178 r = indexOfDoubleO(self, value); 15179 ck_assert_int_eq(r, 2); 15180 // not indexOf 15181 delElemO(self, 2); 15182 r = indexOfDoubleO(self, value); 15183 ck_assert_int_eq(r, -1); 15184 terminateO(self); 15185 15186 } 15187 15188 15189 void indexOfIntSmallArrayT(CuTest *tc UNUSED) { 15190 15191 ssize_t r; 15192 smallArrayt *self = allocG(rtSmallArrayt); 15193 int64_t value = 1000; 15194 15195 // indexOf 15196 self->f->pushUndefined(self); 15197 self->f->pushUndefined(self); 15198 delElemO(self, 1); 15199 self->f->pushInt(self, 1000); 15200 r = indexOfIntO(self, value); 15201 ck_assert_int_eq(r, 2); 15202 // not indexOf 15203 delElemO(self, 2); 15204 r = indexOfIntO(self, value); 15205 ck_assert_int_eq(r, -1); 15206 terminateO(self); 15207 15208 } 15209 15210 15211 void indexOfSSmallArrayT(CuTest *tc UNUSED) { 15212 15213 ssize_t r; 15214 smallArrayt *self = allocG(rtSmallArrayt); 15215 const char *value = "asd"; 15216 15217 // indexOf 15218 self->f->pushUndefined(self); 15219 self->f->pushUndefined(self); 15220 delElemO(self, 1); 15221 self->f->pushS(self, "asd"); 15222 r = indexOfSO(self, value); 15223 ck_assert_int_eq(r, 2); 15224 // not indexOf 15225 delElemO(self, 2); 15226 r = indexOfSO(self, value); 15227 ck_assert_int_eq(r, -1); 15228 // NULL value 15229 r = indexOfSO(self, NULL); 15230 ck_assert_int_eq(r, -1); 15231 terminateO(self); 15232 15233 } 15234 15235 15236 void indexOfCharSmallArrayT(CuTest *tc UNUSED) { 15237 15238 ssize_t r; 15239 smallArrayt *self = allocG(rtSmallArrayt); 15240 char value = 'a'; 15241 15242 // indexOf 15243 self->f->pushUndefined(self); 15244 self->f->pushUndefined(self); 15245 delElemO(self, 1); 15246 self->f->pushS(self, "a"); 15247 r = indexOfCharO(self, value); 15248 ck_assert_int_eq(r, 2); 15249 // not indexOf 15250 delElemO(self, 2); 15251 r = indexOfCharO(self, value); 15252 ck_assert_int_eq(r, -1); 15253 terminateO(self); 15254 15255 } 15256 15257 15258 void indexOfDictSmallArrayT(CuTest *tc UNUSED) { 15259 15260 ssize_t r; 15261 smallArrayt *self = allocG(rtSmallArrayt); 15262 smallDictt *value = allocSmallDict(); 15263 15264 // indexOf 15265 createAllocateSmallDict(elem); 15266 elem->f->setInt(elem, "a", 1); 15267 self->f->pushNFreeDict(self, elem); 15268 self->f->pushUndefined(self); 15269 delElemO(self, 1); 15270 self->f->pushNFreeDict(self, allocSmallDict()); 15271 r = indexOfDictO(self, value); 15272 ck_assert_int_eq(r, 2); 15273 // not indexOf 15274 delElemO(self, 2); 15275 r = indexOfDictO(self, value); 15276 ck_assert_int_eq(r, -1); 15277 // non smallDict object 15278 terminateO(value); 15279 value = (smallDictt*) allocSmallInt(2); 15280 r = indexOfDictO(self, value); 15281 ck_assert_int_eq(r, -1); 15282 // NULL value 15283 r = indexOfDictO(self, NULL); 15284 ck_assert_int_eq(r, -1); 15285 terminateO(self); 15286 terminateO(value); 15287 15288 } 15289 15290 15291 void indexOfArraySmallArrayT(CuTest *tc UNUSED) { 15292 15293 ssize_t r; 15294 smallArrayt *self = allocG(rtSmallArrayt); 15295 smallArrayt *value = allocSmallArray(); 15296 15297 // indexOf 15298 createAllocateSmallArray(elem); 15299 elem->f->pushInt(elem, 1); 15300 self->f->pushNFreeArray(self, elem); 15301 self->f->pushUndefined(self); 15302 delElemO(self, 1); 15303 self->f->pushNFreeArray(self, allocSmallArray()); 15304 r = indexOfArrayO(self, value); 15305 ck_assert_int_eq(r, 2); 15306 // non smallArray object 15307 terminateO(value); 15308 value = (smallArrayt*) allocSmallInt(2); 15309 r = indexOfArrayO(self, value); 15310 ck_assert_int_eq(r, -1); 15311 // not indexOf 15312 emptyO(self); 15313 r = indexOfArrayO(self, value); 15314 ck_assert_int_eq(r, -1); 15315 // NULL value 15316 r = indexOfArrayO(self, NULL); 15317 ck_assert_int_eq(r, -1); 15318 terminateO(self); 15319 terminateO(value); 15320 15321 } 15322 15323 15324 void indexOfArraycSmallArrayT(CuTest *tc UNUSED) { 15325 15326 ssize_t r; 15327 smallArrayt *self = allocG(rtSmallArrayt); 15328 char **value = listCreateS("a","bb"); 15329 15330 // indexOf 15331 char **elem = listCreateS("!!","@@@"); 15332 self->f->pushNFreeArrayc(self, elem); 15333 self->f->pushUndefined(self); 15334 delElemO(self, 1); 15335 self->f->pushNFreeArrayc(self, listCreateS("a","bb")); 15336 r = indexOfArraycO(self, value); 15337 ck_assert_int_eq(r, 2); 15338 // not indexOf 15339 delElemO(self, 2); 15340 r = indexOfArraycO(self, value); 15341 ck_assert_int_eq(r, -1); 15342 // NULL value 15343 r = indexOfArraycO(self, NULL); 15344 ck_assert_int_eq(r, -1); 15345 terminateO(self); 15346 listFreeS(value); 15347 15348 } 15349 15350 15351 void indexOfSmallBoolSmallArrayT(CuTest *tc UNUSED) { 15352 15353 ssize_t r; 15354 smallArrayt *self = allocG(rtSmallArrayt); 15355 smallBoolt *value = allocSmallBool(true); 15356 15357 // indexOf 15358 self->f->pushUndefined(self); 15359 self->f->pushUndefined(self); 15360 delElemO(self, 1); 15361 self->f->pushBool(self, true); 15362 r = indexOfSmallBoolO(self, value); 15363 ck_assert_int_eq(r, 2); 15364 // not indexOf 15365 delElemO(self, 2); 15366 r = indexOfSmallBoolO(self, value); 15367 ck_assert_int_eq(r, -1); 15368 // non smallBool object 15369 terminateO(value); 15370 value = (smallBoolt*) allocSmallInt(2); 15371 r = indexOfSmallBoolO(self, value); 15372 ck_assert_int_eq(r, -1); 15373 // NULL value 15374 r = indexOfSmallBoolO(self, NULL); 15375 ck_assert_int_eq(r, -1); 15376 terminateO(self); 15377 terminateO(value); 15378 15379 } 15380 15381 15382 void indexOfSmallBytesSmallArrayT(CuTest *tc UNUSED) { 15383 15384 ssize_t r; 15385 smallArrayt *self = allocG(rtSmallArrayt); 15386 createAllocateSmallBytes(value); 15387 pushBufferO(value, &self, 8); 15388 15389 // indexOf 15390 self->f->pushUndefined(self); 15391 self->f->pushUndefined(self); 15392 delElemO(self, 1); 15393 createAllocateSmallBytes(elem); 15394 pushBufferO(elem, &self, 8); 15395 self->f->pushNFreeSmallBytes(self, elem); 15396 r = indexOfSmallBytesO(self, value); 15397 ck_assert_int_eq(r, 2); 15398 // not indexOf 15399 delElemO(self, 2); 15400 r = indexOfSmallBytesO(self, value); 15401 ck_assert_int_eq(r, -1); 15402 // non smallBytes object 15403 terminateO(value); 15404 value = (smallBytest*) allocSmallInt(2); 15405 r = indexOfSmallBytesO(self, value); 15406 ck_assert_int_eq(r, -1); 15407 // NULL value 15408 r = indexOfSmallBytesO(self, NULL); 15409 ck_assert_int_eq(r, -1); 15410 terminateO(self); 15411 terminateO(value); 15412 15413 } 15414 15415 15416 void indexOfSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 15417 15418 ssize_t r; 15419 smallArrayt *self = allocG(rtSmallArrayt); 15420 smallDoublet *value = allocSmallDouble(2); 15421 15422 // indexOf 15423 self->f->pushUndefined(self); 15424 self->f->pushUndefined(self); 15425 delElemO(self, 1); 15426 self->f->pushDouble(self, 2); 15427 r = indexOfSmallDoubleO(self, value); 15428 ck_assert_int_eq(r, 2); 15429 // not indexOf 15430 delElemO(self, 2); 15431 r = indexOfSmallDoubleO(self, value); 15432 ck_assert_int_eq(r, -1); 15433 // non smallDouble object 15434 terminateO(value); 15435 value = (smallDoublet*) allocSmallInt(2); 15436 r = indexOfSmallDoubleO(self, value); 15437 ck_assert_int_eq(r, -1); 15438 // NULL value 15439 r = indexOfSmallDoubleO(self, NULL); 15440 ck_assert_int_eq(r, -1); 15441 terminateO(self); 15442 terminateO(value); 15443 15444 } 15445 15446 15447 void indexOfSmallIntSmallArrayT(CuTest *tc UNUSED) { 15448 15449 ssize_t r; 15450 smallArrayt *self = allocG(rtSmallArrayt); 15451 smallIntt *value = allocSmallInt(12); 15452 15453 // indexOf 15454 self->f->pushUndefined(self); 15455 self->f->pushUndefined(self); 15456 delElemO(self, 1); 15457 self->f->pushInt(self, 12); 15458 r = indexOfSmallIntO(self, value); 15459 ck_assert_int_eq(r, 2); 15460 // not indexOf 15461 delElemO(self, 2); 15462 r = indexOfSmallIntO(self, value); 15463 ck_assert_int_eq(r, -1); 15464 // non smallInt object 15465 terminateO(value); 15466 value = (smallIntt*) allocSmallBool(true); 15467 r = indexOfSmallIntO(self, value); 15468 ck_assert_int_eq(r, -1); 15469 // NULL value 15470 r = indexOfSmallIntO(self, NULL); 15471 ck_assert_int_eq(r, -1); 15472 terminateO(self); 15473 terminateO(value); 15474 15475 } 15476 15477 15478 void indexOfSmallJsonSmallArrayT(CuTest *tc UNUSED) { 15479 15480 ssize_t r; 15481 smallArrayt *self = allocG(rtSmallArrayt); 15482 smallJsont *value = allocSmallJson(); 15483 15484 // indexOf json undefined 15485 createUndefined(u); 15486 setTopO(value, (baset*)&u); 15487 self->f->pushUndefined(self); 15488 r = self->f->indexOfSmallJson(self, value); 15489 ck_assert_int_eq(r, 0); 15490 freeO(value); 15491 // indexOf json bool 15492 smallBoolt *b = allocSmallBool(true); 15493 setTopNFreeSmallBoolO(value, b); 15494 self->f->pushBool(self, true); 15495 r = self->f->indexOfSmallJson(self, value); 15496 ck_assert_int_eq(r, 1); 15497 freeO(value); 15498 // indexOf json double 15499 smallDoublet *d = allocSmallDouble(1); 15500 setTopNFreeSmallDoubleO(value, d); 15501 self->f->pushDouble(self, 1); 15502 r = self->f->indexOfSmallJson(self, value); 15503 ck_assert_int_eq(r, 2); 15504 freeO(value); 15505 // indexOf json int 15506 smallIntt *i = allocSmallInt(1); 15507 setTopNFreeSmallIntO(value, i); 15508 self->f->pushInt(self, 1); 15509 r = self->f->indexOfSmallJson(self, value); 15510 ck_assert_int_eq(r, 3); 15511 freeO(value); 15512 // indexOf json string 15513 smallStringt *s = allocSmallString("asd"); 15514 setTopNFreeSmallStringO(value, s); 15515 self->f->pushS(self, "asd"); 15516 r = self->f->indexOfSmallJson(self, value); 15517 ck_assert_int_eq(r, 4); 15518 freeO(value); 15519 // indexOf json dict 15520 smallDictt *D = allocSmallDict(); 15521 setTopNFreeDictO(value, D); 15522 self->f->pushNFreeDict(self, allocSmallDict()); 15523 r = self->f->indexOfSmallJson(self, value); 15524 ck_assert_int_eq(r, 5); 15525 freeO(value); 15526 // indexOf json array 15527 value->f->pushInt(value, 1); 15528 delElemO(self, 1); 15529 createAllocateSmallJson(elem); 15530 elem->f->pushInt(elem, 1); 15531 self->f->pushNFreeSmallJson(self, elem); 15532 r = self->f->indexOfSmallJson(self, value); 15533 ck_assert_int_eq(r, 6); 15534 // not indexOf 15535 delElemO(self, 6); 15536 r = self->f->indexOfSmallJson(self, value); 15537 ck_assert_int_eq(r, -1); 15538 // empty json object 15539 freeO(value); 15540 r = self->f->indexOfSmallJson(self, value); 15541 ck_assert_int_eq(r, -1); 15542 // non smallJson object 15543 terminateO(value); 15544 value = (smallJsont*) allocSmallInt(2); 15545 r = self->f->indexOfSmallJson(self, value); 15546 ck_assert_int_eq(r, -1); 15547 // NULL value 15548 r = self->f->indexOfSmallJson(self, NULL); 15549 ck_assert_int_eq(r, -1); 15550 terminateO(self); 15551 terminateO(value); 15552 15553 } 15554 15555 15556 void indexOfSmallStringSmallArrayT(CuTest *tc UNUSED) { 15557 15558 ssize_t r; 15559 smallArrayt *self = allocG(rtSmallArrayt); 15560 smallStringt *value = allocSmallString("qwe"); 15561 15562 // indexOf 15563 self->f->pushUndefined(self); 15564 self->f->pushUndefined(self); 15565 delElemO(self, 1); 15566 self->f->pushS(self, "qwe"); 15567 r = self->f->indexOfSmallString(self, value); 15568 ck_assert_int_eq(r, 2); 15569 // not indexOf 15570 delElemO(self, 2); 15571 r = self->f->indexOfSmallString(self, value); 15572 ck_assert_int_eq(r, -1); 15573 // non smallString object 15574 terminateO(value); 15575 value = (smallStringt*) allocSmallInt(2); 15576 r = self->f->indexOfSmallString(self, value); 15577 ck_assert_int_eq(r, -1); 15578 // NULL value 15579 r = self->f->indexOfSmallString(self, NULL); 15580 ck_assert_int_eq(r, -1); 15581 terminateO(self); 15582 terminateO(value); 15583 15584 } 15585 15586 15587 void indexOfSmallContainerSmallArrayT(CuTest *tc UNUSED) { 15588 15589 ssize_t r; 15590 smallArrayt *self = allocG(rtSmallArrayt); 15591 createAllocateSmallContainer(value); 15592 15593 // indexOf 15594 self->f->pushUndefined(self); 15595 self->f->pushUndefined(self); 15596 delElemO(self, 1); 15597 createAllocateSmallContainer(elem); 15598 self->f->pushNFreeSmallContainer(self, elem); 15599 r = self->f->indexOfSmallContainer(self, value); 15600 ck_assert_int_eq(r, -1); 15601 // not indexOf 15602 delElemO(self, 2); 15603 r = self->f->indexOfSmallContainer(self, value); 15604 ck_assert_int_eq(r, -1); 15605 // non smallContainer object 15606 terminateO(value); 15607 value = (smallContainert*) allocSmallInt(2); 15608 r = self->f->indexOfSmallContainer(self, value); 15609 ck_assert_int_eq(r, -1); 15610 // NULL value 15611 r = self->f->indexOfSmallContainer(self, NULL); 15612 ck_assert_int_eq(r, -1); 15613 terminateO(self); 15614 terminateO(value); 15615 15616 } 15617 15618 15619 void binarySearchSmallArrayT(CuTest *tc UNUSED) { 15620 15621 ssize_t r; 15622 smallArrayt *self = allocG(rtSmallArrayt); 15623 baset *value = (baset*)allocSmallString("4"); 15624 15625 // index not trimmed (an element is NULL) 15626 self->f->pushS(self, "0"); 15627 self->f->pushS(self, "1"); 15628 self->f->pushS(self, "2"); 15629 delElemO(self, 2); 15630 self->f->pushS(self, "3"); 15631 self->f->pushS(self, "4"); 15632 self->f->pushS(self, "5"); 15633 r = binarySearchO(self, value); 15634 ck_assert_int_eq(r, -1); 15635 // index 15636 trimO(self); 15637 r = binarySearchO(self, value); 15638 ck_assert_int_eq(r, 3); 15639 smallStringt *v = (smallStringt*) value; 15640 // index in the lower half of the array 15641 setValO(v, "1"); 15642 r = binarySearchO(self, value); 15643 ck_assert_int_eq(r, 1); 15644 // not index 15645 setValO(v, "asd"); 15646 r = binarySearchO(self, value); 15647 ck_assert_int_eq(r, -1); 15648 // NULL value 15649 r = binarySearchO(self, NULL); 15650 ck_assert_int_eq(r, -1); 15651 // empty array 15652 emptyO(self); 15653 r = binarySearchO(self, value); 15654 ck_assert_int_eq(r, -1); 15655 terminateO(self); 15656 terminateO(value); 15657 15658 } 15659 15660 15661 void binarySearchUndefinedSmallArrayT(CuTest *tc UNUSED) { 15662 15663 ssize_t r; 15664 smallArrayt *self = allocG(rtSmallArrayt); 15665 undefinedt *undefined = (undefinedt*) 1234; 15666 15667 r = binarySearchUndefinedO(self, undefined); 15668 ck_assert_int_eq(r, -1); 15669 terminateO(self); 15670 15671 } 15672 15673 15674 void binarySearchBoolSmallArrayT(CuTest *tc UNUSED) { 15675 15676 ssize_t r; 15677 smallArrayt *self = allocG(rtSmallArrayt); 15678 bool value = true; 15679 15680 // index not trimmed (an element is NULL) 15681 self->f->pushUndefined(self); 15682 self->f->pushBool(self, false); 15683 self->f->pushUndefined(self); 15684 delElemO(self, 2); 15685 self->f->pushBool(self, true); 15686 self->f->pushS(self, "4"); 15687 self->f->pushS(self, "5"); 15688 r = binarySearchBoolO(self, value); 15689 ck_assert_int_eq(r, -1); 15690 // index 15691 trimO(self); 15692 r = binarySearchBoolO(self, value); 15693 ck_assert_int_eq(r, 2); 15694 // index in the lower half of the array 15695 value = false; 15696 r = binarySearchBoolO(self, value); 15697 ck_assert_int_eq(r, 1); 15698 // not index 15699 delElemO(self, 1); 15700 trimO(self); 15701 r = binarySearchBoolO(self, value); 15702 ck_assert_int_eq(r, -1); 15703 // empty array 15704 emptyO(self); 15705 r = binarySearchBoolO(self, value); 15706 ck_assert_int_eq(r, -1); 15707 terminateO(self); 15708 15709 } 15710 15711 15712 void binarySearchDoubleSmallArrayT(CuTest *tc UNUSED) { 15713 15714 ssize_t r; 15715 smallArrayt *self = allocG(rtSmallArrayt); 15716 double value = 2; 15717 15718 // index not trimmed (an element is NULL) 15719 self->f->pushUndefined(self); 15720 self->f->pushDouble(self, 1); 15721 self->f->pushUndefined(self); 15722 delElemO(self, 2); 15723 self->f->pushDouble(self, 2); 15724 self->f->pushS(self, "4"); 15725 self->f->pushS(self, "5"); 15726 r = binarySearchDoubleO(self, value); 15727 ck_assert_int_eq(r, -1); 15728 // index 15729 trimO(self); 15730 r = binarySearchDoubleO(self, value); 15731 ck_assert_int_eq(r, 2); 15732 // index in the lower half of the array 15733 value = 1; 15734 r = binarySearchDoubleO(self, value); 15735 ck_assert_int_eq(r, 1); 15736 // not index 15737 delElemO(self, 1); 15738 trimO(self); 15739 r = binarySearchDoubleO(self, value); 15740 ck_assert_int_eq(r, -1); 15741 // empty array 15742 emptyO(self); 15743 r = binarySearchDoubleO(self, value); 15744 ck_assert_int_eq(r, -1); 15745 terminateO(self); 15746 15747 } 15748 15749 15750 void binarySearchIntSmallArrayT(CuTest *tc UNUSED) { 15751 15752 ssize_t r; 15753 smallArrayt *self = allocG(rtSmallArrayt); 15754 int64_t value = 2; 15755 15756 // index not trimmed (an element is NULL) 15757 self->f->pushUndefined(self); 15758 self->f->pushInt(self, 1); 15759 self->f->pushUndefined(self); 15760 delElemO(self, 2); 15761 self->f->pushInt(self, 2); 15762 self->f->pushS(self, "4"); 15763 self->f->pushS(self, "5"); 15764 r = binarySearchIntO(self, value); 15765 ck_assert_int_eq(r, -1); 15766 // index 15767 trimO(self); 15768 r = binarySearchIntO(self, value); 15769 ck_assert_int_eq(r, 2); 15770 // index in the lower half of the array 15771 value = 1; 15772 r = binarySearchIntO(self, value); 15773 ck_assert_int_eq(r, 1); 15774 // not index 15775 delElemO(self, 1); 15776 trimO(self); 15777 r = binarySearchIntO(self, value); 15778 ck_assert_int_eq(r, -1); 15779 // empty array 15780 emptyO(self); 15781 r = binarySearchIntO(self, value); 15782 ck_assert_int_eq(r, -1); 15783 terminateO(self); 15784 15785 } 15786 15787 15788 void binarySearchSSmallArrayT(CuTest *tc UNUSED) { 15789 15790 ssize_t r; 15791 smallArrayt *self = allocG(rtSmallArrayt); 15792 const char *value = "4"; 15793 15794 // index not trimmed (an element is NULL) 15795 self->f->pushS(self, "0"); 15796 self->f->pushS(self, "1"); 15797 self->f->pushS(self, "2"); 15798 delElemO(self, 2); 15799 self->f->pushS(self, "3"); 15800 self->f->pushS(self, "4"); 15801 self->f->pushS(self, "5"); 15802 r = binarySearchSO(self, value); 15803 ck_assert_int_eq(r, -1); 15804 // index 15805 trimO(self); 15806 r = binarySearchSO(self, value); 15807 ck_assert_int_eq(r, 3); 15808 // index in the lower half of the array 15809 value = "1"; 15810 r = binarySearchSO(self, value); 15811 ck_assert_int_eq(r, 1); 15812 // not index 15813 value = "asd"; 15814 r = binarySearchSO(self, value); 15815 ck_assert_int_eq(r, -1); 15816 // NULL value 15817 r = binarySearchSO(self, NULL); 15818 ck_assert_int_eq(r, -1); 15819 // empty array 15820 emptyO(self); 15821 r = binarySearchSO(self, value); 15822 ck_assert_int_eq(r, -1); 15823 terminateO(self); 15824 15825 } 15826 15827 15828 void binarySearchCharSmallArrayT(CuTest *tc UNUSED) { 15829 15830 ssize_t r; 15831 smallArrayt *self = allocG(rtSmallArrayt); 15832 char value = '4'; 15833 15834 // index not trimmed (an element is NULL) 15835 self->f->pushS(self, "0"); 15836 self->f->pushS(self, "1"); 15837 self->f->pushS(self, "2"); 15838 delElemO(self, 2); 15839 self->f->pushS(self, "3"); 15840 self->f->pushS(self, "4"); 15841 self->f->pushS(self, "5"); 15842 r = binarySearchCharO(self, value); 15843 ck_assert_int_eq(r, -1); 15844 // index 15845 trimO(self); 15846 r = binarySearchCharO(self, value); 15847 ck_assert_int_eq(r, 3); 15848 // index in the lower half of the array 15849 value = '1'; 15850 r = binarySearchCharO(self, value); 15851 ck_assert_int_eq(r, 1); 15852 // not index 15853 value = 'a'; 15854 r = binarySearchCharO(self, value); 15855 ck_assert_int_eq(r, -1); 15856 // empty array 15857 emptyO(self); 15858 r = binarySearchCharO(self, value); 15859 ck_assert_int_eq(r, -1); 15860 terminateO(self); 15861 15862 } 15863 15864 15865 void binarySearchDictSmallArrayT(CuTest *tc UNUSED) { 15866 15867 ssize_t r; 15868 smallArrayt *self = allocG(rtSmallArrayt); 15869 smallDictt *value = allocSmallDict(); 15870 value->f->setInt(value, "b", 2); 15871 15872 // index not trimmed (an element is NULL) 15873 createAllocateSmallDict(elem); 15874 elem->f->setInt(elem, "a", 1); 15875 self->f->pushUndefined(self); 15876 self->f->pushDict(self, elem); 15877 resetO(elem); 15878 self->f->pushUndefined(self); 15879 delElemO(self, 2); 15880 elem->f->setInt(elem, "b", 2); 15881 self->f->pushNFreeDict(self, elem); 15882 self->f->pushS(self, "4"); 15883 self->f->pushS(self, "5"); 15884 r = binarySearchDictO(self, value); 15885 ck_assert_int_eq(r, -1); 15886 // index 15887 trimO(self); 15888 r = binarySearchDictO(self, value); 15889 ck_assert_int_eq(r, 2); 15890 // index in the lower half of the array 15891 freeO(value); 15892 value->f->setInt(value, "a", 1); 15893 r = binarySearchDictO(self, value); 15894 ck_assert_int_eq(r, 1); 15895 // not index 15896 freeO(value); 15897 r = binarySearchDictO(self, value); 15898 ck_assert_int_eq(r, -1); 15899 // non smallDict object 15900 terminateO(value); 15901 value = (smallDictt*) allocSmallInt(2); 15902 r = binarySearchDictO(self, value); 15903 ck_assert_int_eq(r, -1); 15904 // NULL value 15905 r = binarySearchDictO(self, NULL); 15906 ck_assert_int_eq(r, -1); 15907 // empty array 15908 emptyO(self); 15909 r = binarySearchDictO(self, value); 15910 ck_assert_int_eq(r, -1); 15911 terminateO(self); 15912 terminateO(value); 15913 15914 } 15915 15916 15917 void binarySearchArraySmallArrayT(CuTest *tc UNUSED) { 15918 15919 ssize_t r; 15920 smallArrayt *self = allocG(rtSmallArrayt); 15921 smallArrayt *value = allocSmallArray(); 15922 value->f->pushInt(value, 2); 15923 15924 // index not trimmed (an element is NULL) 15925 createAllocateSmallArray(elem); 15926 elem->f->pushInt(elem, 1); 15927 self->f->pushUndefined(self); 15928 self->f->pushArray(self, elem); 15929 resetO(elem); 15930 self->f->pushUndefined(self); 15931 delElemO(self, 2); 15932 elem->f->pushInt(elem, 2); 15933 self->f->pushNFreeArray(self, elem); 15934 self->f->pushS(self, "4"); 15935 self->f->pushS(self, "5"); 15936 r = binarySearchArrayO(self, value); 15937 ck_assert_int_eq(r, -1); 15938 // index 15939 trimO(self); 15940 r = binarySearchArrayO(self, value); 15941 ck_assert_int_eq(r, 2); 15942 // index in the lower half of the array 15943 freeO(value); 15944 value->f->pushInt(value, 1); 15945 r = binarySearchArrayO(self, value); 15946 ck_assert_int_eq(r, 1); 15947 // not index 15948 freeO(value); 15949 r = binarySearchArrayO(self, value); 15950 ck_assert_int_eq(r, -1); 15951 // non smallArray object 15952 terminateO(value); 15953 value = (smallArrayt*) allocSmallInt(2); 15954 r = binarySearchArrayO(self, value); 15955 ck_assert_int_eq(r, -1); 15956 // NULL value 15957 r = binarySearchArrayO(self, NULL); 15958 ck_assert_int_eq(r, -1); 15959 // empty array 15960 emptyO(self); 15961 r = binarySearchArrayO(self, value); 15962 ck_assert_int_eq(r, -1); 15963 terminateO(self); 15964 terminateO(value); 15965 15966 } 15967 15968 15969 void binarySearchArraycSmallArrayT(CuTest *tc UNUSED) { 15970 15971 ssize_t r; 15972 smallArrayt *self = allocG(rtSmallArrayt); 15973 char **value = listCreateS("b"); 15974 15975 // index not trimmed (an element is NULL) 15976 char **elem = listCreateS("a"); 15977 self->f->pushUndefined(self); 15978 self->f->pushNFreeArrayc(self, elem); 15979 self->f->pushUndefined(self); 15980 delElemO(self, 2); 15981 elem = listCreateS("b"); 15982 self->f->pushNFreeArrayc(self, elem); 15983 self->f->pushS(self, "4"); 15984 self->f->pushS(self, "5"); 15985 r = binarySearchArraycO(self, value); 15986 ck_assert_int_eq(r, -1); 15987 // index 15988 trimO(self); 15989 r = binarySearchArraycO(self, value); 15990 ck_assert_int_eq(r, 2); 15991 // index in the lower half of the array 15992 free(value[0]); 15993 value[0] = strdup("a"); 15994 r = binarySearchArraycO(self, value); 15995 ck_assert_int_eq(r, 1); 15996 // not index 15997 free(value[0]); 15998 value[0] = strdup("asd"); 15999 r = binarySearchArraycO(self, value); 16000 ck_assert_int_eq(r, -1); 16001 // NULL value 16002 r = binarySearchArraycO(self, NULL); 16003 ck_assert_int_eq(r, -1); 16004 // empty array 16005 emptyO(self); 16006 r = binarySearchArraycO(self, value); 16007 ck_assert_int_eq(r, -1); 16008 terminateO(self); 16009 listFreeS(value); 16010 16011 } 16012 16013 16014 void binarySearchSmallBoolSmallArrayT(CuTest *tc UNUSED) { 16015 16016 ssize_t r; 16017 smallArrayt *self = allocG(rtSmallArrayt); 16018 smallBoolt *value = allocSmallBool(true); 16019 16020 // index not trimmed (an element is NULL) 16021 self->f->pushUndefined(self); 16022 self->f->pushBool(self, false); 16023 self->f->pushUndefined(self); 16024 delElemO(self, 2); 16025 self->f->pushBool(self, true); 16026 self->f->pushS(self, "4"); 16027 self->f->pushS(self, "5"); 16028 r = binarySearchSmallBoolO(self, value); 16029 ck_assert_int_eq(r, -1); 16030 // index 16031 trimO(self); 16032 r = binarySearchSmallBoolO(self, value); 16033 ck_assert_int_eq(r, 2); 16034 // index in the lower half of the array 16035 setValO(value, false); 16036 r = binarySearchSmallBoolO(self, value); 16037 ck_assert_int_eq(r, 1); 16038 // not index 16039 delElemO(self, 1); 16040 trimO(self); 16041 r = binarySearchSmallBoolO(self, value); 16042 ck_assert_int_eq(r, -1); 16043 // non smallBool object 16044 terminateO(value); 16045 value = (smallBoolt*) allocSmallInt(2); 16046 r = binarySearchSmallBoolO(self, value); 16047 ck_assert_int_eq(r, -1); 16048 // NULL value 16049 r = binarySearchArraycO(self, NULL); 16050 ck_assert_int_eq(r, -1); 16051 // empty array 16052 emptyO(self); 16053 r = binarySearchSmallBoolO(self, value); 16054 ck_assert_int_eq(r, -1); 16055 terminateO(self); 16056 terminateO(value); 16057 16058 } 16059 16060 16061 void binarySearchSmallBytesSmallArrayT(CuTest *tc UNUSED) { 16062 16063 ssize_t r; 16064 smallArrayt *self = allocG(rtSmallArrayt); 16065 createAllocateSmallBytes(value); 16066 pushBufferO(value, "bbc", 4); 16067 16068 // index not trimmed (an element is NULL) 16069 createAllocateSmallBytes(elem); 16070 pushBufferO(elem, "abc", 4); 16071 self->f->pushUndefined(self); 16072 self->f->pushNFreeSmallBytes(self, elem); 16073 self->f->pushUndefined(self); 16074 delElemO(self, 2); 16075 elem = allocSmallBytes("bbc", 4); 16076 self->f->pushNFreeSmallBytes(self, elem); 16077 self->f->pushS(self, "4"); 16078 self->f->pushS(self, "5"); 16079 r = binarySearchSmallBytesO(self, value); 16080 ck_assert_int_eq(r, -1); 16081 // index 16082 trimO(self); 16083 r = binarySearchSmallBytesO(self, value); 16084 ck_assert_int_eq(r, 2); 16085 // index in the lower half of the array 16086 freeO(value); 16087 pushBufferO(value, "abc", 4); 16088 r = binarySearchSmallBytesO(self, value); 16089 ck_assert_int_eq(r, 1); 16090 // not index 16091 freeO(value); 16092 pushBufferO(value, "###", 4); 16093 r = binarySearchSmallBytesO(self, value); 16094 ck_assert_int_eq(r, -1); 16095 // non smallBytes object 16096 terminateO(value); 16097 value = (smallBytest*) allocSmallInt(2); 16098 r = binarySearchSmallBytesO(self, value); 16099 ck_assert_int_eq(r, -1); 16100 // NULL value 16101 r = binarySearchSmallBytesO(self, NULL); 16102 ck_assert_int_eq(r, -1); 16103 // empty array 16104 emptyO(self); 16105 r = binarySearchSmallBytesO(self, value); 16106 ck_assert_int_eq(r, -1); 16107 terminateO(self); 16108 terminateO(value); 16109 16110 } 16111 16112 16113 void binarySearchSmallDoubleSmallArrayT(CuTest *tc UNUSED) { 16114 16115 ssize_t r; 16116 smallArrayt *self = allocG(rtSmallArrayt); 16117 smallDoublet *value = allocSmallDouble(2); 16118 16119 // index not trimmed (an element is NULL) 16120 self->f->pushUndefined(self); 16121 self->f->pushDouble(self, 1); 16122 self->f->pushUndefined(self); 16123 delElemO(self, 2); 16124 self->f->pushDouble(self, 2); 16125 self->f->pushS(self, "4"); 16126 self->f->pushS(self, "5"); 16127 r = binarySearchSmallDoubleO(self, value); 16128 ck_assert_int_eq(r, -1); 16129 // index 16130 trimO(self); 16131 r = binarySearchSmallDoubleO(self, value); 16132 ck_assert_int_eq(r, 2); 16133 // index in the lower half of the array 16134 setValO(value, 1); 16135 r = binarySearchSmallDoubleO(self, value); 16136 ck_assert_int_eq(r, 1); 16137 // not index 16138 delElemO(self, 1); 16139 trimO(self); 16140 r = binarySearchSmallDoubleO(self, value); 16141 ck_assert_int_eq(r, -1); 16142 // non smallDouble object 16143 terminateO(value); 16144 value = (smallDoublet*) allocSmallInt(2); 16145 r = binarySearchSmallDoubleO(self, value); 16146 ck_assert_int_eq(r, -1); 16147 // NULL value 16148 r = binarySearchArraycO(self, NULL); 16149 ck_assert_int_eq(r, -1); 16150 // empty array 16151 emptyO(self); 16152 r = binarySearchSmallDoubleO(self, value); 16153 ck_assert_int_eq(r, -1); 16154 terminateO(self); 16155 terminateO(value); 16156 16157 } 16158 16159 16160 void binarySearchSmallIntSmallArrayT(CuTest *tc UNUSED) { 16161 16162 ssize_t r; 16163 smallArrayt *self = allocG(rtSmallArrayt); 16164 smallIntt *value = allocSmallInt(2); 16165 16166 // index not trimmed (an element is NULL) 16167 self->f->pushUndefined(self); 16168 self->f->pushInt(self, 1); 16169 self->f->pushUndefined(self); 16170 delElemO(self, 2); 16171 self->f->pushInt(self, 2); 16172 self->f->pushS(self, "4"); 16173 self->f->pushS(self, "5"); 16174 r = binarySearchSmallIntO(self, value); 16175 ck_assert_int_eq(r, -1); 16176 // index 16177 trimO(self); 16178 r = binarySearchSmallIntO(self, value); 16179 ck_assert_int_eq(r, 2); 16180 // index in the lower half of the array 16181 setValO(value, 1); 16182 r = binarySearchSmallIntO(self, value); 16183 ck_assert_int_eq(r, 1); 16184 // not index 16185 delElemO(self, 1); 16186 trimO(self); 16187 r = binarySearchSmallIntO(self, value); 16188 ck_assert_int_eq(r, -1); 16189 // non smallInt object 16190 terminateO(value); 16191 value = (smallIntt*) allocSmallBool(true); 16192 r = binarySearchSmallIntO(self, value); 16193 ck_assert_int_eq(r, -1); 16194 // NULL value 16195 r = binarySearchArraycO(self, NULL); 16196 ck_assert_int_eq(r, -1); 16197 // empty array 16198 emptyO(self); 16199 r = binarySearchSmallIntO(self, value); 16200 ck_assert_int_eq(r, -1); 16201 terminateO(self); 16202 terminateO(value); 16203 16204 } 16205 16206 16207 void binarySearchSmallJsonSmallArrayT(CuTest *tc UNUSED) { 16208 16209 ssize_t r; 16210 smallArrayt *self = allocG(rtSmallArrayt); 16211 smallJsont *value = allocSmallJson(); 16212 value->f->pushInt(value, 2); 16213 16214 // index not trimmed (an element is NULL) 16215 self->f->pushUndefined(self); 16216 createAllocateSmallArray(elem); 16217 elem->f->pushInt(elem, 1); 16218 self->f->pushArray(self, elem); 16219 resetO(elem); 16220 self->f->pushUndefined(self); 16221 delElemO(self, 2); 16222 elem->f->pushInt(elem, 2); 16223 self->f->pushNFreeArray(self, elem); 16224 self->f->pushS(self, "4"); 16225 self->f->pushS(self, "5"); 16226 r = self->f->binarySearchSmallJson(self, value); 16227 ck_assert_int_eq(r, -1); 16228 // index 16229 trimO(self); 16230 r = self->f->binarySearchSmallJson(self, value); 16231 ck_assert_int_eq(r, 2); 16232 // index in the lower half of the array 16233 freeO(value); 16234 value->f->pushInt(value, 1); 16235 r = self->f->binarySearchSmallJson(self, value); 16236 ck_assert_int_eq(r, 1); 16237 // not index (json array) 16238 delElemO(self, 1); 16239 trimO(self); 16240 r = self->f->binarySearchSmallJson(self, value); 16241 ck_assert_int_eq(r, -1); 16242 // not index json undefined 16243 createUndefined(u); 16244 freeO(value); 16245 setTopO(value, (baset*)&u); 16246 r = self->f->binarySearchSmallJson(self, value); 16247 ck_assert_int_eq(r, -1); 16248 // not index json bool 16249 createSmallBool(b); 16250 freeO(value); 16251 setTopO(value, (baset*)&b); 16252 r = self->f->binarySearchSmallJson(self, value); 16253 ck_assert_int_eq(r, -1); 16254 // not index json double 16255 createSmallDouble(d); 16256 freeO(value); 16257 setTopO(value, (baset*)&d); 16258 r = self->f->binarySearchSmallJson(self, value); 16259 ck_assert_int_eq(r, -1); 16260 // not index json int 16261 createSmallInt(i); 16262 freeO(value); 16263 setTopO(value, (baset*)&i); 16264 r = self->f->binarySearchSmallJson(self, value); 16265 ck_assert_int_eq(r, -1); 16266 // not index json string 16267 createSmallString(s); 16268 freeO(value); 16269 setTopO(value, (baset*)&s); 16270 r = self->f->binarySearchSmallJson(self, value); 16271 ck_assert_int_eq(r, -1); 16272 // not index json dict 16273 createSmallDict(D); 16274 freeO(value); 16275 setTopO(value, (baset*)&D); 16276 r = self->f->binarySearchSmallJson(self, value); 16277 ck_assert_int_eq(r, -1); 16278 // empty json object 16279 freeO(value); 16280 r = self->f->binarySearchSmallJson(self, value); 16281 ck_assert_int_eq(r, -1); 16282 // non smallJson object 16283 terminateO(value); 16284 value = (smallJsont*) allocSmallInt(2); 16285 r = self->f->binarySearchSmallJson(self, value); 16286 ck_assert_int_eq(r, -1); 16287 // NULL value 16288 r = self->f->binarySearchSmallJson(self, NULL); 16289 ck_assert_int_eq(r, -1); 16290 // empty array 16291 emptyO(self); 16292 r = self->f->binarySearchSmallJson(self, value); 16293 ck_assert_int_eq(r, -1); 16294 terminateO(self); 16295 terminateO(value); 16296 16297 } 16298 16299 16300 void binarySearchSmallStringSmallArrayT(CuTest *tc UNUSED) { 16301 16302 ssize_t r; 16303 smallArrayt *self = allocG(rtSmallArrayt); 16304 smallStringt *value = allocSmallString("4"); 16305 16306 // index not trimmed (an element is NULL) 16307 self->f->pushS(self, "0"); 16308 self->f->pushS(self, "1"); 16309 self->f->pushS(self, "2"); 16310 delElemO(self, 2); 16311 self->f->pushS(self, "3"); 16312 self->f->pushS(self, "4"); 16313 self->f->pushS(self, "5"); 16314 r = binarySearchSmallStringO(self, value); 16315 ck_assert_int_eq(r, -1); 16316 // index 16317 trimO(self); 16318 r = binarySearchSmallStringO(self, value); 16319 ck_assert_int_eq(r, 3); 16320 // index in the lower half of the array 16321 setValO(value, "1"); 16322 r = binarySearchSmallStringO(self, value); 16323 ck_assert_int_eq(r, 1); 16324 // not index 16325 setValO(value, "asd"); 16326 r = binarySearchSmallStringO(self, value); 16327 ck_assert_int_eq(r, -1); 16328 // non smallString object 16329 terminateO(value); 16330 value = (smallStringt*) allocSmallInt(2); 16331 r = binarySearchSmallStringO(self, value); 16332 ck_assert_int_eq(r, -1); 16333 // NULL value 16334 r = binarySearchSmallStringO(self, NULL); 16335 ck_assert_int_eq(r, -1); 16336 // empty array 16337 emptyO(self); 16338 r = binarySearchSmallStringO(self, value); 16339 ck_assert_int_eq(r, -1); 16340 terminateO(self); 16341 terminateO(value); 16342 16343 } 16344 16345 16346 void binarySearchSmallContainerSmallArrayT(CuTest *tc UNUSED) { 16347 16348 ssize_t r; 16349 smallArrayt *self = allocG(rtSmallArrayt); 16350 createAllocateSmallContainer(value); 16351 16352 r = self->f->binarySearchSmallContainer(self, value); 16353 ck_assert_int_eq(r, -1); 16354 terminateO(self); 16355 terminateO(value); 16356 16357 } 16358 16359 16360 void uniqSmallArrayT(CuTest *tc UNUSED) { 16361 16362 smallArrayt* r; 16363 smallArrayt *self = allocG(rtSmallArrayt); 16364 16365 // empty array 16366 r = self->f->uniq(self); 16367 ck_assert_ptr_eq(r, NULL); 16368 // one element 16369 self->f->pushUndefined(self); 16370 r = self->f->uniq(self); 16371 ck_assert_ptr_eq(r, self); 16372 // uniq elements 16373 self->f->pushUndefined(self); 16374 self->f->pushBool(self, true); 16375 self->f->pushNFreeDict(self, allocSmallDict()); 16376 self->f->pushDouble(self, 1); 16377 self->f->pushInt(self, 2); 16378 self->f->pushS(self, ""); 16379 self->f->pushNFreeArray(self, allocSmallArray()); 16380 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 16381 self->f->pushUndefined(self); 16382 self->f->pushBool(self, true); 16383 self->f->pushNFreeDict(self, allocSmallDict()); 16384 self->f->pushDouble(self, 1); 16385 self->f->pushInt(self, 2); 16386 self->f->pushS(self, ""); 16387 self->f->pushNFreeArray(self, allocSmallArray()); 16388 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 16389 r = self->f->uniq(self); 16390 ck_assert_ptr_ne(r, NULL); 16391 char *s = toStringO(r); 16392 ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"\",[],[0x71,0x77,0x65,0x00]]"); 16393 free(s); 16394 terminateO(self); 16395 16396 } 16397 16398 16399 void icHasSmallArrayT(CuTest *tc UNUSED) { 16400 16401 bool r; 16402 smallArrayt *self = allocG(rtSmallArrayt); 16403 baset *value = (baset*)allocSmallString("a"); 16404 16405 // has 16406 self->f->pushS(self, "A"); 16407 r = icHasO(self, value); 16408 ck_assert(r); 16409 // not has 16410 emptyO(self); 16411 r = icHasO(self, value); 16412 ck_assert(!r); 16413 // NULL value 16414 r = icHasO(self, NULL); 16415 ck_assert(!r); 16416 terminateO(self); 16417 terminateO(value); 16418 16419 } 16420 16421 16422 void icHasSSmallArrayT(CuTest *tc UNUSED) { 16423 16424 bool r; 16425 smallArrayt *self = allocG(rtSmallArrayt); 16426 const char *value = "ASD"; 16427 16428 // has 16429 self->f->pushS(self, "asd"); 16430 r = icHasSO(self, value); 16431 ck_assert(r); 16432 // not has 16433 emptyO(self); 16434 r = icHasSO(self, value); 16435 ck_assert(!r); 16436 // NULL value 16437 r = icHasSO(self, NULL); 16438 ck_assert(!r); 16439 terminateO(self); 16440 16441 } 16442 16443 16444 void icHasCharSmallArrayT(CuTest *tc UNUSED) { 16445 16446 bool r; 16447 smallArrayt *self = allocG(rtSmallArrayt); 16448 char value = 'A'; 16449 16450 // has 16451 self->f->pushS(self, "a"); 16452 r = icHasCharO(self, value); 16453 ck_assert(r); 16454 // not has 16455 emptyO(self); 16456 r = icHasCharO(self, value); 16457 ck_assert(!r); 16458 terminateO(self); 16459 16460 } 16461 16462 16463 void icHasDictSmallArrayT(CuTest *tc UNUSED) { 16464 16465 bool r; 16466 smallArrayt *self = allocG(rtSmallArrayt); 16467 smallDictt *value = allocSmallDict(); 16468 value->f->setInt(value, "A", 1); 16469 16470 // has 16471 createAllocateSmallDict(d); 16472 d->f->setInt(d, "a", 1); 16473 self->f->pushNFreeDict(self, d); 16474 r = icHasDictO(self, value); 16475 ck_assert(r); 16476 // not has 16477 emptyO(self); 16478 r = icHasDictO(self, value); 16479 ck_assert(!r); 16480 // NULL value 16481 r = icHasDictO(self, NULL); 16482 ck_assert(!r); 16483 terminateO(self); 16484 terminateO(value); 16485 16486 } 16487 16488 16489 void icHasArraySmallArrayT(CuTest *tc UNUSED) { 16490 16491 bool r; 16492 smallArrayt *self = allocG(rtSmallArrayt); 16493 smallArrayt *value = allocSmallArray(); 16494 value->f->pushS(value, "A"); 16495 16496 // has 16497 createAllocateSmallArray(a); 16498 a->f->pushS(a, "a"); 16499 self->f->pushNFreeArray(self, a); 16500 r = icHasArrayO(self, value); 16501 ck_assert(r); 16502 // not has 16503 emptyO(self); 16504 r = icHasArrayO(self, value); 16505 ck_assert(!r); 16506 // NULL value 16507 r = icHasArrayO(self, NULL); 16508 ck_assert(!r); 16509 terminateO(self); 16510 terminateO(value); 16511 16512 } 16513 16514 16515 void icHasArraycSmallArrayT(CuTest *tc UNUSED) { 16516 16517 bool r; 16518 smallArrayt *self = allocG(rtSmallArrayt); 16519 char **value = listCreateS("A","BB"); 16520 16521 // has 16522 self->f->pushNFreeArrayc(self, listCreateS("a","bb")); 16523 r = icHasArraycO(self, value); 16524 ck_assert(r); 16525 // not has 16526 emptyO(self); 16527 r = icHasArraycO(self, value); 16528 ck_assert(!r); 16529 // NULL value 16530 r = icHasArraycO(self, NULL); 16531 ck_assert(!r); 16532 terminateO(self); 16533 listFreeS(value); 16534 16535 } 16536 16537 16538 void icHasSmallJsonSmallArrayT(CuTest *tc UNUSED) { 16539 16540 bool r; 16541 smallArrayt *self = allocG(rtSmallArrayt); 16542 smallJsont *value = allocSmallJson(); 16543 value->f->pushS(value, "A"); 16544 16545 // has 16546 createAllocateSmallJson(elem); 16547 elem->f->pushS(elem, "a"); 16548 self->f->pushNFreeSmallJson(self, elem); 16549 r = self->f->icHasSmallJson(self, value); 16550 ck_assert(r); 16551 // not has 16552 emptyO(self); 16553 r = self->f->icHasSmallJson(self, value); 16554 ck_assert(!r); 16555 // NULL value 16556 r = self->f->icHasSmallJson(self, NULL); 16557 ck_assert(!r); 16558 terminateO(self); 16559 terminateO(value); 16560 16561 } 16562 16563 16564 void icHasSmallStringSmallArrayT(CuTest *tc UNUSED) { 16565 16566 bool r; 16567 smallArrayt *self = allocG(rtSmallArrayt); 16568 smallStringt *value = allocSmallString("QWE"); 16569 16570 // has 16571 self->f->pushS(self, "qwe"); 16572 r = self->f->icHasSmallString(self, value); 16573 ck_assert(r); 16574 // not has 16575 emptyO(self); 16576 r = self->f->icHasSmallString(self, value); 16577 ck_assert(!r); 16578 // NULL value 16579 r = self->f->icHasSmallString(self, NULL); 16580 ck_assert(!r); 16581 terminateO(self); 16582 terminateO(value); 16583 16584 } 16585 16586 16587 void icIndexOfSmallArrayT(CuTest *tc UNUSED) { 16588 16589 ssize_t r; 16590 smallArrayt *self = allocG(rtSmallArrayt); 16591 baset *value = (baset*)allocSmallString("A"); 16592 16593 // index 16594 self->f->pushS(self, "2"); 16595 self->f->pushS(self, "3"); 16596 delElemO(self, 1); 16597 self->f->pushS(self, "a"); 16598 r = icIndexOfO(self, value); 16599 ck_assert_int_eq(r, 2); 16600 // not index 16601 smallStringt *v = (smallStringt*) value; 16602 setValO(v, "3"); 16603 r = icIndexOfO(self, value); 16604 ck_assert_int_eq(r, -1); 16605 // NULL value 16606 r = icIndexOfO(self, NULL); 16607 ck_assert_int_eq(r, -1); 16608 terminateO(self); 16609 terminateO(value); 16610 16611 } 16612 16613 16614 void icIndexOfSSmallArrayT(CuTest *tc UNUSED) { 16615 16616 ssize_t r; 16617 smallArrayt *self = allocG(rtSmallArrayt); 16618 const char *value = "ASD"; 16619 16620 // indexOf 16621 self->f->pushUndefined(self); 16622 self->f->pushUndefined(self); 16623 delElemO(self, 1); 16624 self->f->pushS(self, "asd"); 16625 r = icIndexOfSO(self, value); 16626 ck_assert_int_eq(r, 2); 16627 // not indexOf 16628 delElemO(self, 2); 16629 r = icIndexOfSO(self, value); 16630 ck_assert_int_eq(r, -1); 16631 // NULL value 16632 r = icIndexOfSO(self, NULL); 16633 ck_assert_int_eq(r, -1); 16634 terminateO(self); 16635 16636 } 16637 16638 16639 void icIndexOfCharSmallArrayT(CuTest *tc UNUSED) { 16640 16641 ssize_t r; 16642 smallArrayt *self = allocG(rtSmallArrayt); 16643 char value = 'A'; 16644 16645 // indexOf 16646 self->f->pushUndefined(self); 16647 self->f->pushUndefined(self); 16648 delElemO(self, 1); 16649 self->f->pushS(self, "a"); 16650 r = icIndexOfCharO(self, value); 16651 ck_assert_int_eq(r, 2); 16652 // not indexOf 16653 delElemO(self, 2); 16654 r = icIndexOfCharO(self, value); 16655 ck_assert_int_eq(r, -1); 16656 terminateO(self); 16657 16658 } 16659 16660 16661 void icIndexOfDictSmallArrayT(CuTest *tc UNUSED) { 16662 16663 ssize_t r; 16664 smallArrayt *self = allocG(rtSmallArrayt); 16665 smallDictt *value = allocSmallDict(); 16666 value->f->setInt(value, "B", 1); 16667 16668 // indexOf 16669 createAllocateSmallDict(elem); 16670 elem->f->setInt(elem, "a", 1); 16671 self->f->pushDict(self, elem); 16672 resetO(elem); 16673 self->f->pushUndefined(self); 16674 delElemO(self, 1); 16675 elem->f->setInt(elem, "b", 1); 16676 self->f->pushNFreeDict(self, elem); 16677 r = icIndexOfDictO(self, value); 16678 ck_assert_int_eq(r, 2); 16679 // not indexOf 16680 delElemO(self, 2); 16681 r = icIndexOfDictO(self, value); 16682 ck_assert_int_eq(r, -1); 16683 // non smallDict object 16684 terminateO(value); 16685 value = (smallDictt*) allocSmallInt(2); 16686 r = icIndexOfDictO(self, value); 16687 ck_assert_int_eq(r, -1); 16688 // NULL value 16689 r = icIndexOfDictO(self, NULL); 16690 ck_assert_int_eq(r, -1); 16691 terminateO(self); 16692 terminateO(value); 16693 16694 } 16695 16696 16697 void icIndexOfArraySmallArrayT(CuTest *tc UNUSED) { 16698 16699 ssize_t r; 16700 smallArrayt *self = allocG(rtSmallArrayt); 16701 smallArrayt *value = allocSmallArray(); 16702 value->f->pushS(value, "A"); 16703 16704 // indexOf 16705 createAllocateSmallArray(elem); 16706 elem->f->pushInt(elem, 1); 16707 self->f->pushArray(self, elem); 16708 resetO(elem); 16709 self->f->pushUndefined(self); 16710 delElemO(self, 1); 16711 elem->f->pushS(elem, "a"); 16712 self->f->pushNFreeArray(self, elem); 16713 r = icIndexOfArrayO(self, value); 16714 ck_assert_int_eq(r, 2); 16715 // non smallArray object 16716 terminateO(value); 16717 value = (smallArrayt*) allocSmallInt(2); 16718 r = icIndexOfArrayO(self, value); 16719 ck_assert_int_eq(r, -1); 16720 // not indexOf 16721 emptyO(self); 16722 r = icIndexOfArrayO(self, value); 16723 ck_assert_int_eq(r, -1); 16724 // NULL value 16725 r = icIndexOfArrayO(self, NULL); 16726 ck_assert_int_eq(r, -1); 16727 terminateO(self); 16728 terminateO(value); 16729 16730 } 16731 16732 16733 void icIndexOfArraycSmallArrayT(CuTest *tc UNUSED) { 16734 16735 ssize_t r; 16736 smallArrayt *self = allocG(rtSmallArrayt); 16737 char **value = listCreateS("A","BB"); 16738 16739 // indexOf 16740 char **elem = listCreateS("!!","@@@"); 16741 self->f->pushNFreeArrayc(self, elem); 16742 self->f->pushUndefined(self); 16743 delElemO(self, 1); 16744 self->f->pushNFreeArrayc(self, listCreateS("a","bb")); 16745 r = icIndexOfArraycO(self, value); 16746 ck_assert_int_eq(r, 2); 16747 // not indexOf 16748 delElemO(self, 2); 16749 r = icIndexOfArraycO(self, value); 16750 ck_assert_int_eq(r, -1); 16751 // NULL value 16752 r = icIndexOfArraycO(self, NULL); 16753 ck_assert_int_eq(r, -1); 16754 terminateO(self); 16755 listFreeS(value); 16756 16757 } 16758 16759 16760 void icIndexOfSmallJsonSmallArrayT(CuTest *tc UNUSED) { 16761 16762 ssize_t r; 16763 smallArrayt *self = allocG(rtSmallArrayt); 16764 smallJsont *value = allocSmallJson(); 16765 16766 // indexOf json undefined 16767 createUndefined(u); 16768 setTopO(value, (baset*)&u); 16769 self->f->pushUndefined(self); 16770 r = self->f->icIndexOfSmallJson(self, value); 16771 ck_assert_int_eq(r, 0); 16772 freeO(value); 16773 // indexOf json bool 16774 smallBoolt *b = allocSmallBool(true); 16775 setTopNFreeSmallBoolO(value, b); 16776 self->f->pushBool(self, true); 16777 r = self->f->icIndexOfSmallJson(self, value); 16778 ck_assert_int_eq(r, 1); 16779 freeO(value); 16780 // indexOf json double 16781 smallDoublet *d = allocSmallDouble(1); 16782 setTopNFreeSmallDoubleO(value, d); 16783 self->f->pushDouble(self, 1); 16784 r = self->f->icIndexOfSmallJson(self, value); 16785 ck_assert_int_eq(r, 2); 16786 freeO(value); 16787 // indexOf json int 16788 smallIntt *i = allocSmallInt(1); 16789 setTopNFreeSmallIntO(value, i); 16790 self->f->pushInt(self, 1); 16791 r = self->f->icIndexOfSmallJson(self, value); 16792 ck_assert_int_eq(r, 3); 16793 freeO(value); 16794 // indexOf json string 16795 smallStringt *s = allocSmallString("ASD"); 16796 setTopNFreeSmallStringO(value, s); 16797 self->f->pushS(self, "asd"); 16798 r = self->f->icIndexOfSmallJson(self, value); 16799 ck_assert_int_eq(r, 4); 16800 freeO(value); 16801 // indexOf json dict 16802 smallDictt *D = allocSmallDict(); 16803 D->f->setInt(D, "A", 1); 16804 setTopDictO(value, D); 16805 resetO(D); 16806 D->f->setInt(D, "a", 1); 16807 self->f->pushNFreeDict(self, D); 16808 r = self->f->icIndexOfSmallJson(self, value); 16809 ck_assert_int_eq(r, 5); 16810 freeO(value); 16811 // indexOf json array 16812 value->f->pushS(value, "A"); 16813 delElemO(self, 1); 16814 createAllocateSmallJson(elem); 16815 elem->f->pushS(elem, "a"); 16816 self->f->pushNFreeSmallJson(self, elem); 16817 r = self->f->icIndexOfSmallJson(self, value); 16818 ck_assert_int_eq(r, 6); 16819 // not indexOf 16820 delElemO(self, 6); 16821 r = self->f->icIndexOfSmallJson(self, value); 16822 ck_assert_int_eq(r, -1); 16823 // empty json object 16824 freeO(value); 16825 r = self->f->icIndexOfSmallJson(self, value); 16826 ck_assert_int_eq(r, -1); 16827 // non smallJson object 16828 terminateO(value); 16829 value = (smallJsont*) allocSmallInt(2); 16830 r = self->f->icIndexOfSmallJson(self, value); 16831 ck_assert_int_eq(r, -1); 16832 // NULL value 16833 r = self->f->icIndexOfSmallJson(self, NULL); 16834 ck_assert_int_eq(r, -1); 16835 terminateO(self); 16836 terminateO(value); 16837 16838 } 16839 16840 16841 void icIndexOfSmallStringSmallArrayT(CuTest *tc UNUSED) { 16842 16843 ssize_t r; 16844 smallArrayt *self = allocG(rtSmallArrayt); 16845 smallStringt *value = allocSmallString("QWE"); 16846 16847 // indexOf 16848 self->f->pushUndefined(self); 16849 self->f->pushUndefined(self); 16850 delElemO(self, 1); 16851 self->f->pushS(self, "qwe"); 16852 r = self->f->icIndexOfSmallString(self, value); 16853 ck_assert_int_eq(r, 2); 16854 // not indexOf 16855 delElemO(self, 2); 16856 r = self->f->icIndexOfSmallString(self, value); 16857 ck_assert_int_eq(r, -1); 16858 // non smallString object 16859 terminateO(value); 16860 value = (smallStringt*) allocSmallInt(2); 16861 r = self->f->icIndexOfSmallString(self, value); 16862 ck_assert_int_eq(r, -1); 16863 // NULL value 16864 r = self->f->icIndexOfSmallString(self, NULL); 16865 ck_assert_int_eq(r, -1); 16866 terminateO(self); 16867 terminateO(value); 16868 16869 } 16870 16871 16872 void icBinarySearchSmallArrayT(CuTest *tc UNUSED) { 16873 16874 ssize_t r; 16875 smallArrayt *self = allocG(rtSmallArrayt); 16876 baset *value = (baset*)allocSmallString("E"); 16877 16878 // index not trimmed (an element is NULL) 16879 self->f->pushS(self, "a"); 16880 self->f->pushS(self, "b"); 16881 self->f->pushS(self, "c"); 16882 delElemO(self, 2); 16883 self->f->pushS(self, "d"); 16884 self->f->pushS(self, "e"); 16885 self->f->pushS(self, "f"); 16886 r = icBinarySearchO(self, value); 16887 ck_assert_int_eq(r, -1); 16888 // index 16889 trimO(self); 16890 r = icBinarySearchO(self, value); 16891 ck_assert_int_eq(r, 3); 16892 smallStringt *v = (smallStringt*) value; 16893 // index in the lower half of the array 16894 setValO(v, "B"); 16895 r = icBinarySearchO(self, value); 16896 ck_assert_int_eq(r, 1); 16897 // not index 16898 setValO(v, "asd"); 16899 r = icBinarySearchO(self, value); 16900 ck_assert_int_eq(r, -1); 16901 // NULL value 16902 r = icBinarySearchO(self, NULL); 16903 ck_assert_int_eq(r, -1); 16904 // empty array 16905 emptyO(self); 16906 r = icBinarySearchO(self, value); 16907 ck_assert_int_eq(r, -1); 16908 terminateO(self); 16909 terminateO(value); 16910 16911 } 16912 16913 16914 void icBinarySearchSSmallArrayT(CuTest *tc UNUSED) { 16915 16916 ssize_t r; 16917 smallArrayt *self = allocG(rtSmallArrayt); 16918 const char *value = "E"; 16919 16920 // index not trimmed (an element is NULL) 16921 self->f->pushS(self, "a"); 16922 self->f->pushS(self, "b"); 16923 self->f->pushS(self, "c"); 16924 delElemO(self, 2); 16925 self->f->pushS(self, "d"); 16926 self->f->pushS(self, "e"); 16927 self->f->pushS(self, "f"); 16928 r = icBinarySearchSO(self, value); 16929 ck_assert_int_eq(r, -1); 16930 // index 16931 trimO(self); 16932 r = icBinarySearchSO(self, value); 16933 ck_assert_int_eq(r, 3); 16934 // index in the lower half of the array 16935 value = "B"; 16936 r = icBinarySearchSO(self, value); 16937 ck_assert_int_eq(r, 1); 16938 // not index 16939 value = "asd"; 16940 r = icBinarySearchSO(self, value); 16941 ck_assert_int_eq(r, -1); 16942 // NULL value 16943 r = icBinarySearchSO(self, NULL); 16944 ck_assert_int_eq(r, -1); 16945 // empty array 16946 emptyO(self); 16947 r = icBinarySearchSO(self, value); 16948 ck_assert_int_eq(r, -1); 16949 terminateO(self); 16950 16951 } 16952 16953 16954 void icBinarySearchCharSmallArrayT(CuTest *tc UNUSED) { 16955 16956 ssize_t r; 16957 smallArrayt *self = allocG(rtSmallArrayt); 16958 char value = 'E'; 16959 16960 // index not trimmed (an element is NULL) 16961 self->f->pushS(self, "a"); 16962 self->f->pushS(self, "b"); 16963 self->f->pushS(self, "c"); 16964 delElemO(self, 2); 16965 self->f->pushS(self, "d"); 16966 self->f->pushS(self, "e"); 16967 self->f->pushS(self, "f"); 16968 r = icBinarySearchCharO(self, value); 16969 ck_assert_int_eq(r, -1); 16970 // index 16971 trimO(self); 16972 r = icBinarySearchCharO(self, value); 16973 ck_assert_int_eq(r, 3); 16974 // index in the lower half of the array 16975 value = 'B'; 16976 r = icBinarySearchCharO(self, value); 16977 ck_assert_int_eq(r, 1); 16978 // not index 16979 value = '1'; 16980 r = icBinarySearchCharO(self, value); 16981 ck_assert_int_eq(r, -1); 16982 // empty array 16983 emptyO(self); 16984 r = icBinarySearchCharO(self, value); 16985 ck_assert_int_eq(r, -1); 16986 terminateO(self); 16987 16988 } 16989 16990 16991 void icBinarySearchDictSmallArrayT(CuTest *tc UNUSED) { 16992 16993 ssize_t r; 16994 smallArrayt *self = allocG(rtSmallArrayt); 16995 smallDictt *value = allocSmallDict(); 16996 value->f->setInt(value, "B", 2); 16997 16998 // index not trimmed (an element is NULL) 16999 createAllocateSmallDict(elem); 17000 elem->f->setInt(elem, "a", 1); 17001 self->f->pushUndefined(self); 17002 self->f->pushDict(self, elem); 17003 resetO(elem); 17004 self->f->pushUndefined(self); 17005 delElemO(self, 2); 17006 elem->f->setInt(elem, "b", 2); 17007 self->f->pushNFreeDict(self, elem); 17008 self->f->pushS(self, "4"); 17009 self->f->pushS(self, "5"); 17010 r = icBinarySearchDictO(self, value); 17011 ck_assert_int_eq(r, -1); 17012 // index 17013 trimO(self); 17014 r = icBinarySearchDictO(self, value); 17015 ck_assert_int_eq(r, 2); 17016 // index in the lower half of the array 17017 freeO(value); 17018 value->f->setInt(value, "A", 1); 17019 r = icBinarySearchDictO(self, value); 17020 ck_assert_int_eq(r, 1); 17021 // not index 17022 freeO(value); 17023 r = icBinarySearchDictO(self, value); 17024 ck_assert_int_eq(r, -1); 17025 // non smallDict object 17026 terminateO(value); 17027 value = (smallDictt*) allocSmallInt(2); 17028 r = icBinarySearchDictO(self, value); 17029 ck_assert_int_eq(r, -1); 17030 // NULL value 17031 r = icBinarySearchDictO(self, NULL); 17032 ck_assert_int_eq(r, -1); 17033 // empty array 17034 emptyO(self); 17035 r = icBinarySearchDictO(self, value); 17036 ck_assert_int_eq(r, -1); 17037 terminateO(self); 17038 terminateO(value); 17039 17040 } 17041 17042 17043 void icBinarySearchArraySmallArrayT(CuTest *tc UNUSED) { 17044 17045 ssize_t r; 17046 smallArrayt *self = allocG(rtSmallArrayt); 17047 smallArrayt *value = allocSmallArray(); 17048 value->f->pushS(value, "B"); 17049 17050 // index not trimmed (an element is NULL) 17051 createAllocateSmallArray(elem); 17052 elem->f->pushS(elem, "a"); 17053 self->f->pushUndefined(self); 17054 self->f->pushArray(self, elem); 17055 resetO(elem); 17056 self->f->pushUndefined(self); 17057 delElemO(self, 2); 17058 elem->f->pushS(elem, "b"); 17059 self->f->pushNFreeArray(self, elem); 17060 self->f->pushS(self, "4"); 17061 self->f->pushS(self, "5"); 17062 r = icBinarySearchArrayO(self, value); 17063 ck_assert_int_eq(r, -1); 17064 // index 17065 trimO(self); 17066 r = icBinarySearchArrayO(self, value); 17067 ck_assert_int_eq(r, 2); 17068 // index in the lower half of the array 17069 freeO(value); 17070 value->f->pushS(value, "A"); 17071 r = icBinarySearchArrayO(self, value); 17072 ck_assert_int_eq(r, 1); 17073 // not index 17074 freeO(value); 17075 r = icBinarySearchArrayO(self, value); 17076 ck_assert_int_eq(r, -1); 17077 // non smallArray object 17078 terminateO(value); 17079 value = (smallArrayt*) allocSmallInt(2); 17080 r = icBinarySearchArrayO(self, value); 17081 ck_assert_int_eq(r, -1); 17082 // NULL value 17083 r = icBinarySearchArrayO(self, NULL); 17084 ck_assert_int_eq(r, -1); 17085 // empty array 17086 emptyO(self); 17087 r = icBinarySearchArrayO(self, value); 17088 ck_assert_int_eq(r, -1); 17089 terminateO(self); 17090 terminateO(value); 17091 17092 } 17093 17094 17095 void icBinarySearchArraycSmallArrayT(CuTest *tc UNUSED) { 17096 17097 ssize_t r; 17098 smallArrayt *self = allocG(rtSmallArrayt); 17099 char **value = listCreateS("B"); 17100 17101 // index not trimmed (an element is NULL) 17102 char **elem = listCreateS("a"); 17103 self->f->pushUndefined(self); 17104 self->f->pushNFreeArrayc(self, elem); 17105 self->f->pushUndefined(self); 17106 delElemO(self, 2); 17107 elem = listCreateS("b"); 17108 self->f->pushNFreeArrayc(self, elem); 17109 self->f->pushS(self, "4"); 17110 self->f->pushS(self, "5"); 17111 r = icBinarySearchArraycO(self, value); 17112 ck_assert_int_eq(r, -1); 17113 // index 17114 trimO(self); 17115 r = icBinarySearchArraycO(self, value); 17116 ck_assert_int_eq(r, 2); 17117 // index in the lower half of the array 17118 free(value[0]); 17119 value[0] = strdup("A"); 17120 r = icBinarySearchArraycO(self, value); 17121 ck_assert_int_eq(r, 1); 17122 // not index 17123 free(value[0]); 17124 value[0] = strdup("asd"); 17125 r = icBinarySearchArraycO(self, value); 17126 ck_assert_int_eq(r, -1); 17127 // NULL value 17128 r = icBinarySearchArraycO(self, NULL); 17129 ck_assert_int_eq(r, -1); 17130 // empty array 17131 emptyO(self); 17132 r = icBinarySearchArraycO(self, value); 17133 ck_assert_int_eq(r, -1); 17134 terminateO(self); 17135 listFreeS(value); 17136 17137 } 17138 17139 17140 void icBinarySearchSmallJsonSmallArrayT(CuTest *tc UNUSED) { 17141 17142 ssize_t r; 17143 smallArrayt *self = allocG(rtSmallArrayt); 17144 smallJsont *value = allocSmallJson(); 17145 value->f->pushS(value, "B"); 17146 17147 // index not trimmed (an element is NULL) 17148 self->f->pushUndefined(self); 17149 createAllocateSmallArray(elem); 17150 elem->f->pushS(elem, "a"); 17151 self->f->pushArray(self, elem); 17152 resetO(elem); 17153 self->f->pushUndefined(self); 17154 delElemO(self, 2); 17155 elem->f->pushS(elem, "b"); 17156 self->f->pushNFreeArray(self, elem); 17157 self->f->pushS(self, "4"); 17158 self->f->pushS(self, "5"); 17159 r = self->f->icBinarySearchSmallJson(self, value); 17160 ck_assert_int_eq(r, -1); 17161 // index 17162 trimO(self); 17163 r = self->f->icBinarySearchSmallJson(self, value); 17164 ck_assert_int_eq(r, 2); 17165 // index in the lower half of the array 17166 freeO(value); 17167 value->f->pushS(value, "A"); 17168 r = self->f->icBinarySearchSmallJson(self, value); 17169 ck_assert_int_eq(r, 1); 17170 // not index (json array) 17171 delElemO(self, 1); 17172 trimO(self); 17173 r = self->f->icBinarySearchSmallJson(self, value); 17174 ck_assert_int_eq(r, -1); 17175 // not index json undefined 17176 createUndefined(u); 17177 freeO(value); 17178 setTopO(value, (baset*)&u); 17179 r = self->f->icBinarySearchSmallJson(self, value); 17180 ck_assert_int_eq(r, -1); 17181 // not index json bool 17182 createSmallBool(b); 17183 freeO(value); 17184 setTopO(value, (baset*)&b); 17185 r = self->f->icBinarySearchSmallJson(self, value); 17186 ck_assert_int_eq(r, -1); 17187 // not index json double 17188 createSmallDouble(d); 17189 freeO(value); 17190 setTopO(value, (baset*)&d); 17191 r = self->f->icBinarySearchSmallJson(self, value); 17192 ck_assert_int_eq(r, -1); 17193 // not index json int 17194 createSmallInt(i); 17195 freeO(value); 17196 setTopO(value, (baset*)&i); 17197 r = self->f->icBinarySearchSmallJson(self, value); 17198 ck_assert_int_eq(r, -1); 17199 // not index json string 17200 createSmallString(s); 17201 freeO(value); 17202 setTopO(value, (baset*)&s); 17203 r = self->f->icBinarySearchSmallJson(self, value); 17204 ck_assert_int_eq(r, -1); 17205 // not index json dict 17206 createSmallDict(D); 17207 freeO(value); 17208 setTopO(value, (baset*)&D); 17209 r = self->f->icBinarySearchSmallJson(self, value); 17210 ck_assert_int_eq(r, -1); 17211 // empty json object 17212 freeO(value); 17213 r = self->f->icBinarySearchSmallJson(self, value); 17214 ck_assert_int_eq(r, -1); 17215 // non smallJson object 17216 terminateO(value); 17217 value = (smallJsont*) allocSmallInt(2); 17218 r = self->f->icBinarySearchSmallJson(self, value); 17219 ck_assert_int_eq(r, -1); 17220 // NULL value 17221 r = self->f->icBinarySearchSmallJson(self, NULL); 17222 ck_assert_int_eq(r, -1); 17223 // empty array 17224 emptyO(self); 17225 r = self->f->icBinarySearchSmallJson(self, value); 17226 ck_assert_int_eq(r, -1); 17227 terminateO(self); 17228 terminateO(value); 17229 17230 } 17231 17232 17233 void icBinarySearchSmallStringSmallArrayT(CuTest *tc UNUSED) { 17234 17235 ssize_t r; 17236 smallArrayt *self = allocG(rtSmallArrayt); 17237 smallStringt *value = allocSmallString("E"); 17238 17239 // index not trimmed (an element is NULL) 17240 self->f->pushS(self, "a"); 17241 self->f->pushS(self, "b"); 17242 self->f->pushS(self, "c"); 17243 delElemO(self, 2); 17244 self->f->pushS(self, "d"); 17245 self->f->pushS(self, "e"); 17246 self->f->pushS(self, "f"); 17247 r = icBinarySearchSmallStringO(self, value); 17248 ck_assert_int_eq(r, -1); 17249 // index 17250 trimO(self); 17251 r = icBinarySearchSmallStringO(self, value); 17252 ck_assert_int_eq(r, 3); 17253 // index in the lower half of the array 17254 setValO(value, "B"); 17255 r = icBinarySearchSmallStringO(self, value); 17256 ck_assert_int_eq(r, 1); 17257 // not index 17258 setValO(value, "asd"); 17259 r = icBinarySearchSmallStringO(self, value); 17260 ck_assert_int_eq(r, -1); 17261 // non smallString object 17262 terminateO(value); 17263 value = (smallStringt*) allocSmallInt(2); 17264 r = icBinarySearchSmallStringO(self, value); 17265 ck_assert_int_eq(r, -1); 17266 // NULL value 17267 r = icBinarySearchSmallStringO(self, NULL); 17268 ck_assert_int_eq(r, -1); 17269 // empty array 17270 emptyO(self); 17271 r = icBinarySearchSmallStringO(self, value); 17272 ck_assert_int_eq(r, -1); 17273 terminateO(self); 17274 terminateO(value); 17275 17276 } 17277 17278 17279 void icUniqSmallArrayT(CuTest *tc UNUSED) { 17280 17281 smallArrayt* r; 17282 smallArrayt *self = allocG(rtSmallArrayt); 17283 17284 // empty array 17285 r = self->f->icUniq(self); 17286 ck_assert_ptr_eq(r, NULL); 17287 // one element 17288 self->f->pushUndefined(self); 17289 r = self->f->icUniq(self); 17290 ck_assert_ptr_eq(r, self); 17291 // uniq elements 17292 self->f->pushUndefined(self); 17293 self->f->pushBool(self, true); 17294 self->f->pushNFreeDict(self, allocSmallDict()); 17295 self->f->pushDouble(self, 1); 17296 self->f->pushInt(self, 2); 17297 self->f->pushS(self, "ASD"); 17298 self->f->pushNFreeArray(self, allocSmallArray()); 17299 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 17300 self->f->pushUndefined(self); 17301 self->f->pushBool(self, true); 17302 self->f->pushNFreeDict(self, allocSmallDict()); 17303 self->f->pushDouble(self, 1); 17304 self->f->pushInt(self, 2); 17305 self->f->pushS(self, "asd"); 17306 self->f->pushNFreeArray(self, allocSmallArray()); 17307 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 17308 r = self->f->icUniq(self); 17309 ck_assert_ptr_ne(r, NULL); 17310 char *s = toStringO(r); 17311 ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"ASD\",[],[0x71,0x77,0x65,0x00]]"); 17312 free(s); 17313 terminateO(self); 17314 17315 } 17316 17317 17318 void compactSmallArrayT(CuTest *tc UNUSED) { 17319 17320 smallArrayt* r; 17321 smallArrayt *self = allocG(rtSmallArrayt); 17322 17323 // add and remove elements 17324 self->f->pushUndefined(self); 17325 // null element 17326 self->f->pushUndefined(self); 17327 delElemO(self, 1); 17328 self->f->pushBool(self, true); 17329 createSmallContainer(c); 17330 self->f->pushSmallContainer(self, &c); 17331 // empty dict 17332 createSmallDict(d); 17333 self->f->pushDict(self, &d); 17334 resetO(&d); 17335 (&d)->f->setInt(&d, "a", 1); 17336 self->f->pushDict(self, &d); 17337 self->f->pushDouble(self, 2); 17338 self->f->pushInt(self, 5); 17339 self->f->pushS(self, " "); 17340 self->f->pushS(self, "asd"); 17341 // empty Array 17342 createSmallArray(a); 17343 self->f->pushArray(self, &a); 17344 resetO(&a); 17345 (&a)->f->pushInt(&a, 1); 17346 self->f->pushArray(self, &a); 17347 // empty bytes 17348 createSmallBytes(b); 17349 self->f->pushSmallBytes(self, &b); 17350 smallBytest *B = allocSmallBytes("asd", 4); 17351 self->f->pushNFreeSmallBytes(self, B); 17352 r = compactO(self); 17353 ck_assert_ptr_ne(r, NULL); 17354 ck_assert_int_eq(lenO(r), 8); 17355 char *s = toStringO(r); 17356 ck_assert_str_eq(s, "[true,\"<data container>\",{\"a\":1},2.000000e+00,5,\"asd\",[1],[0x61,0x73,0x64,0x00]]"); 17357 free(s); 17358 // array with blank elements, becomes empty after compact 17359 // self->a should not be null 17360 // self->a should an empty sArray to avoid issues with the setP function 17361 self->f->free(self); 17362 self->f->pushS(self, " "); 17363 self->f->pushS(self, ""); 17364 r = compactO(self); 17365 ck_assert_ptr_ne(r, NULL); 17366 ck_assert_ptr_ne(r->a, NULL); 17367 ck_assert_int_eq(lenO(r), 0); 17368 s = toStringO(r); 17369 ck_assert_str_eq(s, "[]"); 17370 free(s); 17371 // empty array 17372 emptyO(self); 17373 r = compactO(self); 17374 ck_assert_ptr_eq(r, NULL); 17375 terminateO(self); 17376 17377 } 17378 17379 17380 void isBlankSmallArrayT(CuTest *tc UNUSED) { 17381 17382 bool r; 17383 smallArrayt *self = allocG(rtSmallArrayt); 17384 17385 // bool 17386 self->f->pushBool(self, true); 17387 r = isBlankO(self); 17388 ck_assert(!r); 17389 // container 17390 emptyO(self); 17391 createSmallContainer(c); 17392 self->f->pushSmallContainer(self, &c); 17393 r = isBlankO(self); 17394 ck_assert(!r); 17395 // blank dict 17396 emptyO(self); 17397 createSmallDict(d); 17398 self->f->pushDict(self, &d); 17399 r = isBlankO(self); 17400 ck_assert(r); 17401 // dict 17402 emptyO(self); 17403 resetO(&d); 17404 (&d)->f->setInt(&d, "a", 1); 17405 self->f->pushDict(self, &d); 17406 r = isBlankO(self); 17407 ck_assert(!r); 17408 // double 17409 emptyO(self); 17410 self->f->pushDouble(self, 0); 17411 r = isBlankO(self); 17412 ck_assert(!r); 17413 // int 17414 emptyO(self); 17415 self->f->pushInt(self, 0); 17416 r = isBlankO(self); 17417 ck_assert(!r); 17418 // blank string 17419 emptyO(self); 17420 self->f->pushS(self, " "); 17421 r = isBlankO(self); 17422 ck_assert(r); 17423 // string 17424 emptyO(self); 17425 self->f->pushS(self, "asd"); 17426 r = isBlankO(self); 17427 ck_assert(!r); 17428 // blank dict 17429 emptyO(self); 17430 createSmallArray(a); 17431 self->f->pushArray(self, &a); 17432 r = isBlankO(self); 17433 ck_assert(r); 17434 // dict 17435 emptyO(self); 17436 resetO(&a); 17437 (&a)->f->pushInt(&a, 1); 17438 self->f->pushArray(self, &a); 17439 r = isBlankO(self); 17440 ck_assert(!r); 17441 // blank Bytes 17442 emptyO(self); 17443 createSmallBytes(b); 17444 self->f->pushSmallBytes(self, &b); 17445 r = isBlankO(self); 17446 ck_assert(r); 17447 // Bytes 17448 emptyO(self); 17449 smallBytest *B = allocSmallBytes("asd", 4); 17450 self->f->pushNFreeSmallBytes(self, B); 17451 r = isBlankO(self); 17452 ck_assert(!r); 17453 // empty array 17454 emptyO(self); 17455 r = isBlankO(self); 17456 ck_assert(r); 17457 terminateO(self); 17458 17459 } 17460 17461 17462 bool fef(void *closure UNUSED, baset *e) { 17463 bool r = true; 17464 if (isOUndefined(e)) r = true; 17465 elif (isOSmallInt(e)) r = false; 17466 else { 17467 static u16 c; 17468 r = !c; 17469 c++; 17470 } 17471 return r; 17472 } 17473 17474 void forEachSmallArrayFT(CuTest *tc UNUSED) { 17475 17476 smallArrayt *self = allocG(rtSmallArrayt); 17477 17478 // empty 17479 self->f->forEach(self, NULL, fef); 17480 // array with elements 17481 self->f->pushUndefined(self); 17482 self->f->pushBool(self, true); 17483 // base class 17484 createAllocateSmallInt(i); 17485 i->type = "userclass"; 17486 self->f->push(self, (baset*)i); 17487 createAllocateSmallInt(j); 17488 j->type = "userclass"; 17489 self->f->push(self, (baset*)j); 17490 delElemO(self, 1); 17491 self->f->pushInt(self, 2); 17492 self->f->forEach(self, NULL, fef); 17493 self->f->del(self, 2, 4); 17494 self->f->forEach(self, NULL, fef); 17495 terminateO(self); 17496 17497 } 17498 17499 17500 bool ef(void *closure UNUSED, u64 i UNUSED, baset *e) { 17501 bool r = true; 17502 if (isOUndefined(e)) r = true; 17503 elif (isOSmallInt(e)) r = false; 17504 else { 17505 static u16 c; 17506 r = !c; 17507 c++; 17508 } 17509 return r; 17510 } 17511 17512 void enumerateSmallArrayFT(CuTest *tc UNUSED) { 17513 17514 smallArrayt *self = allocG(rtSmallArrayt); 17515 17516 // empty 17517 self->f->enumerate(self, NULL, ef); 17518 // array with elements 17519 self->f->pushUndefined(self); 17520 self->f->pushBool(self, true); 17521 // base class 17522 createAllocateSmallInt(i); 17523 i->type = "userclass"; 17524 self->f->push(self, (baset*)i); 17525 createAllocateSmallInt(j); 17526 j->type = "userclass"; 17527 self->f->push(self, (baset*)j); 17528 delElemO(self, 1); 17529 self->f->pushInt(self, 2); 17530 self->f->enumerate(self, NULL, ef); 17531 self->f->del(self, 2, 4); 17532 self->f->enumerate(self, NULL, ef); 17533 terminateO(self); 17534 17535 } 17536 17537 17538 void iterStartSmallArrayT(CuTest *tc UNUSED) { 17539 17540 baset* r; 17541 smallArrayt *self = allocG(rtSmallArrayt); 17542 17543 // array with sObjects 17544 self->f->pushUndefined(self); 17545 self->f->pushBool(self, true); 17546 r = iterStartO(self); 17547 ck_assert_ptr_ne(r, NULL); 17548 ck_assert(isOUndefined(r)); 17549 // start again 17550 r = iterStartO(self); 17551 ck_assert_ptr_ne(r, NULL); 17552 ck_assert(isOUndefined(r)); 17553 // array with objects from other classes 17554 emptyO(self); 17555 createAllocateSmallInt(ip); 17556 ip->type = "anothertype"; 17557 setValG(ip, 11); 17558 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17559 ck_assert_ptr_ne(r2, NULL); 17560 r = iterStartO(self); 17561 ck_assert_ptr_ne(r, NULL); 17562 // array with all deleted elements 17563 emptyO(self); 17564 self->f->pushUndefined(self); 17565 delElemO(self, 0); 17566 r = iterStartO(self); 17567 ck_assert_ptr_eq(r, NULL); 17568 // empty array 17569 emptyO(self); 17570 r = iterStartO(self); 17571 ck_assert_ptr_eq(r, NULL); 17572 terminateO(self); 17573 17574 } 17575 17576 17577 void iterStartLastSmallArrayT(CuTest *tc UNUSED) { 17578 17579 baset* r; 17580 smallArrayt *self = allocG(rtSmallArrayt); 17581 17582 // array with sObjects 17583 self->f->pushUndefined(self); 17584 self->f->pushBool(self, true); 17585 r = iterStartLastO(self); 17586 ck_assert_ptr_ne(r, NULL); 17587 ck_assert(isOSmallBool(r)); 17588 // start again 17589 r = iterStartLastO(self); 17590 ck_assert_ptr_ne(r, NULL); 17591 ck_assert(isOSmallBool(r)); 17592 // array with objects from other classes 17593 emptyO(self); 17594 createAllocateSmallInt(ip); 17595 ip->type = "anothertype"; 17596 setValG(ip, 11); 17597 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17598 ck_assert_ptr_ne(r2, NULL); 17599 r = iterStartLastO(self); 17600 ck_assert_ptr_ne(r, NULL); 17601 ck_assert(isOType(r, "anothertype")); 17602 // array with all deleted elements 17603 emptyO(self); 17604 self->f->pushUndefined(self); 17605 delElemO(self, 0); 17606 r = iterStartLastO(self); 17607 ck_assert_ptr_eq(r, NULL); 17608 // empty array 17609 emptyO(self); 17610 r = iterStartLastO(self); 17611 ck_assert_ptr_eq(r, NULL); 17612 terminateO(self); 17613 17614 } 17615 17616 17617 void iterStartFromSmallArrayT(CuTest *tc UNUSED) { 17618 17619 baset* r; 17620 smallArrayt *self = allocG(rtSmallArrayt); 17621 17622 // array with sObjects 17623 self->f->pushUndefined(self); 17624 self->f->pushBool(self, true); 17625 r = iterStartFromO(self, 1); 17626 ck_assert_ptr_ne(r, NULL); 17627 ck_assert(isOSmallBool(r)); 17628 // start again 17629 r = iterStartFromO(self, 1); 17630 ck_assert_ptr_ne(r, NULL); 17631 ck_assert(isOSmallBool(r)); 17632 // array with objects from other classes 17633 emptyO(self); 17634 self->f->pushUndefined(self); 17635 createAllocateSmallInt(ip); 17636 ip->type = "anothertype"; 17637 setValG(ip, 11); 17638 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17639 ck_assert_ptr_ne(r2, NULL); 17640 r = iterStartFromO(self, -1); 17641 ck_assert_ptr_ne(r, NULL); 17642 ck_assert(isOType(r, "anothertype")); 17643 // index outside array 17644 r = iterStartFromO(self, 2); 17645 ck_assert_ptr_eq(r, NULL); 17646 r = iterStartFromO(self, -3); 17647 ck_assert_ptr_eq(r, NULL); 17648 // array with all deleted elements 17649 // except the ones before the start index 17650 emptyO(self); 17651 self->f->pushUndefined(self); 17652 self->f->pushUndefined(self); 17653 self->f->pushUndefined(self); 17654 delElemO(self, 1); 17655 delElemO(self, 2); 17656 r = iterStartFromO(self, 1); 17657 ck_assert_ptr_eq(r, NULL); 17658 // array with all deleted elements 17659 emptyO(self); 17660 self->f->pushUndefined(self); 17661 self->f->pushUndefined(self); 17662 self->f->pushUndefined(self); 17663 delElemO(self, 0); 17664 delElemO(self, 1); 17665 delElemO(self, 2); 17666 r = iterStartFromO(self, 1); 17667 ck_assert_ptr_eq(r, NULL); 17668 // empty array 17669 emptyO(self); 17670 r = iterStartFromO(self, 1); 17671 ck_assert_ptr_eq(r, NULL); 17672 terminateO(self); 17673 17674 } 17675 17676 17677 void iterStartFromStepSmallArrayT(CuTest *tc UNUSED) { 17678 17679 baset* r; 17680 smallArrayt *self = allocG(rtSmallArrayt); 17681 17682 // array with sObjects 17683 self->f->pushUndefined(self); 17684 self->f->pushBool(self, true); 17685 r = iterStartFromStepO(self, 1, 2); 17686 ck_assert_ptr_ne(r, NULL); 17687 ck_assert(isOSmallBool(r)); 17688 // start again 17689 r = iterStartFromStepO(self, 1, 2); 17690 ck_assert_ptr_ne(r, NULL); 17691 ck_assert(isOSmallBool(r)); 17692 // array with objects from other classes 17693 emptyO(self); 17694 self->f->pushUndefined(self); 17695 createAllocateSmallInt(ip); 17696 ip->type = "anothertype"; 17697 setValG(ip, 11); 17698 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17699 ck_assert_ptr_ne(r2, NULL); 17700 r = iterStartFromStepO(self, -1, 2); 17701 ck_assert_ptr_ne(r, NULL); 17702 ck_assert(isOType(r, "anothertype")); 17703 // index outside array 17704 r = iterStartFromStepO(self, 2, 1); 17705 ck_assert_ptr_eq(r, NULL); 17706 r = iterStartFromStepO(self, -3, 1); 17707 ck_assert_ptr_eq(r, NULL); 17708 // array with all deleted elements 17709 // except the ones before the start index 17710 emptyO(self); 17711 self->f->pushUndefined(self); 17712 self->f->pushUndefined(self); 17713 self->f->pushUndefined(self); 17714 delElemO(self, 1); 17715 delElemO(self, 2); 17716 r = iterStartFromStepO(self, 1, 1); 17717 ck_assert_ptr_eq(r, NULL); 17718 // negative step 17719 r = iterStartFromStepO(self, 1, -1); 17720 ck_assert_ptr_ne(r, NULL); 17721 ck_assert(isOUndefined(r)); 17722 // array with all deleted elements 17723 emptyO(self); 17724 self->f->pushUndefined(self); 17725 self->f->pushUndefined(self); 17726 self->f->pushUndefined(self); 17727 delElemO(self, 0); 17728 delElemO(self, 1); 17729 delElemO(self, 2); 17730 r = iterStartFromStepO(self, 1, 2); 17731 ck_assert_ptr_eq(r, NULL); 17732 // empty array 17733 emptyO(self); 17734 r = iterStartFromStepO(self, 1, 1); 17735 ck_assert_ptr_eq(r, NULL); 17736 // step 0 17737 self->f->pushUndefined(self); 17738 r = iterStartFromStepO(self, 0, 0); 17739 ck_assert_ptr_eq(r, NULL); 17740 terminateO(self); 17741 17742 } 17743 17744 17745 void iterNextSmallArrayT(CuTest *tc UNUSED) { 17746 17747 baset* r; 17748 smallArrayt *self = allocG(rtSmallArrayt); 17749 17750 // array with sObjects 17751 self->f->pushUndefined(self); 17752 self->f->pushBool(self, true); 17753 r = iterStartO(self); 17754 ck_assert_ptr_ne(r, NULL); 17755 ck_assert(isOUndefined(r)); 17756 r = iterNextO(self); 17757 ck_assert(isOSmallBool(r)); 17758 // array with objects from other classes 17759 emptyO(self); 17760 createAllocateSmallInt(ip); 17761 ip->type = "anothertype"; 17762 setValG(ip, 11); 17763 smallArrayt *r2 = self->f->push(self, (baset*)ip); 17764 ck_assert_ptr_ne(r2, NULL); 17765 createAllocateSmallInt(ip2); 17766 ip2->type = "anothertype2"; 17767 setValG(ip2, 11); 17768 r2 = self->f->push(self, (baset*)ip2); 17769 ck_assert_ptr_ne(r2, NULL); 17770 r = iterStartO(self); 17771 ck_assert_ptr_ne(r, NULL); 17772 ck_assert(isOType(r, "anothertype")); 17773 r = iterNextO(self); 17774 ck_assert_ptr_ne(r, NULL); 17775 ck_assert_str_eq(r->type, "anothertype2"); 17776 // iteration ended 17777 r = iterNextO(self); 17778 ck_assert_ptr_eq(r, NULL); 17779 // array with all deleted elements 17780 emptyO(self); 17781 self->f->pushUndefined(self); 17782 delElemO(self, 0); 17783 r = iterStartO(self); 17784 ck_assert_ptr_eq(r, NULL); 17785 // empty array 17786 emptyO(self); 17787 r = iterStartO(self); 17788 ck_assert_ptr_eq(r, NULL); 17789 // empty array, uninitialized iterator 17790 emptyO(self); 17791 r = iterNextO(self); 17792 ck_assert_ptr_eq(r, NULL); 17793 terminateO(self); 17794 17795 } 17796 17797 17798 void iterElementSmallArrayT(CuTest *tc UNUSED) { 17799 17800 baset* r; 17801 smallArrayt *self = allocG(rtSmallArrayt); 17802 17803 // start iteration 17804 self->f->pushUndefined(self); 17805 r = iterStartO(self); 17806 ck_assert_ptr_ne(r, NULL); 17807 baset *r2 = iterElementO(self); 17808 ck_assert_ptr_eq(r, r2); 17809 ck_assert_str_eq(r->type, "undefined"); 17810 // end iteration 17811 r = iterNextO(self); 17812 ck_assert_ptr_eq(r, NULL); 17813 r = iterElementO(self); 17814 ck_assert_ptr_eq(r, NULL); 17815 terminateO(self); 17816 17817 } 17818 17819 17820 void iterIndexSmallArrayT(CuTest *tc UNUSED) { 17821 17822 ssize_t r; 17823 baset* r2; 17824 smallArrayt *self = allocG(rtSmallArrayt); 17825 17826 // start iteration 17827 self->f->pushUndefined(self); 17828 r2 = iterStartO(self); 17829 ck_assert_ptr_ne(r2, NULL); 17830 ck_assert_str_eq(r2->type, "undefined"); 17831 r = iterIndexO(self); 17832 ck_assert_int_eq(r, 0); 17833 // end iteration 17834 r2 = iterNextO(self); 17835 ck_assert_ptr_eq(r2, NULL); 17836 r = iterIndexO(self); 17837 ck_assert_int_eq(r, -1); 17838 terminateO(self); 17839 17840 } 17841 17842 17843 void iterStepSmallArrayT(CuTest *tc UNUSED) { 17844 17845 int64_t r; 17846 baset* r2; 17847 smallArrayt *self = allocG(rtSmallArrayt); 17848 17849 // start iteration 17850 self->f->pushUndefined(self); 17851 r2 = iterStartO(self); 17852 ck_assert_ptr_ne(r2, NULL); 17853 ck_assert_str_eq(r2->type, "undefined"); 17854 r = iterStepO(self); 17855 ck_assert_int_eq(r, 1); 17856 // start iterator twice and 17857 // set step 17858 r2 =iterStartFromStepO(self, 0, 10); 17859 ck_assert_ptr_ne(r2, NULL); 17860 ck_assert_str_eq(r2->type, "undefined"); 17861 r = iterStepO(self); 17862 ck_assert_int_eq(r, 10); 17863 terminateO(self); 17864 17865 } 17866 17867 17868 void joinSmallArrayT(CuTest *tc UNUSED) { 17869 17870 smallStringt* r; 17871 smallArrayt *self = allocG(rtSmallArrayt); 17872 17873 // join non string objects 17874 self->f->pushUndefined(self); 17875 self->f->pushInt(self, 123); 17876 r = joinO(self, ";"); 17877 ck_assert_ptr_ne(r, NULL); 17878 char *s = toStringO(r); 17879 terminateO(r); 17880 ck_assert_str_eq(s, "null;123"); 17881 free(s); 17882 // join strings 17883 emptyO(self); 17884 self->f->pushS(self, "a"); 17885 self->f->pushS(self, "b"); 17886 self->f->pushS(self, "c"); 17887 self->f->pushS(self, "d"); 17888 delElemO(self, 1); 17889 r = joinO(self, ";"); 17890 ck_assert_ptr_ne(r, NULL); 17891 s = toStringO(r); 17892 terminateO(r); 17893 ck_assert_str_eq(s, "a;c;d"); 17894 free(s); 17895 // null delimiter 17896 r = joinO(self, NULL); 17897 ck_assert_ptr_eq(r, NULL); 17898 // empty array 17899 emptyO(self); 17900 r = joinO(self, ";"); 17901 ck_assert_ptr_eq(r, NULL); 17902 terminateO(self); 17903 17904 } 17905 17906 17907 void joinCharSmallArrayT(CuTest *tc UNUSED) { 17908 17909 smallStringt* r; 17910 smallArrayt *self = allocG(rtSmallArrayt); 17911 17912 // join non string objects 17913 self->f->pushUndefined(self); 17914 self->f->pushInt(self, 123); 17915 r = joinCharO(self, ';'); 17916 ck_assert_ptr_ne(r, NULL); 17917 char *s = toStringO(r); 17918 terminateO(r); 17919 ck_assert_str_eq(s, "null;123"); 17920 free(s); 17921 // join strings 17922 emptyO(self); 17923 self->f->pushS(self, "a"); 17924 self->f->pushS(self, "b"); 17925 self->f->pushS(self, "c"); 17926 self->f->pushS(self, "d"); 17927 delElemO(self, 1); 17928 r = joinCharO(self, ';'); 17929 ck_assert_ptr_ne(r, NULL); 17930 s = toStringO(r); 17931 terminateO(r); 17932 ck_assert_str_eq(s, "a;c;d"); 17933 free(s); 17934 // empty array 17935 emptyO(self); 17936 r = joinCharO(self, ';'); 17937 ck_assert_ptr_eq(r, NULL); 17938 terminateO(self); 17939 17940 } 17941 17942 17943 void joinSmallJsonSmallArrayT(CuTest *tc UNUSED) { 17944 17945 smallStringt* r; 17946 smallArrayt *self = allocG(rtSmallArrayt); 17947 smallJsont* delim = allocSmallJson(); 17948 17949 // join non string objects 17950 setTopSO(delim, ";"); 17951 self->f->pushUndefined(self); 17952 self->f->pushInt(self, 123); 17953 r = self->f->joinSmallJson(self, delim); 17954 ck_assert_ptr_ne(r, NULL); 17955 char *s = toStringO(r); 17956 terminateO(r); 17957 ck_assert_str_eq(s, "null;123"); 17958 free(s); 17959 // join strings 17960 emptyO(self); 17961 self->f->pushS(self, "a"); 17962 self->f->pushS(self, "b"); 17963 self->f->pushS(self, "c"); 17964 self->f->pushS(self, "d"); 17965 delElemO(self, 1); 17966 r = self->f->joinSmallJson(self, delim); 17967 ck_assert_ptr_ne(r, NULL); 17968 s = toStringO(r); 17969 terminateO(r); 17970 ck_assert_str_eq(s, "a;c;d"); 17971 free(s); 17972 // delimiter not a string 17973 freeO(delim); 17974 setTopIntO(delim, 1); 17975 r = self->f->joinSmallJson(self, delim); 17976 ck_assert_ptr_eq(r, NULL); 17977 // non smallJson object 17978 terminateO(delim); 17979 delim = (smallJsont*) allocSmallInt(2); 17980 r = self->f->joinSmallJson(self, delim); 17981 ck_assert_ptr_eq(r, NULL); 17982 // null delimiter 17983 r = self->f->joinSmallJson(self, NULL); 17984 ck_assert_ptr_eq(r, NULL); 17985 // empty array 17986 emptyO(self); 17987 freeO(delim); 17988 setTopSO(delim, ";"); 17989 r = self->f->joinSmallJson(self, delim); 17990 ck_assert_ptr_eq(r, NULL); 17991 terminateO(self); 17992 terminateO(delim); 17993 17994 } 17995 17996 17997 void joinSmallStringSmallArrayT(CuTest *tc UNUSED) { 17998 17999 smallStringt* r; 18000 smallArrayt *self = allocG(rtSmallArrayt); 18001 smallStringt* delim = allocSmallString(";"); 18002 18003 // join non string objects 18004 self->f->pushUndefined(self); 18005 self->f->pushInt(self, 123); 18006 r = joinSmallStringO(self, delim); 18007 ck_assert_ptr_ne(r, NULL); 18008 char *s = toStringO(r); 18009 terminateO(r); 18010 ck_assert_str_eq(s, "null;123"); 18011 free(s); 18012 // join strings 18013 emptyO(self); 18014 self->f->pushS(self, "a"); 18015 self->f->pushS(self, "b"); 18016 self->f->pushS(self, "c"); 18017 self->f->pushS(self, "d"); 18018 delElemO(self, 1); 18019 r = joinSmallStringO(self, delim); 18020 ck_assert_ptr_ne(r, NULL); 18021 s = toStringO(r); 18022 terminateO(r); 18023 ck_assert_str_eq(s, "a;c;d"); 18024 free(s); 18025 // delimiter with no string 18026 freeO(delim); 18027 r = joinSmallStringO(self, delim); 18028 ck_assert_ptr_eq(r, NULL); 18029 // null delimiter 18030 r = joinSmallStringO(self, NULL); 18031 ck_assert_ptr_eq(r, NULL); 18032 // empty array 18033 emptyO(self); 18034 setValO(delim, ";"); 18035 r = joinSmallStringO(self, delim); 18036 ck_assert_ptr_eq(r, NULL); 18037 terminateO(self); 18038 terminateO(delim); 18039 18040 } 18041 18042 18043 void joinSSmallArrayT(CuTest *tc UNUSED) { 18044 18045 char* r; 18046 smallArrayt *self = allocG(rtSmallArrayt); 18047 18048 // join non string objects 18049 self->f->pushUndefined(self); 18050 self->f->pushInt(self, 123); 18051 r = self->f->joinS(self, ";"); 18052 ck_assert_ptr_ne(r, NULL); 18053 ck_assert_str_eq(r, "null;123"); 18054 free(r); 18055 // join strings 18056 emptyO(self); 18057 self->f->pushS(self, "a"); 18058 self->f->pushS(self, "b"); 18059 self->f->pushS(self, "c"); 18060 self->f->pushS(self, "d"); 18061 delElemO(self, 1); 18062 r = self->f->joinS(self, ";"); 18063 ck_assert_ptr_ne(r, NULL); 18064 ck_assert_str_eq(r, "a;c;d"); 18065 free(r); 18066 // null delimiter 18067 r = self->f->joinS(self, NULL); 18068 ck_assert_ptr_eq(r, NULL); 18069 // empty array 18070 emptyO(self); 18071 r = self->f->joinS(self, ";"); 18072 ck_assert_ptr_eq(r, NULL); 18073 terminateO(self); 18074 18075 } 18076 18077 18078 void joinCharSSmallArrayT(CuTest *tc UNUSED) { 18079 18080 char* r; 18081 smallArrayt *self = allocG(rtSmallArrayt); 18082 18083 // join non string objects 18084 self->f->pushUndefined(self); 18085 self->f->pushInt(self, 123); 18086 r = joinCharSO(self, ';'); 18087 ck_assert_ptr_ne(r, NULL); 18088 ck_assert_str_eq(r, "null;123"); 18089 free(r); 18090 // join strings 18091 emptyO(self); 18092 self->f->pushS(self, "a"); 18093 self->f->pushS(self, "b"); 18094 self->f->pushS(self, "c"); 18095 self->f->pushS(self, "d"); 18096 delElemO(self, 1); 18097 r = joinCharSO(self, ';'); 18098 ck_assert_ptr_ne(r, NULL); 18099 ck_assert_str_eq(r, "a;c;d"); 18100 free(r); 18101 // empty array 18102 emptyO(self); 18103 r = joinCharSO(self, ';'); 18104 ck_assert_ptr_eq(r, NULL); 18105 terminateO(self); 18106 18107 } 18108 18109 18110 void joinSmallJsonSSmallArrayT(CuTest *tc UNUSED) { 18111 18112 char* r; 18113 smallArrayt *self = allocG(rtSmallArrayt); 18114 smallJsont* delim = allocSmallJson(); 18115 18116 // join non string objects 18117 setTopSO(delim, ";"); 18118 self->f->pushUndefined(self); 18119 self->f->pushInt(self, 123); 18120 r = joinSmallJsonSO(self, delim); 18121 ck_assert_ptr_ne(r, NULL); 18122 ck_assert_str_eq(r, "null;123"); 18123 free(r); 18124 // join strings 18125 emptyO(self); 18126 self->f->pushS(self, "a"); 18127 self->f->pushS(self, "b"); 18128 self->f->pushS(self, "c"); 18129 self->f->pushS(self, "d"); 18130 delElemO(self, 1); 18131 r = joinSmallJsonSO(self, delim); 18132 ck_assert_ptr_ne(r, NULL); 18133 ck_assert_str_eq(r, "a;c;d"); 18134 free(r); 18135 // delimiter not a string 18136 freeO(delim); 18137 setTopIntO(delim, 1); 18138 r = joinSmallJsonSO(self, delim); 18139 ck_assert_ptr_eq(r, NULL); 18140 // non smallJson object 18141 terminateO(delim); 18142 delim = (smallJsont*) allocSmallInt(2); 18143 r = joinSmallJsonSO(self, delim); 18144 ck_assert_ptr_eq(r, NULL); 18145 // null delimiter 18146 r = joinSmallJsonSO(self, NULL); 18147 ck_assert_ptr_eq(r, NULL); 18148 // empty array 18149 emptyO(self); 18150 freeO(delim); 18151 setTopSO(delim, ";"); 18152 r = joinSmallJsonSO(self, delim); 18153 ck_assert_ptr_eq(r, NULL); 18154 terminateO(self); 18155 terminateO(delim); 18156 18157 } 18158 18159 18160 void joinSmallStringSSmallArrayT(CuTest *tc UNUSED) { 18161 18162 char* r; 18163 smallArrayt *self = allocG(rtSmallArrayt); 18164 smallStringt* delim = allocSmallString(";"); 18165 18166 // join non string objects 18167 self->f->pushUndefined(self); 18168 self->f->pushInt(self, 123); 18169 r = joinSmallStringSO(self, delim); 18170 ck_assert_ptr_ne(r, NULL); 18171 ck_assert_str_eq(r, "null;123"); 18172 free(r); 18173 // join strings 18174 emptyO(self); 18175 self->f->pushS(self, "a"); 18176 self->f->pushS(self, "b"); 18177 self->f->pushS(self, "c"); 18178 self->f->pushS(self, "d"); 18179 delElemO(self, 1); 18180 r = joinSmallStringSO(self, delim); 18181 ck_assert_ptr_ne(r, NULL); 18182 ck_assert_str_eq(r, "a;c;d"); 18183 free(r); 18184 // delimiter with no string 18185 freeO(delim); 18186 r = joinSmallStringSO(self, delim); 18187 ck_assert_ptr_eq(r, NULL); 18188 // null delimiter 18189 r = joinSmallStringSO(self, NULL); 18190 ck_assert_ptr_eq(r, NULL); 18191 // empty array 18192 emptyO(self); 18193 setValO(delim, ";"); 18194 r = joinSmallStringSO(self, delim); 18195 ck_assert_ptr_eq(r, NULL); 18196 terminateO(self); 18197 terminateO(delim); 18198 18199 } 18200 18201 18202 void zipSmallArrayT(CuTest *tc UNUSED) { 18203 18204 smallArrayt* r; 18205 smallArrayt *self = allocG(rtSmallArrayt); 18206 smallArrayt *array1 = allocSmallArray(); 18207 smallArrayt *array2 = allocSmallArray(); 18208 18209 // zip arrays 18210 // add an element to self 18211 // array1 has 2 elements 18212 // array2 has 3 elements 18213 // only 2 elements are zipped 18214 self->f->pushS(self, "qwe"); 18215 array1->f->pushS(array1, "a"); 18216 array1->f->pushS(array1, "b"); 18217 array2->f->pushInt(array2, 1); 18218 array2->f->pushInt(array2, 2); 18219 array2->f->pushInt(array2, 3); 18220 r = zipO(self, array1, array2); 18221 ck_assert_ptr_ne(r, NULL); 18222 char *s = toStringO(r); 18223 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18224 free(s); 18225 // delete the element not in self 18226 delElemO(array2, 2); 18227 // empty arrays 18228 disposeO(array2); 18229 r = zipO(self, array1, array2); 18230 ck_assert_ptr_ne(r, NULL); 18231 s = toStringO(r); 18232 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18233 free(s); 18234 disposeO(array1); 18235 r = zipO(self, array1, array2); 18236 ck_assert_ptr_ne(r, NULL); 18237 s = toStringO(r); 18238 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18239 free(s); 18240 // array1 and array2 same element count 18241 array1->f->pushS(array1, "aa"); 18242 array1->f->pushS(array1, "bb"); 18243 array2->f->pushInt(array2, 11); 18244 array2->f->pushInt(array2, 22); 18245 delElemO(array1, 1); 18246 r = zipO(self, array1, array2); 18247 delElemO(array2, 1); 18248 ck_assert_ptr_ne(r, NULL); 18249 // some elements were zipped 18250 s = toStringO(self); 18251 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18252 free(s); 18253 // but an element is NULL 18254 // non smallArray objects 18255 smashO(array1); 18256 array1 = (smallArrayt*) allocSmallInt(2); 18257 r = zipO(self, array1, array2); 18258 ck_assert_ptr_eq(r, NULL); 18259 terminateO(array1); 18260 array1 = allocSmallArray(); 18261 smashO(array2); 18262 array2 = (smallArrayt*) allocSmallInt(2); 18263 r = zipO(self, array1, array2); 18264 ck_assert_ptr_eq(r, NULL); 18265 terminateO(array2); 18266 array2 = allocSmallArray(); 18267 // NULL arrays 18268 r = zipO(self, NULL, array2); 18269 ck_assert_ptr_eq(r, NULL); 18270 r = zipO(self, array1, NULL); 18271 ck_assert_ptr_eq(r, NULL); 18272 terminateO(self); 18273 smashO(array1); 18274 smashO(array2); 18275 18276 } 18277 18278 18279 void zipSmallJsonSmallArrayT(CuTest *tc UNUSED) { 18280 18281 smallArrayt* r; 18282 smallArrayt *self = allocG(rtSmallArrayt); 18283 smallArrayt *array1 = allocSmallArray(); 18284 smallJsont *array2 = allocSmallJson(); 18285 18286 // zip arrays 18287 // add an element to self 18288 // array1 has 2 elements 18289 // array2 has 3 elements 18290 // only 2 elements are zipped 18291 self->f->pushS(self, "qwe"); 18292 array1->f->pushS(array1, "a"); 18293 array1->f->pushS(array1, "b"); 18294 array2->f->pushInt(array2, 1); 18295 array2->f->pushInt(array2, 2); 18296 array2->f->pushInt(array2, 3); 18297 r = self->f->zipSmallJson(self, array1, array2); 18298 ck_assert_ptr_ne(r, NULL); 18299 char *s = toStringO(r); 18300 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18301 free(s); 18302 // delete the element not in self 18303 delElemIndexO(array2, 2); 18304 // empty arrays 18305 disposeO(array1); 18306 r = self->f->zipSmallJson(self, array1, array2); 18307 ck_assert_ptr_ne(r, NULL); 18308 s = toStringO(r); 18309 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18310 free(s); 18311 disposeO(array2); 18312 r = self->f->zipSmallJson(self, array1, array2); 18313 ck_assert_ptr_eq(r, NULL); 18314 // array1 and array2 same element count 18315 array1->f->pushS(array1, "aa"); 18316 array1->f->pushS(array1, "bb"); 18317 array2->f->pushInt(array2, 11); 18318 array2->f->pushInt(array2, 22); 18319 delElemO(array1, 1); 18320 r = self->f->zipSmallJson(self, array1, array2); 18321 delElemIndexO(array2, 1); 18322 ck_assert_ptr_ne(r, NULL); 18323 // some elements were zipped 18324 s = toStringO(self); 18325 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18326 free(s); 18327 // but an element is NULL 18328 // non smallArray objects 18329 smashO(array1); 18330 array1 = (smallArrayt*) allocSmallInt(2); 18331 r = self->f->zipSmallJson(self, array1, array2); 18332 ck_assert_ptr_eq(r, NULL); 18333 terminateO(array1); 18334 array1 = allocSmallArray(); 18335 smashO(array2); 18336 array2 = (smallJsont*) allocSmallInt(2); 18337 r = self->f->zipSmallJson(self, array1, array2); 18338 ck_assert_ptr_eq(r, NULL); 18339 terminateO(array2); 18340 array2 = allocSmallJson(); 18341 // NULL arrays 18342 r = self->f->zipSmallJson(self, NULL, array2); 18343 ck_assert_ptr_eq(r, NULL); 18344 r = self->f->zipSmallJson(self, array1, NULL); 18345 ck_assert_ptr_eq(r, NULL); 18346 terminateO(self); 18347 smashO(array1); 18348 smashO(array2); 18349 18350 } 18351 18352 18353 void zipSmallJsonSmallArraySmallArrayT(CuTest *tc UNUSED) { 18354 18355 smallArrayt* r; 18356 smallArrayt *self = allocG(rtSmallArrayt); 18357 smallJsont *array1 = allocSmallJson(); 18358 smallArrayt *array2 = allocSmallArray(); 18359 18360 // zip arrays 18361 // add an element to self 18362 // array1 has 2 elements 18363 // array2 has 3 elements 18364 // only 2 elements are zipped 18365 self->f->pushS(self, "qwe"); 18366 array1->f->pushS(array1, "a"); 18367 array1->f->pushS(array1, "b"); 18368 array2->f->pushInt(array2, 1); 18369 array2->f->pushInt(array2, 2); 18370 array2->f->pushInt(array2, 3); 18371 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18372 ck_assert_ptr_ne(r, NULL); 18373 char *s = toStringO(r); 18374 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18375 free(s); 18376 // delete the element not in self 18377 delElemO(array2, 2); 18378 // empty arrays 18379 disposeO(array2); 18380 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18381 ck_assert_ptr_ne(r, NULL); 18382 s = toStringO(r); 18383 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18384 free(s); 18385 disposeO(array1); 18386 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18387 ck_assert_ptr_eq(r, NULL); 18388 // array1 and array2 same element count 18389 array1->f->pushS(array1, "aa"); 18390 array1->f->pushS(array1, "bb"); 18391 array2->f->pushInt(array2, 11); 18392 array2->f->pushInt(array2, 22); 18393 delElemIndexO(array1, 1); 18394 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18395 delElemO(array2, 1); 18396 ck_assert_ptr_ne(r, NULL); 18397 // some elements were zipped 18398 s = toStringO(self); 18399 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18400 free(s); 18401 // but an element is NULL 18402 // non smallArray objects 18403 smashO(array1); 18404 array1 = (smallJsont*) allocSmallInt(2); 18405 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18406 ck_assert_ptr_eq(r, NULL); 18407 terminateO(array1); 18408 array1 = allocSmallJson(); 18409 smashO(array2); 18410 array2 = (smallArrayt*) allocSmallInt(2); 18411 r = self->f->zipSmallJsonSmallArray(self, array1, array2); 18412 ck_assert_ptr_eq(r, NULL); 18413 terminateO(array2); 18414 array2 = allocSmallArray(); 18415 // NULL arrays 18416 r = self->f->zipSmallJsonSmallArray(self, NULL, array2); 18417 ck_assert_ptr_eq(r, NULL); 18418 r = self->f->zipSmallJsonSmallArray(self, array1, NULL); 18419 ck_assert_ptr_eq(r, NULL); 18420 terminateO(self); 18421 smashO(array1); 18422 smashO(array2); 18423 18424 } 18425 18426 18427 void zipSmallJsonSmallJsonSmallArrayT(CuTest *tc UNUSED) { 18428 18429 smallArrayt* r; 18430 smallArrayt *self = allocG(rtSmallArrayt); 18431 smallJsont *array1 = allocSmallJson(); 18432 smallJsont *array2 = allocSmallJson(); 18433 18434 // zip arrays 18435 // add an element to self 18436 // array1 has 2 elements 18437 // array2 has 3 elements 18438 // only 2 elements are zipped 18439 self->f->pushS(self, "qwe"); 18440 array1->f->pushS(array1, "a"); 18441 array1->f->pushS(array1, "b"); 18442 array2->f->pushInt(array2, 1); 18443 array2->f->pushInt(array2, 2); 18444 array2->f->pushInt(array2, 3); 18445 r = zipSmallJsonSmallJsonO(self, array1, array2); 18446 ck_assert_ptr_ne(r, NULL); 18447 char *s = toStringO(r); 18448 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18449 free(s); 18450 // delete the element not in self 18451 delElemIndexO(array2, 2); 18452 // empty arrays 18453 disposeO(array1); 18454 r = zipSmallJsonSmallJsonO(self, array1, array2); 18455 ck_assert_ptr_eq(r, NULL); 18456 disposeO(array2); 18457 array1->f->pushS(array1, "a"); 18458 r = zipSmallJsonSmallJsonO(self, array1, array2); 18459 ck_assert_ptr_eq(r, NULL); 18460 array2->f->pushInt(array2, 1); 18461 delElemIndexO(array2, 0); 18462 r = zipSmallJsonSmallJsonO(self, array1, array2); 18463 ck_assert_ptr_ne(r, NULL); 18464 s = toStringO(r); 18465 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"a\"]]"); 18466 free(s); 18467 disposeO(array1); 18468 trimO(array2); 18469 // array1 and array2 same element count 18470 array1->f->pushS(array1, "aa"); 18471 array1->f->pushS(array1, "bb"); 18472 array2->f->pushInt(array2, 11); 18473 array2->f->pushInt(array2, 22); 18474 delElemIndexO(array1, 1); 18475 r = zipSmallJsonSmallJsonO(self, array1, array2); 18476 delElemIndexO(array2, 1); 18477 ck_assert_ptr_ne(r, NULL); 18478 // some elements were zipped 18479 s = toStringO(self); 18480 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"a\"],[\"aa\",11]]"); 18481 free(s); 18482 // but an element is NULL 18483 // non smallJson objects 18484 smashO(array1); 18485 array1 = (smallJsont*) allocSmallInt(2); 18486 r = zipSmallJsonSmallJsonO(self, array1, array2); 18487 ck_assert_ptr_eq(r, NULL); 18488 terminateO(array1); 18489 array1 = allocSmallJson(); 18490 smashO(array2); 18491 array2 = (smallJsont*) allocSmallInt(2); 18492 r = zipSmallJsonSmallJsonO(self, array1, array2); 18493 ck_assert_ptr_eq(r, NULL); 18494 terminateO(array2); 18495 array2 = allocSmallJson(); 18496 // NULL arrays 18497 r = zipSmallJsonSmallJsonO(self, NULL, array2); 18498 ck_assert_ptr_eq(r, NULL); 18499 r = zipSmallJsonSmallJsonO(self, array1, NULL); 18500 ck_assert_ptr_eq(r, NULL); 18501 terminateO(self); 18502 smashO(array1); 18503 smashO(array2); 18504 18505 } 18506 18507 18508 void zipSmallJsonCharSmallArrayT(CuTest *tc UNUSED) { 18509 18510 smallArrayt* r; 18511 smallArrayt *self = allocG(rtSmallArrayt); 18512 smallJsont *array1 = allocSmallJson(); 18513 char **array2; 18514 18515 // zip arrays 18516 // add an element to self 18517 // array1 has 2 elements 18518 // array2 has 3 elements 18519 // only 2 elements are zipped 18520 self->f->pushS(self, "qwe"); 18521 array1->f->pushS(array1, "a"); 18522 array1->f->pushS(array1, "b"); 18523 array2 = listCreateS("1", "2", "3"); 18524 r = zipSmallJsonCharO(self, array1, array2); 18525 ck_assert_ptr_ne(r, NULL); 18526 char *s = toStringO(r); 18527 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18528 free(s); 18529 // delete the element not in self 18530 iListDelElemS(&array2, 2); 18531 // empty arrays 18532 iListRemoveS(&array2, 0, 2); 18533 r = zipSmallJsonCharO(self, array1, array2); 18534 ck_assert_ptr_ne(r, NULL); 18535 s = toStringO(r); 18536 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18537 free(s); 18538 disposeO(array1); 18539 r = zipSmallJsonCharO(self, array1, array2); 18540 ck_assert_ptr_eq(r, NULL); 18541 free(array2); 18542 // array1 and array2 same element count 18543 array1->f->pushS(array1, "aa"); 18544 array1->f->pushS(array1, "bb"); 18545 array2 = listCreateS("11", "22"); 18546 delElemIndexO(array1, 1); 18547 r = zipSmallJsonCharO(self, array1, array2); 18548 iListDelElemS(&array2, 1); 18549 ck_assert_ptr_ne(r, NULL); 18550 // some elements were zipped 18551 s = toStringO(self); 18552 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 18553 free(s); 18554 // but an element is NULL 18555 // non smallJson objects 18556 smashO(array1); 18557 array1 = (smallJsont*) allocSmallInt(2); 18558 r = zipSmallJsonCharO(self, array1, array2); 18559 ck_assert_ptr_eq(r, NULL); 18560 terminateO(array1); 18561 array1 = allocSmallJson(); 18562 // NULL arrays 18563 r = zipSmallJsonCharO(self, NULL, array2); 18564 ck_assert_ptr_eq(r, NULL); 18565 r = zipSmallJsonCharO(self, array1, NULL); 18566 ck_assert_ptr_eq(r, NULL); 18567 terminateO(self); 18568 smashO(array1); 18569 free(array2); 18570 18571 } 18572 18573 18574 void zipSmallJsonCCharSmallArrayT(CuTest *tc UNUSED) { 18575 18576 smallArrayt* r; 18577 smallArrayt *self = allocG(rtSmallArrayt); 18578 smallJsont *array1 = allocSmallJson(); 18579 const char* array2[] = {"1", "2", "3", null}; 18580 18581 // zip arrays 18582 // add an element to self 18583 // array1 has 2 elements 18584 // array2 has 3 elements 18585 // only 2 elements are zipped 18586 self->f->pushS(self, "qwe"); 18587 array1->f->pushS(array1, "a"); 18588 array1->f->pushS(array1, "b"); 18589 r = self->f->zipSmallJsonCChar(self, array1, array2); 18590 ck_assert_ptr_ne(r, NULL); 18591 char *s = toStringO(r); 18592 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18593 free(s); 18594 // empty arrays 18595 const char* array22[] = {null}; 18596 r = self->f->zipSmallJsonCChar(self, array1, array22); 18597 ck_assert_ptr_ne(r, NULL); 18598 s = toStringO(r); 18599 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18600 free(s); 18601 disposeO(array1); 18602 r = self->f->zipSmallJsonCChar(self, array1, array2); 18603 ck_assert_ptr_eq(r, NULL); 18604 // array1 and array2 same element count 18605 array1->f->pushS(array1, "aa"); 18606 array1->f->pushS(array1, "bb"); 18607 const char* array222[] = {"11", "22", null}; 18608 delElemIndexO(array1, 1); 18609 r = self->f->zipSmallJsonCChar(self, array1, array222); 18610 ck_assert_ptr_ne(r, NULL); 18611 // some elements were zipped 18612 s = toStringO(self); 18613 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 18614 free(s); 18615 // but an element is NULL 18616 // non smallJson objects 18617 smashO(array1); 18618 array1 = (smallJsont*) allocSmallInt(2); 18619 r = zipSmallJsonCCharO(self, array1, array2); 18620 ck_assert_ptr_eq(r, NULL); 18621 terminateO(array1); 18622 array1 = allocSmallJson(); 18623 // NULL arrays 18624 r = self->f->zipSmallJsonCChar(self, NULL, array2); 18625 ck_assert_ptr_eq(r, NULL); 18626 r = self->f->zipSmallJsonCChar(self, array1, NULL); 18627 ck_assert_ptr_eq(r, NULL); 18628 terminateO(self); 18629 smashO(array1); 18630 18631 } 18632 18633 18634 void zipArraySmallArrayT(CuTest *tc UNUSED) { 18635 18636 smallArrayt* r; 18637 smallArrayt *self = allocG(rtSmallArrayt); 18638 char** array1; 18639 smallArrayt *array2 = allocSmallArray(); 18640 18641 // zip arrays 18642 // add an element to self 18643 // array1 has 2 elements 18644 // array2 has 3 elements 18645 // only 2 elements are zipped 18646 self->f->pushS(self, "qwe"); 18647 array1 = listCreateS("a", "b"); 18648 array2->f->pushInt(array2, 1); 18649 array2->f->pushInt(array2, 2); 18650 array2->f->pushInt(array2, 3); 18651 r = zipArrayO(self, array1, array2); 18652 ck_assert_ptr_ne(r, NULL); 18653 char *s = toStringO(r); 18654 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18655 free(s); 18656 // delete the element not in self 18657 delElemO(array2, 2); 18658 // empty arrays 18659 disposeO(array2); 18660 r = zipArrayO(self, array1, array2); 18661 ck_assert_ptr_ne(r, NULL); 18662 s = toStringO(r); 18663 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18664 free(s); 18665 iListRemoveS(&array1, 0, 2); 18666 r = zipArrayO(self, array1, array2); 18667 free(array1); 18668 ck_assert_ptr_ne(r, NULL); 18669 s = toStringO(r); 18670 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18671 free(s); 18672 // array1 and array2 same element count 18673 array1 = listCreateS("aa", "bb"); 18674 array2->f->pushInt(array2, 11); 18675 array2->f->pushInt(array2, 22); 18676 iListDelElemS(&array1, 1); 18677 r = zipArrayO(self, array1, array2); 18678 delElemO(array2, 1); 18679 ck_assert_ptr_ne(r, NULL); 18680 // some elements were zipped 18681 s = toStringO(self); 18682 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18683 free(s); 18684 // but an element is NULL 18685 // non smallArray objects 18686 smashO(array2); 18687 array2 = (smallArrayt*) allocSmallInt(2); 18688 r = zipArrayO(self, array1, array2); 18689 ck_assert_ptr_eq(r, NULL); 18690 terminateO(array2); 18691 array2 = allocSmallArray(); 18692 // NULL arrays 18693 r = zipArrayO(self, NULL, array2); 18694 ck_assert_ptr_eq(r, NULL); 18695 r = zipArrayO(self, array1, NULL); 18696 ck_assert_ptr_eq(r, NULL); 18697 terminateO(self); 18698 free(array1); 18699 smashO(array2); 18700 18701 } 18702 18703 18704 void zipCArraySmallArrayT(CuTest *tc UNUSED) { 18705 18706 smallArrayt* r; 18707 smallArrayt *self = allocG(rtSmallArrayt); 18708 const char* array1[] = {"a", "b", null}; 18709 smallArrayt *array2 = allocSmallArray(); 18710 18711 // zip arrays 18712 // add an element to self 18713 // array1 has 2 elements 18714 // array2 has 3 elements 18715 // only 2 elements are zipped 18716 self->f->pushS(self, "qwe"); 18717 array2->f->pushInt(array2, 1); 18718 array2->f->pushInt(array2, 2); 18719 array2->f->pushInt(array2, 3); 18720 r = self->f->zipCArray(self, array1, array2); 18721 ck_assert_ptr_ne(r, NULL); 18722 char *s = toStringO(r); 18723 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18724 free(s); 18725 // delete the element not in self 18726 delElemO(array2, 2); 18727 // empty arrays 18728 disposeO(array2); 18729 r = self->f->zipCArray(self, array1, array2); 18730 ck_assert_ptr_ne(r, NULL); 18731 s = toStringO(r); 18732 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18733 free(s); 18734 const char* array11[] = {null}; 18735 r = self->f->zipCArray(self, array11, array2); 18736 ck_assert_ptr_ne(r, NULL); 18737 s = toStringO(r); 18738 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18739 free(s); 18740 // array1 and array2 same element count 18741 const char* array111[] = {"aa", null}; 18742 array2->f->pushInt(array2, 11); 18743 array2->f->pushInt(array2, 22); 18744 r = self->f->zipCArray(self, array111, array2); 18745 delElemO(array2, 1); 18746 ck_assert_ptr_ne(r, NULL); 18747 // some elements were zipped 18748 s = toStringO(self); 18749 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18750 free(s); 18751 // but an element is NULL 18752 // non smallArray objects 18753 smashO(array2); 18754 array2 = (smallArrayt*) allocSmallInt(2); 18755 r = self->f->zipCArray(self, array1, array2); 18756 ck_assert_ptr_eq(r, NULL); 18757 terminateO(array2); 18758 array2 = allocSmallArray(); 18759 // NULL arrays 18760 r = self->f->zipCArray(self, NULL, array2); 18761 ck_assert_ptr_eq(r, NULL); 18762 r = self->f->zipCArray(self, array1, NULL); 18763 ck_assert_ptr_eq(r, NULL); 18764 terminateO(self); 18765 smashO(array2); 18766 18767 } 18768 18769 18770 void zipArraySmallJsonSmallArrayT(CuTest *tc UNUSED) { 18771 18772 smallArrayt* r; 18773 smallArrayt *self = allocG(rtSmallArrayt); 18774 char** array1; 18775 smallJsont *array2 = allocSmallJson(); 18776 18777 // zip arrays 18778 // add an element to self 18779 // array1 has 2 elements 18780 // array2 has 3 elements 18781 // only 2 elements are zipped 18782 self->f->pushS(self, "qwe"); 18783 array1 = listCreateS("a", "b"); 18784 array2->f->pushInt(array2, 1); 18785 array2->f->pushInt(array2, 2); 18786 array2->f->pushInt(array2, 3); 18787 r = self->f->zipArraySmallJson(self, array1, array2); 18788 ck_assert_ptr_ne(r, NULL); 18789 char *s = toStringO(r); 18790 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18791 free(s); 18792 // delete the element not in self 18793 delElemIndexO(array2, 2); 18794 // empty arrays 18795 iListRemoveS(&array1, 0, 2); 18796 r = self->f->zipArraySmallJson(self, array1, array2); 18797 ck_assert_ptr_ne(r, NULL); 18798 s = toStringO(r); 18799 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18800 free(s); 18801 disposeO(array2); 18802 r = self->f->zipArraySmallJson(self, array1, array2); 18803 free(array1); 18804 ck_assert_ptr_eq(r, NULL); 18805 // array1 and array2 same element count 18806 array1 = listCreateS("aa", "bb"); 18807 array2->f->pushInt(array2, 11); 18808 array2->f->pushInt(array2, 22); 18809 iListDelElemS(&array1, 1); 18810 r = self->f->zipArraySmallJson(self, array1, array2); 18811 delElemIndexO(array2, 1); 18812 ck_assert_ptr_ne(r, NULL); 18813 // some elements were zipped 18814 s = toStringO(self); 18815 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18816 free(s); 18817 // but an element is NULL 18818 // non smallJson object 18819 smashO(array2); 18820 array2 = (smallJsont*) allocSmallInt(2); 18821 r = self->f->zipArraySmallJson(self, array1, array2); 18822 ck_assert_ptr_eq(r, NULL); 18823 terminateO(array2); 18824 array2 = allocSmallJson(); 18825 // NULL arrays 18826 r = self->f->zipArraySmallJson(self, NULL, array2); 18827 ck_assert_ptr_eq(r, NULL); 18828 r = self->f->zipArraySmallJson(self, array1, NULL); 18829 ck_assert_ptr_eq(r, NULL); 18830 terminateO(self); 18831 free(array1); 18832 smashO(array2); 18833 18834 } 18835 18836 18837 void zipCArraySmallJsonSmallArrayT(CuTest *tc UNUSED) { 18838 18839 smallArrayt* r; 18840 smallArrayt *self = allocG(rtSmallArrayt); 18841 const char* array1[] = {"a", "b", null}; 18842 smallJsont *array2 = allocSmallJson(); 18843 18844 // zip arrays 18845 // add an element to self 18846 // array1 has 2 elements 18847 // array2 has 3 elements 18848 // only 2 elements are zipped 18849 self->f->pushS(self, "qwe"); 18850 array2->f->pushInt(array2, 1); 18851 array2->f->pushInt(array2, 2); 18852 array2->f->pushInt(array2, 3); 18853 r = self->f->zipCArraySmallJson(self, array1, array2); 18854 ck_assert_ptr_ne(r, NULL); 18855 char *s = toStringO(r); 18856 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18857 free(s); 18858 // delete the element not in self 18859 delElemIndexO(array2, 2); 18860 // empty arrays 18861 const char* array11[] = {null}; 18862 r = self->f->zipCArraySmallJson(self, array11, array2); 18863 ck_assert_ptr_ne(r, NULL); 18864 s = toStringO(r); 18865 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 18866 free(s); 18867 disposeO(array2); 18868 r = self->f->zipCArraySmallJson(self, array1, array2); 18869 ck_assert_ptr_eq(r, NULL); 18870 // array1 and array2 same element count 18871 const char *array111[] = {"aa", null}; 18872 array2->f->pushInt(array2, 11); 18873 array2->f->pushInt(array2, 22); 18874 r = self->f->zipCArraySmallJson(self, array111, array2); 18875 delElemIndexO(array2, 1); 18876 ck_assert_ptr_ne(r, NULL); 18877 // some elements were zipped 18878 s = toStringO(self); 18879 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]"); 18880 free(s); 18881 // but an element is NULL 18882 // non smallJson object 18883 smashO(array2); 18884 array2 = (smallJsont*) allocSmallInt(2); 18885 r = self->f->zipCArraySmallJson(self, array1, array2); 18886 ck_assert_ptr_eq(r, NULL); 18887 terminateO(array2); 18888 array2 = allocSmallJson(); 18889 // NULL arrays 18890 r = self->f->zipCArraySmallJson(self, NULL, array2); 18891 ck_assert_ptr_eq(r, NULL); 18892 r = self->f->zipCArraySmallJson(self, array1, NULL); 18893 ck_assert_ptr_eq(r, NULL); 18894 terminateO(self); 18895 smashO(array2); 18896 18897 } 18898 18899 18900 void zipCharSmallArrayT(CuTest *tc UNUSED) { 18901 18902 smallArrayt* r; 18903 smallArrayt *self = allocG(rtSmallArrayt); 18904 smallArrayt *array1 = allocSmallArray(); 18905 char** array2; 18906 18907 // zip arrays 18908 // add an element to self 18909 // array1 has 2 elements 18910 // array2 has 3 elements 18911 // only 2 elements are zipped 18912 self->f->pushS(self, "qwe"); 18913 array1->f->pushS(array1, "a"); 18914 array1->f->pushS(array1, "b"); 18915 array2 = listCreateS("1", "2", "3"); 18916 r = zipCharO(self, array1, array2); 18917 ck_assert_ptr_ne(r, NULL); 18918 char *s = toStringO(r); 18919 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18920 free(s); 18921 // delete the element not in self 18922 iListDelElemS(&array2, 2); 18923 // empty arrays 18924 iListRemoveS(&array2, 0, 2); 18925 r = zipCharO(self, array1, array2); 18926 ck_assert_ptr_ne(r, NULL); 18927 s = toStringO(r); 18928 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18929 free(s); 18930 disposeO(array1); 18931 r = zipCharO(self, array1, array2); 18932 ck_assert_ptr_ne(r, NULL); 18933 s = toStringO(r); 18934 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18935 free(s); 18936 free(array2); 18937 // array1 and array2 same element count 18938 array1->f->pushS(array1, "aa"); 18939 array1->f->pushS(array1, "bb"); 18940 array2 = listCreateS("11", "22"); 18941 delElemO(array1, 1); 18942 r = zipCharO(self, array1, array2); 18943 iListDelElemS(&array2, 1); 18944 ck_assert_ptr_ne(r, NULL); 18945 // some elements were zipped 18946 s = toStringO(self); 18947 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 18948 free(s); 18949 // but an element is NULL 18950 // non smallJson objects 18951 smashO(array1); 18952 array1 = (smallArrayt*) allocSmallInt(2); 18953 r = zipCharO(self, array1, array2); 18954 ck_assert_ptr_eq(r, NULL); 18955 terminateO(array1); 18956 array1 = allocSmallArray(); 18957 // NULL arrays 18958 r = zipCharO(self, NULL, array2); 18959 ck_assert_ptr_eq(r, NULL); 18960 r = zipCharO(self, array1, NULL); 18961 ck_assert_ptr_eq(r, NULL); 18962 terminateO(self); 18963 smashO(array1); 18964 free(array2); 18965 18966 } 18967 18968 18969 void zipCCharSmallArrayT(CuTest *tc UNUSED) { 18970 18971 smallArrayt* r; 18972 smallArrayt *self = allocG(rtSmallArrayt); 18973 smallArrayt *array1 = allocSmallArray(); 18974 const char* array2[] = {"1", "2", "3", null}; 18975 18976 // zip arrays 18977 // add an element to self 18978 // array1 has 2 elements 18979 // array2 has 3 elements 18980 // only 2 elements are zipped 18981 self->f->pushS(self, "qwe"); 18982 array1->f->pushS(array1, "a"); 18983 array1->f->pushS(array1, "b"); 18984 r = self->f->zipCChar(self, array1, array2); 18985 ck_assert_ptr_ne(r, NULL); 18986 char *s = toStringO(r); 18987 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18988 free(s); 18989 // delete the element not in self 18990 // empty arrays 18991 const char* array22[] = {null}; 18992 r = self->f->zipCChar(self, array1, array22); 18993 ck_assert_ptr_ne(r, NULL); 18994 s = toStringO(r); 18995 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 18996 free(s); 18997 disposeO(array1); 18998 r = self->f->zipCChar(self, array1, array2); 18999 ck_assert_ptr_ne(r, NULL); 19000 s = toStringO(r); 19001 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19002 free(s); 19003 // array1 and array2 same element count 19004 array1->f->pushS(array1, "aa"); 19005 array1->f->pushS(array1, "bb"); 19006 const char* array222[] = {"11", "22", null}; 19007 delElemO(array1, 1); 19008 r = self->f->zipCChar(self, array1, array222); 19009 ck_assert_ptr_ne(r, NULL); 19010 // some elements were zipped 19011 s = toStringO(self); 19012 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19013 free(s); 19014 // but an element is NULL 19015 // non smallJson objects 19016 smashO(array1); 19017 array1 = (smallArrayt*) allocSmallInt(2); 19018 r = self->f->zipCChar(self, array1, array2); 19019 ck_assert_ptr_eq(r, NULL); 19020 terminateO(array1); 19021 array1 = allocSmallArray(); 19022 // NULL arrays 19023 r = self->f->zipCChar(self, NULL, array2); 19024 ck_assert_ptr_eq(r, NULL); 19025 r = self->f->zipCChar(self, array1, NULL); 19026 ck_assert_ptr_eq(r, NULL); 19027 terminateO(self); 19028 smashO(array1); 19029 19030 } 19031 19032 19033 void zipArrayCharSmallArrayT(CuTest *tc UNUSED) { 19034 19035 smallArrayt* r; 19036 smallArrayt *self = allocG(rtSmallArrayt); 19037 char** array1; 19038 char** array2; 19039 19040 // zip arrays 19041 // add an element to self 19042 // array1 has 2 elements 19043 // array2 has 3 elements 19044 // only 2 elements are zipped 19045 self->f->pushS(self, "qwe"); 19046 array1 = listCreateS("a", "b"); 19047 array2 = listCreateS("1", "2", "3"); 19048 r = zipArrayCharO(self, array1, array2); 19049 ck_assert_ptr_ne(r, NULL); 19050 char *s = toStringO(r); 19051 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19052 free(s); 19053 // delete the element not in self 19054 iListDelElemS(&array2, 2); 19055 // empty arrays 19056 iListRemoveS(&array2, 0, 2); 19057 r = zipArrayCharO(self, array1, array2); 19058 ck_assert_ptr_ne(r, NULL); 19059 s = toStringO(r); 19060 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19061 free(s); 19062 iListRemoveS(&array1, 0, 2); 19063 r = zipArrayCharO(self, array1, array2); 19064 ck_assert_ptr_ne(r, NULL); 19065 s = toStringO(r); 19066 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19067 free(s); 19068 free(array1); 19069 free(array2); 19070 // array1 and array2 same element count 19071 array1 = listCreateS("aa", "bb"); 19072 array2 = listCreateS("11", "22"); 19073 iListDelElemS(&array1, 1); 19074 r = zipArrayCharO(self, array1, array2); 19075 iListDelElemS(&array2, 1); 19076 ck_assert_ptr_ne(r, NULL); 19077 // some elements were zipped 19078 s = toStringO(self); 19079 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19080 free(s); 19081 // but an element is NULL 19082 // NULL arrays 19083 r = zipArrayCharO(self, NULL, array2); 19084 ck_assert_ptr_eq(r, NULL); 19085 r = zipArrayCharO(self, array1, NULL); 19086 ck_assert_ptr_eq(r, NULL); 19087 terminateO(self); 19088 free(array1); 19089 free(array2); 19090 19091 } 19092 19093 19094 void zipCArrayCharSmallArrayT(CuTest *tc UNUSED) { 19095 19096 smallArrayt* r; 19097 smallArrayt *self = allocG(rtSmallArrayt); 19098 const char* array1[] = {"a", "b", null}; 19099 char** array2; 19100 19101 // zip arrays 19102 // add an element to self 19103 // array1 has 2 elements 19104 // array2 has 3 elements 19105 // only 2 elements are zipped 19106 self->f->pushS(self, "qwe"); 19107 array2 = listCreateS("1", "2", "3"); 19108 r = self->f->zipCArrayChar(self, array1, array2); 19109 ck_assert_ptr_ne(r, NULL); 19110 char *s = toStringO(r); 19111 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19112 free(s); 19113 // delete the element not in self 19114 iListDelElemS(&array2, 2); 19115 // empty arrays 19116 iListRemoveS(&array2, 0, 2); 19117 r = self->f->zipCArrayChar(self, array1, array2); 19118 ck_assert_ptr_ne(r, NULL); 19119 s = toStringO(r); 19120 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19121 free(s); 19122 const char* array11[] = {null}; 19123 r = self->f->zipCArrayChar(self, array11, array2); 19124 ck_assert_ptr_ne(r, NULL); 19125 s = toStringO(r); 19126 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19127 free(s); 19128 free(array2); 19129 // array1 and array2 same element count 19130 const char *array111[] = {"aa", null}; 19131 array2 = listCreateS("11", "22"); 19132 r = self->f->zipCArrayChar(self, array111, array2); 19133 iListDelElemS(&array2, 1); 19134 ck_assert_ptr_ne(r, NULL); 19135 // some elements were zipped 19136 s = toStringO(self); 19137 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19138 free(s); 19139 // but an element is NULL 19140 // NULL arrays 19141 r = self->f->zipCArrayChar(self, NULL, array2); 19142 ck_assert_ptr_eq(r, NULL); 19143 r = self->f->zipCArrayChar(self, array1, NULL); 19144 ck_assert_ptr_eq(r, NULL); 19145 terminateO(self); 19146 free(array2); 19147 19148 } 19149 19150 19151 void zipArrayCCharSmallArrayT(CuTest *tc UNUSED) { 19152 19153 smallArrayt* r; 19154 smallArrayt *self = allocG(rtSmallArrayt); 19155 char** array1; 19156 const char* array2[] = {"1", "2", "3", null}; 19157 19158 // zip arrays 19159 // add an element to self 19160 // array1 has 2 elements 19161 // array2 has 3 elements 19162 // only 2 elements are zipped 19163 self->f->pushS(self, "qwe"); 19164 array1 = listCreateS("a", "b"); 19165 r = self->f->zipArrayCChar(self, array1, array2); 19166 ck_assert_ptr_ne(r, NULL); 19167 char *s = toStringO(r); 19168 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19169 free(s); 19170 // empty arrays 19171 const char* array22[] = {null}; 19172 r = self->f->zipArrayCChar(self, array1, array22); 19173 ck_assert_ptr_ne(r, NULL); 19174 s = toStringO(r); 19175 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19176 free(s); 19177 iListRemoveS(&array1, 0, 2); 19178 r = self->f->zipArrayCChar(self, array1, array2); 19179 ck_assert_ptr_ne(r, NULL); 19180 s = toStringO(r); 19181 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19182 free(s); 19183 free(array1); 19184 // array1 and array2 same element count 19185 array1 = listCreateS("aa", "bb"); 19186 const char* array222[] = {"11", "22", null}; 19187 iListDelElemS(&array1, 1); 19188 r = self->f->zipArrayCChar(self, array1, array222); 19189 ck_assert_ptr_ne(r, NULL); 19190 // some elements were zipped 19191 s = toStringO(self); 19192 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19193 free(s); 19194 // but an element is NULL 19195 // NULL arrays 19196 r = self->f->zipArrayCChar(self, NULL, array2); 19197 ck_assert_ptr_eq(r, NULL); 19198 r = self->f->zipArrayCChar(self, array1, NULL); 19199 ck_assert_ptr_eq(r, NULL); 19200 terminateO(self); 19201 free(array1); 19202 19203 } 19204 19205 19206 void zipCArrayCCharSmallArrayT(CuTest *tc UNUSED) { 19207 19208 smallArrayt* r; 19209 smallArrayt *self = allocG(rtSmallArrayt); 19210 const char* array1[] = {"a", "b", null}; 19211 const char* array2[] = {"1", "2", "3", null}; 19212 19213 // zip arrays 19214 // add an element to self 19215 // array1 has 2 elements 19216 // array2 has 3 elements 19217 // only 2 elements are zipped 19218 self->f->pushS(self, "qwe"); 19219 r = self->f->zipCArrayCChar(self, array1, array2); 19220 ck_assert_ptr_ne(r, NULL); 19221 char *s = toStringO(r); 19222 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19223 free(s); 19224 // delete the element not in self 19225 // empty arrays 19226 const char* array22[] = {null}; 19227 r = self->f->zipCArrayCChar(self, array1, array22); 19228 ck_assert_ptr_ne(r, NULL); 19229 s = toStringO(r); 19230 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19231 free(s); 19232 const char* array11[] = {null}; 19233 r = self->f->zipCArrayCChar(self, array11, array2); 19234 ck_assert_ptr_ne(r, NULL); 19235 s = toStringO(r); 19236 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 19237 free(s); 19238 // array1 and array2 same element count 19239 const char *array111[] = {"aa", null}; 19240 const char *array222[] = {"11", "22", null}; 19241 r = self->f->zipCArrayCChar(self, array111, array222); 19242 ck_assert_ptr_ne(r, NULL); 19243 // some elements were zipped 19244 s = toStringO(self); 19245 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]"); 19246 free(s); 19247 // but an element is NULL 19248 // NULL arrays 19249 r = self->f->zipCArrayCChar(self, NULL, array2); 19250 ck_assert_ptr_eq(r, NULL); 19251 r = self->f->zipCArrayCChar(self, array1, NULL); 19252 ck_assert_ptr_eq(r, NULL); 19253 terminateO(self); 19254 19255 } 19256 19257 19258 void logSmallArrayT(CuTest *tc UNUSED) { 19259 19260 smallArrayt *self = allocG(rtSmallArrayt); 19261 19262 // only prints to stdout 19263 logO(self); 19264 terminateO(self); 19265 19266 } 19267 19268 19269 void readTextSmallArrayT(CuTest *tc UNUSED) { 19270 19271 smallArrayt* r; 19272 smallArrayt *self = allocG(rtSmallArrayt); 19273 19274 // text 19275 r = readTextO(self, "../textTest.null"); 19276 ck_assert_ptr_ne(r, NULL); 19277 char *s = toStringO(r); 19278 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19279 free(s); 19280 // empty text 19281 emptyO(self); 19282 r = readTextO(self, "../chmodTest.null"); 19283 ck_assert_ptr_ne(r, NULL); 19284 ck_assert(isEmptyO(self)); 19285 // NULL path 19286 r = readTextO(self, NULL); 19287 ck_assert_ptr_eq(r, NULL); 19288 // non existing path 19289 if (fileExists("../nonExistingFile")) 19290 rmAll("../nonExistingFile"); 19291 r = readTextO(self, "../nonExistingFile"); 19292 ck_assert_ptr_eq(r, NULL); 19293 terminateO(self); 19294 19295 } 19296 19297 19298 void readTextSmallJsonSmallArrayT(CuTest *tc UNUSED) { 19299 19300 smallArrayt* r; 19301 smallArrayt *self = allocG(rtSmallArrayt); 19302 smallJsont *filePath = allocSmallJson(); 19303 19304 // text 19305 setTopSO(filePath, "../textTest.null"); 19306 r = self->f->readTextSmallJson(self, filePath); 19307 ck_assert_ptr_ne(r, NULL); 19308 char *s = toStringO(r); 19309 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19310 free(s); 19311 // empty text 19312 emptyO(self); 19313 freeO(filePath); 19314 setTopSO(filePath, "../chmodTest.null"); 19315 r = self->f->readTextSmallJson(self, filePath); 19316 ck_assert_ptr_ne(r, NULL); 19317 ck_assert(isEmptyO(self)); 19318 // NULL path 19319 r = self->f->readTextSmallJson(self, NULL); 19320 ck_assert_ptr_eq(r, NULL); 19321 // non existing path 19322 if (fileExists("../nonExistingFile")) 19323 rmAll("../nonExistingFile"); 19324 freeO(filePath); 19325 setTopSO(filePath, "../nonExistingFile"); 19326 r = self->f->readTextSmallJson(self, filePath); 19327 ck_assert_ptr_eq(r, NULL); 19328 // filePath not a string 19329 freeO(filePath); 19330 setTopIntO(filePath, 0); 19331 r = self->f->readTextSmallJson(self, filePath); 19332 ck_assert_ptr_eq(r, NULL); 19333 // non smallJson object 19334 terminateO(filePath); 19335 filePath = (smallJsont*) allocSmallInt(2); 19336 r = self->f->readTextSmallJson(self, filePath); 19337 ck_assert_ptr_eq(r, NULL); 19338 terminateO(self); 19339 terminateO(filePath); 19340 19341 } 19342 19343 19344 void readTextSmallStringSmallArrayT(CuTest *tc UNUSED) { 19345 19346 smallArrayt* r; 19347 smallArrayt *self = allocG(rtSmallArrayt); 19348 smallStringt *filePath = allocSmallString(""); 19349 19350 // text 19351 setValO(filePath, "../textTest.null"); 19352 r = readTextSmallStringO(self, filePath); 19353 ck_assert_ptr_ne(r, NULL); 19354 char *s = toStringO(r); 19355 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19356 free(s); 19357 // empty text 19358 emptyO(self); 19359 setValO(filePath, "../chmodTest.null"); 19360 r = readTextSmallStringO(self, filePath); 19361 ck_assert_ptr_ne(r, NULL); 19362 ck_assert(isEmptyO(self)); 19363 // NULL path 19364 r = readTextSmallStringO(self, NULL); 19365 ck_assert_ptr_eq(r, NULL); 19366 // non existing path 19367 if (fileExists("../nonExistingFile")) 19368 rmAll("../nonExistingFile"); 19369 setValO(filePath, "../nonExistingFile"); 19370 r = readTextSmallStringO(self, filePath); 19371 ck_assert_ptr_eq(r, NULL); 19372 // blank file path 19373 setValO(filePath, " "); 19374 r = readTextSmallStringO(self, filePath); 19375 ck_assert_ptr_eq(r, NULL); 19376 // non smallString object 19377 terminateO(filePath); 19378 filePath = (smallStringt*) allocSmallInt(2); 19379 r = readTextSmallStringO(self, filePath); 19380 ck_assert_ptr_eq(r, NULL); 19381 terminateO(self); 19382 terminateO(filePath); 19383 19384 } 19385 19386 19387 void readStreamSmallArrayT(CuTest *tc UNUSED) { 19388 19389 smallArrayt* r; 19390 smallArrayt *self = allocG(rtSmallArrayt); 19391 FILE *fp; 19392 19393 // stream 19394 fp = fopen("../textTest.null", "r"); 19395 r = readStreamO(self, fp); 19396 fclose(fp); 19397 ck_assert_ptr_ne(r, NULL); 19398 char *s = toStringO(r); 19399 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19400 free(s); 19401 // empty stream 19402 emptyO(self); 19403 fp = fopen("../chmodTest.null", "r"); 19404 r = readStreamO(self, fp); 19405 fclose(fp); 19406 ck_assert_ptr_ne(r, NULL); 19407 ck_assert(isEmptyO(self)); 19408 // NULL stream 19409 ck_assert_ptr_eq(readStreamO(self, NULL), NULL); 19410 terminateO(self); 19411 19412 } 19413 19414 19415 void writeTextSmallArrayT(CuTest *tc UNUSED) { 19416 19417 bool r; 19418 smallArrayt *self = allocG(rtSmallArrayt); 19419 19420 // write textOutTest.null 19421 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19422 ck_assert_ptr_ne(r2, NULL); 19423 r = writeTextO(self, "../textOutTest.null"); 19424 ck_assert(r); 19425 // check textOutTest.null 19426 emptyO(self); 19427 r2 = readTextO(self, "../textOutTest.null"); 19428 ck_assert_ptr_ne(r2, NULL); 19429 char *s = toStringO(r2); 19430 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19431 free(s); 19432 // empty array 19433 emptyO(self); 19434 r = writeTextO(self, "../textOutTest.null"); 19435 ck_assert(!r); 19436 r2 = readTextO(self, "../textOutTest.null"); 19437 ck_assert_ptr_ne(r2, NULL); 19438 s = toStringO(r2); 19439 ck_assert_str_eq(s, "[]"); 19440 free(s); 19441 // non existing file 19442 // make sure the file doesnt exist 19443 if (fileExists("../nonExistingFile")) 19444 rmAll("../nonExistingFile"); 19445 self->f->pushS(self, "qwe"); 19446 ck_assert(writeTextO(self, "../nonExistingFile")); 19447 if (fileExists("../nonExistingFile")) 19448 rmAll("../nonExistingFile"); 19449 // write readonly path 19450 ck_assert(!writeTextO(self, "/readOnlyFileTest")); 19451 // NULL path 19452 ck_assert(!writeTextO(self, NULL)); 19453 terminateO(self); 19454 19455 } 19456 19457 19458 void writeTextSmallJsonSmallArrayT(CuTest *tc UNUSED) { 19459 19460 bool r; 19461 smallArrayt *self = allocG(rtSmallArrayt); 19462 smallJsont *filePath = allocSmallJson(); 19463 19464 // write textOutTest.null 19465 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19466 ck_assert_ptr_ne(r2, NULL); 19467 setTopSO(filePath, "../textOutTest.null"); 19468 r = self->f->writeTextSmallJson(self, filePath); 19469 ck_assert(r); 19470 // check textOutTest.null 19471 emptyO(self); 19472 r2 = readTextO(self, "../textOutTest.null"); 19473 ck_assert_ptr_ne(r2, NULL); 19474 char *s = toStringO(r2); 19475 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19476 free(s); 19477 // empty array 19478 emptyO(self); 19479 freeO(filePath); 19480 setTopSO(filePath, "../textOutTest.null"); 19481 r = self->f->writeTextSmallJson(self, filePath); 19482 ck_assert(!r); 19483 r2 = readTextO(self, "../textOutTest.null"); 19484 ck_assert_ptr_ne(r2, NULL); 19485 s = toStringO(r2); 19486 ck_assert_str_eq(s, "[]"); 19487 free(s); 19488 // non existing file 19489 // make sure the file doesnt exist 19490 if (fileExists("../nonExistingFile")) 19491 rmAll("../nonExistingFile"); 19492 self->f->pushS(self, "qwe"); 19493 freeO(filePath); 19494 setTopSO(filePath, "../nonExistingFile"); 19495 ck_assert(self->f->writeTextSmallJson(self, filePath)); 19496 if (fileExists("../nonExistingFile")) 19497 rmAll("../nonExistingFile"); 19498 // filePath not a string 19499 freeO(filePath); 19500 setTopIntO(filePath, 0); 19501 r = self->f->writeTextSmallJson(self, filePath); 19502 ck_assert(!r); 19503 // non smallJson object 19504 terminateO(filePath); 19505 filePath = (smallJsont*) allocSmallInt(2); 19506 r = self->f->writeTextSmallJson(self, filePath); 19507 ck_assert(!r); 19508 // NULL path 19509 ck_assert(!self->f->writeTextSmallJson(self, NULL)); 19510 terminateO(self); 19511 terminateO(filePath); 19512 19513 } 19514 19515 19516 void writeTextSmallStringSmallArrayT(CuTest *tc UNUSED) { 19517 19518 bool r; 19519 smallArrayt *self = allocG(rtSmallArrayt); 19520 smallStringt *filePath = allocSmallString(""); 19521 19522 // write textOutTest.null 19523 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19524 ck_assert_ptr_ne(r2, NULL); 19525 setValO(filePath, "../textOutTest.null"); 19526 r = writeTextSmallStringO(self, filePath); 19527 ck_assert(r); 19528 // check textOutTest.null 19529 emptyO(self); 19530 r2 = readTextO(self, "../textOutTest.null"); 19531 ck_assert_ptr_ne(r2, NULL); 19532 char *s = toStringO(r2); 19533 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19534 free(s); 19535 // empty array 19536 emptyO(self); 19537 setValO(filePath, "../textOutTest.null"); 19538 r = writeTextSmallStringO(self, filePath); 19539 ck_assert(!r); 19540 r2 = readTextO(self, "../textOutTest.null"); 19541 ck_assert_ptr_ne(r2, NULL); 19542 s = toStringO(r2); 19543 ck_assert_str_eq(s, "[]"); 19544 free(s); 19545 // non existing file 19546 // make sure the file doesnt exist 19547 if (fileExists("../nonExistingFile")) 19548 rmAll("../nonExistingFile"); 19549 self->f->pushS(self, "qwe"); 19550 setValO(filePath, "../nonExistingFile"); 19551 ck_assert(writeTextSmallStringO(self, filePath)); 19552 if (fileExists("../nonExistingFile")) 19553 rmAll("../nonExistingFile"); 19554 // non smallJson object 19555 terminateO(filePath); 19556 filePath = (smallStringt*) allocSmallInt(2); 19557 r = writeTextSmallStringO(self, filePath); 19558 ck_assert(!r); 19559 // NULL path 19560 ck_assert(!writeTextSmallStringO(self, NULL)); 19561 terminateO(self); 19562 terminateO(filePath); 19563 19564 } 19565 19566 19567 void writeStreamSmallArrayT(CuTest *tc UNUSED) { 19568 19569 bool r; 19570 smallArrayt *self = allocG(rtSmallArrayt); 19571 FILE *fp; 19572 19573 // write textOutTest.null 19574 fp = fopen("../textTest.null", "r"); 19575 smallArrayt *r2 = readStreamO(self, fp); 19576 fclose(fp); 19577 ck_assert_ptr_ne(r2, NULL); 19578 fp = fopen("../textOutTest.null", "w"); 19579 r = writeStreamO(self, fp); 19580 ck_assert(r); 19581 // empty array 19582 emptyO(self); 19583 ck_assert(!writeStreamO(self, fp)); 19584 fclose(fp); 19585 // check textOutTest.null 19586 fp = fopen("../textOutTest.null", "r"); 19587 r2 = readStreamO(self, fp); 19588 fclose(fp); 19589 ck_assert_ptr_ne(r2, NULL); 19590 char *s = toStringO(r2); 19591 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 19592 free(s); 19593 terminateO(self); 19594 19595 } 19596 19597 19598 void appendTextSmallArrayT(CuTest *tc UNUSED) { 19599 19600 bool r; 19601 smallArrayt *self = allocG(rtSmallArrayt); 19602 19603 // append to textOutTest.null 19604 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19605 ck_assert_ptr_ne(r2, NULL); 19606 r = writeTextO(self, "../textOutTest.null"); 19607 ck_assert(r); 19608 emptyO(self); 19609 self->f->pushS(self, "A"); 19610 self->f->pushS(self, "B"); 19611 r = appendTextO(self, "../textOutTest.null"); 19612 // check textOutTest.null 19613 emptyO(self); 19614 r2 = readTextO(self, "../textOutTest.null"); 19615 ck_assert_ptr_ne(r2, NULL); 19616 char *s = toStringO(r2); 19617 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 19618 free(s); 19619 // non existing file 19620 // make sure the file doesnt exist 19621 if (fileExists("../nonExistingFile")) 19622 rmAll("../nonExistingFile"); 19623 ck_assert(appendTextO(self, "../nonExistingFile")); 19624 if (fileExists("../nonExistingFile")) 19625 rmAll("../nonExistingFile"); 19626 // empty array 19627 emptyO(self); 19628 r = appendTextO(self, "../textOutTest.null"); 19629 ck_assert(!r); 19630 // check textOutTest.null 19631 emptyO(self); 19632 r2 = readTextO(self, "../textOutTest.null"); 19633 ck_assert_ptr_ne(r2, NULL); 19634 s = toStringO(r2); 19635 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 19636 free(s); 19637 // blank path 19638 ck_assert(!appendTextO(self, " ")); 19639 // append readonly path 19640 ck_assert(!appendTextO(self, "/readOnlyFileTest")); 19641 // NULL path 19642 ck_assert(!appendTextO(self, NULL)); 19643 terminateO(self); 19644 19645 } 19646 19647 19648 void appendTextSmallStringSmallArrayT(CuTest *tc UNUSED) { 19649 19650 bool r; 19651 smallArrayt *self = allocG(rtSmallArrayt); 19652 smallStringt *filePath = allocSmallString(""); 19653 19654 // append to textOutTest.null 19655 smallArrayt *r2 = readTextO(self, "../textTest.null"); 19656 ck_assert_ptr_ne(r2, NULL); 19657 r = writeTextO(self, "../textOutTest.null"); 19658 ck_assert(r); 19659 emptyO(self); 19660 self->f->pushS(self, "A"); 19661 self->f->pushS(self, "B"); 19662 setValO(filePath, "../textOutTest.null"); 19663 r = appendTextSmallStringO(self, filePath); 19664 // check textOutTest.null 19665 emptyO(self); 19666 r2 = readTextO(self, "../textOutTest.null"); 19667 ck_assert_ptr_ne(r2, NULL); 19668 char *s = toStringO(r2); 19669 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 19670 free(s); 19671 // non existing file 19672 // make sure the file doesnt exist 19673 if (fileExists("../nonExistingFile")) 19674 rmAll("../nonExistingFile"); 19675 setValO(filePath, "../nonExistingFile"); 19676 ck_assert(appendTextSmallStringO(self, filePath)); 19677 if (fileExists("../nonExistingFile")) 19678 rmAll("../nonExistingFile"); 19679 // empty array 19680 emptyO(self); 19681 r = appendTextSmallStringO(self, filePath); 19682 ck_assert(!r); 19683 // check textOutTest.null 19684 emptyO(self); 19685 r2 = readTextO(self, "../textOutTest.null"); 19686 ck_assert_ptr_ne(r2, NULL); 19687 s = toStringO(r2); 19688 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 19689 free(s); 19690 // blank path 19691 setValO(filePath, " "); 19692 ck_assert(!appendTextSmallStringO(self, filePath)); 19693 // non smallString object 19694 terminateO(filePath); 19695 filePath = (smallStringt*) allocSmallInt(2); 19696 r = appendTextSmallStringO(self, filePath); 19697 ck_assert(!r); 19698 // NULL path 19699 ck_assert(!appendTextSmallStringO(self, NULL)); 19700 terminateO(self); 19701 terminateO(filePath); 19702 19703 } 19704 19705 19706 void typeSmallStringSmallArrayT(CuTest *tc UNUSED) { 19707 19708 smallStringt* r; 19709 smallArrayt *self = allocG(rtSmallArrayt); 19710 19711 // empty array 19712 r = typeSmallStringO(self, 0); 19713 ck_assert_ptr_ne(r, NULL); 19714 char *s = toStringO(r); 19715 ck_assert_str_eq(s, "not a sheepy object"); 19716 free(s); 19717 terminateO(self); 19718 terminateO(r); 19719 19720 } 19721 19722 19723 void typeSmallStringsSmallArrayT(CuTest *tc UNUSED) { 19724 19725 smallArrayt* r; 19726 smallArrayt *self = allocG(rtSmallArrayt); 19727 19728 // empty array 19729 r = typeSmallStringsO(self); 19730 ck_assert_ptr_eq(r, NULL); 19731 // array 19732 self->f->pushS(self, "qwe"); 19733 self->f->pushBool(self, true); 19734 self->f->pushDouble(self, 1); 19735 r = typeSmallStringsO(self); 19736 ck_assert_ptr_ne(r, NULL); 19737 char *s = toStringO(r); 19738 ck_assert_str_eq(s, "[\"string\",\"bool\",\"double\"]"); 19739 free(s); 19740 terminateO(self); 19741 terminateO(r); 19742 19743 } 19744 19745 19746 void isETypeSmallArrayT(CuTest *tc UNUSED) { 19747 19748 bool r; 19749 smallArrayt *self = allocG(rtSmallArrayt); 19750 19751 self->f->pushUndefined(self); 19752 r = isETypeO(self, 0, "undefined"); 19753 ck_assert(r); 19754 // NULL type 19755 emptyO(self); 19756 r = isETypeO(self, 0, NULL); 19757 ck_assert(!r); 19758 terminateO(self); 19759 19760 } 19761 19762 19763 void isEUndefinedSmallArrayT(CuTest *tc UNUSED) { 19764 19765 bool r; 19766 smallArrayt *self = allocG(rtSmallArrayt); 19767 19768 // array 19769 self->f->pushUndefined(self); 19770 self->f->pushS(self, ""); 19771 r = isEUndefinedO(self, 0); 19772 ck_assert(r); 19773 r = isEUndefinedO(self, -1); 19774 ck_assert(!r); 19775 terminateO(self); 19776 19777 } 19778 19779 19780 void isEBoolSmallArrayT(CuTest *tc UNUSED) { 19781 19782 bool r; 19783 smallArrayt *self = allocG(rtSmallArrayt); 19784 19785 // array 19786 self->f->pushBool(self, true); 19787 self->f->pushS(self, ""); 19788 r = isEBoolO(self, 0); 19789 ck_assert(r); 19790 r = isEBoolO(self, -1); 19791 ck_assert(!r); 19792 terminateO(self); 19793 19794 } 19795 19796 19797 void isEContainerSmallArrayT(CuTest *tc UNUSED) { 19798 19799 bool r; 19800 smallArrayt *self = allocG(rtSmallArrayt); 19801 19802 // array 19803 createSmallContainer(c); 19804 self->f->pushSmallContainer(self, &c); 19805 self->f->pushS(self, ""); 19806 r = isEContainerO(self, 0); 19807 ck_assert(r); 19808 r = isEContainerO(self, -1); 19809 ck_assert(!r); 19810 terminateO(self); 19811 19812 } 19813 19814 19815 void isEDictSmallArrayT(CuTest *tc UNUSED) { 19816 19817 bool r; 19818 smallArrayt *self = allocG(rtSmallArrayt); 19819 19820 // array 19821 createSmallDict(d); 19822 self->f->pushDict(self, &d); 19823 self->f->pushS(self, ""); 19824 r = isEDictO(self, 0); 19825 ck_assert(r); 19826 r = isEDictO(self, -1); 19827 ck_assert(!r); 19828 terminateO(self); 19829 19830 } 19831 19832 19833 void isEDoubleSmallArrayT(CuTest *tc UNUSED) { 19834 19835 bool r; 19836 smallArrayt *self = allocG(rtSmallArrayt); 19837 19838 // array 19839 self->f->pushDouble(self, 1); 19840 self->f->pushS(self, ""); 19841 r = isEDoubleO(self, 0); 19842 ck_assert(r); 19843 r = isEDoubleO(self, -1); 19844 ck_assert(!r); 19845 terminateO(self); 19846 19847 } 19848 19849 19850 void isEIntSmallArrayT(CuTest *tc UNUSED) { 19851 19852 bool r; 19853 smallArrayt *self = allocG(rtSmallArrayt); 19854 19855 // array 19856 self->f->pushInt(self, 1); 19857 self->f->pushS(self, ""); 19858 r = isEIntO(self, 0); 19859 ck_assert(r); 19860 r = isEIntO(self, -1); 19861 ck_assert(!r); 19862 terminateO(self); 19863 19864 } 19865 19866 19867 void isEStringSmallArrayT(CuTest *tc UNUSED) { 19868 19869 bool r; 19870 smallArrayt *self = allocG(rtSmallArrayt); 19871 19872 // array 19873 self->f->pushUndefined(self); 19874 self->f->pushS(self, ""); 19875 r = isEStringO(self, -1); 19876 ck_assert(r); 19877 r = isEStringO(self, 0); 19878 ck_assert(!r); 19879 terminateO(self); 19880 19881 } 19882 19883 19884 void isEFaststringSmallArrayT(CuTest *tc UNUSED) { 19885 19886 bool r; 19887 smallArrayt *self = allocG(rtSmallArrayt); 19888 19889 r = isEFaststringO(self, 0); 19890 ck_assert(!r); 19891 terminateO(self); 19892 19893 } 19894 19895 19896 void isEArraySmallArrayT(CuTest *tc UNUSED) { 19897 19898 bool r; 19899 smallArrayt *self = allocG(rtSmallArrayt); 19900 19901 // array 19902 createSmallArray(a); 19903 self->f->pushArray(self, &a); 19904 self->f->pushS(self, ""); 19905 r = isEArrayO(self, 0); 19906 ck_assert(r); 19907 r = isEArrayO(self, -1); 19908 ck_assert(!r); 19909 terminateO(self); 19910 19911 } 19912 19913 19914 void isEBytesSmallArrayT(CuTest *tc UNUSED) { 19915 19916 bool r; 19917 smallArrayt *self = allocG(rtSmallArrayt); 19918 19919 // array 19920 createSmallBytes(b); 19921 self->f->pushSmallBytes(self, &b); 19922 self->f->pushS(self, ""); 19923 r = isEBytesO(self, 0); 19924 ck_assert(r); 19925 r = isEBytesO(self, -1); 19926 ck_assert(!r); 19927 terminateO(self); 19928 19929 } 19930 19931 19932 void areAllETypeSmallArrayT(CuTest *tc UNUSED) { 19933 19934 bool r; 19935 smallArrayt *self = allocG(rtSmallArrayt); 19936 19937 // empty array 19938 r = areAllETypeO(self, "undefined"); 19939 ck_assert(!r); 19940 // array 19941 self->f->pushUndefined(self); 19942 self->f->pushUndefined(self); 19943 self->f->pushUndefined(self); 19944 delElemO(self, 1); 19945 r = areAllETypeO(self, "undefined"); 19946 ck_assert(!r); 19947 trimO(self); 19948 r = areAllETypeO(self, "undefined"); 19949 ck_assert(r); 19950 // NULL type 19951 r = areAllETypeO(self, NULL); 19952 ck_assert(!r); 19953 terminateO(self); 19954 19955 } 19956 19957 19958 void areAllEUndefinedSmallArrayT(CuTest *tc UNUSED) { 19959 19960 bool r; 19961 smallArrayt *self = allocG(rtSmallArrayt); 19962 19963 // array 19964 self->f->pushUndefined(self); 19965 self->f->pushUndefined(self); 19966 self->f->pushUndefined(self); 19967 r = areAllEUndefinedO(self); 19968 ck_assert(r); 19969 terminateO(self); 19970 19971 } 19972 19973 19974 void areAllEBoolSmallArrayT(CuTest *tc UNUSED) { 19975 19976 bool r; 19977 smallArrayt *self = allocG(rtSmallArrayt); 19978 19979 // array 19980 self->f->pushBool(self, true); 19981 self->f->pushBool(self, true); 19982 self->f->pushBool(self, true); 19983 r = areAllEBoolO(self); 19984 ck_assert(r); 19985 terminateO(self); 19986 19987 } 19988 19989 19990 void areAllEContainerSmallArrayT(CuTest *tc UNUSED) { 19991 19992 bool r; 19993 smallArrayt *self = allocG(rtSmallArrayt); 19994 19995 createSmallContainer(c); 19996 self->f->pushSmallContainer(self, &c); 19997 r = areAllEContainerO(self); 19998 ck_assert(r); 19999 terminateO(self); 20000 20001 } 20002 20003 20004 void areAllEDictSmallArrayT(CuTest *tc UNUSED) { 20005 20006 bool r; 20007 smallArrayt *self = allocG(rtSmallArrayt); 20008 20009 createSmallDict(d); 20010 self->f->pushDict(self, &d); 20011 r = areAllEDictO(self); 20012 ck_assert(r); 20013 terminateO(self); 20014 20015 } 20016 20017 20018 void areAllEDoubleSmallArrayT(CuTest *tc UNUSED) { 20019 20020 bool r; 20021 smallArrayt *self = allocG(rtSmallArrayt); 20022 20023 self->f->pushDouble(self, 1); 20024 r = areAllEDoubleO(self); 20025 ck_assert(r); 20026 terminateO(self); 20027 20028 } 20029 20030 20031 void areAllEIntSmallArrayT(CuTest *tc UNUSED) { 20032 20033 bool r; 20034 smallArrayt *self = allocG(rtSmallArrayt); 20035 20036 self->f->pushInt(self, 1); 20037 r = areAllEIntO(self); 20038 ck_assert(r); 20039 terminateO(self); 20040 20041 } 20042 20043 20044 void areAllEStringSmallArrayT(CuTest *tc UNUSED) { 20045 20046 bool r; 20047 smallArrayt *self = allocG(rtSmallArrayt); 20048 20049 self->f->pushS(self, ""); 20050 r = areAllEStringO(self); 20051 ck_assert(r); 20052 terminateO(self); 20053 20054 } 20055 20056 20057 void areAllEFaststringSmallArrayT(CuTest *tc UNUSED) { 20058 20059 bool r; 20060 smallArrayt *self = allocG(rtSmallArrayt); 20061 20062 self->f->pushS(self, ""); 20063 r = areAllEFaststringO(self); 20064 ck_assert(!r); 20065 terminateO(self); 20066 20067 } 20068 20069 20070 void areAllEArraySmallArrayT(CuTest *tc UNUSED) { 20071 20072 bool r; 20073 smallArrayt *self = allocG(rtSmallArrayt); 20074 20075 createSmallArray(a); 20076 self->f->pushArray(self, &a); 20077 r = areAllEArrayO(self); 20078 ck_assert(r); 20079 terminateO(self); 20080 20081 } 20082 20083 20084 void areAllEBytesSmallArrayT(CuTest *tc UNUSED) { 20085 20086 bool r; 20087 smallArrayt *self = allocG(rtSmallArrayt); 20088 20089 createSmallBytes(b); 20090 self->f->pushSmallBytes(self, &b); 20091 r = areAllEBytesO(self); 20092 ck_assert(r); 20093 terminateO(self); 20094 20095 } 20096 20097 20098 void allocSmallArrayGT(CuTest *tc UNUSED) { 20099 20100 smallArrayt *self = allocSmallArrayG(self); 20101 20102 ck_assert_ptr_ne(self, NULL); 20103 char *s = toStringO(self); 20104 ck_assert_str_eq(s, "[]"); 20105 free(s); 20106 terminateO(self); 20107 20108 } 20109 20110 20111 void duplicateSmallArrayGT(CuTest *tc UNUSED) { 20112 20113 smallArrayt* r; 20114 smallArrayt *self = allocG(rtSmallArrayt); 20115 20116 self->f->pushInt(self, 1); 20117 r = duplicateSmallArrayG(self); 20118 char *s = toStringO(r); 20119 terminateO(r); 20120 ck_assert_str_eq(s, "[1]"); 20121 free(s); 20122 terminateO(self); 20123 20124 } 20125 20126 20127 void freeSmallArrayGT(CuTest *tc UNUSED) { 20128 20129 smallArrayt *self = allocG(rtSmallArrayt); 20130 20131 self->f->pushInt(self, 1); 20132 freeSmallArrayG(self); 20133 char *s = toStringO(self); 20134 ck_assert_str_eq(s, "[]"); 20135 free(s); 20136 terminateO(self); 20137 20138 } 20139 20140 20141 void fromArraySmallArrayGT(CuTest *tc UNUSED) { 20142 20143 smallArrayt* r; 20144 smallArrayt *self = allocG(rtSmallArrayt); 20145 20146 char *array[] = {"1", "22", "333"}; 20147 r = fromArraySmallArrayG(self, array, 3); 20148 ck_assert_ptr_ne(r, NULL); 20149 char *s = toStringO(r); 20150 ck_assert_str_eq(s, "[\"1\",\"22\",\"333\"]"); 20151 free(s); 20152 terminateO(self); 20153 20154 } 20155 20156 20157 void fromCArraySmallArrayGT(CuTest *tc UNUSED) { 20158 20159 smallArrayt* r; 20160 smallArrayt *self = allocG(rtSmallArrayt); 20161 20162 const char *array[] = {"1", "22", "333"}; 20163 r = fromCArraySmallArrayG(self, array, 3); 20164 ck_assert_ptr_ne(r, NULL); 20165 char *s = toStringO(r); 20166 ck_assert_str_eq(s, "[\"1\",\"22\",\"333\"]"); 20167 free(s); 20168 terminateO(self); 20169 20170 } 20171 20172 20173 void setFromSmallArrayGT(CuTest *tc UNUSED) { 20174 20175 smallArrayt* r; 20176 smallArrayt *self = allocG(rtSmallArrayt); 20177 20178 char *array[] = {"1", "22", "333", NULL}; 20179 r = setFromSmallArrayG(self, array); 20180 ck_assert_ptr_ne(r, NULL); 20181 char *s = toStringO(r); 20182 ck_assert_str_eq(s, "[\"1\",\"22\",\"333\"]"); 20183 free(s); 20184 terminateO(self); 20185 20186 } 20187 20188 20189 void setFromCSmallArrayGT(CuTest *tc UNUSED) { 20190 20191 smallArrayt *r; 20192 smallArrayt *self = allocG(rtSmallArrayt); 20193 20194 const char *array[] = {"1", "22", "333", NULL}; 20195 r = setFromCSmallArrayG(self, array); 20196 ck_assert_ptr_ne(r, NULL); 20197 char *s = toStringO(r); 20198 ck_assert_str_eq(s, "[\"1\",\"22\",\"333\"]"); 20199 free(s); 20200 terminateO(self); 20201 20202 } 20203 20204 20205 void pushSmallArrayGT(CuTest *tc UNUSED) { 20206 20207 smallArrayt* r; 20208 smallArrayt *self = allocG(rtSmallArrayt); 20209 baset *value = (baset*) allocSmallInt(1); 20210 20211 r = pushSmallArrayG(self, value); 20212 ck_assert_ptr_ne(r, null); 20213 finishO(value); 20214 char *s = toStringO(r); 20215 ck_assert_str_eq(s, "[1]"); 20216 free(s); 20217 terminateO(self); 20218 20219 } 20220 20221 20222 void pushUndefinedSmallArrayGT(CuTest *tc UNUSED) { 20223 20224 smallArrayt* r; 20225 smallArrayt *self = allocG(rtSmallArrayt); 20226 20227 r = pushUndefinedSmallArrayG(self, NULL); 20228 ck_assert_ptr_ne(r, null); 20229 char *s = toStringO(r); 20230 ck_assert_str_eq(s, "[null]"); 20231 free(s); 20232 terminateO(self); 20233 20234 } 20235 20236 20237 void pushBoolSmallArrayGT(CuTest *tc UNUSED) { 20238 20239 smallArrayt* r; 20240 smallArrayt *self = allocG(rtSmallArrayt); 20241 20242 r = pushBoolSmallArrayG(self, true); 20243 ck_assert_ptr_ne(r, null); 20244 char *s = toStringO(r); 20245 ck_assert_str_eq(s, "[true]"); 20246 free(s); 20247 terminateO(self); 20248 20249 } 20250 20251 20252 void pushDoubleSmallArrayGT(CuTest *tc UNUSED) { 20253 20254 smallArrayt* r; 20255 smallArrayt *self = allocG(rtSmallArrayt); 20256 20257 r = pushDoubleSmallArrayG(self, 1); 20258 ck_assert_ptr_ne(r, null); 20259 char *s = toStringO(r); 20260 ck_assert_str_eq(s, "[1.000000e+00]"); 20261 free(s); 20262 terminateO(self); 20263 20264 } 20265 20266 20267 void pushIntSmallArrayGT(CuTest *tc UNUSED) { 20268 20269 smallArrayt* r; 20270 smallArrayt *self = allocG(rtSmallArrayt); 20271 20272 r = pushIntSmallArrayG(self, 1); 20273 ck_assert_ptr_ne(r, null); 20274 char *s = toStringO(r); 20275 ck_assert_str_eq(s, "[1]"); 20276 free(s); 20277 terminateO(self); 20278 20279 } 20280 20281 20282 void pushSSmallArrayGT(CuTest *tc UNUSED) { 20283 20284 smallArrayt* r; 20285 smallArrayt *self = allocG(rtSmallArrayt); 20286 20287 r = pushSSmallArrayG(self, "qwe"); 20288 ck_assert_ptr_ne(r, null); 20289 char *s = toStringO(r); 20290 ck_assert_str_eq(s, "[\"qwe\"]"); 20291 free(s); 20292 terminateO(self); 20293 20294 } 20295 20296 20297 void pushCharSmallArrayGT(CuTest *tc UNUSED) { 20298 20299 smallArrayt* r; 20300 smallArrayt *self = allocG(rtSmallArrayt); 20301 20302 r = pushCharSmallArrayG(self, 'Q'); 20303 ck_assert_ptr_ne(r, null); 20304 char *s = toStringO(r); 20305 ck_assert_str_eq(s, "[\"Q\"]"); 20306 free(s); 20307 terminateO(self); 20308 20309 } 20310 20311 20312 void pushDictSmallArrayGT(CuTest *tc UNUSED) { 20313 20314 smallArrayt* r; 20315 smallArrayt *self = allocG(rtSmallArrayt); 20316 smallDictt *dict = allocSmallDict(); 20317 20318 r = pushDictSmallArrayG(self, dict); 20319 ck_assert_ptr_ne(r, null); 20320 finishO(dict); 20321 char *s = toStringO(r); 20322 ck_assert_str_eq(s, "[{}]"); 20323 free(s); 20324 terminateO(self); 20325 20326 } 20327 20328 20329 void pushArraySmallArrayGT(CuTest *tc UNUSED) { 20330 20331 smallArrayt* r; 20332 smallArrayt *self = allocG(rtSmallArrayt); 20333 smallArrayt *array = allocSmallArray(); 20334 20335 r = pushArraySmallArrayG(self, array); 20336 ck_assert_ptr_ne(r, null); 20337 finishO(array); 20338 char *s = toStringO(r); 20339 ck_assert_str_eq(s, "[[]]"); 20340 free(s); 20341 terminateO(self); 20342 20343 } 20344 20345 20346 void pushArraycSmallArrayGT(CuTest *tc UNUSED) { 20347 20348 smallArrayt* r; 20349 smallArrayt *self = allocG(rtSmallArrayt); 20350 char **array = listCreateS("a","bb"); 20351 20352 r = pushArraycSmallArrayG(self, array); 20353 ck_assert_ptr_ne(r, null); 20354 ck_assert_int_eq(lenO(r), 1); 20355 listFreeS(array); 20356 char *s = toStringO(r); 20357 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 20358 free(s); 20359 terminateO(self); 20360 20361 } 20362 20363 20364 void pushCArraycSmallArrayGT(CuTest *tc UNUSED) { 20365 20366 smallArrayt* r; 20367 smallArrayt *self = allocG(rtSmallArrayt); 20368 const char *array[] = {"a", "bb", NULL}; 20369 20370 r = pushCArraycSmallArrayG(self, array); 20371 ck_assert_ptr_ne(r, null); 20372 ck_assert_int_eq(lenO(r), 1); 20373 char *s = toStringO(r); 20374 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 20375 free(s); 20376 terminateO(self); 20377 20378 } 20379 20380 20381 void pushVoidSmallArrayGT(CuTest *tc UNUSED) { 20382 20383 smallArrayt* r; 20384 smallArrayt *self = allocG(rtSmallArrayt); 20385 20386 // NULL value 20387 r = pushVoidSmallArrayG(self, NULL); 20388 ck_assert_ptr_ne(r, null); 20389 char *s = toStringO(r); 20390 ck_assert_str_eq(s, "[null]"); 20391 free(s); 20392 // value 20393 r = pushVoidSmallArrayG(self, r); 20394 s = toStringO(r); 20395 ck_assert_str_eq(s, "[null,\"<data container>\"]"); 20396 free(s); 20397 terminateO(self); 20398 20399 } 20400 20401 20402 void pushSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 20403 20404 smallArrayt* r; 20405 smallArrayt *self = allocG(rtSmallArrayt); 20406 smallBoolt *value = allocSmallBool(true); 20407 20408 r = pushSmallBoolSmallArrayG(self, value); 20409 ck_assert_ptr_ne(r, null); 20410 finishO(value); 20411 char *s = toStringO(r); 20412 ck_assert_str_eq(s, "[true]"); 20413 free(s); 20414 terminateO(self); 20415 20416 } 20417 20418 20419 void pushSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 20420 20421 smallArrayt* r; 20422 smallArrayt *self = allocG(rtSmallArrayt); 20423 smallBytest *value = allocSmallBytes("qwe", 3); 20424 20425 r = pushSmallBytesSmallArrayG(self, value); 20426 ck_assert_ptr_ne(r, null); 20427 finishO(value); 20428 char *s = toStringO(r); 20429 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 20430 free(s); 20431 terminateO(self); 20432 20433 } 20434 20435 20436 void pushSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 20437 20438 smallArrayt* r; 20439 smallArrayt *self = allocG(rtSmallArrayt); 20440 smallDoublet *value = allocSmallDouble(1); 20441 20442 r = pushSmallDoubleSmallArrayG(self, value); 20443 ck_assert_ptr_ne(r, null); 20444 finishO(value); 20445 char *s = toStringO(r); 20446 ck_assert_str_eq(s, "[1.000000e+00]"); 20447 free(s); 20448 terminateO(self); 20449 20450 } 20451 20452 20453 void pushSmallIntSmallArrayGT(CuTest *tc UNUSED) { 20454 20455 smallArrayt* r; 20456 smallArrayt *self = allocG(rtSmallArrayt); 20457 smallIntt *value = allocSmallInt(1); 20458 20459 r = pushSmallIntSmallArrayG(self, value); 20460 ck_assert_ptr_ne(r, null); 20461 finishO(value); 20462 char *s = toStringO(r); 20463 ck_assert_str_eq(s, "[1]"); 20464 free(s); 20465 terminateO(self); 20466 20467 } 20468 20469 20470 void pushSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 20471 20472 smallArrayt* r; 20473 smallArrayt *self = allocG(rtSmallArrayt); 20474 smallJsont *value = allocSmallJson(); 20475 20476 r = pushSmallJsonSmallArrayG(self, value); 20477 ck_assert_ptr_ne(r, null); 20478 finishO(value); 20479 char *s = toStringO(r); 20480 ck_assert_str_eq(s, "[{}]"); 20481 free(s); 20482 terminateO(self); 20483 20484 } 20485 20486 20487 void pushSmallStringSmallArrayGT(CuTest *tc UNUSED) { 20488 20489 smallArrayt* r; 20490 smallArrayt *self = allocG(rtSmallArrayt); 20491 smallStringt *string = allocSmallString("qwe"); 20492 20493 r = pushSmallStringSmallArrayG(self, string); 20494 ck_assert_ptr_ne(r, null); 20495 finishO(string); 20496 char *s = toStringO(r); 20497 ck_assert_str_eq(s, "[\"qwe\"]"); 20498 free(s); 20499 terminateO(self); 20500 20501 } 20502 20503 20504 void pushSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 20505 20506 smallArrayt* r; 20507 smallArrayt *self = allocG(rtSmallArrayt); 20508 20509 createSmallContainer(c); 20510 r = pushSmallContainerSmallArrayG(self, &c); 20511 ck_assert_ptr_ne(r, null); 20512 char *s = toStringO(r); 20513 ck_assert_str_eq(s, "[\"<data container>\"]"); 20514 free(s); 20515 terminateO(self); 20516 20517 } 20518 20519 20520 void pushNFreeSmallArrayGT(CuTest *tc UNUSED) { 20521 20522 smallArrayt* r; 20523 smallArrayt *self = allocG(rtSmallArrayt); 20524 baset *value = (baset*) allocSmallInt(1); 20525 20526 r = pushNFreeSmallArrayG(self, value); 20527 ck_assert_ptr_ne(r, null); 20528 char *s = toStringO(r); 20529 ck_assert_str_eq(s, "[1]"); 20530 free(s); 20531 terminateO(self); 20532 20533 } 20534 20535 20536 void pushNFreeUndefinedSmallArrayGT(CuTest *tc UNUSED) { 20537 20538 smallArrayt* r; 20539 smallArrayt *self = allocG(rtSmallArrayt); 20540 undefinedt *value = allocUndefined(); 20541 20542 r = pushNFreeUndefinedSmallArrayG(self, value); 20543 ck_assert_ptr_ne(r, null); 20544 char *s = toStringO(r); 20545 ck_assert_str_eq(s, "[null]"); 20546 free(s); 20547 terminateO(self); 20548 20549 } 20550 20551 20552 void pushNFreeSSmallArrayGT(CuTest *tc UNUSED) { 20553 20554 smallArrayt* r; 20555 smallArrayt *self = allocG(rtSmallArrayt); 20556 20557 r = pushNFreeSSmallArrayG(self, strdup("qwe")); 20558 ck_assert_ptr_ne(r, null); 20559 char *s = toStringO(r); 20560 ck_assert_str_eq(s, "[\"qwe\"]"); 20561 free(s); 20562 terminateO(self); 20563 20564 } 20565 20566 20567 void pushNFreeDictSmallArrayGT(CuTest *tc UNUSED) { 20568 20569 smallArrayt* r; 20570 smallArrayt *self = allocG(rtSmallArrayt); 20571 smallDictt *dict = allocSmallDict(); 20572 20573 r = pushNFreeDictSmallArrayG(self, dict); 20574 ck_assert_ptr_ne(r, null); 20575 char *s = toStringO(r); 20576 ck_assert_str_eq(s, "[{}]"); 20577 free(s); 20578 terminateO(self); 20579 20580 } 20581 20582 20583 void pushNFreeArraySmallArrayGT(CuTest *tc UNUSED) { 20584 20585 smallArrayt* r; 20586 smallArrayt *self = allocG(rtSmallArrayt); 20587 smallArrayt *array = allocSmallArray(); 20588 20589 r = pushNFreeArraySmallArrayG(self, array); 20590 ck_assert_ptr_ne(r, null); 20591 char *s = toStringO(r); 20592 ck_assert_str_eq(s, "[[]]"); 20593 free(s); 20594 terminateO(self); 20595 20596 } 20597 20598 20599 void pushNFreeArraycSmallArrayGT(CuTest *tc UNUSED) { 20600 20601 smallArrayt* r; 20602 smallArrayt *self = allocG(rtSmallArrayt); 20603 char **array = listCreateS("a","bb"); 20604 20605 r = pushNFreeArraycSmallArrayG(self, array); 20606 ck_assert_ptr_ne(r, null); 20607 ck_assert_int_eq(lenO(r), 1); 20608 char *s = toStringO(r); 20609 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 20610 free(s); 20611 terminateO(self); 20612 20613 } 20614 20615 20616 void pushNFreeSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 20617 20618 smallArrayt* r; 20619 smallArrayt *self = allocG(rtSmallArrayt); 20620 smallBoolt *value = allocSmallBool(true); 20621 20622 r = pushNFreeSmallBoolSmallArrayG(self, value); 20623 ck_assert_ptr_ne(r, null); 20624 char *s = toStringO(r); 20625 ck_assert_str_eq(s, "[true]"); 20626 free(s); 20627 terminateO(self); 20628 20629 } 20630 20631 20632 void pushNFreeSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 20633 20634 smallArrayt* r; 20635 smallArrayt *self = allocG(rtSmallArrayt); 20636 smallBytest *value = allocSmallBytes("qwe", 3); 20637 20638 r = pushNFreeSmallBytesSmallArrayG(self, value); 20639 ck_assert_ptr_ne(r, null); 20640 char *s = toStringO(r); 20641 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 20642 free(s); 20643 terminateO(self); 20644 20645 } 20646 20647 20648 void pushNFreeSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 20649 20650 smallArrayt* r; 20651 smallArrayt *self = allocG(rtSmallArrayt); 20652 smallDoublet *value = allocSmallDouble(1); 20653 20654 r = pushNFreeSmallDoubleSmallArrayG(self, value); 20655 ck_assert_ptr_ne(r, null); 20656 char *s = toStringO(r); 20657 ck_assert_str_eq(s, "[1.000000e+00]"); 20658 free(s); 20659 terminateO(self); 20660 20661 } 20662 20663 20664 void pushNFreeSmallIntSmallArrayGT(CuTest *tc UNUSED) { 20665 20666 smallArrayt* r; 20667 smallArrayt *self = allocG(rtSmallArrayt); 20668 smallIntt *value = allocSmallInt(1); 20669 20670 r = pushNFreeSmallIntSmallArrayG(self, value); 20671 ck_assert_ptr_ne(r, null); 20672 char *s = toStringO(r); 20673 ck_assert_str_eq(s, "[1]"); 20674 free(s); 20675 terminateO(self); 20676 20677 } 20678 20679 20680 void pushNFreeSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 20681 20682 smallArrayt* r; 20683 smallArrayt *self = allocG(rtSmallArrayt); 20684 smallJsont *value = allocSmallJson(); 20685 20686 r = pushNFreeSmallJsonSmallArrayG(self, value); 20687 ck_assert_ptr_ne(r, null); 20688 char *s = toStringO(r); 20689 ck_assert_str_eq(s, "[{}]"); 20690 free(s); 20691 terminateO(self); 20692 20693 } 20694 20695 20696 void pushNFreeSmallStringSmallArrayGT(CuTest *tc UNUSED) { 20697 20698 smallArrayt* r; 20699 smallArrayt *self = allocG(rtSmallArrayt); 20700 smallStringt *string = allocSmallString("qwe"); 20701 20702 r = pushNFreeSmallStringSmallArrayG(self, string); 20703 ck_assert_ptr_ne(r, null); 20704 char *s = toStringO(r); 20705 ck_assert_str_eq(s, "[\"qwe\"]"); 20706 free(s); 20707 terminateO(self); 20708 20709 } 20710 20711 20712 void pushNFreeSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 20713 20714 smallArrayt* r; 20715 smallArrayt *self = allocG(rtSmallArrayt); 20716 20717 createAllocateSmallContainer(c); 20718 r = pushNFreeSmallContainerSmallArrayG(self, c); 20719 ck_assert_ptr_ne(r, null); 20720 char *s = toStringO(r); 20721 ck_assert_str_eq(s, "[\"<data container>\"]"); 20722 free(s); 20723 terminateO(self); 20724 20725 } 20726 20727 20728 void popSmallArrayGT(CuTest *tc UNUSED) { 20729 20730 baset* r; 20731 smallArrayt *self = allocG(rtSmallArrayt); 20732 20733 smallArrayt *r2 = self->f->pushInt(self, 1); 20734 ck_assert_ptr_ne(r2, null); 20735 r = popSmallArrayG(self, NULL); 20736 ck_assert_ptr_ne(r, null); 20737 char *s = toStringO(r); 20738 terminateO(r); 20739 ck_assert_str_eq(s, "1"); 20740 free(s); 20741 // empty array 20742 self->f->pushUndefined(self); 20743 delElemO(self, -1); 20744 r = popSmallArrayG(self, NULL); 20745 ck_assert_ptr_eq(r, null); 20746 terminateO(self); 20747 20748 } 20749 20750 20751 void popUndefinedSmallArrayGT(CuTest *tc UNUSED) { 20752 20753 undefinedt* r; 20754 smallArrayt *self = allocG(rtSmallArrayt); 20755 20756 smallArrayt *r2 = self->f->pushUndefined(self); 20757 ck_assert_ptr_ne(r2, null); 20758 r = popUndefinedSmallArrayG(self, null); 20759 ck_assert_ptr_ne(r, null); 20760 char *s = toStringO(r); 20761 terminateO(r); 20762 ck_assert_str_eq(s, "null"); 20763 free(s); 20764 terminateO(self); 20765 20766 } 20767 20768 20769 void popBoolSmallArrayGT(CuTest *tc UNUSED) { 20770 20771 bool r; 20772 smallArrayt *self = allocG(rtSmallArrayt); 20773 20774 smallArrayt *r2 = self->f->pushBool(self, TRUE); 20775 ck_assert_ptr_ne(r2, null); 20776 r = popBoolSmallArrayG(self, null); 20777 ck_assert(r); 20778 terminateO(self); 20779 20780 } 20781 20782 20783 void popDoubleSmallArrayGT(CuTest *tc UNUSED) { 20784 20785 double r; 20786 smallArrayt *self = allocG(rtSmallArrayt); 20787 20788 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 20789 ck_assert_ptr_ne(r2, null); 20790 r = popDoubleSmallArrayG(self, 0); 20791 ck_assert(r==2.0); 20792 terminateO(self); 20793 20794 } 20795 20796 20797 void popIntSmallArrayGT(CuTest *tc UNUSED) { 20798 20799 int64_t r; 20800 smallArrayt *self = allocG(rtSmallArrayt); 20801 20802 smallArrayt *r2 = self->f->pushInt(self, 2); 20803 ck_assert_ptr_ne(r2, null); 20804 r = popIntSmallArrayG(self, 0); 20805 ck_assert_int_eq(r, 2); 20806 terminateO(self); 20807 20808 } 20809 20810 20811 void popInt32SmallArrayGT(CuTest *tc UNUSED) { 20812 20813 int32_t r; 20814 smallArrayt *self = allocG(rtSmallArrayt); 20815 20816 smallArrayt *r2 = self->f->pushInt(self, 2); 20817 ck_assert_ptr_ne(r2, null); 20818 r = popInt32SmallArrayG(self, 0); 20819 ck_assert_int_eq(r, 2); 20820 terminateO(self); 20821 20822 } 20823 20824 20825 void popUintSmallArrayGT(CuTest *tc UNUSED) { 20826 20827 uint64_t r; 20828 smallArrayt *self = allocG(rtSmallArrayt); 20829 20830 smallArrayt *r2 = self->f->pushInt(self, 2); 20831 ck_assert_ptr_ne(r2, null); 20832 r = popUintSmallArrayG(self, 0); 20833 ck_assert_int_eq(r, 2); 20834 terminateO(self); 20835 20836 } 20837 20838 20839 void popUint32SmallArrayGT(CuTest *tc UNUSED) { 20840 20841 uint32_t r; 20842 smallArrayt *self = allocG(rtSmallArrayt); 20843 20844 smallArrayt *r2 = self->f->pushInt(self, 2); 20845 ck_assert_ptr_ne(r2, null); 20846 r = popUint32SmallArrayG(self, 0); 20847 ck_assert_int_eq(r, 2); 20848 terminateO(self); 20849 20850 } 20851 20852 20853 void popSSmallArrayGT(CuTest *tc UNUSED) { 20854 20855 char* r; 20856 smallArrayt *self = allocG(rtSmallArrayt); 20857 20858 smallArrayt *r2 = self->f->pushS(self, "2"); 20859 ck_assert_ptr_ne(r2, null); 20860 r = popSSmallArrayG(self, null); 20861 ck_assert_str_eq(r, "2"); 20862 free(r); 20863 terminateO(self); 20864 20865 } 20866 20867 20868 void popDictSmallArrayGT(CuTest *tc UNUSED) { 20869 20870 smallDictt* r; 20871 smallArrayt *self = allocG(rtSmallArrayt); 20872 20873 createSmallDict(d); 20874 smallArrayt *r2 = self->f->pushDict(self, &d); 20875 ck_assert_ptr_ne(r2, null); 20876 r = popDictSmallArrayG(self, null); 20877 ck_assert_ptr_ne(r, null); 20878 char *s = toStringO(r); 20879 ck_assert_str_eq(s, "{}"); 20880 free(s); 20881 terminateO(r); 20882 terminateO(self); 20883 20884 } 20885 20886 20887 void popArraySmallArrayGT(CuTest *tc UNUSED) { 20888 20889 smallArrayt* r; 20890 smallArrayt *self = allocG(rtSmallArrayt); 20891 20892 createSmallArray(a); 20893 smallArrayt *r2 = self->f->pushArray(self, &a); 20894 ck_assert_ptr_ne(r2, null); 20895 r = popArraySmallArrayG(self, null); 20896 ck_assert_ptr_ne(r, null); 20897 char *s = toStringO(r); 20898 ck_assert_str_eq(s, "[]"); 20899 free(s); 20900 terminateO(r); 20901 terminateO(self); 20902 20903 } 20904 20905 20906 void popSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 20907 20908 smallBoolt* r; 20909 smallArrayt *self = allocG(rtSmallArrayt); 20910 20911 smallArrayt *r2 = self->f->pushBool(self, true); 20912 ck_assert_ptr_ne(r2, null); 20913 r = popSmallBoolSmallArrayG(self, null); 20914 ck_assert_ptr_ne(r, null); 20915 char *s = toStringO(r); 20916 ck_assert_str_eq(s, "true"); 20917 free(s); 20918 terminateO(r); 20919 terminateO(self); 20920 20921 } 20922 20923 20924 void popSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 20925 20926 smallBytest* r; 20927 smallArrayt *self = allocG(rtSmallArrayt); 20928 20929 createSmallBytes(b); 20930 smallArrayt *r2 = self->f->pushSmallBytes(self, &b); 20931 ck_assert_ptr_ne(r2, null); 20932 r = popSmallBytesSmallArrayG(self, null); 20933 ck_assert_ptr_ne(r, null); 20934 char *s = toStringO(r); 20935 ck_assert_str_eq(s, "[]"); 20936 free(s); 20937 terminateO(r); 20938 terminateO(self); 20939 20940 } 20941 20942 20943 void popSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 20944 20945 smallDoublet* r; 20946 smallArrayt *self = allocG(rtSmallArrayt); 20947 20948 smallArrayt *r2 = self->f->pushDouble(self, 1); 20949 ck_assert_ptr_ne(r2, null); 20950 r = popSmallDoubleSmallArrayG(self, null); 20951 ck_assert_ptr_ne(r, null); 20952 char *s = toStringO(r); 20953 ck_assert_str_eq(s, "1.000000e+00"); 20954 free(s); 20955 terminateO(r); 20956 terminateO(self); 20957 20958 } 20959 20960 20961 void popSmallIntSmallArrayGT(CuTest *tc UNUSED) { 20962 20963 smallIntt* r; 20964 smallArrayt *self = allocG(rtSmallArrayt); 20965 20966 smallArrayt *r2 = self->f->pushInt(self, 1); 20967 ck_assert_ptr_ne(r2, null); 20968 r = popSmallIntSmallArrayG(self, null); 20969 ck_assert_ptr_ne(r, null); 20970 char *s = toStringO(r); 20971 ck_assert_str_eq(s, "1"); 20972 free(s); 20973 terminateO(r); 20974 terminateO(self); 20975 20976 } 20977 20978 20979 void popSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 20980 20981 smallJsont* r; 20982 smallArrayt *self = allocG(rtSmallArrayt); 20983 20984 createSmallJson(j); 20985 smallArrayt *r2 = self->f->pushSmallJson(self, &j); 20986 ck_assert_ptr_ne(r2, null); 20987 r = popSmallJsonSmallArrayG(self, null); 20988 ck_assert_ptr_ne(r, null); 20989 char *s = toStringO(r); 20990 ck_assert_str_eq(s, "{}"); 20991 free(s); 20992 terminateO(r); 20993 terminateO(self); 20994 20995 } 20996 20997 20998 void popSmallStringSmallArrayGT(CuTest *tc UNUSED) { 20999 21000 smallStringt* r; 21001 smallArrayt *self = allocG(rtSmallArrayt); 21002 21003 createSmallString(S); 21004 smallArrayt *r2 = self->f->pushSmallString(self, &S); 21005 ck_assert_ptr_ne(r2, null); 21006 r = popSmallStringSmallArrayG(self, null); 21007 ck_assert_ptr_ne(r, null); 21008 char *s = toStringO(r); 21009 ck_assert_str_eq(s, ""); 21010 free(s); 21011 terminateO(r); 21012 terminateO(self); 21013 21014 } 21015 21016 21017 void popVoidSmallArrayGT(CuTest *tc UNUSED) { 21018 21019 void* r; 21020 smallArrayt *self = allocG(rtSmallArrayt); 21021 21022 createSmallContainer(c); 21023 setValO(&c, &r); 21024 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 21025 ck_assert_ptr_ne(r2, null); 21026 r = popVoidSmallArrayG(self, null); 21027 ck_assert_ptr_eq(r, &r); 21028 terminateO(self); 21029 21030 } 21031 21032 21033 void popSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 21034 21035 smallContainert* r; 21036 smallArrayt *self = allocG(rtSmallArrayt); 21037 21038 createSmallContainer(c); 21039 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 21040 ck_assert_ptr_ne(r2, null); 21041 r = popSmallContainerSmallArrayG(self, null); 21042 ck_assert_ptr_ne(r, null); 21043 char *s = toStringO(r); 21044 ck_assert_str_eq(s, "<data smallContainer>"); 21045 free(s); 21046 terminateO(r); 21047 terminateO(self); 21048 21049 } 21050 21051 21052 void prependSmallArrayGT(CuTest *tc UNUSED) { 21053 21054 smallArrayt* r; 21055 smallArrayt *self = allocG(rtSmallArrayt); 21056 baset *value = (baset*) allocSmallInt(1); 21057 21058 r = prependSmallArrayG(self, value); 21059 ck_assert_ptr_ne(r, null); 21060 finishO(value); 21061 char *s = toStringO(r); 21062 ck_assert_str_eq(s, "[1]"); 21063 free(s); 21064 terminateO(self); 21065 21066 } 21067 21068 21069 void prependUndefinedSmallArrayGT(CuTest *tc UNUSED) { 21070 21071 smallArrayt* r; 21072 smallArrayt *self = allocG(rtSmallArrayt); 21073 21074 r = prependUndefinedSmallArrayG(self, NULL); 21075 ck_assert_ptr_ne(r, null); 21076 char *s = toStringO(r); 21077 ck_assert_str_eq(s, "[null]"); 21078 free(s); 21079 terminateO(self); 21080 21081 } 21082 21083 21084 void prependBoolSmallArrayGT(CuTest *tc UNUSED) { 21085 21086 smallArrayt* r; 21087 smallArrayt *self = allocG(rtSmallArrayt); 21088 21089 r = prependBoolSmallArrayG(self, true); 21090 ck_assert_ptr_ne(r, null); 21091 char *s = toStringO(r); 21092 ck_assert_str_eq(s, "[true]"); 21093 free(s); 21094 terminateO(self); 21095 21096 } 21097 21098 21099 void prependDoubleSmallArrayGT(CuTest *tc UNUSED) { 21100 21101 smallArrayt* r; 21102 smallArrayt *self = allocG(rtSmallArrayt); 21103 21104 r = prependDoubleSmallArrayG(self, 1); 21105 ck_assert_ptr_ne(r, null); 21106 char *s = toStringO(r); 21107 ck_assert_str_eq(s, "[1.000000e+00]"); 21108 free(s); 21109 terminateO(self); 21110 21111 } 21112 21113 21114 void prependIntSmallArrayGT(CuTest *tc UNUSED) { 21115 21116 smallArrayt* r; 21117 smallArrayt *self = allocG(rtSmallArrayt); 21118 21119 r = prependIntSmallArrayG(self, 1); 21120 ck_assert_ptr_ne(r, null); 21121 char *s = toStringO(r); 21122 ck_assert_str_eq(s, "[1]"); 21123 free(s); 21124 terminateO(self); 21125 21126 } 21127 21128 21129 void prependSSmallArrayGT(CuTest *tc UNUSED) { 21130 21131 smallArrayt* r; 21132 smallArrayt *self = allocG(rtSmallArrayt); 21133 21134 r = prependSSmallArrayG(self, "qwe"); 21135 ck_assert_ptr_ne(r, null); 21136 char *s = toStringO(r); 21137 ck_assert_str_eq(s, "[\"qwe\"]"); 21138 free(s); 21139 terminateO(self); 21140 21141 } 21142 21143 21144 void prependCharSmallArrayGT(CuTest *tc UNUSED) { 21145 21146 smallArrayt* r; 21147 smallArrayt *self = allocG(rtSmallArrayt); 21148 21149 r = prependCharSmallArrayG(self, 'Q'); 21150 ck_assert_ptr_ne(r, null); 21151 char *s = toStringO(r); 21152 ck_assert_str_eq(s, "[\"Q\"]"); 21153 free(s); 21154 terminateO(self); 21155 21156 } 21157 21158 21159 void prependDictSmallArrayGT(CuTest *tc UNUSED) { 21160 21161 smallArrayt* r; 21162 smallArrayt *self = allocG(rtSmallArrayt); 21163 smallDictt *dict = allocSmallDict(); 21164 21165 r = prependDictSmallArrayG(self, dict); 21166 ck_assert_ptr_ne(r, null); 21167 finishO(dict); 21168 char *s = toStringO(r); 21169 ck_assert_str_eq(s, "[{}]"); 21170 free(s); 21171 terminateO(self); 21172 21173 } 21174 21175 21176 void prependArraySmallArrayGT(CuTest *tc UNUSED) { 21177 21178 smallArrayt* r; 21179 smallArrayt *self = allocG(rtSmallArrayt); 21180 smallArrayt *array = allocSmallArray(); 21181 21182 r = prependArraySmallArrayG(self, array); 21183 ck_assert_ptr_ne(r, null); 21184 finishO(array); 21185 char *s = toStringO(r); 21186 ck_assert_str_eq(s, "[[]]"); 21187 free(s); 21188 terminateO(self); 21189 21190 } 21191 21192 21193 void prependArraycSmallArrayGT(CuTest *tc UNUSED) { 21194 21195 smallArrayt* r; 21196 smallArrayt *self = allocG(rtSmallArrayt); 21197 char **array = listCreateS("a","bb"); 21198 21199 r = prependArraycSmallArrayG(self, array); 21200 ck_assert_ptr_ne(r, null); 21201 ck_assert_int_eq(lenO(r), 1); 21202 listFreeS(array); 21203 char *s = toStringO(r); 21204 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 21205 free(s); 21206 terminateO(self); 21207 21208 } 21209 21210 21211 void prependCArraycSmallArrayGT(CuTest *tc UNUSED) { 21212 21213 smallArrayt* r; 21214 smallArrayt *self = allocG(rtSmallArrayt); 21215 const char *array[] = {"a", "bb", NULL}; 21216 21217 r = prependCArraycSmallArrayG(self, array); 21218 ck_assert_ptr_ne(r, null); 21219 ck_assert_int_eq(lenO(r), 1); 21220 char *s = toStringO(r); 21221 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 21222 free(s); 21223 terminateO(self); 21224 21225 } 21226 21227 21228 void prependVoidSmallArrayGT(CuTest *tc UNUSED) { 21229 21230 smallArrayt* r; 21231 smallArrayt *self = allocG(rtSmallArrayt); 21232 21233 // NULL value 21234 r = prependVoidSmallArrayG(self, NULL); 21235 ck_assert_ptr_ne(r, null); 21236 char *s = toStringO(r); 21237 ck_assert_str_eq(s, "[null]"); 21238 free(s); 21239 // value 21240 r = prependVoidSmallArrayG(self, r); 21241 s = toStringO(r); 21242 ck_assert_str_eq(s, "[\"<data container>\",null]"); 21243 free(s); 21244 terminateO(self); 21245 21246 } 21247 21248 21249 void prependSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 21250 21251 smallArrayt* r; 21252 smallArrayt *self = allocG(rtSmallArrayt); 21253 smallBoolt *value = allocSmallBool(true); 21254 21255 r = prependSmallBoolSmallArrayG(self, value); 21256 ck_assert_ptr_ne(r, null); 21257 finishO(value); 21258 char *s = toStringO(r); 21259 ck_assert_str_eq(s, "[true]"); 21260 free(s); 21261 terminateO(self); 21262 21263 } 21264 21265 21266 void prependSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 21267 21268 smallArrayt* r; 21269 smallArrayt *self = allocG(rtSmallArrayt); 21270 smallBytest *value = allocSmallBytes("qwe", 3); 21271 21272 r = prependSmallBytesSmallArrayG(self, value); 21273 ck_assert_ptr_ne(r, null); 21274 finishO(value); 21275 char *s = toStringO(r); 21276 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 21277 free(s); 21278 terminateO(self); 21279 21280 } 21281 21282 21283 void prependSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 21284 21285 smallArrayt* r; 21286 smallArrayt *self = allocG(rtSmallArrayt); 21287 smallDoublet *value = allocSmallDouble(1); 21288 21289 r = prependSmallDoubleSmallArrayG(self, value); 21290 ck_assert_ptr_ne(r, null); 21291 finishO(value); 21292 char *s = toStringO(r); 21293 ck_assert_str_eq(s, "[1.000000e+00]"); 21294 free(s); 21295 terminateO(self); 21296 21297 } 21298 21299 21300 void prependSmallIntSmallArrayGT(CuTest *tc UNUSED) { 21301 21302 smallArrayt* r; 21303 smallArrayt *self = allocG(rtSmallArrayt); 21304 smallIntt *value = allocSmallInt(1); 21305 21306 r = prependSmallIntSmallArrayG(self, value); 21307 ck_assert_ptr_ne(r, null); 21308 finishO(value); 21309 char *s = toStringO(r); 21310 ck_assert_str_eq(s, "[1]"); 21311 free(s); 21312 terminateO(self); 21313 21314 } 21315 21316 21317 void prependSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 21318 21319 smallArrayt* r; 21320 smallArrayt *self = allocG(rtSmallArrayt); 21321 smallJsont *value = allocSmallJson(); 21322 21323 r = prependSmallJsonSmallArrayG(self, value); 21324 ck_assert_ptr_ne(r, null); 21325 finishO(value); 21326 char *s = toStringO(r); 21327 ck_assert_str_eq(s, "[{}]"); 21328 free(s); 21329 terminateO(self); 21330 21331 } 21332 21333 21334 void prependSmallStringSmallArrayGT(CuTest *tc UNUSED) { 21335 21336 smallArrayt* r; 21337 smallArrayt *self = allocG(rtSmallArrayt); 21338 smallStringt *string = allocSmallString("qwe"); 21339 21340 r = prependSmallStringSmallArrayG(self, string); 21341 ck_assert_ptr_ne(r, null); 21342 finishO(string); 21343 char *s = toStringO(r); 21344 ck_assert_str_eq(s, "[\"qwe\"]"); 21345 free(s); 21346 terminateO(self); 21347 21348 } 21349 21350 21351 void prependSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 21352 21353 smallArrayt* r; 21354 smallArrayt *self = allocG(rtSmallArrayt); 21355 21356 createSmallContainer(c); 21357 r = prependSmallContainerSmallArrayG(self, &c); 21358 ck_assert_ptr_ne(r, null); 21359 char *s = toStringO(r); 21360 ck_assert_str_eq(s, "[\"<data container>\"]"); 21361 free(s); 21362 terminateO(self); 21363 21364 } 21365 21366 21367 void prependNFreeSmallArrayGT(CuTest *tc UNUSED) { 21368 21369 smallArrayt* r; 21370 smallArrayt *self = allocG(rtSmallArrayt); 21371 baset *value = (baset*) allocSmallInt(1); 21372 21373 r = prependNFreeSmallArrayG(self, value); 21374 ck_assert_ptr_ne(r, null); 21375 char *s = toStringO(r); 21376 ck_assert_str_eq(s, "[1]"); 21377 free(s); 21378 terminateO(self); 21379 21380 } 21381 21382 21383 void prependNFreeUndefinedSmallArrayGT(CuTest *tc UNUSED) { 21384 21385 smallArrayt* r; 21386 smallArrayt *self = allocG(rtSmallArrayt); 21387 undefinedt *value = allocUndefined(); 21388 21389 r = prependNFreeUndefinedSmallArrayG(self, value); 21390 ck_assert_ptr_ne(r, null); 21391 char *s = toStringO(r); 21392 ck_assert_str_eq(s, "[null]"); 21393 free(s); 21394 terminateO(self); 21395 21396 } 21397 21398 21399 void prependNFreeSSmallArrayGT(CuTest *tc UNUSED) { 21400 21401 smallArrayt* r; 21402 smallArrayt *self = allocG(rtSmallArrayt); 21403 21404 r = prependNFreeSSmallArrayG(self, strdup("qwe")); 21405 ck_assert_ptr_ne(r, null); 21406 char *s = toStringO(r); 21407 ck_assert_str_eq(s, "[\"qwe\"]"); 21408 free(s); 21409 terminateO(self); 21410 21411 } 21412 21413 21414 void prependNFreeDictSmallArrayGT(CuTest *tc UNUSED) { 21415 21416 smallArrayt* r; 21417 smallArrayt *self = allocG(rtSmallArrayt); 21418 smallDictt *dict = allocSmallDict(); 21419 21420 r = prependNFreeDictSmallArrayG(self, dict); 21421 ck_assert_ptr_ne(r, null); 21422 char *s = toStringO(r); 21423 ck_assert_str_eq(s, "[{}]"); 21424 free(s); 21425 terminateO(self); 21426 21427 } 21428 21429 21430 void prependNFreeArraySmallArrayGT(CuTest *tc UNUSED) { 21431 21432 smallArrayt* r; 21433 smallArrayt *self = allocG(rtSmallArrayt); 21434 smallArrayt *array = allocSmallArray(); 21435 21436 r = prependNFreeArraySmallArrayG(self, array); 21437 ck_assert_ptr_ne(r, null); 21438 char *s = toStringO(r); 21439 ck_assert_str_eq(s, "[[]]"); 21440 free(s); 21441 terminateO(self); 21442 21443 } 21444 21445 21446 void prependNFreeArraycSmallArrayGT(CuTest *tc UNUSED) { 21447 21448 smallArrayt* r; 21449 smallArrayt *self = allocG(rtSmallArrayt); 21450 char **array = listCreateS("a","bb"); 21451 21452 r = prependNFreeArraycSmallArrayG(self, array); 21453 ck_assert_ptr_ne(r, null); 21454 ck_assert_int_eq(lenO(r), 1); 21455 char *s = toStringO(r); 21456 ck_assert_str_eq(s, "[[\"a\",\"bb\"]]"); 21457 free(s); 21458 terminateO(self); 21459 21460 } 21461 21462 21463 void prependNFreeSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 21464 21465 smallArrayt* r; 21466 smallArrayt *self = allocG(rtSmallArrayt); 21467 smallBoolt *value = allocSmallBool(true); 21468 21469 r = prependNFreeSmallBoolSmallArrayG(self, value); 21470 ck_assert_ptr_ne(r, null); 21471 char *s = toStringO(r); 21472 ck_assert_str_eq(s, "[true]"); 21473 free(s); 21474 terminateO(self); 21475 21476 } 21477 21478 21479 void prependNFreeSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 21480 21481 smallArrayt* r; 21482 smallArrayt *self = allocG(rtSmallArrayt); 21483 smallBytest *value = allocSmallBytes("qwe", 3); 21484 21485 r = prependNFreeSmallBytesSmallArrayG(self, value); 21486 ck_assert_ptr_ne(r, null); 21487 char *s = toStringO(r); 21488 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 21489 free(s); 21490 terminateO(self); 21491 21492 } 21493 21494 21495 void prependNFreeSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 21496 21497 smallArrayt* r; 21498 smallArrayt *self = allocG(rtSmallArrayt); 21499 smallDoublet *value = allocSmallDouble(1); 21500 21501 r = prependNFreeSmallDoubleSmallArrayG(self, value); 21502 ck_assert_ptr_ne(r, null); 21503 char *s = toStringO(r); 21504 ck_assert_str_eq(s, "[1.000000e+00]"); 21505 free(s); 21506 terminateO(self); 21507 21508 } 21509 21510 21511 void prependNFreeSmallIntSmallArrayGT(CuTest *tc UNUSED) { 21512 21513 smallArrayt* r; 21514 smallArrayt *self = allocG(rtSmallArrayt); 21515 smallIntt *value = allocSmallInt(1); 21516 21517 r = prependNFreeSmallIntSmallArrayG(self, value); 21518 ck_assert_ptr_ne(r, null); 21519 char *s = toStringO(r); 21520 ck_assert_str_eq(s, "[1]"); 21521 free(s); 21522 terminateO(self); 21523 21524 } 21525 21526 21527 void prependNFreeSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 21528 21529 smallArrayt* r; 21530 smallArrayt *self = allocG(rtSmallArrayt); 21531 smallJsont *value = allocSmallJson(); 21532 21533 r = prependNFreeSmallJsonSmallArrayG(self, value); 21534 ck_assert_ptr_ne(r, null); 21535 char *s = toStringO(r); 21536 ck_assert_str_eq(s, "[{}]"); 21537 free(s); 21538 terminateO(self); 21539 21540 } 21541 21542 21543 void prependNFreeSmallStringSmallArrayGT(CuTest *tc UNUSED) { 21544 21545 smallArrayt* r; 21546 smallArrayt *self = allocG(rtSmallArrayt); 21547 smallStringt *string = allocSmallString("qwe"); 21548 21549 r = prependNFreeSmallStringSmallArrayG(self, string); 21550 ck_assert_ptr_ne(r, null); 21551 char *s = toStringO(r); 21552 ck_assert_str_eq(s, "[\"qwe\"]"); 21553 free(s); 21554 terminateO(self); 21555 21556 } 21557 21558 21559 void prependNFreeSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 21560 21561 smallArrayt* r; 21562 smallArrayt *self = allocG(rtSmallArrayt); 21563 21564 createAllocateSmallContainer(c); 21565 r = prependNFreeSmallContainerSmallArrayG(self, c); 21566 ck_assert_ptr_ne(r, null); 21567 char *s = toStringO(r); 21568 ck_assert_str_eq(s, "[\"<data container>\"]"); 21569 free(s); 21570 terminateO(self); 21571 21572 } 21573 21574 21575 void dequeueSmallArrayGT(CuTest *tc UNUSED) { 21576 21577 baset* r; 21578 smallArrayt *self = allocG(rtSmallArrayt); 21579 21580 smallArrayt *r2 = self->f->pushInt(self, 1); 21581 ck_assert_ptr_ne(r2, null); 21582 r = dequeueSmallArrayG(self, NULL); 21583 ck_assert_ptr_ne(r, null); 21584 char *s = toStringO(r); 21585 terminateO(r); 21586 ck_assert_str_eq(s, "1"); 21587 free(s); 21588 terminateO(self); 21589 21590 } 21591 21592 21593 void dequeueUndefinedSmallArrayGT(CuTest *tc UNUSED) { 21594 21595 undefinedt* r; 21596 smallArrayt *self = allocG(rtSmallArrayt); 21597 21598 smallArrayt *r2 = self->f->pushUndefined(self); 21599 ck_assert_ptr_ne(r2, null); 21600 r = dequeueUndefinedSmallArrayG(self, null); 21601 ck_assert_ptr_ne(r, null); 21602 char *s = toStringO(r); 21603 terminateO(r); 21604 ck_assert_str_eq(s, "null"); 21605 free(s); 21606 terminateO(self); 21607 21608 } 21609 21610 21611 void dequeueBoolSmallArrayGT(CuTest *tc UNUSED) { 21612 21613 bool r; 21614 smallArrayt *self = allocG(rtSmallArrayt); 21615 21616 smallArrayt *r2 = self->f->pushBool(self, TRUE); 21617 ck_assert_ptr_ne(r2, null); 21618 r = dequeueBoolSmallArrayG(self, null); 21619 ck_assert(r); 21620 terminateO(self); 21621 21622 } 21623 21624 21625 void dequeueDoubleSmallArrayGT(CuTest *tc UNUSED) { 21626 21627 double r; 21628 smallArrayt *self = allocG(rtSmallArrayt); 21629 21630 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 21631 ck_assert_ptr_ne(r2, null); 21632 r = dequeueDoubleSmallArrayG(self, 0); 21633 ck_assert(r==2.0); 21634 terminateO(self); 21635 21636 } 21637 21638 21639 void dequeueIntSmallArrayGT(CuTest *tc UNUSED) { 21640 21641 int64_t r; 21642 smallArrayt *self = allocG(rtSmallArrayt); 21643 21644 smallArrayt *r2 = self->f->pushInt(self, 2); 21645 ck_assert_ptr_ne(r2, null); 21646 r = dequeueIntSmallArrayG(self, 0); 21647 ck_assert_int_eq(r, 2); 21648 terminateO(self); 21649 21650 } 21651 21652 21653 void dequeueInt32SmallArrayGT(CuTest *tc UNUSED) { 21654 21655 int32_t r; 21656 smallArrayt *self = allocG(rtSmallArrayt); 21657 21658 smallArrayt *r2 = self->f->pushInt(self, 2); 21659 ck_assert_ptr_ne(r2, null); 21660 r = dequeueInt32SmallArrayG(self, 0); 21661 ck_assert_int_eq(r, 2); 21662 terminateO(self); 21663 21664 } 21665 21666 21667 void dequeueUintSmallArrayGT(CuTest *tc UNUSED) { 21668 21669 uint64_t r; 21670 smallArrayt *self = allocG(rtSmallArrayt); 21671 21672 smallArrayt *r2 = self->f->pushInt(self, 2); 21673 ck_assert_ptr_ne(r2, null); 21674 r = dequeueUintSmallArrayG(self, 0); 21675 ck_assert_int_eq(r, 2); 21676 terminateO(self); 21677 21678 } 21679 21680 21681 void dequeueUint32SmallArrayGT(CuTest *tc UNUSED) { 21682 21683 uint32_t r; 21684 smallArrayt *self = allocG(rtSmallArrayt); 21685 21686 smallArrayt *r2 = self->f->pushInt(self, 2); 21687 ck_assert_ptr_ne(r2, null); 21688 r = dequeueUint32SmallArrayG(self, 0); 21689 ck_assert_int_eq(r, 2); 21690 terminateO(self); 21691 21692 } 21693 21694 21695 void dequeueSSmallArrayGT(CuTest *tc UNUSED) { 21696 21697 char* r; 21698 smallArrayt *self = allocG(rtSmallArrayt); 21699 21700 smallArrayt *r2 = self->f->pushS(self, "2"); 21701 ck_assert_ptr_ne(r2, null); 21702 r = dequeueSSmallArrayG(self, null); 21703 ck_assert_str_eq(r, "2"); 21704 free(r); 21705 terminateO(self); 21706 21707 } 21708 21709 21710 void dequeueDictSmallArrayGT(CuTest *tc UNUSED) { 21711 21712 smallDictt* r; 21713 smallArrayt *self = allocG(rtSmallArrayt); 21714 21715 createSmallDict(d); 21716 smallArrayt *r2 = self->f->pushDict(self, &d); 21717 ck_assert_ptr_ne(r2, null); 21718 r = dequeueDictSmallArrayG(self, null); 21719 ck_assert_ptr_ne(r, null); 21720 char *s = toStringO(r); 21721 ck_assert_str_eq(s, "{}"); 21722 free(s); 21723 terminateO(r); 21724 terminateO(self); 21725 21726 } 21727 21728 21729 void dequeueArraySmallArrayGT(CuTest *tc UNUSED) { 21730 21731 smallArrayt* r; 21732 smallArrayt *self = allocG(rtSmallArrayt); 21733 21734 createSmallArray(a); 21735 smallArrayt *r2 = self->f->pushArray(self, &a); 21736 ck_assert_ptr_ne(r2, null); 21737 r = dequeueArraySmallArrayG(self, null); 21738 ck_assert_ptr_ne(r, null); 21739 char *s = toStringO(r); 21740 ck_assert_str_eq(s, "[]"); 21741 free(s); 21742 terminateO(r); 21743 terminateO(self); 21744 21745 } 21746 21747 21748 void dequeueSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 21749 21750 smallBoolt* r; 21751 smallArrayt *self = allocG(rtSmallArrayt); 21752 21753 smallArrayt *r2 = self->f->pushBool(self, true); 21754 ck_assert_ptr_ne(r2, null); 21755 r = dequeueSmallBoolSmallArrayG(self, null); 21756 ck_assert_ptr_ne(r, null); 21757 char *s = toStringO(r); 21758 ck_assert_str_eq(s, "true"); 21759 free(s); 21760 terminateO(r); 21761 terminateO(self); 21762 21763 } 21764 21765 21766 void dequeueSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 21767 21768 smallBytest* r; 21769 smallArrayt *self = allocG(rtSmallArrayt); 21770 21771 createSmallBytes(b); 21772 smallArrayt *r2 = self->f->pushSmallBytes(self, &b); 21773 ck_assert_ptr_ne(r2, null); 21774 r = dequeueSmallBytesSmallArrayG(self, null); 21775 ck_assert_ptr_ne(r, null); 21776 char *s = toStringO(r); 21777 ck_assert_str_eq(s, "[]"); 21778 free(s); 21779 terminateO(r); 21780 terminateO(self); 21781 21782 } 21783 21784 21785 void dequeueSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 21786 21787 smallDoublet* r; 21788 smallArrayt *self = allocG(rtSmallArrayt); 21789 21790 smallArrayt *r2 = self->f->pushDouble(self, 1); 21791 ck_assert_ptr_ne(r2, null); 21792 r = dequeueSmallDoubleSmallArrayG(self, null); 21793 ck_assert_ptr_ne(r, null); 21794 char *s = toStringO(r); 21795 ck_assert_str_eq(s, "1.000000e+00"); 21796 free(s); 21797 terminateO(r); 21798 terminateO(self); 21799 21800 } 21801 21802 21803 void dequeueSmallIntSmallArrayGT(CuTest *tc UNUSED) { 21804 21805 smallIntt* r; 21806 smallArrayt *self = allocG(rtSmallArrayt); 21807 21808 smallArrayt *r2 = self->f->pushInt(self, 1); 21809 ck_assert_ptr_ne(r2, null); 21810 r = dequeueSmallIntSmallArrayG(self, null); 21811 ck_assert_ptr_ne(r, null); 21812 char *s = toStringO(r); 21813 ck_assert_str_eq(s, "1"); 21814 free(s); 21815 terminateO(r); 21816 terminateO(self); 21817 21818 } 21819 21820 21821 void dequeueSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 21822 21823 smallJsont* r; 21824 smallArrayt *self = allocG(rtSmallArrayt); 21825 21826 createSmallJson(j); 21827 smallArrayt *r2 = self->f->pushSmallJson(self, &j); 21828 ck_assert_ptr_ne(r2, null); 21829 r = dequeueSmallJsonSmallArrayG(self, null); 21830 ck_assert_ptr_ne(r, null); 21831 char *s = toStringO(r); 21832 ck_assert_str_eq(s, "{}"); 21833 free(s); 21834 terminateO(r); 21835 terminateO(self); 21836 21837 } 21838 21839 21840 void dequeueSmallStringSmallArrayGT(CuTest *tc UNUSED) { 21841 21842 smallStringt* r; 21843 smallArrayt *self = allocG(rtSmallArrayt); 21844 21845 createSmallString(S); 21846 smallArrayt *r2 = self->f->pushSmallString(self, &S); 21847 ck_assert_ptr_ne(r2, null); 21848 r = dequeueSmallStringSmallArrayG(self, null); 21849 ck_assert_ptr_ne(r, null); 21850 char *s = toStringO(r); 21851 ck_assert_str_eq(s, ""); 21852 free(s); 21853 terminateO(r); 21854 terminateO(self); 21855 21856 } 21857 21858 21859 void dequeueVoidSmallArrayGT(CuTest *tc UNUSED) { 21860 21861 void* r; 21862 smallArrayt *self = allocG(rtSmallArrayt); 21863 21864 createSmallContainer(c); 21865 setValO(&c, &r); 21866 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 21867 ck_assert_ptr_ne(r2, null); 21868 r = dequeueVoidSmallArrayG(self, null); 21869 ck_assert_ptr_eq(r, &r); 21870 terminateO(self); 21871 21872 } 21873 21874 21875 void dequeueSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 21876 21877 smallContainert* r; 21878 smallArrayt *self = allocG(rtSmallArrayt); 21879 21880 createSmallContainer(c); 21881 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 21882 ck_assert_ptr_ne(r2, null); 21883 r = dequeueSmallContainerSmallArrayG(self, null); 21884 ck_assert_ptr_ne(r, null); 21885 char *s = toStringO(r); 21886 ck_assert_str_eq(s, "<data smallContainer>"); 21887 free(s); 21888 terminateO(r); 21889 terminateO(self); 21890 21891 } 21892 21893 21894 21895 void getAtSmallArrayGT(CuTest *tc UNUSED) { 21896 21897 baset* r; 21898 smallArrayt *self = allocG(rtSmallArrayt); 21899 21900 smallArrayt *r2 = self->f->pushInt(self, 1); 21901 ck_assert_ptr_ne(r2, null); 21902 r = getAtSmallArrayG(self, NULL, 0); 21903 ck_assert_ptr_ne(r, null); 21904 char *s = toStringO(r); 21905 finishO(r); 21906 ck_assert_str_eq(s, "1"); 21907 free(s); 21908 terminateO(self); 21909 21910 } 21911 21912 21913 void getAtUndefinedSmallArrayGT(CuTest *tc UNUSED) { 21914 21915 undefinedt* r; 21916 smallArrayt *self = allocG(rtSmallArrayt); 21917 21918 smallArrayt *r2 = self->f->pushUndefined(self); 21919 ck_assert_ptr_ne(r2, null); 21920 r = getAtUndefinedSmallArrayG(self, null, 0); 21921 ck_assert_ptr_ne(r, null); 21922 char *s = toStringO(r); 21923 finishO(r); 21924 ck_assert_str_eq(s, "null"); 21925 free(s); 21926 terminateO(self); 21927 21928 } 21929 21930 21931 void getAtBoolSmallArrayGT(CuTest *tc UNUSED) { 21932 21933 bool r; 21934 smallArrayt *self = allocG(rtSmallArrayt); 21935 21936 smallArrayt *r2 = self->f->pushBool(self, TRUE); 21937 ck_assert_ptr_ne(r2, null); 21938 r = getAtBoolSmallArrayG(self, null, 0); 21939 ck_assert(r); 21940 terminateO(self); 21941 21942 } 21943 21944 21945 void getAtBoolPSmallArrayGT(CuTest *tc UNUSED) { 21946 21947 bool* r; 21948 smallArrayt *self = allocG(rtSmallArrayt); 21949 21950 smallArrayt *r2 = self->f->pushBool(self, TRUE); 21951 ck_assert_ptr_ne(r2, null); 21952 r = getAtBoolPSmallArrayG(self, null, 0); 21953 ck_assert_ptr_ne(r, null); 21954 ck_assert(*r); 21955 terminateO(self); 21956 21957 } 21958 21959 21960 void getAtDoubleSmallArrayGT(CuTest *tc UNUSED) { 21961 21962 double r; 21963 smallArrayt *self = allocG(rtSmallArrayt); 21964 21965 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 21966 ck_assert_ptr_ne(r2, null); 21967 r = getAtDoubleSmallArrayG(self, 0, 0); 21968 ck_assert(r==2.0); 21969 terminateO(self); 21970 21971 } 21972 21973 21974 void getAtDoublePSmallArrayGT(CuTest *tc UNUSED) { 21975 21976 double* r; 21977 smallArrayt *self = allocG(rtSmallArrayt); 21978 21979 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 21980 ck_assert_ptr_ne(r2, null); 21981 r = getAtDoublePSmallArrayG(self, 0, 0); 21982 ck_assert_ptr_ne(r, null); 21983 ck_assert(*r==2.0); 21984 terminateO(self); 21985 21986 } 21987 21988 21989 void getAtIntSmallArrayGT(CuTest *tc UNUSED) { 21990 21991 int64_t r; 21992 smallArrayt *self = allocG(rtSmallArrayt); 21993 21994 smallArrayt *r2 = self->f->pushInt(self, 2); 21995 ck_assert_ptr_ne(r2, null); 21996 r = getAtIntSmallArrayG(self, 0, 0); 21997 ck_assert_int_eq(r, 2); 21998 terminateO(self); 21999 22000 } 22001 22002 22003 void getAtIntPSmallArrayGT(CuTest *tc UNUSED) { 22004 22005 int64_t* r; 22006 smallArrayt *self = allocG(rtSmallArrayt); 22007 22008 smallArrayt *r2 = self->f->pushInt(self, 2); 22009 ck_assert_ptr_ne(r2, null); 22010 r = getAtIntPSmallArrayG(self, 0, 0); 22011 ck_assert_ptr_ne(r, null); 22012 ck_assert_int_eq(*r, 2); 22013 terminateO(self); 22014 22015 } 22016 22017 22018 void getAtInt32SmallArrayGT(CuTest *tc UNUSED) { 22019 22020 int32_t r; 22021 smallArrayt *self = allocG(rtSmallArrayt); 22022 22023 smallArrayt *r2 = self->f->pushInt(self, 2); 22024 ck_assert_ptr_ne(r2, null); 22025 r = getAtInt32SmallArrayG(self, 0, 0); 22026 ck_assert_int_eq(r, 2); 22027 terminateO(self); 22028 22029 } 22030 22031 22032 void getAtInt32PSmallArrayGT(CuTest *tc UNUSED) { 22033 22034 int32_t* r; 22035 smallArrayt *self = allocG(rtSmallArrayt); 22036 22037 smallArrayt *r2 = self->f->pushInt(self, 2); 22038 ck_assert_ptr_ne(r2, null); 22039 r = getAtInt32PSmallArrayG(self, 0, 0); 22040 ck_assert_ptr_ne(r, null); 22041 ck_assert_int_eq(*r, 2); 22042 terminateO(self); 22043 22044 } 22045 22046 22047 void getAtUintSmallArrayGT(CuTest *tc UNUSED) { 22048 22049 uint64_t r; 22050 smallArrayt *self = allocG(rtSmallArrayt); 22051 22052 smallArrayt *r2 = self->f->pushInt(self, 2); 22053 ck_assert_ptr_ne(r2, null); 22054 r = getAtUintSmallArrayG(self, 0, 0); 22055 ck_assert_int_eq(r, 2); 22056 terminateO(self); 22057 22058 } 22059 22060 22061 void getAtUintPSmallArrayGT(CuTest *tc UNUSED) { 22062 22063 uint64_t* r; 22064 smallArrayt *self = allocG(rtSmallArrayt); 22065 22066 smallArrayt *r2 = self->f->pushInt(self, 2); 22067 ck_assert_ptr_ne(r2, null); 22068 r = getAtUintPSmallArrayG(self, 0, 0); 22069 ck_assert_ptr_ne(r, null); 22070 ck_assert_int_eq(*r, 2); 22071 terminateO(self); 22072 22073 } 22074 22075 22076 void getAtUint32SmallArrayGT(CuTest *tc UNUSED) { 22077 22078 uint32_t r; 22079 smallArrayt *self = allocG(rtSmallArrayt); 22080 22081 smallArrayt *r2 = self->f->pushInt(self, 2); 22082 ck_assert_ptr_ne(r2, null); 22083 r = getAtUint32SmallArrayG(self, 0, 0); 22084 ck_assert_int_eq(r, 2); 22085 terminateO(self); 22086 22087 } 22088 22089 22090 void getAtUint32PSmallArrayGT(CuTest *tc UNUSED) { 22091 22092 uint32_t* r; 22093 smallArrayt *self = allocG(rtSmallArrayt); 22094 22095 smallArrayt *r2 = self->f->pushInt(self, 2); 22096 ck_assert_ptr_ne(r2, null); 22097 r = getAtUint32PSmallArrayG(self, 0, 0); 22098 ck_assert_ptr_ne(r, null); 22099 ck_assert_int_eq(*r, 2); 22100 terminateO(self); 22101 22102 } 22103 22104 22105 void getAtSSmallArrayGT(CuTest *tc UNUSED) { 22106 22107 char* r; 22108 smallArrayt *self = allocG(rtSmallArrayt); 22109 22110 smallArrayt *r2 = self->f->pushS(self, "2"); 22111 ck_assert_ptr_ne(r2, null); 22112 r = getAtSSmallArrayG(self, null, 0); 22113 ck_assert_str_eq(r, "2"); 22114 terminateO(self); 22115 22116 } 22117 22118 22119 void getAtDictSmallArrayGT(CuTest *tc UNUSED) { 22120 22121 smallDictt* r; 22122 smallArrayt *self = allocG(rtSmallArrayt); 22123 22124 createSmallDict(d); 22125 smallArrayt *r2 = self->f->pushDict(self, &d); 22126 ck_assert_ptr_ne(r2, null); 22127 r = getAtDictSmallArrayG(self, null, 0); 22128 ck_assert_ptr_ne(r, null); 22129 char *s = toStringO(r); 22130 ck_assert_str_eq(s, "{}"); 22131 free(s); 22132 finishO(r); 22133 terminateO(self); 22134 22135 } 22136 22137 22138 void getAtArraySmallArrayGT(CuTest *tc UNUSED) { 22139 22140 smallArrayt* r; 22141 smallArrayt *self = allocG(rtSmallArrayt); 22142 22143 createSmallArray(a); 22144 smallArrayt *r2 = self->f->pushArray(self, &a); 22145 ck_assert_ptr_ne(r2, null); 22146 r = getAtArraySmallArrayG(self, null, 0); 22147 ck_assert_ptr_ne(r, null); 22148 char *s = toStringO(r); 22149 ck_assert_str_eq(s, "[]"); 22150 free(s); 22151 finishO(r); 22152 terminateO(self); 22153 22154 } 22155 22156 22157 void getAtSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 22158 22159 smallBoolt* r; 22160 smallArrayt *self = allocG(rtSmallArrayt); 22161 22162 smallArrayt *r2 = self->f->pushBool(self, true); 22163 ck_assert_ptr_ne(r2, null); 22164 r = getAtSmallBoolSmallArrayG(self, null, 0); 22165 ck_assert_ptr_ne(r, null); 22166 char *s = toStringO(r); 22167 ck_assert_str_eq(s, "true"); 22168 free(s); 22169 finishO(r); 22170 terminateO(self); 22171 22172 } 22173 22174 22175 void getAtSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 22176 22177 smallBytest* r; 22178 smallArrayt *self = allocG(rtSmallArrayt); 22179 22180 createSmallBytes(b); 22181 smallArrayt *r2 = self->f->pushSmallBytes(self, &b); 22182 ck_assert_ptr_ne(r2, null); 22183 r = getAtSmallBytesSmallArrayG(self, null, 0); 22184 ck_assert_ptr_ne(r, null); 22185 char *s = toStringO(r); 22186 ck_assert_str_eq(s, "[]"); 22187 free(s); 22188 finishO(r); 22189 terminateO(self); 22190 22191 } 22192 22193 22194 void getAtSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 22195 22196 smallDoublet* r; 22197 smallArrayt *self = allocG(rtSmallArrayt); 22198 22199 smallArrayt *r2 = self->f->pushDouble(self, 1); 22200 ck_assert_ptr_ne(r2, null); 22201 r = getAtSmallDoubleSmallArrayG(self, null, 0); 22202 ck_assert_ptr_ne(r, null); 22203 char *s = toStringO(r); 22204 ck_assert_str_eq(s, "1.000000e+00"); 22205 free(s); 22206 finishO(r); 22207 terminateO(self); 22208 22209 } 22210 22211 22212 void getAtSmallIntSmallArrayGT(CuTest *tc UNUSED) { 22213 22214 smallIntt* r; 22215 smallArrayt *self = allocG(rtSmallArrayt); 22216 22217 smallArrayt *r2 = self->f->pushInt(self, 1); 22218 ck_assert_ptr_ne(r2, null); 22219 r = getAtSmallIntSmallArrayG(self, null, 0); 22220 ck_assert_ptr_ne(r, null); 22221 char *s = toStringO(r); 22222 ck_assert_str_eq(s, "1"); 22223 free(s); 22224 finishO(r); 22225 terminateO(self); 22226 22227 } 22228 22229 22230 void getAtSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 22231 22232 smallJsont* r; 22233 smallArrayt *self = allocG(rtSmallArrayt); 22234 22235 createSmallJson(j); 22236 smallArrayt *r2 = self->f->pushSmallJson(self, &j); 22237 ck_assert_ptr_ne(r2, null); 22238 r = getAtSmallJsonSmallArrayG(self, null, 0); 22239 ck_assert_ptr_ne(r, null); 22240 char *s = toStringO(r); 22241 ck_assert_str_eq(s, "{}"); 22242 free(s); 22243 finishO(r); 22244 terminateO(self); 22245 22246 } 22247 22248 22249 void getAtSmallStringSmallArrayGT(CuTest *tc UNUSED) { 22250 22251 smallStringt* r; 22252 smallArrayt *self = allocG(rtSmallArrayt); 22253 22254 createSmallString(S); 22255 smallArrayt *r2 = self->f->pushSmallString(self, &S); 22256 ck_assert_ptr_ne(r2, null); 22257 r = getAtSmallStringSmallArrayG(self, null, 0); 22258 ck_assert_ptr_ne(r, null); 22259 char *s = toStringO(r); 22260 ck_assert_str_eq(s, ""); 22261 free(s); 22262 finishO(r); 22263 terminateO(self); 22264 22265 } 22266 22267 22268 void getAtVoidSmallArrayGT(CuTest *tc UNUSED) { 22269 22270 void* r; 22271 smallArrayt *self = allocG(rtSmallArrayt); 22272 22273 createSmallContainer(c); 22274 setValO(&c, &r); 22275 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 22276 ck_assert_ptr_ne(r2, null); 22277 r = getAtVoidSmallArrayG(self, null, 0); 22278 ck_assert_ptr_eq(r, &r); 22279 terminateO(self); 22280 22281 } 22282 22283 22284 void getAtSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 22285 22286 smallContainert* r; 22287 smallArrayt *self = allocG(rtSmallArrayt); 22288 22289 createSmallContainer(c); 22290 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 22291 ck_assert_ptr_ne(r2, null); 22292 r = getAtSmallContainerSmallArrayG(self, null, 0); 22293 ck_assert_ptr_ne(r, null); 22294 char *s = toStringO(r); 22295 ck_assert_str_eq(s, "<data smallContainer>"); 22296 free(s); 22297 finishO(r); 22298 terminateO(self); 22299 22300 } 22301 22302 22303 void getAtNDupSmallArrayGT(CuTest *tc UNUSED) { 22304 22305 baset* r; 22306 smallArrayt *self = allocG(rtSmallArrayt); 22307 22308 smallArrayt *r2 = self->f->pushInt(self, 1); 22309 ck_assert_ptr_ne(r2, null); 22310 r = getAtNDupSmallArrayG(self, NULL, 0); 22311 ck_assert_ptr_ne(r, null); 22312 char *s = toStringO(r); 22313 terminateO(r); 22314 ck_assert_str_eq(s, "1"); 22315 free(s); 22316 terminateO(self); 22317 22318 } 22319 22320 22321 void getAtNDupUndefinedSmallArrayGT(CuTest *tc UNUSED) { 22322 22323 undefinedt* r; 22324 smallArrayt *self = allocG(rtSmallArrayt); 22325 22326 smallArrayt *r2 = self->f->pushUndefined(self); 22327 ck_assert_ptr_ne(r2, null); 22328 r = getAtNDupUndefinedSmallArrayG(self, null, 0); 22329 ck_assert_ptr_ne(r, null); 22330 char *s = toStringO(r); 22331 terminateO(r); 22332 ck_assert_str_eq(s, "null"); 22333 free(s); 22334 terminateO(self); 22335 22336 } 22337 22338 22339 void getAtNDupBoolSmallArrayGT(CuTest *tc UNUSED) { 22340 22341 bool r; 22342 smallArrayt *self = allocG(rtSmallArrayt); 22343 22344 smallArrayt *r2 = self->f->pushBool(self, TRUE); 22345 ck_assert_ptr_ne(r2, null); 22346 r = getAtNDupBoolSmallArrayG(self, null, 0); 22347 ck_assert(r); 22348 terminateO(self); 22349 22350 } 22351 22352 22353 void getAtNDupDoubleSmallArrayGT(CuTest *tc UNUSED) { 22354 22355 double r; 22356 smallArrayt *self = allocG(rtSmallArrayt); 22357 22358 smallArrayt *r2 = self->f->pushDouble(self, 2.0); 22359 ck_assert_ptr_ne(r2, null); 22360 r = getAtNDupDoubleSmallArrayG(self, 0, 0); 22361 ck_assert(r==2.0); 22362 terminateO(self); 22363 22364 } 22365 22366 22367 void getAtNDupIntSmallArrayGT(CuTest *tc UNUSED) { 22368 22369 int64_t r; 22370 smallArrayt *self = allocG(rtSmallArrayt); 22371 22372 smallArrayt *r2 = self->f->pushInt(self, 2); 22373 ck_assert_ptr_ne(r2, null); 22374 r = getAtNDupIntSmallArrayG(self, 0, 0); 22375 ck_assert_int_eq(r, 2); 22376 terminateO(self); 22377 22378 } 22379 22380 22381 void getAtNDupInt32SmallArrayGT(CuTest *tc UNUSED) { 22382 22383 int32_t r; 22384 smallArrayt *self = allocG(rtSmallArrayt); 22385 22386 smallArrayt *r2 = self->f->pushInt(self, 2); 22387 ck_assert_ptr_ne(r2, null); 22388 r = getAtNDupInt32SmallArrayG(self, 0, 0); 22389 ck_assert_int_eq(r, 2); 22390 terminateO(self); 22391 22392 } 22393 22394 22395 void getAtNDupUintSmallArrayGT(CuTest *tc UNUSED) { 22396 22397 uint64_t r; 22398 smallArrayt *self = allocG(rtSmallArrayt); 22399 22400 smallArrayt *r2 = self->f->pushInt(self, 2); 22401 ck_assert_ptr_ne(r2, null); 22402 r = getAtNDupUintSmallArrayG(self, 0, 0); 22403 ck_assert_int_eq(r, 2); 22404 terminateO(self); 22405 22406 } 22407 22408 22409 void getAtNDupUint32SmallArrayGT(CuTest *tc UNUSED) { 22410 22411 uint32_t r; 22412 smallArrayt *self = allocG(rtSmallArrayt); 22413 22414 smallArrayt *r2 = self->f->pushInt(self, 2); 22415 ck_assert_ptr_ne(r2, null); 22416 r = getAtNDupUint32SmallArrayG(self, 0, 0); 22417 ck_assert_int_eq(r, 2); 22418 terminateO(self); 22419 22420 } 22421 22422 22423 void getAtNDupSSmallArrayGT(CuTest *tc UNUSED) { 22424 22425 char* r; 22426 smallArrayt *self = allocG(rtSmallArrayt); 22427 22428 smallArrayt *r2 = self->f->pushS(self, "2"); 22429 ck_assert_ptr_ne(r2, null); 22430 r = getAtNDupSSmallArrayG(self, null, 0); 22431 ck_assert_str_eq(r, "2"); 22432 free(r); 22433 terminateO(self); 22434 22435 } 22436 22437 22438 void getAtNDupDictSmallArrayGT(CuTest *tc UNUSED) { 22439 22440 smallDictt* r; 22441 smallArrayt *self = allocG(rtSmallArrayt); 22442 22443 createSmallDict(d); 22444 smallArrayt *r2 = self->f->pushDict(self, &d); 22445 ck_assert_ptr_ne(r2, null); 22446 r = getAtNDupDictSmallArrayG(self, null, 0); 22447 ck_assert_ptr_ne(r, null); 22448 char *s = toStringO(r); 22449 ck_assert_str_eq(s, "{}"); 22450 free(s); 22451 terminateO(r); 22452 terminateO(self); 22453 22454 } 22455 22456 22457 void getAtNDupArraySmallArrayGT(CuTest *tc UNUSED) { 22458 22459 smallArrayt* r; 22460 smallArrayt *self = allocG(rtSmallArrayt); 22461 22462 createSmallArray(a); 22463 smallArrayt *r2 = self->f->pushArray(self, &a); 22464 ck_assert_ptr_ne(r2, null); 22465 r = getAtNDupArraySmallArrayG(self, null, 0); 22466 ck_assert_ptr_ne(r, null); 22467 char *s = toStringO(r); 22468 ck_assert_str_eq(s, "[]"); 22469 free(s); 22470 terminateO(r); 22471 terminateO(self); 22472 22473 } 22474 22475 22476 void getAtNDupSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 22477 22478 smallBoolt* r; 22479 smallArrayt *self = allocG(rtSmallArrayt); 22480 22481 smallArrayt *r2 = self->f->pushBool(self, true); 22482 ck_assert_ptr_ne(r2, null); 22483 r = getAtNDupSmallBoolSmallArrayG(self, null, 0); 22484 ck_assert_ptr_ne(r, null); 22485 char *s = toStringO(r); 22486 ck_assert_str_eq(s, "true"); 22487 free(s); 22488 terminateO(r); 22489 terminateO(self); 22490 22491 } 22492 22493 22494 void getAtNDupSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 22495 22496 smallBytest* r; 22497 smallArrayt *self = allocG(rtSmallArrayt); 22498 22499 createSmallBytes(b); 22500 smallArrayt *r2 = self->f->pushSmallBytes(self, &b); 22501 ck_assert_ptr_ne(r2, null); 22502 r = getAtNDupSmallBytesSmallArrayG(self, null, 0); 22503 ck_assert_ptr_ne(r, null); 22504 char *s = toStringO(r); 22505 ck_assert_str_eq(s, "[]"); 22506 free(s); 22507 terminateO(r); 22508 terminateO(self); 22509 22510 } 22511 22512 22513 void getAtNDupSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 22514 22515 smallDoublet* r; 22516 smallArrayt *self = allocG(rtSmallArrayt); 22517 22518 smallArrayt *r2 = self->f->pushDouble(self, 1); 22519 ck_assert_ptr_ne(r2, null); 22520 r = getAtNDupSmallDoubleSmallArrayG(self, null, 0); 22521 ck_assert_ptr_ne(r, null); 22522 char *s = toStringO(r); 22523 ck_assert_str_eq(s, "1.000000e+00"); 22524 free(s); 22525 terminateO(r); 22526 terminateO(self); 22527 22528 } 22529 22530 22531 void getAtNDupSmallIntSmallArrayGT(CuTest *tc UNUSED) { 22532 22533 smallIntt* r; 22534 smallArrayt *self = allocG(rtSmallArrayt); 22535 22536 smallArrayt *r2 = self->f->pushInt(self, 1); 22537 ck_assert_ptr_ne(r2, null); 22538 r = getAtNDupSmallIntSmallArrayG(self, null, 0); 22539 ck_assert_ptr_ne(r, null); 22540 char *s = toStringO(r); 22541 ck_assert_str_eq(s, "1"); 22542 free(s); 22543 terminateO(r); 22544 terminateO(self); 22545 22546 } 22547 22548 22549 void getAtNDupSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 22550 22551 smallJsont* r; 22552 smallArrayt *self = allocG(rtSmallArrayt); 22553 22554 createSmallJson(j); 22555 smallArrayt *r2 = self->f->pushSmallJson(self, &j); 22556 ck_assert_ptr_ne(r2, null); 22557 r = getAtNDupSmallJsonSmallArrayG(self, null, 0); 22558 ck_assert_ptr_ne(r, null); 22559 char *s = toStringO(r); 22560 ck_assert_str_eq(s, "{}"); 22561 free(s); 22562 terminateO(r); 22563 terminateO(self); 22564 22565 } 22566 22567 22568 void getAtNDupSmallStringSmallArrayGT(CuTest *tc UNUSED) { 22569 22570 smallStringt* r; 22571 smallArrayt *self = allocG(rtSmallArrayt); 22572 22573 createSmallString(S); 22574 smallArrayt *r2 = self->f->pushSmallString(self, &S); 22575 ck_assert_ptr_ne(r2, null); 22576 r = getAtNDupSmallStringSmallArrayG(self, null, 0); 22577 ck_assert_ptr_ne(r, null); 22578 char *s = toStringO(r); 22579 ck_assert_str_eq(s, ""); 22580 free(s); 22581 terminateO(r); 22582 terminateO(self); 22583 22584 } 22585 22586 22587 void getAtNDupVoidSmallArrayGT(CuTest *tc UNUSED) { 22588 22589 void* r; 22590 smallArrayt *self = allocG(rtSmallArrayt); 22591 22592 createSmallContainer(c); 22593 setValO(&c, &r); 22594 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 22595 ck_assert_ptr_ne(r2, null); 22596 r = getAtNDupVoidSmallArrayG(self, null, 0); 22597 ck_assert_ptr_eq(r, NULL); 22598 terminateO(self); 22599 22600 } 22601 22602 22603 void getAtNDupSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 22604 22605 smallContainert* r; 22606 smallArrayt *self = allocG(rtSmallArrayt); 22607 22608 createSmallContainer(c); 22609 smallArrayt *r2 = self->f->pushSmallContainer(self, &c); 22610 ck_assert_ptr_ne(r2, null); 22611 r = getAtNDupSmallContainerSmallArrayG(self, null, 0); 22612 ck_assert_ptr_ne(r, null); 22613 char *s = toStringO(r); 22614 ck_assert_str_eq(s, "<data smallContainer>"); 22615 free(s); 22616 terminateO(r); 22617 terminateO(self); 22618 22619 } 22620 22621 22622 void setAtSmallArrayGT(CuTest *tc UNUSED) { 22623 22624 smallArrayt* r; 22625 smallArrayt *self = allocG(rtSmallArrayt); 22626 baset *value = (baset*) allocSmallInt(1); 22627 22628 r = pushSmallArrayG(self, value); 22629 ck_assert_ptr_ne(r, null); 22630 finishO(value); 22631 value = (baset*) allocSmallInt(2); 22632 r = setAtSmallArrayG(self, 0, value); 22633 ck_assert_ptr_ne(r, null); 22634 finishO(value); 22635 char *s = toStringO(r); 22636 ck_assert_str_eq(s, "[2]"); 22637 free(s); 22638 terminateO(self); 22639 22640 } 22641 22642 22643 void setAtUndefinedSmallArrayGT(CuTest *tc UNUSED) { 22644 22645 smallArrayt* r; 22646 smallArrayt *self = allocG(rtSmallArrayt); 22647 baset *value = (baset*) allocSmallInt(1); 22648 22649 r = pushSmallArrayG(self, value); 22650 ck_assert_ptr_ne(r, null); 22651 finishO(value); 22652 r = setAtUndefinedSmallArrayG(self, 0, null); 22653 ck_assert_ptr_ne(r, null); 22654 char *s = toStringO(r); 22655 ck_assert_str_eq(s, "[null]"); 22656 free(s); 22657 terminateO(self); 22658 22659 } 22660 22661 22662 void setAtBoolSmallArrayGT(CuTest *tc UNUSED) { 22663 22664 smallArrayt* r; 22665 smallArrayt *self = allocG(rtSmallArrayt); 22666 22667 r = pushBoolSmallArrayG(self, true); 22668 ck_assert_ptr_ne(r, null); 22669 r = setAtBoolSmallArrayG(self, 0, false); 22670 ck_assert_ptr_ne(r, null); 22671 char *s = toStringO(r); 22672 ck_assert_str_eq(s, "[false]"); 22673 free(s); 22674 terminateO(self); 22675 22676 } 22677 22678 22679 void setAtDoubleSmallArrayGT(CuTest *tc UNUSED) { 22680 22681 smallArrayt* r; 22682 smallArrayt *self = allocG(rtSmallArrayt); 22683 22684 r = pushDoubleSmallArrayG(self, 1); 22685 ck_assert_ptr_ne(r, null); 22686 r = setAtDoubleSmallArrayG(self, 0, 2); 22687 ck_assert_ptr_ne(r, null); 22688 char *s = toStringO(r); 22689 ck_assert_str_eq(s, "[2.000000e+00]"); 22690 free(s); 22691 terminateO(self); 22692 22693 } 22694 22695 22696 void setAtIntSmallArrayGT(CuTest *tc UNUSED) { 22697 22698 smallArrayt* r; 22699 smallArrayt *self = allocG(rtSmallArrayt); 22700 22701 r = pushIntSmallArrayG(self, 1); 22702 ck_assert_ptr_ne(r, null); 22703 r = setAtIntSmallArrayG(self, 0, 2); 22704 ck_assert_ptr_ne(r, null); 22705 char *s = toStringO(r); 22706 ck_assert_str_eq(s, "[2]"); 22707 free(s); 22708 terminateO(self); 22709 22710 } 22711 22712 22713 void setAtSSmallArrayGT(CuTest *tc UNUSED) { 22714 22715 smallArrayt* r; 22716 smallArrayt *self = allocG(rtSmallArrayt); 22717 22718 r = pushSSmallArrayG(self, "qwe"); 22719 ck_assert_ptr_ne(r, null); 22720 r = setAtSSmallArrayG(self, 0, "asd"); 22721 ck_assert_ptr_ne(r, null); 22722 char *s = toStringO(r); 22723 ck_assert_str_eq(s, "[\"asd\"]"); 22724 free(s); 22725 terminateO(self); 22726 22727 } 22728 22729 22730 void setAtCharSmallArrayGT(CuTest *tc UNUSED) { 22731 22732 smallArrayt* r; 22733 smallArrayt *self = allocG(rtSmallArrayt); 22734 22735 r = pushCharSmallArrayG(self, 'Q'); 22736 ck_assert_ptr_ne(r, null); 22737 r = setAtCharSmallArrayG(self, 0, 'x'); 22738 ck_assert_ptr_ne(r, null); 22739 char *s = toStringO(r); 22740 ck_assert_str_eq(s, "[\"x\"]"); 22741 free(s); 22742 terminateO(self); 22743 22744 } 22745 22746 22747 void setAtDictSmallArrayGT(CuTest *tc UNUSED) { 22748 22749 smallArrayt* r; 22750 smallArrayt *self = allocG(rtSmallArrayt); 22751 smallDictt *dict = allocSmallDict(); 22752 22753 r = pushDictSmallArrayG(self, dict); 22754 ck_assert_ptr_ne(r, null); 22755 resetO(dict); 22756 dict->f->setInt(dict, "a", 1); 22757 r = setAtDictSmallArrayG(self, 0, dict); 22758 ck_assert_ptr_ne(r, null); 22759 finishO(dict); 22760 char *s = toStringO(r); 22761 ck_assert_str_eq(s, "[{\"a\":1}]"); 22762 free(s); 22763 terminateO(self); 22764 22765 } 22766 22767 22768 void setAtArraySmallArrayGT(CuTest *tc UNUSED) { 22769 22770 smallArrayt* r; 22771 smallArrayt *self = allocG(rtSmallArrayt); 22772 smallArrayt *array = allocSmallArray(); 22773 22774 r = pushArraySmallArrayG(self, array); 22775 ck_assert_ptr_ne(r, null); 22776 resetO(array); 22777 array->f->pushInt(array, 1); 22778 r = setAtArraySmallArrayG(self, 0, array); 22779 ck_assert_ptr_ne(r, null); 22780 finishO(array); 22781 char *s = toStringO(r); 22782 ck_assert_str_eq(s, "[[1]]"); 22783 free(s); 22784 terminateO(self); 22785 22786 } 22787 22788 22789 void setAtArraycSmallArrayGT(CuTest *tc UNUSED) { 22790 22791 smallArrayt* r; 22792 smallArrayt *self = allocG(rtSmallArrayt); 22793 char **array = listCreateS("a","bb"); 22794 22795 r = pushArraycSmallArrayG(self, array); 22796 ck_assert_ptr_ne(r, null); 22797 listFreeS(array); 22798 array = listCreateS("1","22"); 22799 r = setAtArraycSmallArrayG(self, 0, array); 22800 ck_assert_ptr_ne(r, null); 22801 ck_assert_int_eq(lenO(r), 1); 22802 listFreeS(array); 22803 char *s = toStringO(r); 22804 ck_assert_str_eq(s, "[[\"1\",\"22\"]]"); 22805 free(s); 22806 terminateO(self); 22807 22808 } 22809 22810 22811 void setAtCArraycSmallArrayGT(CuTest *tc UNUSED) { 22812 22813 smallArrayt* r; 22814 smallArrayt *self = allocG(rtSmallArrayt); 22815 const char *array[] = {"a", "bb", NULL}; 22816 22817 r = pushCArraycSmallArrayG(self, array); 22818 ck_assert_ptr_ne(r, null); 22819 const char *array2[] = {"1", "22", NULL}; 22820 r = setAtCArraycSmallArrayG(self, 0, array2); 22821 ck_assert_ptr_ne(r, null); 22822 ck_assert_int_eq(lenO(r), 1); 22823 char *s = toStringO(r); 22824 ck_assert_str_eq(s, "[[\"1\",\"22\"]]"); 22825 free(s); 22826 terminateO(self); 22827 22828 } 22829 22830 22831 void setAtVoidSmallArrayGT(CuTest *tc UNUSED) { 22832 22833 smallArrayt* r; 22834 smallArrayt *self = allocG(rtSmallArrayt); 22835 22836 // NULL value 22837 r = pushVoidSmallArrayG(self, NULL); 22838 ck_assert_ptr_ne(r, null); 22839 r = setAtVoidSmallArrayG(self, 0, null); 22840 ck_assert_ptr_ne(r, null); 22841 r = setAtVoidSmallArrayG(self, 0, r); 22842 ck_assert_ptr_ne(r, null); 22843 char *s = toStringO(r); 22844 ck_assert_str_eq(s, "[\"<data container>\"]"); 22845 free(s); 22846 terminateO(self); 22847 22848 } 22849 22850 22851 void setAtSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 22852 22853 smallArrayt* r; 22854 smallArrayt *self = allocG(rtSmallArrayt); 22855 smallBoolt *value = allocSmallBool(true); 22856 22857 r = pushBoolSmallArrayG(self, false); 22858 ck_assert_ptr_ne(r, null); 22859 r = setAtSmallBoolSmallArrayG(self, 0, value); 22860 ck_assert_ptr_ne(r, null); 22861 finishO(value); 22862 char *s = toStringO(r); 22863 ck_assert_str_eq(s, "[true]"); 22864 free(s); 22865 terminateO(self); 22866 22867 } 22868 22869 22870 void setAtSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 22871 22872 smallArrayt* r; 22873 smallArrayt *self = allocG(rtSmallArrayt); 22874 smallBytest *value = allocSmallBytes("qwe", 3); 22875 22876 r = pushSmallBytesSmallArrayG(self, value); 22877 ck_assert_ptr_ne(r, null); 22878 finishO(value); 22879 value = allocSmallBytes("asd", 3); 22880 r = setAtSmallBytesSmallArrayG(self, 0, value); 22881 ck_assert_ptr_ne(r, null); 22882 finishO(value); 22883 char *s = toStringO(r); 22884 ck_assert_str_eq(s, "[[0x61,0x73,0x64]]"); 22885 free(s); 22886 terminateO(self); 22887 22888 } 22889 22890 22891 void setAtSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 22892 22893 smallArrayt* r; 22894 smallArrayt *self = allocG(rtSmallArrayt); 22895 smallDoublet *value = allocSmallDouble(1); 22896 22897 r = pushDoubleSmallArrayG(self, 2); 22898 ck_assert_ptr_ne(r, null); 22899 r = setAtSmallDoubleSmallArrayG(self, 0, value); 22900 ck_assert_ptr_ne(r, null); 22901 finishO(value); 22902 char *s = toStringO(r); 22903 ck_assert_str_eq(s, "[1.000000e+00]"); 22904 free(s); 22905 22906 terminateO(self); 22907 22908 } 22909 22910 22911 void setAtSmallIntSmallArrayGT(CuTest *tc UNUSED) { 22912 22913 smallArrayt* r; 22914 smallArrayt *self = allocG(rtSmallArrayt); 22915 smallIntt *value = allocSmallInt(1); 22916 22917 r = pushIntSmallArrayG(self, 2); 22918 ck_assert_ptr_ne(r, null); 22919 r = setAtSmallIntSmallArrayG(self, 0, value); 22920 ck_assert_ptr_ne(r, null); 22921 finishO(value); 22922 char *s = toStringO(r); 22923 ck_assert_str_eq(s, "[1]"); 22924 free(s); 22925 terminateO(self); 22926 22927 } 22928 22929 22930 void setAtSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 22931 22932 smallArrayt* r; 22933 smallArrayt *self = allocG(rtSmallArrayt); 22934 smallJsont *value = allocSmallJson(); 22935 22936 r = pushSmallJsonSmallArrayG(self, value); 22937 ck_assert_ptr_ne(r, null); 22938 finishO(value); 22939 value = allocSmallJson(); 22940 value->f->setInt(value, "a", 1); 22941 r = setAtSmallJsonSmallArrayG(self, 0, value); 22942 ck_assert_ptr_ne(r, null); 22943 finishO(value); 22944 char *s = toStringO(r); 22945 ck_assert_str_eq(s, "[{\"a\":1}]"); 22946 free(s); 22947 terminateO(self); 22948 22949 } 22950 22951 22952 void setAtSmallStringSmallArrayGT(CuTest *tc UNUSED) { 22953 22954 smallArrayt* r; 22955 smallArrayt *self = allocG(rtSmallArrayt); 22956 smallStringt *string = allocSmallString("qwe"); 22957 22958 r = pushSSmallArrayG(self, "asd"); 22959 ck_assert_ptr_ne(r, null); 22960 r = setAtSmallStringSmallArrayG(self, 0, string); 22961 ck_assert_ptr_ne(r, null); 22962 finishO(string); 22963 char *s = toStringO(r); 22964 ck_assert_str_eq(s, "[\"qwe\"]"); 22965 free(s); 22966 terminateO(self); 22967 22968 } 22969 22970 22971 void setAtSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 22972 22973 smallArrayt* r; 22974 smallArrayt *self = allocG(rtSmallArrayt); 22975 22976 createSmallContainer(c); 22977 r = pushSmallContainerSmallArrayG(self, &c); 22978 ck_assert_ptr_ne(r, null); 22979 createSmallContainer(c2); 22980 r = setAtSmallContainerSmallArrayG(self, 0, &c2); 22981 ck_assert_ptr_ne(r, null); 22982 char *s = toStringO(r); 22983 ck_assert_str_eq(s, "[\"<data container>\"]"); 22984 free(s); 22985 terminateO(self); 22986 22987 } 22988 22989 22990 void setAtNFreeSmallArrayGT(CuTest *tc UNUSED) { 22991 22992 smallArrayt* r; 22993 smallArrayt *self = allocG(rtSmallArrayt); 22994 baset *value = (baset*) allocSmallInt(1); 22995 22996 r = pushSmallArrayG(self, value); 22997 ck_assert_ptr_ne(r, null); 22998 finishO(value); 22999 value = (baset*) allocSmallInt(2); 23000 r = setAtNFreeSmallArrayG(self, 0, value); 23001 ck_assert_ptr_ne(r, null); 23002 char *s = toStringO(r); 23003 ck_assert_str_eq(s, "[2]"); 23004 free(s); 23005 terminateO(self); 23006 23007 } 23008 23009 23010 void setAtNFreeUndefinedSmallArrayGT(CuTest *tc UNUSED) { 23011 23012 smallArrayt* r; 23013 smallArrayt *self = allocG(rtSmallArrayt); 23014 baset *value = (baset*) allocSmallInt(1); 23015 23016 r = pushSmallArrayG(self, value); 23017 ck_assert_ptr_ne(r, null); 23018 finishO(value); 23019 r = setAtNFreeUndefinedSmallArrayG(self, 0, null); 23020 ck_assert_ptr_ne(r, null); 23021 char *s = toStringO(r); 23022 ck_assert_str_eq(s, "[null]"); 23023 free(s); 23024 terminateO(self); 23025 23026 } 23027 23028 23029 void setAtNFreeSSmallArrayGT(CuTest *tc UNUSED) { 23030 23031 smallArrayt* r; 23032 smallArrayt *self = allocG(rtSmallArrayt); 23033 23034 r = pushSSmallArrayG(self, "qwe"); 23035 ck_assert_ptr_ne(r, null); 23036 r = setAtNFreeSSmallArrayG(self, 0, strdup("asd")); 23037 ck_assert_ptr_ne(r, null); 23038 char *s = toStringO(r); 23039 ck_assert_str_eq(s, "[\"asd\"]"); 23040 free(s); 23041 terminateO(self); 23042 23043 } 23044 23045 23046 void setAtNFreeDictSmallArrayGT(CuTest *tc UNUSED) { 23047 23048 smallArrayt* r; 23049 smallArrayt *self = allocG(rtSmallArrayt); 23050 smallDictt *dict = allocSmallDict(); 23051 23052 r = pushDictSmallArrayG(self, dict); 23053 ck_assert_ptr_ne(r, null); 23054 resetO(dict); 23055 dict->f->setInt(dict, "a", 1); 23056 r = setAtNFreeDictSmallArrayG(self, 0, dict); 23057 ck_assert_ptr_ne(r, null); 23058 char *s = toStringO(r); 23059 ck_assert_str_eq(s, "[{\"a\":1}]"); 23060 free(s); 23061 terminateO(self); 23062 23063 } 23064 23065 23066 void setAtNFreeArraySmallArrayGT(CuTest *tc UNUSED) { 23067 23068 smallArrayt* r; 23069 smallArrayt *self = allocG(rtSmallArrayt); 23070 smallArrayt *array = allocSmallArray(); 23071 23072 r = pushArraySmallArrayG(self, array); 23073 ck_assert_ptr_ne(r, null); 23074 resetO(array); 23075 array->f->pushInt(array, 1); 23076 r = setAtNFreeArraySmallArrayG(self, 0, array); 23077 ck_assert_ptr_ne(r, null); 23078 char *s = toStringO(r); 23079 ck_assert_str_eq(s, "[[1]]"); 23080 free(s); 23081 terminateO(self); 23082 23083 } 23084 23085 23086 void setAtNFreeArraycSmallArrayGT(CuTest *tc UNUSED) { 23087 23088 smallArrayt* r; 23089 smallArrayt *self = allocG(rtSmallArrayt); 23090 char **array = listCreateS("a","bb"); 23091 23092 r = pushArraycSmallArrayG(self, array); 23093 ck_assert_ptr_ne(r, null); 23094 listFreeS(array); 23095 array = listCreateS("1","22"); 23096 r = setAtNFreeArraycSmallArrayG(self, 0, array); 23097 ck_assert_ptr_ne(r, null); 23098 ck_assert_int_eq(lenO(r), 1); 23099 char *s = toStringO(r); 23100 ck_assert_str_eq(s, "[[\"1\",\"22\"]]"); 23101 free(s); 23102 terminateO(self); 23103 23104 } 23105 23106 23107 void setAtNFreeSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 23108 23109 smallArrayt* r; 23110 smallArrayt *self = allocG(rtSmallArrayt); 23111 smallBoolt *value = allocSmallBool(true); 23112 23113 r = pushBoolSmallArrayG(self, false); 23114 ck_assert_ptr_ne(r, null); 23115 r = setAtNFreeSmallBoolSmallArrayG(self, 0, value); 23116 ck_assert_ptr_ne(r, null); 23117 char *s = toStringO(r); 23118 ck_assert_str_eq(s, "[true]"); 23119 free(s); 23120 terminateO(self); 23121 23122 } 23123 23124 23125 void setAtNFreeSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 23126 23127 smallArrayt* r; 23128 smallArrayt *self = allocG(rtSmallArrayt); 23129 smallBytest *value = allocSmallBytes("qwe", 3); 23130 23131 r = pushSmallBytesSmallArrayG(self, value); 23132 ck_assert_ptr_ne(r, null); 23133 finishO(value); 23134 value = allocSmallBytes("asd", 3); 23135 r = setAtNFreeSmallBytesSmallArrayG(self, 0, value); 23136 ck_assert_ptr_ne(r, null); 23137 char *s = toStringO(r); 23138 ck_assert_str_eq(s, "[[0x61,0x73,0x64]]"); 23139 free(s); 23140 terminateO(self); 23141 23142 } 23143 23144 23145 void setAtNFreeSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 23146 23147 smallArrayt* r; 23148 smallArrayt *self = allocG(rtSmallArrayt); 23149 smallDoublet *value = allocSmallDouble(1); 23150 23151 r = pushDoubleSmallArrayG(self, 2); 23152 ck_assert_ptr_ne(r, null); 23153 r = setAtNFreeSmallDoubleSmallArrayG(self, 0, value); 23154 ck_assert_ptr_ne(r, null); 23155 char *s = toStringO(r); 23156 ck_assert_str_eq(s, "[1.000000e+00]"); 23157 free(s); 23158 terminateO(self); 23159 23160 } 23161 23162 23163 void setAtNFreeSmallIntSmallArrayGT(CuTest *tc UNUSED) { 23164 23165 smallArrayt* r; 23166 smallArrayt *self = allocG(rtSmallArrayt); 23167 smallIntt *value = allocSmallInt(1); 23168 23169 r = pushIntSmallArrayG(self, 2); 23170 ck_assert_ptr_ne(r, null); 23171 r = setAtNFreeSmallIntSmallArrayG(self, 0, value); 23172 ck_assert_ptr_ne(r, null); 23173 char *s = toStringO(r); 23174 ck_assert_str_eq(s, "[1]"); 23175 free(s); 23176 terminateO(self); 23177 23178 } 23179 23180 23181 void setAtNFreeSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 23182 23183 smallArrayt* r; 23184 smallArrayt *self = allocG(rtSmallArrayt); 23185 smallJsont *value = allocSmallJson(); 23186 23187 r = pushSmallJsonSmallArrayG(self, value); 23188 ck_assert_ptr_ne(r, null); 23189 finishO(value); 23190 value = allocSmallJson(); 23191 value->f->setInt(value, "a", 1); 23192 r = setAtNFreeSmallJsonSmallArrayG(self, 0, value); 23193 ck_assert_ptr_ne(r, null); 23194 char *s = toStringO(r); 23195 ck_assert_str_eq(s, "[{\"a\":1}]"); 23196 free(s); 23197 terminateO(self); 23198 23199 } 23200 23201 23202 void setAtNFreeSmallStringSmallArrayGT(CuTest *tc UNUSED) { 23203 23204 smallArrayt* r; 23205 smallArrayt *self = allocG(rtSmallArrayt); 23206 smallStringt *string = allocSmallString("qwe"); 23207 23208 r = pushSSmallArrayG(self, "asd"); 23209 ck_assert_ptr_ne(r, null); 23210 r = setAtNFreeSmallStringSmallArrayG(self, 0, string); 23211 ck_assert_ptr_ne(r, null); 23212 char *s = toStringO(r); 23213 ck_assert_str_eq(s, "[\"qwe\"]"); 23214 free(s); 23215 terminateO(self); 23216 23217 } 23218 23219 23220 void setAtNFreeSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 23221 23222 smallArrayt* r; 23223 smallArrayt *self = allocG(rtSmallArrayt); 23224 23225 createSmallContainer(c); 23226 r = pushSmallContainerSmallArrayG(self, &c); 23227 ck_assert_ptr_ne(r, null); 23228 createAllocateSmallContainer(c2); 23229 r = setAtNFreeSmallContainerSmallArrayG(self, 0, c2); 23230 ck_assert_ptr_ne(r, null); 23231 char *s = toStringO(r); 23232 ck_assert_str_eq(s, "[\"<data container>\"]"); 23233 free(s); 23234 terminateO(self); 23235 23236 } 23237 23238 23239 void setPAtDictSmallArrayGT(CuTest *tc UNUSED) { 23240 23241 smallArrayt* r; 23242 smallArrayt *self = allocG(rtSmallArrayt); 23243 smallDictt *dict = allocSmallDict(); 23244 23245 r = pushDictSmallArrayG(self, dict); 23246 ck_assert_ptr_ne(r, null); 23247 finishO(dict); 23248 dict = getAtDictSmallArrayG(self, null, 0); 23249 ck_assert_ptr_ne(dict, null); 23250 dict->f->setInt(dict, "a", 1); 23251 r = setPAtDictSmallArrayG(self, 0, dict); 23252 ck_assert_ptr_ne(r, null); 23253 finishO(dict); 23254 char *s = toStringO(r); 23255 ck_assert_str_eq(s, "[{\"a\":1}]"); 23256 free(s); 23257 terminateO(self); 23258 23259 } 23260 23261 23262 void setPAtArraySmallArrayGT(CuTest *tc UNUSED) { 23263 23264 smallArrayt* r; 23265 smallArrayt *self = allocG(rtSmallArrayt); 23266 smallArrayt *array = allocSmallArray(); 23267 23268 r = pushArraySmallArrayG(self, array); 23269 ck_assert_ptr_ne(r, null); 23270 finishO(array); 23271 array = getAtArraySmallArrayG(self, null, 0); 23272 ck_assert_ptr_ne(array, null); 23273 array->f->pushInt(array, 1); 23274 r = setPAtArraySmallArrayG(self, 0, array); 23275 ck_assert_ptr_ne(r, null); 23276 finishO(array); 23277 char *s = toStringO(r); 23278 ck_assert_str_eq(s, "[[1]]"); 23279 free(s); 23280 terminateO(self); 23281 23282 } 23283 23284 23285 void setPAtSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 23286 23287 smallArrayt* r; 23288 smallArrayt *self = allocG(rtSmallArrayt); 23289 smallJsont *value = allocSmallJson(); 23290 23291 r = pushSmallJsonSmallArrayG(self, value); 23292 ck_assert_ptr_ne(r, null); 23293 finishO(value); 23294 value = getAtSmallJsonSmallArrayG(self, null, 0); 23295 value->f->setInt(value, "a", 1); 23296 r = setPAtSmallJsonSmallArrayG(self, 0, value); 23297 ck_assert_ptr_ne(r, null); 23298 finishO(value); 23299 char *s = toStringO(r); 23300 ck_assert_str_eq(s, "[{\"a\":1}]"); 23301 free(s); 23302 terminateO(self); 23303 23304 } 23305 23306 23307 void setPAtSmallStringSmallArrayGT(CuTest *tc UNUSED) { 23308 23309 smallArrayt* r; 23310 smallArrayt *self = allocG(rtSmallArrayt); 23311 smallStringt *string; 23312 23313 r = pushSSmallArrayG(self, "asd"); 23314 ck_assert_ptr_ne(r, null); 23315 string = getAtSmallStringSmallArrayG(self, null, 0); 23316 setValO(string, "qwe"); 23317 r = setPAtSmallStringSmallArrayG(self, 0, string); 23318 ck_assert_ptr_ne(r, null); 23319 finishO(string); 23320 char *s = toStringO(r); 23321 ck_assert_str_eq(s, "[\"qwe\"]"); 23322 free(s); 23323 terminateO(self); 23324 23325 } 23326 23327 23328 void setPAtNFreeDictSmallArrayGT(CuTest *tc UNUSED) { 23329 23330 smallArrayt* r; 23331 smallArrayt *self = allocG(rtSmallArrayt); 23332 smallDictt *dict = allocSmallDict(); 23333 23334 r = pushDictSmallArrayG(self, dict); 23335 ck_assert_ptr_ne(r, null); 23336 finishO(dict); 23337 dict = getAtDictSmallArrayG(self, null, 0); 23338 ck_assert_ptr_ne(dict, null); 23339 dict->f->setInt(dict, "a", 1); 23340 r = setPAtNFreeDictSmallArrayG(self, 0, dict); 23341 ck_assert_ptr_ne(r, null); 23342 char *s = toStringO(r); 23343 ck_assert_str_eq(s, "[{\"a\":1}]"); 23344 free(s); 23345 terminateO(self); 23346 23347 } 23348 23349 23350 void setPAtNFreeArraySmallArrayGT(CuTest *tc UNUSED) { 23351 23352 smallArrayt* r; 23353 smallArrayt *self = allocG(rtSmallArrayt); 23354 smallArrayt *array = allocSmallArray(); 23355 23356 r = pushArraySmallArrayG(self, array); 23357 ck_assert_ptr_ne(r, null); 23358 finishO(array); 23359 array = getAtArraySmallArrayG(self, null, 0); 23360 ck_assert_ptr_ne(array, null); 23361 array->f->pushInt(array, 1); 23362 r = setPAtNFreeArraySmallArrayG(self, 0, array); 23363 ck_assert_ptr_ne(r, null); 23364 char *s = toStringO(r); 23365 ck_assert_str_eq(s, "[[1]]"); 23366 free(s); 23367 terminateO(self); 23368 23369 } 23370 23371 23372 void setPAtNFreeSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 23373 23374 smallArrayt* r; 23375 smallArrayt *self = allocG(rtSmallArrayt); 23376 smallJsont *value = allocSmallJson(); 23377 23378 r = pushSmallJsonSmallArrayG(self, value); 23379 ck_assert_ptr_ne(r, null); 23380 finishO(value); 23381 value = getAtSmallJsonSmallArrayG(self, null, 0); 23382 value->f->setInt(value, "a", 1); 23383 r = setPAtNFreeSmallJsonSmallArrayG(self, 0, value); 23384 ck_assert_ptr_ne(r, null); 23385 char *s = toStringO(r); 23386 ck_assert_str_eq(s, "[{\"a\":1}]"); 23387 free(s); 23388 terminateO(self); 23389 23390 } 23391 23392 23393 void setPAtNFreeSmallStringSmallArrayGT(CuTest *tc UNUSED) { 23394 23395 smallArrayt* r; 23396 smallArrayt *self = allocG(rtSmallArrayt); 23397 smallStringt *string; 23398 23399 r = pushSSmallArrayG(self, "asd"); 23400 ck_assert_ptr_ne(r, null); 23401 string = getAtSmallStringSmallArrayG(self, null, 0); 23402 setValO(string, "qwe"); 23403 r = setPAtNFreeSmallStringSmallArrayG(self, 0, string); 23404 ck_assert_ptr_ne(r, null); 23405 char *s = toStringO(r); 23406 ck_assert_str_eq(s, "[\"qwe\"]"); 23407 free(s); 23408 terminateO(self); 23409 23410 } 23411 23412 23413 void getNumSmallArrayGT(CuTest *tc UNUSED) { 23414 23415 double r; 23416 smallArrayt *self = allocG(rtSmallArrayt); 23417 smallArrayt *r2; 23418 23419 r2 = self->f->pushDouble(self, 1); 23420 ck_assert_ptr_ne(r2, NULL); 23421 r = getNumSmallArrayG(self, 0); 23422 ck_assert(r==1); 23423 terminateO(self); 23424 23425 } 23426 23427 23428 void reverseSmallArrayGT(CuTest *tc UNUSED) { 23429 23430 smallArrayt* r; 23431 smallArrayt *self = allocG(rtSmallArrayt); 23432 23433 self->f->pushInt(self, 1); 23434 self->f->pushInt(self, 2); 23435 r = reverseSmallArrayG(self); 23436 ck_assert_ptr_ne(r, NULL); 23437 char *s = toStringO(r); 23438 ck_assert_str_eq(s, "[2,1]"); 23439 free(s); 23440 terminateO(self); 23441 23442 } 23443 23444 23445 void appendSmallArrayGT(CuTest *tc UNUSED) { 23446 23447 smallArrayt* r; 23448 smallArrayt *self = allocG(rtSmallArrayt); 23449 smallArrayt *array = allocSmallArray(); 23450 23451 r = self->f->pushInt(self, 1); 23452 ck_assert_ptr_ne(r, null); 23453 array->f->pushInt(array, 1); 23454 array->f->pushInt(array, 2); 23455 r = appendSmallArrayG(self, array); 23456 ck_assert_ptr_ne(r, NULL); 23457 smashO(array); 23458 char *s = toStringO(r); 23459 ck_assert_str_eq(s, "[1,1,2]"); 23460 free(s); 23461 // non smallArray object 23462 array = (smallArrayt*) allocSmallInt(0); 23463 r = appendSmallArrayG(self, array); 23464 ck_assert_ptr_eq(r, NULL); 23465 terminateO(array); 23466 terminateO(self); 23467 23468 } 23469 23470 23471 void appendSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 23472 23473 smallArrayt* r; 23474 smallArrayt *self = allocG(rtSmallArrayt); 23475 smallJsont *json = allocSmallJson(); 23476 23477 r = self->f->pushInt(self, 1); 23478 ck_assert_ptr_ne(r, null); 23479 json->f->pushInt(json, 1); 23480 json->f->pushInt(json, 2); 23481 r = appendSmallJsonSmallArrayG(self, json); 23482 ck_assert_ptr_ne(r, NULL); 23483 smashO(json); 23484 char *s = toStringO(r); 23485 ck_assert_str_eq(s, "[1,1,2]"); 23486 free(s); 23487 terminateO(self); 23488 23489 } 23490 23491 23492 void appendNSmashSmallArrayGT(CuTest *tc UNUSED) { 23493 23494 smallArrayt* r; 23495 smallArrayt *self = allocG(rtSmallArrayt); 23496 smallArrayt *array = allocSmallArray(); 23497 23498 r = self->f->pushInt(self, 1); 23499 ck_assert_ptr_ne(r, null); 23500 array->f->pushInt(array, 1); 23501 array->f->pushInt(array, 2); 23502 r = appendNSmashSmallArrayG(self, array); 23503 ck_assert_ptr_ne(r, NULL); 23504 char *s = toStringO(r); 23505 ck_assert_str_eq(s, "[1,1,2]"); 23506 free(s); 23507 terminateO(self); 23508 23509 } 23510 23511 23512 void appendNSmashSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 23513 23514 smallArrayt* r; 23515 smallArrayt *self = allocG(rtSmallArrayt); 23516 smallJsont *json = allocSmallJson(); 23517 23518 r = self->f->pushInt(self, 1); 23519 ck_assert_ptr_ne(r, null); 23520 json->f->pushInt(json, 1); 23521 json->f->pushInt(json, 2); 23522 r = appendNSmashSmallJsonSmallArrayG(self, json); 23523 ck_assert_ptr_ne(r, NULL); 23524 char *s = toStringO(r); 23525 ck_assert_str_eq(s, "[1,1,2]"); 23526 free(s); 23527 terminateO(self); 23528 23529 } 23530 23531 23532 void appendArraySmallArrayGT(CuTest *tc UNUSED) { 23533 23534 smallArrayt* r; 23535 smallArrayt *self = allocG(rtSmallArrayt); 23536 char **array = listCreateS("1", "2"); 23537 23538 r = self->f->pushInt(self, 1); 23539 ck_assert_ptr_ne(r, null); 23540 r = appendArraySmallArrayG(self, array); 23541 ck_assert_ptr_ne(r, NULL); 23542 listFreeS(array); 23543 char *s = toStringO(r); 23544 ck_assert_str_eq(s, "[1,\"1\",\"2\"]"); 23545 free(s); 23546 terminateO(self); 23547 23548 } 23549 23550 23551 void appendNSmashArraySmallArrayGT(CuTest *tc UNUSED) { 23552 23553 smallArrayt* r; 23554 smallArrayt *self = allocG(rtSmallArrayt); 23555 char **array = listCreateS("1", "2"); 23556 23557 r = self->f->pushInt(self, 1); 23558 ck_assert_ptr_ne(r, null); 23559 r = appendNSmashArraySmallArrayG(self, array); 23560 ck_assert_ptr_ne(r, NULL); 23561 char *s = toStringO(r); 23562 ck_assert_str_eq(s, "[1,\"1\",\"2\"]"); 23563 free(s); 23564 terminateO(self); 23565 23566 } 23567 23568 23569 void appendCArraySmallArrayGT(CuTest *tc UNUSED) { 23570 23571 smallArrayt* r; 23572 smallArrayt *self = allocG(rtSmallArrayt); 23573 const char *array[] = {"1", "2", null}; 23574 23575 r = self->f->pushInt(self, 1); 23576 ck_assert_ptr_ne(r, null); 23577 r = appendCArraySmallArrayG(self, array); 23578 ck_assert_ptr_ne(r, NULL); 23579 char *s = toStringO(r); 23580 ck_assert_str_eq(s, "[1,\"1\",\"2\"]"); 23581 free(s); 23582 terminateO(self); 23583 23584 } 23585 23586 23587 void shiftSmallArrayGT(CuTest *tc UNUSED) { 23588 23589 smallArrayt* r; 23590 smallArrayt *self = allocG(rtSmallArrayt); 23591 smallArrayt *array = allocSmallArray(); 23592 23593 r = self->f->pushInt(self, 1); 23594 ck_assert_ptr_ne(r, null); 23595 array->f->pushInt(array, 1); 23596 array->f->pushInt(array, 2); 23597 r = shiftSmallArrayG(self, array); 23598 ck_assert_ptr_ne(r, NULL); 23599 smashO(array); 23600 char *s = toStringO(r); 23601 ck_assert_str_eq(s, "[1,2,1]"); 23602 free(s); 23603 terminateO(self); 23604 23605 } 23606 23607 23608 void shiftSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 23609 23610 smallArrayt* r; 23611 smallArrayt *self = allocG(rtSmallArrayt); 23612 smallJsont *json = allocSmallJson(); 23613 23614 r = self->f->pushInt(self, 1); 23615 ck_assert_ptr_ne(r, null); 23616 json->f->pushInt(json, 1); 23617 json->f->pushInt(json, 2); 23618 r = shiftSmallJsonSmallArrayG(self, json); 23619 ck_assert_ptr_ne(r, NULL); 23620 smashO(json); 23621 char *s = toStringO(r); 23622 ck_assert_str_eq(s, "[1,2,1]"); 23623 free(s); 23624 terminateO(self); 23625 23626 } 23627 23628 23629 void shiftNSmashSmallArrayGT(CuTest *tc UNUSED) { 23630 23631 smallArrayt* r; 23632 smallArrayt *self = allocG(rtSmallArrayt); 23633 smallArrayt *array = allocSmallArray(); 23634 23635 r = self->f->pushInt(self, 1); 23636 ck_assert_ptr_ne(r, null); 23637 array->f->pushInt(array, 1); 23638 array->f->pushInt(array, 2); 23639 r = shiftNSmashSmallArrayG(self, array); 23640 ck_assert_ptr_ne(r, NULL); 23641 char *s = toStringO(r); 23642 ck_assert_str_eq(s, "[1,2,1]"); 23643 free(s); 23644 terminateO(self); 23645 23646 } 23647 23648 23649 void shiftNSmashSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 23650 23651 smallArrayt* r; 23652 smallArrayt *self = allocG(rtSmallArrayt); 23653 smallJsont *json = allocSmallJson(); 23654 23655 r = self->f->pushInt(self, 1); 23656 ck_assert_ptr_ne(r, null); 23657 json->f->pushInt(json, 1); 23658 json->f->pushInt(json, 2); 23659 r = shiftNSmashSmallJsonSmallArrayG(self, json); 23660 ck_assert_ptr_ne(r, NULL); 23661 char *s = toStringO(r); 23662 ck_assert_str_eq(s, "[1,2,1]"); 23663 free(s); 23664 terminateO(self); 23665 23666 } 23667 23668 23669 void addSmallArrayGT(CuTest *tc UNUSED) { 23670 23671 smallArrayt* r; 23672 smallArrayt *self = allocG(rtSmallArrayt); 23673 createAllocateSmallArray(a); 23674 23675 // add an element to check that the second array is added 23676 // at the end 23677 r = self->f->pushInt(self, 1); 23678 ck_assert_ptr_ne(r, null); 23679 23680 // add array 23681 a->f->pushInt(a, 2); 23682 r = addSmallArrayG(self, a); 23683 smashO(a); 23684 ck_assert_ptr_ne(r, null); 23685 char *s = toStringO(r); 23686 terminateO(r); 23687 ck_assert_str_eq(s, "[1,2]"); 23688 free(s); 23689 // empty array 23690 initiateAllocateSmallArray(&a); 23691 r = addSmallArrayG(self, a); 23692 smashO(a); 23693 ck_assert_ptr_ne(r, null); 23694 s = toStringO(r); 23695 terminateO(r); 23696 ck_assert_str_eq(s, "[1]"); 23697 free(s); 23698 // non smallArray object 23699 a = (smallArrayt*) allocSmallInt(0); 23700 r = addSmallArrayG(self, a); 23701 ck_assert_ptr_eq(r, NULL); 23702 terminateO(a); 23703 terminateO(self); 23704 23705 } 23706 23707 23708 void sliceSmallArrayGT(CuTest *tc UNUSED) { 23709 23710 smallArrayt* r; 23711 smallArrayt *self = allocG(rtSmallArrayt); 23712 23713 r = self->f->pushInt(self, 1); 23714 ck_assert_ptr_ne(r, null); 23715 r = self->f->pushInt(self, 2); 23716 ck_assert_ptr_ne(r, null); 23717 r = self->f->pushInt(self, 3); 23718 ck_assert_ptr_ne(r, null); 23719 r = self->f->pushInt(self, 4); 23720 ck_assert_ptr_ne(r, null); 23721 r = sliceSmallArrayG(self, 1, -1); 23722 ck_assert_ptr_ne(r, null); 23723 char *s = toStringO(r); 23724 ck_assert_str_eq(s, "[2,3]"); 23725 free(s); 23726 terminateO(self); 23727 23728 } 23729 23730 23731 void cropSmallArrayGT(CuTest *tc UNUSED) { 23732 23733 smallArrayt* r; 23734 smallArrayt *self = allocG(rtSmallArrayt); 23735 23736 r = self->f->pushInt(self, 1); 23737 ck_assert_ptr_ne(r, null); 23738 r = self->f->pushInt(self, 2); 23739 ck_assert_ptr_ne(r, null); 23740 r = self->f->pushInt(self, 3); 23741 ck_assert_ptr_ne(r, null); 23742 r = self->f->pushInt(self, 4); 23743 ck_assert_ptr_ne(r, null); 23744 r = cropSmallArrayG(self, 1, -1); 23745 ck_assert_ptr_ne(r, null); 23746 char *s = toStringO(r); 23747 terminateO(r); 23748 ck_assert_str_eq(s, "[2,3]"); 23749 free(s); 23750 s = toStringO(self); 23751 ck_assert_str_eq(s, "[1,4]"); 23752 free(s); 23753 terminateO(self); 23754 23755 } 23756 23757 23758 void cropElemSmallArrayGT(CuTest *tc UNUSED) { 23759 23760 baset* r; 23761 smallArrayt *self = allocG(rtSmallArrayt); 23762 23763 smallArrayt *r2 = self->f->pushInt(self, 1); 23764 ck_assert_ptr_ne(r2, null); 23765 r = cropElemSmallArrayG(self, 0); 23766 ck_assert_ptr_ne(r, null); 23767 char *s = toStringO(r); 23768 terminateO(r); 23769 ck_assert_str_eq(s, "1"); 23770 free(s); 23771 terminateO(self); 23772 23773 } 23774 23775 23776 void cropElemUndefinedSmallArrayGT(CuTest *tc UNUSED) { 23777 23778 undefinedt* r; 23779 smallArrayt *self = allocG(rtSmallArrayt); 23780 23781 smallArrayt *r2 = self->f->pushUndefined(self); 23782 ck_assert_ptr_ne(r2, null); 23783 r = cropElemUndefinedSmallArrayG(self, 0); 23784 ck_assert_ptr_ne(r, null); 23785 char *s = toStringO(r); 23786 terminateO(r); 23787 ck_assert_str_eq(s, "null"); 23788 free(s); 23789 terminateO(self); 23790 23791 } 23792 23793 23794 void cropElemBoolSmallArrayGT(CuTest *tc UNUSED) { 23795 23796 bool r; 23797 smallArrayt *self = allocG(rtSmallArrayt); 23798 23799 smallArrayt *r2 = self->f->pushBool(self, true); 23800 ck_assert_ptr_ne(r2, null); 23801 r = cropElemBoolSmallArrayG(self, 0); 23802 ck_assert(r); 23803 terminateO(self); 23804 23805 } 23806 23807 23808 void cropElemDoubleSmallArrayGT(CuTest *tc UNUSED) { 23809 23810 double r; 23811 smallArrayt *self = allocG(rtSmallArrayt); 23812 23813 smallArrayt *r2 = self->f->pushDouble(self, 1); 23814 ck_assert_ptr_ne(r2, null); 23815 r = cropElemDoubleSmallArrayG(self, 0); 23816 ck_assert(r==1); 23817 terminateO(self); 23818 23819 } 23820 23821 23822 void cropElemIntSmallArrayGT(CuTest *tc UNUSED) { 23823 23824 int64_t r; 23825 smallArrayt *self = allocG(rtSmallArrayt); 23826 23827 smallArrayt *r2 = self->f->pushInt(self, 2); 23828 ck_assert_ptr_ne(r2, null); 23829 r = cropElemIntSmallArrayG(self, 0); 23830 ck_assert_int_eq(r, 2); 23831 terminateO(self); 23832 23833 } 23834 23835 23836 void cropElemInt32SmallArrayGT(CuTest *tc UNUSED) { 23837 23838 int32_t r; 23839 smallArrayt *self = allocG(rtSmallArrayt); 23840 23841 smallArrayt *r2 = self->f->pushInt(self, 2); 23842 ck_assert_ptr_ne(r2, null); 23843 r = cropElemInt32SmallArrayG(self, 0); 23844 ck_assert_int_eq(r, 2); 23845 terminateO(self); 23846 23847 } 23848 23849 23850 void cropElemUintSmallArrayGT(CuTest *tc UNUSED) { 23851 23852 uint64_t r; 23853 smallArrayt *self = allocG(rtSmallArrayt); 23854 23855 smallArrayt *r2 = self->f->pushInt(self, 2); 23856 ck_assert_ptr_ne(r2, null); 23857 r = cropElemUintSmallArrayG(self, 0); 23858 ck_assert_int_eq(r, 2); 23859 terminateO(self); 23860 23861 } 23862 23863 23864 void cropElemUint32SmallArrayGT(CuTest *tc UNUSED) { 23865 23866 uint32_t r; 23867 smallArrayt *self = allocG(rtSmallArrayt); 23868 23869 smallArrayt *r2 = self->f->pushInt(self, 2); 23870 ck_assert_ptr_ne(r2, null); 23871 r = cropElemUint32SmallArrayG(self, 0); 23872 ck_assert_int_eq(r, 2); 23873 terminateO(self); 23874 23875 } 23876 23877 23878 void cropElemSSmallArrayGT(CuTest *tc UNUSED) { 23879 23880 char* r; 23881 smallArrayt *self = allocG(rtSmallArrayt); 23882 23883 smallArrayt *r2 = self->f->pushS(self, "qwe"); 23884 ck_assert_ptr_ne(r2, null); 23885 r = cropElemSSmallArrayG(self, 0); 23886 ck_assert_str_eq(r, "qwe"); 23887 free(r); 23888 terminateO(self); 23889 23890 } 23891 23892 23893 void cropElemDictSmallArrayGT(CuTest *tc UNUSED) { 23894 23895 smallDictt* r; 23896 smallArrayt *self = allocG(rtSmallArrayt); 23897 23898 createSmallDict(d); 23899 (&d)->f->setInt(&d, "a", 1); 23900 smallArrayt *r2 = self->f->pushDict(self, &d); 23901 ck_assert_ptr_ne(r2, null); 23902 r = cropElemDictSmallArrayG(self, 0); 23903 ck_assert_ptr_ne(r, null); 23904 char *s = toStringO(r); 23905 terminateO(r); 23906 ck_assert_str_eq(s, "{\"a\":1}"); 23907 free(s); 23908 terminateO(self); 23909 23910 } 23911 23912 23913 void cropElemArraySmallArrayGT(CuTest *tc UNUSED) { 23914 23915 smallArrayt* r; 23916 smallArrayt *self = allocG(rtSmallArrayt); 23917 23918 r = allocSmallArray(); 23919 r->f->pushInt(r, 1); 23920 smallArrayt *r2 = self->f->pushNFreeArray(self, r); 23921 ck_assert_ptr_ne(r2, null); 23922 r = cropElemArraySmallArrayG(self, 0); 23923 ck_assert_ptr_ne(r, null); 23924 char *s = toStringO(r); 23925 terminateO(r); 23926 ck_assert_str_eq(s, "[1]"); 23927 free(s); 23928 terminateO(self); 23929 23930 } 23931 23932 23933 void cropElemSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 23934 23935 smallBoolt* r; 23936 smallArrayt *self = allocG(rtSmallArrayt); 23937 23938 smallArrayt *r2 = self->f->pushBool(self, true); 23939 ck_assert_ptr_ne(r2, null); 23940 r = cropElemSmallBoolSmallArrayG(self, 0); 23941 ck_assert_ptr_ne(r, null); 23942 char *s = toStringO(r); 23943 terminateO(r); 23944 ck_assert_str_eq(s, "true"); 23945 free(s); 23946 terminateO(self); 23947 23948 } 23949 23950 23951 void cropElemSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 23952 23953 smallBytest* r; 23954 smallArrayt *self = allocG(rtSmallArrayt); 23955 23956 r = allocSmallBytes("qwe", 3); 23957 smallArrayt *r2 = self->f->pushNFreeSmallBytes(self, r); 23958 ck_assert_ptr_ne(r2, null); 23959 r = cropElemSmallBytesSmallArrayG(self, 0); 23960 ck_assert_ptr_ne(r, null); 23961 char *s = toStringO(r); 23962 terminateO(r); 23963 ck_assert_str_eq(s, "[0x71,0x77,0x65]"); 23964 free(s); 23965 terminateO(self); 23966 23967 } 23968 23969 23970 void cropElemSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 23971 23972 smallDoublet* r; 23973 smallArrayt *self = allocG(rtSmallArrayt); 23974 23975 smallArrayt *r2 = self->f->pushDouble(self, 1); 23976 ck_assert_ptr_ne(r2, null); 23977 r = cropElemSmallDoubleSmallArrayG(self, 0); 23978 ck_assert_ptr_ne(r, null); 23979 char *s = toStringO(r); 23980 terminateO(r); 23981 ck_assert_str_eq(s, "1.000000e+00"); 23982 free(s); 23983 terminateO(self); 23984 23985 } 23986 23987 23988 void cropElemSmallIntSmallArrayGT(CuTest *tc UNUSED) { 23989 23990 smallIntt* r; 23991 smallArrayt *self = allocG(rtSmallArrayt); 23992 23993 smallArrayt *r2 = self->f->pushInt(self, 1); 23994 ck_assert_ptr_ne(r2, null); 23995 r = cropElemSmallIntSmallArrayG(self, 0); 23996 ck_assert_ptr_ne(r, null); 23997 char *s = toStringO(r); 23998 terminateO(r); 23999 ck_assert_str_eq(s, "1"); 24000 free(s); 24001 terminateO(self); 24002 24003 } 24004 24005 24006 void cropElemSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 24007 24008 smallJsont* r; 24009 smallArrayt *self = allocG(rtSmallArrayt); 24010 24011 r = allocSmallJson(); 24012 r->f->setInt(r, "a", 1); 24013 smallArrayt *r2 = self->f->pushNFreeSmallJson(self, r); 24014 ck_assert_ptr_ne(r2, null); 24015 r = cropElemSmallJsonSmallArrayG(self, 0); 24016 ck_assert_ptr_ne(r, null); 24017 char *s = toStringO(r); 24018 terminateO(r); 24019 ck_assert_str_eq(s, "{\"a\":1}"); 24020 free(s); 24021 terminateO(self); 24022 24023 } 24024 24025 24026 void cropElemSmallStringSmallArrayGT(CuTest *tc UNUSED) { 24027 24028 smallStringt* r; 24029 smallArrayt *self = allocG(rtSmallArrayt); 24030 24031 smallArrayt *r2 = self->f->pushS(self, "qwe"); 24032 ck_assert_ptr_ne(r2, null); 24033 r = cropElemSmallStringSmallArrayG(self, 0); 24034 ck_assert_ptr_ne(r, null); 24035 char *s = toStringO(r); 24036 terminateO(r); 24037 ck_assert_str_eq(s, "qwe"); 24038 free(s); 24039 terminateO(self); 24040 24041 } 24042 24043 24044 void cropElemVoidSmallArrayGT(CuTest *tc UNUSED) { 24045 24046 void* r; 24047 smallArrayt *self = allocG(rtSmallArrayt); 24048 24049 smallArrayt *r2 = pushVoidSmallArrayG(self, &r); 24050 ck_assert_ptr_ne(r2, null); 24051 r = cropElemVoidSmallArrayG(self, 0); 24052 ck_assert_ptr_eq(r, &r); 24053 terminateO(self); 24054 24055 } 24056 24057 24058 void cropElemSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 24059 24060 smallContainert* r; 24061 smallArrayt *self = allocG(rtSmallArrayt); 24062 24063 createSmallContainer(e2); 24064 smallArrayt *r2 = self->f->pushSmallContainer(self, &e2); 24065 ck_assert_ptr_ne(r2, null); 24066 r = cropElemSmallContainerSmallArrayG(self, 0); 24067 ck_assert_ptr_ne(r, null); 24068 char *s = toStringO(r); 24069 terminateO(r); 24070 ck_assert_str_eq(s, "<data smallContainer>"); 24071 free(s); 24072 terminateO(self); 24073 24074 } 24075 24076 24077 void copySmallArrayGT(CuTest *tc UNUSED) { 24078 24079 smallArrayt* r; 24080 smallArrayt *self = allocG(rtSmallArrayt); 24081 24082 // add elements to self 24083 r = self->f->pushInt(self, 1); 24084 ck_assert_ptr_ne(r, null); 24085 r = self->f->pushInt(self, 2); 24086 ck_assert_ptr_ne(r, null); 24087 r = self->f->pushInt(self, 3); 24088 ck_assert_ptr_ne(r, null); 24089 r = self->f->pushInt(self, 4); 24090 ck_assert_ptr_ne(r, null); 24091 r = copySmallArrayG(self, 1, -1); 24092 ck_assert_ptr_ne(r, null); 24093 ck_assert_int_eq(lenO(r), 2); 24094 char *s = toStringO(r); 24095 terminateO(r); 24096 ck_assert_str_eq(s, "[2,3]"); 24097 free(s); 24098 s = toStringO(self); 24099 ck_assert_str_eq(s, "[1,2,3,4]"); 24100 free(s); 24101 terminateO(self); 24102 24103 } 24104 24105 24106 void insertSmallArrayGT(CuTest *tc UNUSED) { 24107 24108 smallArrayt* r; 24109 smallArrayt *self = allocG(rtSmallArrayt); 24110 smallArrayt *toInsert = allocSmallArray(); 24111 24112 toInsert->f->pushInt(toInsert, 3); 24113 r = insertSmallArrayG(self, 0, toInsert); 24114 smashO(toInsert); 24115 ck_assert_ptr_ne(r, null); 24116 char *s = toStringO(r); 24117 ck_assert_str_eq(s, "[3]"); 24118 free(s); 24119 terminateO(self); 24120 24121 } 24122 24123 24124 void insertSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 24125 24126 smallArrayt* r; 24127 smallArrayt *self = allocG(rtSmallArrayt); 24128 smallJsont *toInsert = allocSmallJson(); 24129 24130 toInsert->f->pushInt(toInsert, 3); 24131 r = insertSmallJsonSmallArrayG(self, 0, toInsert); 24132 smashO(toInsert); 24133 ck_assert_ptr_ne(r, null); 24134 char *s = toStringO(r); 24135 ck_assert_str_eq(s, "[3]"); 24136 free(s); 24137 terminateO(self); 24138 24139 } 24140 24141 24142 void insertNSmashSmallArrayGT(CuTest *tc UNUSED) { 24143 24144 smallArrayt* r; 24145 smallArrayt *self = allocG(rtSmallArrayt); 24146 smallArrayt *toInsert = allocSmallArray(); 24147 24148 toInsert->f->pushInt(toInsert, 3); 24149 r = insertNSmashSmallArrayG(self, 0, toInsert); 24150 ck_assert_ptr_ne(r, null); 24151 char *s = toStringO(r); 24152 ck_assert_str_eq(s, "[3]"); 24153 free(s); 24154 terminateO(self); 24155 24156 } 24157 24158 24159 void insertNSmashSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 24160 24161 smallArrayt* r; 24162 smallArrayt *self = allocG(rtSmallArrayt); 24163 smallJsont *toInsert = allocSmallJson(); 24164 24165 toInsert->f->pushInt(toInsert, 3); 24166 r = insertNSmashSmallJsonSmallArrayG(self, 0, toInsert); 24167 ck_assert_ptr_ne(r, null); 24168 char *s = toStringO(r); 24169 ck_assert_str_eq(s, "[3]"); 24170 free(s); 24171 terminateO(self); 24172 24173 } 24174 24175 24176 void injectSmallArrayGT(CuTest *tc UNUSED) { 24177 24178 smallArrayt* r; 24179 smallArrayt *self = allocG(rtSmallArrayt); 24180 baset *value = (baset*) allocSmallInt(8); 24181 24182 r = injectSmallArrayG(self, 0, value); 24183 ck_assert_ptr_ne(r, null); 24184 finishO(value); 24185 char *s = toStringO(r); 24186 ck_assert_str_eq(s, "[8]"); 24187 free(s); 24188 terminateO(self); 24189 24190 } 24191 24192 24193 void injectUndefinedSmallArrayGT(CuTest *tc UNUSED) { 24194 24195 smallArrayt* r; 24196 smallArrayt *self = allocG(rtSmallArrayt); 24197 24198 r = injectUndefinedSmallArrayG(self, 0, null); 24199 ck_assert_ptr_ne(r, null); 24200 char *s = toStringO(r); 24201 ck_assert_str_eq(s, "[null]"); 24202 free(s); 24203 terminateO(self); 24204 24205 } 24206 24207 24208 void injectBoolSmallArrayGT(CuTest *tc UNUSED) { 24209 24210 smallArrayt* r; 24211 smallArrayt *self = allocG(rtSmallArrayt); 24212 24213 r = injectBoolSmallArrayG(self, 0, true); 24214 ck_assert_ptr_ne(r, null); 24215 char *s = toStringO(r); 24216 ck_assert_str_eq(s, "[true]"); 24217 free(s); 24218 terminateO(self); 24219 24220 } 24221 24222 24223 void injectDoubleSmallArrayGT(CuTest *tc UNUSED) { 24224 24225 smallArrayt* r; 24226 smallArrayt *self = allocG(rtSmallArrayt); 24227 24228 r = injectDoubleSmallArrayG(self, 0, 1); 24229 ck_assert_ptr_ne(r, null); 24230 char *s = toStringO(r); 24231 ck_assert_str_eq(s, "[1.000000e+00]"); 24232 free(s); 24233 terminateO(self); 24234 24235 } 24236 24237 24238 void injectIntSmallArrayGT(CuTest *tc UNUSED) { 24239 24240 smallArrayt* r; 24241 smallArrayt *self = allocG(rtSmallArrayt); 24242 24243 r = injectIntSmallArrayG(self, 0, 2); 24244 ck_assert_ptr_ne(r, null); 24245 char *s = toStringO(r); 24246 ck_assert_str_eq(s, "[2]"); 24247 free(s); 24248 terminateO(self); 24249 24250 } 24251 24252 24253 void injectSSmallArrayGT(CuTest *tc UNUSED) { 24254 24255 smallArrayt* r; 24256 smallArrayt *self = allocG(rtSmallArrayt); 24257 24258 r = injectSSmallArrayG(self, 0, "qwe"); 24259 ck_assert_ptr_ne(r, null); 24260 char *s = toStringO(r); 24261 ck_assert_str_eq(s, "[\"qwe\"]"); 24262 free(s); 24263 terminateO(self); 24264 24265 } 24266 24267 24268 void injectCharSmallArrayGT(CuTest *tc UNUSED) { 24269 24270 smallArrayt* r; 24271 smallArrayt *self = allocG(rtSmallArrayt); 24272 24273 r = injectCharSmallArrayG(self, 0, 'a'); 24274 ck_assert_ptr_ne(r, null); 24275 char *s = toStringO(r); 24276 ck_assert_str_eq(s, "[\"a\"]"); 24277 free(s); 24278 terminateO(self); 24279 24280 } 24281 24282 24283 void injectDictSmallArrayGT(CuTest *tc UNUSED) { 24284 24285 smallArrayt* r; 24286 smallArrayt *self = allocG(rtSmallArrayt); 24287 24288 createSmallDict(d); 24289 r = injectDictSmallArrayG(self, 0, &d); 24290 ck_assert_ptr_ne(r, null); 24291 char *s = toStringO(r); 24292 ck_assert_str_eq(s, "[{}]"); 24293 free(s); 24294 terminateO(self); 24295 24296 } 24297 24298 24299 void injectArraySmallArrayGT(CuTest *tc UNUSED) { 24300 24301 smallArrayt* r; 24302 smallArrayt *self = allocG(rtSmallArrayt); 24303 24304 createSmallArray(a); 24305 r = injectArraySmallArrayG(self, 0, &a); 24306 ck_assert_ptr_ne(r, null); 24307 char *s = toStringO(r); 24308 ck_assert_str_eq(s, "[[]]"); 24309 free(s); 24310 terminateO(self); 24311 24312 } 24313 24314 24315 void injectArraycSmallArrayGT(CuTest *tc UNUSED) { 24316 24317 smallArrayt* r; 24318 smallArrayt *self = allocG(rtSmallArrayt); 24319 char **array = listCreateS("a","b"); 24320 24321 r = injectArraycSmallArrayG(self, 0, array); 24322 ck_assert_ptr_ne(r, null); 24323 listFreeS(array); 24324 char *s = toStringO(r); 24325 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 24326 free(s); 24327 terminateO(self); 24328 24329 } 24330 24331 24332 void injectCArraycSmallArrayGT(CuTest *tc UNUSED) { 24333 24334 smallArrayt* r; 24335 smallArrayt *self = allocG(rtSmallArrayt); 24336 const char *array[] = {"a","b",null}; 24337 24338 r = injectCArraycSmallArrayG(self, 0, array); 24339 ck_assert_ptr_ne(r, null); 24340 char *s = toStringO(r); 24341 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 24342 free(s); 24343 terminateO(self); 24344 24345 } 24346 24347 24348 void injectVoidSmallArrayGT(CuTest *tc UNUSED) { 24349 24350 smallArrayt* r; 24351 smallArrayt *self = allocG(rtSmallArrayt); 24352 24353 r = injectVoidSmallArrayG(self, 0, null); 24354 ck_assert_ptr_ne(r, null); 24355 char *s = toStringO(r); 24356 ck_assert_str_eq(s, "[null]"); 24357 free(s); 24358 r = injectVoidSmallArrayG(self, 0, &r); 24359 ck_assert_ptr_ne(r, null); 24360 s = toStringO(r); 24361 ck_assert_str_eq(s, "[\"<data container>\",null]"); 24362 free(s); 24363 terminateO(self); 24364 24365 } 24366 24367 24368 void injectSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 24369 24370 smallArrayt* r; 24371 smallArrayt *self = allocG(rtSmallArrayt); 24372 24373 smallBoolt *b = allocSmallBool(true); 24374 r = injectSmallBoolSmallArrayG(self, 0, b); 24375 ck_assert_ptr_ne(r, null); 24376 finishO(b); 24377 char *s = toStringO(r); 24378 ck_assert_str_eq(s, "[true]"); 24379 free(s); 24380 terminateO(self); 24381 24382 } 24383 24384 24385 void injectSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 24386 24387 smallArrayt* r; 24388 smallArrayt *self = allocG(rtSmallArrayt); 24389 smallBytest *b = allocSmallBytes("qwe", 3); 24390 24391 r = injectSmallBytesSmallArrayG(self, 0, b); 24392 ck_assert_ptr_ne(r, null); 24393 finishO(b); 24394 char *s = toStringO(r); 24395 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 24396 free(s); 24397 terminateO(self); 24398 24399 } 24400 24401 24402 void injectSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 24403 24404 smallArrayt* r; 24405 smallArrayt *self = allocG(rtSmallArrayt); 24406 smallDoublet *value = allocSmallDouble(1); 24407 24408 r = injectSmallDoubleSmallArrayG(self, 0, value); 24409 ck_assert_ptr_ne(r, null); 24410 finishO(value); 24411 char *s = toStringO(r); 24412 ck_assert_str_eq(s, "[1.000000e+00]"); 24413 free(s); 24414 terminateO(self); 24415 24416 } 24417 24418 24419 void injectSmallIntSmallArrayGT(CuTest *tc UNUSED) { 24420 24421 smallArrayt* r; 24422 smallArrayt *self = allocG(rtSmallArrayt); 24423 smallIntt *value = allocSmallInt(1); 24424 24425 r = injectSmallIntSmallArrayG(self, 0, value); 24426 ck_assert_ptr_ne(r, null); 24427 finishO(value); 24428 char *s = toStringO(r); 24429 ck_assert_str_eq(s, "[1]"); 24430 free(s); 24431 terminateO(self); 24432 24433 } 24434 24435 24436 void injectSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 24437 24438 smallArrayt* r; 24439 smallArrayt *self = allocG(rtSmallArrayt); 24440 smallJsont *string = allocSmallJson(); 24441 24442 r = injectSmallJsonSmallArrayG(self, 0, string); 24443 ck_assert_ptr_ne(r, null); 24444 finishO(string); 24445 char *s = toStringO(r); 24446 ck_assert_str_eq(s, "[{}]"); 24447 free(s); 24448 terminateO(self); 24449 24450 } 24451 24452 24453 void injectSmallStringSmallArrayGT(CuTest *tc UNUSED) { 24454 24455 smallArrayt* r; 24456 smallArrayt *self = allocG(rtSmallArrayt); 24457 smallStringt *string = allocSmallString("qwe"); 24458 24459 r = injectSmallStringSmallArrayG(self, 0, string); 24460 ck_assert_ptr_ne(r, null); 24461 finishO(string); 24462 char *s = toStringO(r); 24463 ck_assert_str_eq(s, "[\"qwe\"]"); 24464 free(s); 24465 terminateO(self); 24466 24467 } 24468 24469 24470 void injectSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 24471 24472 smallArrayt* r; 24473 smallArrayt *self = allocG(rtSmallArrayt); 24474 smallContainert *value = allocSmallContainer(null); 24475 24476 r = injectSmallContainerSmallArrayG(self, 0, value); 24477 ck_assert_ptr_ne(r, null); 24478 finishO(value); 24479 char *s = toStringO(r); 24480 ck_assert_str_eq(s, "[\"<data container>\"]"); 24481 free(s); 24482 terminateO(self); 24483 24484 } 24485 24486 24487 void injectNFreeSmallArrayGT(CuTest *tc UNUSED) { 24488 24489 smallArrayt* r; 24490 smallArrayt *self = allocG(rtSmallArrayt); 24491 baset *value = (baset*) allocSmallInt(8); 24492 24493 r = injectNFreeSmallArrayG(self, 0, value); 24494 ck_assert_ptr_ne(r, null); 24495 char *s = toStringO(r); 24496 ck_assert_str_eq(s, "[8]"); 24497 free(s); 24498 terminateO(self); 24499 24500 } 24501 24502 24503 void injectNFreeUndefinedSmallArrayGT(CuTest *tc UNUSED) { 24504 24505 smallArrayt* r; 24506 smallArrayt *self = allocG(rtSmallArrayt); 24507 24508 createAllocateUndefined(u); 24509 r = injectNFreeUndefinedSmallArrayG(self, 0, u); 24510 ck_assert_ptr_ne(r, null); 24511 char *s = toStringO(r); 24512 ck_assert_str_eq(s, "[null]"); 24513 free(s); 24514 terminateO(self); 24515 24516 } 24517 24518 24519 void injectNFreeSSmallArrayGT(CuTest *tc UNUSED) { 24520 24521 smallArrayt* r; 24522 smallArrayt *self = allocG(rtSmallArrayt); 24523 char *string = strdup("qwe"); 24524 24525 r = injectNFreeSSmallArrayG(self, 0, string); 24526 ck_assert_ptr_ne(r, null); 24527 char *s = toStringO(r); 24528 ck_assert_str_eq(s, "[\"qwe\"]"); 24529 free(s); 24530 terminateO(self); 24531 24532 } 24533 24534 24535 void injectNFreeDictSmallArrayGT(CuTest *tc UNUSED) { 24536 24537 smallArrayt* r; 24538 smallArrayt *self = allocG(rtSmallArrayt); 24539 24540 createAllocateSmallDict(d); 24541 r = injectNFreeDictSmallArrayG(self, 0, d); 24542 ck_assert_ptr_ne(r, null); 24543 char *s = toStringO(r); 24544 ck_assert_str_eq(s, "[{}]"); 24545 free(s); 24546 terminateO(self); 24547 24548 } 24549 24550 24551 void injectNFreeArraySmallArrayGT(CuTest *tc UNUSED) { 24552 24553 smallArrayt* r; 24554 smallArrayt *self = allocG(rtSmallArrayt); 24555 24556 createAllocateSmallArray(a); 24557 r = injectNFreeArraySmallArrayG(self, 0, a); 24558 ck_assert_ptr_ne(r, null); 24559 char *s = toStringO(r); 24560 ck_assert_str_eq(s, "[[]]"); 24561 free(s); 24562 terminateO(self); 24563 24564 } 24565 24566 24567 void injectNFreeArraycSmallArrayGT(CuTest *tc UNUSED) { 24568 24569 smallArrayt* r; 24570 smallArrayt *self = allocG(rtSmallArrayt); 24571 char **array = listCreateS("a","b"); 24572 24573 r = injectNFreeArraycSmallArrayG(self, 0, array); 24574 ck_assert_ptr_ne(r, null); 24575 char *s = toStringO(r); 24576 ck_assert_str_eq(s, "[[\"a\",\"b\"]]"); 24577 free(s); 24578 terminateO(self); 24579 24580 } 24581 24582 24583 void injectNFreeSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 24584 24585 smallArrayt* r; 24586 smallArrayt *self = allocG(rtSmallArrayt); 24587 24588 smallBoolt *b = allocSmallBool(true); 24589 r = injectNFreeSmallBoolSmallArrayG(self, 0, b); 24590 ck_assert_ptr_ne(r, null); 24591 char *s = toStringO(r); 24592 ck_assert_str_eq(s, "[true]"); 24593 free(s); 24594 terminateO(self); 24595 24596 } 24597 24598 24599 void injectNFreeSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 24600 24601 smallArrayt* r; 24602 smallArrayt *self = allocG(rtSmallArrayt); 24603 smallBytest *b = allocSmallBytes("qwe", 3); 24604 24605 r = injectNFreeSmallBytesSmallArrayG(self, 0, b); 24606 ck_assert_ptr_ne(r, null); 24607 char *s = toStringO(r); 24608 ck_assert_str_eq(s, "[[0x71,0x77,0x65]]"); 24609 free(s); 24610 terminateO(self); 24611 24612 } 24613 24614 24615 void injectNFreeSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 24616 24617 smallArrayt* r; 24618 smallArrayt *self = allocG(rtSmallArrayt); 24619 smallDoublet *value = allocSmallDouble(1); 24620 24621 r = injectNFreeSmallDoubleSmallArrayG(self, 0, value); 24622 ck_assert_ptr_ne(r, null); 24623 char *s = toStringO(r); 24624 ck_assert_str_eq(s, "[1.000000e+00]"); 24625 free(s); 24626 terminateO(self); 24627 24628 } 24629 24630 24631 void injectNFreeSmallIntSmallArrayGT(CuTest *tc UNUSED) { 24632 24633 smallArrayt* r; 24634 smallArrayt *self = allocG(rtSmallArrayt); 24635 smallIntt *value = allocSmallInt(1); 24636 24637 r = injectNFreeSmallIntSmallArrayG(self, 0, value); 24638 ck_assert_ptr_ne(r, null); 24639 char *s = toStringO(r); 24640 ck_assert_str_eq(s, "[1]"); 24641 free(s); 24642 terminateO(self); 24643 24644 } 24645 24646 24647 void injectNFreeSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 24648 24649 smallArrayt* r; 24650 smallArrayt *self = allocG(rtSmallArrayt); 24651 smallJsont *string = allocSmallJson(); 24652 24653 r = injectNFreeSmallJsonSmallArrayG(self, 0, string); 24654 ck_assert_ptr_ne(r, null); 24655 char *s = toStringO(r); 24656 ck_assert_str_eq(s, "[{}]"); 24657 free(s); 24658 terminateO(self); 24659 24660 } 24661 24662 24663 void injectNFreeSmallStringSmallArrayGT(CuTest *tc UNUSED) { 24664 24665 smallArrayt* r; 24666 smallArrayt *self = allocG(rtSmallArrayt); 24667 smallStringt *string = allocSmallString("qwe"); 24668 24669 r = injectNFreeSmallStringSmallArrayG(self, 0, string); 24670 ck_assert_ptr_ne(r, null); 24671 char *s = toStringO(r); 24672 ck_assert_str_eq(s, "[\"qwe\"]"); 24673 free(s); 24674 terminateO(self); 24675 24676 } 24677 24678 24679 void injectNFreeSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 24680 24681 smallArrayt* r; 24682 smallArrayt *self = allocG(rtSmallArrayt); 24683 smallContainert *value = allocSmallContainer(null); 24684 24685 r = injectNFreeSmallContainerSmallArrayG(self, 0, value); 24686 ck_assert_ptr_ne(r, null); 24687 char *s = toStringO(r); 24688 ck_assert_str_eq(s, "[\"<data container>\"]"); 24689 free(s); 24690 terminateO(self); 24691 24692 } 24693 24694 24695 void delSmallArrayGT(CuTest *tc UNUSED) { 24696 24697 smallArrayt* r; 24698 smallArrayt *self = allocG(rtSmallArrayt); 24699 24700 r = self->f->pushInt(self, 1); 24701 ck_assert_ptr_ne(r, null); 24702 r = self->f->pushInt(self, 2); 24703 ck_assert_ptr_ne(r, null); 24704 r = self->f->pushInt(self, 3); 24705 ck_assert_ptr_ne(r, null); 24706 r = self->f->pushInt(self, 4); 24707 ck_assert_ptr_ne(r, null); 24708 r = delSmallArrayG(self, 1, -1); 24709 ck_assert_ptr_ne(r, null); 24710 char *s = toStringO(r); 24711 ck_assert_str_eq(s, "[1,4]"); 24712 free(s); 24713 terminateO(self); 24714 24715 } 24716 24717 24718 void delElemSmallArrayGT(CuTest *tc UNUSED) { 24719 24720 smallArrayt* r; 24721 smallArrayt *self = allocG(rtSmallArrayt); 24722 24723 r = self->f->pushInt(self, 1); 24724 ck_assert_ptr_ne(r, null); 24725 r = self->f->pushInt(self, 2); 24726 ck_assert_ptr_ne(r, null); 24727 r = self->f->pushInt(self, 3); 24728 ck_assert_ptr_ne(r, null); 24729 r = self->f->pushInt(self, 4); 24730 ck_assert_ptr_ne(r, null); 24731 r = delElemSmallArrayG(self, 0); 24732 ck_assert_ptr_ne(r, null); 24733 char *s = toStringO(r); 24734 ck_assert_str_eq(s, "[2,3,4]"); 24735 free(s); 24736 r = delElemSmallArrayG(self, -1); 24737 ck_assert_ptr_ne(r, null); 24738 s = toStringO(r); 24739 ck_assert_str_eq(s, "[2,3]"); 24740 free(s); 24741 r = delElemSmallArrayG(self, 5); 24742 ck_assert_ptr_eq(r, null); 24743 r = delElemSmallArrayG(self, -5); 24744 ck_assert_ptr_eq(r, null); 24745 terminateO(self); 24746 24747 } 24748 24749 24750 void removeSmallArrayGT(CuTest *tc UNUSED) { 24751 24752 smallArrayt* r; 24753 smallArrayt *self = allocG(rtSmallArrayt); 24754 24755 r = self->f->pushInt(self, 1); 24756 ck_assert_ptr_ne(r, null); 24757 r = self->f->pushInt(self, 2); 24758 ck_assert_ptr_ne(r, null); 24759 r = self->f->pushInt(self, 3); 24760 ck_assert_ptr_ne(r, null); 24761 r = self->f->pushInt(self, 4); 24762 ck_assert_ptr_ne(r, null); 24763 24764 smallIntt *e[4]; 24765 arange(i,e) { 24766 e[i] = self->f->getAtSmallInt(self, i); 24767 } 24768 24769 // negative index 24770 r = removeSmallArrayG(self, 1, -1); 24771 ck_assert_ptr_ne(r, null); 24772 char *s = toStringO(self); 24773 ck_assert_str_eq(s, "[1,4]"); 24774 free(s); 24775 r = removeSmallArrayG(self, 0, 40); 24776 ck_assert_ptr_ne(r, null); 24777 s = toStringO(self); 24778 ck_assert_str_eq(s, "[]"); 24779 free(s); 24780 arange(i,e) { 24781 terminateO(e[i]); 24782 } 24783 terminateO(self); 24784 24785 } 24786 24787 24788 void removeElemSmallArrayGT(CuTest *tc UNUSED) { 24789 24790 smallArrayt* r; 24791 smallArrayt *self = allocG(rtSmallArrayt); 24792 24793 r = self->f->pushInt(self, 1); 24794 ck_assert_ptr_ne(r, null); 24795 r = self->f->pushInt(self, 2); 24796 ck_assert_ptr_ne(r, null); 24797 r = self->f->pushInt(self, 3); 24798 ck_assert_ptr_ne(r, null); 24799 r = self->f->pushInt(self, 4); 24800 ck_assert_ptr_ne(r, null); 24801 smallIntt *e = self->f->getAtSmallInt(self, 1);; 24802 r = removeElemSmallArrayG(self, 1); 24803 ck_assert_ptr_ne(r, null); 24804 terminateO(e); 24805 char *s = toStringO(self); 24806 ck_assert_str_eq(s, "[1,3,4]"); 24807 free(s); 24808 terminateO(self); 24809 24810 } 24811 24812 24813 void sortSmallArrayGT(CuTest *tc UNUSED) { 24814 24815 smallArrayt* r; 24816 smallArrayt *self = allocG(rtSmallArrayt); 24817 24818 self->f->pushS(self, "bb"); 24819 self->f->pushS(self, "a"); 24820 r = sortSmallArrayG(self); 24821 ck_assert_ptr_ne(r, null); 24822 char *s = toStringO(r); 24823 ck_assert_str_eq(s, "[\"a\",\"bb\"]"); 24824 free(s); 24825 terminateO(self); 24826 24827 } 24828 24829 24830 void sortFSmallArrayGT(CuTest *tc UNUSED) { 24831 24832 smallArrayt* r; 24833 smallArrayt *self = allocG(rtSmallArrayt); 24834 24835 // sort dict 24836 smallDictt *d[4]; 24837 arange(i,d) d[i] = allocSmallDict(); 24838 d[0]->f->setInt(d[0], "a", 1); 24839 d[1]->f->setInt(d[1], "a", 0); 24840 d[3]->f->setInt(d[3], "a", 0); 24841 d[3]->f->setInt(d[3], "b", 0); 24842 arange(i,d) self->f->pushNFreeDict(self, d[i]); 24843 r = sortFSmallArrayG(self, sortFOCmp); 24844 ck_assert_ptr_ne(r, null); 24845 char *s = toStringO(r); 24846 ck_assert_str_eq(s, "[{},{\"a\":0},{\"a\":1},{\"a\":0,\"b\":0}]"); 24847 free(s); 24848 terminateO(self); 24849 24850 } 24851 24852 24853 void icSortSmallArrayGT(CuTest *tc UNUSED) { 24854 24855 smallArrayt* r; 24856 smallArrayt *self = allocG(rtSmallArrayt); 24857 24858 self->f->pushS(self, "bb"); 24859 self->f->pushS(self, "A"); 24860 r = icSortSmallArrayG(self); 24861 ck_assert_ptr_ne(r, null); 24862 char *s = toStringO(r); 24863 ck_assert_str_eq(s, "[\"A\",\"bb\"]"); 24864 free(s); 24865 terminateO(self); 24866 24867 } 24868 24869 24870 void equalSmallArrayGT(CuTest *tc UNUSED) { 24871 24872 bool r; 24873 smallArrayt *self = allocG(rtSmallArrayt); 24874 smallArrayt *array = allocSmallArray(); 24875 24876 r = equalSmallArrayG(self, array); 24877 ck_assert(r); 24878 terminateO(array); 24879 terminateO(self); 24880 24881 } 24882 24883 24884 void equalSmallArraySmallJsonGT(CuTest *tc UNUSED) { 24885 24886 bool r; 24887 smallArrayt *self = allocG(rtSmallArrayt); 24888 smallJsont *array = allocSmallJson(); 24889 24890 r = equalSmallArraySmallJsonG(self, array); 24891 // the smallJson is empty, so the result is false 24892 ck_assert(!r); 24893 terminateO(self); 24894 terminateO(array); 24895 24896 } 24897 24898 24899 void equalSmallArrayArrayGT(CuTest *tc UNUSED) { 24900 24901 bool r; 24902 smallArrayt* self = allocG(rtSmallArrayt); 24903 24904 r = equalSmallArrayArrayG(self, null); 24905 ck_assert(r); 24906 terminateO(self); 24907 24908 } 24909 24910 24911 void equalSmallArrayCArrayGT(CuTest *tc UNUSED) { 24912 24913 bool r; 24914 smallArrayt* self = allocG(rtSmallArrayt); 24915 24916 r = equalSmallArrayCArrayG(self, null); 24917 ck_assert(r); 24918 terminateO(self); 24919 24920 } 24921 24922 24923 void equalSmallArrayBaseGT(CuTest *tc UNUSED) { 24924 24925 bool r; 24926 smallArrayt* self = allocG(rtSmallArrayt); 24927 baset* p2 = (baset*) allocG(1); 24928 24929 r = equalSmallArrayBaseG(self, p2); 24930 ck_assert(!r); 24931 terminateO(p2); 24932 terminateO(self); 24933 24934 } 24935 24936 24937 void icEqualSmallArrayGT(CuTest *tc UNUSED) { 24938 24939 bool r; 24940 smallArrayt *self = allocG(rtSmallArrayt); 24941 smallArrayt *array = allocG(rtSmallArrayt); 24942 24943 self->f->pushS(self, "a"); 24944 array->f->pushS(array, "A"); 24945 r = icEqualSmallArrayG(self, array); 24946 ck_assert(r); 24947 terminateO(array); 24948 terminateO(self); 24949 24950 } 24951 24952 24953 void icEqualSmallArraySmallJsonGT(CuTest *tc UNUSED) { 24954 24955 bool r; 24956 smallArrayt *self = allocG(rtSmallArrayt); 24957 smallJsont *array = allocSmallJson(); 24958 24959 r = icEqualSmallArraySmallJsonG(self, array); 24960 ck_assert(!r); 24961 terminateO(array); 24962 terminateO(self); 24963 24964 } 24965 24966 24967 void icEqualSmallArrayArrayGT(CuTest *tc UNUSED) { 24968 24969 bool r; 24970 smallArrayt* self = allocG(rtSmallArrayt); 24971 24972 r = icEqualSmallArrayArrayG(self, null); 24973 ck_assert(r); 24974 terminateO(self); 24975 24976 } 24977 24978 24979 void icEqualSmallArrayCArrayGT(CuTest *tc UNUSED) { 24980 24981 bool r; 24982 smallArrayt* self = allocG(rtSmallArrayt); 24983 24984 r = icEqualSmallArrayCArrayG(self, null); 24985 ck_assert(r); 24986 terminateO(self); 24987 24988 } 24989 24990 24991 void icEqualSmallArrayBaseGT(CuTest *tc UNUSED) { 24992 24993 bool r; 24994 smallArrayt* self = allocG(rtSmallArrayt); 24995 24996 r = icEqualSmallArrayBaseG(self, null); 24997 ck_assert(!r); 24998 terminateO(self); 24999 25000 } 25001 25002 25003 void lenSmallArrayGT(CuTest *tc UNUSED) { 25004 25005 size_t r; 25006 smallArrayt *self = allocG(rtSmallArrayt); 25007 25008 self->f->pushInt(self, 1); 25009 r = lenSmallArrayG(self); 25010 ck_assert_int_eq(r, 1); 25011 terminateO(self); 25012 25013 } 25014 25015 25016 void trimSmallArrayGT(CuTest *tc UNUSED) { 25017 25018 smallArrayt* r; 25019 smallArrayt *self = allocG(rtSmallArrayt); 25020 25021 self->f->pushInt(self, 1); 25022 delElemO(self, 0); 25023 r = trimSmallArrayG(self); 25024 ck_assert_ptr_ne(r, null); 25025 ck_assert_int_eq(lenSmallArrayG(self), 0); 25026 terminateO(self); 25027 25028 } 25029 25030 25031 void hasSmallArrayGT(CuTest *tc UNUSED) { 25032 25033 bool r; 25034 smallArrayt *self = allocG(rtSmallArrayt); 25035 25036 r = hasSmallArrayG(self, null); 25037 ck_assert(!r); 25038 terminateO(self); 25039 25040 } 25041 25042 25043 void hasUndefinedSmallArrayGT(CuTest *tc UNUSED) { 25044 25045 bool r; 25046 smallArrayt *self = allocG(rtSmallArrayt); 25047 25048 r = hasUndefinedSmallArrayG(self, null); 25049 ck_assert(!r); 25050 terminateO(self); 25051 25052 } 25053 25054 25055 void hasBoolSmallArrayGT(CuTest *tc UNUSED) { 25056 25057 bool r; 25058 smallArrayt *self = allocG(rtSmallArrayt); 25059 25060 r = hasBoolSmallArrayG(self, true); 25061 ck_assert(!r); 25062 terminateO(self); 25063 25064 } 25065 25066 25067 void hasDoubleSmallArrayGT(CuTest *tc UNUSED) { 25068 25069 bool r; 25070 smallArrayt *self = allocG(rtSmallArrayt); 25071 25072 r = hasDoubleSmallArrayG(self, 1); 25073 ck_assert(!r); 25074 terminateO(self); 25075 25076 } 25077 25078 25079 void hasIntSmallArrayGT(CuTest *tc UNUSED) { 25080 25081 bool r; 25082 smallArrayt *self = allocG(rtSmallArrayt); 25083 25084 r = hasIntSmallArrayG(self, 1); 25085 ck_assert(!r); 25086 terminateO(self); 25087 25088 } 25089 25090 25091 void hasSSmallArrayGT(CuTest *tc UNUSED) { 25092 25093 bool r; 25094 smallArrayt *self = allocG(rtSmallArrayt); 25095 25096 r = hasSSmallArrayG(self, null); 25097 ck_assert(!r); 25098 terminateO(self); 25099 25100 } 25101 25102 25103 void hasCharSmallArrayGT(CuTest *tc UNUSED) { 25104 25105 bool r; 25106 smallArrayt *self = allocG(rtSmallArrayt); 25107 25108 r = hasCharSmallArrayG(self, ' '); 25109 ck_assert(!r); 25110 terminateO(self); 25111 25112 } 25113 25114 25115 void hasDictSmallArrayGT(CuTest *tc UNUSED) { 25116 25117 bool r; 25118 smallArrayt *self = allocG(rtSmallArrayt); 25119 25120 r = hasDictSmallArrayG(self, null); 25121 ck_assert(!r); 25122 terminateO(self); 25123 25124 } 25125 25126 25127 void hasArraySmallArrayGT(CuTest *tc UNUSED) { 25128 25129 bool r; 25130 smallArrayt *self = allocG(rtSmallArrayt); 25131 25132 r = hasArraySmallArrayG(self, null); 25133 ck_assert(!r); 25134 terminateO(self); 25135 25136 } 25137 25138 25139 void hasArraycSmallArrayGT(CuTest *tc UNUSED) { 25140 25141 bool r; 25142 smallArrayt *self = allocG(rtSmallArrayt); 25143 25144 r = hasArraycSmallArrayG(self, null); 25145 ck_assert(!r); 25146 terminateO(self); 25147 25148 } 25149 25150 25151 void hasCArraycSmallArrayGT(CuTest *tc UNUSED) { 25152 25153 bool r; 25154 smallArrayt *self = allocG(rtSmallArrayt); 25155 25156 r = hasCArraycSmallArrayG(self, null); 25157 ck_assert(!r); 25158 terminateO(self); 25159 25160 } 25161 25162 25163 void hasSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 25164 25165 bool r; 25166 smallArrayt *self = allocG(rtSmallArrayt); 25167 25168 r = hasSmallBoolSmallArrayG(self, null); 25169 ck_assert(!r); 25170 terminateO(self); 25171 25172 } 25173 25174 25175 void hasSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 25176 25177 bool r; 25178 smallArrayt *self = allocG(rtSmallArrayt); 25179 25180 r = hasSmallBytesSmallArrayG(self, null); 25181 ck_assert(!r); 25182 terminateO(self); 25183 25184 } 25185 25186 25187 void hasSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 25188 25189 bool r; 25190 smallArrayt *self = allocG(rtSmallArrayt); 25191 25192 r = hasSmallDoubleSmallArrayG(self, null); 25193 ck_assert(!r); 25194 terminateO(self); 25195 25196 } 25197 25198 25199 void hasSmallIntSmallArrayGT(CuTest *tc UNUSED) { 25200 25201 bool r; 25202 smallArrayt *self = allocG(rtSmallArrayt); 25203 25204 r = hasSmallIntSmallArrayG(self, null); 25205 ck_assert(!r); 25206 terminateO(self); 25207 25208 } 25209 25210 25211 void hasSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 25212 25213 bool r; 25214 smallArrayt *self = allocG(rtSmallArrayt); 25215 25216 r = hasSmallJsonSmallArrayG(self, null); 25217 ck_assert(!r); 25218 terminateO(self); 25219 25220 } 25221 25222 25223 void hasSmallStringSmallArrayGT(CuTest *tc UNUSED) { 25224 25225 bool r; 25226 smallArrayt *self = allocG(rtSmallArrayt); 25227 25228 r = hasSmallStringSmallArrayG(self, null); 25229 ck_assert(!r); 25230 terminateO(self); 25231 25232 } 25233 25234 25235 void hasSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 25236 25237 bool r; 25238 smallArrayt *self = allocG(rtSmallArrayt); 25239 25240 r = hasSmallContainerSmallArrayG(self, null); 25241 ck_assert(!r); 25242 terminateO(self); 25243 25244 } 25245 25246 25247 void indexOfSmallArrayGT(CuTest *tc UNUSED) { 25248 25249 ssize_t r; 25250 smallArrayt *self = allocG(rtSmallArrayt); 25251 25252 r = indexOfSmallArrayG(self, null); 25253 ck_assert_int_eq(r, -1); 25254 terminateO(self); 25255 25256 } 25257 25258 25259 void indexOfUndefinedSmallArrayGT(CuTest *tc UNUSED) { 25260 25261 ssize_t r; 25262 smallArrayt *self = allocG(rtSmallArrayt); 25263 25264 r = indexOfUndefinedSmallArrayG(self, null); 25265 ck_assert_int_eq(r, -1); 25266 terminateO(self); 25267 25268 } 25269 25270 25271 void indexOfBoolSmallArrayGT(CuTest *tc UNUSED) { 25272 25273 ssize_t r; 25274 smallArrayt *self = allocG(rtSmallArrayt); 25275 25276 r = indexOfBoolSmallArrayG(self, false); 25277 ck_assert_int_eq(r, -1); 25278 terminateO(self); 25279 25280 } 25281 25282 25283 void indexOfDoubleSmallArrayGT(CuTest *tc UNUSED) { 25284 25285 ssize_t r; 25286 smallArrayt *self = allocG(rtSmallArrayt); 25287 25288 r = indexOfDoubleSmallArrayG(self, 0); 25289 ck_assert_int_eq(r, -1); 25290 terminateO(self); 25291 25292 } 25293 25294 25295 void indexOfIntSmallArrayGT(CuTest *tc UNUSED) { 25296 25297 ssize_t r; 25298 smallArrayt *self = allocG(rtSmallArrayt); 25299 25300 r = indexOfIntSmallArrayG(self, 0); 25301 ck_assert_int_eq(r, -1); 25302 terminateO(self); 25303 25304 } 25305 25306 25307 void indexOfSSmallArrayGT(CuTest *tc UNUSED) { 25308 25309 ssize_t r; 25310 smallArrayt *self = allocG(rtSmallArrayt); 25311 25312 r = indexOfSSmallArrayG(self, null); 25313 ck_assert_int_eq(r, -1); 25314 terminateO(self); 25315 25316 } 25317 25318 25319 void indexOfCharSmallArrayGT(CuTest *tc UNUSED) { 25320 25321 ssize_t r; 25322 smallArrayt *self = allocG(rtSmallArrayt); 25323 25324 r = indexOfCharSmallArrayG(self, ' '); 25325 ck_assert_int_eq(r, -1); 25326 terminateO(self); 25327 25328 } 25329 25330 25331 void indexOfDictSmallArrayGT(CuTest *tc UNUSED) { 25332 25333 ssize_t r; 25334 smallArrayt *self = allocG(rtSmallArrayt); 25335 25336 r = indexOfDictSmallArrayG(self, null); 25337 ck_assert_int_eq(r, -1); 25338 terminateO(self); 25339 25340 } 25341 25342 25343 void indexOfArraySmallArrayGT(CuTest *tc UNUSED) { 25344 25345 ssize_t r; 25346 smallArrayt *self = allocG(rtSmallArrayt); 25347 25348 r = indexOfArraySmallArrayG(self, null); 25349 ck_assert_int_eq(r, -1); 25350 terminateO(self); 25351 25352 } 25353 25354 25355 void indexOfArraycSmallArrayGT(CuTest *tc UNUSED) { 25356 25357 ssize_t r; 25358 smallArrayt *self = allocG(rtSmallArrayt); 25359 25360 r = indexOfArraycSmallArrayG(self, null); 25361 ck_assert_int_eq(r, -1); 25362 terminateO(self); 25363 25364 } 25365 25366 25367 void indexOfCArraycSmallArrayGT(CuTest *tc UNUSED) { 25368 25369 ssize_t r; 25370 smallArrayt *self = allocG(rtSmallArrayt); 25371 25372 r = indexOfCArraycSmallArrayG(self, null); 25373 ck_assert_int_eq(r, -1); 25374 terminateO(self); 25375 25376 } 25377 25378 25379 void indexOfSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 25380 25381 ssize_t r; 25382 smallArrayt *self = allocG(rtSmallArrayt); 25383 25384 r = indexOfSmallBoolSmallArrayG(self, null); 25385 ck_assert_int_eq(r, -1); 25386 terminateO(self); 25387 25388 } 25389 25390 25391 void indexOfSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 25392 25393 ssize_t r; 25394 smallArrayt *self = allocG(rtSmallArrayt); 25395 25396 r = indexOfSmallBytesSmallArrayG(self, null); 25397 ck_assert_int_eq(r, -1); 25398 terminateO(self); 25399 25400 } 25401 25402 25403 void indexOfSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 25404 25405 ssize_t r; 25406 smallArrayt *self = allocG(rtSmallArrayt); 25407 25408 r = indexOfSmallDoubleSmallArrayG(self, null); 25409 ck_assert_int_eq(r, -1); 25410 terminateO(self); 25411 25412 } 25413 25414 25415 void indexOfSmallIntSmallArrayGT(CuTest *tc UNUSED) { 25416 25417 ssize_t r; 25418 smallArrayt *self = allocG(rtSmallArrayt); 25419 25420 r = indexOfSmallIntSmallArrayG(self, null); 25421 ck_assert_int_eq(r, -1); 25422 terminateO(self); 25423 25424 } 25425 25426 25427 void indexOfSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 25428 25429 ssize_t r; 25430 smallArrayt *self = allocG(rtSmallArrayt); 25431 25432 r = indexOfSmallJsonSmallArrayG(self, null); 25433 ck_assert_int_eq(r, -1); 25434 terminateO(self); 25435 25436 } 25437 25438 25439 void indexOfSmallStringSmallArrayGT(CuTest *tc UNUSED) { 25440 25441 ssize_t r; 25442 smallArrayt *self = allocG(rtSmallArrayt); 25443 25444 r = indexOfSmallStringSmallArrayG(self, null); 25445 ck_assert_int_eq(r, -1); 25446 terminateO(self); 25447 25448 } 25449 25450 25451 void indexOfSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 25452 25453 ssize_t r; 25454 smallArrayt *self = allocG(rtSmallArrayt); 25455 25456 r = indexOfSmallContainerSmallArrayG(self, null); 25457 ck_assert_int_eq(r, -1); 25458 terminateO(self); 25459 25460 } 25461 25462 25463 void binarySearchSmallArrayGT(CuTest *tc UNUSED) { 25464 25465 ssize_t r; 25466 smallArrayt *self = allocG(rtSmallArrayt); 25467 25468 r = binarySearchSmallArrayG(self, null); 25469 ck_assert_int_eq(r, -1); 25470 terminateO(self); 25471 25472 } 25473 25474 25475 void binarySearchUndefinedSmallArrayGT(CuTest *tc UNUSED) { 25476 25477 ssize_t r; 25478 smallArrayt *self = allocG(rtSmallArrayt); 25479 25480 r = binarySearchUndefinedSmallArrayG(self, null); 25481 ck_assert_int_eq(r, -1); 25482 terminateO(self); 25483 25484 } 25485 25486 25487 void binarySearchBoolSmallArrayGT(CuTest *tc UNUSED) { 25488 25489 ssize_t r; 25490 smallArrayt *self = allocG(rtSmallArrayt); 25491 25492 r = binarySearchBoolSmallArrayG(self, false); 25493 ck_assert_int_eq(r, -1); 25494 terminateO(self); 25495 25496 } 25497 25498 25499 void binarySearchDoubleSmallArrayGT(CuTest *tc UNUSED) { 25500 25501 ssize_t r; 25502 smallArrayt *self = allocG(rtSmallArrayt); 25503 25504 r = binarySearchDoubleSmallArrayG(self, 0); 25505 ck_assert_int_eq(r, -1); 25506 terminateO(self); 25507 25508 } 25509 25510 25511 void binarySearchIntSmallArrayGT(CuTest *tc UNUSED) { 25512 25513 ssize_t r; 25514 smallArrayt *self = allocG(rtSmallArrayt); 25515 25516 r = binarySearchIntSmallArrayG(self, 0); 25517 ck_assert_int_eq(r, -1); 25518 terminateO(self); 25519 25520 } 25521 25522 25523 void binarySearchSSmallArrayGT(CuTest *tc UNUSED) { 25524 25525 ssize_t r; 25526 smallArrayt *self = allocG(rtSmallArrayt); 25527 25528 r = binarySearchSSmallArrayG(self, null); 25529 ck_assert_int_eq(r, -1); 25530 terminateO(self); 25531 25532 } 25533 25534 25535 void binarySearchCharSmallArrayGT(CuTest *tc UNUSED) { 25536 25537 ssize_t r; 25538 smallArrayt *self = allocG(rtSmallArrayt); 25539 25540 r = binarySearchCharSmallArrayG(self, ' '); 25541 ck_assert_int_eq(r, -1); 25542 terminateO(self); 25543 25544 } 25545 25546 25547 void binarySearchDictSmallArrayGT(CuTest *tc UNUSED) { 25548 25549 ssize_t r; 25550 smallArrayt *self = allocG(rtSmallArrayt); 25551 25552 r = binarySearchDictSmallArrayG(self, null); 25553 ck_assert_int_eq(r, -1); 25554 terminateO(self); 25555 25556 } 25557 25558 25559 void binarySearchArraySmallArrayGT(CuTest *tc UNUSED) { 25560 25561 ssize_t r; 25562 smallArrayt *self = allocG(rtSmallArrayt); 25563 25564 r = binarySearchArraySmallArrayG(self, null); 25565 ck_assert_int_eq(r, -1); 25566 terminateO(self); 25567 25568 } 25569 25570 25571 void binarySearchArraycSmallArrayGT(CuTest *tc UNUSED) { 25572 25573 ssize_t r; 25574 smallArrayt *self = allocG(rtSmallArrayt); 25575 25576 r = binarySearchArraycSmallArrayG(self, null); 25577 ck_assert_int_eq(r, -1); 25578 terminateO(self); 25579 25580 } 25581 25582 25583 void binarySearchCArraycSmallArrayGT(CuTest *tc UNUSED) { 25584 25585 ssize_t r; 25586 smallArrayt *self = allocG(rtSmallArrayt); 25587 25588 r = binarySearchCArraycSmallArrayG(self, null); 25589 ck_assert_int_eq(r, -1); 25590 terminateO(self); 25591 25592 } 25593 25594 25595 void binarySearchSmallBoolSmallArrayGT(CuTest *tc UNUSED) { 25596 25597 ssize_t r; 25598 smallArrayt *self = allocG(rtSmallArrayt); 25599 25600 r = binarySearchSmallBoolSmallArrayG(self, null); 25601 ck_assert_int_eq(r, -1); 25602 terminateO(self); 25603 25604 } 25605 25606 25607 void binarySearchSmallBytesSmallArrayGT(CuTest *tc UNUSED) { 25608 25609 ssize_t r; 25610 smallArrayt *self = allocG(rtSmallArrayt); 25611 25612 r = binarySearchSmallBytesSmallArrayG(self, null); 25613 ck_assert_int_eq(r, -1); 25614 terminateO(self); 25615 25616 } 25617 25618 25619 void binarySearchSmallDoubleSmallArrayGT(CuTest *tc UNUSED) { 25620 25621 ssize_t r; 25622 smallArrayt *self = allocG(rtSmallArrayt); 25623 25624 r = binarySearchSmallDoubleSmallArrayG(self, null); 25625 ck_assert_int_eq(r, -1); 25626 terminateO(self); 25627 25628 } 25629 25630 25631 void binarySearchSmallIntSmallArrayGT(CuTest *tc UNUSED) { 25632 25633 ssize_t r; 25634 smallArrayt *self = allocG(rtSmallArrayt); 25635 25636 r = binarySearchSmallIntSmallArrayG(self, null); 25637 ck_assert_int_eq(r, -1); 25638 terminateO(self); 25639 25640 } 25641 25642 25643 void binarySearchSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 25644 25645 ssize_t r; 25646 smallArrayt *self = allocG(rtSmallArrayt); 25647 25648 r = binarySearchSmallJsonSmallArrayG(self, null); 25649 ck_assert_int_eq(r, -1); 25650 terminateO(self); 25651 25652 } 25653 25654 25655 void binarySearchSmallStringSmallArrayGT(CuTest *tc UNUSED) { 25656 25657 ssize_t r; 25658 smallArrayt *self = allocG(rtSmallArrayt); 25659 25660 r = binarySearchSmallStringSmallArrayG(self, null); 25661 ck_assert_int_eq(r, -1); 25662 terminateO(self); 25663 25664 } 25665 25666 25667 void binarySearchSmallContainerSmallArrayGT(CuTest *tc UNUSED) { 25668 25669 ssize_t r; 25670 smallArrayt *self = allocG(rtSmallArrayt); 25671 25672 r = binarySearchSmallContainerSmallArrayG(self, null); 25673 ck_assert_int_eq(r, -1); 25674 terminateO(self); 25675 25676 } 25677 25678 25679 void uniqSmallArrayGT(CuTest *tc UNUSED) { 25680 25681 smallArrayt* r; 25682 smallArrayt *self = allocG(rtSmallArrayt); 25683 25684 self->f->pushUndefined(self); 25685 self->f->pushBool(self, true); 25686 self->f->pushNFreeDict(self, allocSmallDict()); 25687 self->f->pushDouble(self, 1); 25688 self->f->pushInt(self, 2); 25689 self->f->pushS(self, ""); 25690 self->f->pushNFreeArray(self, allocSmallArray()); 25691 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 25692 self->f->pushUndefined(self); 25693 self->f->pushBool(self, true); 25694 self->f->pushNFreeDict(self, allocSmallDict()); 25695 self->f->pushDouble(self, 1); 25696 self->f->pushInt(self, 2); 25697 self->f->pushS(self, ""); 25698 self->f->pushNFreeArray(self, allocSmallArray()); 25699 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 25700 r = uniqSmallArrayG(self, 0); 25701 ck_assert_ptr_ne(r, NULL); 25702 char *s = toStringO(r); 25703 ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"\",[],[0x71,0x77,0x65,0x00]]"); 25704 free(s); 25705 terminateO(self); 25706 25707 } 25708 25709 25710 void icHasSmallArrayGT(CuTest *tc UNUSED) { 25711 25712 bool r; 25713 smallArrayt *self = allocG(rtSmallArrayt); 25714 25715 r = icHasSmallArrayG(self, null); 25716 ck_assert(!r); 25717 terminateO(self); 25718 25719 } 25720 25721 25722 void icHasSSmallArrayGT(CuTest *tc UNUSED) { 25723 25724 bool r; 25725 smallArrayt *self = allocG(rtSmallArrayt); 25726 25727 r = icHasSSmallArrayG(self, null); 25728 ck_assert(!r); 25729 terminateO(self); 25730 25731 } 25732 25733 25734 void icHasCharSmallArrayGT(CuTest *tc UNUSED) { 25735 25736 bool r; 25737 smallArrayt *self = allocG(rtSmallArrayt); 25738 25739 r = icHasCharSmallArrayG(self, 'a'); 25740 ck_assert(!r); 25741 terminateO(self); 25742 25743 } 25744 25745 25746 void icHasDictSmallArrayGT(CuTest *tc UNUSED) { 25747 25748 bool r; 25749 smallArrayt *self = allocG(rtSmallArrayt); 25750 25751 r = icHasDictSmallArrayG(self, null); 25752 ck_assert(!r); 25753 terminateO(self); 25754 25755 } 25756 25757 25758 void icHasArraySmallArrayGT(CuTest *tc UNUSED) { 25759 25760 bool r; 25761 smallArrayt *self = allocG(rtSmallArrayt); 25762 25763 r = icHasArraySmallArrayG(self, null); 25764 ck_assert(!r); 25765 terminateO(self); 25766 25767 } 25768 25769 25770 void icHasArraycSmallArrayGT(CuTest *tc UNUSED) { 25771 25772 bool r; 25773 smallArrayt *self = allocG(rtSmallArrayt); 25774 25775 r = icHasArraycSmallArrayG(self, null); 25776 ck_assert(!r); 25777 terminateO(self); 25778 25779 } 25780 25781 25782 void icHasCArraycSmallArrayGT(CuTest *tc UNUSED) { 25783 25784 bool r; 25785 smallArrayt *self = allocG(rtSmallArrayt); 25786 25787 r = icHasCArraycSmallArrayG(self, null); 25788 ck_assert(!r); 25789 terminateO(self); 25790 25791 } 25792 25793 25794 void icHasSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 25795 25796 bool r; 25797 smallArrayt *self = allocG(rtSmallArrayt); 25798 25799 r = icHasSmallJsonSmallArrayG(self, null); 25800 ck_assert(!r); 25801 terminateO(self); 25802 25803 } 25804 25805 25806 void icHasSmallStringSmallArrayGT(CuTest *tc UNUSED) { 25807 25808 bool r; 25809 smallArrayt *self = allocG(rtSmallArrayt); 25810 25811 r = icHasSmallStringSmallArrayG(self, null); 25812 ck_assert(!r); 25813 terminateO(self); 25814 25815 } 25816 25817 25818 void icIndexOfSmallArrayGT(CuTest *tc UNUSED) { 25819 25820 ssize_t r; 25821 smallArrayt *self = allocG(rtSmallArrayt); 25822 25823 r = icIndexOfSmallArrayG(self, null); 25824 ck_assert_int_eq(r, -1); 25825 terminateO(self); 25826 25827 } 25828 25829 25830 void icIndexOfSSmallArrayGT(CuTest *tc UNUSED) { 25831 25832 ssize_t r; 25833 smallArrayt *self = allocG(rtSmallArrayt); 25834 25835 r = icIndexOfSSmallArrayG(self, null); 25836 ck_assert_int_eq(r, -1); 25837 terminateO(self); 25838 25839 } 25840 25841 25842 void icIndexOfCharSmallArrayGT(CuTest *tc UNUSED) { 25843 25844 ssize_t r; 25845 smallArrayt *self = allocG(rtSmallArrayt); 25846 25847 r = icIndexOfCharSmallArrayG(self, 'A'); 25848 ck_assert_int_eq(r, -1); 25849 terminateO(self); 25850 25851 } 25852 25853 25854 void icIndexOfDictSmallArrayGT(CuTest *tc UNUSED) { 25855 25856 ssize_t r; 25857 smallArrayt *self = allocG(rtSmallArrayt); 25858 25859 r = icIndexOfDictSmallArrayG(self, null); 25860 ck_assert_int_eq(r, -1); 25861 terminateO(self); 25862 25863 } 25864 25865 25866 void icIndexOfArraySmallArrayGT(CuTest *tc UNUSED) { 25867 25868 ssize_t r; 25869 smallArrayt *self = allocG(rtSmallArrayt); 25870 25871 r = icIndexOfArraySmallArrayG(self, null); 25872 ck_assert_int_eq(r, -1); 25873 terminateO(self); 25874 25875 } 25876 25877 25878 void icIndexOfArraycSmallArrayGT(CuTest *tc UNUSED) { 25879 25880 ssize_t r; 25881 smallArrayt *self = allocG(rtSmallArrayt); 25882 25883 r = icIndexOfArraycSmallArrayG(self, null); 25884 ck_assert_int_eq(r, -1); 25885 terminateO(self); 25886 25887 } 25888 25889 25890 void icIndexOfCArraycSmallArrayGT(CuTest *tc UNUSED) { 25891 25892 ssize_t r; 25893 smallArrayt *self = allocG(rtSmallArrayt); 25894 25895 r = icIndexOfCArraycSmallArrayG(self, null); 25896 ck_assert_int_eq(r, -1); 25897 terminateO(self); 25898 25899 } 25900 25901 25902 void icIndexOfSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 25903 25904 ssize_t r; 25905 smallArrayt *self = allocG(rtSmallArrayt); 25906 25907 r = icIndexOfSmallJsonSmallArrayG(self, null); 25908 ck_assert_int_eq(r, -1); 25909 terminateO(self); 25910 25911 } 25912 25913 25914 void icIndexOfSmallStringSmallArrayGT(CuTest *tc UNUSED) { 25915 25916 ssize_t r; 25917 smallArrayt *self = allocG(rtSmallArrayt); 25918 25919 r = icIndexOfSmallStringSmallArrayG(self, null); 25920 ck_assert_int_eq(r, -1); 25921 terminateO(self); 25922 25923 } 25924 25925 25926 void icBinarySearchSmallArrayGT(CuTest *tc UNUSED) { 25927 25928 ssize_t r; 25929 smallArrayt *self = allocG(rtSmallArrayt); 25930 25931 r = icBinarySearchSmallArrayG(self, null); 25932 ck_assert_int_eq(r, -1); 25933 terminateO(self); 25934 25935 } 25936 25937 25938 void icBinarySearchSSmallArrayGT(CuTest *tc UNUSED) { 25939 25940 ssize_t r; 25941 smallArrayt *self = allocG(rtSmallArrayt); 25942 25943 r = icBinarySearchSSmallArrayG(self, null); 25944 ck_assert_int_eq(r, -1); 25945 terminateO(self); 25946 25947 } 25948 25949 25950 void icBinarySearchCharSmallArrayGT(CuTest *tc UNUSED) { 25951 25952 ssize_t r; 25953 smallArrayt *self = allocG(rtSmallArrayt); 25954 25955 r = icBinarySearchCharSmallArrayG(self, 'a'); 25956 ck_assert_int_eq(r, -1); 25957 terminateO(self); 25958 25959 } 25960 25961 25962 void icBinarySearchDictSmallArrayGT(CuTest *tc UNUSED) { 25963 25964 ssize_t r; 25965 smallArrayt *self = allocG(rtSmallArrayt); 25966 25967 r = icBinarySearchDictSmallArrayG(self, null); 25968 ck_assert_int_eq(r, -1); 25969 terminateO(self); 25970 25971 } 25972 25973 25974 void icBinarySearchArraySmallArrayGT(CuTest *tc UNUSED) { 25975 25976 ssize_t r; 25977 smallArrayt *self = allocG(rtSmallArrayt); 25978 25979 r = icBinarySearchArraySmallArrayG(self, null); 25980 ck_assert_int_eq(r, -1); 25981 terminateO(self); 25982 25983 } 25984 25985 25986 void icBinarySearchArraycSmallArrayGT(CuTest *tc UNUSED) { 25987 25988 ssize_t r; 25989 smallArrayt *self = allocG(rtSmallArrayt); 25990 25991 r = icBinarySearchArraycSmallArrayG(self, null); 25992 ck_assert_int_eq(r, -1); 25993 terminateO(self); 25994 25995 } 25996 25997 25998 void icBinarySearchCArraycSmallArrayGT(CuTest *tc UNUSED) { 25999 26000 ssize_t r; 26001 smallArrayt *self = allocG(rtSmallArrayt); 26002 26003 r = icBinarySearchCArraycSmallArrayG(self, null); 26004 ck_assert_int_eq(r, -1); 26005 terminateO(self); 26006 26007 } 26008 26009 26010 void icBinarySearchSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 26011 26012 ssize_t r; 26013 smallArrayt *self = allocG(rtSmallArrayt); 26014 26015 r = icBinarySearchSmallJsonSmallArrayG(self, null); 26016 ck_assert_int_eq(r, -1); 26017 terminateO(self); 26018 26019 } 26020 26021 26022 void icBinarySearchSmallStringSmallArrayGT(CuTest *tc UNUSED) { 26023 26024 ssize_t r; 26025 smallArrayt *self = allocG(rtSmallArrayt); 26026 26027 r = icBinarySearchSmallStringSmallArrayG(self, null); 26028 ck_assert_int_eq(r, -1); 26029 terminateO(self); 26030 26031 } 26032 26033 26034 void icUniqSmallArrayGT(CuTest *tc UNUSED) { 26035 26036 smallArrayt* r; 26037 smallArrayt *self = allocG(rtSmallArrayt); 26038 26039 self->f->pushUndefined(self); 26040 self->f->pushBool(self, true); 26041 self->f->pushNFreeDict(self, allocSmallDict()); 26042 self->f->pushDouble(self, 1); 26043 self->f->pushInt(self, 2); 26044 self->f->pushS(self, "ASD"); 26045 self->f->pushNFreeArray(self, allocSmallArray()); 26046 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 26047 self->f->pushUndefined(self); 26048 self->f->pushBool(self, true); 26049 self->f->pushNFreeDict(self, allocSmallDict()); 26050 self->f->pushDouble(self, 1); 26051 self->f->pushInt(self, 2); 26052 self->f->pushS(self, "asd"); 26053 self->f->pushNFreeArray(self, allocSmallArray()); 26054 self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4)); 26055 r = icUniqSmallArrayG(self, 0); 26056 ck_assert_ptr_ne(r, NULL); 26057 char *s = toStringO(r); 26058 ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"ASD\",[],[0x71,0x77,0x65,0x00]]"); 26059 free(s); 26060 terminateO(self); 26061 26062 } 26063 26064 26065 void compactSmallArrayGT(CuTest *tc UNUSED) { 26066 26067 smallArrayt* r; 26068 smallArrayt *self = allocG(rtSmallArrayt); 26069 26070 self->f->pushUndefined(self); 26071 // null element 26072 self->f->pushUndefined(self); 26073 delElemO(self, 1); 26074 self->f->pushBool(self, true); 26075 createSmallContainer(c); 26076 self->f->pushSmallContainer(self, &c); 26077 // empty dict 26078 createSmallDict(d); 26079 self->f->pushDict(self, &d); 26080 resetO(&d); 26081 (&d)->f->setInt(&d, "a", 1); 26082 self->f->pushDict(self, &d); 26083 self->f->pushDouble(self, 2); 26084 self->f->pushInt(self, 5); 26085 self->f->pushS(self, " "); 26086 self->f->pushS(self, "asd"); 26087 // empty Array 26088 createSmallArray(a); 26089 self->f->pushArray(self, &a); 26090 resetO(&a); 26091 (&a)->f->pushInt(&a, 1); 26092 self->f->pushArray(self, &a); 26093 // empty bytes 26094 createSmallBytes(b); 26095 self->f->pushSmallBytes(self, &b); 26096 smallBytest *B = allocSmallBytes("asd", 4); 26097 self->f->pushNFreeSmallBytes(self, B); 26098 r = compactSmallArrayG(self); 26099 ck_assert_ptr_ne(r, NULL); 26100 ck_assert_int_eq(lenO(r), 8); 26101 char *s = toStringO(r); 26102 ck_assert_str_eq(s, "[true,\"<data container>\",{\"a\":1},2.000000e+00,5,\"asd\",[1],[0x61,0x73,0x64,0x00]]"); 26103 free(s); 26104 terminateO(self); 26105 26106 } 26107 26108 26109 void emptySmallArrayGT(CuTest *tc UNUSED) { 26110 26111 smallArrayt* r; 26112 smallArrayt *self = allocG(rtSmallArrayt); 26113 26114 self->f->pushInt(self, 1); 26115 r = emptySmallArrayG(self); 26116 ck_assert_ptr_ne(r, null); 26117 char *s = toStringO(r); 26118 ck_assert_str_eq(s, "[]"); 26119 free(s); 26120 terminateO(self); 26121 26122 } 26123 26124 26125 void isEmptySmallArrayGT(CuTest *tc UNUSED) { 26126 26127 bool r; 26128 smallArrayt *self = allocG(rtSmallArrayt); 26129 26130 r = isEmptySmallArrayG(self); 26131 ck_assert(r); 26132 terminateO(self); 26133 26134 } 26135 26136 26137 void isBlankSmallArrayGT(CuTest *tc UNUSED) { 26138 26139 bool r; 26140 smallArrayt *self = allocG(rtSmallArrayt); 26141 26142 r = isBlankSmallArrayG(self); 26143 ck_assert(r); 26144 terminateO(self); 26145 26146 } 26147 26148 26149 void joinSmallArrayGT(CuTest *tc UNUSED) { 26150 26151 smallStringt* r; 26152 smallArrayt *self = allocG(rtSmallArrayt); 26153 26154 self->f->pushS(self, "a"); 26155 self->f->pushS(self, "b"); 26156 r = joinSmallArrayG(self, "|"); 26157 ck_assert_ptr_ne(r, null); 26158 char *s = toStringO(r); 26159 ck_assert_str_eq(s, "a|b"); 26160 free(s); 26161 terminateO(r); 26162 terminateO(self); 26163 26164 } 26165 26166 26167 void joinCharSmallArrayGT(CuTest *tc UNUSED) { 26168 26169 smallStringt* r; 26170 smallArrayt *self = allocG(rtSmallArrayt); 26171 26172 self->f->pushS(self, "a"); 26173 self->f->pushS(self, "b"); 26174 r = joinCharSmallArrayG(self, '|'); 26175 ck_assert_ptr_ne(r, null); 26176 char *s = toStringO(r); 26177 ck_assert_str_eq(s, "a|b"); 26178 free(s); 26179 terminateO(r); 26180 terminateO(self); 26181 26182 } 26183 26184 26185 void joinSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 26186 26187 smallStringt* r; 26188 smallArrayt *self = allocG(rtSmallArrayt); 26189 26190 r = joinSmallJsonSmallArrayG(self, null); 26191 ck_assert_ptr_eq(r, null); 26192 terminateO(self); 26193 26194 } 26195 26196 26197 void joinSmallStringSmallArrayGT(CuTest *tc UNUSED) { 26198 26199 smallStringt* r; 26200 smallArrayt *self = allocG(rtSmallArrayt); 26201 26202 r = joinSmallStringSmallArrayG(self, null); 26203 ck_assert_ptr_eq(r, null); 26204 terminateO(self); 26205 26206 } 26207 26208 26209 void joinSSmallArrayGT(CuTest *tc UNUSED) { 26210 26211 char* r; 26212 smallArrayt *self = allocG(rtSmallArrayt); 26213 26214 r = joinSSmallArrayG(self, null); 26215 ck_assert_ptr_eq(r, null); 26216 terminateO(self); 26217 26218 } 26219 26220 26221 void joinCharSSmallArrayGT(CuTest *tc UNUSED) { 26222 26223 char* r; 26224 smallArrayt *self = allocG(rtSmallArrayt); 26225 26226 r = joinCharSSmallArrayG(self, '#'); 26227 ck_assert_ptr_eq(r, null); 26228 terminateO(self); 26229 26230 } 26231 26232 26233 void joinSmallJsonSSmallArrayGT(CuTest *tc UNUSED) { 26234 26235 char* r; 26236 smallArrayt *self = allocG(rtSmallArrayt); 26237 26238 r = joinSmallJsonSSmallArrayG(self, null); 26239 ck_assert_ptr_eq(r, null); 26240 terminateO(self); 26241 26242 } 26243 26244 26245 void joinSmallStringSSmallArrayGT(CuTest *tc UNUSED) { 26246 26247 char* r; 26248 smallArrayt *self = allocG(rtSmallArrayt); 26249 26250 r = joinSmallStringSSmallArrayG(self, null); 26251 ck_assert_ptr_eq(r, null); 26252 terminateO(self); 26253 26254 } 26255 26256 26257 void zipSmallArrayGT(CuTest *tc UNUSED) { 26258 26259 smallArrayt* r; 26260 smallArrayt *self = allocG(rtSmallArrayt); 26261 smallArrayt *array1 = allocSmallArray(); 26262 smallArrayt *array2 = allocSmallArray(); 26263 26264 // zip arrays 26265 // add an element to self 26266 // array1 has 2 elements 26267 // array2 has 3 elements 26268 // only 2 elements are zipped 26269 self->f->pushS(self, "qwe"); 26270 array1->f->pushS(array1, "a"); 26271 array1->f->pushS(array1, "b"); 26272 array2->f->pushInt(array2, 1); 26273 array2->f->pushInt(array2, 2); 26274 array2->f->pushInt(array2, 3); 26275 r = zipSmallArrayG(self, array1, array2); 26276 ck_assert_ptr_ne(r, NULL); 26277 char *s = toStringO(r); 26278 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 26279 free(s); 26280 // delete the element not in self 26281 delElemO(array2, 2); 26282 terminateO(self); 26283 smashO(array1); 26284 smashO(array2); 26285 26286 } 26287 26288 26289 void zipSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 26290 26291 smallArrayt* r; 26292 smallArrayt *self = allocG(rtSmallArrayt); 26293 smallArrayt *array1 = allocSmallArray(); 26294 smallJsont *array2 = allocSmallJson(); 26295 26296 // zip arrays 26297 // add an element to self 26298 // array1 has 2 elements 26299 // array2 has 3 elements 26300 // only 2 elements are zipped 26301 self->f->pushS(self, "qwe"); 26302 array1->f->pushS(array1, "a"); 26303 array1->f->pushS(array1, "b"); 26304 array2->f->pushInt(array2, 1); 26305 array2->f->pushInt(array2, 2); 26306 array2->f->pushInt(array2, 3); 26307 r = zipSmallJsonSmallArrayG(self, array1, array2); 26308 ck_assert_ptr_ne(r, NULL); 26309 char *s = toStringO(r); 26310 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 26311 free(s); 26312 // delete the element not in self 26313 delElemIndexO(array2, 2); 26314 terminateO(self); 26315 smashO(array1); 26316 smashO(array2); 26317 26318 } 26319 26320 26321 void zipSmallJsonSmallArraySmallArrayGT(CuTest *tc UNUSED) { 26322 26323 smallArrayt* r; 26324 smallArrayt *self = allocG(rtSmallArrayt); 26325 smallJsont *array1 = allocSmallJson(); 26326 smallArrayt *array2 = allocSmallArray(); 26327 26328 // zip arrays 26329 // add an element to self 26330 // array1 has 2 elements 26331 // array2 has 3 elements 26332 // only 2 elements are zipped 26333 self->f->pushS(self, "qwe"); 26334 array1->f->pushS(array1, "a"); 26335 array1->f->pushS(array1, "b"); 26336 array2->f->pushInt(array2, 1); 26337 array2->f->pushInt(array2, 2); 26338 array2->f->pushInt(array2, 3); 26339 r = zipSmallJsonSmallArraySmallArrayG(self, array1, array2); 26340 ck_assert_ptr_ne(r, NULL); 26341 char *s = toStringO(r); 26342 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 26343 free(s); 26344 // delete the element not in self 26345 delElemO(array2, 2); 26346 terminateO(self); 26347 smashO(array1); 26348 smashO(array2); 26349 26350 } 26351 26352 26353 void zipSmallJsonSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 26354 26355 smallArrayt* r; 26356 smallArrayt *self = allocG(rtSmallArrayt); 26357 smallJsont *array1 = allocSmallJson(); 26358 smallJsont *array2 = allocSmallJson(); 26359 26360 // zip arrays 26361 // add an element to self 26362 // array1 has 2 elements 26363 // array2 has 3 elements 26364 // only 2 elements are zipped 26365 self->f->pushS(self, "qwe"); 26366 array1->f->pushS(array1, "a"); 26367 array1->f->pushS(array1, "b"); 26368 array2->f->pushInt(array2, 1); 26369 array2->f->pushInt(array2, 2); 26370 array2->f->pushInt(array2, 3); 26371 r = zipSmallJsonSmallJsonSmallArrayG(self, array1, array2); 26372 ck_assert_ptr_ne(r, NULL); 26373 char *s = toStringO(r); 26374 ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]"); 26375 free(s); 26376 // delete the element not in self 26377 delElemIndexO(array2, 2); 26378 terminateO(self); 26379 smashO(array1); 26380 smashO(array2); 26381 26382 } 26383 26384 26385 void zipSmallJsonCharSmallArrayGT(CuTest *tc UNUSED) { 26386 26387 smallArrayt* r; 26388 smallArrayt *self = allocG(rtSmallArrayt); 26389 smallJsont *array1 = allocSmallJson(); 26390 char **array2; 26391 26392 // zip arrays 26393 // add an element to self 26394 // array1 has 2 elements 26395 // array2 has 3 elements 26396 // only 2 elements are zipped 26397 self->f->pushS(self, "qwe"); 26398 array1->f->pushS(array1, "a"); 26399 array1->f->pushS(array1, "b"); 26400 array2 = listCreateS("1", "2", "3"); 26401 r = zipSmallJsonCharSmallArrayG(self, array1, array2); 26402 ck_assert_ptr_ne(r, NULL); 26403 char *s = toStringO(r); 26404 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26405 free(s); 26406 // delete the element not in self 26407 iListDelElemS(&array2, 2); 26408 terminateO(self); 26409 smashO(array1); 26410 free(array2); 26411 26412 } 26413 26414 26415 void zipSmallJsonCCharSmallArrayGT(CuTest *tc UNUSED) { 26416 26417 smallArrayt* r; 26418 smallArrayt *self = allocG(rtSmallArrayt); 26419 smallJsont *array1 = allocSmallJson(); 26420 26421 // zip arrays 26422 // add an element to self 26423 // array1 has 2 elements 26424 // array2 has 3 elements 26425 // only 2 elements are zipped 26426 self->f->pushS(self, "qwe"); 26427 array1->f->pushS(array1, "a"); 26428 array1->f->pushS(array1, "b"); 26429 const char *array2[] = {"1", "2", "3", null}; 26430 r = zipSmallJsonCCharSmallArrayG(self, array1, array2); 26431 ck_assert_ptr_ne(r, NULL); 26432 char *s = toStringO(r); 26433 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26434 free(s); 26435 terminateO(self); 26436 smashO(array1); 26437 26438 } 26439 26440 26441 void zipArraySmallArrayGT(CuTest *tc UNUSED) { 26442 26443 smallArrayt* r; 26444 smallArrayt *self = allocG(rtSmallArrayt); 26445 char** array1; 26446 smallArrayt *array2 = allocSmallArray(); 26447 26448 self->f->pushS(self, "qwe"); 26449 array1 = listCreateS("a", "b"); 26450 array2->f->pushS(array2, "1"); 26451 array2->f->pushS(array2, "2"); 26452 r = zipArraySmallArrayG(self, array1, array2); 26453 ck_assert_ptr_ne(r, NULL); 26454 char *s = toStringO(r); 26455 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26456 free(s); 26457 terminateO(self); 26458 free(array1); 26459 smashO(array2); 26460 26461 } 26462 26463 26464 void zipCArraySmallArrayGT(CuTest *tc UNUSED) { 26465 26466 smallArrayt* r; 26467 smallArrayt *self = allocG(rtSmallArrayt); 26468 const char* array1[] = {"a", "b", null}; 26469 smallArrayt *array2 = allocSmallArray(); 26470 26471 self->f->pushS(self, "qwe"); 26472 array2->f->pushS(array2, "1"); 26473 array2->f->pushS(array2, "2"); 26474 r = zipCArraySmallArrayG(self, array1, array2); 26475 ck_assert_ptr_ne(r, NULL); 26476 char *s = toStringO(r); 26477 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26478 free(s); 26479 terminateO(self); 26480 smashO(array2); 26481 26482 } 26483 26484 26485 void zipArraySmallJsonSmallArrayGT(CuTest *tc UNUSED) { 26486 26487 smallArrayt* r; 26488 smallArrayt *self = allocG(rtSmallArrayt); 26489 char** array1; 26490 smallJsont *array2 = allocSmallJson(); 26491 26492 self->f->pushS(self, "qwe"); 26493 array1 = listCreateS("a", "b"); 26494 array2->f->pushS(array2, "1"); 26495 array2->f->pushS(array2, "2"); 26496 r = zipArraySmallJsonSmallArrayG(self, array1, array2); 26497 ck_assert_ptr_ne(r, NULL); 26498 char *s = toStringO(r); 26499 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26500 free(s); 26501 terminateO(self); 26502 free(array1); 26503 smashO(array2); 26504 26505 } 26506 26507 26508 void zipCArraySmallJsonSmallArrayGT(CuTest *tc UNUSED) { 26509 26510 smallArrayt* r; 26511 smallArrayt *self = allocG(rtSmallArrayt); 26512 const char* array1[] = {"a", "b", null}; 26513 smallJsont *array2 = allocSmallJson(); 26514 26515 self->f->pushS(self, "qwe"); 26516 array2->f->pushS(array2, "1"); 26517 array2->f->pushS(array2, "2"); 26518 r = zipCArraySmallJsonSmallArrayG(self, array1, array2); 26519 ck_assert_ptr_ne(r, NULL); 26520 char *s = toStringO(r); 26521 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26522 free(s); 26523 terminateO(self); 26524 smashO(array2); 26525 26526 } 26527 26528 26529 void zipCharSmallArrayGT(CuTest *tc UNUSED) { 26530 26531 smallArrayt* r; 26532 smallArrayt *self = allocG(rtSmallArrayt); 26533 smallArrayt *array1 = allocSmallArray(); 26534 char** array2; 26535 26536 self->f->pushS(self, "qwe"); 26537 array1->f->pushS(array1, "a"); 26538 array1->f->pushS(array1, "b"); 26539 array2 = listCreateS("1", "2"); 26540 r = zipCharSmallArrayG(self, array1, array2); 26541 ck_assert_ptr_ne(r, NULL); 26542 char *s = toStringO(r); 26543 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26544 free(s); 26545 terminateO(self); 26546 smashO(array1); 26547 free(array2); 26548 26549 } 26550 26551 26552 void zipCCharSmallArrayGT(CuTest *tc UNUSED) { 26553 26554 smallArrayt* r; 26555 smallArrayt *self = allocG(rtSmallArrayt); 26556 smallArrayt *array1 = allocSmallArray(); 26557 const char* array2[] = {"1", "2", "3", null}; 26558 26559 self->f->pushS(self, "qwe"); 26560 array1->f->pushS(array1, "a"); 26561 array1->f->pushS(array1, "b"); 26562 r = zipCCharSmallArrayG(self, array1, array2); 26563 ck_assert_ptr_ne(r, NULL); 26564 char *s = toStringO(r); 26565 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26566 free(s); 26567 terminateO(self); 26568 smashO(array1); 26569 26570 } 26571 26572 26573 void zipArrayCharSmallArrayGT(CuTest *tc UNUSED) { 26574 26575 smallArrayt* r; 26576 smallArrayt *self = allocG(rtSmallArrayt); 26577 char** array1; 26578 char** array2; 26579 26580 self->f->pushS(self, "qwe"); 26581 array1 = listCreateS("a", "b"); 26582 array2 = listCreateS("1", "2"); 26583 r = zipArrayCharSmallArrayG(self, array1, array2); 26584 ck_assert_ptr_ne(r, NULL); 26585 char *s = toStringO(r); 26586 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26587 free(s); 26588 terminateO(self); 26589 free(array1); 26590 free(array2); 26591 26592 } 26593 26594 26595 void zipArrayCCharSmallArrayGT(CuTest *tc UNUSED) { 26596 26597 smallArrayt* r; 26598 smallArrayt *self = allocG(rtSmallArrayt); 26599 char** array1; 26600 const char* array2[] = {"1", "2", "3", null}; 26601 26602 self->f->pushS(self, "qwe"); 26603 array1 = listCreateS("a", "b"); 26604 r = zipArrayCCharSmallArrayG(self, array1, array2); 26605 ck_assert_ptr_ne(r, NULL); 26606 char *s = toStringO(r); 26607 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26608 free(s); 26609 terminateO(self); 26610 free(array1); 26611 26612 } 26613 26614 26615 void zipCArrayCharSmallArrayGT(CuTest *tc UNUSED) { 26616 26617 smallArrayt* r; 26618 smallArrayt *self = allocG(rtSmallArrayt); 26619 const char* array1[] = {"a", "b", null}; 26620 char** array2; 26621 26622 self->f->pushS(self, "qwe"); 26623 array2 = listCreateS("1", "2"); 26624 r = zipCArrayCharSmallArrayG(self, array1, array2); 26625 ck_assert_ptr_ne(r, NULL); 26626 char *s = toStringO(r); 26627 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26628 free(s); 26629 terminateO(self); 26630 free(array2); 26631 26632 } 26633 26634 26635 void zipCArrayCCharSmallArrayGT(CuTest *tc UNUSED) { 26636 26637 smallArrayt* r; 26638 smallArrayt *self = allocG(rtSmallArrayt); 26639 const char* array1[] = {"a", "b", null}; 26640 const char* array2[] = {"1", "2", "3", null}; 26641 26642 self->f->pushS(self, "qwe"); 26643 r = zipCArrayCCharSmallArrayG(self, array1, array2); 26644 ck_assert_ptr_ne(r, NULL); 26645 char *s = toStringO(r); 26646 ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]"); 26647 free(s); 26648 terminateO(self); 26649 26650 } 26651 26652 26653 void logSmallArrayGT(CuTest *tc UNUSED) { 26654 26655 smallArrayt *self = allocG(rtSmallArrayt); 26656 26657 self->f->pushS(self, "qwe"); 26658 self->f->pushS(self, "asd"); 26659 delElemO(self, 0); 26660 logSmallArrayG(self); 26661 terminateO(self); 26662 26663 } 26664 26665 26666 void readTextSmallArrayGT(CuTest *tc UNUSED) { 26667 26668 smallArrayt* r; 26669 smallArrayt *self = allocG(rtSmallArrayt); 26670 26671 r = readTextSmallArrayG(self, "../textTest.null"); 26672 ck_assert_ptr_ne(r, NULL); 26673 char *s = toStringO(r); 26674 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26675 free(s); 26676 terminateO(self); 26677 26678 } 26679 26680 26681 void readTextSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 26682 26683 smallArrayt* r; 26684 smallArrayt *self = allocG(rtSmallArrayt); 26685 smallJsont *filePath = allocSmallJson(); 26686 26687 // text 26688 setTopSO(filePath, "../textTest.null"); 26689 r = readTextSmallJsonSmallArrayG(self, filePath); 26690 ck_assert_ptr_ne(r, NULL); 26691 char *s = toStringO(r); 26692 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26693 free(s); 26694 terminateO(self); 26695 terminateO(filePath); 26696 26697 } 26698 26699 26700 void readTextSmallStringSmallArrayGT(CuTest *tc UNUSED) { 26701 26702 smallArrayt* r; 26703 smallArrayt *self = allocG(rtSmallArrayt); 26704 smallStringt *filePath = allocSmallString(""); 26705 26706 // text 26707 setValO(filePath, "../textTest.null"); 26708 r = readTextSmallStringSmallArrayG(self, filePath); 26709 ck_assert_ptr_ne(r, NULL); 26710 char *s = toStringO(r); 26711 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26712 free(s); 26713 terminateO(self); 26714 terminateO(filePath); 26715 26716 } 26717 26718 26719 void readStreamSmallArrayGT(CuTest *tc UNUSED) { 26720 26721 smallArrayt* r; 26722 smallArrayt *self = allocG(rtSmallArrayt); 26723 FILE *fp; 26724 26725 fp = fopen("../textTest.null", "r"); 26726 r = readStreamSmallArrayG(self, fp); 26727 fclose(fp); 26728 ck_assert_ptr_ne(r, NULL); 26729 char *s = toStringO(r); 26730 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26731 free(s); 26732 terminateO(self); 26733 26734 } 26735 26736 26737 void writeTextSmallArrayGT(CuTest *tc UNUSED) { 26738 26739 bool r; 26740 smallArrayt *self = allocG(rtSmallArrayt); 26741 26742 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26743 ck_assert_ptr_ne(r2, NULL); 26744 r = writeTextSmallArrayG(self, "../textOutTest.null"); 26745 ck_assert(r); 26746 // check textOutTest.null 26747 emptyO(self); 26748 r2 = readTextO(self, "../textOutTest.null"); 26749 ck_assert_ptr_ne(r2, NULL); 26750 char *s = toStringO(r2); 26751 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26752 free(s); 26753 terminateO(self); 26754 26755 } 26756 26757 26758 void writeTextSmallJsonSmallArrayGT(CuTest *tc UNUSED) { 26759 26760 bool r; 26761 smallArrayt *self = allocG(rtSmallArrayt); 26762 smallJsont *filePath = allocSmallJson(); 26763 26764 // write textOutTest.null 26765 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26766 ck_assert_ptr_ne(r2, NULL); 26767 setTopSO(filePath, "../textOutTest.null"); 26768 r = writeTextSmallJsonSmallArrayG(self, filePath); 26769 ck_assert(r); 26770 // check textOutTest.null 26771 emptyO(self); 26772 r2 = readTextO(self, "../textOutTest.null"); 26773 ck_assert_ptr_ne(r2, NULL); 26774 char *s = toStringO(r2); 26775 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26776 free(s); 26777 terminateO(self); 26778 terminateO(filePath); 26779 26780 } 26781 26782 26783 void writeTextSmallStringSmallArrayGT(CuTest *tc UNUSED) { 26784 26785 bool r; 26786 smallArrayt *self = allocG(rtSmallArrayt); 26787 smallStringt *filePath = allocSmallString(""); 26788 26789 // write textOutTest.null 26790 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26791 ck_assert_ptr_ne(r2, NULL); 26792 setValO(filePath, "../textOutTest.null"); 26793 r = writeTextSmallStringSmallArrayG(self, filePath); 26794 ck_assert(r); 26795 // check textOutTest.null 26796 emptyO(self); 26797 r2 = readTextO(self, "../textOutTest.null"); 26798 ck_assert_ptr_ne(r2, NULL); 26799 char *s = toStringO(r2); 26800 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]"); 26801 free(s); 26802 terminateO(self); 26803 terminateO(filePath); 26804 26805 } 26806 26807 26808 void writeStreamSmallArrayGT(CuTest *tc UNUSED) { 26809 26810 bool r; 26811 smallArrayt *self = allocG(rtSmallArrayt); 26812 FILE *fp; 26813 26814 // write textOutTest.null 26815 fp = fopen("../textTest.null", "r"); 26816 smallArrayt *r2 = readStreamO(self, fp); 26817 fclose(fp); 26818 ck_assert_ptr_ne(r2, NULL); 26819 fp = fopen("../textOutTest.null", "w"); 26820 r = writeStreamSmallArrayG(self, fp); 26821 ck_assert(r); 26822 fclose(fp); 26823 terminateO(self); 26824 26825 } 26826 26827 26828 void appendTextSmallArrayGT(CuTest *tc UNUSED) { 26829 26830 bool r; 26831 smallArrayt *self = allocG(rtSmallArrayt); 26832 26833 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26834 ck_assert_ptr_ne(r2, NULL); 26835 r = writeTextO(self, "../textOutTest.null"); 26836 ck_assert(r); 26837 emptyO(self); 26838 self->f->pushS(self, "A"); 26839 self->f->pushS(self, "B"); 26840 r = appendTextSmallArrayG(self, "../textOutTest.null"); 26841 // check textOutTest.null 26842 emptyO(self); 26843 r2 = readTextO(self, "../textOutTest.null"); 26844 char *s = toStringO(r2); 26845 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 26846 free(s); 26847 terminateO(self); 26848 26849 } 26850 26851 26852 void appendTextSmallStringSmallArrayGT(CuTest *tc UNUSED) { 26853 26854 bool r; 26855 smallArrayt *self = allocG(rtSmallArrayt); 26856 smallStringt *filePath = allocSmallString(""); 26857 26858 // append to textOutTest.null 26859 smallArrayt *r2 = readTextO(self, "../textTest.null"); 26860 ck_assert_ptr_ne(r2, NULL); 26861 r = writeTextO(self, "../textOutTest.null"); 26862 ck_assert(r); 26863 emptyO(self); 26864 self->f->pushS(self, "A"); 26865 self->f->pushS(self, "B"); 26866 setValO(filePath, "../textOutTest.null"); 26867 r = appendTextSmallStringSmallArrayG(self, filePath); 26868 // check textOutTest.null 26869 emptyO(self); 26870 r2 = readTextO(self, "../textOutTest.null"); 26871 char *s = toStringO(r2); 26872 ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]"); 26873 free(s); 26874 terminateO(self); 26875 terminateO(filePath); 26876 26877 } 26878 26879 26880 void typeSmallStringSmallArrayGT(CuTest *tc UNUSED) { 26881 26882 smallStringt* r; 26883 smallArrayt *self = allocG(rtSmallArrayt); 26884 26885 r = typeSmallStringSmallArrayG(self, 0); 26886 char *s = toStringO(r); 26887 ck_assert_str_eq(s, "not a sheepy object"); 26888 free(s); 26889 terminateO(self); 26890 terminateO(r); 26891 26892 } 26893 26894 26895 void typeSmallStringsSmallArrayGT(CuTest *tc UNUSED) { 26896 26897 smallArrayt* r; 26898 smallArrayt *self = allocG(rtSmallArrayt); 26899 26900 self->f->pushS(self, "qwe"); 26901 self->f->pushBool(self, true); 26902 self->f->pushDouble(self, 1); 26903 r = typeSmallStringsSmallArrayG(self); 26904 ck_assert_ptr_ne(r, NULL); 26905 char *s = toStringO(r); 26906 ck_assert_str_eq(s, "[\"string\",\"bool\",\"double\"]"); 26907 free(s); 26908 terminateO(self); 26909 terminateO(r); 26910 26911 } 26912 26913 26914 void cSmallArrayT(CuTest *tc UNUSED) { 26915 26916 // local object 26917 createSmallArray(obj); 26918 ck_assert_str_eq(obj.type, "smallArray"); 26919 // object 26920 createAllocateSmallArray(obj2); 26921 ck_assert_str_eq(obj2->type, "smallArray"); 26922 // toString 26923 char *s = obj2->f->toString(obj2); 26924 ck_assert_str_eq(s, "[]"); 26925 free(s); 26926 createAllocateUndefined(oU); 26927 obj2->f->push(obj2, (baset *)oU); 26928 finishO(oU); 26929 createAllocateSmallInt(oInt); 26930 oInt->f->set(oInt, 123); 26931 obj2->f->push(obj2, (baset *)oInt); 26932 finishO(oInt); 26933 createAllocateSmallString(oStr); 26934 oStr->f->set(oStr, "sheepy"); 26935 obj2->f->push(obj2, (baset *)oStr); 26936 finishO(oStr); 26937 s = obj2->f->toString(obj2); 26938 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 26939 free(s); 26940 // delete an element 26941 smallArrayt *o2; 26942 o2 = obj2->f->duplicate(obj2); 26943 o2->f->delElem(o2, 0); 26944 s = o2->f->toString(o2); 26945 ck_assert_str_eq(s, "[123,\"sheepy\"]"); 26946 free(s); 26947 terminateO(o2); 26948 // duplicate 26949 smallArrayt *o; 26950 o = obj2->f->duplicate(obj2); 26951 undefinedt *u; 26952 u = (undefinedt *) o->f->getAt(o, 0); 26953 ck_assert(isOType(u, "undefined")); 26954 terminateO(u); 26955 smallIntt *in; 26956 in = (smallIntt *) o->f->getAt(o, 1); 26957 ck_assert(in->value->value == 123); 26958 smashO(in); 26959 smallStringt *st; 26960 st = (smallStringt *) o->f->getAt(o, 2); 26961 ck_assert(strEq(st->f->get(st), "sheepy")); 26962 smashO(st); 26963 terminateO(o); 26964 // delete an element 26965 o2 = obj2->f->duplicate(obj2); 26966 o2->f->delElem(o2, 0); 26967 o = o2->f->duplicate(o2); 26968 in = (smallIntt *) o->f->getAt(o, 0); 26969 ck_assert(in->value->value == 123); 26970 smashO(in); 26971 st = (smallStringt *) o->f->getAt(o, 1); 26972 ck_assert(strEq(st->f->get(st), "sheepy")); 26973 smashO(st); 26974 terminateO(o); 26975 terminateO(o2); 26976 // fromArray 26977 initiateAllocateSmallArray(&o); 26978 char *array[] = {"1", "22", "333"}; 26979 char *arrayNULL[] = {"1", NULL, "333"}; 26980 // copy array to list 26981 o->f->fromArray(o, (void *)array, 3); 26982 ck_assert_uint_eq(o->f->len(o),3); 26983 smallStringt *strFrom; 26984 strFrom = (smallStringt*) o->f->getAt(o,0); 26985 ck_assert_str_eq(strFrom->f->get(strFrom), "1"); 26986 smashO(strFrom); 26987 strFrom = (smallStringt*) o->f->getAt(o,1); 26988 ck_assert_str_eq(strFrom->f->get(strFrom), "22"); 26989 smashO(strFrom); 26990 strFrom = (smallStringt*) o->f->getAt(o,2); 26991 ck_assert_str_eq(strFrom->f->get(strFrom), "333"); 26992 smashO(strFrom); 26993 // array with NULL inside 26994 o->f->fromArray(o, (void *)arrayNULL, 3); 26995 ck_assert_uint_eq(o->f->len(o),3); 26996 strFrom = (smallStringt*) o->f->getAt(o,0); 26997 ck_assert_str_eq(strFrom->f->get(strFrom), "1"); 26998 smashO(strFrom); 26999 strFrom = (smallStringt*) o->f->getAt(o,1); 27000 ck_assert_ptr_eq(strFrom, NULL); 27001 strFrom = (smallStringt*) o->f->getAt(o,2); 27002 ck_assert_str_eq(strFrom->f->get(strFrom), "333"); 27003 smashO(strFrom); 27004 // char** list 27005 char **shpList = listCreateS("lib", "sheepy"); 27006 o->f->fromArray(o, shpList, 0); 27007 ck_assert_uint_eq(o->f->len(o),2); 27008 listFreeS(shpList); 27009 // NULL pointer to list - list not changed 27010 o->f->fromArray(o, (void *)arrayNULL, 3); 27011 o->f->fromArray(o, NULL, 3); 27012 ck_assert_uint_eq(o->f->len(o),3); 27013 strFrom = (smallStringt*) o->f->getAt(o,0); 27014 ck_assert_str_eq(strFrom->f->get(strFrom), "1"); 27015 smashO(strFrom); 27016 strFrom = (smallStringt*) o->f->getAt(o,1); 27017 ck_assert_ptr_eq(strFrom, NULL); 27018 strFrom = (smallStringt*) o->f->getAt(o,2); 27019 ck_assert_str_eq(strFrom->f->get(strFrom), "333"); 27020 smashO(strFrom); 27021 terminateO(o); 27022 // push 27023 o = obj2->f->duplicate(obj2); 27024 initiateAllocateSmallInt(&in); 27025 in->f->set(in, 654); 27026 o->f->push(o, (baset *)in); 27027 finishO(in); 27028 in = (smallIntt *) o->f->getAt(o, 3); 27029 ck_assert_uint_eq(o->f->len(o), 4); 27030 ck_assert_uint_eq(in->value->value, 654); 27031 smashO(in); 27032 // NULL 27033 o->f->push(o, NULL); 27034 ck_assert_uint_eq(o->f->len(o), 4); 27035 terminateO(o); 27036 // pop 27037 o = obj2->f->duplicate(obj2); 27038 ck_assert_uint_eq(o->f->len(o), 3); 27039 st = (smallStringt *) o->f->pop(o); 27040 ck_assert_uint_eq(o->f->len(o), 2); 27041 ck_assert_str_eq(st->f->get(st), "sheepy"); 27042 terminateO(st); 27043 in = (smallIntt *) o->f->pop(o); 27044 ck_assert_uint_eq(in->value->value, 123); 27045 terminateO(in); 27046 u = (undefinedt *) o->f->pop(o); 27047 ck_assert(isOType(u, "undefined")); 27048 terminateO(u); 27049 // empty list 27050 u = (undefinedt *) o->f->pop(o); 27051 ck_assert_ptr_eq(u,NULL); 27052 // after initialize 27053 o->f->free(o); 27054 ck_assert_uint_eq(o->f->len(o), 0); 27055 u = (undefinedt *) o->f->pop(o); 27056 ck_assert_uint_eq(o->f->len(o), 0); 27057 ck_assert_ptr_eq(u,NULL); 27058 terminateO(o); 27059 // append 27060 o = obj2->f->duplicate(obj2); 27061 o2 = obj2->f->duplicate(obj2); 27062 in = (smallIntt *) o2->f->getAt(o2, 1); 27063 in->value->value = 789; 27064 o2->f->setAt(o2, 1, (baset *)in); 27065 finishO(in); 27066 o->f->append(o, o2); 27067 s = toStringO(o); 27068 ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]"); 27069 free(s); 27070 // same list 27071 o->f->append(o, o); 27072 s = toStringO(o); 27073 ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]"); 27074 free(s); 27075 o->f->free(o); 27076 o2->f->smash(&o2); 27077 // empty list + list 27078 o2 = obj2->f->duplicate(obj2); 27079 in = (smallIntt *) o2->f->getAt(o2, 1); 27080 in->value->value = 789; 27081 o2->f->setAt(o2, 1, (baset *)in); 27082 finishO(in); 27083 o->f->append(o, o2); 27084 s = toStringO(o); 27085 ck_assert_str_eq(s, "[null,789,\"sheepy\"]"); 27086 free(s); 27087 // list + empty list 27088 o2->f->dispose(o2); 27089 o->f->append(o, o2); 27090 s = toStringO(o); 27091 ck_assert_str_eq(s, "[null,789,\"sheepy\"]"); 27092 free(s); 27093 // empty list + empty list 27094 o->f->free(o); 27095 o->f->append(o, o2); 27096 s = toStringO(o); 27097 ck_assert_str_eq(s, "[]"); 27098 free(s); 27099 terminateO(o2); 27100 // NULL list 27101 o->f->append(o, NULL); 27102 s = toStringO(o); 27103 ck_assert_str_eq(s, "[]"); 27104 free(s); 27105 terminateO(o); 27106 // slice 27107 o = obj2->f->duplicate(obj2); 27108 initiateAllocateSmallInt(&in); 27109 in->f->set(in, 5345); 27110 o->f->push(o, (baset *) in); 27111 finishO(in); 27112 o->f->slice(o,1,-1); 27113 s = toStringO(o); 27114 ck_assert_str_eq(s, "[123,\"sheepy\"]"); 27115 free(s); 27116 terminateO(o); 27117 // start outside 27118 o = obj2->f->duplicate(obj2); 27119 initiateAllocateSmallInt(&in); 27120 in->f->set(in, 5345); 27121 o->f->push(o, (baset *) in); 27122 finishO(in); 27123 o->f->slice(o,20,-1); 27124 s = toStringO(o); 27125 ck_assert_str_eq(s, "[]"); 27126 free(s); 27127 terminateO(o); 27128 // start negative and outside 27129 o = obj2->f->duplicate(obj2); 27130 initiateAllocateSmallInt(&in); 27131 in->f->set(in, 5345); 27132 o->f->push(o, (baset *) in); 27133 finishO(in); 27134 o->f->slice(o,-20,1); 27135 s = toStringO(o); 27136 ck_assert_str_eq(s, "[null]"); 27137 free(s); 27138 terminateO(o); 27139 // end outside 27140 o = obj2->f->duplicate(obj2); 27141 initiateAllocateSmallInt(&in); 27142 in->f->set(in, 5345); 27143 o->f->push(o, (baset *) in); 27144 finishO(in); 27145 o->f->slice(o,2,40); 27146 s = toStringO(o); 27147 ck_assert_str_eq(s, "[\"sheepy\",5345]"); 27148 free(s); 27149 terminateO(o); 27150 // end negative and outside 27151 o = obj2->f->duplicate(obj2); 27152 initiateAllocateSmallInt(&in); 27153 in->f->set(in, 5345); 27154 o->f->push(o, (baset *) in); 27155 finishO(in); 27156 o->f->slice(o,2,-40); 27157 s = toStringO(o); 27158 ck_assert_str_eq(s, "[]"); 27159 free(s); 27160 terminateO(o); 27161 // end before start 27162 o = obj2->f->duplicate(obj2); 27163 initiateAllocateSmallInt(&in); 27164 in->f->set(in, 5345); 27165 o->f->push(o, (baset *) in); 27166 finishO(in); 27167 o->f->slice(o,3,2); 27168 s = toStringO(o); 27169 ck_assert_str_eq(s, "[]"); 27170 free(s); 27171 terminateO(o); 27172 // negative start last element 27173 o = obj2->f->duplicate(obj2); 27174 initiateAllocateSmallInt(&in); 27175 in->f->set(in, 5345); 27176 o->f->push(o, (baset *) in); 27177 finishO(in); 27178 o->f->slice(o,-1,0); 27179 s = toStringO(o); 27180 ck_assert_str_eq(s, "[5345]"); 27181 free(s); 27182 terminateO(o); 27183 // start = end 27184 o = obj2->f->duplicate(obj2); 27185 initiateAllocateSmallInt(&in); 27186 in->f->set(in, 5345); 27187 o->f->push(o, (baset *) in); 27188 finishO(in); 27189 o->f->slice(o,1,1); 27190 s = toStringO(o); 27191 ck_assert_str_eq(s, "[]"); 27192 free(s); 27193 terminateO(o); 27194 // empty list 27195 initiateAllocateSmallArray(&o); 27196 o->f->slice(o,0,0); 27197 s = toStringO(o); 27198 ck_assert_str_eq(s, "[]"); 27199 free(s); 27200 terminateO(o); 27201 // insert 27202 o = obj2->f->duplicate(obj2); 27203 o2 = obj2->f->duplicate(obj2); 27204 in = (smallIntt *) o2->f->getAt(o2, 1); 27205 in->value->value = 789; 27206 o2->f->setAt(o2, 1, (baset *)in); 27207 finishO(in); 27208 o->f->insert(o, 0, o2); 27209 s = toStringO(o); 27210 ck_assert_str_eq(s, "[null,789,\"sheepy\",null,123,\"sheepy\"]"); 27211 free(s); 27212 terminateO(o); 27213 o2->f->smash(&o2); 27214 // negative index 27215 o = obj2->f->duplicate(obj2); 27216 o2 = obj2->f->duplicate(obj2); 27217 in = (smallIntt *) o2->f->getAt(o2, 1); 27218 in->value->value = 789; 27219 o2->f->setAt(o2, 1, (baset *)in); 27220 finishO(in); 27221 o->f->insert(o, -1, o2); 27222 s = toStringO(o); 27223 ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]"); 27224 free(s); 27225 terminateO(o); 27226 o2->f->smash(&o2); 27227 // edge 27228 o = obj2->f->duplicate(obj2); 27229 o2 = obj2->f->duplicate(obj2); 27230 in = (smallIntt *) o2->f->getAt(o2, 1); 27231 in->value->value = 789; 27232 o2->f->setAt(o2, 1, (baset *)in); 27233 finishO(in); 27234 o->f->insert(o, 3, o2); 27235 s = toStringO(o); 27236 ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]"); 27237 free(s); 27238 terminateO(o); 27239 o2->f->smash(&o2); 27240 // outside 27241 o = obj2->f->duplicate(obj2); 27242 o2 = obj2->f->duplicate(obj2); 27243 in = (smallIntt *) o2->f->getAt(o2, 1); 27244 in->value->value = 789; 27245 o2->f->setAt(o2, 1, (baset *)in); 27246 finishO(in); 27247 o->f->insert(o, 4, o2); 27248 s = toStringO(o); 27249 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27250 free(s); 27251 o->f->insert(o, -5, o2); 27252 s = toStringO(o); 27253 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27254 free(s); 27255 terminateO(o); 27256 terminateO(o2); 27257 // negative index in a one element list 27258 o = obj2->f->duplicate(obj2); 27259 o2 = obj2->f->duplicate(obj2); 27260 in = (smallIntt *) o2->f->getAt(o2, 1); 27261 in->value->value = 789; 27262 o2->f->setAt(o2, 1, (baset *)in); 27263 finishO(in); 27264 o->f->delElem(o, 1); 27265 o->f->delElem(o, 2); 27266 o->f->trim(o); 27267 o->f->insert(o, -1, o2); 27268 s = toStringO(o); 27269 ck_assert_str_eq(s, "[null,null,789,\"sheepy\"]"); 27270 free(s); 27271 terminateO(o); 27272 o2->f->smash(&o2); 27273 // empty list 27274 initiateAllocateSmallArray(&o); 27275 o2 = obj2->f->duplicate(obj2); 27276 in = (smallIntt *) o2->f->getAt(o2, 1); 27277 in->value->value = 789; 27278 o2->f->setAt(o2, 1, (baset *)in); 27279 finishO(in); 27280 o->f->insert(o, 0, o2); 27281 s = toStringO(o); 27282 ck_assert_str_eq(s, "[null,789,\"sheepy\"]"); 27283 free(s); 27284 terminateO(o); 27285 o2->f->dispose(o2); 27286 // empty insert list 27287 o = obj2->f->duplicate(obj2); 27288 o->f->insert(o, 0, o2); 27289 s = toStringO(o); 27290 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27291 free(s); 27292 terminateO(o); 27293 o2->f->smash(&o2); 27294 //NULL insert 27295 o = obj2->f->duplicate(obj2); 27296 o->f->insert(o, 0, NULL); 27297 s = toStringO(o); 27298 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27299 free(s); 27300 terminateO(o); 27301 // del 27302 o = obj2->f->duplicate(obj2); 27303 initiateAllocateSmallInt(&in); 27304 in->f->set(in, 5345); 27305 o->f->push(o, (baset *) in); 27306 finishO(in); 27307 o->f->del(o,1,-1); 27308 s = toStringO(o); 27309 ck_assert_str_eq(s, "[null,5345]"); 27310 free(s); 27311 terminateO(o); 27312 // start outside 27313 o = obj2->f->duplicate(obj2); 27314 initiateAllocateSmallInt(&in); 27315 in->f->set(in, 5345); 27316 o->f->push(o, (baset *) in); 27317 finishO(in); 27318 o->f->del(o,20,-1); 27319 s = toStringO(o); 27320 ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]"); 27321 free(s); 27322 terminateO(o); 27323 // start negative and outside 27324 o = obj2->f->duplicate(obj2); 27325 initiateAllocateSmallInt(&in); 27326 in->f->set(in, 5345); 27327 o->f->push(o, (baset *) in); 27328 finishO(in); 27329 o->f->del(o,-20,1); 27330 s = toStringO(o); 27331 ck_assert_str_eq(s, "[123,\"sheepy\",5345]"); 27332 free(s); 27333 terminateO(o); 27334 // end outside 27335 o = obj2->f->duplicate(obj2); 27336 initiateAllocateSmallInt(&in); 27337 in->f->set(in, 5345); 27338 o->f->push(o, (baset *) in); 27339 finishO(in); 27340 o->f->del(o,2,40); 27341 s = toStringO(o); 27342 ck_assert_str_eq(s, "[null,123]"); 27343 free(s); 27344 terminateO(o); 27345 // end negative and outside 27346 o = obj2->f->duplicate(obj2); 27347 initiateAllocateSmallInt(&in); 27348 in->f->set(in, 5345); 27349 o->f->push(o, (baset *) in); 27350 finishO(in); 27351 o->f->del(o,2,-40); 27352 s = toStringO(o); 27353 ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]"); 27354 free(s); 27355 terminateO(o); 27356 // end before start 27357 o = obj2->f->duplicate(obj2); 27358 initiateAllocateSmallInt(&in); 27359 in->f->set(in, 5345); 27360 o->f->push(o, (baset *) in); 27361 finishO(in); 27362 o->f->del(o,3,2); 27363 s = toStringO(o); 27364 ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]"); 27365 free(s); 27366 terminateO(o); 27367 // negative start last element 27368 o = obj2->f->duplicate(obj2); 27369 initiateAllocateSmallInt(&in); 27370 in->f->set(in, 5345); 27371 o->f->push(o, (baset *) in); 27372 finishO(in); 27373 o->f->del(o,-1,0); 27374 s = toStringO(o); 27375 ck_assert_str_eq(s, "[null,123,\"sheepy\"]"); 27376 free(s); 27377 terminateO(o); 27378 // start = end 27379 o = obj2->f->duplicate(obj2); 27380 initiateAllocateSmallInt(&in); 27381 in->f->set(in, 5345); 27382 o->f->push(o, (baset *) in); 27383 finishO(in); 27384 o->f->del(o,1,1); 27385 s = toStringO(o); 27386 ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]"); 27387 free(s); 27388 terminateO(o); 27389 // empty list 27390 initiateAllocateSmallArray(&o); 27391 o->f->del(o,0,0); 27392 s = toStringO(o); 27393 ck_assert_str_eq(s, "[]"); 27394 free(s); 27395 terminateO(o); 27396 // len 27397 ck_assert_uint_eq(obj2->f->len(obj2), 3); 27398 // trim 27399 o = obj2->f->duplicate(obj2); 27400 ck_assert_uint_eq(o->f->len(o), 3); 27401 st = (smallStringt *) o->f->pop(o); 27402 terminateO(st); 27403 o->f->delElem(o, 0); 27404 o->f->trim(o); 27405 ck_assert_uint_eq(o->f->len(o), 1); 27406 s = toStringO(o); 27407 ck_assert_str_eq(s, "[123]"); 27408 free(s); 27409 terminateO(o); 27410 // getAt 27411 o = obj2->f->duplicate(obj2); 27412 u = (undefinedt *) o->f->getAt(o, 0); 27413 ck_assert_str_eq(u->type, "undefined"); 27414 terminateO(u); 27415 st = (smallStringt *) o->f->getAt(o, -1); 27416 ck_assert_str_eq(st->type, "smallString"); 27417 smashO(st); 27418 // outside 27419 u = (undefinedt *) o->f->getAt(o, 4); 27420 ck_assert_ptr_eq(u, NULL); 27421 u = (undefinedt *) o->f->getAt(o, -4); 27422 ck_assert_ptr_eq(u, NULL); 27423 terminateO(o); 27424 // empty 27425 initiateAllocateSmallArray(&o); 27426 u = (undefinedt *) o->f->getAt(o, 0); 27427 ck_assert_ptr_eq(u, NULL); 27428 terminateO(o); 27429 // setAt 27430 o = obj2->f->duplicate(obj2); 27431 initiateAllocateSmallInt(&in); 27432 o->f->setAt(o, 0, (baset *) in); 27433 finishO(in); 27434 s = toStringO(o); 27435 ck_assert_str_eq(s, "[0,123,\"sheepy\"]"); 27436 free(s); 27437 initiateAllocateSmallInt(&in); 27438 o->f->setAt(o, -1, (baset *) in); 27439 finishO(in); 27440 s = toStringO(o); 27441 ck_assert_str_eq(s, "[0,123,0]"); 27442 free(s); 27443 // outside 27444 o->f->setAt(o, 4, (baset *) in); 27445 s = toStringO(o); 27446 ck_assert_str_eq(s, "[0,123,0]"); 27447 free(s); 27448 o->f->setAt(o, -4, (baset *) in); 27449 s = toStringO(o); 27450 ck_assert_str_eq(s, "[0,123,0]"); 27451 free(s); 27452 terminateO(o); 27453 // empty 27454 o = obj2->f->duplicate(obj2); 27455 o->f->empty(o); 27456 ck_assert(o->f->isEmpty(o)); 27457 terminateO(o); 27458 // isEmpty 27459 o = obj2->f->duplicate(obj2); 27460 ck_assert(!o->f->isEmpty(o)); 27461 terminateO(o); 27462 initiateAllocateSmallArray(&o); 27463 ck_assert(o->f->isEmpty(o)); 27464 terminateO(o); 27465 // typeString type typeStrings types 27466 initiateAllocateSmallArray(&o2); 27467 o = allocSmallArray(); 27468 oU = allocUndefined(); 27469 o->f->push(o, (baset *)oU); 27470 finishO(oU); 27471 oInt = allocSmallInt(123); 27472 o->f->push(o, (baset *)oInt); 27473 finishO(oInt); 27474 oStr = allocSmallString("sheepy"); 27475 o->f->push(o, (baset *)oStr); 27476 finishO(oStr); 27477 o->f->push(o, NULL); 27478 // typeString 27479 s = (char *)o->f->typeString(o, 0); 27480 ck_assert_str_eq(s, "undefined"); 27481 // type 27482 char c = o->f->type(o, 2); 27483 ck_assert_uint_eq(c, STRING); 27484 // negative index 27485 c = o->f->type(o, -2); 27486 ck_assert_uint_eq(c, INT); 27487 // outside 27488 ck_assert(!o->f->type(o, 10)); 27489 ck_assert(!o->f->type(o, -14)); 27490 // NULL element 27491 c = o->f->type(o, 0); 27492 ck_assert_uint_eq(c, UNDEFINED); 27493 // empty object 27494 ck_assert(!o2->f->type(o2, 0)); 27495 // typeStrings 27496 char **l = o->f->typeStrings(o); 27497 s = join(l, ","); 27498 ck_assert_str_eq(s, "undefined,int,string"); 27499 free(s); 27500 free(l); 27501 // empty object 27502 ck_assert_ptr_eq(o2->f->typeStrings(o2), NULL); 27503 // types 27504 smallBytest *B = o->f->types(o); 27505 s = sToStringTiny((smallt *)B->B); 27506 ck_assert_str_eq(s, "[0x01,0x07,0x08]"); 27507 free(s); 27508 // empty object 27509 ck_assert_ptr_eq(o2->f->types(o2), NULL); 27510 terminateO(B); 27511 terminateO(o); 27512 terminateO(o2); 27513 // free local object 27514 obj.f->free(&obj); 27515 ck_assert_str_eq(obj.type, "smallArray"); 27516 // free object 27517 obj2->f->terminate(&obj2); 27518 ck_assert_ptr_eq(obj2, NULL); 27519 // init NULL 27520 initiateAllocateSmallArray(NULL); 27521 27522 } 27523 27524 27525 27526 27527 int main(int n UNUSED, char**v UNUSED) { 27528 // disable btrace to make the test run faster 27529 btraceDisable(); 27530 CuString *output = CuStringNew(); 27531 CuSuite *suite = CuSuiteNew(); 27532 27533 SUITE_ADD_TEST(suite, allocArraySmallArrayT); 27534 SUITE_ADD_TEST(suite, allocCArraySmallArrayT); 27535 SUITE_ADD_TEST(suite, createSAFT); 27536 SUITE_ADD_TEST(suite, getsoSmallArrayT); 27537 SUITE_ADD_TEST(suite, setsoSmallArrayT); 27538 SUITE_ADD_TEST(suite, mirrorSmallArrayT); 27539 SUITE_ADD_TEST(suite, fromArrayNFreeSmallArrayT); 27540 SUITE_ADD_TEST(suite, pushUndefinedSmallArrayT); 27541 SUITE_ADD_TEST(suite, pushBoolSmallArrayT); 27542 SUITE_ADD_TEST(suite, pushDoubleSmallArrayT); 27543 SUITE_ADD_TEST(suite, pushIntSmallArrayT); 27544 SUITE_ADD_TEST(suite, pushSSmallArrayT); 27545 SUITE_ADD_TEST(suite, pushCharSmallArrayT); 27546 SUITE_ADD_TEST(suite, pushDictSmallArrayT); 27547 SUITE_ADD_TEST(suite, pushArraySmallArrayT); 27548 SUITE_ADD_TEST(suite, pushArraycSmallArrayT); 27549 SUITE_ADD_TEST(suite, pushSmallBoolSmallArrayT); 27550 SUITE_ADD_TEST(suite, pushSmallBytesSmallArrayT); 27551 SUITE_ADD_TEST(suite, pushSmallDoubleSmallArrayT); 27552 SUITE_ADD_TEST(suite, pushSmallIntSmallArrayT); 27553 SUITE_ADD_TEST(suite, pushSmallJsonSmallArrayT); 27554 SUITE_ADD_TEST(suite, pushSmallStringSmallArrayT); 27555 SUITE_ADD_TEST(suite, pushSmallContainerSmallArrayT); 27556 SUITE_ADD_TEST(suite, pushNFreeSmallArrayT); 27557 SUITE_ADD_TEST(suite, pushNFreeUndefinedSmallArrayT); 27558 SUITE_ADD_TEST(suite, pushNFreeSSmallArrayT); 27559 SUITE_ADD_TEST(suite, pushNFreeDictSmallArrayT); 27560 SUITE_ADD_TEST(suite, pushNFreeArraySmallArrayT); 27561 SUITE_ADD_TEST(suite, pushNFreeArraycSmallArrayT); 27562 SUITE_ADD_TEST(suite, pushNFreeSmallBoolSmallArrayT); 27563 SUITE_ADD_TEST(suite, pushNFreeSmallBytesSmallArrayT); 27564 SUITE_ADD_TEST(suite, pushNFreeSmallDoubleSmallArrayT); 27565 SUITE_ADD_TEST(suite, pushNFreeSmallIntSmallArrayT); 27566 SUITE_ADD_TEST(suite, pushNFreeSmallJsonSmallArrayT); 27567 SUITE_ADD_TEST(suite, pushNFreeSmallStringSmallArrayT); 27568 SUITE_ADD_TEST(suite, pushNFreeSmallContainerSmallArrayT); 27569 SUITE_ADD_TEST(suite, pushManySmallArrayT); 27570 SUITE_ADD_TEST(suite, pushManySSmallArrayT); 27571 SUITE_ADD_TEST(suite, pushNFreeManySmallArrayT); 27572 SUITE_ADD_TEST(suite, pushNFreeManySSmallArrayT); 27573 SUITE_ADD_TEST(suite, popSmallArrayT); 27574 SUITE_ADD_TEST(suite, popUndefinedSmallArrayT); 27575 SUITE_ADD_TEST(suite, popBoolSmallArrayT); 27576 SUITE_ADD_TEST(suite, popDoubleSmallArrayT); 27577 SUITE_ADD_TEST(suite, popIntSmallArrayT); 27578 SUITE_ADD_TEST(suite, popInt32SmallArrayT); 27579 SUITE_ADD_TEST(suite, popUintSmallArrayT); 27580 SUITE_ADD_TEST(suite, popUint32SmallArrayT); 27581 SUITE_ADD_TEST(suite, popSSmallArrayT); 27582 SUITE_ADD_TEST(suite, popDictSmallArrayT); 27583 SUITE_ADD_TEST(suite, popArraySmallArrayT); 27584 SUITE_ADD_TEST(suite, popSmallBoolSmallArrayT); 27585 SUITE_ADD_TEST(suite, popSmallBytesSmallArrayT); 27586 SUITE_ADD_TEST(suite, popSmallDoubleSmallArrayT); 27587 SUITE_ADD_TEST(suite, popSmallIntSmallArrayT); 27588 SUITE_ADD_TEST(suite, popSmallJsonSmallArrayT); 27589 SUITE_ADD_TEST(suite, popSmallStringSmallArrayT); 27590 SUITE_ADD_TEST(suite, popVoidSmallArrayT); 27591 SUITE_ADD_TEST(suite, popSmallContainerSmallArrayT); 27592 SUITE_ADD_TEST(suite, popNumSmallArrayT); 27593 SUITE_ADD_TEST(suite, prependSmallArrayT); 27594 SUITE_ADD_TEST(suite, prependUndefinedSmallArrayT); 27595 SUITE_ADD_TEST(suite, prependBoolSmallArrayT); 27596 SUITE_ADD_TEST(suite, prependDoubleSmallArrayT); 27597 SUITE_ADD_TEST(suite, prependIntSmallArrayT); 27598 SUITE_ADD_TEST(suite, prependSSmallArrayT); 27599 SUITE_ADD_TEST(suite, prependCharSmallArrayT); 27600 SUITE_ADD_TEST(suite, prependDictSmallArrayT); 27601 SUITE_ADD_TEST(suite, prependArraySmallArrayT); 27602 SUITE_ADD_TEST(suite, prependArraycSmallArrayT); 27603 SUITE_ADD_TEST(suite, prependSmallBoolSmallArrayT); 27604 SUITE_ADD_TEST(suite, prependSmallBytesSmallArrayT); 27605 SUITE_ADD_TEST(suite, prependSmallDoubleSmallArrayT); 27606 SUITE_ADD_TEST(suite, prependSmallIntSmallArrayT); 27607 SUITE_ADD_TEST(suite, prependSmallJsonSmallArrayT); 27608 SUITE_ADD_TEST(suite, prependSmallStringSmallArrayT); 27609 SUITE_ADD_TEST(suite, prependSmallContainerSmallArrayT); 27610 SUITE_ADD_TEST(suite, prependNFreeSmallArrayT); 27611 SUITE_ADD_TEST(suite, prependNFreeUndefinedSmallArrayT); 27612 SUITE_ADD_TEST(suite, prependNFreeSSmallArrayT); 27613 SUITE_ADD_TEST(suite, prependNFreeDictSmallArrayT); 27614 SUITE_ADD_TEST(suite, prependNFreeArraySmallArrayT); 27615 SUITE_ADD_TEST(suite, prependNFreeArraycSmallArrayT); 27616 SUITE_ADD_TEST(suite, prependNFreeSmallBoolSmallArrayT); 27617 SUITE_ADD_TEST(suite, prependNFreeSmallBytesSmallArrayT); 27618 SUITE_ADD_TEST(suite, prependNFreeSmallDoubleSmallArrayT); 27619 SUITE_ADD_TEST(suite, prependNFreeSmallIntSmallArrayT); 27620 SUITE_ADD_TEST(suite, prependNFreeSmallJsonSmallArrayT); 27621 SUITE_ADD_TEST(suite, prependNFreeSmallStringSmallArrayT); 27622 SUITE_ADD_TEST(suite, prependNFreeSmallContainerSmallArrayT); 27623 SUITE_ADD_TEST(suite, dequeueSmallArrayT); 27624 SUITE_ADD_TEST(suite, dequeueUndefinedSmallArrayT); 27625 SUITE_ADD_TEST(suite, dequeueBoolSmallArrayT); 27626 SUITE_ADD_TEST(suite, dequeueDoubleSmallArrayT); 27627 SUITE_ADD_TEST(suite, dequeueIntSmallArrayT); 27628 SUITE_ADD_TEST(suite, dequeueInt32SmallArrayT); 27629 SUITE_ADD_TEST(suite, dequeueUintSmallArrayT); 27630 SUITE_ADD_TEST(suite, dequeueUint32SmallArrayT); 27631 SUITE_ADD_TEST(suite, dequeueSSmallArrayT); 27632 SUITE_ADD_TEST(suite, dequeueDictSmallArrayT); 27633 SUITE_ADD_TEST(suite, dequeueArraySmallArrayT); 27634 SUITE_ADD_TEST(suite, dequeueSmallBoolSmallArrayT); 27635 SUITE_ADD_TEST(suite, dequeueSmallBytesSmallArrayT); 27636 SUITE_ADD_TEST(suite, dequeueSmallDoubleSmallArrayT); 27637 SUITE_ADD_TEST(suite, dequeueSmallIntSmallArrayT); 27638 SUITE_ADD_TEST(suite, dequeueSmallJsonSmallArrayT); 27639 SUITE_ADD_TEST(suite, dequeueSmallStringSmallArrayT); 27640 SUITE_ADD_TEST(suite, dequeueVoidSmallArrayT); 27641 SUITE_ADD_TEST(suite, dequeueSmallContainerSmallArrayT); 27642 SUITE_ADD_TEST(suite, dequeueNumSmallArrayT); 27643 SUITE_ADD_TEST(suite, reverseSmallArrayT); 27644 SUITE_ADD_TEST(suite, catSmallArrayT); 27645 SUITE_ADD_TEST(suite, appendSmallJsonSmallArrayT); 27646 SUITE_ADD_TEST(suite, appendNSmashSmallArrayT); 27647 SUITE_ADD_TEST(suite, appendNSmashSmallJsonSmallArrayT); 27648 SUITE_ADD_TEST(suite, appendArraySmallArrayT); 27649 SUITE_ADD_TEST(suite, appendNSmashArraySmallArrayT); 27650 SUITE_ADD_TEST(suite, shiftSmallArrayT); 27651 SUITE_ADD_TEST(suite, shiftSmallJsonSmallArrayT); 27652 SUITE_ADD_TEST(suite, shiftNSmashSmallArrayT); 27653 SUITE_ADD_TEST(suite, shiftNSmashSmallJsonSmallArrayT); 27654 SUITE_ADD_TEST(suite, addSmallArrayT); 27655 SUITE_ADD_TEST(suite, cropSmallArrayT); 27656 SUITE_ADD_TEST(suite, cropElemSmallArrayT); 27657 SUITE_ADD_TEST(suite, cropElemUndefinedSmallArrayT); 27658 SUITE_ADD_TEST(suite, cropElemBoolSmallArrayT); 27659 SUITE_ADD_TEST(suite, cropElemDoubleSmallArrayT); 27660 SUITE_ADD_TEST(suite, cropElemIntSmallArrayT); 27661 SUITE_ADD_TEST(suite, cropElemInt32SmallArrayT); 27662 SUITE_ADD_TEST(suite, cropElemUintSmallArrayT); 27663 SUITE_ADD_TEST(suite, cropElemUint32SmallArrayT); 27664 SUITE_ADD_TEST(suite, cropElemSSmallArrayT); 27665 SUITE_ADD_TEST(suite, cropElemDictSmallArrayT); 27666 SUITE_ADD_TEST(suite, cropElemArraySmallArrayT); 27667 SUITE_ADD_TEST(suite, cropElemSmallBoolSmallArrayT); 27668 SUITE_ADD_TEST(suite, cropElemSmallBytesSmallArrayT); 27669 SUITE_ADD_TEST(suite, cropElemSmallDoubleSmallArrayT); 27670 SUITE_ADD_TEST(suite, cropElemSmallIntSmallArrayT); 27671 SUITE_ADD_TEST(suite, cropElemSmallJsonSmallArrayT); 27672 SUITE_ADD_TEST(suite, cropElemSmallStringSmallArrayT); 27673 SUITE_ADD_TEST(suite, cropElemVoidSmallArrayT); 27674 SUITE_ADD_TEST(suite, cropElemSmallContainerSmallArrayT); 27675 SUITE_ADD_TEST(suite, copySmallArrayT); 27676 SUITE_ADD_TEST(suite, insertSmallArrayT); 27677 SUITE_ADD_TEST(suite, insertSmallJsonSmallArrayT); 27678 SUITE_ADD_TEST(suite, insertNSmashSmallArrayT); 27679 SUITE_ADD_TEST(suite, insertNSmashSmallJsonSmallArrayT); 27680 SUITE_ADD_TEST(suite, injectSmallArrayT); 27681 SUITE_ADD_TEST(suite, injectUndefinedSmallArrayT); 27682 SUITE_ADD_TEST(suite, injectBoolSmallArrayT); 27683 SUITE_ADD_TEST(suite, injectDoubleSmallArrayT); 27684 SUITE_ADD_TEST(suite, injectIntSmallArrayT); 27685 SUITE_ADD_TEST(suite, injectSSmallArrayT); 27686 SUITE_ADD_TEST(suite, injectCharSmallArrayT); 27687 SUITE_ADD_TEST(suite, injectDictSmallArrayT); 27688 SUITE_ADD_TEST(suite, injectArraySmallArrayT); 27689 SUITE_ADD_TEST(suite, injectArraycSmallArrayT); 27690 SUITE_ADD_TEST(suite, injectSmallBoolSmallArrayT); 27691 SUITE_ADD_TEST(suite, injectSmallBytesSmallArrayT); 27692 SUITE_ADD_TEST(suite, injectSmallDoubleSmallArrayT); 27693 SUITE_ADD_TEST(suite, injectSmallIntSmallArrayT); 27694 SUITE_ADD_TEST(suite, injectSmallJsonSmallArrayT); 27695 SUITE_ADD_TEST(suite, injectSmallStringSmallArrayT); 27696 SUITE_ADD_TEST(suite, injectSmallContainerSmallArrayT); 27697 SUITE_ADD_TEST(suite, injectNFreeSmallArrayT); 27698 SUITE_ADD_TEST(suite, injectNFreeUndefinedSmallArrayT); 27699 SUITE_ADD_TEST(suite, injectNFreeSSmallArrayT); 27700 SUITE_ADD_TEST(suite, injectNFreeDictSmallArrayT); 27701 SUITE_ADD_TEST(suite, injectNFreeArraySmallArrayT); 27702 SUITE_ADD_TEST(suite, injectNFreeArraycSmallArrayT); 27703 SUITE_ADD_TEST(suite, injectNFreeSmallBoolSmallArrayT); 27704 SUITE_ADD_TEST(suite, injectNFreeSmallBytesSmallArrayT); 27705 SUITE_ADD_TEST(suite, injectNFreeSmallDoubleSmallArrayT); 27706 SUITE_ADD_TEST(suite, injectNFreeSmallIntSmallArrayT); 27707 SUITE_ADD_TEST(suite, injectNFreeSmallJsonSmallArrayT); 27708 SUITE_ADD_TEST(suite, injectNFreeSmallStringSmallArrayT); 27709 SUITE_ADD_TEST(suite, injectNFreeSmallContainerSmallArrayT); 27710 SUITE_ADD_TEST(suite, removeSmallArrayT); 27711 SUITE_ADD_TEST(suite, removeElemSmallArrayT); 27712 SUITE_ADD_TEST(suite, sortSmallArrayT); 27713 SUITE_ADD_TEST(suite, icSortSmallArrayT); 27714 SUITE_ADD_TEST(suite, sortFSmallArrayT); 27715 SUITE_ADD_TEST(suite, equalSmallArrayT); 27716 SUITE_ADD_TEST(suite, equalSmallArraySmallJsonT); 27717 SUITE_ADD_TEST(suite, equalSmallArrayArrayT); 27718 SUITE_ADD_TEST(suite, equalSmallArrayBaseT); 27719 SUITE_ADD_TEST(suite, icEqualSmallArrayT); 27720 SUITE_ADD_TEST(suite, icEqualSmallArraySmallJsonT); 27721 SUITE_ADD_TEST(suite, icEqualSmallArrayArrayT); 27722 SUITE_ADD_TEST(suite, icEqualSmallArrayBaseT); 27723 SUITE_ADD_TEST(suite, getAtUndefinedSmallArrayT); 27724 SUITE_ADD_TEST(suite, getAtBoolSmallArrayT); 27725 SUITE_ADD_TEST(suite, getAtBoolPSmallArrayT); 27726 SUITE_ADD_TEST(suite, getAtDoubleSmallArrayT); 27727 SUITE_ADD_TEST(suite, getAtDoublePSmallArrayT); 27728 SUITE_ADD_TEST(suite, getAtIntSmallArrayT); 27729 SUITE_ADD_TEST(suite, getAtIntPSmallArrayT); 27730 SUITE_ADD_TEST(suite, getAtInt32SmallArrayT); 27731 SUITE_ADD_TEST(suite, getAtInt32PSmallArrayT); 27732 SUITE_ADD_TEST(suite, getAtUintSmallArrayT); 27733 SUITE_ADD_TEST(suite, getAtUintPSmallArrayT); 27734 SUITE_ADD_TEST(suite, getAtUint32SmallArrayT); 27735 SUITE_ADD_TEST(suite, getAtUint32PSmallArrayT); 27736 SUITE_ADD_TEST(suite, getAtSSmallArrayT); 27737 SUITE_ADD_TEST(suite, getAtDictSmallArrayT); 27738 SUITE_ADD_TEST(suite, getAtArraySmallArrayT); 27739 SUITE_ADD_TEST(suite, getAtSmallBoolSmallArrayT); 27740 SUITE_ADD_TEST(suite, getAtSmallBytesSmallArrayT); 27741 SUITE_ADD_TEST(suite, getAtSmallDoubleSmallArrayT); 27742 SUITE_ADD_TEST(suite, getAtSmallIntSmallArrayT); 27743 SUITE_ADD_TEST(suite, getAtSmallJsonSmallArrayT); 27744 SUITE_ADD_TEST(suite, getAtSmallStringSmallArrayT); 27745 SUITE_ADD_TEST(suite, getAtVoidSmallArrayT); 27746 SUITE_ADD_TEST(suite, getAtSmallContainerSmallArrayT); 27747 SUITE_ADD_TEST(suite, getAtNDupSmallArrayT); 27748 SUITE_ADD_TEST(suite, getAtNDupUndefinedSmallArrayT); 27749 SUITE_ADD_TEST(suite, getAtNDupBoolSmallArrayT); 27750 SUITE_ADD_TEST(suite, getAtNDupDoubleSmallArrayT); 27751 SUITE_ADD_TEST(suite, getAtNDupIntSmallArrayT); 27752 SUITE_ADD_TEST(suite, getAtNDupInt32SmallArrayT); 27753 SUITE_ADD_TEST(suite, getAtNDupUintSmallArrayT); 27754 SUITE_ADD_TEST(suite, getAtNDupUint32SmallArrayT); 27755 SUITE_ADD_TEST(suite, getAtNDupSSmallArrayT); 27756 SUITE_ADD_TEST(suite, getAtNDupDictSmallArrayT); 27757 SUITE_ADD_TEST(suite, getAtNDupArraySmallArrayT); 27758 SUITE_ADD_TEST(suite, getAtNDupSmallBoolSmallArrayT); 27759 SUITE_ADD_TEST(suite, getAtNDupSmallBytesSmallArrayT); 27760 SUITE_ADD_TEST(suite, getAtNDupSmallDoubleSmallArrayT); 27761 SUITE_ADD_TEST(suite, getAtNDupSmallIntSmallArrayT); 27762 SUITE_ADD_TEST(suite, getAtNDupSmallJsonSmallArrayT); 27763 SUITE_ADD_TEST(suite, getAtNDupSmallStringSmallArrayT); 27764 SUITE_ADD_TEST(suite, getAtNDupVoidSmallArrayT); 27765 SUITE_ADD_TEST(suite, getAtNDupSmallContainerSmallArrayT); 27766 SUITE_ADD_TEST(suite, setAtSmallArrayT); 27767 SUITE_ADD_TEST(suite, setAtUndefinedSmallArrayT); 27768 SUITE_ADD_TEST(suite, setAtBoolSmallArrayT); 27769 SUITE_ADD_TEST(suite, setAtDoubleSmallArrayT); 27770 SUITE_ADD_TEST(suite, setAtIntSmallArrayT); 27771 SUITE_ADD_TEST(suite, setAtSSmallArrayT); 27772 SUITE_ADD_TEST(suite, setAtCharSmallArrayT); 27773 SUITE_ADD_TEST(suite, setAtDictSmallArrayT); 27774 SUITE_ADD_TEST(suite, setAtArraySmallArrayT); 27775 SUITE_ADD_TEST(suite, setAtArraycSmallArrayT); 27776 SUITE_ADD_TEST(suite, setAtSmallBoolSmallArrayT); 27777 SUITE_ADD_TEST(suite, setAtSmallBytesSmallArrayT); 27778 SUITE_ADD_TEST(suite, setAtSmallDoubleSmallArrayT); 27779 SUITE_ADD_TEST(suite, setAtSmallIntSmallArrayT); 27780 SUITE_ADD_TEST(suite, setAtSmallJsonSmallArrayT); 27781 SUITE_ADD_TEST(suite, setAtSmallStringSmallArrayT); 27782 SUITE_ADD_TEST(suite, setAtSmallContainerSmallArrayT); 27783 SUITE_ADD_TEST(suite, setAtNFreeSmallArrayT); 27784 SUITE_ADD_TEST(suite, setAtNFreeUndefinedSmallArrayT); 27785 SUITE_ADD_TEST(suite, setAtNFreeSSmallArrayT); 27786 SUITE_ADD_TEST(suite, setAtNFreeDictSmallArrayT); 27787 SUITE_ADD_TEST(suite, setAtNFreeArraySmallArrayT); 27788 SUITE_ADD_TEST(suite, setAtNFreeArraycSmallArrayT); 27789 SUITE_ADD_TEST(suite, setAtNFreeSmallBoolSmallArrayT); 27790 SUITE_ADD_TEST(suite, setAtNFreeSmallBytesSmallArrayT); 27791 SUITE_ADD_TEST(suite, setAtNFreeSmallDoubleSmallArrayT); 27792 SUITE_ADD_TEST(suite, setAtNFreeSmallIntSmallArrayT); 27793 SUITE_ADD_TEST(suite, setAtNFreeSmallJsonSmallArrayT); 27794 SUITE_ADD_TEST(suite, setAtNFreeSmallStringSmallArrayT); 27795 SUITE_ADD_TEST(suite, setAtNFreeSmallContainerSmallArrayT); 27796 SUITE_ADD_TEST(suite, setPAtDictSmallArrayT); 27797 SUITE_ADD_TEST(suite, setPAtArraySmallArrayT); 27798 SUITE_ADD_TEST(suite, setPAtSmallJsonSmallArrayT); 27799 SUITE_ADD_TEST(suite, setPAtSmallStringSmallArrayT); 27800 SUITE_ADD_TEST(suite, setPAtNFreeDictSmallArrayT); 27801 SUITE_ADD_TEST(suite, setPAtNFreeArraySmallArrayT); 27802 SUITE_ADD_TEST(suite, setPAtNFreeSmallJsonSmallArrayT); 27803 SUITE_ADD_TEST(suite, setPAtNFreeSmallStringSmallArrayT); 27804 SUITE_ADD_TEST(suite, getNumSmallArrayT); 27805 SUITE_ADD_TEST(suite, hasSmallArrayT); 27806 SUITE_ADD_TEST(suite, hasUndefinedSmallArrayT); 27807 SUITE_ADD_TEST(suite, hasBoolSmallArrayT); 27808 SUITE_ADD_TEST(suite, hasDoubleSmallArrayT); 27809 SUITE_ADD_TEST(suite, hasIntSmallArrayT); 27810 SUITE_ADD_TEST(suite, hasSSmallArrayT); 27811 SUITE_ADD_TEST(suite, hasCharSmallArrayT); 27812 SUITE_ADD_TEST(suite, hasDictSmallArrayT); 27813 SUITE_ADD_TEST(suite, hasArraySmallArrayT); 27814 SUITE_ADD_TEST(suite, hasArraycSmallArrayT); 27815 SUITE_ADD_TEST(suite, hasSmallBoolSmallArrayT); 27816 SUITE_ADD_TEST(suite, hasSmallBytesSmallArrayT); 27817 SUITE_ADD_TEST(suite, hasSmallDoubleSmallArrayT); 27818 SUITE_ADD_TEST(suite, hasSmallIntSmallArrayT); 27819 SUITE_ADD_TEST(suite, hasSmallJsonSmallArrayT); 27820 SUITE_ADD_TEST(suite, hasSmallStringSmallArrayT); 27821 SUITE_ADD_TEST(suite, hasSmallContainerSmallArrayT); 27822 SUITE_ADD_TEST(suite, indexOfSmallArrayT); 27823 SUITE_ADD_TEST(suite, indexOfUndefinedSmallArrayT); 27824 SUITE_ADD_TEST(suite, indexOfBoolSmallArrayT); 27825 SUITE_ADD_TEST(suite, indexOfDoubleSmallArrayT); 27826 SUITE_ADD_TEST(suite, indexOfIntSmallArrayT); 27827 SUITE_ADD_TEST(suite, indexOfSSmallArrayT); 27828 SUITE_ADD_TEST(suite, indexOfCharSmallArrayT); 27829 SUITE_ADD_TEST(suite, indexOfDictSmallArrayT); 27830 SUITE_ADD_TEST(suite, indexOfArraySmallArrayT); 27831 SUITE_ADD_TEST(suite, indexOfArraycSmallArrayT); 27832 SUITE_ADD_TEST(suite, indexOfSmallBoolSmallArrayT); 27833 SUITE_ADD_TEST(suite, indexOfSmallBytesSmallArrayT); 27834 SUITE_ADD_TEST(suite, indexOfSmallDoubleSmallArrayT); 27835 SUITE_ADD_TEST(suite, indexOfSmallIntSmallArrayT); 27836 SUITE_ADD_TEST(suite, indexOfSmallJsonSmallArrayT); 27837 SUITE_ADD_TEST(suite, indexOfSmallStringSmallArrayT); 27838 SUITE_ADD_TEST(suite, indexOfSmallContainerSmallArrayT); 27839 SUITE_ADD_TEST(suite, binarySearchSmallArrayT); 27840 SUITE_ADD_TEST(suite, binarySearchUndefinedSmallArrayT); 27841 SUITE_ADD_TEST(suite, binarySearchBoolSmallArrayT); 27842 SUITE_ADD_TEST(suite, binarySearchDoubleSmallArrayT); 27843 SUITE_ADD_TEST(suite, binarySearchIntSmallArrayT); 27844 SUITE_ADD_TEST(suite, binarySearchSSmallArrayT); 27845 SUITE_ADD_TEST(suite, binarySearchCharSmallArrayT); 27846 SUITE_ADD_TEST(suite, binarySearchDictSmallArrayT); 27847 SUITE_ADD_TEST(suite, binarySearchArraySmallArrayT); 27848 SUITE_ADD_TEST(suite, binarySearchArraycSmallArrayT); 27849 SUITE_ADD_TEST(suite, binarySearchSmallBoolSmallArrayT); 27850 SUITE_ADD_TEST(suite, binarySearchSmallBytesSmallArrayT); 27851 SUITE_ADD_TEST(suite, binarySearchSmallDoubleSmallArrayT); 27852 SUITE_ADD_TEST(suite, binarySearchSmallIntSmallArrayT); 27853 SUITE_ADD_TEST(suite, binarySearchSmallJsonSmallArrayT); 27854 SUITE_ADD_TEST(suite, binarySearchSmallStringSmallArrayT); 27855 SUITE_ADD_TEST(suite, binarySearchSmallContainerSmallArrayT); 27856 SUITE_ADD_TEST(suite, uniqSmallArrayT); 27857 SUITE_ADD_TEST(suite, icHasSmallArrayT); 27858 SUITE_ADD_TEST(suite, icHasSSmallArrayT); 27859 SUITE_ADD_TEST(suite, icHasCharSmallArrayT); 27860 SUITE_ADD_TEST(suite, icHasDictSmallArrayT); 27861 SUITE_ADD_TEST(suite, icHasArraySmallArrayT); 27862 SUITE_ADD_TEST(suite, icHasArraycSmallArrayT); 27863 SUITE_ADD_TEST(suite, icHasSmallJsonSmallArrayT); 27864 SUITE_ADD_TEST(suite, icHasSmallStringSmallArrayT); 27865 SUITE_ADD_TEST(suite, icIndexOfSmallArrayT); 27866 SUITE_ADD_TEST(suite, icIndexOfSSmallArrayT); 27867 SUITE_ADD_TEST(suite, icIndexOfCharSmallArrayT); 27868 SUITE_ADD_TEST(suite, icIndexOfDictSmallArrayT); 27869 SUITE_ADD_TEST(suite, icIndexOfArraySmallArrayT); 27870 SUITE_ADD_TEST(suite, icIndexOfArraycSmallArrayT); 27871 SUITE_ADD_TEST(suite, icIndexOfSmallJsonSmallArrayT); 27872 SUITE_ADD_TEST(suite, icIndexOfSmallStringSmallArrayT); 27873 SUITE_ADD_TEST(suite, icBinarySearchSmallArrayT); 27874 SUITE_ADD_TEST(suite, icBinarySearchSSmallArrayT); 27875 SUITE_ADD_TEST(suite, icBinarySearchCharSmallArrayT); 27876 SUITE_ADD_TEST(suite, icBinarySearchDictSmallArrayT); 27877 SUITE_ADD_TEST(suite, icBinarySearchArraySmallArrayT); 27878 SUITE_ADD_TEST(suite, icBinarySearchArraycSmallArrayT); 27879 SUITE_ADD_TEST(suite, icBinarySearchSmallJsonSmallArrayT); 27880 SUITE_ADD_TEST(suite, icBinarySearchSmallStringSmallArrayT); 27881 SUITE_ADD_TEST(suite, icUniqSmallArrayT); 27882 SUITE_ADD_TEST(suite, compactSmallArrayT); 27883 SUITE_ADD_TEST(suite, isBlankSmallArrayT); 27884 SUITE_ADD_TEST(suite, forEachSmallArrayFT); 27885 SUITE_ADD_TEST(suite, enumerateSmallArrayFT); 27886 SUITE_ADD_TEST(suite, iterStartSmallArrayT); 27887 SUITE_ADD_TEST(suite, iterStartLastSmallArrayT); 27888 SUITE_ADD_TEST(suite, iterStartFromSmallArrayT); 27889 SUITE_ADD_TEST(suite, iterStartFromStepSmallArrayT); 27890 SUITE_ADD_TEST(suite, iterNextSmallArrayT); 27891 SUITE_ADD_TEST(suite, iterElementSmallArrayT); 27892 SUITE_ADD_TEST(suite, iterIndexSmallArrayT); 27893 SUITE_ADD_TEST(suite, iterStepSmallArrayT); 27894 SUITE_ADD_TEST(suite, joinSmallArrayT); 27895 SUITE_ADD_TEST(suite, joinCharSmallArrayT); 27896 SUITE_ADD_TEST(suite, joinSmallJsonSmallArrayT); 27897 SUITE_ADD_TEST(suite, joinSmallStringSmallArrayT); 27898 SUITE_ADD_TEST(suite, joinSSmallArrayT); 27899 SUITE_ADD_TEST(suite, joinCharSSmallArrayT); 27900 SUITE_ADD_TEST(suite, joinSmallJsonSSmallArrayT); 27901 SUITE_ADD_TEST(suite, joinSmallStringSSmallArrayT); 27902 SUITE_ADD_TEST(suite, zipSmallArrayT); 27903 SUITE_ADD_TEST(suite, zipSmallJsonSmallArrayT); 27904 SUITE_ADD_TEST(suite, zipSmallJsonSmallArraySmallArrayT); 27905 SUITE_ADD_TEST(suite, zipSmallJsonSmallJsonSmallArrayT); 27906 SUITE_ADD_TEST(suite, zipSmallJsonCharSmallArrayT); 27907 SUITE_ADD_TEST(suite, zipSmallJsonCCharSmallArrayT); 27908 SUITE_ADD_TEST(suite, zipArraySmallArrayT); 27909 SUITE_ADD_TEST(suite, zipCArraySmallArrayT); 27910 SUITE_ADD_TEST(suite, zipArraySmallJsonSmallArrayT); 27911 SUITE_ADD_TEST(suite, zipCArraySmallJsonSmallArrayT); 27912 SUITE_ADD_TEST(suite, zipCharSmallArrayT); 27913 SUITE_ADD_TEST(suite, zipCCharSmallArrayT); 27914 SUITE_ADD_TEST(suite, zipArrayCharSmallArrayT); 27915 SUITE_ADD_TEST(suite, zipCArrayCharSmallArrayT); 27916 SUITE_ADD_TEST(suite, zipArrayCCharSmallArrayT); 27917 SUITE_ADD_TEST(suite, zipCArrayCCharSmallArrayT); 27918 SUITE_ADD_TEST(suite, logSmallArrayT); 27919 SUITE_ADD_TEST(suite, readTextSmallArrayT); 27920 SUITE_ADD_TEST(suite, readTextSmallJsonSmallArrayT); 27921 SUITE_ADD_TEST(suite, readTextSmallStringSmallArrayT); 27922 SUITE_ADD_TEST(suite, readStreamSmallArrayT); 27923 SUITE_ADD_TEST(suite, writeTextSmallArrayT); 27924 SUITE_ADD_TEST(suite, writeTextSmallJsonSmallArrayT); 27925 SUITE_ADD_TEST(suite, writeTextSmallStringSmallArrayT); 27926 SUITE_ADD_TEST(suite, writeStreamSmallArrayT); 27927 SUITE_ADD_TEST(suite, appendTextSmallArrayT); 27928 SUITE_ADD_TEST(suite, appendTextSmallStringSmallArrayT); 27929 SUITE_ADD_TEST(suite, typeSmallStringSmallArrayT); 27930 SUITE_ADD_TEST(suite, typeSmallStringsSmallArrayT); 27931 SUITE_ADD_TEST(suite, isETypeSmallArrayT); 27932 SUITE_ADD_TEST(suite, isEUndefinedSmallArrayT); 27933 SUITE_ADD_TEST(suite, isEBoolSmallArrayT); 27934 SUITE_ADD_TEST(suite, isEContainerSmallArrayT); 27935 SUITE_ADD_TEST(suite, isEDictSmallArrayT); 27936 SUITE_ADD_TEST(suite, isEDoubleSmallArrayT); 27937 SUITE_ADD_TEST(suite, isEIntSmallArrayT); 27938 SUITE_ADD_TEST(suite, isEStringSmallArrayT); 27939 SUITE_ADD_TEST(suite, isEFaststringSmallArrayT); 27940 SUITE_ADD_TEST(suite, isEArraySmallArrayT); 27941 SUITE_ADD_TEST(suite, isEBytesSmallArrayT); 27942 SUITE_ADD_TEST(suite, areAllETypeSmallArrayT); 27943 SUITE_ADD_TEST(suite, areAllEUndefinedSmallArrayT); 27944 SUITE_ADD_TEST(suite, areAllEBoolSmallArrayT); 27945 SUITE_ADD_TEST(suite, areAllEContainerSmallArrayT); 27946 SUITE_ADD_TEST(suite, areAllEDictSmallArrayT); 27947 SUITE_ADD_TEST(suite, areAllEDoubleSmallArrayT); 27948 SUITE_ADD_TEST(suite, areAllEIntSmallArrayT); 27949 SUITE_ADD_TEST(suite, areAllEStringSmallArrayT); 27950 SUITE_ADD_TEST(suite, areAllEFaststringSmallArrayT); 27951 SUITE_ADD_TEST(suite, areAllEArraySmallArrayT); 27952 SUITE_ADD_TEST(suite, areAllEBytesSmallArrayT); 27953 SUITE_ADD_TEST(suite, allocSmallArrayGT); 27954 SUITE_ADD_TEST(suite, duplicateSmallArrayGT); 27955 SUITE_ADD_TEST(suite, freeSmallArrayGT); 27956 SUITE_ADD_TEST(suite, fromArraySmallArrayGT); 27957 SUITE_ADD_TEST(suite, fromCArraySmallArrayGT); 27958 SUITE_ADD_TEST(suite, setFromSmallArrayGT); 27959 SUITE_ADD_TEST(suite, setFromCSmallArrayGT); 27960 SUITE_ADD_TEST(suite, pushSmallArrayGT); 27961 SUITE_ADD_TEST(suite, pushUndefinedSmallArrayGT); 27962 SUITE_ADD_TEST(suite, pushBoolSmallArrayGT); 27963 SUITE_ADD_TEST(suite, pushDoubleSmallArrayGT); 27964 SUITE_ADD_TEST(suite, pushIntSmallArrayGT); 27965 SUITE_ADD_TEST(suite, pushSSmallArrayGT); 27966 SUITE_ADD_TEST(suite, pushCharSmallArrayGT); 27967 SUITE_ADD_TEST(suite, pushDictSmallArrayGT); 27968 SUITE_ADD_TEST(suite, pushArraySmallArrayGT); 27969 SUITE_ADD_TEST(suite, pushArraycSmallArrayGT); 27970 SUITE_ADD_TEST(suite, pushCArraycSmallArrayGT); 27971 SUITE_ADD_TEST(suite, pushVoidSmallArrayGT); 27972 SUITE_ADD_TEST(suite, pushSmallBoolSmallArrayGT); 27973 SUITE_ADD_TEST(suite, pushSmallBytesSmallArrayGT); 27974 SUITE_ADD_TEST(suite, pushSmallDoubleSmallArrayGT); 27975 SUITE_ADD_TEST(suite, pushSmallIntSmallArrayGT); 27976 SUITE_ADD_TEST(suite, pushSmallJsonSmallArrayGT); 27977 SUITE_ADD_TEST(suite, pushSmallStringSmallArrayGT); 27978 SUITE_ADD_TEST(suite, pushSmallContainerSmallArrayGT); 27979 SUITE_ADD_TEST(suite, pushNFreeSmallArrayGT); 27980 SUITE_ADD_TEST(suite, pushNFreeUndefinedSmallArrayGT); 27981 SUITE_ADD_TEST(suite, pushNFreeSSmallArrayGT); 27982 SUITE_ADD_TEST(suite, pushNFreeDictSmallArrayGT); 27983 SUITE_ADD_TEST(suite, pushNFreeArraySmallArrayGT); 27984 SUITE_ADD_TEST(suite, pushNFreeArraycSmallArrayGT); 27985 SUITE_ADD_TEST(suite, pushNFreeSmallBoolSmallArrayGT); 27986 SUITE_ADD_TEST(suite, pushNFreeSmallBytesSmallArrayGT); 27987 SUITE_ADD_TEST(suite, pushNFreeSmallDoubleSmallArrayGT); 27988 SUITE_ADD_TEST(suite, pushNFreeSmallIntSmallArrayGT); 27989 SUITE_ADD_TEST(suite, pushNFreeSmallJsonSmallArrayGT); 27990 SUITE_ADD_TEST(suite, pushNFreeSmallStringSmallArrayGT); 27991 SUITE_ADD_TEST(suite, pushNFreeSmallContainerSmallArrayGT); 27992 SUITE_ADD_TEST(suite, popSmallArrayGT); 27993 SUITE_ADD_TEST(suite, popUndefinedSmallArrayGT); 27994 SUITE_ADD_TEST(suite, popBoolSmallArrayGT); 27995 SUITE_ADD_TEST(suite, popDoubleSmallArrayGT); 27996 SUITE_ADD_TEST(suite, popIntSmallArrayGT); 27997 SUITE_ADD_TEST(suite, popInt32SmallArrayGT); 27998 SUITE_ADD_TEST(suite, popUintSmallArrayGT); 27999 SUITE_ADD_TEST(suite, popUint32SmallArrayGT); 28000 SUITE_ADD_TEST(suite, popSSmallArrayGT); 28001 SUITE_ADD_TEST(suite, popDictSmallArrayGT); 28002 SUITE_ADD_TEST(suite, popArraySmallArrayGT); 28003 SUITE_ADD_TEST(suite, popSmallBoolSmallArrayGT); 28004 SUITE_ADD_TEST(suite, popSmallBytesSmallArrayGT); 28005 SUITE_ADD_TEST(suite, popSmallDoubleSmallArrayGT); 28006 SUITE_ADD_TEST(suite, popSmallIntSmallArrayGT); 28007 SUITE_ADD_TEST(suite, popSmallJsonSmallArrayGT); 28008 SUITE_ADD_TEST(suite, popSmallStringSmallArrayGT); 28009 SUITE_ADD_TEST(suite, popVoidSmallArrayGT); 28010 SUITE_ADD_TEST(suite, popSmallContainerSmallArrayGT); 28011 SUITE_ADD_TEST(suite, prependSmallArrayGT); 28012 SUITE_ADD_TEST(suite, prependUndefinedSmallArrayGT); 28013 SUITE_ADD_TEST(suite, prependBoolSmallArrayGT); 28014 SUITE_ADD_TEST(suite, prependDoubleSmallArrayGT); 28015 SUITE_ADD_TEST(suite, prependIntSmallArrayGT); 28016 SUITE_ADD_TEST(suite, prependSSmallArrayGT); 28017 SUITE_ADD_TEST(suite, prependCharSmallArrayGT); 28018 SUITE_ADD_TEST(suite, prependDictSmallArrayGT); 28019 SUITE_ADD_TEST(suite, prependArraySmallArrayGT); 28020 SUITE_ADD_TEST(suite, prependArraycSmallArrayGT); 28021 SUITE_ADD_TEST(suite, prependCArraycSmallArrayGT); 28022 SUITE_ADD_TEST(suite, prependVoidSmallArrayGT); 28023 SUITE_ADD_TEST(suite, prependSmallBoolSmallArrayGT); 28024 SUITE_ADD_TEST(suite, prependSmallBytesSmallArrayGT); 28025 SUITE_ADD_TEST(suite, prependSmallDoubleSmallArrayGT); 28026 SUITE_ADD_TEST(suite, prependSmallIntSmallArrayGT); 28027 SUITE_ADD_TEST(suite, prependSmallJsonSmallArrayGT); 28028 SUITE_ADD_TEST(suite, prependSmallStringSmallArrayGT); 28029 SUITE_ADD_TEST(suite, prependSmallContainerSmallArrayGT); 28030 SUITE_ADD_TEST(suite, prependNFreeSmallArrayGT); 28031 SUITE_ADD_TEST(suite, prependNFreeUndefinedSmallArrayGT); 28032 SUITE_ADD_TEST(suite, prependNFreeSSmallArrayGT); 28033 SUITE_ADD_TEST(suite, prependNFreeDictSmallArrayGT); 28034 SUITE_ADD_TEST(suite, prependNFreeArraySmallArrayGT); 28035 SUITE_ADD_TEST(suite, prependNFreeArraycSmallArrayGT); 28036 SUITE_ADD_TEST(suite, prependNFreeSmallBoolSmallArrayGT); 28037 SUITE_ADD_TEST(suite, prependNFreeSmallBytesSmallArrayGT); 28038 SUITE_ADD_TEST(suite, prependNFreeSmallDoubleSmallArrayGT); 28039 SUITE_ADD_TEST(suite, prependNFreeSmallIntSmallArrayGT); 28040 SUITE_ADD_TEST(suite, prependNFreeSmallJsonSmallArrayGT); 28041 SUITE_ADD_TEST(suite, prependNFreeSmallStringSmallArrayGT); 28042 SUITE_ADD_TEST(suite, prependNFreeSmallContainerSmallArrayGT); 28043 SUITE_ADD_TEST(suite, dequeueSmallArrayGT); 28044 SUITE_ADD_TEST(suite, dequeueUndefinedSmallArrayGT); 28045 SUITE_ADD_TEST(suite, dequeueBoolSmallArrayGT); 28046 SUITE_ADD_TEST(suite, dequeueDoubleSmallArrayGT); 28047 SUITE_ADD_TEST(suite, dequeueIntSmallArrayGT); 28048 SUITE_ADD_TEST(suite, dequeueInt32SmallArrayGT); 28049 SUITE_ADD_TEST(suite, dequeueUintSmallArrayGT); 28050 SUITE_ADD_TEST(suite, dequeueUint32SmallArrayGT); 28051 SUITE_ADD_TEST(suite, dequeueSSmallArrayGT); 28052 SUITE_ADD_TEST(suite, dequeueDictSmallArrayGT); 28053 SUITE_ADD_TEST(suite, dequeueArraySmallArrayGT); 28054 SUITE_ADD_TEST(suite, dequeueSmallBoolSmallArrayGT); 28055 SUITE_ADD_TEST(suite, dequeueSmallBytesSmallArrayGT); 28056 SUITE_ADD_TEST(suite, dequeueSmallDoubleSmallArrayGT); 28057 SUITE_ADD_TEST(suite, dequeueSmallIntSmallArrayGT); 28058 SUITE_ADD_TEST(suite, dequeueSmallJsonSmallArrayGT); 28059 SUITE_ADD_TEST(suite, dequeueSmallStringSmallArrayGT); 28060 SUITE_ADD_TEST(suite, dequeueVoidSmallArrayGT); 28061 SUITE_ADD_TEST(suite, dequeueSmallContainerSmallArrayGT); 28062 SUITE_ADD_TEST(suite, getAtSmallArrayGT); 28063 SUITE_ADD_TEST(suite, getAtUndefinedSmallArrayGT); 28064 SUITE_ADD_TEST(suite, getAtBoolSmallArrayGT); 28065 SUITE_ADD_TEST(suite, getAtBoolPSmallArrayGT); 28066 SUITE_ADD_TEST(suite, getAtDoubleSmallArrayGT); 28067 SUITE_ADD_TEST(suite, getAtDoublePSmallArrayGT); 28068 SUITE_ADD_TEST(suite, getAtIntSmallArrayGT); 28069 SUITE_ADD_TEST(suite, getAtIntPSmallArrayGT); 28070 SUITE_ADD_TEST(suite, getAtInt32SmallArrayGT); 28071 SUITE_ADD_TEST(suite, getAtInt32PSmallArrayGT); 28072 SUITE_ADD_TEST(suite, getAtUintSmallArrayGT); 28073 SUITE_ADD_TEST(suite, getAtUintPSmallArrayGT); 28074 SUITE_ADD_TEST(suite, getAtUint32SmallArrayGT); 28075 SUITE_ADD_TEST(suite, getAtUint32PSmallArrayGT); 28076 SUITE_ADD_TEST(suite, getAtSSmallArrayGT); 28077 SUITE_ADD_TEST(suite, getAtDictSmallArrayGT); 28078 SUITE_ADD_TEST(suite, getAtArraySmallArrayGT); 28079 SUITE_ADD_TEST(suite, getAtSmallBoolSmallArrayGT); 28080 SUITE_ADD_TEST(suite, getAtSmallBytesSmallArrayGT); 28081 SUITE_ADD_TEST(suite, getAtSmallDoubleSmallArrayGT); 28082 SUITE_ADD_TEST(suite, getAtSmallIntSmallArrayGT); 28083 SUITE_ADD_TEST(suite, getAtSmallJsonSmallArrayGT); 28084 SUITE_ADD_TEST(suite, getAtSmallStringSmallArrayGT); 28085 SUITE_ADD_TEST(suite, getAtVoidSmallArrayGT); 28086 SUITE_ADD_TEST(suite, getAtSmallContainerSmallArrayGT); 28087 SUITE_ADD_TEST(suite, getAtNDupSmallArrayGT); 28088 SUITE_ADD_TEST(suite, getAtNDupUndefinedSmallArrayGT); 28089 SUITE_ADD_TEST(suite, getAtNDupBoolSmallArrayGT); 28090 SUITE_ADD_TEST(suite, getAtNDupDoubleSmallArrayGT); 28091 SUITE_ADD_TEST(suite, getAtNDupIntSmallArrayGT); 28092 SUITE_ADD_TEST(suite, getAtNDupInt32SmallArrayGT); 28093 SUITE_ADD_TEST(suite, getAtNDupUintSmallArrayGT); 28094 SUITE_ADD_TEST(suite, getAtNDupUint32SmallArrayGT); 28095 SUITE_ADD_TEST(suite, getAtNDupSSmallArrayGT); 28096 SUITE_ADD_TEST(suite, getAtNDupDictSmallArrayGT); 28097 SUITE_ADD_TEST(suite, getAtNDupArraySmallArrayGT); 28098 SUITE_ADD_TEST(suite, getAtNDupSmallBoolSmallArrayGT); 28099 SUITE_ADD_TEST(suite, getAtNDupSmallBytesSmallArrayGT); 28100 SUITE_ADD_TEST(suite, getAtNDupSmallDoubleSmallArrayGT); 28101 SUITE_ADD_TEST(suite, getAtNDupSmallIntSmallArrayGT); 28102 SUITE_ADD_TEST(suite, getAtNDupSmallJsonSmallArrayGT); 28103 SUITE_ADD_TEST(suite, getAtNDupSmallStringSmallArrayGT); 28104 SUITE_ADD_TEST(suite, getAtNDupVoidSmallArrayGT); 28105 SUITE_ADD_TEST(suite, getAtNDupSmallContainerSmallArrayGT); 28106 SUITE_ADD_TEST(suite, setAtSmallArrayGT); 28107 SUITE_ADD_TEST(suite, setAtUndefinedSmallArrayGT); 28108 SUITE_ADD_TEST(suite, setAtBoolSmallArrayGT); 28109 SUITE_ADD_TEST(suite, setAtDoubleSmallArrayGT); 28110 SUITE_ADD_TEST(suite, setAtIntSmallArrayGT); 28111 SUITE_ADD_TEST(suite, setAtSSmallArrayGT); 28112 SUITE_ADD_TEST(suite, setAtCharSmallArrayGT); 28113 SUITE_ADD_TEST(suite, setAtDictSmallArrayGT); 28114 SUITE_ADD_TEST(suite, setAtArraySmallArrayGT); 28115 SUITE_ADD_TEST(suite, setAtArraycSmallArrayGT); 28116 SUITE_ADD_TEST(suite, setAtCArraycSmallArrayGT); 28117 SUITE_ADD_TEST(suite, setAtVoidSmallArrayGT); 28118 SUITE_ADD_TEST(suite, setAtSmallBoolSmallArrayGT); 28119 SUITE_ADD_TEST(suite, setAtSmallBytesSmallArrayGT); 28120 SUITE_ADD_TEST(suite, setAtSmallDoubleSmallArrayGT); 28121 SUITE_ADD_TEST(suite, setAtSmallIntSmallArrayGT); 28122 SUITE_ADD_TEST(suite, setAtSmallJsonSmallArrayGT); 28123 SUITE_ADD_TEST(suite, setAtSmallStringSmallArrayGT); 28124 SUITE_ADD_TEST(suite, setAtSmallContainerSmallArrayGT); 28125 SUITE_ADD_TEST(suite, setAtNFreeSmallArrayGT); 28126 SUITE_ADD_TEST(suite, setAtNFreeUndefinedSmallArrayGT); 28127 SUITE_ADD_TEST(suite, setAtNFreeSSmallArrayGT); 28128 SUITE_ADD_TEST(suite, setAtNFreeDictSmallArrayGT); 28129 SUITE_ADD_TEST(suite, setAtNFreeArraySmallArrayGT); 28130 SUITE_ADD_TEST(suite, setAtNFreeArraycSmallArrayGT); 28131 SUITE_ADD_TEST(suite, setAtNFreeSmallBoolSmallArrayGT); 28132 SUITE_ADD_TEST(suite, setAtNFreeSmallBytesSmallArrayGT); 28133 SUITE_ADD_TEST(suite, setAtNFreeSmallDoubleSmallArrayGT); 28134 SUITE_ADD_TEST(suite, setAtNFreeSmallIntSmallArrayGT); 28135 SUITE_ADD_TEST(suite, setAtNFreeSmallJsonSmallArrayGT); 28136 SUITE_ADD_TEST(suite, setAtNFreeSmallStringSmallArrayGT); 28137 SUITE_ADD_TEST(suite, setAtNFreeSmallContainerSmallArrayGT); 28138 SUITE_ADD_TEST(suite, setPAtDictSmallArrayGT); 28139 SUITE_ADD_TEST(suite, setPAtArraySmallArrayGT); 28140 SUITE_ADD_TEST(suite, setPAtSmallJsonSmallArrayGT); 28141 SUITE_ADD_TEST(suite, setPAtSmallStringSmallArrayGT); 28142 SUITE_ADD_TEST(suite, setPAtNFreeDictSmallArrayGT); 28143 SUITE_ADD_TEST(suite, setPAtNFreeArraySmallArrayGT); 28144 SUITE_ADD_TEST(suite, setPAtNFreeSmallJsonSmallArrayGT); 28145 SUITE_ADD_TEST(suite, setPAtNFreeSmallStringSmallArrayGT); 28146 SUITE_ADD_TEST(suite, getNumSmallArrayGT); 28147 SUITE_ADD_TEST(suite, reverseSmallArrayGT); 28148 SUITE_ADD_TEST(suite, appendSmallArrayGT); 28149 SUITE_ADD_TEST(suite, appendSmallJsonSmallArrayGT); 28150 SUITE_ADD_TEST(suite, appendNSmashSmallArrayGT); 28151 SUITE_ADD_TEST(suite, appendNSmashSmallJsonSmallArrayGT); 28152 SUITE_ADD_TEST(suite, appendArraySmallArrayGT); 28153 SUITE_ADD_TEST(suite, appendNSmashArraySmallArrayGT); 28154 SUITE_ADD_TEST(suite, appendCArraySmallArrayGT); 28155 SUITE_ADD_TEST(suite, shiftSmallArrayGT); 28156 SUITE_ADD_TEST(suite, shiftSmallJsonSmallArrayGT); 28157 SUITE_ADD_TEST(suite, shiftNSmashSmallArrayGT); 28158 SUITE_ADD_TEST(suite, shiftNSmashSmallJsonSmallArrayGT); 28159 SUITE_ADD_TEST(suite, addSmallArrayGT); 28160 SUITE_ADD_TEST(suite, sliceSmallArrayGT); 28161 SUITE_ADD_TEST(suite, cropSmallArrayGT); 28162 SUITE_ADD_TEST(suite, cropElemSmallArrayGT); 28163 SUITE_ADD_TEST(suite, cropElemUndefinedSmallArrayGT); 28164 SUITE_ADD_TEST(suite, cropElemBoolSmallArrayGT); 28165 SUITE_ADD_TEST(suite, cropElemDoubleSmallArrayGT); 28166 SUITE_ADD_TEST(suite, cropElemIntSmallArrayGT); 28167 SUITE_ADD_TEST(suite, cropElemInt32SmallArrayGT); 28168 SUITE_ADD_TEST(suite, cropElemUintSmallArrayGT); 28169 SUITE_ADD_TEST(suite, cropElemUint32SmallArrayGT); 28170 SUITE_ADD_TEST(suite, cropElemSSmallArrayGT); 28171 SUITE_ADD_TEST(suite, cropElemDictSmallArrayGT); 28172 SUITE_ADD_TEST(suite, cropElemArraySmallArrayGT); 28173 SUITE_ADD_TEST(suite, cropElemSmallBoolSmallArrayGT); 28174 SUITE_ADD_TEST(suite, cropElemSmallBytesSmallArrayGT); 28175 SUITE_ADD_TEST(suite, cropElemSmallDoubleSmallArrayGT); 28176 SUITE_ADD_TEST(suite, cropElemSmallIntSmallArrayGT); 28177 SUITE_ADD_TEST(suite, cropElemSmallJsonSmallArrayGT); 28178 SUITE_ADD_TEST(suite, cropElemSmallStringSmallArrayGT); 28179 SUITE_ADD_TEST(suite, cropElemVoidSmallArrayGT); 28180 SUITE_ADD_TEST(suite, cropElemSmallContainerSmallArrayGT); 28181 SUITE_ADD_TEST(suite, copySmallArrayGT); 28182 SUITE_ADD_TEST(suite, insertSmallArrayGT); 28183 SUITE_ADD_TEST(suite, insertSmallJsonSmallArrayGT); 28184 SUITE_ADD_TEST(suite, insertNSmashSmallArrayGT); 28185 SUITE_ADD_TEST(suite, insertNSmashSmallJsonSmallArrayGT); 28186 SUITE_ADD_TEST(suite, injectSmallArrayGT); 28187 SUITE_ADD_TEST(suite, injectUndefinedSmallArrayGT); 28188 SUITE_ADD_TEST(suite, injectBoolSmallArrayGT); 28189 SUITE_ADD_TEST(suite, injectDoubleSmallArrayGT); 28190 SUITE_ADD_TEST(suite, injectIntSmallArrayGT); 28191 SUITE_ADD_TEST(suite, injectSSmallArrayGT); 28192 SUITE_ADD_TEST(suite, injectCharSmallArrayGT); 28193 SUITE_ADD_TEST(suite, injectDictSmallArrayGT); 28194 SUITE_ADD_TEST(suite, injectArraySmallArrayGT); 28195 SUITE_ADD_TEST(suite, injectArraycSmallArrayGT); 28196 SUITE_ADD_TEST(suite, injectCArraycSmallArrayGT); 28197 SUITE_ADD_TEST(suite, injectVoidSmallArrayGT); 28198 SUITE_ADD_TEST(suite, injectSmallBoolSmallArrayGT); 28199 SUITE_ADD_TEST(suite, injectSmallBytesSmallArrayGT); 28200 SUITE_ADD_TEST(suite, injectSmallDoubleSmallArrayGT); 28201 SUITE_ADD_TEST(suite, injectSmallIntSmallArrayGT); 28202 SUITE_ADD_TEST(suite, injectSmallJsonSmallArrayGT); 28203 SUITE_ADD_TEST(suite, injectSmallStringSmallArrayGT); 28204 SUITE_ADD_TEST(suite, injectSmallContainerSmallArrayGT); 28205 SUITE_ADD_TEST(suite, injectNFreeSmallArrayGT); 28206 SUITE_ADD_TEST(suite, injectNFreeUndefinedSmallArrayGT); 28207 SUITE_ADD_TEST(suite, injectNFreeSSmallArrayGT); 28208 SUITE_ADD_TEST(suite, injectNFreeDictSmallArrayGT); 28209 SUITE_ADD_TEST(suite, injectNFreeArraySmallArrayGT); 28210 SUITE_ADD_TEST(suite, injectNFreeArraycSmallArrayGT); 28211 SUITE_ADD_TEST(suite, injectNFreeSmallBoolSmallArrayGT); 28212 SUITE_ADD_TEST(suite, injectNFreeSmallBytesSmallArrayGT); 28213 SUITE_ADD_TEST(suite, injectNFreeSmallDoubleSmallArrayGT); 28214 SUITE_ADD_TEST(suite, injectNFreeSmallIntSmallArrayGT); 28215 SUITE_ADD_TEST(suite, injectNFreeSmallJsonSmallArrayGT); 28216 SUITE_ADD_TEST(suite, injectNFreeSmallStringSmallArrayGT); 28217 SUITE_ADD_TEST(suite, injectNFreeSmallContainerSmallArrayGT); 28218 SUITE_ADD_TEST(suite, delSmallArrayGT); 28219 SUITE_ADD_TEST(suite, delElemSmallArrayGT); 28220 SUITE_ADD_TEST(suite, removeSmallArrayGT); 28221 SUITE_ADD_TEST(suite, removeElemSmallArrayGT); 28222 SUITE_ADD_TEST(suite, sortSmallArrayGT); 28223 SUITE_ADD_TEST(suite, sortFSmallArrayGT); 28224 SUITE_ADD_TEST(suite, icSortSmallArrayGT); 28225 SUITE_ADD_TEST(suite, equalSmallArrayGT); 28226 SUITE_ADD_TEST(suite, equalSmallArraySmallJsonGT); 28227 SUITE_ADD_TEST(suite, equalSmallArrayArrayGT); 28228 SUITE_ADD_TEST(suite, equalSmallArrayCArrayGT); 28229 SUITE_ADD_TEST(suite, equalSmallArrayBaseGT); 28230 SUITE_ADD_TEST(suite, icEqualSmallArrayGT); 28231 SUITE_ADD_TEST(suite, icEqualSmallArraySmallJsonGT); 28232 SUITE_ADD_TEST(suite, icEqualSmallArrayArrayGT); 28233 SUITE_ADD_TEST(suite, icEqualSmallArrayCArrayGT); 28234 SUITE_ADD_TEST(suite, icEqualSmallArrayBaseGT); 28235 SUITE_ADD_TEST(suite, lenSmallArrayGT); 28236 SUITE_ADD_TEST(suite, trimSmallArrayGT); 28237 SUITE_ADD_TEST(suite, hasSmallArrayGT); 28238 SUITE_ADD_TEST(suite, hasUndefinedSmallArrayGT); 28239 SUITE_ADD_TEST(suite, hasBoolSmallArrayGT); 28240 SUITE_ADD_TEST(suite, hasDoubleSmallArrayGT); 28241 SUITE_ADD_TEST(suite, hasIntSmallArrayGT); 28242 SUITE_ADD_TEST(suite, hasSSmallArrayGT); 28243 SUITE_ADD_TEST(suite, hasCharSmallArrayGT); 28244 SUITE_ADD_TEST(suite, hasDictSmallArrayGT); 28245 SUITE_ADD_TEST(suite, hasArraySmallArrayGT); 28246 SUITE_ADD_TEST(suite, hasArraycSmallArrayGT); 28247 SUITE_ADD_TEST(suite, hasCArraycSmallArrayGT); 28248 SUITE_ADD_TEST(suite, hasSmallBoolSmallArrayGT); 28249 SUITE_ADD_TEST(suite, hasSmallBytesSmallArrayGT); 28250 SUITE_ADD_TEST(suite, hasSmallDoubleSmallArrayGT); 28251 SUITE_ADD_TEST(suite, hasSmallIntSmallArrayGT); 28252 SUITE_ADD_TEST(suite, hasSmallJsonSmallArrayGT); 28253 SUITE_ADD_TEST(suite, hasSmallStringSmallArrayGT); 28254 SUITE_ADD_TEST(suite, hasSmallContainerSmallArrayGT); 28255 SUITE_ADD_TEST(suite, indexOfSmallArrayGT); 28256 SUITE_ADD_TEST(suite, indexOfUndefinedSmallArrayGT); 28257 SUITE_ADD_TEST(suite, indexOfBoolSmallArrayGT); 28258 SUITE_ADD_TEST(suite, indexOfDoubleSmallArrayGT); 28259 SUITE_ADD_TEST(suite, indexOfIntSmallArrayGT); 28260 SUITE_ADD_TEST(suite, indexOfSSmallArrayGT); 28261 SUITE_ADD_TEST(suite, indexOfCharSmallArrayGT); 28262 SUITE_ADD_TEST(suite, indexOfDictSmallArrayGT); 28263 SUITE_ADD_TEST(suite, indexOfArraySmallArrayGT); 28264 SUITE_ADD_TEST(suite, indexOfArraycSmallArrayGT); 28265 SUITE_ADD_TEST(suite, indexOfCArraycSmallArrayGT); 28266 SUITE_ADD_TEST(suite, indexOfSmallBoolSmallArrayGT); 28267 SUITE_ADD_TEST(suite, indexOfSmallBytesSmallArrayGT); 28268 SUITE_ADD_TEST(suite, indexOfSmallDoubleSmallArrayGT); 28269 SUITE_ADD_TEST(suite, indexOfSmallIntSmallArrayGT); 28270 SUITE_ADD_TEST(suite, indexOfSmallJsonSmallArrayGT); 28271 SUITE_ADD_TEST(suite, indexOfSmallStringSmallArrayGT); 28272 SUITE_ADD_TEST(suite, indexOfSmallContainerSmallArrayGT); 28273 SUITE_ADD_TEST(suite, binarySearchSmallArrayGT); 28274 SUITE_ADD_TEST(suite, binarySearchUndefinedSmallArrayGT); 28275 SUITE_ADD_TEST(suite, binarySearchBoolSmallArrayGT); 28276 SUITE_ADD_TEST(suite, binarySearchDoubleSmallArrayGT); 28277 SUITE_ADD_TEST(suite, binarySearchIntSmallArrayGT); 28278 SUITE_ADD_TEST(suite, binarySearchSSmallArrayGT); 28279 SUITE_ADD_TEST(suite, binarySearchCharSmallArrayGT); 28280 SUITE_ADD_TEST(suite, binarySearchDictSmallArrayGT); 28281 SUITE_ADD_TEST(suite, binarySearchArraySmallArrayGT); 28282 SUITE_ADD_TEST(suite, binarySearchArraycSmallArrayGT); 28283 SUITE_ADD_TEST(suite, binarySearchCArraycSmallArrayGT); 28284 SUITE_ADD_TEST(suite, binarySearchSmallBoolSmallArrayGT); 28285 SUITE_ADD_TEST(suite, binarySearchSmallBytesSmallArrayGT); 28286 SUITE_ADD_TEST(suite, binarySearchSmallDoubleSmallArrayGT); 28287 SUITE_ADD_TEST(suite, binarySearchSmallIntSmallArrayGT); 28288 SUITE_ADD_TEST(suite, binarySearchSmallJsonSmallArrayGT); 28289 SUITE_ADD_TEST(suite, binarySearchSmallStringSmallArrayGT); 28290 SUITE_ADD_TEST(suite, binarySearchSmallContainerSmallArrayGT); 28291 SUITE_ADD_TEST(suite, uniqSmallArrayGT); 28292 SUITE_ADD_TEST(suite, icHasSmallArrayGT); 28293 SUITE_ADD_TEST(suite, icHasSSmallArrayGT); 28294 SUITE_ADD_TEST(suite, icHasCharSmallArrayGT); 28295 SUITE_ADD_TEST(suite, icHasDictSmallArrayGT); 28296 SUITE_ADD_TEST(suite, icHasArraySmallArrayGT); 28297 SUITE_ADD_TEST(suite, icHasArraycSmallArrayGT); 28298 SUITE_ADD_TEST(suite, icHasCArraycSmallArrayGT); 28299 SUITE_ADD_TEST(suite, icHasSmallJsonSmallArrayGT); 28300 SUITE_ADD_TEST(suite, icHasSmallStringSmallArrayGT); 28301 SUITE_ADD_TEST(suite, icIndexOfSmallArrayGT); 28302 SUITE_ADD_TEST(suite, icIndexOfSSmallArrayGT); 28303 SUITE_ADD_TEST(suite, icIndexOfCharSmallArrayGT); 28304 SUITE_ADD_TEST(suite, icIndexOfDictSmallArrayGT); 28305 SUITE_ADD_TEST(suite, icIndexOfArraySmallArrayGT); 28306 SUITE_ADD_TEST(suite, icIndexOfArraycSmallArrayGT); 28307 SUITE_ADD_TEST(suite, icIndexOfCArraycSmallArrayGT); 28308 SUITE_ADD_TEST(suite, icIndexOfSmallJsonSmallArrayGT); 28309 SUITE_ADD_TEST(suite, icIndexOfSmallStringSmallArrayGT); 28310 SUITE_ADD_TEST(suite, icBinarySearchSmallArrayGT); 28311 SUITE_ADD_TEST(suite, icBinarySearchSSmallArrayGT); 28312 SUITE_ADD_TEST(suite, icBinarySearchCharSmallArrayGT); 28313 SUITE_ADD_TEST(suite, icBinarySearchDictSmallArrayGT); 28314 SUITE_ADD_TEST(suite, icBinarySearchArraySmallArrayGT); 28315 SUITE_ADD_TEST(suite, icBinarySearchArraycSmallArrayGT); 28316 SUITE_ADD_TEST(suite, icBinarySearchCArraycSmallArrayGT); 28317 SUITE_ADD_TEST(suite, icBinarySearchSmallJsonSmallArrayGT); 28318 SUITE_ADD_TEST(suite, icBinarySearchSmallStringSmallArrayGT); 28319 SUITE_ADD_TEST(suite, icUniqSmallArrayGT); 28320 SUITE_ADD_TEST(suite, compactSmallArrayGT); 28321 SUITE_ADD_TEST(suite, emptySmallArrayGT); 28322 SUITE_ADD_TEST(suite, isEmptySmallArrayGT); 28323 SUITE_ADD_TEST(suite, isBlankSmallArrayGT); 28324 SUITE_ADD_TEST(suite, joinSmallArrayGT); 28325 SUITE_ADD_TEST(suite, joinCharSmallArrayGT); 28326 SUITE_ADD_TEST(suite, joinSmallJsonSmallArrayGT); 28327 SUITE_ADD_TEST(suite, joinSmallStringSmallArrayGT); 28328 SUITE_ADD_TEST(suite, joinSSmallArrayGT); 28329 SUITE_ADD_TEST(suite, joinCharSSmallArrayGT); 28330 SUITE_ADD_TEST(suite, joinSmallJsonSSmallArrayGT); 28331 SUITE_ADD_TEST(suite, joinSmallStringSSmallArrayGT); 28332 SUITE_ADD_TEST(suite, zipSmallArrayGT); 28333 SUITE_ADD_TEST(suite, zipSmallJsonSmallArrayGT); 28334 SUITE_ADD_TEST(suite, zipSmallJsonSmallArraySmallArrayGT); 28335 SUITE_ADD_TEST(suite, zipSmallJsonSmallJsonSmallArrayGT); 28336 SUITE_ADD_TEST(suite, zipSmallJsonCharSmallArrayGT); 28337 SUITE_ADD_TEST(suite, zipSmallJsonCCharSmallArrayGT); 28338 SUITE_ADD_TEST(suite, zipArraySmallArrayGT); 28339 SUITE_ADD_TEST(suite, zipCArraySmallArrayGT); 28340 SUITE_ADD_TEST(suite, zipArraySmallJsonSmallArrayGT); 28341 SUITE_ADD_TEST(suite, zipCArraySmallJsonSmallArrayGT); 28342 SUITE_ADD_TEST(suite, zipCharSmallArrayGT); 28343 SUITE_ADD_TEST(suite, zipCCharSmallArrayGT); 28344 SUITE_ADD_TEST(suite, zipArrayCharSmallArrayGT); 28345 SUITE_ADD_TEST(suite, zipArrayCCharSmallArrayGT); 28346 SUITE_ADD_TEST(suite, zipCArrayCharSmallArrayGT); 28347 SUITE_ADD_TEST(suite, zipCArrayCCharSmallArrayGT); 28348 SUITE_ADD_TEST(suite, logSmallArrayGT); 28349 SUITE_ADD_TEST(suite, readTextSmallArrayGT); 28350 SUITE_ADD_TEST(suite, readTextSmallJsonSmallArrayGT); 28351 SUITE_ADD_TEST(suite, readTextSmallStringSmallArrayGT); 28352 SUITE_ADD_TEST(suite, readStreamSmallArrayGT); 28353 SUITE_ADD_TEST(suite, writeTextSmallArrayGT); 28354 SUITE_ADD_TEST(suite, writeTextSmallJsonSmallArrayGT); 28355 SUITE_ADD_TEST(suite, writeTextSmallStringSmallArrayGT); 28356 SUITE_ADD_TEST(suite, writeStreamSmallArrayGT); 28357 SUITE_ADD_TEST(suite, appendTextSmallArrayGT); 28358 SUITE_ADD_TEST(suite, appendTextSmallStringSmallArrayGT); 28359 SUITE_ADD_TEST(suite, typeSmallStringSmallArrayGT); 28360 SUITE_ADD_TEST(suite, typeSmallStringsSmallArrayGT); 28361 SUITE_ADD_TEST(suite, cSmallArrayT); 28362 28363 28364 CuSuiteRun(suite); 28365 CuSuiteDetails(suite, output); 28366 printf ("%s\n", output->buffer); 28367 return suite->failCount; 28368 }