libsheepy

libsheepyCSmallJsonTestMem.c (1457247B)

---

 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 
 #define ck_assert_str_eq(a,b) a;b;
 #define ck_assert_str_ne(a,b) a;b;
 #define ck_assert_ptr_eq(a,b) a;b;
 #define ck_assert_ptr_ne(a,b) a;b;
 #define ck_assert_uint_eq(a,b) a;b;
 #define ck_assert_uint_ne(a,b) a;b;
 #define ck_assert_int_eq(a,b) a;b;
 #define ck_assert_int_ne(a,b) a;b;
 #define ck_assert(a) a;
 
 
 #include "../libsheepy.h"
 #include "../libsheepyObject.h"
 
 #ifdef __GNUC__
 #define UNUSED __attribute__ ((unused))
 #else
 #define UNUSED
 #endif
 
 // TODO redirect stderr
 
 
 void createSJFT(void) {
 
   smallJsont* r;
 
   r = createSJ("a", "bb");
   ck_assert_ptr_ne(r, NULL);
   char *s      = toStringO(r);
   ck_assert_str_eq(s, "[\"a\",\"bb\"]");
   free(s);
 
   terminateO(r);
 
 }
 
 
 void getsoSmallJsonT(void) {
 
   smallt* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // undefined
   freeO(self);
   createUndefined(u);
   setTopO(self, (baset*)&u);
   r = getsoO(self);
   ck_assert_ptr_eq(r, self->topU);
   // bool
   freeO(self);
   setTopBoolO(self, true);
   r = getsoO(self);
   ck_assert_ptr_eq(r, self->topB);
   // double
   freeO(self);
   setTopDoubleO(self, 1);
   r = getsoO(self);
   ck_assert_ptr_eq(r, self->topD);
   // int
   freeO(self);
   setTopIntO(self, 1);
   r = getsoO(self);
   ck_assert_ptr_eq(r, self->topI);
   // string
   freeO(self);
   setTopSO(self, "qwe");
   r = getsoO(self);
   ck_assert_ptr_eq(r, self->topS);
   // dict
   freeO(self);
   self->f->setS(self, "qwe", "asd");
   r = getsoO(self);
   ck_assert_ptr_eq(r, self->top);
   // array
   freeO(self);
   pushG(self, 1);
   r = getsoO(self);
   ck_assert_ptr_eq(r, self->topA);
   terminateO(self);
 
 }
 
 
 void setsoSmallJsonT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   smallt *so;
 
   createSmallJson(src);
   // undefined
   createUndefined(u);
   setTopO(&src, (baset*)&u);
   so = getsoO(&src);
   resetO(&src);
   setsoO(self, so);
   ck_assert_ptr_eq(so, self->topU);
   freeO(self);
   // bool
   setTopBoolO(&src, true);
   so = getsoO(&src);
   resetO(&src);
   setsoO(self, so);
   ck_assert_ptr_eq(so, self->topB);
   freeO(self);
   // double
   setTopDoubleO(&src, 1);
   so = getsoO(&src);
   resetO(&src);
   setsoO(self, so);
   ck_assert_ptr_eq(so, self->topD);
   freeO(self);
   // int
   setTopIntO(&src, 1);
   so = getsoO(&src);
   resetO(&src);
   setsoO(self, so);
   ck_assert_ptr_eq(so, self->topI);
   freeO(self);
   // string
   setTopSO(&src, "qwe");
   so = getsoO(&src);
   resetO(&src);
   setsoO(self, so);
   ck_assert_ptr_eq(so, self->topS);
   freeO(self);
   // dict
   createSmallDict(d);
   (&d)->f->setS(&d, "1", "1");
   (&d)->f->setS(&d, "2", "2");
   char *as = null;
   // reset test: free iterElement in d
   iter(&d, E) {
     as = toStringO(E);
     break;
   }
   ck_assert_ptr_ne(as, null);
   ck_assert_str_eq(as, "1");
   free(as);
   so = (smallt*)getsoO(&d);
   resetO(&d);
   setsoO(self, so);
   ck_assert_ptr_eq(so, self->top);
   freeO(self);
   // array
   createSmallArray(a);
   pushG(&a, 1);
   pushG(&a, 2);
   as = null;
   // reset test: free iterElement in a
   iter(&a, E) {
     as = toStringO(E);
     break;
   }
   ck_assert_str_eq(as, "1");
   free(as);
   so = (smallt*)getsoO(&a);
   resetO(&a);
   setsoO(self, so);
   ck_assert_ptr_eq(so, self->topA);
   terminateO(self);
 
 }
 
 
 void mirrorSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // dict
   // empty self
   r = mirrorO(self);
   ck_assert_ptr_eq(r, null);
   // non empty with iterator
   self->f->setS(self, "1", "1");
   self->f->setS(self, "2", "2");
   char *as = null;
   iter(self, E) {
     as = toStringO(E);
     break;
   }
   ck_assert_str_eq(as, "1");
   free(as);
   r = mirrorO(self);
   ck_assert_ptr_eq(r->top, self->top);
   finishO(r);
   freeO(self);
   // array
   // empty self
   r = mirrorO(self);
   ck_assert_ptr_eq(r, null);
   // non empty with iterator
   pushG(self, 1);
   pushG(self, 2);
   as = null;
   iter(self, E) {
     as = toStringO(E);
     break;
   }
   ck_assert_str_eq(as, "1");
   free(as);
   r = mirrorO(self);
   ck_assert_ptr_eq(r->topA, self->topA);
   finishO(r);
   terminateO(self);
 
 }
 
 
 void setTopBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopBoolO(self, true);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopDoubleO(self, 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2.000000e+00");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopIntO(self, 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopStringO(self, "qwe");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   // null
   ck_assert_ptr_eq(setTopStringO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopCharO(self, 'X');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "X");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallDictt *value = allocSmallDict();
 
   r = setTopDictO(self, value);
   ck_assert_ptr_ne(r, null);
   finishG(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   // non smallDict value
   value = (smallDictt*) allocSmallInt(1);
   ck_assert_ptr_eq(setTopDictO(self, value), null);
   terminateO(value);
   // null
   ck_assert_ptr_eq(setTopDictO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallArrayt *value = allocSmallArray();
 
   r = setTopArrayO(self, value);
   ck_assert_ptr_ne(r, null);
   finishG(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   // non smallArray value
   value = (smallArrayt*) allocSmallInt(1);
   ck_assert_ptr_eq(setTopArrayO(self, value), null);
   terminateO(value);
   // null
   ck_assert_ptr_eq(setTopArrayO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopArraycSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   char **value     = listCreateS("a","bb");
 
   r = setTopArraycO(self, value);
   ck_assert_ptr_ne(r, null);
   listFreeS(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"a\",\"bb\"]");
   free(s);
   // null
   ck_assert_ptr_eq(setTopArraycO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopSmallBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallBoolt *value = allocSmallBool(true);
 
   r = setTopSmallBoolO(self, value);
   ck_assert_ptr_ne(r, null);
   finishG(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   // non smallBool value
   value = (smallBoolt*) allocSmallInt(1);
   ck_assert_ptr_eq(setTopSmallBoolO(self, value), null);
   terminateO(value);
   // null
   ck_assert_ptr_eq(setTopSmallBoolO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopSmallDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocG(rtSmallJsont);
   smallDoublet *value = allocSmallDouble(2);
 
   r = setTopSmallDoubleO(self, value);
   ck_assert_ptr_ne(r, null);
   finishG(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2.000000e+00");
   free(s);
   // non smallDouble value
   value = (smallDoublet*) allocSmallInt(1);
   ck_assert_ptr_eq(setTopSmallDoubleO(self, value), null);
   terminateO(value);
   // null
   ck_assert_ptr_eq(setTopSmallDoubleO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopSmallIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   smallIntt *value = allocSmallInt(2);
 
   r = setTopSmallIntO(self, value);
   ck_assert_ptr_ne(r, null);
   finishG(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   // non smallInt value
   value = (smallIntt*) allocSmallBool(true);
   ck_assert_ptr_eq(setTopSmallIntO(self, value), null);
   terminateO(value);
   // null
   ck_assert_ptr_eq(setTopSmallIntO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallJsont *value = allocSmallJson();
 
   r = self->f->setTopSmallJson(self, value);
   ck_assert_ptr_ne(r, null);
   finishG(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   // non smallJson value
   value = (smallJsont*) allocSmallInt(1);
   ck_assert_ptr_eq(self->f->setTopSmallJson(self, value), null);
   terminateO(value);
   // null
   ck_assert_ptr_eq(self->f->setTopSmallJson(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocG(rtSmallJsont);
   smallStringt *value = allocSmallString("qwe");
 
   r = setTopSmallStringO(self, value);
   ck_assert_ptr_ne(r, null);
   finishG(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   // non smallString value
   value = (smallStringt*) allocSmallInt(1);
   ck_assert_ptr_eq(setTopSmallStringO(self, value), null);
   terminateO(value);
   // null
   ck_assert_ptr_eq(setTopSmallStringO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopNFreeSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   baset *value     = (baset*)allocSmallInt(2);
 
   r = setTopNFreeO(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopNFreeBoolO(self, true);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopNFreeDoubleO(self, 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2.000000e+00");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopNFreeIntO(self, 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   char *value      = strdup("qwe");
 
   r = setTopNFreeStringO(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   // null
   ck_assert_ptr_eq(setTopNFreeStringO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopNFreeDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallDictt *value = allocSmallDict();
 
   r = setTopNFreeDictO(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   // non smallDict value
   value = (smallDictt*) allocSmallInt(1);
   ck_assert_ptr_eq(setTopNFreeDictO(self, value), null);
   terminateO(value);
   // null
   ck_assert_ptr_eq(setTopNFreeDictO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopNFreeArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallArrayt *value = allocSmallArray();
 
   r = setTopNFreeArrayO(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   // non smallArray value
   value = (smallArrayt*) allocSmallInt(1);
   ck_assert_ptr_eq(setTopNFreeArrayO(self, value), null);
   terminateO(value);
   // null
   ck_assert_ptr_eq(setTopNFreeArrayO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopNFreeArraycSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   char **value     = listCreateS("a","bb");
 
   r = setTopNFreeArraycO(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"a\",\"bb\"]");
   free(s);
   // null
   ck_assert_ptr_eq(setTopNFreeArraycO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopNFreeSmallBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallBoolt *value = allocSmallBool(true);
 
   r = setTopNFreeSmallBoolO(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   // non smallBool value
   value = (smallBoolt*) allocSmallInt(1);
   ck_assert_ptr_eq(setTopNFreeSmallBoolO(self, value), null);
   terminateO(value);
   // null
   ck_assert_ptr_eq(setTopNFreeSmallBoolO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopNFreeSmallDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocG(rtSmallJsont);
   smallDoublet *value = allocSmallDouble(2);
 
   r = setTopNFreeSmallDoubleO(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2.000000e+00");
   free(s);
   // non smallDouble value
   value = (smallDoublet*) allocSmallInt(1);
   ck_assert_ptr_eq(setTopNFreeSmallDoubleO(self, value), null);
   terminateO(value);
   // null
   ck_assert_ptr_eq(setTopNFreeSmallDoubleO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopNFreeSmallIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   smallIntt *value = allocSmallInt(2);
 
   r = setTopNFreeSmallIntO(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   // non smallInt value
   value = (smallIntt*) allocSmallBool(true);
   ck_assert_ptr_eq(setTopNFreeSmallIntO(self, value), null);
   terminateO(value);
   // null
   ck_assert_ptr_eq(setTopNFreeSmallIntO(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopNFreeSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallJsont *value = allocSmallJson();
 
   r = self->f->setTopNFreeSmallJson(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   // non smallJson value
   value = (smallJsont*) allocSmallInt(1);
   ck_assert_ptr_eq(self->f->setTopNFreeSmallJson(self, value), null);
   terminateO(value);
   // null
   ck_assert_ptr_eq(self->f->setTopNFreeSmallJson(self, null), null);
   terminateO(self);
 
 }
 
 
 void setTopNFreeSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocG(rtSmallJsont);
   smallStringt *value = allocSmallString("qwe");
 
   r = setTopNFreeSmallStringO(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   // non smallString value
   value = (smallStringt*) allocSmallInt(1);
   ck_assert_ptr_eq(setTopNFreeSmallStringO(self, value), null);
   terminateO(value);
   // null
   ck_assert_ptr_eq(setTopNFreeSmallStringO(self, null), null);
   terminateO(self);
 
 }
 
 
 void fromArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   char **array;
   size_t size = 3;
 
   // libsheepy list
   array = listCreateS("a", "bb", "ccc");
   r = fromArrayO(self, array, 0);
   ck_assert_ptr_eq(self, r);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"a\",\"bb\",\"ccc\"]");
   free(s);
   listFreeS(array);
   // array with strings
   freeO(self);
   array = allocArray(array, size+1);
   array[0] = strdup("a1");
   array[1] = strdup("bb1");
   array[2] = strdup("ccc1");
   array[3] = array[2];
   r = fromArrayO(self, array, size);
   ck_assert_ptr_eq(self, r);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"a1\",\"bb1\",\"ccc1\"]");
   free(s);
   // null in array
   freeO(self);
   char *elem = array[0];
   array[0]   = null;
   r = fromArrayO(self, array, size);
   ck_assert_ptr_eq(self, r);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"bb1\",\"ccc1\"]");
   ck_assert_uint_eq(lenO(self), 3);
   free(s);
   array[0] = elem;
   // json dict
   freeO(self);
   setTypeIntO(self);
   r = fromArrayO(self, array, 1);
   ck_assert_ptr_eq(r, null);
   array[3] = null;
   listFreeS(array);
   // NULL array
   r = fromArrayO(self, null, 1);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void fromArrayNFreeSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array;
   size_t size = 3;
 
   // libsheepy list
   array = listCreateS("a", "bb", "ccc");
   r = fromArrayNFreeO(self, array, 0);
   ck_assert_ptr_eq(self, r);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"a\",\"bb\",\"ccc\"]");
   free(s);
   // array with strings
   array = allocArray(array, size);
   array[0] = strdup("a1");
   array[1] = strdup("bb1");
   array[2] = strdup("ccc1");
   r = fromArrayNFreeO(self, array, size);
   ck_assert_ptr_eq(self, r);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"a1\",\"bb1\",\"ccc1\"]");
   free(s);
   // NULL array
   r = fromArrayNFreeO(self, null, 1);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void fromArrayDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallArrayt *items = allocSmallArray();
 
   self->f->setInt(self, "", 1);
   // ignored item
   items->f->pushS(items, "ignored");
   createAllocateSmallArray(a);
   a->f->pushS(a, "a");
   a->f->pushInt(a, 1);
   items->f->pushNFreeArray(items, a);
   a = allocSmallArray();
   items->f->pushNFreeArray(items, a);
   a = allocSmallArray();
   a->f->pushInt(a, 1);
   a->f->pushInt(a, 2);
   items->f->pushNFreeArray(items, a);
   r = fromArrayDictO(self, items);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":1}");
   free(s);
   // empty json
   freeO(self);
   r = fromArrayDictO(self, items);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"a\":1}");
   free(s);
   // non json dict
   freeO(self);
   setTypeIntO(self);
   r = fromArrayDictO(self, items);
   ck_assert_ptr_eq(r, NULL);
   terminateO(items);
   // non smallArray items
   freeO(self);
   items = (smallArrayt*) allocSmallInt(2);
   r = fromArrayDictO(self, items);
   ck_assert_ptr_eq(r, NULL);
   // null items
   r = fromArrayDictO(self, null);
   ck_assert_ptr_eq(r, NULL);
   terminateO(items);
   terminateO(self);
 
 }
 
 
 void toArrayDictSmallJsonT(void) {
 
   smallArrayt* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   parseO(self, "{\"a\":2,\"bb\":4}");
 
   r = toArrayDictO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[[\"a\",2],[\"bb\",4]]");
   free(s);
   // empty self
   freeO(self);
   setTypeDictO(self);
   ck_assert_ptr_eq(toArrayDictO(self), null);
   // non json dict
   freeO(self);
   ck_assert_ptr_eq(toArrayDictO(self), null);
   terminateO(self);
 
 }
 
 
 void getTopUndefinedSmallJsonT(void) {
 
   undefinedt*   r  = allocUndefined();
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopO(self, (baset*) r);
   finishO(r);
   r = getTopUndefinedO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   // non json undefined
   freeO(self);
   ck_assert_ptr_eq(getTopUndefinedO(self), null);
   terminateO(self);
 
 }
 
 
 void getTopBoolSmallJsonT(void) {
 
   bool          r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopBoolO(self, true);
   r = getTopBoolO(self);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void getTopBoolPSmallJsonT(void) {
 
   bool*         r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopBoolO(self, true);
   r = getTopBoolPO(self);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r);
   terminateO(self);
 
 }
 
 
 void getTopDoubleSmallJsonT(void) {
 
   double        r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopDoubleO(self, 2);
   r = getTopDoubleO(self);
   ck_assert(r==2);
   terminateO(self);
 
 }
 
 
 void getTopDoublePSmallJsonT(void) {
 
   double*       r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopDoubleO(self, 2);
   r = getTopDoublePO(self);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r==2);
   terminateO(self);
 
 }
 
 
 void getTopIntSmallJsonT(void) {
 
   int64_t       r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopIntO(self);
   ck_assert_int_eq(r, 3);
   terminateO(self);
 
 }
 
 
 void getTopIntPSmallJsonT(void) {
 
   int64_t*      r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopIntPO(self);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 3);
   terminateO(self);
 
 }
 
 
 void getTopInt32SmallJsonT(void) {
 
   int32_t       r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopInt32O(self);
   ck_assert_int_eq(r, 3);
   terminateO(self);
 
 }
 
 
 void getTopInt32PSmallJsonT(void) {
 
   int32_t*      r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopInt32PO(self);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 3);
   terminateO(self);
 
 }
 
 
 void getTopUintSmallJsonT(void) {
 
   uint64_t      r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopUintO(self);
   ck_assert_int_eq(r, 3);
   terminateO(self);
 
 }
 
 
 void getTopUintPSmallJsonT(void) {
 
   uint64_t*     r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopUintPO(self);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 3);
   terminateO(self);
 
 }
 
 
 void getTopUint32SmallJsonT(void) {
 
   uint32_t      r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopUint32O(self);
   ck_assert_int_eq(r, 3);
   terminateO(self);
 
 }
 
 
 void getTopUint32PSmallJsonT(void) {
 
   uint32_t*     r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopUint32PO(self);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 3);
   terminateO(self);
 
 }
 
 
 void getTopSSmallJsonT(void) {
 
   char*         r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopStringO(self, "qwe");
   r = getTopSO(self);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "qwe");
   terminateO(self);
 
 }
 
 
 void getTopDictSmallJsonT(void) {
 
   smallDictt*   r  = allocSmallDict();
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopNFreeDictO(self, r);
   r = getTopDictO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   // non json dict
   freeO(self);
   ck_assert_ptr_eq(getTopDictO(self), null);
   terminateO(self);
 
 }
 
 
 void getTopArraySmallJsonT(void) {
 
   smallArrayt*  r  = allocSmallArray();
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopNFreeArrayO(self, r);
   r = getTopArrayO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   // non json array
   freeO(self);
   ck_assert_ptr_eq(getTopArrayO(self), null);
   terminateO(self);
 
 }
 
 
 void getTopSmallBoolSmallJsonT(void) {
 
   smallBoolt*   r  = allocSmallBool(true);
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopNFreeSmallBoolO(self, r);
   r = getTopSmallBoolO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   // non json bool
   freeO(self);
   ck_assert_ptr_eq(getTopSmallBoolO(self), null);
   terminateO(self);
 
 }
 
 
 void getTopSmallDoubleSmallJsonT(void) {
 
   smallDoublet* r  = allocSmallDouble(2);
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopNFreeSmallDoubleO(self, r);
   r = getTopSmallDoubleO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "2.000000e+00");
   free(s);
   // non json double
   freeO(self);
   ck_assert_ptr_eq(getTopSmallDoubleO(self), null);
   terminateO(self);
 
 }
 
 
 void getTopSmallIntSmallJsonT(void) {
 
   smallIntt* r     = allocSmallInt(2);
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopNFreeSmallIntO(self, r);
   r = getTopSmallIntO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   // non json int
   freeO(self);
   ck_assert_ptr_eq(getTopSmallIntO(self), null);
   terminateO(self);
 
 }
 
 
 void getTopSmallStringSmallJsonT(void) {
 
   smallStringt* r  = allocSmallString("qwe");
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopNFreeSmallStringO(self, r);
   r = getTopSmallStringO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   // non json string
   freeO(self);
   ck_assert_ptr_eq(getTopSmallStringO(self), null);
   terminateO(self);
 
 }
 
 
 void keyIsSmallJsonT(void) {
 
   jsonPathRest r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // array path
   r = keyIsO(self, "[123].\"wef\"");
   ck_assert_int_eq(r, ARRAY_PATH);
   // dict path
   r = keyIsO(self, "\"wef\"[-123]");
   ck_assert_int_eq(r, DICT_PATH);
   // not a path
   r = keyIsO(self, "[\"");
   ck_assert_int_eq(r, NOT_A_PATH);
   r = keyIsO(self, "[[123]");
   ck_assert_int_eq(r, NOT_A_PATH);
   r = keyIsO(self, "[123]]");
   ck_assert_int_eq(r, NOT_A_PATH);
   r = keyIsO(self, "[123]qwe");
   ck_assert_int_eq(r, NOT_A_PATH);
   r = keyIsO(self, "['123]");
   ck_assert_int_eq(r, NOT_A_PATH);
   r = keyIsO(self, "[1-]");
   ck_assert_int_eq(r, NOT_A_PATH);
   // null key
   r = keyIsO(self, null);
   ck_assert_int_eq(r, KEY_IS_NULL);
   terminateO(self);
 
 }
 
 
 void keyIsSSmallJsonT(void) {
 
   const char* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // array path
   r = keyIsSO(self, "[123].\"wef\"");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "ARRAY_PATH");
   // dict path
   r = keyIsSO(self, "\"wef\"[-123]");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "DICT_PATH");
   // not a path
   r = keyIsSO(self, "key");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "NOT_A_PATH");
   // null key
   r = keyIsSO(self, null);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void makeKeySmallJsonT(void) {
 
   char*  r;
   smallJsont *self = allocG(rtSmallJsont);
 
 
   r = makeKeyO(self, "\"\\asd");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "\"\\\"\\\\asd\"");
   free(r);
   // null key
   r = makeKeyO(self, null);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void iMakeKeySmallJsonT(void) {
 
   char*  r;
   smallJsont *self = allocG(rtSmallJsont);
   char *key = strdup("qwe");
 
   r = iMakeKeyO(self, &key);
   ck_assert_ptr_ne(r, null);
   ck_assert_ptr_eq(r, key);
   ck_assert_str_eq(r, "\"qwe\"");
   // null key
   freen(key);
   r = iMakeKeyO(self, &key);
   ck_assert_ptr_eq(r, null);
   r = iMakeKeyO(self, null);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void bMakeKeySmallJsonT(void) {
 
   char*  r;
   smallJsont *self = allocG(rtSmallJsont);
   char dest[20];
 
   r = bMakeKeyO(self, dest, "\"\\123");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "\"\\\"\\\\123\"");
   // null
   r = bMakeKeyO(self, dest, null);
   ck_assert_ptr_eq(r, null);
   r = bMakeKeyO(self, null, "\"\\123");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void bLMakeKeySmallJsonT(void) {
 
   char*  r;
   smallJsont *self = allocG(rtSmallJsont);
   char dest[20];
 
   r = bLMakeKeyO(self, dest, sizeof(dest), "\"\\123");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "\"\\\"\\\\123\"");
   // just enough space
   r = bLMakeKeyO(self, dest, 10, "\"\\123");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "\"\\\"\\\\123\"");
   // dest too short
   r = bLMakeKeyO(self, dest, 9, "\"\\123");
   ck_assert_ptr_eq(r, null);
   // null
   r = bLMakeKeyO(self, dest, 45, null);
   ck_assert_ptr_eq(r, null);
   r = bLMakeKeyO(self, null, 4, "\"\\123");
   ck_assert_ptr_eq(r, null);
   r = bLMakeKeyO(self, dest, 0, "\"\\123");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void makeKeyLenSmallJsonT(void) {
 
   size_t r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = makeKeyLenO(self, "\"\\asd");
   ck_assert_int_eq(r, 9);
   r = makeKeyLenO(self, "");
   ck_assert_int_eq(r, 2);
   // null
   ck_assert_int_eq(makeKeyLenO(self, null), 0);
   terminateO(self);
 
 }
 
 
 void setSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value     = (baset*) allocSmallInt(1);
 
   r = self->f->set(self, "1", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":1}");
   free(s);
   // path
   value = (baset*) allocSmallInt(2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->set(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":1,\"array\":[{\"key\":2}]}");
   free(s);
   // json bool
   freeO(self);
   value = (baset*) allocSmallInt(2);
   setTypeBoolO(self);
   r = self->f->set(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->set(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->set(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //    wrong path and empty smallInt container (sInt is allocated in toSmallt)
   createSmallInt(i);
   r = self->f->set(self, "\"1\".[1]", (baset*)&i);
   ck_assert_ptr_eq(r, null);
   freeO(&i);
   //    wrong path and user class
   i.type = "myclass";
   r = self->f->set(self, "\"1\".[1]", (baset*)&i);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->set(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->set(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->set(self, null, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setUndefinedSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = self->f->setUndefined(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":null}");
   free(s);
   // path
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setUndefined(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":null,\"array\":[{\"key\":null}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setUndefined(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setUndefined(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setUndefined(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setUndefined(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setUndefined(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setUndefined(self, null);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void setBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":true}");
   free(s);
   // path
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setBool(self, "\"array\"[0].\"key\"", false);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":true,\"array\":[{\"key\":false}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setBool(self, "1", true);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setBool(self, "1", true);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setBool(self, "\"1\"[1]", true);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setBool(self, "\"1\".\"1\"", true);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setBool(self, "\"2\".\"1\".[12]", true);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setBool(self, null, false);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void setDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = self->f->setDouble(self, "1", 2.2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2.200000e+00}");
   free(s);
   // path
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setDouble(self, "\"array\"[0].\"key\"", 1.2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2.200000e+00,\"array\":[{\"key\":1.200000e+00}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setDouble(self, "1", 2.2);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setDouble(self, "1", 2.2);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setDouble(self, "\"1\"[1]", 2.2);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setDouble(self, "\"1\".\"1\"", 2.2);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setDouble(self, "\"2\".\"1\".[12]", 2.2);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setDouble(self, null, 1);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void setIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2}");
   free(s);
   // path
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setInt(self, "\"array\"[0].\"key\"", 4);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2,\"array\":[{\"key\":4}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setInt(self, "1", 1);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setInt(self, "1", 1);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setInt(self, "\"1\"[1]", 1);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setInt(self, "\"1\".\"1\"", 1);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setInt(self, "\"2\".\"1\".[12]", 1);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setInt(self, null, 1);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void setSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = self->f->setS(self, "1", "qwe");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"qwe\"}");
   free(s);
   // path
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setS(self, "\"array\"[0].\"key\"", "a");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"qwe\",\"array\":[{\"key\":\"a\"}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setS(self, "1", "");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setS(self, "1", "");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setS(self, "\"1\"[1]", "");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setS(self, "\"1\".\"1\"", "");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setS(self, "\"2\".\"1\".[12]", "");
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setS(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setS(self, null, "");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void setCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = self->f->setChar(self, "1", 'x');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"x\"}");
   free(s);
   // path
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setChar(self, "\"array\"[0].\"key\"", 'q');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"x\",\"array\":[{\"key\":\"q\"}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setChar(self, "1", 'c');
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setChar(self, "1", 'x');
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setChar(self, "\"1\"[1]", 'x');
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setChar(self, "\"1\".\"1\"", 'q');
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setChar(self, "\"2\".\"1\".[12]", 'q');
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setChar(self, null, '1');
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void setDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict = allocSmallDict();
 
   // empty dict
   r = self->f->setDict(self, "1", dict);
   ck_assert_ptr_ne(r, null);
   finishO(dict);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{}}");
   free(s);
   // set dict
   dict = allocSmallDict();
   dict->f->setS(dict, "a", "zxc");
   r = self->f->setDict(self, "1", dict);
   ck_assert_ptr_ne(r, null);
   finishO(dict);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{\"a\":\"zxc\"}}");
   free(s);
   // non smallDict object
   dict = (smallDictt*) allocSmallInt(2);
   r = self->f->setDict(self, "1", dict);
   ck_assert_ptr_eq(r, null);
   terminateO(dict);
   // path
   dict = allocSmallDict();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setDict(self, "\"array\"[0].\"key\"", dict);
   ck_assert_ptr_ne(r, null);
   finishO(dict);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{\"a\":\"zxc\"},\"array\":[{\"key\":{}}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   dict = allocSmallDict();
   r = self->f->setDict(self, "1", dict);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setDict(self, "1", dict);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setDict(self, "\"1\"[1]", dict);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setDict(self, "\"1\".\"1\"", dict);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setDict(self, "\"2\".\"1\".[12]", dict);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setDict(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setDict(self, null, dict);
   ck_assert_ptr_eq(r, null);
   terminateO(dict);
   terminateO(self);
 
 }
 
 
 void setArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   // empty array
   r = self->f->setArray(self, "1", array);
   ck_assert_ptr_ne(r, null);
   finishO(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[]}");
   free(s);
   // set array
   array = allocSmallArray();
   array->f->pushS(array, "zxc");
   r = self->f->setArray(self, "1", array);
   ck_assert_ptr_ne(r, null);
   finishO(array);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[\"zxc\"]}");
   free(s);
   // non smallArray object
   array = (smallArrayt*) allocSmallInt(2);
   r = self->f->setArray(self, "1", array);
   ck_assert_ptr_eq(r, null);
   terminateO(array);
   // path
   array = allocSmallArray();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setArray(self, "\"array\"[0].\"key\"", array);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[\"zxc\"],\"array\":[{\"key\":[]}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setArray(self, "1", array);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setArray(self, "1", array);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setArray(self, "\"1\"[1]", array);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setArray(self, "\"1\".\"1\"", array);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setArray(self, "\"2\".\"1\".[12]", array);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setArray(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setArray(self, null, array);
   ck_assert_ptr_eq(r, null);
   finishO(array);
   terminateO(self);
 
 }
 
 
 void setArraycSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array     = listCreateS("a", "b");
 
   r = self->f->setArrayc(self, "1", array);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[\"a\",\"b\"]}");
   free(s);
   // zero element list
   char *e0 = array[0];
   array[0] = null;
   r = self->f->setArrayc(self, "1", array);
   ck_assert_ptr_ne(r, null);
   array[0] = e0;
   listFreeS(array);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[]}");
   free(s);
   // path
   array = listCreateS("1", "2");
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setArrayc(self, "\"array\"[0].\"key\"", array);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[],\"array\":[{\"key\":[\"1\",\"2\"]}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setArrayc(self, "1", array);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setArrayc(self, "1", array);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setArrayc(self, "\"1\"[1]", array);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setArrayc(self, "\"1\".\"1\"", array);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setArrayc(self, "\"2\".\"1\".[12]", array);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setArrayc(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setArrayc(self, null, array);
   ck_assert_ptr_eq(r, null);
   listFreeS(array);
   terminateO(self);
 
 }
 
 
 void setSmallBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   r = self->f->setSmallBool(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":true}");
   free(s);
   // empty smallBool
   value->value = null;
   r = self->f->setSmallBool(self, "1", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":false}");
   free(s);
   // non smallBool object
   value = (smallBoolt*) allocSmallInt(2);
   r = self->f->setSmallBool(self, "1", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // path
   value = allocSmallBool(true);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setSmallBool(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":false,\"array\":[{\"key\":true}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setSmallBool(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setSmallBool(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setSmallBool(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //    wrong path and empty smallInt container (sInt is allocated in toSmallt)
   createSmallBool(i);
   r = self->f->setSmallBool(self, "\"1\".[1]", &i);
   ck_assert_ptr_eq(r, null);
   freeO(&i);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setSmallBool(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setSmallBool(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setSmallBool(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setSmallBool(self, null, value);
   ck_assert_ptr_eq(r, null);
   finishO(value);
   terminateO(self);
 
 }
 
 
 void setSmallBytesSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallBytest *value = allocSmallBytes("qwe", sizeof("qwe"));
 
   r = self->f->setSmallBytes(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[0x71,0x77,0x65,0x00]}");
   free(s);
   // empty smallBytes
   value->B = null;
   r = self->f->setSmallBytes(self, "1", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[]}");
   free(s);
   // non smallBytes object
   value = (smallBytest*) allocSmallInt(2);
   r = self->f->setSmallBytes(self, "1", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // path
   value = allocSmallBytes("qwf", sizeof("qwf"));
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setSmallBytes(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[],\"array\":[{\"key\":[0x71,0x77,0x66,0x00]}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setSmallBytes(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setSmallBytes(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setSmallBytes(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //    wrong path and empty smallInt container (sInt is allocated in toSmallt)
   createSmallBytes(i);
   r = self->f->setSmallBytes(self, "\"1\".[1]", &i);
   ck_assert_ptr_eq(r, null);
   freeO(&i);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setSmallBytes(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setSmallBytes(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setSmallBytes(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setSmallBytes(self, null, value);
   ck_assert_ptr_eq(r, null);
   finishO(value);
   terminateO(self);
 
 }
 
 
 void setSmallDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   smallDoublet *value = allocSmallDouble(2.2);
 
   r = self->f->setSmallDouble(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2.200000e+00}");
   free(s);
   // empty smallDouble
   value->value = null;
   r = self->f->setSmallDouble(self, "1", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":0.000000e+00}");
   free(s);
   // non smallDouble object
   value = (smallDoublet*) allocSmallInt(2);
   r = self->f->setSmallDouble(self, "1", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // path
   value = allocSmallDouble(1.2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setSmallDouble(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":0.000000e+00,\"array\":[{\"key\":1.200000e+00}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setSmallDouble(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setSmallDouble(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setSmallDouble(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //    wrong path and empty smallInt container (sInt is allocated in toSmallt)
   createSmallDouble(i);
   r = self->f->setSmallDouble(self, "\"1\".[1]", &i);
   ck_assert_ptr_eq(r, null);
   freeO(&i);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setSmallDouble(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setSmallDouble(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setSmallDouble(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setSmallDouble(self, null, value);
   ck_assert_ptr_eq(r, null);
   finishO(value);
   terminateO(self);
 
 }
 
 
 void setSmallIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value = allocSmallInt(2);
 
   r = self->f->setSmallInt(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2}");
   free(s);
   // empty smallInt
   value->value = null;
   r = self->f->setSmallInt(self, "1", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":0}");
   free(s);
   // non smallInt object
   value = (smallIntt*) allocSmallBool(true);
   r = self->f->setSmallInt(self, "1", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // path
   value = allocSmallInt(1);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setSmallInt(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":0,\"array\":[{\"key\":1}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setSmallInt(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setSmallInt(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setSmallInt(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //    wrong path and empty smallInt container (sInt is allocated in toSmallt)
   createSmallInt(i);
   r = self->f->setSmallInt(self, "\"1\".[1]", &i);
   freeO(&i);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setSmallInt(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setSmallInt(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setSmallInt(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setSmallInt(self, null, value);
   ck_assert_ptr_eq(r, null);
   finishO(value);
   terminateO(self);
 
 }
 
 
 void setSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   setTopIntO(value, 2);
   r = self->f->setSmallJson(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2}");
   free(s);
   // empty smallJson
   resetO(value);
   r = self->f->setSmallJson(self, "1", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{}}");
   free(s);
   // non smallJson object
   value = (smallJsont*) allocSmallInt(2);
   r = self->f->setSmallJson(self, "1", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // path
   value = allocSmallJson();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setSmallJson(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{},\"array\":[{\"key\":{}}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setSmallJson(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setSmallJson(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setSmallJson(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //    wrong path and empty smallInt container (sInt is allocated in toSmallt)
   createSmallJson(i);
   r = self->f->setSmallJson(self, "\"1\".[1]", &i);
   ck_assert_ptr_eq(r, null);
   freeO(&i);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setSmallJson(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setSmallJson(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setSmallJson(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setSmallJson(self, null, value);
   ck_assert_ptr_eq(r, null);
   finishO(value);
   terminateO(self);
 
 }
 
 
 void setSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocSmallJson();
   smallStringt *string = allocSmallString("qwe");
 
   r = self->f->setSmallString(self, "1", string);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"qwe\"}");
   free(s);
   // empty smallString
   string->data = null;
   r = self->f->setSmallString(self, "1", string);
   ck_assert_ptr_ne(r, null);
   finishO(string);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"\"}");
   free(s);
   // non smallString object
   string = (smallStringt*) allocSmallInt(2);
   r = self->f->setSmallString(self, "1", string);
   ck_assert_ptr_eq(r, null);
   terminateO(string);
   // path
   smallStringt *value = allocSmallString("asd");
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setSmallString(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"\",\"array\":[{\"key\":\"asd\"}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setSmallString(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setSmallString(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setSmallString(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //    wrong path and empty smallInt container (sInt is allocated in toSmallt)
   createSmallString(i);
   r = self->f->setSmallString(self, "\"1\".[1]", &i);
   ck_assert_ptr_eq(r, null);
   freeO(&i);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setSmallString(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setSmallString(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setSmallString(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setSmallString(self, null, string);
   ck_assert_ptr_eq(r, null);
   finishO(value);
   terminateO(self);
 
 }
 
 
 void setSmallContainerSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self           = allocSmallJson();
   smallContainert *container = allocSmallContainer(null);
 
   r = self->f->setSmallContainer(self, "1", container);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"<data container>\"}");
   free(s);
   // empty smallContainer
   container->data = null;
   r = self->f->setSmallContainer(self, "1", container);
   ck_assert_ptr_ne(r, null);
   finishO(container);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"<data container>\"}");
   free(s);
   // non smallContainer object
   container = (smallContainert*) allocSmallInt(2);
   r = self->f->setSmallContainer(self, "1", container);
   ck_assert_ptr_eq(r, null);
   terminateO(container);
   // path
   smallContainert *value = allocSmallContainer(null);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setSmallContainer(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"<data container>\",\"array\":[{\"key\":\"<data container>\"}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setSmallContainer(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setSmallContainer(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setSmallContainer(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //    wrong path and empty smallInt container (sInt is allocated in toSmallt)
   createSmallContainer(i);
   r = self->f->setSmallContainer(self, "\"1\".[1]", &i);
   ck_assert_ptr_eq(r, null);
   freeO(&i);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setSmallContainer(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setSmallContainer(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setSmallContainer(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setSmallContainer(self, null, container);
   ck_assert_ptr_eq(r, null);
   finishO(value);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value;
 
   // undefined object
   value   = (baset*)allocUndefined();
   r = self->f->setNFree(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":null}");
   free(s);
   // container
   createAllocateSmallContainer(c);
   r = self->f->setNFree(self, "1", (baset*)c);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"<data container>\"}");
   free(s);
   // base object in container
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r = self->f->setNFree(self, "1", (baset*)I);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"<data container>\"}");
   free(s);
   // path
   value = (baset*) allocSmallInt(2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFree(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"<data container>\",\"array\":[{\"key\":2}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   value = (baset*) allocSmallInt(2);
   r = self->f->setNFree(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFree(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFree(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //    wrong path and empty smallInt container (sInt is allocated in toSmallt)
   createSmallInt(i);
   r = self->f->setNFree(self, "\"1\".[1]", (baset*)&i);
   ck_assert_ptr_eq(r, null);
   freeO(&i);
   //    wrong path and user class
   i.type = "myclass";
   r = self->f->setNFree(self, "\"1\".[1]", (baset*)&i);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFree(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFree(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // null value
   r = self->f->setNFree(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setNFree(self, null, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void setNFreeUndefinedSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self      = allocSmallJson();
   undefinedt *undefined = allocUndefined();
 
   r = self->f->setNFreeUndefined(self, "1", undefined);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":null}");
   free(s);
   // path
   undefined = allocUndefined();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreeUndefined(self, "\"array\"[0].\"key\"", undefined);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":null,\"array\":[{\"key\":null}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   undefined = allocUndefined();
   r = self->f->setNFreeUndefined(self, "1", undefined);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreeUndefined(self, "1", undefined);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreeUndefined(self, "\"1\"[1]", undefined);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreeUndefined(self, "\"1\".\"1\"", undefined);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreeUndefined(self, "\"2\".\"1\".[12]", undefined);
   ck_assert_ptr_eq(r, null);
   terminateO(undefined);
   // null value
   r = self->f->setNFreeUndefined(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   undefined = allocUndefined();
   r = self->f->setNFreeUndefined(self, null, undefined);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(undefined);
 
 }
 
 
 void setNFreeSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char *string     = strdup("qwe");
 
   r = self->f->setNFreeS(self, "1", string);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"qwe\"}");
   free(s);
   // path
   string = strdup("asd");
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreeS(self, "\"array\"[0].\"key\"", string);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"qwe\",\"array\":[{\"key\":\"asd\"}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   string = strdup("asd");
   r = self->f->setNFreeS(self, "1", string);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreeS(self, "1", string);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreeS(self, "\"1\"[1]", string);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreeS(self, "\"1\".\"1\"", string);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreeS(self, "\"2\".\"1\".[12]", string);
   ck_assert_ptr_eq(r, null);
   free(string);
   // null value
   r = self->f->setNFreeS(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   string = strdup("qwe");
   r = self->f->setNFreeS(self, null, string);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   free(string);
 
 }
 
 
 void setNFreeDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict = allocSmallDict();
 
   r = self->f->setNFreeDict(self, "1", dict);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{}}");
   free(s);
   // null value
   r = self->f->setNFreeDict(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // path
   smallDictt *value = allocSmallDict();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreeDict(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{},\"array\":[{\"key\":{}}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallDict();
   r = self->f->setNFreeDict(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreeDict(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreeDict(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreeDict(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreeDict(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // null key
   dict = allocSmallDict();
   r = self->f->setNFreeDict(self, null, dict);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(dict);
 
 }
 
 
 void setNFreeArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   // empty array
   r = self->f->setNFreeArray(self, "1", array);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[]}");
   free(s);
   // path
   smallArrayt *value = allocSmallArray();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreeArray(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[],\"array\":[{\"key\":[]}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallArray();
   r = self->f->setNFreeArray(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreeArray(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreeArray(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreeArray(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreeArray(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // null value
   r = self->f->setNFreeArray(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setNFreeArray(self, null, array);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void setNFreeArraycSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array     = listCreateS("a", "b");
 
   r = self->f->setNFreeArrayc(self, "1", array);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[\"a\",\"b\"]}");
   free(s);
   // path
   char **value = listCreateS("1", "2");
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreeArrayc(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[\"a\",\"b\"],\"array\":[{\"key\":[\"1\",\"2\"]}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   value = listCreateS("1", "2");
   r = self->f->setNFreeArrayc(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreeArrayc(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreeArrayc(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreeArrayc(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreeArrayc(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   listFreeS(value);
   // null value
   r = self->f->setNFreeArrayc(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setNFreeArrayc(self, null, array);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   r = self->f->setNFreeSmallBool(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":true}");
   free(s);
   // path
   value = allocSmallBool(false);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreeSmallBool(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":true,\"array\":[{\"key\":false}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallBool(true);
   r = self->f->setNFreeSmallBool(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreeSmallBool(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreeSmallBool(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreeSmallBool(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreeSmallBool(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setNFreeSmallBool(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setNFreeSmallBool(self, null, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallBytesSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallBytest *value = allocSmallBytes("qwe", sizeof("qwe"));
 
   r = self->f->setNFreeSmallBytes(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[0x71,0x77,0x65,0x00]}");
   free(s);
   // path
   value = allocSmallBytes("qwf", sizeof("qwf"));
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreeSmallBytes(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[0x71,0x77,0x65,0x00],\"array\":[{\"key\":[0x71,0x77,0x66,0x00]}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallBytes("qwf", sizeof("qwf"));
   r = self->f->setNFreeSmallBytes(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreeSmallBytes(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreeSmallBytes(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreeSmallBytes(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreeSmallBytes(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setNFreeSmallBytes(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setNFreeSmallBytes(self, null, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   smallDoublet *value = allocSmallDouble(2.2);
 
   r = self->f->setNFreeSmallDouble(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2.200000e+00}");
   free(s);
   // path
   value = allocSmallDouble(1.2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreeSmallDouble(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2.200000e+00,\"array\":[{\"key\":1.200000e+00}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallDouble(3.2);
   r = self->f->setNFreeSmallDouble(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreeSmallDouble(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreeSmallDouble(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreeSmallDouble(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreeSmallDouble(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setNFreeSmallDouble(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setNFreeSmallDouble(self, null, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value = allocSmallInt(2);
 
   r = self->f->setNFreeSmallInt(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2}");
   free(s);
   // path
   value = allocSmallInt(3);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreeSmallInt(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2,\"array\":[{\"key\":3}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallInt(1);
   r = self->f->setNFreeSmallInt(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreeSmallInt(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreeSmallInt(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreeSmallInt(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreeSmallInt(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setNFreeSmallInt(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setNFreeSmallInt(self, null, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   setTopIntO(value, 2);
   r = self->f->setNFreeSmallJson(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2}");
   free(s);
   // path
   value = allocSmallJson();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreeSmallJson(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2,\"array\":[{\"key\":{}}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallJson();
   r = self->f->setNFreeSmallJson(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreeSmallJson(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreeSmallJson(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreeSmallJson(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreeSmallJson(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setNFreeSmallJson(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setNFreeSmallJson(self, null, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocSmallJson();
   smallStringt *string = allocSmallString("qwe");
 
   r = self->f->setNFreeSmallString(self, "1", string);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"qwe\"}");
   free(s);
   // path
   smallStringt *value = allocSmallString("asd");
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreeSmallString(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"qwe\",\"array\":[{\"key\":\"asd\"}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallString("123");
   r = self->f->setNFreeSmallString(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreeSmallString(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreeSmallString(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreeSmallString(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreeSmallString(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setNFreeSmallString(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setNFreeSmallString(self, null, string);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallContainerSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self           = allocSmallJson();
   smallContainert *container = allocSmallContainer(null);
 
   r = self->f->setNFreeSmallContainer(self, "1", container);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"<data container>\"}");
   free(s);
   // path
   smallContainert *value = allocSmallContainer(null);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreeSmallContainer(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"<data container>\",\"array\":[{\"key\":\"<data container>\"}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallContainer(null);
   r = self->f->setNFreeSmallContainer(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreeSmallContainer(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreeSmallContainer(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreeSmallContainer(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreeSmallContainer(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setNFreeSmallContainer(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setNFreeSmallContainer(self, null, container);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setPDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict;
 
   dict = allocSmallDict();
   r    = self->f->setDict(self, "1", dict);
   ck_assert_ptr_ne(r, null);
   dict->f->setInt(dict, "a", 1);
   r    = self->f->setPDict(self, "1", dict);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{\"a\":1}}");
   free(s);
   // empty dict
 	finishO(dict);
   dict = allocSmallDict();
   r    = self->f->setPDict(self, "1", dict);
   ck_assert_ptr_eq(r, null);
   finishO(dict);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":{\"a\":1}}");
   free(s);
   // non smallDict object
   dict = (smallDictt*) allocSmallInt(2);
   r = self->f->setPDict(self, "1", dict);
   ck_assert_ptr_eq(r, null);
   terminateO(dict);
   // path
   dict = allocSmallDict();
   dict->f->setInt(dict, "b", 2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setPDict(self, "\"array\"[0].\"key\"", dict);
   ck_assert_ptr_ne(r, null);
   finishO(dict);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{\"a\":1},\"array\":[{\"key\":{\"b\":2}}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   dict = allocSmallDict();
   dict->f->setInt(dict, "b", 2);
   r = self->f->setPDict(self, "1", dict);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setPDict(self, "1", dict);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setPDict(self, "\"1\"[1]", dict);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setPDict(self, "\"1\".\"1\"", dict);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setPDict(self, "\"2\".\"1\".[12]", dict);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setPDict(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setPDict(self, null, dict);
   ck_assert_ptr_eq(r, null);
   terminateO(dict);
   terminateO(self);
 
 }
 
 
 void setPArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *array;
 
   array   = allocSmallArray();
   r       = self->f->setArray(self, "1", array);
   ck_assert_ptr_ne(r, null);
   array->f->pushInt(array, 1);
   r       = self->f->setPArray(self, "1", array);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[1]}");
   free(s);
   // empty array
 	finishO(array);
   array = allocSmallArray();
   r    = self->f->setPArray(self, "1", array);
   ck_assert_ptr_eq(r, null);
   finishO(array);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":[1]}");
   free(s);
   // non smallDict object
   array = (smallArrayt*) allocSmallInt(2);
   r = self->f->setPArray(self, "1", array);
   ck_assert_ptr_eq(r, null);
   terminateO(array);
   // path
   array = allocSmallArray();
   array->f->pushInt(array, 2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setPArray(self, "\"array\"[0].\"key\"", array);
   ck_assert_ptr_ne(r, null);
   finishO(array);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[1],\"array\":[{\"key\":[2]}]}");
   free(s);
   // json bool
   array = allocSmallArray();
   array->f->pushInt(array, 2);
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setPArray(self, "1", array);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setPArray(self, "1", array);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setPArray(self, "\"1\"[1]", array);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setPArray(self, "\"1\".\"1\"", array);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setPArray(self, "\"2\".\"1\".[12]", array);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setPArray(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setPArray(self, null, array);
   ck_assert_ptr_eq(r, null);
   terminateO(array);
   terminateO(self);
 
 }
 
 
 void setPSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *json;
 
   json    = allocSmallJson();
   r       = self->f->setSmallJson(self, "1", json);
   ck_assert_ptr_ne(r, null);
   json->f->setInt(json, "a", 1);
   r       = self->f->setPSmallJson(self, "1", json);
   ck_assert_ptr_ne(r, null);
   finishO(json);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{\"a\":1}}");
   free(s);
   // empty smallJson
   json   = allocSmallJson();
   r = self->f->setPSmallJson(self, "1", json);
   ck_assert_ptr_eq(r, null);
   terminateO(json);
   // non smallJson object
   json = (smallJsont*) allocSmallInt(2);
   r = self->f->setPSmallJson(self, "1", json);
   ck_assert_ptr_eq(r, null);
   // path
   smallJsont *value = allocSmallJson();
   value->f->setInt(value, "b", 2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setPSmallJson(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{\"a\":1},\"array\":[{\"key\":{\"b\":2}}]}");
   free(s);
   // json bool
   value = allocSmallJson();
   value->f->setInt(value, "b", 2);
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setPSmallJson(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setPSmallJson(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setPSmallJson(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //    wrong path and empty smallInt container (sInt is allocated in toSmallt)
   createSmallJson(i);
   r = self->f->setPSmallJson(self, "\"1\".[1]", &i);
   ck_assert_ptr_eq(r, null);
   freeO(&i);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setPSmallJson(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setPSmallJson(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // null value
   r = self->f->setPSmallJson(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setPSmallJson(self, null, json);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(json);
 
 }
 
 
 void setPSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *string;
 
   string = allocSmallString("");
   r      = self->f->setSmallString(self, "1", string);
   ck_assert_ptr_ne(r, null);
   string->f->appendS(string, "s");
   r      = self->f->setPSmallString(self, "1", string);
   ck_assert_ptr_ne(r, null);
   finishO(string);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"s\"}");
   free(s);
   // empty SmallString
   string = allocSmallString("");
   freeO(string);
   r = self->f->setPSmallString(self, "1", string);
   ck_assert_ptr_eq(r, null);
   terminateO(string);
   // non smallString object
   string = (smallStringt*) allocSmallInt(2);
   r = self->f->setPSmallString(self, "1", string);
   ck_assert_ptr_eq(r, null);
   terminateO(string);
   // path
   smallStringt *value = allocSmallString("asd");
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setPSmallString(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"s\",\"array\":[{\"key\":\"asd\"}]}");
   free(s);
   // json bool
   value = allocSmallString("ASD");
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setPSmallString(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setPSmallString(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setPSmallString(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //    wrong path and empty smallInt container (sInt is allocated in toSmallt)
   createSmallString(i);
   r = self->f->setPSmallString(self, "\"1\".[1]", &i);
   ck_assert_ptr_eq(r, null);
   freeO(&i);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setPSmallString(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setPSmallString(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // null value
   r = self->f->setPSmallString(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   string = allocSmallString("");
   r = self->f->setPSmallString(self, null, string);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(string);
 
 }
 
 
 void setNFreePDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *value;
 
   value   = allocSmallDict();
   r       = self->f->setDict(self, "1", value);
   ck_assert_ptr_ne(r, null);
   value->f->setInt(value, "a", 1);
   r       = self->f->setNFreePDict(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{\"a\":1}}");
   free(s);
   // empty smallDict
   value   = allocSmallDict();
   r       = self->f->setNFreePDict(self, "1", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // non smallDict object
   value = (smallDictt*) allocSmallInt(2);
   r = self->f->setNFreePDict(self, "1", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // path
   value = allocSmallDict();
   value->f->setInt(value, "b", 2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreePDict(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{\"a\":1},\"array\":[{\"key\":{\"b\":2}}]}");
   free(s);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallDict();
   value->f->setInt(value, "b", 2);
   r = self->f->setNFreePDict(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreePDict(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreePDict(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreePDict(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreePDict(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setNFreePDict(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setNFreePDict(self, null, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void setNFreePArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *value;
 
   value   = allocSmallArray();
   r       = self->f->setArray(self, "1", value);
   ck_assert_ptr_ne(r, null);
   value->f->pushInt(value, 2);
   r       = self->f->setNFreePArray(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[2]}");
   free(s);
   // empty smallArray
   value   = allocSmallArray();
   r       = self->f->setNFreePArray(self, "1", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // non smallArray object
   value   = (smallArrayt*) allocSmallInt(2);
   r       = self->f->setNFreePArray(self, "1", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // path
   value = allocSmallArray();
   value->f->pushInt(value, 3);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreePArray(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[2],\"array\":[{\"key\":[3]}]}");
   free(s);
   // json bool
   value = allocSmallArray();
   value->f->pushInt(value, 2);
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setNFreePArray(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreePArray(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreePArray(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreePArray(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreePArray(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setNFreePArray(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setNFreePArray(self, null, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void setNFreePSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value;
 
   value   = allocSmallJson();
   r       = self->f->setSmallJson(self, "1", value);
   ck_assert_ptr_ne(r, null);
   value->f->setInt(value, "a", 1);
   r       = self->f->setNFreePSmallJson(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{\"a\":1}}");
   free(s);
   // empty smallJson
   value   = allocSmallJson();
   r = self->f->setNFreePSmallJson(self, "1", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // non smallJson object
   value = (smallJsont*) allocSmallInt(2);
   r = self->f->setNFreePSmallJson(self, "1", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // path
   value = allocSmallJson();
   value->f->setInt(value, "b", 2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreePSmallJson(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{\"a\":1},\"array\":[{\"key\":{\"b\":2}}]}");
   free(s);
   // json bool
   value = allocSmallJson();
   value->f->setInt(value, "b", 2);
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setNFreePSmallJson(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreePSmallJson(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreePSmallJson(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //    wrong path and empty smallInt container (sInt is allocated in toSmallt)
   createSmallJson(i);
   r = self->f->setNFreePSmallJson(self, "\"1\".[1]", &i);
   ck_assert_ptr_eq(r, null);
   freeO(&i);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreePSmallJson(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreePSmallJson(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setNFreePSmallJson(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setNFreePSmallJson(self, null, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void setNFreePSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *value;
 
   value = allocSmallString("");
   r       = self->f->setSmallString(self, "1", value);
   ck_assert_ptr_ne(r, null);
   value->f->appendS(value, "2");
   r       = self->f->setNFreePSmallString(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"2\"}");
   free(s);
   // empty SmallString
   value   = allocSmallString("");
   freeO(value);
   r = self->f->setNFreePSmallString(self, "1", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // non smallString object
   value = (smallStringt*) allocSmallInt(2);
   r = self->f->setNFreePSmallString(self, "1", value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // path
   value = allocSmallString("asd");
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setNFreePSmallString(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"2\",\"array\":[{\"key\":\"asd\"}]}");
   free(s);
   // json bool
   value = allocSmallString("ASD");
   freeO(self);
   setTypeBoolO(self);
   r = self->f->setNFreePSmallString(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->setNFreePSmallString(self, "1", value);
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->setNFreePSmallString(self, "\"1\"[1]", value);
   ck_assert_ptr_eq(r, null);
   //    wrong path and empty smallInt container (sInt is allocated in toSmallt)
   createSmallString(i);
   r = self->f->setNFreePSmallString(self, "\"1\".[1]", &i);
   ck_assert_ptr_eq(r, null);
   freeO(&i);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->setNFreePSmallString(self, "\"1\".\"1\"", value);
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->setNFreePSmallString(self, "\"2\".\"1\".[12]", value);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->setNFreePSmallString(self, "1", null);
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->setNFreePSmallString(self, null, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void setAtSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = (baset*)allocSmallInt(123);
   r       = self->f->setAt(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,123,3,4]");
   free(s);
   // negative index
   value   = (baset*)allocSmallInt(234);
   r = self->f->setAt(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,123,3,234]");
   free(s);
   // undefined object
   value   = (baset*)allocUndefined();
   r = self->f->setAt(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,123,3,null]");
   free(s);
   // container
   createAllocateSmallContainer(c);
   r = self->f->setAt(self, -1, (baset*)c);
   ck_assert_ptr_ne(r, null);
   finishO(c);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]");
   free(s);
   // base object in container
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r = self->f->setAt(self, -1, (baset*)I);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]");
   free(s);
   // index outside
   value = (baset*)allocSmallInt(123);
   ck_assert_ptr_eq(self->f->setAt(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAt(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAt(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAt(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAt(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setAtUndefinedSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   r       = self->f->setAtUndefined(self, 1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,null,3,4]");
   free(s);
   // negative index
   r = self->f->setAtUndefined(self, -1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,null,3,null]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->setAtUndefined(self, 20), NULL);
   ck_assert_ptr_eq(self->f->setAtUndefined(self, -8), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtUndefined(self, 0), NULL);
   ck_assert_ptr_eq(self->f->setAtUndefined(self, -1), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->setAtUndefined(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void setAtBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   r       = self->f->setAtBool(self, 1, true);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,true,3,4]");
   free(s);
   // negative index
   r = self->f->setAtBool(self, -1, true);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,true,3,true]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->setAtBool(self, 20, true), NULL);
   ck_assert_ptr_eq(self->f->setAtBool(self, -8, true), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtBool(self, 0, true), NULL);
   ck_assert_ptr_eq(self->f->setAtBool(self, -1, true), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->setAtBool(self, 0, true), NULL);
   terminateO(self);
 
 }
 
 
 void setAtDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   r       = self->f->setAtDouble(self, 1, 12);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,1.200000e+01,3,4]");
   free(s);
   // negative index
   r = self->f->setAtDouble(self, -1, 14);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,1.200000e+01,3,1.400000e+01]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->setAtDouble(self, 20, 1), NULL);
   ck_assert_ptr_eq(self->f->setAtDouble(self, -8, 1), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtDouble(self, 0, 1), NULL);
   ck_assert_ptr_eq(self->f->setAtDouble(self, -1, 1), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->setAtDouble(self, 0, 1), NULL);
   terminateO(self);
 
 }
 
 
 void setAtIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   r       = self->f->setAtInt(self, 1, 12);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,12,3,4]");
   free(s);
   // negative index
   r = self->f->setAtInt(self, -1, 14);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,12,3,14]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->setAtInt(self, 20, 1), NULL);
   ck_assert_ptr_eq(self->f->setAtInt(self, -8, 1), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtInt(self, 0, 1), NULL);
   ck_assert_ptr_eq(self->f->setAtInt(self, -1, 1), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->setAtInt(self, 0, 1), NULL);
   terminateO(self);
 
 }
 
 
 void setAtSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   r       = self->f->setAtS(self, 1, "a");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"a\",3,4]");
   free(s);
   // negative index
   r = self->f->setAtS(self, -1, "b");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"a\",3,\"b\"]");
   free(s);
   // NULL string
   r = self->f->setAtS(self, -1, NULL);
   ck_assert_ptr_eq(r, null);
   // index outside
   ck_assert_ptr_eq(self->f->setAtS(self, 20, ""), NULL);
   ck_assert_ptr_eq(self->f->setAtS(self, -8, ""), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtS(self, 0, ""), NULL);
   ck_assert_ptr_eq(self->f->setAtS(self, -1, ""), NULL);
   terminateO(self);
 
 }
 
 
 void setAtCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   r       = self->f->setAtChar(self, 1, 'a');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"a\",3,4]");
   free(s);
   // negative index
   r = self->f->setAtChar(self, -1, 'b');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"a\",3,\"b\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->setAtChar(self, 20, 'a'), NULL);
   ck_assert_ptr_eq(self->f->setAtChar(self, -8, 's'), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtChar(self, 0, 'a'), NULL);
   ck_assert_ptr_eq(self->f->setAtChar(self, -1, 's'), NULL);
   terminateO(self);
 
 }
 
 
 void setAtDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallDict();
   r       = self->f->setAtDict(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,{},3,4]");
   free(s);
   // negative index
   value   = allocSmallDict();
   r = self->f->setAtDict(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,{},3,{}]");
   free(s);
   // index outside
   value = allocSmallDict();
   ck_assert_ptr_eq(self->f->setAtDict(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtDict(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtDict(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtDict(self, -1, value), NULL);
   terminateO(value);
   // non smallDict object
   value = (smallDictt*) allocSmallInt(2);
   r = self->f->setAtDict(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtDict(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setAtArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallArray();
   r       = self->f->setAtArray(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,[],3,4]");
   free(s);
   // negative index
   value   = allocSmallArray();
   r = self->f->setAtArray(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[],3,[]]");
   free(s);
   // index outside
   value = allocSmallArray();
   ck_assert_ptr_eq(self->f->setAtArray(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtArray(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtArray(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtArray(self, -1, value), NULL);
   terminateO(value);
   // non smallArray object
   value = (smallArrayt*) allocSmallInt(2);
   r = self->f->setAtArray(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtArray(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setAtArraycSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = listCreateS("a");
   r       = self->f->setAtArrayc(self, 1, value);
   ck_assert_ptr_ne(r, null);
   listFreeS(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,[\"a\"],3,4]");
   free(s);
   // negative index
   value   = listCreateS("b");
   r = self->f->setAtArrayc(self, -1, value);
   ck_assert_ptr_ne(r, null);
   listFreeS(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[\"a\"],3,[\"b\"]]");
   free(s);
   // index outside
   value = (char**)r;
   ck_assert_ptr_eq(self->f->setAtArrayc(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtArrayc(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtArrayc(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtArrayc(self, -1, value), NULL);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtArrayc(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setAtSmallBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallBool(true);
   r       = self->f->setAtSmallBool(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,true,3,4]");
   free(s);
   // negative index
   value   = allocSmallBool(true);
   r = self->f->setAtSmallBool(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,true,3,true]");
   free(s);
   // empty smallBool
   value = allocSmallBool(true);
   freeO(value);
   r = self->f->setAtSmallBool(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,true,3,false]");
   free(s);
   // index outside
   value = allocSmallBool(true);
   ck_assert_ptr_eq(self->f->setAtSmallBool(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtSmallBool(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtSmallBool(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtSmallBool(self, -1, value), NULL);
   terminateO(value);
   // non smallBool object
   value = (smallBoolt*) allocSmallInt(2);
   r = self->f->setAtSmallBool(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtSmallBool(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setAtSmallBytesSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBytest *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallBytes(NULL, 0);
   r       = self->f->setAtSmallBytes(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,[],3,4]");
   free(s);
   // empty smallBytes
   value   = allocSmallBytes(NULL, 0);
   freeO(value);
   r       = self->f->setAtSmallBytes(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[],3,4]");
   free(s);
   // negative index
   value   = allocSmallBytes(NULL, 0);
   r = self->f->setAtSmallBytes(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[],3,[]]");
   free(s);
   // index outside
   value = allocSmallBytes(NULL, 0);
   ck_assert_ptr_eq(self->f->setAtSmallBytes(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtSmallBytes(self, -5, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtSmallBytes(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtSmallBytes(self, -1, value), NULL);
   terminateO(value);
   // non smallBytes object
   value = (smallBytest*) allocSmallInt(2);
   r = self->f->setAtSmallBytes(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtSmallBytes(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setAtSmallDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDoublet *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallDouble(5);
   r       = self->f->setAtSmallDouble(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,5.000000e+00,3,4]");
   free(s);
   // negative index
   value   = allocSmallDouble(6);
   r = self->f->setAtSmallDouble(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,5.000000e+00,3,6.000000e+00]");
   free(s);
   // empty smallDouble
   value   = allocSmallDouble(0);
   freeO(value);
   r = self->f->setAtSmallDouble(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,5.000000e+00,3,0.000000e+00]");
   free(s);
   // index outside
   value = allocSmallDouble(1);
   ck_assert_ptr_eq(self->f->setAtSmallDouble(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtSmallDouble(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtSmallDouble(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtSmallDouble(self, -1, value), NULL);
   terminateO(value);
   // non smallDouble object
   value = (smallDoublet*) allocSmallInt(2);
   r = self->f->setAtSmallDouble(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtSmallDouble(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setAtSmallIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallInt(5);
   r       = self->f->setAtSmallInt(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,5,3,4]");
   free(s);
   // negative index
   value   = allocSmallInt(6);
   r = self->f->setAtSmallInt(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,5,3,6]");
   free(s);
   // empty SmallInt
   value   = allocSmallInt(0);
   freeO(value);
   r = self->f->setAtSmallInt(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,5,3,0]");
   free(s);
   // index outside
   value = allocSmallInt(1);
   ck_assert_ptr_eq(self->f->setAtSmallInt(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtSmallInt(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtSmallInt(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtSmallInt(self, -1, value), NULL);
   terminateO(value);
   // non smallInt object
   value = (smallIntt*) allocSmallBool(true);
   r = self->f->setAtSmallInt(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtSmallInt(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setAtSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallJson();
   r       = self->f->setAtSmallJson(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,{},3,4]");
   free(s);
   // negative index
   value   = allocSmallJson();
   r = self->f->setAtSmallJson(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,{},3,{}]");
   free(s);
   // index outside
   value = allocSmallJson();
   ck_assert_ptr_eq(self->f->setAtSmallJson(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtSmallJson(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtSmallJson(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtSmallJson(self, -1, value), NULL);
   terminateO(value);
   // non smallJson object
   value = (smallJsont*) allocSmallInt(2);
   r = self->f->setAtSmallJson(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtSmallJson(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setAtSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   initiateAllocateSmallString(&value);
   r       = self->f->setAtSmallString(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"\",3,4]");
   free(s);
   // negative index
   value   = allocSmallString("a");
   r = self->f->setAtSmallString(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"\",3,\"a\"]");
   free(s);
   // index outside
   value = allocSmallString("asd");
   ck_assert_ptr_eq(self->f->setAtSmallString(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtSmallString(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtSmallString(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtSmallString(self, -1, value), NULL);
   terminateO(value);
   // non smallString object
   value = (smallStringt*) allocSmallInt(2);
   r = self->f->setAtSmallString(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtSmallString(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setAtSmallContainerSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallContainert *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   initiateAllocateSmallContainer(&value);
   r       = self->f->setAtSmallContainer(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,4]");
   free(s);
   // negative index
   initiateAllocateSmallContainer(&value);
   r = self->f->setAtSmallContainer(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]");
   free(s);
   // index outside
   initiateAllocateSmallContainer(&value);
   ck_assert_ptr_eq(self->f->setAtSmallContainer(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtSmallContainer(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtSmallContainer(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtSmallContainer(self, -1, value), NULL);
   terminateO(value);
   // non smallContainer object
   value = (smallContainert*) allocSmallInt(2);
   r = self->f->setAtSmallContainer(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtSmallContainer(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = (baset*)allocSmallInt(123);
   r       = self->f->setAtNFree(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,123,3,4]");
   free(s);
   // negative index
   value   = (baset*)allocSmallInt(234);
   r = self->f->setAtNFree(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,123,3,234]");
   free(s);
   // undefined object
   value   = (baset*)allocUndefined();
   r = self->f->setAtNFree(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,123,3,null]");
   free(s);
   // container
   createAllocateSmallContainer(c);
   r = self->f->setAtNFree(self, -1, (baset*)c);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]");
   free(s);
   // base object in container
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r = self->f->setAtNFree(self, -1, (baset*)I);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,123,3,\"<data container>\"]");
   free(s);
   // index outside
   value = (baset*)allocSmallInt(123);
   ck_assert_ptr_eq(self->f->setAtNFree(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFree(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtNFree(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFree(self, -1, value), NULL);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtNFree(self, 0, NULL), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setAtNFreeUndefinedSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   undefinedt *value = NULL;
 
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value = allocUndefined();
   r       = self->f->setAtNFreeUndefined(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,null,3,4]");
   free(s);
   // negative index
   value = allocUndefined();
   r = self->f->setAtNFreeUndefined(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,null,3,null]");
   free(s);
   // index outside
   value = allocUndefined();
   ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, 20, value), NULL);
   terminateO(value);
   value = allocUndefined();
   ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, -8, value), NULL);
   terminateO(value);
   // empty list
   emptyO(self);
   value = allocUndefined();
   ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, 0, value), NULL);
   terminateO(value);
   value = allocUndefined();
   ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, -1, value), NULL);
   terminateO(value);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = allocUndefined();
   ck_assert_ptr_eq(self->f->setAtNFreeUndefined(self, 0, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   r       = self->f->setAtNFreeS(self, 1, strdup("a"));
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"a\",3,4]");
   free(s);
   // negative index
   r = self->f->setAtNFreeS(self, -1, strdup("b"));
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"a\",3,\"b\"]");
   free(s);
   // NULL string
   r = self->f->setAtNFreeS(self, -1, NULL);
   ck_assert_ptr_eq(r, null);
   // index outside
   ck_assert_ptr_eq(self->f->setAtNFreeS(self, 20, ""), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeS(self, -8, ""), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtNFreeS(self, 0, ""), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeS(self, -1, ""), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->setAtNFreeS(self, 0, ""), NULL);
   terminateO(self);
 
 }
 
 
 void setAtNFreeDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallDict();
   r       = self->f->setAtNFreeDict(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,{},3,4]");
   free(s);
   // negative index
   value   = allocSmallDict();
   r = self->f->setAtNFreeDict(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,{},3,{}]");
   free(s);
   // index outside
   value = allocSmallDict();
   ck_assert_ptr_eq(self->f->setAtNFreeDict(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeDict(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtNFreeDict(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeDict(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtNFreeDict(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallDict();
   ck_assert_ptr_eq(self->f->setAtNFreeDict(self, 0, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setAtNFreeArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallArray();
   r       = self->f->setAtNFreeArray(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,[],3,4]");
   free(s);
   // negative index
   value   = allocSmallArray();
   r = self->f->setAtNFreeArray(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[],3,[]]");
   free(s);
   // index outside
   value = allocSmallArray();
   ck_assert_ptr_eq(self->f->setAtNFreeArray(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeArray(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtNFreeArray(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeArray(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtNFreeArray(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallArray();
   ck_assert_ptr_eq(self->f->setAtNFreeArray(self, 0, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setAtNFreeArraycSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = listCreateS("a");
   r       = self->f->setAtNFreeArrayc(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,[\"a\"],3,4]");
   free(s);
   // negative index
   value   = listCreateS("b");
   r = self->f->setAtNFreeArrayc(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[\"a\"],3,[\"b\"]]");
   free(s);
   // index outside
   value = (char**)r;
   ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, -1, value), NULL);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = listCreateS("b");
   ck_assert_ptr_eq(self->f->setAtNFreeArrayc(self, 0, value), NULL);
   listFreeS(value);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallBool(true);
   r       = self->f->setAtNFreeSmallBool(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,true,3,4]");
   free(s);
   // negative index
   value   = allocSmallBool(true);
   r = self->f->setAtNFreeSmallBool(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,true,3,true]");
   free(s);
   // index outside
   value = allocSmallBool(true);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallBool(true);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallBool(self, 0, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallBytesSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBytest *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallBytes(NULL, 0);
   r       = self->f->setAtNFreeSmallBytes(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,[],3,4]");
   free(s);
   // negative index
   value   = allocSmallBytes(NULL, 0);
   r = self->f->setAtNFreeSmallBytes(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[],3,[]]");
   free(s);
   // index outside
   value = allocSmallBytes(NULL, 0);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, -5, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallBytes("", sizeof(""));
   ck_assert_ptr_eq(self->f->setAtNFreeSmallBytes(self, 0, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDoublet *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallDouble(5);
   r       = self->f->setAtNFreeSmallDouble(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,5.000000e+00,3,4]");
   free(s);
   // negative index
   value   = allocSmallDouble(6);
   r = self->f->setAtNFreeSmallDouble(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,5.000000e+00,3,6.000000e+00]");
   free(s);
   // index outside
   value = allocSmallDouble(1);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallDouble(1);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallDouble(self, 0, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallInt(5);
   r       = self->f->setAtNFreeSmallInt(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,5,3,4]");
   free(s);
   // negative index
   value   = allocSmallInt(6);
   r = self->f->setAtNFreeSmallInt(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,5,3,6]");
   free(s);
   // index outside
   value = allocSmallInt(1);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallInt(2);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallInt(self, 0, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallJson();
   r       = self->f->setAtNFreeSmallJson(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,{},3,4]");
   free(s);
   // negative index
   value   = allocSmallJson();
   r = self->f->setAtNFreeSmallJson(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,{},3,{}]");
   free(s);
   // index outside
   value = allocSmallJson();
   ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallJson();
   ck_assert_ptr_eq(self->f->setAtNFreeSmallJson(self, 0, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   initiateAllocateSmallString(&value);
   r       = self->f->setAtNFreeSmallString(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"\",3,4]");
   free(s);
   // negative index
   value   = allocSmallString("a");
   r = self->f->setAtNFreeSmallString(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"\",3,\"a\"]");
   free(s);
   // index outside
   value = allocSmallString("asd");
   ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallString("qwe");
   ck_assert_ptr_eq(self->f->setAtNFreeSmallString(self, 0, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallContainerSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallContainert *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   initiateAllocateSmallContainer(&value);
   r       = self->f->setAtNFreeSmallContainer(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,4]");
   free(s);
   // negative index
   initiateAllocateSmallContainer(&value);
   r = self->f->setAtNFreeSmallContainer(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]");
   free(s);
   // index outside
   initiateAllocateSmallContainer(&value);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   initiateAllocateSmallContainer(&value);
   ck_assert_ptr_eq(self->f->setAtNFreeSmallContainer(self, 0, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void setPAtDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallDict();
   r       = self->f->setAtDict(self, 1, value);
   ck_assert_ptr_ne(r, null);
   value->f->setInt(value, "a", 1);
   r       = self->f->setPAtDict(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,{\"a\":1},3,4]");
   free(s);
   // negative index
   value   = allocSmallDict();
   r       = self->f->setAtDict(self, -1, value);
   ck_assert_ptr_ne(r, null);
   value->f->setInt(value, "a", 2);
   r       = self->f->setPAtDict(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]");
   free(s);
   // empty smallDict
   value   = allocSmallDict();
   r       = self->f->setPAtDict(self, -1, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // non smallDict object
   value   = (smallDictt*) allocSmallInt(2);
   r       = self->f->setPAtDict(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // index outside
   value = allocSmallDict();
   ck_assert_ptr_eq(self->f->setPAtDict(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtDict(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setPAtDict(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtDict(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setPAtDict(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setPAtArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallArray();
   r       = self->f->setAtArray(self, 1, value);
   ck_assert_ptr_ne(r, null);
   value->f->pushInt(value, 1);
   r       = self->f->setPAtArray(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,[1],3,4]");
   free(s);
   // negative index
   value   = allocSmallArray();
   r = self->f->setAtArray(self, -1, value);
   ck_assert_ptr_ne(r, null);
   value->f->pushInt(value, 2);
   r       = self->f->setPAtArray(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[1],3,[2]]");
   free(s);
   // empty smallArray
   value   = allocSmallArray();
   r       = self->f->setPAtArray(self, -1, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // non smallArray object
   value   = (smallArrayt*) allocSmallInt(2);
   r       = self->f->setPAtArray(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // index outside
   value = allocSmallArray();
   ck_assert_ptr_eq(self->f->setPAtArray(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtArray(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setPAtArray(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtArray(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setPAtArray(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setPAtSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallJson();
   r       = self->f->setAtSmallJson(self, 1, value);
   ck_assert_ptr_ne(r, null);
   value->f->setInt(value, "a", 1);
   r       = self->f->setPAtSmallJson(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,{\"a\":1},3,4]");
   free(s);
   // negative index
   value   = allocSmallJson();
   r = self->f->setAtSmallJson(self, -1, value);
   ck_assert_ptr_ne(r, null);
   value->f->setInt(value, "a", 2);
   r       = self->f->setPAtSmallJson(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]");
   free(s);
   // empty smallJson
   value   = allocSmallJson();
   r = self->f->setPAtSmallJson(self, -1, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // non smallJson object
   value = (smallJsont*) allocSmallInt(2);
   r = self->f->setPAtSmallJson(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // index outside
   value = allocSmallJson();
   ck_assert_ptr_eq(self->f->setPAtSmallJson(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtSmallJson(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setPAtSmallJson(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtSmallJson(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setPAtSmallJson(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setPAtSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   initiateAllocateSmallString(&value);
   r       = self->f->setAtSmallString(self, 1, value);
   ck_assert_ptr_ne(r, null);
   value->f->appendS(value, "1");
   r       = self->f->setPAtSmallString(self, 1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"1\",3,4]");
   free(s);
   // negative index
   value   = allocSmallString("a");
   r = self->f->setAtSmallString(self, -1, value);
   ck_assert_ptr_ne(r, null);
   value->f->appendS(value, "2");
   r       = self->f->setPAtSmallString(self, -1, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"1\",3,\"a2\"]");
   free(s);
   // empty SmallString
   value   = allocSmallString("");
   freeO(value);
   r = self->f->setPAtSmallString(self, -1, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // non smallString object
   value = (smallStringt*) allocSmallInt(2);
   r = self->f->setPAtSmallString(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // index outside
   value = allocSmallString("asd");
   ck_assert_ptr_eq(self->f->setPAtSmallString(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtSmallString(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setPAtSmallString(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtSmallString(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setPAtSmallString(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setPAtNFreeDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallDict();
   r       = self->f->setAtDict(self, 1, value);
   ck_assert_ptr_ne(r, null);
   value->f->setInt(value, "a", 1);
   r       = self->f->setPAtNFreeDict(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,{\"a\":1},3,4]");
   free(s);
   // negative index
   value   = allocSmallDict();
   r       = self->f->setAtDict(self, -1, value);
   ck_assert_ptr_ne(r, null);
   value->f->setInt(value, "a", 2);
   r       = self->f->setPAtNFreeDict(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]");
   free(s);
   // empty smallDict
   value   = allocSmallDict();
   r       = self->f->setPAtNFreeDict(self, -1, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // non smallDict object
   value = (smallDictt*) allocSmallInt(2);
   r = self->f->setPAtNFreeDict(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // index outside
   value = allocSmallDict();
   ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setPAtNFreeDict(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setPAtNFreeArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallArray();
   r       = self->f->setAtArray(self, 1, value);
   ck_assert_ptr_ne(r, null);
   value->f->pushInt(value, 1);
   r       = self->f->setPAtNFreeArray(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,[1],3,4]");
   free(s);
   // negative index
   value   = allocSmallArray();
   r = self->f->setAtArray(self, -1, value);
   ck_assert_ptr_ne(r, null);
   value->f->pushInt(value, 2);
   r       = self->f->setPAtNFreeArray(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[1],3,[2]]");
   free(s);
   // empty smallArray
   value   = allocSmallArray();
   r       = self->f->setPAtNFreeArray(self, -1, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // non smallArray object
   value   = (smallArrayt*) allocSmallInt(2);
   r       = self->f->setPAtNFreeArray(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // index outside
   value = allocSmallArray();
   ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setPAtNFreeArray(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setPAtNFreeSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value   = allocSmallJson();
   r       = self->f->setAtSmallJson(self, 1, value);
   ck_assert_ptr_ne(r, null);
   value->f->setInt(value, "a", 1);
   r       = self->f->setPAtNFreeSmallJson(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,{\"a\":1},3,4]");
   free(s);
   // negative index
   value   = allocSmallJson();
   r = self->f->setAtSmallJson(self, -1, value);
   ck_assert_ptr_ne(r, null);
   value->f->setInt(value, "a", 2);
   r       = self->f->setPAtNFreeSmallJson(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,{\"a\":1},3,{\"a\":2}]");
   free(s);
   // empty smallJson
   value   = allocSmallJson();
   r = self->f->setPAtNFreeSmallJson(self, -1, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // non smallJson object
   value = (smallJsont*) allocSmallInt(2);
   r = self->f->setPAtNFreeSmallJson(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // index outside
   value = allocSmallJson();
   ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setPAtNFreeSmallJson(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void setPAtNFreeSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *value;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   initiateAllocateSmallString(&value);
   r       = self->f->setAtSmallString(self, 1, value);
   ck_assert_ptr_ne(r, null);
   value->f->appendS(value, "1");
   r       = self->f->setPAtNFreeSmallString(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"1\",3,4]");
   free(s);
   // negative index
   value   = allocSmallString("a");
   r = self->f->setAtSmallString(self, -1, value);
   ck_assert_ptr_ne(r, null);
   value->f->appendS(value, "2");
   r       = self->f->setPAtNFreeSmallString(self, -1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"1\",3,\"a2\"]");
   free(s);
   // empty SmallString
   value   = allocSmallString("");
   freeO(value);
   r = self->f->setPAtNFreeSmallString(self, -1, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // non smallString object
   value = (smallStringt*) allocSmallInt(2);
   r = self->f->setPAtNFreeSmallString(self, 0, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // index outside
   value = allocSmallString("asd");
   ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, 20, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, -8, value), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, 0, value), NULL);
   ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, -1, value), NULL);
   terminateO(value);
   // NULL value
   ck_assert_ptr_eq(self->f->setPAtNFreeSmallString(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void pushUndefinedSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,null]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushUndefined(self), NULL);
   terminateO(self);
 
 }
 
 
 void pushBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,true]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushBool(self, true), NULL);
   terminateO(self);
 
 }
 
 
 void pushDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushDouble(self, 1.0);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,1.000000e+00]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushDouble(self, 2.2), NULL);
   terminateO(self);
 
 }
 
 
 void pushIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushInt(self, 3), NULL);
   terminateO(self);
 
 }
 
 
 void pushSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushS(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   char *str = "poi";
   r = self->f->pushS(self, str);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"poi\"]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushS(self, "qwe"), NULL);
   terminateO(self);
   // json string
   self = allocSmallJson();
   setTopSO(self, "qwe");
   r = self->f->pushS(self, "!@#");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "qwe!@#");
   free(s);
   // empty string
   r = self->f->pushS(self, "");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "qwe!@#");
   free(s);
   // empty self
   freeO(self);
   setTypeStringO(self);
   r = self->f->pushS(self, "asd");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "asd");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushChar(self, 'a');
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"a\"]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushChar(self, 'a'), NULL);
   terminateO(self);
 
 }
 
 
 void pushDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict  = allocG(rtSmallDictt);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   // push dict
   r = self->f->pushDict(self, dict);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,{}]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushDict(self, dict), NULL);
   finishO(dict);
   setTypeArrayO(self);
   // non smallDict object
   dict = (smallDictt*) allocSmallInt(2);
   r = self->f->pushDict(self, dict);
   ck_assert_ptr_eq(r, null);
   terminateO(dict);
   // null
   r = self->f->pushDict(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 0);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallArrayt *array = allocG(rtSmallArrayt);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushArray(self, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,[]]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushArray(self, array), NULL);
   finishO(array);
   setTypeArrayO(self);
   // non smallArray object
   array = (smallArrayt*) allocSmallInt(2);
   r = self->f->pushArray(self, array);
   ck_assert_ptr_eq(r, null);
   terminateO(array);
   // null
   r = self->f->pushArray(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 0);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushArraycSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array      = listCreateS("a","bb");
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->pushArrayc(self, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushArrayc(self, array), NULL);
   listFreeS(array);
   setTypeArrayO(self);
   // null
   r = self->f->pushArrayc(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 0);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSmallBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value = allocG(TRUE);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushSmallBool(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,true]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushSmallBool(self, value), NULL);
   finishO(value);
   setTypeArrayO(self);
   // non smallBool object
   value = (smallBoolt*) allocSmallInt(2);
   r = self->f->pushSmallBool(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // bool object with no data
   createAllocateSmallBool(b);
   r = self->f->pushSmallBool(self, b);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   finishO(b);
   s = toStringO(r);
   ck_assert_str_eq(s, "[false]");
   free(s);
   // null
   r = self->f->pushSmallBool(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSmallBytesSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallBytes(value);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   // the smallBytes container is empty
   r = self->f->pushSmallBytes(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,[]]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushSmallBytes(self, value), NULL);
   setTypeArrayO(self);
   // reuse value
   value->B = null;
   char *buffer = "poi";
   pushBufferO(value, buffer, strlen(buffer));
   r = self->f->pushSmallBytes(self, value);
   finishO(value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[0x70,0x6f,0x69]]");
   free(s);
   // non smallBytes object
   value = (smallBytest*) allocSmallInt(2);
   r = self->f->pushSmallBytes(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // null
   r = self->f->pushSmallBytes(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[[0x70,0x6f,0x69]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSmallDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallDoublet *value = allocG(1.0);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushSmallDouble(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,1.000000e+00]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushSmallDouble(self, value), NULL);
   finishO(value);
   setTypeArrayO(self);
   // object with no data
   createAllocateSmallDouble(b);
   r = self->f->pushSmallDouble(self, b);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   finishO(b);
   s = toStringO(r);
   ck_assert_str_eq(s, "[0.000000e+00]");
   free(s);
   // non smallDouble object
   value = (smallDoublet*) allocSmallInt(2);
   r = self->f->pushSmallDouble(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // null
   r = self->f->pushSmallDouble(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[0.000000e+00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSmallIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocG(1);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushSmallInt(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushSmallInt(self, value), NULL);
   finishO(value);
   setTypeArrayO(self);
   // int object with no data
   createAllocateSmallInt(b);
   r = self->f->pushSmallInt(self, b);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   finishO(b);
   s = toStringO(r);
   ck_assert_str_eq(s, "[0]");
   free(s);
   // non smallInt object
   value = (smallIntt*) allocSmallBool(true);
   r = self->f->pushSmallInt(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // null
   r = self->f->pushSmallInt(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[0]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocG(rtSmallJsont);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   // the smallJson container is empty
   r = self->f->pushSmallJson(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,{}]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushSmallJson(self, value), NULL);
   setTypeArrayO(self);
   resetO(value);
   parseO(value, "{}");
   r = self->f->pushSmallJson(self, value);
   finishO(value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   // non smallJson object
   value = (smallJsont*) allocSmallInt(2);
   r = self->f->pushSmallJson(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // null
   r = self->f->pushSmallJson(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   createAllocateSmallString(string);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushSmallString(self, string);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"\"]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushSmallString(self, string), NULL);
   finishO(string);
   setTypeArrayO(self);
   // non smallString object
   string = (smallStringt*) allocSmallInt(2);
   r = self->f->pushSmallString(self, string);
   ck_assert_ptr_eq(r, null);
   terminateO(string);
   // null
   r = self->f->pushSmallString(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 0);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
   // json string
   self   = allocSmallJson();
   setTopSO(self, "qwe");
   string = allocSmallString("!@#");
   r = self->f->pushSmallString(self, string);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "qwe!@#");
   free(s);
   // empty string
   setValO(string, "");
   r = self->f->pushSmallString(self, string);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "qwe!@#");
   free(s);
   freeO(string);
   r = self->f->pushSmallString(self, string);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "qwe!@#");
   free(s);
   // empty self
   freeO(self);
   setTypeStringO(self);
   setValO(string, "asd");
   r = self->f->pushSmallString(self, string);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "asd");
   free(s);
   terminateO(string);
   // not smallString object
   string = (smallStringt*) allocSmallInt(1);
   r = self->f->pushSmallString(self, string);
   ck_assert_ptr_eq(r, null);
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void pushSmallContainerSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self          = allocSmallJson();
   createAllocateSmallContainer(container);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushSmallContainer(self, container);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"<data container>\"]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushSmallContainer(self, container), NULL);
   finishO(container);
   setTypeArrayO(self);
   // non smallContainer object
   container = (smallContainert*) allocSmallInt(2);
   r = self->f->pushSmallContainer(self, container);
   ck_assert_ptr_eq(r, null);
   terminateO(container);
   // null
   r = self->f->pushSmallContainer(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 0);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*) allocG(2);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushNFree(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   // null
   r = self->f->pushNFree(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   // non json array
   freeO(self);
   value = (baset*) allocSmallInt(2);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pushNFree(self, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void pushNFreeUndefinedSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   createAllocateUndefined(value);
   r = self->f->pushNFreeUndefined(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,null]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->pushNFreeS(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
 
   char *str = strdup("poi");
   r = self->f->pushNFreeS(self, str);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"poi\"]");
   free(s);
 
   terminateO(self);
 
 }
 
 
 void pushNFreeDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict  = allocG(rtSmallDictt);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // push dict
   r = self->f->pushNFreeDict(self, dict);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,{}]");
   free(s);
   // null
   r = self->f->pushNFreeDict(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallArrayt *array = allocG(rtSmallArrayt);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->pushNFreeArray(self, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,[]]");
   free(s);
   // null
   r = self->f->pushNFreeArray(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeArraycSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array      = listCreateS("a","bb");
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->pushNFreeArrayc(self, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]");
   free(s);
   // null
   r = self->f->pushNFreeArrayc(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[\"a\",\"bb\"]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value = allocG(TRUE);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->pushNFreeSmallBool(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,true]");
   free(s);
   // bool object with no data
   createAllocateSmallBool(b);
   r = self->f->pushNFreeSmallBool(self, b);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,true,false]");
   free(s);
   // null
   r = self->f->pushNFreeSmallBool(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,false]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallBytesSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallBytes(value);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // the smallBytes container is empty
   r = self->f->pushNFreeSmallBytes(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,[]]");
   free(s);
 
   char *buffer = "poi";
   value        = allocSmallBytes(buffer, strlen(buffer));
   r = self->f->pushNFreeSmallBytes(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[],[0x70,0x6f,0x69]]");
   free(s);
   // null
   r = self->f->pushNFreeSmallBytes(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],[0x70,0x6f,0x69]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallDoublet *value = allocG(1.0);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->pushNFreeSmallDouble(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,1.000000e+00]");
   free(s);
   // object with no data
   createAllocateSmallDouble(b);
   r = self->f->pushNFreeSmallDouble(self, b);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,1.000000e+00,0.000000e+00]");
   free(s);
   // null
   r = self->f->pushNFreeSmallDouble(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,1.000000e+00,0.000000e+00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocG(1);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->pushNFreeSmallInt(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,1]");
   free(s);
   // bool object with no data
   createAllocateSmallInt(b);
   r = self->f->pushNFreeSmallInt(self, b);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,1,0]");
   free(s);
   // null
   r = self->f->pushNFreeSmallInt(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,1,0]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocG(rtSmallJsont);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // the smallJson container is empty
   r = self->f->pushNFreeSmallJson(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,{}]");
   free(s);
 
   value = allocG(rtSmallJsont);
   parseO(value, "{}");
   r = self->f->pushNFreeSmallJson(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,{},{}]");
   free(s);
   // null
   r = self->f->pushNFreeSmallJson(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   createAllocateSmallString(string);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->pushNFreeSmallString(self, string);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"\"]");
   free(s);
   // null
   r = self->f->pushNFreeSmallString(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallContainerSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self          = allocSmallJson();
   createAllocateSmallContainer(container);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->pushNFreeSmallContainer(self, container);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"<data container>\"]");
   free(s);
   // null
   r = self->f->pushNFreeSmallContainer(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushManySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *v1 = allocG(1);
   smallIntt *v2 = allocG(2);
 
   r = self->f->pushMany(self, v1, v2, null);
   finishO(v1);
   finishO(v2);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   terminateO(self);
   // json string
   self = allocSmallJson();
   setTopSO(self, "qwe");
   smallStringt *s1 = allocSmallString("123");
   smallStringt *s2 = allocSmallString("456");
   r = self->f->pushMany(self, s1, s2, null);
   ck_assert_ptr_ne(r, null);
   terminateO(s1);
   terminateO(s2);
   s = toStringO(r);
   ck_assert_str_eq(s, "qwe123456");
   free(s);
   // non smallString object
   s1 = allocSmallString("123");
   s2 = (smallStringt*) allocSmallInt(1);
   r = self->f->pushMany(self, s1, s2, null);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "qwe123456");
   free(s);
   terminateO(s1);
   terminateO(s2);
   terminateO(self);
 
 }
 
 
 void pushManySSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char *v1 = "a";
   char *v2 = "bb";
 
   r = self->f->pushManyS(self, v1, v2, null);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"a\",\"bb\"]");
   free(s);
   terminateO(self);
   // json string
   self = allocSmallJson();
   setTopSO(self, "qwe");
   r = self->f->pushManyS(self, "123", "456", null);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "qwe123456");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeManySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *v1 = allocG(1);
   smallIntt *v2 = allocG(2);
 
   r = self->f->pushNFreeMany(self, v1, v2, null);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   terminateO(self);
   // json string
   self = allocSmallJson();
   setTopSO(self, "qwe");
   smallStringt *s1 = allocSmallString("123");
   smallStringt *s2 = allocSmallString("456");
   r = pushNFreeManyO(self, s1, s2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "qwe123456");
   free(s);
   // non smallString object
   s1 = allocSmallString("123");
   s2 = (smallStringt*) allocSmallInt(1);
   r = pushNFreeManyO(self, s1, s2);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "qwe123456");
   free(s);
   terminateO(s2);
   terminateO(self);
 
 }
 
 
 void pushNFreeManySSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char *v1 = strdup("a");
   char *v2 = strdup("bb");
 
   r = self->f->pushNFreeManyS(self, v1, v2, null);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"a\",\"bb\"]");
   free(s);
   terminateO(self);
   // json string
   self = allocSmallJson();
   setTopSO(self, "qwe");
   r = pushNFreeManySO(self, strdup("123"), strdup("456"));
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "qwe123456");
   free(s);
   terminateO(self);
 
 }
 
 
 void popSmallJsonT(void) {
 
   baset* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // push a base object of unknown type
   smallIntt *o    = allocSmallInt(2);
   o->type         = "newType";
   r2 = self->f->pushNFree(self, (baset*)o);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->pop(self);
   ck_assert_ptr_ne(r, null);
   ck_assert(isOUndefined(r));
   terminateO(r);
   r = self->f->pop(self);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r->type, "newType");
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r = self->f->pop(self);
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->pop(self);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->pop(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->pop(self), NULL);
   terminateO(self);
 
 }
 
 
 void popUndefinedSmallJsonT(void) {
 
   undefinedt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   // pop
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popUndefined(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->popUndefined(self);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popUndefined(self);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popUndefined(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->popUndefined(self), NULL);
   terminateO(self);
 
 }
 
 
 void popBoolSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   r2 = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->popBool(self);
   ck_assert(r);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->popBool(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popBool(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void popDoubleSmallJsonT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   r2 = self->f->pushDouble(self, 2.0);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->popDouble(self);
   ck_assert(r==2.0);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->popDouble(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popDouble(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void popIntSmallJsonT(void) {
 
   int64_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushBool(self, FALSE);
   ck_assert_ptr_ne(r2, null);
   // add second element
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->popInt(self);
   ck_assert_int_eq(r, 2);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
   // pop element of unexpected type
   r = self->f->popInt(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popInt(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void popInt32SmallJsonT(void) {
 
   int32_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushBool(self, FALSE);
   ck_assert_ptr_ne(r2, null);
   // add second element
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->popInt32(self);
   ck_assert_int_eq(r, 2);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
   // pop element of unexpected type
   r = self->f->popInt32(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popInt32(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void popUintSmallJsonT(void) {
 
   uint64_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushBool(self, FALSE);
   ck_assert_ptr_ne(r2, null);
   // add second element
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->popUint(self);
   ck_assert_int_eq(r, 2);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
   // pop element of unexpected type
   r = self->f->popUint(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popUint(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void popUint32SmallJsonT(void) {
 
   uint32_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushBool(self, FALSE);
   ck_assert_ptr_ne(r2, null);
   // add second element
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->popUint32(self);
   ck_assert_int_eq(r, 2);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
   // pop element of unexpected type
   r = self->f->popUint32(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popUint32(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void popSSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   r2 = self->f->pushS(self, "bb");
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->popS(self);
   ck_assert_str_eq(r, "bb");
   free(r);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->popS(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popS(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void popDictSmallJsonT(void) {
 
   smallDictt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallDict(e);
   r2 = self->f->pushDict(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popDict(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->popDict(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popDict(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popDict(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->popDict(self), NULL);
   terminateO(self);
 
 }
 
 
 void popArraySmallJsonT(void) {
 
   smallArrayt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallArray(e);
   r2 = self->f->pushArray(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popArray(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->popArray(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popArray(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popArray(self);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->popArray(self), NULL);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void popSmallBoolSmallJsonT(void) {
 
   smallBoolt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallBool(e);
   r2 = self->f->pushSmallBool(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popSmallBool(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "false");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->popSmallBool(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popSmallBool(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popSmallBool(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->popSmallBool(self), NULL);
   terminateO(self);
 
 }
 
 
 void popSmallBytesSmallJsonT(void) {
 
   smallBytest* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallBytes(e);
   r2 = self->f->pushSmallBytes(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popSmallBytes(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->popSmallBytes(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popSmallBytes(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popSmallBytes(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->popSmallBytes(self), NULL);
   terminateO(self);
 
 }
 
 
 void popSmallDoubleSmallJsonT(void) {
 
   smallDoublet* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallDouble(e);
   r2 = self->f->pushSmallDouble(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popSmallDouble(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "0.000000e+00");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->popSmallDouble(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popSmallDouble(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popSmallDouble(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->popSmallDouble(self), NULL);
   terminateO(self);
 
 }
 
 
 void popSmallIntSmallJsonT(void) {
 
   smallIntt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallInt(e);
   r2 = self->f->pushSmallInt(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popSmallInt(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "0");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true]");
   free(s);
   // pop element of unexpected type
   r = self->f->popSmallInt(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popSmallInt(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popSmallInt(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->popSmallInt(self), NULL);
   terminateO(self);
 
 }
 
 
 void popSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   createSmallBytes(B);
   r2 = self->f->pushSmallBytes(self, &B);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallJson(e);
   r2 = self->f->pushSmallJson(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popSmallJson(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   // pop element of unexpected type
   r = self->f->popSmallJson(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popSmallJson(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popSmallJson(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->popSmallJson(self), NULL);
   terminateO(self);
 
 }
 
 
 void popSmallStringSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallString(e);
   r2 = self->f->pushSmallString(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popSmallString(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->popSmallString(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popSmallString(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popSmallString(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->popSmallString(self), NULL);
   terminateO(self);
 
 }
 
 
 void popVoidSmallJsonT(void) {
 
   void* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallContainer(e);
   setValO(&e, &r);
   r2 = self->f->pushSmallContainer(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->popVoid(self);
   ck_assert_ptr_eq(r, &r);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->popVoid(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popVoid(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void popSmallContainerSmallJsonT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallContainer(e);
   r2 = self->f->pushSmallContainer(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popSmallContainer(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // container with baset object
   // push a base object of unknown type
   smallIntt *o    = allocSmallInt(2);
   o->type         = "newType";
   r2 = self->f->pushNFree(self, (baset*)o);
   ck_assert_ptr_ne(r2, null);
   r = self->f->popSmallContainer(self);
   ck_assert_ptr_eq(r, NULL);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\"]");
   free(s);
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   // pop element of unexpected type
   r = self->f->popSmallContainer(self);
   ck_assert_ptr_eq(r, NULL);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popSmallContainer(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popSmallContainer(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->popSmallContainer(self), NULL);
   terminateO(self);
 
 }
 
 
 void popNumSmallJsonT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
   // add second element
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushDouble(self, 2.5);
   ck_assert_ptr_ne(r2, null);
   // pop
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popNum(self);
   ck_assert(r==2.5);
   ck_assert_int_eq(lenO(self), 2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[true,2]");
   free(s);
   r = self->f->popNum(self);
   ck_assert_int_eq(r, 2);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true]");
   free(s);
   // pop element of unexpected type
   r = self->f->popNum(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->popNum(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->popNum(self);
   ck_assert(!r);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert(!self->f->popNum(self));
   terminateO(self);
 
 }
 
 
 void prependSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*) allocG(2);
 
   // add an element to check that prepend adds the second element
   // at the start
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->prepend(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // null
   r = self->f->prepend(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = (baset*) allocSmallInt(2);
   ck_assert_ptr_eq(self->f->prepend(self, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void prependUndefinedSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->prependUndefined(self);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null,1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->prependUndefined(self), NULL);
   terminateO(self);
 
 }
 
 
 void prependBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->prependBool(self, TRUE);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[true,1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->prependBool(self, true), NULL);
   terminateO(self);
 
 }
 
 
 void prependDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->prependDouble(self, 1.0);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00,1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->prependDouble(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void prependIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->prependInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->prependInt(self, 1);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->prependInt(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void prependSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->prependS(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   char *str = "poi";
   r = self->f->prependS(self, str);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"poi\",1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->prependS(self, ""), NULL);
   terminateO(self);
   // json string
   self = allocSmallJson();
   setTopSO(self, "qwe");
   r = prependSO(self, "!@#");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "!@#qwe");
   free(s);
   // empty string
   r = prependSO(self, "");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "!@#qwe");
   free(s);
   // empty self
   freeO(self);
   setTypeStringO(self);
   r = prependSO(self, "asd");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "asd");
   free(s);
   // null parameter
   r = prependSO(self, null);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void prependCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->prependChar(self, 'a');
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"a\",1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->prependChar(self, 't'), NULL);
   terminateO(self);
 
 }
 
 
 void prependDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict  = allocG(rtSmallDictt);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   // push dict
   r = self->f->prependDict(self, dict);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   finishO(dict);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{},1]");
   free(s);
   // non smallDict object
   dict = (smallDictt*) allocSmallInt(2);
   r = self->f->prependDict(self, dict);
   ck_assert_ptr_eq(r, null);
   terminateO(dict);
   // null
   r = self->f->prependDict(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[{},1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   smallDictt *value = allocSmallDict();
   ck_assert_ptr_eq(self->f->prependDict(self, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void prependArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallArrayt *array = allocG(rtSmallArrayt);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->prependArray(self, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   finishO(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[],1]");
   free(s);
   // non smallArray object
   array = (smallArrayt*) allocSmallInt(2);
   r = self->f->prependArray(self, array);
   ck_assert_ptr_eq(r, null);
   terminateO(array);
   // null
   r = self->f->prependArray(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[[],1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   smallArrayt *value = allocSmallArray();
   ck_assert_ptr_eq(self->f->prependArray(self, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void prependArraycSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array     = listCreateS("a","bb");
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->prependArrayc(self, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   listFreeS(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]");
   free(s);
   // null
   r = self->f->prependArrayc(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   char **value = listCreateS("a","bb");
   ck_assert_ptr_eq(self->f->prependArrayc(self, value), NULL);
   listFreeS(value);
   terminateO(self);
 
 }
 
 
 void prependSmallBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value = allocG(TRUE);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->prependSmallBool(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[true,1]");
   free(s);
   // bool object with no data
   createAllocateSmallBool(b);
   r = self->f->prependSmallBool(self, b);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   finishO(b);
   s = toStringO(r);
   ck_assert_str_eq(s, "[false,true,1]");
   free(s);
   // non smallBool object
   value = (smallBoolt*) allocSmallInt(2);
   r = self->f->prependSmallBool(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // null
   r = self->f->prependSmallBool(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[false,true,1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallBool(true);
   ck_assert_ptr_eq(self->f->prependSmallBool(self, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void prependSmallBytesSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallBytes(value);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   // the smallBytes container is empty
   r = self->f->prependSmallBytes(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[],1]");
   free(s);
   //  reuse value
   value->B = null;
   char *buffer = "poi";
   pushBufferO(value, buffer, strlen(buffer));
   r = self->f->prependSmallBytes(self, value);
   finishO(value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]");
   free(s);
   // non smallBytes object
   value = (smallBytest*) allocSmallInt(2);
   r = self->f->prependSmallBytes(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // null
   r = self->f->prependSmallBytes(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallBytes("", sizeof(""));
   ck_assert_ptr_eq(self->f->prependSmallBytes(self, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void prependSmallDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallDoublet *value = allocG(1.0);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->prependSmallDouble(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00,1]");
   free(s);
   // object with no data
   createAllocateSmallDouble(b);
   r = self->f->prependSmallDouble(self, b);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   finishO(b);
   s = toStringO(r);
   ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]");
   free(s);
   // non smallDouble object
   value = (smallDoublet*) allocSmallInt(2);
   r = self->f->prependSmallDouble(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // null
   r = self->f->prependSmallDouble(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallDouble(2);
   ck_assert_ptr_eq(self->f->prependSmallDouble(self, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void prependSmallIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocG(1);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->prependSmallInt(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,1]");
   free(s);
   // bool object with no data
   createAllocateSmallInt(b);
   r = self->f->prependSmallInt(self, b);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   finishO(b);
   s = toStringO(r);
   ck_assert_str_eq(s, "[0,1,1]");
   free(s);
   // non smallInt object
   value = (smallIntt*) allocSmallBool(true);
   r = self->f->prependSmallInt(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // null
   r = self->f->prependSmallInt(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[0,1,1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallInt(2);
   ck_assert_ptr_eq(self->f->prependSmallInt(self, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void prependSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocG(rtSmallJsont);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   // the smallJson container is empty
   r = self->f->prependSmallJson(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{},1]");
   free(s);
   resetO(value);
   parseO(value, "{}");
   r = self->f->prependSmallJson(self, value);
   finishO(value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{},{},1]");
   free(s);
   // non smallJson object
   value = (smallJsont*) allocSmallInt(2);
   r = self->f->prependSmallJson(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   // null
   r = self->f->prependSmallJson(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[{},{},1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   value = allocSmallJson();
   ck_assert_ptr_eq(self->f->prependSmallJson(self, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void prependSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   createAllocateSmallString(string);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->prependSmallString(self, string);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   finishO(string);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",1]");
   free(s);
   // non smallString object
   string = (smallStringt*) allocSmallInt(2);
   r = self->f->prependSmallString(self, string);
   ck_assert_ptr_eq(r, null);
   terminateO(string);
   // null
   r = self->f->prependSmallString(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"\",1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   smallStringt *value = allocSmallString("");
   ck_assert_ptr_eq(self->f->prependSmallString(self, value), NULL);
   terminateO(value);
   terminateO(self);
   // json string
   self   = allocSmallJson();
   setTopSO(self, "qwe");
   string = allocSmallString("!@#");
   r = self->f->prependSmallString(self, string);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "!@#qwe");
   free(s);
   // empty string
   setValO(string, "");
   r = self->f->prependSmallString(self, string);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "!@#qwe");
   free(s);
   freeO(string);
   r = self->f->prependSmallString(self, string);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "!@#qwe");
   free(s);
   // empty self
   freeO(self);
   setTypeStringO(self);
   setValO(string, "asd");
   r = self->f->prependSmallString(self, string);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "asd");
   free(s);
   terminateO(string);
   // not smallString object
   string = (smallStringt*) allocSmallInt(1);
   r = self->f->prependSmallString(self, string);
   ck_assert_ptr_eq(r, null);
   terminateO(string);
   // null parameter
   r = self->f->prependSmallString(self, null);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void prependSmallContainerSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self          = allocSmallJson();
   createAllocateSmallContainer(container);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->prependSmallContainer(self, container);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   finishO(container);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\",1]");
   free(s);
   // non smallContainer object
   container = (smallContainert*) allocSmallInt(2);
   r = self->f->prependSmallContainer(self, container);
   ck_assert_ptr_eq(r, null);
   terminateO(container);
   // null
   r = self->f->prependSmallContainer(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"<data container>\",1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   smallContainert *value = allocSmallContainer(null);
   ck_assert_ptr_eq(self->f->prependSmallContainer(self, value), NULL);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*) allocG(2);
 
   // add an element to check that prepend adds the second element
   // at the start
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->prependNFree(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // null
   r = self->f->prependNFree(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeUndefinedSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   createAllocateUndefined(value);
   r = self->f->prependNFreeUndefined(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null,1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->prependNFreeS(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
 
   char *str = strdup("poi");
   r = self->f->prependNFreeS(self, str);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"poi\",1]");
   free(s);
 
   terminateO(self);
 
 }
 
 
 void prependNFreeDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict  = allocG(rtSmallDictt);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // push dict
   r = self->f->prependNFreeDict(self, dict);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{},1]");
   free(s);
   // null
   r = self->f->prependNFreeDict(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[{},1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallArrayt *array = allocG(rtSmallArrayt);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->prependNFreeArray(self, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[],1]");
   free(s);
   // null
   r = self->f->prependNFreeArray(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[[],1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeArraycSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array      = listCreateS("a","bb");
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->prependNFreeArrayc(self, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]");
   free(s);
   // null
   r = self->f->prependNFreeArrayc(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[[\"a\",\"bb\"],1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value = allocG(TRUE);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->prependNFreeSmallBool(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[true,1]");
   free(s);
   // bool object with no data
   createAllocateSmallBool(b);
   r = self->f->prependNFreeSmallBool(self, b);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   s = toStringO(r);
   ck_assert_str_eq(s, "[false,true,1]");
   free(s);
   // null
   r = self->f->prependNFreeSmallBool(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[false,true,1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallBytesSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallBytes(value);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // the smallBytes container is empty
   r = self->f->prependNFreeSmallBytes(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[],1]");
   free(s);
 
   char *buffer = "poi";
   value        = allocSmallBytes(buffer, strlen(buffer));
   r = self->f->prependNFreeSmallBytes(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]");
   free(s);
   // null
   r = self->f->prependNFreeSmallBytes(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[[0x70,0x6f,0x69],[],1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallDoublet *value = allocG(1.0);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->prependNFreeSmallDouble(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00,1]");
   free(s);
   // object with no data
   createAllocateSmallDouble(b);
   r = self->f->prependNFreeSmallDouble(self, b);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   s = toStringO(r);
   ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]");
   free(s);
   // null
   r = self->f->prependNFreeSmallDouble(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[0.000000e+00,1.000000e+00,1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocG(1);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->prependNFreeSmallInt(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,1]");
   free(s);
   // bool object with no data
   createAllocateSmallInt(b);
   r = self->f->prependNFreeSmallInt(self, b);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   s = toStringO(r);
   ck_assert_str_eq(s, "[0,1,1]");
   free(s);
   // null
   r = self->f->prependNFreeSmallInt(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[0,1,1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocG(rtSmallJsont);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // the smallJson container is empty
   r = self->f->prependNFreeSmallJson(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{},1]");
   free(s);
 
   value = allocG(rtSmallJsont);
   parseO(value, "{}");
   r = self->f->prependNFreeSmallJson(self, value);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 3);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{},{},1]");
   free(s);
   // null
   r = self->f->prependNFreeSmallJson(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[{},{},1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   createAllocateSmallString(string);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->prependNFreeSmallString(self, string);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",1]");
   free(s);
   // null
   r = self->f->prependNFreeSmallString(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"\",1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallContainerSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self          = allocSmallJson();
   createAllocateSmallContainer(container);
 
   // add an element to check that push adds the second element
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   r = self->f->prependNFreeSmallContainer(self, container);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\",1]");
   free(s);
   // null
   r = self->f->prependNFreeSmallContainer(self, null);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"<data container>\",1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void dequeueSmallJsonT(void) {
 
   baset* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add an element to check that the second element is dequeueed
   // at the end
   r2 = self->f->prependInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // prepend a base object of unknown type
   smallIntt *o    = allocSmallInt(2);
   o->type         = "newType";
   r2 = self->f->prependNFree(self, (baset*)o);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->prependUndefined(self);
   ck_assert_ptr_ne(r2, null);
   r = self->f->dequeue(self);
   ck_assert_ptr_ne(r, null);
   ck_assert(isOUndefined(r));
   terminateO(r);
   r = self->f->dequeue(self);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r->type, "newType");
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r = self->f->dequeue(self);
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeue(self);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->dequeue(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->dequeue(self), NULL);
   terminateO(self);
 
 }
 
 
 void dequeueUndefinedSmallJsonT(void) {
 
   undefinedt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   r2 = self->f->prependUndefined(self);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->dequeueUndefined(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->dequeueUndefined(self);
   ck_assert_ptr_eq(r, null);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueUndefined(self);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->dequeueUndefined(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->dequeueUndefined(self), NULL);
   terminateO(self);
 
 }
 
 
 void dequeueBoolSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
 
   // add second element
   r2 = self->f->prependBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
 
   // pop
   r = self->f->dequeueBool(self);
   ck_assert(r);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
 
   // pop element of unexpected type
   r = self->f->dequeueBool(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
 
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueBool(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void dequeueDoubleSmallJsonT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
 
   // add second element
   r2 = self->f->prependDouble(self, 2.0);
   ck_assert_ptr_ne(r2, null);
 
   // pop
   r = self->f->dequeueDouble(self);
   ck_assert(r==2.0);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
 
   // pop element of unexpected type
   r = self->f->dequeueDouble(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
 
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueDouble(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void dequeueIntSmallJsonT(void) {
 
   int64_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushBool(self, FALSE);
   ck_assert_ptr_ne(r2, null);
 
   // add second element
   r2 = self->f->prependInt(self, 2);
   ck_assert_ptr_ne(r2, null);
 
   // pop
   r = self->f->dequeueInt(self);
   ck_assert_int_eq(r, 2);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
 
   // pop element of unexpected type
   r = self->f->dequeueInt(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
 
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueInt(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void dequeueInt32SmallJsonT(void) {
 
   int32_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushBool(self, FALSE);
   ck_assert_ptr_ne(r2, null);
 
   // add second element
   r2 = self->f->prependInt(self, 2);
   ck_assert_ptr_ne(r2, null);
 
   // pop
   r = self->f->dequeueInt32(self);
   ck_assert_int_eq(r, 2);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
 
   // pop element of unexpected type
   r = self->f->dequeueInt32(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
 
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueInt32(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void dequeueUintSmallJsonT(void) {
 
   uint64_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushBool(self, FALSE);
   ck_assert_ptr_ne(r2, null);
 
   // add second element
   r2 = self->f->prependInt(self, 2);
   ck_assert_ptr_ne(r2, null);
 
   // pop
   r = self->f->dequeueUint(self);
   ck_assert_int_eq(r, 2);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
 
   // pop element of unexpected type
   r = self->f->dequeueUint(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
 
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueUint(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void dequeueUint32SmallJsonT(void) {
 
   uint32_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushBool(self, FALSE);
   ck_assert_ptr_ne(r2, null);
 
   // add second element
   r2 = self->f->prependInt(self, 2);
   ck_assert_ptr_ne(r2, null);
 
   // pop
   r = self->f->dequeueUint32(self);
   ck_assert_int_eq(r, 2);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
 
   // pop element of unexpected type
   r = self->f->dequeueUint32(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[false]");
   free(s);
 
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueUint32(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void dequeueSSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
 
   // add second element
   r2 = self->f->prependS(self, "bb");
   ck_assert_ptr_ne(r2, null);
 
   // pop
   r = self->f->dequeueS(self);
   ck_assert_str_eq(r, "bb");
   free(r);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
 
   // pop element of unexpected type
   r = self->f->dequeueS(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
 
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueS(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void dequeueDictSmallJsonT(void) {
 
   smallDictt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallDict(e);
   r2 = self->f->prependDict(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->dequeueDict(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->dequeueDict(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueDict(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->dequeueDict(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->dequeueDict(self), NULL);
   terminateO(self);
 
 }
 
 
 void dequeueArraySmallJsonT(void) {
 
   smallArrayt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallArray(e);
   r2 = self->f->prependArray(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->dequeueArray(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->dequeueArray(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueArray(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->dequeueArray(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->dequeueArray(self), NULL);
   terminateO(self);
 
 }
 
 
 void dequeueSmallBoolSmallJsonT(void) {
 
   smallBoolt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallBool(e);
   r2 = self->f->prependSmallBool(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->dequeueSmallBool(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "false");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->dequeueSmallBool(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueSmallBool(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->dequeueSmallBool(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->dequeueSmallBool(self), NULL);
   terminateO(self);
 
 }
 
 
 void dequeueSmallBytesSmallJsonT(void) {
 
   smallBytest* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallBytes(e);
   r2 = self->f->prependSmallBytes(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->dequeueSmallBytes(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->dequeueSmallBytes(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueSmallBytes(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->dequeueSmallBytes(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->dequeueSmallBytes(self), NULL);
   terminateO(self);
 
 }
 
 
 void dequeueSmallDoubleSmallJsonT(void) {
 
   smallDoublet* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallDouble(e);
   r2 = self->f->prependSmallDouble(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->dequeueSmallDouble(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "0.000000e+00");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->dequeueSmallDouble(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueSmallDouble(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->dequeueSmallDouble(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->dequeueSmallDouble(self), NULL);
   terminateO(self);
 
 }
 
 
 void dequeueSmallIntSmallJsonT(void) {
 
   smallIntt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallInt(e);
   r2 = self->f->prependSmallInt(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->dequeueSmallInt(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "0");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true]");
   free(s);
   // pop element of unexpected type
   r = self->f->dequeueSmallInt(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueSmallInt(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->dequeueSmallInt(self);
   ck_assert_ptr_eq(r, null);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->dequeueSmallInt(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->dequeueSmallInt(self), NULL);
   terminateO(self);
 
 }
 
 
 void dequeueSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   createSmallBytes(B);
   r2 = self->f->pushSmallBytes(self, &B);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallJson(e);
   r2 = self->f->prependSmallJson(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->dequeueSmallJson(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   // pop element of unexpected type
   r = self->f->dequeueSmallJson(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueSmallJson(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->dequeueSmallJson(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->dequeueSmallJson(self), NULL);
   terminateO(self);
 
 }
 
 
 void dequeueSmallStringSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallString(e);
   r2 = self->f->prependSmallString(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->dequeueSmallString(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // pop element of unexpected type
   r = self->f->dequeueSmallString(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueSmallString(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->dequeueSmallString(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->dequeueSmallString(self), NULL);
   terminateO(self);
 
 }
 
 
 void dequeueVoidSmallJsonT(void) {
 
   void* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
 
   // add second element
   createSmallContainer(e);
   setValO(&e, &r);
   r2 = self->f->prependSmallContainer(self, &e);
   ck_assert_ptr_ne(r2, null);
 
   // pop
   r = self->f->dequeueVoid(self);
   ck_assert_ptr_eq(r, &r);
   ck_assert_int_eq(lenO(self), 1);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
 
   // pop element of unexpected type
   r = self->f->dequeueVoid(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
 
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueVoid(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void dequeueSmallContainerSmallJsonT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   // add second element
   createSmallContainer(e);
   r2 = self->f->prependSmallContainer(self, &e);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->dequeueSmallContainer(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // container with baset object
   // push a base object of unknown type
   smallIntt *o    = allocSmallInt(2);
   o->type         = "newType";
   r2 = self->f->prependNFree(self, (baset*)o);
   ck_assert_ptr_ne(r2, null);
   r = self->f->dequeueSmallContainer(self);
   ck_assert_ptr_eq(r, NULL);
   ck_assert_int_eq(lenO(self), 2);
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"<data container>\",1]");
   free(s);
   r3 = self->f->dequeue(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   // pop element of unexpected type
   r = self->f->dequeueSmallContainer(self);
   ck_assert_ptr_eq(r, NULL);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueSmallContainer(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->dequeueSmallContainer(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->dequeueSmallContainer(self), NULL);
   terminateO(self);
 
 }
 
 
 void dequeueNumSmallJsonT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
   baset *r3;
 
   // add an element to check that the second element is poped
   // at the end
   r2 = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
   // add second element
   r2 = self->f->prependInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->prependDouble(self, 2.5);
   ck_assert_ptr_ne(r2, null);
   // pop
   r = self->f->dequeueNum(self);
   ck_assert(r==2.5);
   ck_assert_int_eq(lenO(self), 2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[2,true]");
   free(s);
   r = self->f->dequeueNum(self);
   ck_assert_int_eq(r, 2);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true]");
   free(s);
   // pop element of unexpected type
   r = self->f->dequeueNum(self);
   ck_assert(!r);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true]");
   free(s);
   // empty array
   r3 = self->f->pop(self);
   ck_assert_ptr_ne(r3, null);
   terminateO(r3);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r = self->f->dequeueNum(self);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = self->f->dequeueNum(self);
   ck_assert(!r);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert(!self->f->dequeueNum(self));
   terminateO(self);
 
 }
 
 
 void reverseSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTypeArrayO(self);
 
   // empty array
   r = reverseO(self);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   // 1 element array
   self->f->pushInt(self,1);
   r = reverseO(self);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // 2 elements array
   self->f->pushInt(self,2);
   r = reverseO(self);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(reverseO(self), NULL);
   terminateO(self);
 
 }
 
 
 void catSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // cat arrays
   self->f->pushInt(self,1);
   createAllocateSmallArray(a);
   createAllocateSmallArray(a2);
   a2->f->pushInt(a2,2);
   r = catO(self, a, a2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   smashManyO(a,a2);
   emptyO(self);
   // null parameter
   r = catO(self, null);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
   // json string
   self = allocSmallJson();
   setTopSO(self, "qwe");
   smallStringt *s1 = allocSmallString("123");
   smallStringt *s2 = allocSmallString("456");
   r = catO(self, s1, s2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "qwe123456");
   free(s);
   // non smallString object
   terminateO(s2);
   s2 = (smallStringt*) allocSmallInt(1);
   r = catO(self, s1, s2);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "qwe123456");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(catO(self, s1), NULL);
   terminateO(s1);
   terminateO(s2);
   terminateO(self);
 
 }
 
 
 void mergeDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self      = allocG(rtSmallJsont);
   smallDictt *smallDict = allocSmallDict();
 
   r = mergeDictO(self, smallDict);
   ck_assert_ptr_ne(r, null);
   smallDict->f->setInt(smallDict, "a", 1);
   r = mergeDictO(self, smallDict);
   ck_assert_ptr_ne(r, null);
   smashO(smallDict);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"a\":1}");
   free(s);
   // same sObject in json and smallDict
   smallDict = allocSmallDict();
   setsoO(smallDict, (sDictt*) getsoO(self));
   r = mergeDictO(self, smallDict);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(mergeDictO(self, smallDict), NULL);
   finishO(smallDict);
   terminateO(self);
 
 }
 
 
 void mergeDictNSmashSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *value = allocSmallDict();
 
   self->f->setS(self, "1", "2");
   self->f->setS(self, "3", "4");
   value->f->setS(value, "3", "#");
   value->f->setInt(value, "4", 0);
   r = self->f->mergeDictNSmash(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"2\",\"3\":\"#\",\"4\":0}");
   free(s);
   // empty dict
   value = allocSmallDict();
   r = self->f->mergeDictNSmash(self, value);
   ck_assert_ptr_eq(r, self);
   // non smallDict object
   createAllocateSmallInt(i);
   r = self->f->mergeDictNSmash(self, (smallDictt*)i);
   ck_assert_ptr_eq(r, null);
   terminateO(i);
   // null
   r = self->f->mergeDictNSmash(self, null);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void mergeSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallJson(json);
 
   // add an element to check that the second array is appended
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // append json array
   json->f->pushInt(json, 2);
   r = mergeO(self, json);
   smashO(json);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   // length 0
   json = allocSmallJson();
   json->f->pushInt(json, 2);
   baset *o = json->f->pop(json);
   terminateO(o);
   r = mergeO(self, json);
   smashO(json);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   // same sArray in both self and json
   json = allocSmallJson();
   setsoO(json, (smallt*) getsoO(self));
   r = mergeO(self, json);
   ck_assert_ptr_eq(r, null);
   finishO(json);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   // json of type not array
   json = allocSmallJson();
   setTopIntO(json, 1);
   r = mergeO(self, json);
   ck_assert_ptr_eq(r, null);
   terminateO(json);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   // non smallJson object
   json = (smallJsont*) allocSmallInt(2);
   r = mergeO(self, json);
   ck_assert_ptr_eq(r, null);
   terminateO(json);
   // null
   r = mergeO(self, null);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   // json empty json
   freeO(self);
   json = allocSmallJson();
   json->f->pushInt(json, 2);
   r = mergeO(self, json);
   smashO(json);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[2]");
   free(s);
   freeO(self);
   json = allocSmallJson();
   json->f->setInt(json, "a", 1);
   r = mergeO(self, json);
   smashO(json);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"a\":1}");
   free(s);
   // same dict in self and json
   json = allocSmallJson();
   setsoO(json, getsoO(self));
   r = mergeO(self, json);
   ck_assert_ptr_eq(r, null);
   finishO(json);
   // non json array or dict
   freeO(self);
   setTypeBoolO(self);
   json = allocSmallJson();
   ck_assert_ptr_eq(mergeO(self, json), NULL);
   terminateO(json);
   terminateO(self);
 
 }
 
 
 void mergeNSmashSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallJson(json);
 
   // add an element to check that the second array is appended
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // append json array
   json->f->pushInt(json, 2);
   r = mergeNSmashO(self, json);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   // null
   r = mergeNSmashO(self, null);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   terminateO(self);
 
 }
 
 
 void appendSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallArrayt *array = allocSmallArray();
 
   array->f->pushInt(array, 12);
   r = appendO(self, array);
   ck_assert_ptr_ne(r, null);
   smashO(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[12]");
   free(s);
   // non smallArray array
   array = (smallArrayt*) allocSmallInt(1);
   r = appendO(self, array);
   ck_assert_ptr_eq(r, null);
   terminateO(array);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   array = allocSmallArray();
   ck_assert_ptr_eq(appendO(self, array), NULL);
   terminateO(array);
   terminateO(self);
 
 }
 
 
 void appendNSmashSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallArray(a);
 
   // add an element to check that the second array is appended
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // append array
   a->f->pushInt(a, 2);
   r = self->f->appendNSmash(self, a);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   // length 0
   a = allocSmallArray();
   a->f->pushInt(a, 2);
   delElemO(a,0);
   r = self->f->appendNSmash(self, a);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   // same sArray in both self and a
   a = allocSmallArray();
   setsoO(a, (sArrayt*) getsoO(self));
   r = self->f->appendNSmash(self, a);
   ck_assert_ptr_eq(r, null);
   finishO(a);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   // null
   r = self->f->appendNSmash(self, null);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   terminateO(self);
 
 }
 
 
 void appendArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array;
 
   // add an element to check that the second array is appended
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // append array
   array = null;
   listPushS(&array, "2");
   r = self->f->appendArray(self, array);
   listFreeS(array);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"2\"]");
   free(s);
   // length 0
   listEmptyS(array);
   r = self->f->appendArray(self, array);
   free(array);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"2\"]");
   free(s);
   // null
   r = self->f->appendArray(self, null);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"2\"]");
   free(s);
   // empty json
   freeO(self);
   array = null;
   listPushS(&array, "2");
   r = self->f->appendArray(self, array);
   listFreeS(array);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"2\"]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   listEmptyS(array);
   ck_assert_ptr_eq(self->f->appendArray(self, array), NULL);
   free(array);
   terminateO(self);
 
 }
 
 
 void appendNSmashArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array;
 
   // add an element to check that the second array is appended
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // append array
   array = null;
   listPushS(&array, "2");
   r = self->f->appendNSmashArray(self, array);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"2\"]");
   free(s);
   // length 0
   listEmptyS(array);
   r = self->f->appendNSmashArray(self, array);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"2\"]");
   free(s);
   // null
   r = self->f->appendNSmashArray(self, null);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"2\"]");
   free(s);
   // empty json
   freeO(self);
   array = null;
   listPushS(&array, "2");
   r = self->f->appendNSmashArray(self, array);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"2\"]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   listEmptyS(array);
   ck_assert_ptr_eq(self->f->appendNSmashArray(self, array), NULL);
   free(array);
   terminateO(self);
 
 }
 
 
 void shiftSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallArray(a);
 
   // add an element to check that the second array is appended
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // append array
   a->f->pushInt(a, 2);
   r = self->f->shift(self, a);
   smashO(a);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // length 0
   a = allocSmallArray();
   a->f->pushInt(a, 2);
   delElemO(a,0);
   r = self->f->shift(self, a);
   smashO(a);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // same sArray in both self and a
   a = allocSmallArray();
   setsoO(a, (sArrayt*) getsoO(self));
   r = self->f->shift(self, a);
   ck_assert_ptr_eq(r, null);
   finishO(a);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // null
   r = self->f->shift(self, null);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void shiftNSmashSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallArray(a);
 
   // add an element to check that the second array is appended
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // append array
   a->f->pushInt(a, 2);
   r = self->f->shiftNSmash(self, a);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // length 0
   a = allocSmallArray();
   a->f->pushInt(a, 2);
   delElemO(a,0);
   r = self->f->shiftNSmash(self, a);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // same sArray in both self and a
   a = allocSmallArray();
   setsoO(a, (sArrayt*) getsoO(self));
   r = self->f->shiftNSmash(self, a);
   ck_assert_ptr_eq(r, null);
   finishO(a);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // null
   r = self->f->shiftNSmash(self, null);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void shiftSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallJson(json);
 
   // add an element to check that the second array is shifted
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // shift json array
   json->f->pushInt(json, 2);
   r = self->f->shiftSmallJson(self, json);
   smashO(json);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // length 0
   json = allocSmallJson();
   json->f->pushInt(json, 2);
   baset *o = json->f->pop(json);
   terminateO(o);
   r = self->f->shiftSmallJson(self, json);
   smashO(json);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // same sArray in both self and json
   json = allocSmallJson();
   setsoO(json, (smallt*) getsoO(self));
   r = self->f->shiftSmallJson(self, json);
   ck_assert_ptr_eq(r, null);
   finishO(json);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // json of type not array
   json = allocSmallJson();
   setTopIntO(json, 1);
   r = self->f->shiftSmallJson(self, json);
   ck_assert_ptr_eq(r, null);
   terminateO(json);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // null
   r = self->f->shiftSmallJson(self, null);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void shiftNSmashSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallJson(json);
 
   // add an element to check that the second array is shifted
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // shift json array
   json->f->pushInt(json, 2);
   r = self->f->shiftNSmashSmallJson(self, json);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // length 0
   json = allocSmallJson();
   json->f->pushInt(json, 2);
   baset *o = json->f->pop(json);
   terminateO(o);
   r = self->f->shiftNSmashSmallJson(self, json);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // same sArray in both self and json
   json = allocSmallJson();
   setsoO(json, (smallt*) getsoO(self));
   r = self->f->shiftNSmashSmallJson(self, json);
   ck_assert_ptr_eq(r, null);
   finishO(json);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // json of type not array
   json = allocSmallJson();
   setTopIntO(json, 1);
   r = self->f->shiftNSmashSmallJson(self, json);
   ck_assert_ptr_eq(r, null);
   terminateO(json);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   // null
   r = self->f->shiftNSmashSmallJson(self, null);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void addSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallArray(a);
 
   // add an element to check that the second array is added
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // add array
   a->f->pushInt(a, 2);
   r = addO(self, a);
   smashO(a);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   // length 0
   a = allocSmallArray();
   a->f->pushInt(a, 2);
   delElemO(a,0);
   r = addO(self, a);
   smashO(a);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   a = allocSmallArray();
   r = addO(self, a);
   smashO(a);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // same sArray in both self and a
   a = allocSmallArray();
   setsoO(a, (sArrayt*) getsoO(self));
   r = addO(self, a);
   ck_assert_ptr_eq(r, null);
   finishO(a);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // null
   r = addO(self, null);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // non smallArray a
   a = (smallArrayt*) allocSmallInt(1);
   ck_assert_ptr_eq(addO(self, a), NULL);
   terminateO(a);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   a = allocSmallArray();
   ck_assert_ptr_eq(addO(self, a), NULL);
   terminateO(a);
   terminateO(self);
 
 }
 
 
 void addJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *a    = allocSmallJson();
 
   // add an element to check that the second array is added
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // add array
   a->f->pushInt(a, 2);
   r = addJsonO(self, a);
   smashO(a);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   // length 0
   a = allocSmallJson();
   a->f->pushInt(a, 2);
   delElemIndexO(a,0);
   r = addJsonO(self, a);
   smashO(a);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   a = allocSmallJson();
   setTypeArrayO(a);
   r = addJsonO(self, a);
   smashO(a);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // same sArray in both self and a
   a = allocSmallJson();
   setsoO(a, getsoO(self));
   r = addJsonO(self, a);
   ck_assert_ptr_eq(r, null);
   finishO(a);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // non json array a
   a = allocSmallJson();
   r = addJsonO(self, a);
   ck_assert_ptr_eq(r, null);
   finishO(a);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // null
   r = addJsonO(self, null);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // non json a
   a = (smallJsont*) allocSmallInt(1);
   ck_assert_ptr_eq(addJsonO(self, a), NULL);
   terminateO(a);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   a = allocSmallJson();
   ck_assert_ptr_eq(addJsonO(self, a), NULL);
   terminateO(a);
   terminateO(self);
 
 }
 
 
 void sliceSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   //r = sliceO(self);
   // slice
   self->f->pushS(self, "asd");
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = sliceO(self,1,-1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[123,\"sheepy\"]");
   free(s);
   terminateO(self);
     // start outside
   self = allocSmallJson();
   self->f->pushS(self, "asd");
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = sliceO(self,20,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
     // start negative and outside
   self = allocSmallJson();
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = sliceO(self,-20,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   terminateO(self);
     // end outside
   self = allocSmallJson();
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = sliceO(self,2,40);
   ck_assert_ptr_ne(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"sheepy\",5345]");
   free(s);
   terminateO(self);
     // end negative and outside
   self = allocSmallJson();
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = sliceO(self,2,-40);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
     // end before start
   self = allocSmallJson();
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = sliceO(self,3,2);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
     // negative start last element
   self = allocSmallJson();
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = sliceO(self,-1,0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[5345]");
   free(s);
   terminateO(self);
     // start = end
   self = allocSmallJson();
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = sliceO(self,1,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
     // empty list
   initiateAllocateSmallJson(&self);
   setTypeArrayO(self);
   r = sliceO(self,0,0);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(sliceO(self, 0, 1), NULL);
   terminateO(self);
   // json string
   self = allocSmallJson();
   // slice
   setTopSO(self, "sheepy");
   r = sliceO(self, 0,2);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(self), "sh");
   // negative index
   freeO(self);
   setTopSO(self, "sheepy");
   r = sliceO(self, -2,0);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(self), "py");
   // positive and negative indexes
   freeO(self);
   setTopSO(self, "sheepy");
   r = sliceO(self, 2,-2);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(self), "ee");
   // start = end
   freeO(self);
   setTopSO(self, "sheepy");
   r = sliceO(self, 2,-4);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(self), "");
   // end of string
   freeO(self);
   setTopSO(self, "sheepy");
   r = sliceO(self, 2,6);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(self), "eepy");
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(sliceO(self, 2,-4), NULL);
   // start outside string
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert_ptr_eq(sliceO(self, 20,-4), NULL);
   // end outside string
   freeO(self);
   setTopSO(self, "sheepy");
   r = sliceO(self, 2,40);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(self), "eepy");
   freeO(self);
   setTopSO(self, "sheepy");
   r = sliceO(self, -22,3);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(self), "she");
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert_ptr_eq(sliceO(self, 2,-40), NULL);
   // end before start
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert_ptr_eq(sliceO(self, 4,2), NULL);
   terminateO(self);
 
 }
 
 
 void cropSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // negative index
   r = cropO(self, 1, -1);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[2,3]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,4]");
   free(s);
   // start outside
   ck_assert_ptr_eq(cropO(self, 20, -4), NULL);
   // end outside
   r = cropO(self, 0, 40);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[1,4]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   // end negative and outside
   //   add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
   ck_assert_ptr_eq(cropO(self, 2, -40), NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // end before start
   ck_assert_ptr_eq(cropO(self, 3, 2), NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative start last element
   r = cropO(self, -1, 0);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[4]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3]");
   free(s);
   // negative start and outside
   r = cropO(self, -10, 1);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,3]");
   free(s);
   // start = end
   r = cropO(self, 1, 1);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 0);
   terminateO(r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,3]");
   free(s);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(cropO(self, 0, 0), NULL);
   ck_assert_ptr_eq(cropO(self, -1, 0), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(cropO(self, 0, 1), NULL);
   terminateO(self);
   // json string
   self = allocSmallJson();
   setTopSO(self, "");
   // crop
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropO(self, 0,2);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "sh");
   ck_assert_str_eq(sjGet(self), "eepy");
   terminateO(r);
   // negative index
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropO(self, -2,0);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "py");
   ck_assert_str_eq(sjGet(self), "shee");
   terminateO(r);
   // positive and negative indexes
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropO(self, 2,-2);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "ee");
   ck_assert_str_eq(sjGet(self), "shpy");
   terminateO(r);
   // start = end
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropO(self, 2,-4);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "");
   ck_assert_str_eq(sjGet(self), "sheepy");
   terminateO(r);
   // end of string
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropO(self, 2,6);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   ck_assert_str_eq(sjGet(self), "sh");
   terminateO(r);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(cropO(self, 2,-4), NULL);
   // start outside string
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert_ptr_eq(cropO(self, 20,-4), NULL);
   // end outside string
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropO(self, 2,40);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   ck_assert_str_eq(sjGet(self), "sh");
   terminateO(r);
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropO(self, -22,3);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "she");
   ck_assert_str_eq(sjGet(self), "epy");
   terminateO(r);
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert_ptr_eq(cropO(self, 2,-40), NULL);
   // end before start
   ck_assert_ptr_eq(cropO(self, 4,2), NULL);
   terminateO(self);
 
 }
 
 
 void cropSSmallJsonT(void) {
 
   char* s;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // crop
   freeO(self);
   setTopSO(self, "sheepy");
   s = cropSO(self, 0,2);
   ck_assert_str_eq(s, "sh");
   ck_assert_str_eq(sjGet(self), "eepy");
   free(s);
   // negative index
   freeO(self);
   setTopSO(self, "sheepy");
   s = cropSO(self, -2,0);
   ck_assert_str_eq(s, "py");
   ck_assert_str_eq(sjGet(self), "shee");
   free(s);
   // positive and negative indexes
   freeO(self);
   setTopSO(self, "sheepy");
   s = cropSO(self, 2,-2);
   ck_assert_str_eq(s, "ee");
   ck_assert_str_eq(sjGet(self), "shpy");
   free(s);
   // start = end
   freeO(self);
   setTopSO(self, "sheepy");
   s = cropSO(self, 2,-4);
   ck_assert_str_eq(s, "");
   ck_assert_str_eq(sjGet(self), "sheepy");
   free(s);
   // end of string
   freeO(self);
   setTopSO(self, "sheepy");
   s = cropSO(self, 2,6);
   ck_assert_str_eq(s, "eepy");
   ck_assert_str_eq(sjGet(self), "sh");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert_ptr_eq(cropSO(self, 0,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(cropSO(self, 2,-4), NULL);
   // start outside string
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert_ptr_eq(cropSO(self, 20,-4), NULL);
   // end outside string
   freeO(self);
   setTopSO(self, "sheepy");
   s = cropSO(self, 2,40);
   ck_assert_str_eq(s, "eepy");
   ck_assert_str_eq(sjGet(self), "sh");
   free(s);
   freeO(self);
   setTopSO(self, "sheepy");
   s = cropSO(self, -22,3);
   ck_assert_str_eq(s, "she");
   ck_assert_str_eq(sjGet(self), "epy");
   free(s);
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert_ptr_eq(cropSO(self, 2,-40), NULL);
   // end before start
   ck_assert_ptr_eq(cropSO(self, 4,2), NULL);
   terminateO(self);
 
 }
 
 
 void cropSmallStringSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // crop
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropSmallStringO(self, 0,2);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(ssGet(r), "sh");
   ck_assert_str_eq(sjGet(self), "eepy");
   terminateO(r);
   // negative index
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropSmallStringO(self, -2,0);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(ssGet(r), "py");
   ck_assert_str_eq(sjGet(self), "shee");
   terminateO(r);
   // positive and negative indexes
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropSmallStringO(self, 2,-2);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(ssGet(r), "ee");
   ck_assert_str_eq(sjGet(self), "shpy");
   terminateO(r);
   // start = end
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropSmallStringO(self, 2,-4);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(ssGet(r), "");
   ck_assert_str_eq(sjGet(self), "sheepy");
   terminateO(r);
   // end of string
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropSmallStringO(self, 2,6);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(ssGet(r), "eepy");
   ck_assert_str_eq(sjGet(self), "sh");
   terminateO(r);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(cropSmallStringO(self, 2,-4), NULL);
   // start outside string
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert_ptr_eq(cropSmallStringO(self, 20,-4), NULL);
   // end outside string
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropSmallStringO(self, 2,40);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(ssGet(r), "eepy");
   ck_assert_str_eq(sjGet(self), "sh");
   terminateO(r);
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropSmallStringO(self, -22,3);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(ssGet(r), "she");
   ck_assert_str_eq(sjGet(self), "epy");
   terminateO(r);
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert_ptr_eq(cropSmallStringO(self, 2,-40), NULL);
   // end before start
   ck_assert_ptr_eq(cropSmallStringO(self, 4,2), NULL);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallJsonT(void) {
 
   baset* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtO(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,4]");
   free(s);
   // negative index
   r = cropElemAtO(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "4");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // undefined object
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtO(self,2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // container
   createSmallContainer(c);
   r2 = self->f->pushSmallContainer(self, &c);
   r = cropElemAtO(self,2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // base object in container
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->push(self, (baset*)I);
   r = cropElemAtO(self,2);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r->type, "anothertype");
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "11");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // index outside
   ck_assert_ptr_eq(cropElemAtO(self, 20), NULL);
   ck_assert_ptr_eq(cropElemAtO(self, -4), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(cropElemAtO(self, 0), NULL);
   ck_assert_ptr_eq(cropElemAtO(self, -1), NULL);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtO(self, 0);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(cropElemAtO(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void cropElemAtUndefinedSmallJsonT(void) {
 
   undefinedt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtUndefinedO(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,null]");
   free(s);
   // negative index
   r = cropElemAtUndefinedO(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtUndefinedO(self,2);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11]");
   free(s);
   // index outside
   ck_assert_ptr_eq(cropElemAtUndefinedO(self, 20), NULL);
   ck_assert_ptr_eq(cropElemAtUndefinedO(self, -4), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(cropElemAtUndefinedO(self, 0), NULL);
   ck_assert_ptr_eq(cropElemAtUndefinedO(self, -1), NULL);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtUndefinedO(self, 0);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(cropElemAtUndefinedO(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void cropElemAtBoolSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtBoolO(self,1);
   ck_assert(r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,true]");
   free(s);
   // negative index
   r = cropElemAtBoolO(self,-1);
   ck_assert(r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = cropElemAtBoolO(self,2);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtBoolO(self,3);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!cropElemAtBoolO(self, 20));
   ck_assert(!cropElemAtBoolO(self, -5));
   // empty list
   emptyO(self);
   ck_assert(!cropElemAtBoolO(self, 0));
   ck_assert(!cropElemAtBoolO(self, -1));
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtBoolO(self, 0);
   ck_assert(!r);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert(!cropElemAtBoolO(self, 0));
   terminateO(self);
 
 }
 
 
 void cropElemAtDoubleSmallJsonT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushDouble(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushDouble(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtDoubleO(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,4.000000e+00]");
   free(s);
   // negative index
   r = cropElemAtDoubleO(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = cropElemAtDoubleO(self,2);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtDoubleO(self,3);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!cropElemAtDoubleO(self, 20));
   ck_assert(!cropElemAtDoubleO(self, -5));
   // empty list
   emptyO(self);
   ck_assert(!cropElemAtDoubleO(self, 0));
   ck_assert(!cropElemAtDoubleO(self, -1));
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtDoubleO(self, 0);
   ck_assert(!r);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert(!cropElemAtDoubleO(self, 0));
   terminateO(self);
 
 }
 
 
 void cropElemAtIntSmallJsonT(void) {
 
   int64_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtIntO(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,4]");
   free(s);
   // negative index
   r = cropElemAtIntO(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = cropElemAtIntO(self,2);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtIntO(self,3);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!cropElemAtIntO(self, 20));
   ck_assert(!cropElemAtIntO(self, -5));
   // empty list
   emptyO(self);
   ck_assert(!cropElemAtIntO(self, 0));
   ck_assert(!cropElemAtIntO(self, -1));
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtIntO(self, 0);
   ck_assert(!r);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert(!cropElemAtO(self, 0));
   terminateO(self);
 
 }
 
 
 void cropElemAtInt32SmallJsonT(void) {
 
   int32_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtInt32O(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,4]");
   free(s);
   // negative index
   r = cropElemAtInt32O(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = cropElemAtInt32O(self,2);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtInt32O(self,3);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!cropElemAtInt32O(self, 20));
   ck_assert(!cropElemAtInt32O(self, -5));
   // empty list
   emptyO(self);
   ck_assert(!cropElemAtInt32O(self, 0));
   ck_assert(!cropElemAtInt32O(self, -1));
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtInt32O(self, 0);
   ck_assert(!r);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert(!cropElemAtO(self, 0));
   terminateO(self);
 
 }
 
 
 void cropElemAtUintSmallJsonT(void) {
 
   uint64_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtUintO(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,4]");
   free(s);
   // negative index
   r = cropElemAtUintO(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = cropElemAtUintO(self,2);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtUintO(self,3);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!cropElemAtUintO(self, 20));
   ck_assert(!cropElemAtUintO(self, -5));
   // empty list
   emptyO(self);
   ck_assert(!cropElemAtUintO(self, 0));
   ck_assert(!cropElemAtUintO(self, -1));
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtUintO(self, 0);
   ck_assert(!r);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert(!cropElemAtUintO(self, 0));
   terminateO(self);
 
 }
 
 
 void cropElemAtUint32SmallJsonT(void) {
 
   uint32_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtUint32O(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,4]");
   free(s);
   // negative index
   r = cropElemAtUint32O(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = cropElemAtUint32O(self,2);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtUint32O(self,3);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!cropElemAtUint32O(self, 20));
   ck_assert(!cropElemAtUint32O(self, -5));
   // empty list
   emptyO(self);
   ck_assert(!cropElemAtUint32O(self, 0));
   ck_assert(!cropElemAtUint32O(self, -1));
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtUint32O(self, 0);
   ck_assert(!r);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert(!cropElemAtUint32O(self, 0));
   terminateO(self);
 
 }
 
 
 void cropElemAtSSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushS(self, "2");
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushS(self, "4");
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtSO(self,1);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "2");
   free(r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,\"4\"]");
   free(s);
   // negative index
   r = cropElemAtSO(self,-1);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "4");
   free(r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = cropElemAtSO(self,2);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSO(self,3);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(cropElemAtSO(self, 20), NULL);
   ck_assert_ptr_eq(cropElemAtSO(self, -5), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(cropElemAtSO(self, 0), NULL);
   ck_assert_ptr_eq(cropElemAtSO(self, -1), NULL);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtSO(self, 0);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(cropElemAtSO(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void cropElemAtCharSmallJsonT(void) {
 
   char r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // crop
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropElemAtCharO(self, 0);
   ck_assert_int_eq(r, 's');
   ck_assert_str_eq(sjGet(self), "heepy");
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropElemAtCharO(self, 5);
   ck_assert_int_eq(r, 'y');
   ck_assert_str_eq(sjGet(self), "sheep");
   // negative index
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropElemAtCharO(self, -1);
   ck_assert_int_eq(r, 'y');
   ck_assert_str_eq(sjGet(self), "sheep");
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropElemAtCharO(self, -6);
   ck_assert_int_eq(r, 's');
   ck_assert_str_eq(sjGet(self), "heepy");
   // index outside string
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropElemAtCharO(self, 6);
   ck_assert_int_eq(r, 0);
   ck_assert_str_eq(sjGet(self), "sheepy");
   freeO(self);
   setTopSO(self, "sheepy");
   r = cropElemAtCharO(self, -7);
   ck_assert_int_eq(r, 0);
   ck_assert_str_eq(sjGet(self), "sheepy");
   // null string
   freeO(self);
   ck_assert_int_eq(cropElemAtCharO(self, 0), 0);
   terminateO(self);
 
 }
 
 
 void cropElemAtDictSmallJsonT(void) {
 
   smallDictt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallDict(e2);
   r2 = self->f->pushDict(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallDict(e4);
   r2 = self->f->pushDict(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtDictO(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,{}]");
   free(s);
   // negative index
   r = cropElemAtDictO(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = cropElemAtDictO(self,2);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtDictO(self,3);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(cropElemAtDictO(self, 20), NULL);
   ck_assert_ptr_eq(cropElemAtDictO(self, -5), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(cropElemAtDictO(self, 0), NULL);
   ck_assert_ptr_eq(cropElemAtDictO(self, -1), NULL);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtDictO(self, 0);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(cropElemAtDictO(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void cropElemAtArraySmallJsonT(void) {
 
   smallArrayt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallArray(e2);
   r2 = self->f->pushArray(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallArray(e4);
   r2 = self->f->pushArray(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtArrayO(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,[]]");
   free(s);
   // negative index
   r = cropElemAtArrayO(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = cropElemAtArrayO(self,2);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtArrayO(self,3);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(cropElemAtArrayO(self, 20), NULL);
   ck_assert_ptr_eq(cropElemAtArrayO(self, -5), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(cropElemAtArrayO(self, 0), NULL);
   ck_assert_ptr_eq(cropElemAtArrayO(self, -1), NULL);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtArrayO(self, 0);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(cropElemAtArrayO(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallBoolSmallJsonT(void) {
 
   smallBoolt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallBool(e2);
   r2 = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallBool(e4);
   r2 = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtSmallBoolO(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,true]");
   free(s);
   // negative index
   r = cropElemAtSmallBoolO(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = cropElemAtSmallBoolO(self,2);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallBoolO(self,3);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(cropElemAtSmallBoolO(self, 20), NULL);
   ck_assert_ptr_eq(cropElemAtSmallBoolO(self, -5), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(cropElemAtSmallBoolO(self, 0), NULL);
   ck_assert_ptr_eq(cropElemAtSmallBoolO(self, -1), NULL);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtSmallBoolO(self, 0);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(cropElemAtSmallBoolO(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallBytesSmallJsonT(void) {
 
   smallBytest* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallBytes(e2);
   r2 = self->f->pushSmallBytes(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallBytes(e4);
   r2 = self->f->pushSmallBytes(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtSmallBytesO(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,[]]");
   free(s);
   // negative index
   r = cropElemAtSmallBytesO(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = cropElemAtSmallBytesO(self,2);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallBytesO(self,3);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(cropElemAtSmallBytesO(self, 20), NULL);
   ck_assert_ptr_eq(cropElemAtSmallBytesO(self, -5), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(cropElemAtSmallBytesO(self, 0), NULL);
   ck_assert_ptr_eq(cropElemAtSmallBytesO(self, -1), NULL);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtSmallBytesO(self, 0);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(cropElemAtSmallBytesO(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallDoubleSmallJsonT(void) {
 
   smallDoublet* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallDouble(e2);
   r2 = self->f->pushSmallDouble(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallDouble(e4);
   r2 = self->f->pushSmallDouble(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtSmallDoubleO(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "0.000000e+00");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,0.000000e+00]");
   free(s);
   // negative index
   r = cropElemAtSmallDoubleO(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "0.000000e+00");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = cropElemAtSmallDoubleO(self,2);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallDoubleO(self,3);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(cropElemAtSmallDoubleO(self, 20), NULL);
   ck_assert_ptr_eq(cropElemAtSmallDoubleO(self, -5), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(cropElemAtSmallDoubleO(self, 0), NULL);
   ck_assert_ptr_eq(cropElemAtSmallDoubleO(self, -1), NULL);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtSmallDoubleO(self, 0);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(cropElemAtSmallDoubleO(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallIntSmallJsonT(void) {
 
   smallIntt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   createSmallInt(e2);
   r2 = self->f->pushSmallInt(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   createSmallInt(e4);
   r2 = self->f->pushSmallInt(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtSmallIntO(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "0");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true,true,0]");
   free(s);
   // negative index
   r = cropElemAtSmallIntO(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "0");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true,true]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = cropElemAtSmallIntO(self,2);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true,true,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallIntO(self,3);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true,true,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(cropElemAtSmallIntO(self, 20), NULL);
   ck_assert_ptr_eq(cropElemAtSmallIntO(self, -5), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(cropElemAtSmallIntO(self, 0), NULL);
   ck_assert_ptr_eq(cropElemAtSmallIntO(self, -1), NULL);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtSmallIntO(self, 0);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(cropElemAtSmallIntO(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallJson(e2);
   r2 = self->f->pushSmallJson(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallJson(e4);
   r2 = self->f->pushSmallJson(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtSmallJsonO(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,{}]");
   free(s);
   // negative index
   r = cropElemAtSmallJsonO(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallBytes(I);
   r2 = self->f->pushSmallBytes(self, &I);
   r = cropElemAtSmallJsonO(self,2);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,[]]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallJsonO(self,3);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,[],\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(cropElemAtSmallJsonO(self, 20), NULL);
   ck_assert_ptr_eq(cropElemAtSmallJsonO(self, -5), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(cropElemAtSmallJsonO(self, 0), NULL);
   ck_assert_ptr_eq(cropElemAtSmallJsonO(self, -1), NULL);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtSmallJsonO(self, 0);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(cropElemAtSmallJsonO(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallStringSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallString(e2);
   r2 = self->f->pushSmallString(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallString(e4);
   r2 = self->f->pushSmallString(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtSmallStringO(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,\"\"]");
   free(s);
   // negative index
   r = cropElemAtSmallStringO(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = cropElemAtSmallStringO(self,2);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallStringO(self,3);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(cropElemAtSmallStringO(self, 20), NULL);
   ck_assert_ptr_eq(cropElemAtSmallStringO(self, -5), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(cropElemAtSmallStringO(self, 0), NULL);
   ck_assert_ptr_eq(cropElemAtSmallStringO(self, -1), NULL);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtSmallStringO(self, 0);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(cropElemAtSmallStringO(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void cropElemAtVoidSmallJsonT(void) {
 
   void* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = pushVoidSmallJsonG(self, &r);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = pushVoidSmallJsonG(self, &self);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtVoidO(self,1);
   ck_assert_ptr_eq(r, &r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,\"<data container>\"]");
   free(s);
   // negative index
   r = cropElemAtVoidO(self,-1);
   ck_assert_ptr_eq(r, &self);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = cropElemAtVoidO(self,2);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtVoidO(self,3);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(cropElemAtVoidO(self, 20), NULL);
   ck_assert_ptr_eq(cropElemAtVoidO(self, -5), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(cropElemAtVoidO(self, 0), NULL);
   ck_assert_ptr_eq(cropElemAtVoidO(self, -1), NULL);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtVoidO(self, 0);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(cropElemAtVoidO(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallContainerSmallJsonT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallContainer(e2);
   r2 = self->f->pushSmallContainer(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallContainer(e4);
   r2 = self->f->pushSmallContainer(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = cropElemAtSmallContainerO(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,\"<data container>\"]");
   free(s);
   // negative index
   r = cropElemAtSmallContainerO(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = cropElemAtSmallContainerO(self,2);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallContainerO(self,3);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(cropElemAtSmallContainerO(self, 20), NULL);
   ck_assert_ptr_eq(cropElemAtSmallContainerO(self, -5), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(cropElemAtSmallContainerO(self, 0), NULL);
   ck_assert_ptr_eq(cropElemAtSmallContainerO(self, -1), NULL);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   delElemIndexO(self,-1);
   r = cropElemAtSmallContainerO(self, 0);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(cropElemAtSmallContainerO(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallJsonT(void) {
 
   baset* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setS(self, "3", "2");
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setUndefined(self, "u");
   ck_assert_ptr_ne(r2, null);
   createSmallContainer(c);
   r2 = self->f->setSmallContainer(self, "c", &c);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "b", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   // get int
   r = cropElemKeyO(self, "3");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"u\":null,\"c\":\"<data container>\",\"b\":\"<data container>\"}");
   free(s);
   // undefined object
   r = cropElemKeyO(self, "u");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"c\":\"<data container>\",\"b\":\"<data container>\"}");
   free(s);
   // container
   r = cropElemKeyO(self, "c");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"b\":\"<data container>\"}");
   free(s);
   // base object in container
   r = cropElemKeyO(self, "b");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "11");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00}");
   free(s);
   // non existing key
   r = cropElemKeyO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null key
   r = cropElemKeyO(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = cropElemKeyO(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void cropElemKeyUndefinedSmallJsonT(void) {
 
   undefinedt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setUndefined(self, "u");
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyUndefinedO(self, "u");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00}");
   free(s);
   // wrong object type
   r = cropElemKeyUndefinedO(self, "1");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00}");
   free(s);
   // non existing key
   r = cropElemKeyUndefinedO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null key
   r = cropElemKeyUndefinedO(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = cropElemKeyUndefinedO(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void cropElemKeyBoolSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setBool(self, "b", true);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyBoolO(self, "b");
   ck_assert(r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeyBoolO(self, "1");
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeyBoolO(self, "B");
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeyBoolO(self, "qwe");
   ck_assert(!r);
   // null key
   r = cropElemKeyBoolO(self, null);
   ck_assert(!r);
 	// empty self
   freeO(self);
   r = cropElemKeyBoolO(self, "1");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void cropElemKeyDoubleSmallJsonT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "b", 3.3);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyDoubleO(self, "b");
   ck_assert(r == 3.3);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeyDoubleO(self, "1");
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeyDoubleO(self, "B");
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeyDoubleO(self, "qwe");
   ck_assert(!r);
   // null key
   r = cropElemKeyDoubleO(self, null);
   ck_assert(r == 0);
 	// empty self
   freeO(self);
   r = cropElemKeyDoubleO(self, "1");
   ck_assert(r == 0);
   terminateO(self);
 
 }
 
 
 void cropElemKeyIntSmallJsonT(void) {
 
   int64_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setInt(self, "b", 2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyIntO(self, "b");
   ck_assert_int_eq(r, 2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeyIntO(self, "2");
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeyIntO(self, "B");
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeyIntO(self, "qwe");
   ck_assert(!r);
   // null key
   r = cropElemKeyIntO(self, null);
   ck_assert_int_eq(r, 0);
 	// empty self
   freeO(self);
   r = cropElemKeyIntO(self, "1");
   ck_assert_int_eq(r, 0);
   terminateO(self);
 
 }
 
 
 void cropElemKeyInt32SmallJsonT(void) {
 
   int32_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setInt(self, "b", 2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyInt32O(self, "b");
   ck_assert_int_eq(r, 2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeyInt32O(self, "2");
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeyInt32O(self, "B");
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeyInt32O(self, "qwe");
   ck_assert(!r);
   // null key
   r = cropElemKeyInt32O(self, null);
   ck_assert_int_eq(r, 0);
 	// empty self
   freeO(self);
   r = cropElemKeyInt32O(self, "1");
   ck_assert_int_eq(r, 0);
   terminateO(self);
 
 }
 
 
 void cropElemKeyUintSmallJsonT(void) {
 
   uint64_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setInt(self, "b", 2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyUintO(self, "b");
   ck_assert_int_eq(r, 2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeyUintO(self, "2");
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeyUintO(self, "B");
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeyUintO(self, "qwe");
   ck_assert(!r);
   // null key
   r = cropElemKeyUintO(self, null);
   ck_assert_int_eq(r, 0);
 	// empty self
   freeO(self);
   r = cropElemKeyUintO(self, "1");
   ck_assert_int_eq(r, 0);
   terminateO(self);
 
 }
 
 
 void cropElemKeyUint32SmallJsonT(void) {
 
   uint32_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setInt(self, "b", 2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyUint32O(self, "b");
   ck_assert_int_eq(r, 2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeyUint32O(self, "2");
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeyUint32O(self, "B");
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeyUint32O(self, "qwe");
   ck_assert(!r);
   // null key
   r = cropElemKeyUint32O(self, null);
   ck_assert_int_eq(r, 0);
 	// empty self
   freeO(self);
   r = cropElemKeyUint32O(self, "1");
   ck_assert_int_eq(r, 0);
   terminateO(self);
 
 }
 
 
 void cropElemKeySSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setS(self, "b", "qwe");
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySO(self, "b");
   ck_assert_str_eq(r, "qwe");
   free(r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeySO(self, "2");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeySO(self, "B");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeySO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null key
   r = cropElemKeySO(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = cropElemKeySO(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void cropElemKeyDictSmallJsonT(void) {
 
   smallDictt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallDict(d);
   r2 = self->f->setNFreeDict(self, "b", d);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyDictO(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeyDictO(self, "2");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeyDictO(self, "B");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeyDictO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null key
   r = cropElemKeyDictO(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = cropElemKeyDictO(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void cropElemKeyArraySmallJsonT(void) {
 
   smallArrayt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallArray(d);
   r2 = self->f->setNFreeArray(self, "b", d);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyArrayO(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeyArrayO(self, "2");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeyArrayO(self, "B");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeyArrayO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null key
   r = cropElemKeyArrayO(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = cropElemKeyArrayO(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallBoolSmallJsonT(void) {
 
   smallBoolt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setBool(self, "b", true);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySmallBoolO(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeySmallBoolO(self, "2");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeySmallBoolO(self, "B");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeySmallBoolO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null key
   r = cropElemKeySmallBoolO(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = cropElemKeySmallBoolO(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallBytesSmallJsonT(void) {
 
   smallBytest* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallBytes(d);
   r2 = self->f->setNFreeSmallBytes(self, "b", d);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySmallBytesO(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeySmallBytesO(self, "2");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeySmallBytesO(self, "B");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeySmallBytesO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null key
   r = cropElemKeySmallBytesO(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = cropElemKeySmallBytesO(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallDoubleSmallJsonT(void) {
 
   smallDoublet* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "b", 3.3);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySmallDoubleO(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "3.300000e+00");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeySmallDoubleO(self, "1");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeySmallDoubleO(self, "B");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeySmallDoubleO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null key
   r = cropElemKeySmallDoubleO(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = cropElemKeySmallDoubleO(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallIntSmallJsonT(void) {
 
   smallIntt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setInt(self, "b", 2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySmallIntO(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeySmallIntO(self, "2");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeySmallIntO(self, "B");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeySmallIntO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null key
   r = cropElemKeySmallIntO(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = cropElemKeySmallIntO(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallBytes(b);
   r2 = self->f->setNFreeSmallBytes(self, "2", b);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallJson(d);
   r2 = self->f->setNFreeSmallJson(self, "b", d);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySmallJsonO(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":[],\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeySmallJsonO(self, "2");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":[],\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeySmallJsonO(self, "B");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":[],\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeySmallJsonO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null key
   r = cropElemKeySmallJsonO(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = cropElemKeySmallJsonO(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallStringSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setS(self, "b", "qwe");
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySmallStringO(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeySmallStringO(self, "2");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeySmallStringO(self, "B");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeySmallStringO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null key
   r = cropElemKeySmallStringO(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = cropElemKeySmallStringO(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void cropElemKeyVoidSmallJsonT(void) {
 
   void* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   smallContainert *c = allocSmallContainer(&r);
   r2 = self->f->setNFreeSmallContainer(self, "b", c);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyVoidO(self, "b");
   ck_assert_ptr_eq(r, &r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeyVoidO(self, "2");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeyVoidO(self, "B");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeyVoidO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null key
   r = cropElemKeyVoidO(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = cropElemKeyVoidO(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallContainerSmallJsonT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   smallContainert *c = allocSmallContainer(&r);
   r2 = self->f->setNFreeSmallContainer(self, "b", c);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySmallContainerO(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // wrong object type
   r = cropElemKeySmallContainerO(self, "2");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   r = cropElemKeySmallContainerO(self, "B");
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   // non existing key
   r = cropElemKeySmallContainerO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null key
   r = cropElemKeySmallContainerO(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = cropElemKeySmallContainerO(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void copySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // negative index
   r = copyRngO(self, 1, -1);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[2,3]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // start outside
   ck_assert_ptr_eq(copyRngO(self, 20, -3), NULL);
   // end outside
   r = copyRngO(self, 0, 40);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 4);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // end negative and outside
   ck_assert_ptr_eq(copyRngO(self, 2, -40), NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // end before start
   ck_assert_ptr_eq(copyRngO(self, 3, 2), NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative start last element
   r = copyRngO(self, -1, 0);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[4]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative start and outside
   r = copyRngO(self, -10, 1);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // start = end
   r = copyRngO(self, 1, 1);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 0);
   terminateO(r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(copyRngO(self, 0, 0), NULL);
   ck_assert_ptr_eq(copyRngO(self, -1, 0), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(copyRngO(self, 0, 1), NULL);
   terminateO(self);
   // json string
   self = allocSmallJson();
   // copy range
   setTopSO(self, "sheepy");
   r = copyRngO(self, 0,2);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "sh");
   ck_assert_str_eq(sjGet(self), "sheepy");
   terminateO(r);
   // negative index
   r = copyRngO(self, -2,0);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "py");
   ck_assert_str_eq(sjGet(self), "sheepy");
   terminateO(r);
   // positive and negative indexes
   r = copyRngO(self, 2,-2);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "ee");
   ck_assert_str_eq(sjGet(self), "sheepy");
   terminateO(r);
   // start = end
   r = copyRngO(self, 2,-4);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "");
   ck_assert_str_eq(sjGet(self), "sheepy");
   terminateO(r);
   // end of string
   r = copyRngO(self, 2,6);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   ck_assert_str_eq(sjGet(self), "sheepy");
   terminateO(r);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(copyRngO(self, 2,-4), NULL);
   // start outside string
   setTopSO(self, "sheepy");
   ck_assert_ptr_eq(copyRngO(self, 20,-4), NULL);
   // end outside string
   r = copyRngO(self, 2,40);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   ck_assert_str_eq(sjGet(self), "sheepy");
   terminateO(r);
   r = copyRngO(self, -22,3);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "she");
   ck_assert_str_eq(sjGet(self), "sheepy");
   terminateO(r);
   ck_assert_ptr_eq(copyRngO(self, 2,-40), NULL);
   // end before start
   ck_assert_ptr_eq(copyRngO(self, 4,2), NULL);
   terminateO(self);
 
 }
 
 
 void insertSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *toInsert;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInsert = allocSmallArray();
   toInsert->f->pushInt(toInsert, 3);
   r        = self->f->insert(self, 1, toInsert);
   smashO(toInsert);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,3,2]");
   free(s);
   // negative index
   toInsert = allocSmallArray();
   toInsert->f->pushInt(toInsert, 4);
   r = self->f->insert(self, -1, toInsert);
   smashO(toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,3,2,4]");
   free(s);
   // empty list
   emptyO(self);
   toInsert = allocSmallArray();
   toInsert->f->pushInt(toInsert, 3);
   r = self->f->insert(self, 0, toInsert);
   smashO(toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   emptyO(self);
   toInsert = allocSmallArray();
   toInsert->f->pushInt(toInsert, 3);
   r = self->f->insert(self, -1, toInsert);
   smashO(toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   // Array array length 0
   toInsert = allocSmallArray();
   r = self->f->insert(self, -1, toInsert);
   smashO(toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   // index outside
   toInsert = allocSmallArray();
   ck_assert_ptr_eq(self->f->insert(self, 20, toInsert), NULL);
   ck_assert_ptr_eq(self->f->insert(self, -5, toInsert), NULL);
   smashO(toInsert);
   // non smallArray toInsert
   toInsert = (smallArrayt*) allocSmallInt(1);
   ck_assert_ptr_eq(self->f->insert(self, 0, toInsert), NULL);
   terminateO(toInsert);
   // insert NULL
   ck_assert_ptr_eq(self->f->insert(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   toInsert = allocSmallArray();
   ck_assert_ptr_eq(self->f->insert(self, 0, toInsert), NULL);
   terminateO(toInsert);
   terminateO(self);
 
 }
 
 
 void insertNSmashSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *toInsert;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInsert = allocSmallArray();
   toInsert->f->pushInt(toInsert, 3);
   r        = self->f->insertNSmash(self, 1, toInsert);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,3,2]");
   free(s);
   // negative index
   toInsert = allocSmallArray();
   toInsert->f->pushInt(toInsert, 4);
   r = self->f->insertNSmash(self, -1, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,3,2,4]");
   free(s);
   // empty list
   emptyO(self);
   toInsert = allocSmallArray();
   toInsert->f->pushInt(toInsert, 3);
   r = self->f->insertNSmash(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   emptyO(self);
   toInsert = allocSmallArray();
   toInsert->f->pushInt(toInsert, 3);
   r = self->f->insertNSmash(self, -1, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   // Array array length 0
   toInsert = allocSmallArray();
   r = self->f->insertNSmash(self, -1, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   // index outside
   toInsert = allocSmallArray();
   ck_assert_ptr_eq(self->f->insertNSmash(self, 20, toInsert), NULL);
   ck_assert_ptr_eq(self->f->insertNSmash(self, -5, toInsert), NULL);
   smashO(toInsert);
   // insert NULL
   ck_assert_ptr_eq(self->f->insertNSmash(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void insertSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *toInsert;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInsert = allocSmallJson();
   toInsert->f->pushInt(toInsert, 3);
   r        = self->f->insertSmallJson(self, 1, toInsert);
   smashO(toInsert);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,3,2]");
   free(s);
   // negative index
   toInsert = allocSmallJson();
   toInsert->f->pushInt(toInsert, 4);
   r = self->f->insertSmallJson(self, -1, toInsert);
   smashO(toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,3,2,4]");
   free(s);
   // empty list
   emptyO(self);
   toInsert = allocSmallJson();
   toInsert->f->pushInt(toInsert, 3);
   r = self->f->insertSmallJson(self, 0, toInsert);
   smashO(toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   emptyO(self);
   toInsert = allocSmallJson();
   toInsert->f->pushInt(toInsert, 3);
   r = self->f->insertSmallJson(self, -1, toInsert);
   smashO(toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   // json array length 0
   toInsert = allocSmallJson();
   setTypeArrayG(toInsert);
   r = self->f->insertSmallJson(self, -1, toInsert);
   smashO(toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   // json with no type
   toInsert = allocSmallJson();
   r = self->f->insertSmallJson(self, -1, toInsert);
   smashO(toInsert);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[3]");
   free(s);
   // non smallJson object
   toInsert = (smallJsont*) allocSmallInt(2);
   r = self->f->insertSmallJson(self, -1, toInsert);
   ck_assert_ptr_eq(r, null);
   terminateO(toInsert);
   // index outside
   toInsert = allocSmallJson();
   ck_assert_ptr_eq(self->f->insertSmallJson(self, 20, toInsert), NULL);
   ck_assert_ptr_eq(self->f->insertSmallJson(self, -5, toInsert), NULL);
   smashO(toInsert);
   // insert NULL
   ck_assert_ptr_eq(self->f->insertSmallJson(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void insertNSmashSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *toInsert;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInsert = allocSmallJson();
   toInsert->f->pushInt(toInsert, 3);
   r        = self->f->insertNSmashSmallJson(self, 1, toInsert);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,3,2]");
   free(s);
   // negative index
   toInsert = allocSmallJson();
   toInsert->f->pushInt(toInsert, 4);
   r = self->f->insertNSmashSmallJson(self, -1, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,3,2,4]");
   free(s);
   // empty list
   emptyO(self);
   toInsert = allocSmallJson();
   toInsert->f->pushInt(toInsert, 3);
   r = self->f->insertNSmashSmallJson(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   emptyO(self);
   toInsert = allocSmallJson();
   toInsert->f->pushInt(toInsert, 3);
   r = self->f->insertNSmashSmallJson(self, -1, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   // json array length 0
   toInsert = allocSmallJson();
   setTypeArrayG(toInsert);
   r = self->f->insertNSmashSmallJson(self, -1, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   // json with no type
   toInsert = allocSmallJson();
   r = self->f->insertNSmashSmallJson(self, -1, toInsert);
   smashO(toInsert);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[3]");
   free(s);
   // index outside
   toInsert = allocSmallJson();
   ck_assert_ptr_eq(self->f->insertNSmashSmallJson(self, 20, toInsert), NULL);
   ck_assert_ptr_eq(self->f->insertNSmashSmallJson(self, -5, toInsert), NULL);
   smashO(toInsert);
   // insert NULL
   ck_assert_ptr_eq(self->f->insertNSmashSmallJson(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void insertStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt *toInsert = allocSmallString("");
 
   // insert
   freeO(self);
   setTopSO(self, "sheepy");
   setValO(toInsert, "lib");
   r = insertStringO(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "libsheepy");
   free(s);
   // negative index
   setValO(toInsert, "P");
   r = insertStringO(self, -2, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "libsheepPy");
   free(s);
   // edge
   freeO(self);
   setTopSO(self, "qwe");
   setValO(toInsert, "C");
   r = insertStringO(self, 3, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "qweC");
   free(s);
   // outside string
   freeO(self);
   setTopSO(self, "qwe");
   r = insertStringO(self, 4, toInsert);
   ck_assert_ptr_eq(r, NULL);
   r = insertStringO(self, -5, toInsert);
   ck_assert_ptr_eq(r, NULL);
   // negative index in a one char string
   freeO(self);
   setTopSO(self, "s");
   setValO(toInsert, "S");
   r = insertStringO(self, -1, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sS");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(toInsert, "s");
   r = insertStringO(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "s");
   free(s);
   freeO(self);
   setTopSO(self, "");
   r = insertStringO(self, -1, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "s");
   free(s);
   // empty insert string
   freeO(self);
   setTopSO(self, "a");
   setValO(toInsert, "");
   r = insertStringO(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "a");
   free(s);
   freeO(toInsert);
   r = insertStringO(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "a");
   free(s);
   // non smallString toInsert
   terminateO(toInsert);
   toInsert = (smallStringt*) allocSmallInt(1);
   r = insertStringO(self, 0, toInsert);
   ck_assert_ptr_eq(r, null);
   terminateO(toInsert);
   toInsert = allocSmallString("");
   // NULL insert string
   r = insertStringO(self, 0, NULL);
   ck_assert_ptr_eq(r, null);
   // NULL string
   freeO(self);
   setValO(toInsert, "s");
   r = insertStringO(self, 1, toInsert);
   ck_assert_ptr_eq(r, null);
   r = insertStringO(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "s");
   free(s);
   terminateO(toInsert);
   terminateO(self);
 
 }
 
 
 void insertSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // insert
   freeO(self);
   setTopSO(self, "sheepy");
   r = insertSO(self, 0, "lib");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "libsheepy");
   free(s);
   // negative index
   r = insertSO(self, -2, "P");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "libsheepPy");
   free(s);
   // edge
   freeO(self);
   setTopSO(self, "qwe");
   r = insertSO(self, 3, "C");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "qweC");
   free(s);
   // outside string
   freeO(self);
   setTopSO(self, "qwe");
   r = insertSO(self, 4, "C");
   ck_assert_ptr_eq(r, NULL);
   r = insertSO(self, -5, "C");
   ck_assert_ptr_eq(r, NULL);
   // negative index in a one char string
   freeO(self);
   setTopSO(self, "s");
   r = insertSO(self, -1, "S");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sS");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = insertSO(self, 0, "s");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "s");
   free(s);
   freeO(self);
   setTopSO(self, "");
   r = insertSO(self, -1, "s");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "s");
   free(s);
   // empty insert string
   freeO(self);
   setTopSO(self, "a");
   r = insertSO(self, 0, "");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "a");
   free(s);
   // NULL insert string
   r = insertSO(self, 0, NULL);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "a");
   free(s);
   // NULL string
   freeO(self);
   r = insertSO(self, 0, "s");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "s");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(insertSO(self, 0, "asd"), NULL);
   terminateO(self);
 
 }
 
 
 void insertNFreeStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt *toInsert = allocSmallString("");
 
   // insert
   freeO(self);
   setTopSO(self, "sheepy");
   setValO(toInsert, "lib");
   r = self->f->insertNFreeString(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "libsheepy");
   free(s);
   // negative index
   toInsert = allocSmallString("P");
   r = self->f->insertNFreeString(self, -2, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "libsheepPy");
   free(s);
   // edge
   freeO(self);
   setTopSO(self, "qwe");
   toInsert = allocSmallString("C");
   r = self->f->insertNFreeString(self, 3, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "qweC");
   free(s);
   // outside string
   freeO(self);
   setTopSO(self, "qwe");
   toInsert = allocSmallString("S");
   r = self->f->insertNFreeString(self, 4, toInsert);
   ck_assert_ptr_eq(r, NULL);
   r = self->f->insertNFreeString(self, -5, toInsert);
   ck_assert_ptr_eq(r, NULL);
   // negative index in a one char string
   freeO(self);
   setTopSO(self, "s");
   r = self->f->insertNFreeString(self, -1, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sS");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   toInsert = allocSmallString("s");
   r = self->f->insertNFreeString(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "s");
   free(s);
   freeO(self);
   setTopSO(self, "");
   toInsert = allocSmallString("s");
   r = self->f->insertNFreeString(self, -1, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "s");
   free(s);
   // empty insert string
   freeO(self);
   setTopSO(self, "a");
   toInsert = allocSmallString("");
   r = self->f->insertNFreeString(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "a");
   free(s);
   toInsert = allocSmallString("");
   freeO(toInsert);
   r = self->f->insertNFreeString(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "a");
   free(s);
   // non smallString toInsert
   toInsert = (smallStringt*) allocSmallInt(1);
   r = self->f->insertNFreeString(self, 0, toInsert);
   ck_assert_ptr_eq(r, null);
   terminateO(toInsert);
   toInsert = allocSmallString("s");
   // NULL insert string
   r = self->f->insertNFreeString(self, 0, NULL);
   ck_assert_ptr_eq(r, null);
   // NULL string
   freeO(self);
   r = self->f->insertNFreeString(self, 1, toInsert);
   ck_assert_ptr_eq(r, null);
   r = self->f->insertNFreeString(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "s");
   free(s);
   terminateO(self);
 
 }
 
 
 void insertSNFreeSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // insert
   freeO(self);
   setTopSO(self, "sheepy");
   r = insertSNFreeO(self, 0, strdup("lib"));
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "libsheepy");
   free(s);
   // negative index
   r = insertSNFreeO(self, -2, strdup("P"));
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "libsheepPy");
   free(s);
   // edge
   freeO(self);
   setTopSO(self, "qwe");
   r = insertSNFreeO(self, 3, strdup("C"));
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "qweC");
   free(s);
   // outside string
   freeO(self);
   setTopSO(self, "qwe");
   r = insertSNFreeO(self, 4, "C");
   ck_assert_ptr_eq(r, NULL);
   r = insertSNFreeO(self, -5, "C");
   ck_assert_ptr_eq(r, NULL);
   // negative index in a one char string
   freeO(self);
   setTopSO(self, "s");
   r = insertSNFreeO(self, -1, strdup("S"));
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sS");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = insertSNFreeO(self, 0, strdup("s"));
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "s");
   free(s);
   freeO(self);
   setTopSO(self, "");
   r = insertSNFreeO(self, -1, strdup("s"));
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "s");
   free(s);
   // empty insert string
   freeO(self);
   setTopSO(self, "a");
   r = insertSNFreeO(self, 0, strdup(""));
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "a");
   free(s);
   // NULL insert string
   r = insertSNFreeO(self, 0, NULL);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "a");
   free(s);
   // NULL string
   freeO(self);
   r = insertSNFreeO(self, 0, strdup("s"));
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "s");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = (baset*) allocSmallInt(8);
   r        = self->f->inject(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,8,2,3,4]");
   free(s);
   // negative index
   toInject = (baset*) allocSmallInt(9);
   r = self->f->inject(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,8,2,3,4,9]");
   free(s);
   // index 0
   toInject = (baset*) allocSmallInt(6);
   r = self->f->inject(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[6,1,8,2,3,4,9]");
   free(s);
   // index outside
   toInject = (baset*) allocSmallInt(7);
   ck_assert_ptr_eq(self->f->inject(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->inject(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty list
   emptyO(self);
   toInject = (baset*) allocSmallInt(7);
   ck_assert_ptr_ne(self->f->inject(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[7]");
   free(s);
   emptyO(self);
   toInject = (baset*) allocSmallInt(7);
   ck_assert_ptr_ne(self->f->inject(self, -1, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[7]");
   free(s);
   // null toInject
   ck_assert_ptr_eq(self->f->inject(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   toInject = (baset*) allocSmallInt(7);
   ck_assert_ptr_eq(self->f->inject(self, 0, toInject), NULL);
   terminateO(toInject);
   terminateO(self);
 
 }
 
 
 void injectUndefinedSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   r        = self->f->injectUndefined(self, 1);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,null,2,3,4]");
   free(s);
   // negative index
   r = self->f->injectUndefined(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,null,2,3,4,null]");
   free(s);
   // index 0
   r = self->f->injectUndefined(self,0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[null,1,null,2,3,4,null]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->injectUndefined(self, 20), NULL);
   ck_assert_ptr_eq(self->f->injectUndefined(self, -9), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_ne(self->f->injectUndefined(self, 0), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   emptyO(self);
   ck_assert_ptr_ne(self->f->injectUndefined(self, -1), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   r        = self->f->injectBool(self, 1, true);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,true,2,3,4]");
   free(s);
   // negative index
   r = self->f->injectBool(self,-1, true);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,true,2,3,4,true]");
   free(s);
   // index 0
   r = self->f->injectBool(self,0, true);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[true,1,true,2,3,4,true]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->injectBool(self, 20, true), NULL);
   ck_assert_ptr_eq(self->f->injectBool(self, -9, true), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_ne(self->f->injectBool(self, 0, true), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   emptyO(self);
   ck_assert_ptr_ne(self->f->injectBool(self, -1, true), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->injectBool(self, 0, true), NULL);
   terminateO(self);
 
 }
 
 
 void injectDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   r        = self->f->injectDouble(self, 1, 7);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,7.000000e+00,2,3,4]");
   free(s);
   // negative index
   r = self->f->injectDouble(self,-1, 8);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,7.000000e+00,2,3,4,8.000000e+00]");
   free(s);
   // index 0
   r = self->f->injectDouble(self,0, 9);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[9.000000e+00,1,7.000000e+00,2,3,4,8.000000e+00]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->injectDouble(self, 20, 7.000000e+00), NULL);
   ck_assert_ptr_eq(self->f->injectDouble(self, -9, 7.000000e+00), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_ne(self->f->injectDouble(self, 0, 9), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[9.000000e+00]");
   free(s);
   emptyO(self);
   ck_assert_ptr_ne(self->f->injectDouble(self, -1, 9), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[9.000000e+00]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->injectDouble(self, 0, 0), NULL);
   terminateO(self);
 
 }
 
 
 void injectIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   r        = self->f->injectInt(self, 1, 5);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,5,2,3,4]");
   free(s);
   // negative index
   r = self->f->injectInt(self,-1, 6);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,5,2,3,4,6]");
   free(s);
   // index 0
   r = self->f->injectInt(self,0, 7);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[7,1,5,2,3,4,6]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->injectInt(self, 20, true), NULL);
   ck_assert_ptr_eq(self->f->injectInt(self, -9, true), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_ne(self->f->injectInt(self, 0, 7), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[7]");
   free(s);
   emptyO(self);
   ck_assert_ptr_ne(self->f->injectInt(self, -1, 7), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[7]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->injectInt(self, 0, 0), NULL);
   terminateO(self);
 
 }
 
 
 void injectSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
   // positive index
   r        = self->f->injectS(self, 1, "5");
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,\"5\",2,3,4]");
   free(s);
   // negative index
   r = self->f->injectS(self,-1, "6");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"5\",2,3,4,\"6\"]");
   free(s);
   // index 0
   r = self->f->injectS(self,0, "7");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]");
   free(s);
   // null toInject
   r = self->f->injectS(self,0, null);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->injectS(self, 20, ""), NULL);
   ck_assert_ptr_eq(self->f->injectS(self, -9, ""), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_ne(self->f->injectS(self, 0, "7"), NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"7\"]");
   free(s);
   emptyO(self);
   ck_assert_ptr_ne(self->f->injectS(self, -1, "7"), NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"7\"]");
   free(s);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(self->f->injectS(self, 0, "7"), NULL);
   terminateO(self);
   // json string
   self = allocSmallJson();
   setTopSO(self, "s");
   r = self->f->injectS(self,1, "heepy");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sheepy");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   r        = self->f->injectChar(self, 1, '5');
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,\"5\",2,3,4]");
   free(s);
   // negative index
   r = self->f->injectChar(self,-1, '6');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"5\",2,3,4,\"6\"]");
   free(s);
   // index 0
   r = self->f->injectChar(self,0, '7');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->injectChar(self, 20, 'y'), NULL);
   ck_assert_ptr_eq(self->f->injectChar(self, -9, 'y'), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_ne(self->f->injectChar(self, 0, '7'), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"7\"]");
   free(s);
   emptyO(self);
   ck_assert_ptr_ne(self->f->injectChar(self, -1, '7'), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"7\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallDict();
   r        = self->f->injectDict(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,{},2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallDict();
   r = self->f->injectDict(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,{},2,3,4,{}]");
   free(s);
   // index 0
   toInject = allocSmallDict();
   r = self->f->injectDict(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{},1,{},2,3,4,{}]");
   free(s);
   // index outside
   toInject = allocSmallDict();
   ck_assert_ptr_eq(self->f->injectDict(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectDict(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty list
   emptyO(self);
   toInject = allocSmallDict();
   ck_assert_ptr_ne(self->f->injectDict(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   emptyO(self);
   toInject = allocSmallDict();
   ck_assert_ptr_ne(self->f->injectDict(self, -1, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   // non smallDict object
   toInject = (smallDictt*) allocSmallInt(2);
   r = self->f->injectDict(self, 0, toInject);
   ck_assert_ptr_eq(r, null);
   terminateO(toInject);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectDict(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   toInject = allocSmallDict();
   ck_assert_ptr_eq(self->f->injectDict(self, 0, toInject), NULL);
   terminateO(toInject);
   terminateO(self);
 
 }
 
 
 void injectArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallArray();
   r        = self->f->injectArray(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,[],2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallArray();
   r = self->f->injectArray(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[],2,3,4,[]]");
   free(s);
   // index 0
   toInject = allocSmallArray();
   r = self->f->injectArray(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]");
   free(s);
   // index outside
   toInject = allocSmallArray();
   ck_assert_ptr_eq(self->f->injectArray(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectArray(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty list
   emptyO(self);
   toInject = allocSmallArray();
   ck_assert_ptr_ne(self->f->injectArray(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   emptyO(self);
   toInject = allocSmallArray();
   ck_assert_ptr_ne(self->f->injectArray(self, -1, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   // non smallArray object
   toInject = (smallArrayt*) allocSmallInt(2);
   r = self->f->injectArray(self, 0, toInject);
   ck_assert_ptr_eq(r, null);
   terminateO(toInject);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectArray(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   toInject = allocSmallArray();
   ck_assert_ptr_eq(self->f->injectArray(self, 0, toInject), NULL);
   terminateO(toInject);
   terminateO(self);
 
 }
 
 
 void injectArraycSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = listCreateS("a","b");
   r        = self->f->injectArrayc(self, 1, toInject);
   listFreeS(toInject);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4]");
   free(s);
   // negative index
   toInject = listCreateS("c","d");
   r = self->f->injectArrayc(self,-1, toInject);
   listFreeS(toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]");
   free(s);
   // index 0
   toInject = listCreateS("e","ff");
   r = self->f->injectArrayc(self,0, toInject);
   listFreeS(toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[\"e\",\"ff\"],1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]");
   free(s);
   // index outside
   toInject = listCreateS("a","b");
   ck_assert_ptr_eq(self->f->injectArrayc(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectArrayc(self, -9, toInject), NULL);
   listFreeS(toInject);
   // empty list
   emptyO(self);
   toInject = listCreateS("a","b");
   ck_assert_ptr_ne(self->f->injectArrayc(self, 0, toInject), NULL);
   listFreeS(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"b\"]]");
   free(s);
   emptyO(self);
   toInject = listCreateS("a","b");
   ck_assert_ptr_ne(self->f->injectArrayc(self, -1, toInject), NULL);
   listFreeS(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"b\"]]");
   free(s);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectArrayc(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   toInject = listCreateS("e","ff");
   ck_assert_ptr_eq(self->f->injectArrayc(self, 0, toInject), NULL);
   listFreeS(toInject);
   terminateO(self);
 
 }
 
 
 void injectSmallBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallBool(true);
   r        = self->f->injectSmallBool(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,true,2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallBool(true);
   r = self->f->injectSmallBool(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,true,2,3,4,true]");
   free(s);
   // index 0
   toInject = allocSmallBool(true);
   r = self->f->injectSmallBool(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[true,1,true,2,3,4,true]");
   free(s);
   // index outside
   toInject = allocSmallBool(true);
   ck_assert_ptr_eq(self->f->injectSmallBool(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectSmallBool(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty object
   emptyO(self);
   toInject = allocSmallBool(true);
   freeO(toInject);
   ck_assert_ptr_ne(self->f->injectSmallBool(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[false]");
   free(s);
   // empty list
   emptyO(self);
   toInject = allocSmallBool(true);
   ck_assert_ptr_ne(self->f->injectSmallBool(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   emptyO(self);
   toInject = allocSmallBool(true);
   ck_assert_ptr_ne(self->f->injectSmallBool(self, -1, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   // non smallBool object
   toInject = (smallBoolt*) allocSmallInt(2);
   r = self->f->injectSmallBool(self, 0, toInject);
   ck_assert_ptr_eq(r, null);
   terminateO(toInject);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectSmallBool(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectSmallBytesSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBytest *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallBytes(null, 0);
   r        = self->f->injectSmallBytes(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,[],2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallBytes(null, 0);
   r = self->f->injectSmallBytes(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[],2,3,4,[]]");
   free(s);
   // index 0
   toInject = allocSmallBytes(null, 0);
   r = self->f->injectSmallBytes(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]");
   free(s);
   // index outside
   toInject = allocSmallBytes(null, 0);
   ck_assert_ptr_eq(self->f->injectSmallBytes(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectSmallBytes(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty object
   emptyO(self);
   toInject = allocSmallBytes(null, 0);
   freeO(toInject);
   ck_assert_ptr_ne(self->f->injectSmallBytes(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   // empty list
   emptyO(self);
   toInject = allocSmallBytes(null, 0);
   ck_assert_ptr_ne(self->f->injectSmallBytes(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   emptyO(self);
   toInject = allocSmallBytes(null, 0);
   ck_assert_ptr_ne(self->f->injectSmallBytes(self, -1, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   // non smallBytes object
   toInject = (smallBytest*) allocSmallInt(2);
   r = self->f->injectSmallBytes(self, 0, toInject);
   ck_assert_ptr_eq(r, null);
   terminateO(toInject);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectSmallBytes(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectSmallDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDoublet *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallDouble(2);
   r        = self->f->injectSmallDouble(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallDouble(3);
   r = self->f->injectSmallDouble(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4,3.000000e+00]");
   free(s);
   // index 0
   toInject = allocSmallDouble(1);
   r = self->f->injectSmallDouble(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00,1,2.000000e+00,2,3,4,3.000000e+00]");
   free(s);
   // index outside
   toInject = allocSmallDouble(1);
   ck_assert_ptr_eq(self->f->injectSmallDouble(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectSmallDouble(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty object
   emptyO(self);
   toInject = allocSmallDouble(1);
   freeO(toInject);
   ck_assert_ptr_ne(self->f->injectSmallDouble(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[0.000000e+00]");
   free(s);
   // empty list
   emptyO(self);
   toInject = allocSmallDouble(1);
   ck_assert_ptr_ne(self->f->injectSmallDouble(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
   emptyO(self);
   toInject = allocSmallDouble(1);
   ck_assert_ptr_ne(self->f->injectSmallDouble(self, -1, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
   // non smallDouble object
   toInject = (smallDoublet*) allocSmallInt(2);
   r = self->f->injectSmallDouble(self, 0, toInject);
   ck_assert_ptr_eq(r, null);
   terminateO(toInject);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectSmallDouble(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectSmallIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallInt(10);
   r        = self->f->injectSmallInt(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,10,2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallInt(11);
   r = self->f->injectSmallInt(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,10,2,3,4,11]");
   free(s);
   // index 0
   toInject = allocSmallInt(12);
   r = self->f->injectSmallInt(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[12,1,10,2,3,4,11]");
   free(s);
   // index outside
   toInject = allocSmallInt(10);
   ck_assert_ptr_eq(self->f->injectSmallInt(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectSmallInt(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty object
   emptyO(self);
   toInject = allocSmallInt(10);
   freeO(toInject);
   ck_assert_ptr_ne(self->f->injectSmallInt(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[0]");
   free(s);
   // empty list
   emptyO(self);
   toInject = allocSmallInt(10);
   ck_assert_ptr_ne(self->f->injectSmallInt(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[10]");
   free(s);
   emptyO(self);
   toInject = allocSmallInt(10);
   ck_assert_ptr_ne(self->f->injectSmallInt(self, -1, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[10]");
   free(s);
   // non smallInt object
   toInject = (smallIntt*) allocSmallBool(true);
   r = self->f->injectSmallInt(self, 0, toInject);
   ck_assert_ptr_eq(r, null);
   terminateO(toInject);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectSmallInt(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallJson();
   r        = self->f->injectSmallJson(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,{},2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallJson();
   r = self->f->injectSmallJson(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,{},2,3,4,{}]");
   free(s);
   // index 0
   toInject = allocSmallJson();
   toInject->f->setS(toInject, "key", "value");
   r = self->f->injectSmallJson(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{\"key\":\"value\"},1,{},2,3,4,{}]");
   free(s);
   // index outside
   toInject = allocSmallJson();
   ck_assert_ptr_eq(self->f->injectSmallJson(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectSmallJson(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty object
   emptyO(self);
   toInject = allocSmallJson();
   freeO(toInject);
   ck_assert_ptr_ne(self->f->injectSmallJson(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   // empty list
   emptyO(self);
   toInject = allocSmallJson();
   ck_assert_ptr_ne(self->f->injectSmallJson(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   emptyO(self);
   toInject = allocSmallJson();
   ck_assert_ptr_ne(self->f->injectSmallJson(self, -1, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   // non smallJson object
   toInject = (smallJsont*) allocSmallInt(2);
   r = self->f->injectSmallJson(self, 0, toInject);
   ck_assert_ptr_eq(r, null);
   terminateO(toInject);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectSmallJson(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallString("1");
   r        = self->f->injectSmallString(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,\"1\",2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallString("2");
   r = self->f->injectSmallString(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"1\",2,3,4,\"2\"]");
   free(s);
   // index 0
   toInject = allocSmallString("3");
   r = self->f->injectSmallString(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"3\",1,\"1\",2,3,4,\"2\"]");
   free(s);
   // index outside
   toInject = allocSmallString("1");
   ck_assert_ptr_eq(self->f->injectSmallString(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectSmallString(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty object
   emptyO(self);
   toInject = allocSmallString("1");
   freeO(toInject);
   r = self->f->injectSmallString(self, 0, toInject);
   ck_assert_ptr_ne(r, NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\"]");
   free(s);
   // empty list
   emptyO(self);
   toInject = allocSmallString("1");
   r = self->f->injectSmallString(self, 0, toInject);
   ck_assert_ptr_ne(r, NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"1\"]");
   free(s);
   emptyO(self);
   toInject = allocSmallString("1");
   r = self->f->injectSmallString(self, -1, toInject);
   ck_assert_ptr_ne(r, NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"1\"]");
   free(s);
   // non smallString object
   toInject = (smallStringt*) allocSmallInt(2);
   r = self->f->injectSmallString(self, 0, toInject);
   ck_assert_ptr_eq(r, null);
   terminateO(toInject);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectSmallString(self, 0, NULL), NULL);
   terminateO(self);
   // json string
   self = allocSmallJson();
   setTopSO(self, "s");
   toInject = allocSmallString("heepy");
   r = self->f->injectSmallString(self, 1, toInject);
   ck_assert_ptr_ne(r, NULL);
   terminateO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "sheepy");
   free(s);
   terminateO(self);
 
 
 }
 
 
 void injectSmallContainerSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallContainert *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallContainer(NULL);
   r        = self->f->injectSmallContainer(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallContainer(NULL);
   r = self->f->injectSmallContainer(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4,\"<data container>\"]");
   free(s);
   // index 0
   toInject = allocSmallContainer(NULL);
   r = self->f->injectSmallContainer(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\",1,\"<data container>\",2,3,4,\"<data container>\"]");
   free(s);
   // index outside
   toInject = allocSmallContainer(NULL);
   ck_assert_ptr_eq(self->f->injectSmallContainer(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectSmallContainer(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty object
   emptyO(self);
   toInject = allocSmallContainer(NULL);
   freeO(toInject);
   ck_assert_ptr_ne(self->f->injectSmallContainer(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   // empty list
   emptyO(self);
   toInject = allocSmallContainer(NULL);
   ck_assert_ptr_ne(self->f->injectSmallContainer(self, 0, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   emptyO(self);
   toInject = allocSmallContainer(NULL);
   ck_assert_ptr_ne(self->f->injectSmallContainer(self, -1, toInject), NULL);
   finishO(toInject);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   // non smallContainer object
   toInject = (smallContainert*) allocSmallInt(2);
   r = self->f->injectSmallContainer(self, 0, toInject);
   ck_assert_ptr_eq(r, null);
   terminateO(toInject);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectSmallContainer(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = (baset*) allocSmallInt(8);
   r        = self->f->injectNFree(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,8,2,3,4]");
   free(s);
   // negative index
   toInject = (baset*) allocSmallInt(9);
   r = self->f->injectNFree(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,8,2,3,4,9]");
   free(s);
   // index 0
   toInject = (baset*) allocSmallInt(6);
   r = self->f->injectNFree(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[6,1,8,2,3,4,9]");
   free(s);
   // index outside
   toInject = (baset*) allocSmallInt(7);
   ck_assert_ptr_eq(self->f->injectNFree(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectNFree(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty list
   emptyO(self);
   toInject = (baset*) allocSmallInt(7);
   ck_assert_ptr_ne(self->f->injectNFree(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[7]");
   free(s);
   emptyO(self);
   toInject = (baset*) allocSmallInt(7);
   ck_assert_ptr_ne(self->f->injectNFree(self, -1, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[7]");
   free(s);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectNFree(self, 0, NULL), NULL);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   toInject = (baset*) allocSmallInt(7);
   ck_assert_ptr_eq(self->f->injectNFree(self, 0, toInject), NULL);
   terminateO(toInject);
   terminateO(self);
 
 }
 
 
 void injectNFreeUndefinedSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   undefinedt *value = NULL;
 
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   value = allocUndefined();
   r        = self->f->injectNFreeUndefined(self, 1, value);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,null,2,3,4]");
   free(s);
   // negative index
   value = allocUndefined();
   r = self->f->injectNFreeUndefined(self,-1, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,null,2,3,4,null]");
   free(s);
   // index 0
   value = allocUndefined();
   r = self->f->injectNFreeUndefined(self,0, value);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[null,1,null,2,3,4,null]");
   free(s);
   // index outside
   value = allocUndefined();
   ck_assert_ptr_eq(self->f->injectNFreeUndefined(self, 20, value), NULL);
   terminateO(value);
 
   value = allocUndefined();
   ck_assert_ptr_eq(self->f->injectNFreeUndefined(self, -9, value), NULL);
   terminateO(value);
 
   // empty list
   emptyO(self);
   value = allocUndefined();
   ck_assert_ptr_ne(self->f->injectNFreeUndefined(self, 0, value), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   emptyO(self);
   value = allocUndefined();
   ck_assert_ptr_ne(self->f->injectNFreeUndefined(self, -1, value), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectNFreeSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   r        = self->f->injectNFreeS(self, 1, strdup("5"));
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,\"5\",2,3,4]");
   free(s);
   // negative index
   r = self->f->injectNFreeS(self,-1, strdup("6"));
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"5\",2,3,4,\"6\"]");
   free(s);
   // index 0
   r = self->f->injectNFreeS(self,0, strdup("7"));
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"7\",1,\"5\",2,3,4,\"6\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->injectNFreeS(self, 20, ""), NULL);
   ck_assert_ptr_eq(self->f->injectNFreeS(self, -9, ""), NULL);
   // empty list
   emptyO(self);
   r = self->f->injectNFreeS(self, 0, strdup("7"));
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"7\"]");
   free(s);
   emptyO(self);
   r = self->f->injectNFreeS(self, -1, strdup("7"));
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"7\"]");
   free(s);
   // null
   ck_assert_ptr_eq(self->f->injectNFreeS(self, -1, null), NULL);
   terminateO(self);
 
 }
 
 
 void injectNFreeDictSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallDict();
   r        = self->f->injectNFreeDict(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,{},2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallDict();
   r = self->f->injectNFreeDict(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,{},2,3,4,{}]");
   free(s);
   // index 0
   toInject = allocSmallDict();
   r = self->f->injectNFreeDict(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{},1,{},2,3,4,{}]");
   free(s);
   // index outside
   toInject = allocSmallDict();
   ck_assert_ptr_eq(self->f->injectNFreeDict(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectNFreeDict(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty list
   emptyO(self);
   toInject = allocSmallDict();
   ck_assert_ptr_ne(self->f->injectNFreeDict(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   emptyO(self);
   toInject = allocSmallDict();
   ck_assert_ptr_ne(self->f->injectNFreeDict(self, -1, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectNFreeDict(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectNFreeArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallArray();
   r        = self->f->injectNFreeArray(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,[],2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallArray();
   r = self->f->injectNFreeArray(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[],2,3,4,[]]");
   free(s);
   // index 0
   toInject = allocSmallArray();
   r = self->f->injectNFreeArray(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]");
   free(s);
   // index outside
   toInject = allocSmallArray();
   ck_assert_ptr_eq(self->f->injectNFreeArray(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectNFreeArray(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty list
   emptyO(self);
   toInject = allocSmallArray();
   ck_assert_ptr_ne(self->f->injectNFreeArray(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   emptyO(self);
   toInject = allocSmallArray();
   ck_assert_ptr_ne(self->f->injectNFreeArray(self, -1, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectNFreeArray(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectNFreeArraycSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = listCreateS("a","b");
   r        = self->f->injectNFreeArrayc(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4]");
   free(s);
   // negative index
   toInject = listCreateS("c","d");
   r = self->f->injectNFreeArrayc(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]");
   free(s);
   // index 0
   toInject = listCreateS("e","ff");
   r = self->f->injectNFreeArrayc(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[\"e\",\"ff\"],1,[\"a\",\"b\"],2,3,4,[\"c\",\"d\"]]");
   free(s);
   // index outside
   toInject = listCreateS("a","b");
   ck_assert_ptr_eq(self->f->injectNFreeArrayc(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectNFreeArrayc(self, -9, toInject), NULL);
   listFreeS(toInject);
   // empty list
   emptyO(self);
   toInject = listCreateS("a","b");
   ck_assert_ptr_ne(self->f->injectNFreeArrayc(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"b\"]]");
   free(s);
   emptyO(self);
   toInject = listCreateS("a","b");
   ck_assert_ptr_ne(self->f->injectNFreeArrayc(self, -1, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"b\"]]");
   free(s);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectNFreeArrayc(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallBoolSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallBool(true);
   r        = self->f->injectNFreeSmallBool(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,true,2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallBool(true);
   r = self->f->injectNFreeSmallBool(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,true,2,3,4,true]");
   free(s);
   // index 0
   toInject = allocSmallBool(true);
   r = self->f->injectNFreeSmallBool(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[true,1,true,2,3,4,true]");
   free(s);
   // index outside
   toInject = allocSmallBool(true);
   ck_assert_ptr_eq(self->f->injectNFreeSmallBool(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectNFreeSmallBool(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty object
   emptyO(self);
   toInject = allocSmallBool(true);
   freeO(toInject);
   ck_assert_ptr_ne(self->f->injectNFreeSmallBool(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[false]");
   free(s);
   // empty list
   emptyO(self);
   toInject = allocSmallBool(true);
   ck_assert_ptr_ne(self->f->injectNFreeSmallBool(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   emptyO(self);
   toInject = allocSmallBool(true);
   ck_assert_ptr_ne(self->f->injectNFreeSmallBool(self, -1, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectNFreeSmallBool(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallBytesSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBytest *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallBytes(null, 0);
   r        = self->f->injectNFreeSmallBytes(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,[],2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallBytes(null, 0);
   r = self->f->injectNFreeSmallBytes(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,[],2,3,4,[]]");
   free(s);
   // index 0
   toInject = allocSmallBytes(null, 0);
   r = self->f->injectNFreeSmallBytes(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[],1,[],2,3,4,[]]");
   free(s);
   // index outside
   toInject = allocSmallBytes(null, 0);
   ck_assert_ptr_eq(self->f->injectNFreeSmallBytes(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectNFreeSmallBytes(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty object
   emptyO(self);
   toInject = allocSmallBytes(null, 0);
   freeO(toInject);
   ck_assert_ptr_ne(self->f->injectNFreeSmallBytes(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   // empty list
   emptyO(self);
   toInject = allocSmallBytes(null, 0);
   ck_assert_ptr_ne(self->f->injectNFreeSmallBytes(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   emptyO(self);
   toInject = allocSmallBytes(null, 0);
   ck_assert_ptr_ne(self->f->injectNFreeSmallBytes(self, -1, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectNFreeSmallBytes(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallDoubleSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDoublet *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallDouble(2);
   r        = self->f->injectNFreeSmallDouble(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallDouble(3);
   r = self->f->injectNFreeSmallDouble(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,2.000000e+00,2,3,4,3.000000e+00]");
   free(s);
   // index 0
   toInject = allocSmallDouble(1);
   r = self->f->injectNFreeSmallDouble(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00,1,2.000000e+00,2,3,4,3.000000e+00]");
   free(s);
   // index outside
   toInject = allocSmallDouble(1);
   ck_assert_ptr_eq(self->f->injectNFreeSmallDouble(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectNFreeSmallDouble(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty object
   emptyO(self);
   toInject = allocSmallDouble(1);
   freeO(toInject);
   ck_assert_ptr_ne(self->f->injectNFreeSmallDouble(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[0.000000e+00]");
   free(s);
   // empty list
   emptyO(self);
   toInject = allocSmallDouble(1);
   ck_assert_ptr_ne(self->f->injectNFreeSmallDouble(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
   emptyO(self);
   toInject = allocSmallDouble(1);
   ck_assert_ptr_ne(self->f->injectNFreeSmallDouble(self, -1, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectNFreeSmallDouble(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallIntSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallInt(10);
   r        = self->f->injectNFreeSmallInt(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,10,2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallInt(11);
   r = self->f->injectNFreeSmallInt(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,10,2,3,4,11]");
   free(s);
   // index 0
   toInject = allocSmallInt(12);
   r = self->f->injectNFreeSmallInt(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[12,1,10,2,3,4,11]");
   free(s);
   // index outside
   toInject = allocSmallInt(10);
   ck_assert_ptr_eq(self->f->injectNFreeSmallInt(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectNFreeSmallInt(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty object
   emptyO(self);
   toInject = allocSmallInt(10);
   freeO(toInject);
   ck_assert_ptr_ne(self->f->injectNFreeSmallInt(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[0]");
   free(s);
   // empty list
   emptyO(self);
   toInject = allocSmallInt(10);
   ck_assert_ptr_ne(self->f->injectNFreeSmallInt(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[10]");
   free(s);
   emptyO(self);
   toInject = allocSmallInt(10);
   ck_assert_ptr_ne(self->f->injectNFreeSmallInt(self, -1, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[10]");
   free(s);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectNFreeSmallInt(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallJson();
   r        = self->f->injectNFreeSmallJson(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,{},2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallJson();
   r = self->f->injectNFreeSmallJson(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,{},2,3,4,{}]");
   free(s);
   // index 0
   toInject = allocSmallJson();
   toInject->f->setS(toInject, "key", "value");
   r = self->f->injectNFreeSmallJson(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{\"key\":\"value\"},1,{},2,3,4,{}]");
   free(s);
   // index outside
   toInject = allocSmallJson();
   ck_assert_ptr_eq(self->f->injectNFreeSmallJson(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectNFreeSmallJson(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty object
   emptyO(self);
   toInject = allocSmallJson();
   freeO(toInject);
   ck_assert_ptr_ne(self->f->injectNFreeSmallJson(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   // empty list
   emptyO(self);
   toInject = allocSmallJson();
   ck_assert_ptr_ne(self->f->injectNFreeSmallJson(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   emptyO(self);
   toInject = allocSmallJson();
   ck_assert_ptr_ne(self->f->injectNFreeSmallJson(self, -1, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectNFreeSmallJson(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallString("1");
   r        = self->f->injectNFreeSmallString(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,\"1\",2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallString("2");
   r = self->f->injectNFreeSmallString(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"1\",2,3,4,\"2\"]");
   free(s);
   // index 0
   toInject = allocSmallString("3");
   r = self->f->injectNFreeSmallString(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"3\",1,\"1\",2,3,4,\"2\"]");
   free(s);
   // index outside
   toInject = allocSmallString("1");
   ck_assert_ptr_eq(self->f->injectNFreeSmallString(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectNFreeSmallString(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty object
   emptyO(self);
   toInject = allocSmallString("1");
   freeO(toInject);
   ck_assert_ptr_ne(self->f->injectNFreeSmallString(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\"]");
   free(s);
   // empty list
   emptyO(self);
   toInject = allocSmallString("1");
   ck_assert_ptr_ne(self->f->injectNFreeSmallString(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"1\"]");
   free(s);
   emptyO(self);
   toInject = allocSmallString("1");
   ck_assert_ptr_ne(self->f->injectNFreeSmallString(self, -1, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"1\"]");
   free(s);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectNFreeSmallString(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallContainerSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallContainert *toInject;
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   // positive index
   toInject = allocSmallContainer(NULL);
   r        = self->f->injectNFreeSmallContainer(self, 1, toInject);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4]");
   free(s);
   // negative index
   toInject = allocSmallContainer(NULL);
   r = self->f->injectNFreeSmallContainer(self,-1, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"<data container>\",2,3,4,\"<data container>\"]");
   free(s);
   // index 0
   toInject = allocSmallContainer(NULL);
   r = self->f->injectNFreeSmallContainer(self,0, toInject);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\",1,\"<data container>\",2,3,4,\"<data container>\"]");
   free(s);
   // index outside
   toInject = allocSmallContainer(NULL);
   ck_assert_ptr_eq(self->f->injectNFreeSmallContainer(self, 20, toInject), NULL);
   ck_assert_ptr_eq(self->f->injectNFreeSmallContainer(self, -9, toInject), NULL);
   terminateO(toInject);
   // empty object
   emptyO(self);
   toInject = allocSmallContainer(NULL);
   freeO(toInject);
   ck_assert_ptr_ne(self->f->injectNFreeSmallContainer(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   // empty list
   emptyO(self);
   toInject = allocSmallContainer(NULL);
   ck_assert_ptr_ne(self->f->injectNFreeSmallContainer(self, 0, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   emptyO(self);
   toInject = allocSmallContainer(NULL);
   ck_assert_ptr_ne(self->f->injectNFreeSmallContainer(self, -1, toInject), NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   // null toInsert
   ck_assert_ptr_eq(self->f->injectNFreeSmallContainer(self, 0, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void uniqSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // empty array
   r       = self->f->uniq(self);
   ck_assert_ptr_eq(r, NULL);
   setTypeArrayO(self);
   r       = self->f->uniq(self);
   ck_assert_ptr_eq(r, NULL);
   // one element
   self->f->pushUndefined(self);
   r       = self->f->uniq(self);
   ck_assert_ptr_eq(r, self);
   // uniq elements
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   self->f->pushNFreeDict(self, allocSmallDict());
   self->f->pushDouble(self, 1);
   self->f->pushInt(self, 2);
   self->f->pushS(self, "");
   self->f->pushNFreeArray(self, allocSmallArray());
   self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4));
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   self->f->pushNFreeDict(self, allocSmallDict());
   self->f->pushDouble(self, 1);
   self->f->pushInt(self, 2);
   self->f->pushS(self, "");
   self->f->pushNFreeArray(self, allocSmallArray());
   self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4));
   r       = self->f->uniq(self);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"\",[],[0x71,0x77,0x65,0x00]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void sortSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // sort undefined
   self->f->pushInt(self, 0);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   r = sortO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null,null,null,null,0]");
   free(s);
   // sort bool
   emptyO(self);
   self->f->pushBool(self, false);
   self->f->pushBool(self, true);
   r = sortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[false,true]");
   free(s);
   // sort container
   emptyO(self);
   pushVoidSmallJsonG(self, &r);
   pushVoidSmallJsonG(self, &r);
   r = sortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\",\"<data container>\"]");
   free(s);
   // sort dict
   emptyO(self);
   smallDictt *d[4];
   arange(i,d) d[i] = allocSmallDict();
   d[0]->f->setInt(d[0], "a", 1);
   d[1]->f->setInt(d[1], "a", 0);
   d[3]->f->setInt(d[3], "a", 0);
   d[3]->f->setInt(d[3], "b", 0);
   arange(i,d) self->f->pushNFreeDict(self, d[i]);
   r = sortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{},{\"a\":0},{\"a\":1},{\"a\":0,\"b\":0}]");
   free(s);
   // sort double
   emptyO(self);
   self->f->pushDouble(self, 0);
   self->f->pushDouble(self, 0);
   self->f->pushDouble(self, 1);
   self->f->pushDouble(self, -1);
   r = sortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[-1.000000e+00,0.000000e+00,0.000000e+00,1.000000e+00]");
   free(s);
   // sort Int
   emptyO(self);
   self->f->pushInt(self, 0);
   self->f->pushInt(self, 0);
   self->f->pushInt(self, 1);
   self->f->pushInt(self, -1);
   r = sortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[-1,0,0,1]");
   free(s);
   // sort strings
   emptyO(self);
   self->f->pushS(self, "bb");
   self->f->pushS(self, "a");
   r = sortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"a\",\"bb\"]");
   free(s);
   // sort Array
   emptyO(self);
   smallArrayt *a[4];
   arange(i,a) a[i] = allocSmallArray();
   a[0]->f->pushInt(a[0], 1);
   a[1]->f->pushInt(a[1], 0);
   a[3]->f->pushInt(a[3], 0);
   a[3]->f->pushInt(a[3], 0);
   arange(i,a) self->f->pushNFreeArray(self, a[i]);
   r = sortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[],[0],[1],[0,0]]");
   free(s);
   // sort bytes
   emptyO(self);
   smallBytest *B[4];
   range(i,3) B[i] = allocSmallBytes("12345678", i);
   B[3] = allocSmallBytes("0", 1);
   arange(i,B) self->f->pushNFreeSmallBytes(self, B[i]);
   r = sortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[],[0x30],[0x31],[0x31,0x32]]");
   free(s);
   // TODO add element and remove some elements
   emptyO(self);
   self->f->pushInt(self, 0);
   self->f->pushInt(self, 0);
   self->f->pushInt(self, 1);
   self->f->pushInt(self, -1);
   smallIntt *i1 = self->f->getAtSmallInt(self, 1);
   smallIntt *i2 = self->f->getAtSmallInt(self, 2);
   removeO(self, 1, 3);
   terminateO(i1);
   terminateO(i2);
   r = sortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[-1,0]");
   free(s);
   // length 0
   emptyO(self);
   r = sortO(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(sortO(self), NULL);
   terminateO(self);
 
 }
 
 
 void icSortSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // sort undefined
   self->f->pushInt(self, 0);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   r = icSortO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null,null,null,null,0]");
   free(s);
   // sort bool
   emptyO(self);
   self->f->pushBool(self, false);
   self->f->pushBool(self, true);
   r = icSortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[false,true]");
   free(s);
   // sort container
   emptyO(self);
   pushVoidSmallJsonG(self, &r);
   pushVoidSmallJsonG(self, &r);
   r = icSortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\",\"<data container>\"]");
   free(s);
   // sort dict
   emptyO(self);
   smallDictt *d[4];
   arange(i,d) d[i] = allocSmallDict();
   d[0]->f->setInt(d[0], "a", 1);
   d[1]->f->setInt(d[1], "A", 0);
   d[3]->f->setInt(d[3], "a", 0);
   d[3]->f->setInt(d[3], "b", 0);
   arange(i,d) self->f->pushNFreeDict(self, d[i]);
   r = icSortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[{},{\"A\":0},{\"a\":1},{\"a\":0,\"b\":0}]");
   free(s);
   // sort double
   emptyO(self);
   self->f->pushDouble(self, 0);
   self->f->pushDouble(self, 0);
   self->f->pushDouble(self, 1);
   self->f->pushDouble(self, -1);
   r = icSortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[-1.000000e+00,0.000000e+00,0.000000e+00,1.000000e+00]");
   free(s);
   // sort Int
   emptyO(self);
   self->f->pushInt(self, 0);
   self->f->pushInt(self, 0);
   self->f->pushInt(self, 1);
   self->f->pushInt(self, -1);
   r = icSortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[-1,0,0,1]");
   free(s);
   // sort strings
   emptyO(self);
   self->f->pushS(self, "bb");
   self->f->pushS(self, "B");
   r = icSortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"B\",\"bb\"]");
   free(s);
   // sort Array
   emptyO(self);
   smallArrayt *a[4];
   arange(i,a) a[i] = allocSmallArray();
   a[0]->f->pushInt(a[0], 1);
   a[1]->f->pushInt(a[1], 0);
   a[3]->f->pushInt(a[3], 0);
   a[3]->f->pushInt(a[3], 0);
   arange(i,a) self->f->pushNFreeArray(self, a[i]);
   r = icSortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[],[0],[1],[0,0]]");
   free(s);
   // sort bytes
   emptyO(self);
   smallBytest *B[4];
   range(i,3) B[i] = allocSmallBytes("12345678", i);
   B[3] = allocSmallBytes("0", 1);
   arange(i,B) self->f->pushNFreeSmallBytes(self, B[i]);
   r = icSortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[[],[0x30],[0x31],[0x31,0x32]]");
   free(s);
   // TODO add element and remove some elements
   emptyO(self);
   self->f->pushInt(self, 0);
   self->f->pushInt(self, 0);
   self->f->pushInt(self, 1);
   self->f->pushInt(self, -1);
   smallIntt *i1 = self->f->getAtSmallInt(self, 1);
   smallIntt *i2 = self->f->getAtSmallInt(self, 2);
   removeO(self, 1, 3);
   terminateO(i1);
   terminateO(i2);
   r = icSortO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[-1,0]");
   free(s);
   // length 0
   emptyO(self);
   r = icSortO(self);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(icSortO(self), NULL);
   terminateO(self);
 
 }
 
 
 int sortFOCmp(const void *A, const void *B) {
   cast(smallDictt*, a, A);
   cast(smallDictt*, b, B);
 
   if (lenO(a) < lenO(b))
     return -1;
   else if (lenO(a) == lenO(b)) {
     var As = toStringO(a);
     var Bs = toStringO(b);
     int r = strcmp(As,Bs);
     freeManyS(As,Bs);
     return r;
   }
   else
     return 1;
 }
 
 void sortFSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // sort dict
   smallDictt *d[4];
   arange(i,d) d[i] = allocSmallDict();
   d[0]->f->setInt(d[0], "a", 1);
   d[1]->f->setInt(d[1], "a", 0);
   d[3]->f->setInt(d[3], "a", 0);
   d[3]->f->setInt(d[3], "b", 0);
   arange(i,d) self->f->pushNFreeDict(self, d[i]);
   r = sortFO(self, sortFOCmp);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{},{\"a\":0},{\"a\":1},{\"a\":0,\"b\":0}]");
   free(s);
   // no compare function
   r = sortFO(self, NULL);
   ck_assert_ptr_eq(r, null);
   // empty array
   emptyO(self);
   r = sortFO(self, sortFOCmp);
   ck_assert_ptr_eq(r, null);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert_ptr_eq(sortFO(self, sortFOCmp), NULL);
   terminateO(self);
 
 }
 
 
 void icUniqSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // empty array
   r       = self->f->icUniq(self);
   ck_assert_ptr_eq(r, NULL);
   setTypeArrayO(self);
   r       = self->f->icUniq(self);
   ck_assert_ptr_eq(r, NULL);
   // one element
   self->f->pushUndefined(self);
   r       = self->f->icUniq(self);
   ck_assert_ptr_eq(r, self);
   // uniq elements
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   self->f->pushNFreeDict(self, allocSmallDict());
   self->f->pushDouble(self, 1);
   self->f->pushInt(self, 2);
   self->f->pushS(self, "ASD");
   self->f->pushNFreeArray(self, allocSmallArray());
   self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4));
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   self->f->pushNFreeDict(self, allocSmallDict());
   self->f->pushDouble(self, 1);
   self->f->pushInt(self, 2);
   self->f->pushS(self, "asd");
   self->f->pushNFreeArray(self, allocSmallArray());
   self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4));
   r       = self->f->icUniq(self);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"ASD\",[],[0x71,0x77,0x65,0x00]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void uniqCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // uniquify
   freeO(self);
   setTopSO(self, "/qwd///");
   r = uniqCharO(self, '/');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "/qwd/");
   free(s);
   // short string
   freeO(self);
   setTopSO(self, "?");
   r = uniqCharO(self, '/');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "?");
   free(s);
   // NULL
   freeO(self);
   ck_assert_ptr_eq(uniqCharO(self, '/'), NULL);
   terminateO(self);
 
 }
 
 
 void icUniqCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // uniquify
   freeO(self);
   setTopSO(self, "/qQwd///");
   r = icUniqCharO(self, 'q');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "/qwd///");
   free(s);
   // short string
   freeO(self);
   setTopSO(self, "?");
   r = icUniqCharO(self, '/');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "?");
   free(s);
   // NULL
   freeO(self);
   ck_assert_ptr_eq(icUniqCharO(self, '/'), NULL);
   terminateO(self);
 
 }
 
 
 void hasSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*)allocSmallInt(1);
 
   // has
   self->f->pushInt(self, 1);
   r = hasO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = hasO(self, value);
   ck_assert(!r);
   // NULL value
   r = hasO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void hasUndefinedSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   undefinedt *value = allocUndefined();
 
   // has
   self->f->pushUndefined(self);
   r = hasUndefinedO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = hasUndefinedO(self, value);
   ck_assert(!r);
   // non undefined object
   terminateO(value);
   value = (undefinedt*) allocSmallInt(2);
   r = hasUndefinedO(self, value);
   ck_assert(!r);
   // NULL value
   r = hasUndefinedO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void hasBoolSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   bool value = true;
 
   // has
   self->f->pushBool(self, true);
   r = hasBoolO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = hasBoolO(self, value);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasDoubleSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   double value = 2;
 
   // has
   self->f->pushDouble(self, 2);
   r = hasDoubleO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = hasDoubleO(self, value);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasIntSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   int64_t value = 1000;
 
   // has
   self->f->pushInt(self, 1000);
   r = hasIntO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = hasIntO(self, value);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasSSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   const char *value = "asd";
 
   // has
   self->f->pushS(self, "asd");
   r = hasSO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = hasSO(self, value);
   ck_assert(!r);
   // NULL value
   r = hasSO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   // json dict
   self = allocSmallJson();
   self->f->setInt(self, "u", 0);
   ck_assert(!hasSO(self, "qwe"));
   ck_assert(hasSO(self, "u"));
   terminateO(self);
 
 }
 
 
 void hasCharSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   char value = 'a';
 
   // has
   self->f->pushS(self, "a");
   r = hasCharO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = hasCharO(self, value);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasDictSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   smallDictt *value = allocSmallDict();
 
   // has
   self->f->pushNFreeDict(self, allocSmallDict());
   r = hasDictO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = hasDictO(self, value);
   ck_assert(!r);
   // non smallDict object
   terminateO(value);
   value = (smallDictt*) allocSmallInt(2);
   r = hasDictO(self, value);
   ck_assert(!r);
   // NULL value
   r = hasDictO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void hasArraySmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   smallArrayt *value = allocSmallArray();
 
   // has
   self->f->pushNFreeArray(self, allocSmallArray());
   r = hasArrayO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = hasArrayO(self, value);
   ck_assert(!r);
   // non smallArray object
   terminateO(value);
   value = (smallArrayt*) allocSmallInt(2);
   r = hasArrayO(self, value);
   ck_assert(!r);
   // NULL value
   r = hasArrayO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void hasArraycSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   char **value = listCreateS("a","bb");
 
   // has
   self->f->pushNFreeArrayc(self, listCreateS("a","bb"));
   r = hasArraycO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = hasArraycO(self, value);
   ck_assert(!r);
   // NULL value
   r = hasArraycO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   listFreeS(value);
 
 }
 
 
 void hasSmallBoolSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   // has
   self->f->pushBool(self, true);
   r = hasSmallBoolO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = hasSmallBoolO(self, value);
   ck_assert(!r);
   // non smallBool object
   terminateO(value);
   value = (smallBoolt*) allocSmallInt(2);
   r = hasSmallBoolO(self, value);
   ck_assert(!r);
   // NULL value
   r = hasSmallBoolO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void hasSmallBytesSmallJsonT(void) {
 
   bool r;
   smallJsont *self  = allocSmallJson();
   createAllocateSmallBytes(value);
   pushBufferO(value, &self, 8);
 
   // has
   createAllocateSmallBytes(elem);
   pushBufferO(elem, &self, 8);
   self->f->pushNFreeSmallBytes(self, elem);
   r = hasSmallBytesO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = hasSmallBytesO(self, value);
   ck_assert(!r);
   // non smallBytes object
   terminateO(value);
   value = (smallBytest*) allocSmallInt(2);
   r = hasSmallBytesO(self, value);
   ck_assert(!r);
   // NULL value
   r = hasSmallBytesO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void hasSmallDoubleSmallJsonT(void) {
 
   bool r;
   smallJsont *self   = allocSmallJson();
   smallDoublet *value = allocSmallDouble(2);
 
   // has
   self->f->pushDouble(self, 2);
   r = hasSmallDoubleO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = hasSmallDoubleO(self, value);
   ck_assert(!r);
   // non smallDouble object
   terminateO(value);
   value = (smallDoublet*) allocSmallInt(2);
   r = hasSmallDoubleO(self, value);
   ck_assert(!r);
   // NULL value
   r = hasSmallDoubleO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void hasSmallIntSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocSmallInt(12);
 
   // has
   self->f->pushInt(self, 12);
   r = hasSmallIntO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = hasSmallIntO(self, value);
   ck_assert(!r);
   // non smallInt object
   terminateO(value);
   value = (smallIntt*) allocSmallBool(true);
   r = hasSmallIntO(self, value);
   ck_assert(!r);
   // NULL value
   r = hasSmallIntO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void hasSmallJsonSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocSmallJson();
   value->f->pushInt(value, 1);
 
   // has
   createAllocateSmallJson(elem);
   elem->f->pushInt(elem, 1);
   self->f->pushNFreeSmallJson(self, elem);
   r = self->f->hasSmallJson(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = self->f->hasSmallJson(self, value);
   ck_assert(!r);
   // non smallJson object
   terminateO(value);
   value = (smallJsont*) allocSmallInt(2);
   r = self->f->hasSmallJson(self, value);
   ck_assert(!r);
   // NULL value
   r = self->f->hasSmallJson(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void hasSmallStringSmallJsonT(void) {
 
   bool r;
   smallJsont *self   = allocSmallJson();
   smallStringt *value = allocSmallString("qwe");
 
   // has
   self->f->pushS(self, "qwe");
   r = self->f->hasSmallString(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = self->f->hasSmallString(self, value);
   ck_assert(!r);
   // non smallString object
   terminateO(value);
   value = (smallStringt*) allocSmallInt(2);
   r = self->f->hasSmallString(self, value);
   ck_assert(!r);
   // NULL value
   r = self->f->hasSmallString(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void hasSmallContainerSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallContainer(value);
 
   // has
   createAllocateSmallContainer(elem);
   self->f->pushNFreeSmallContainer(self, elem);
   r = hasSmallContainerO(self, value);
   ck_assert(!r);
   // not has
   emptyO(self);
   r = hasSmallContainerO(self, value);
   ck_assert(!r);
   // non smallContainer object
   terminateO(value);
   value = (smallContainert*) allocSmallInt(2);
   r = self->f->hasSmallContainer(self, value);
   ck_assert(!r);
   // NULL value
   r = hasSmallContainerO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void findSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // find string in the middle
   freeO(self);
   setTopSO(self, "sheepy");
   r =  findO(self, "ee");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   // find non existing string
   ck_assert_ptr_eq(findO(self, "$"), NULL);
   // find NULL
   ck_assert_ptr_eq(findO(self, NULL), NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert_ptr_eq(findO(self, "$"), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(findO(self, "$"), NULL);
   terminateO(self);
 
 }
 
 
 void findCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // find string in the middle
   freeO(self);
   setTopSO(self, "sheepy");
   r = findCharO(self, 'e');
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   // find non existing string
   ck_assert_ptr_eq(findCharO(self, '$'), NULL);
   // find 0
   r = findCharO(self, 0);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "");
   terminateO(r);
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert_ptr_eq(findCharO(self, '$'), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(findCharO(self, '$'), NULL);
   terminateO(self);
 
 }
 
 
 void findSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt *needle = allocSmallString("ee");
 
   // find string in the middle
   freeO(self);
   setTopSO(self, "sheepy");
   r = self->f->findSmallString(self, needle);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   // find non existing string
   setValO(needle, "$");
   ck_assert_ptr_eq(self->f->findSmallString(self, needle), NULL);
   // non smallString object
   terminateO(needle);
   needle = (smallStringt*) allocSmallInt(1);
   ck_assert_ptr_eq(self->f->findSmallString(self, needle), NULL);
   terminateO(needle);
   // find NULL
   ck_assert_ptr_eq(self->f->findSmallString(self, NULL), NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   needle = allocSmallString("$");
   ck_assert_ptr_eq(self->f->findSmallString(self, needle), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(self->f->findSmallString(self, needle), NULL);
   terminateO(needle);
   terminateO(self);
 
 }
 
 
 void findJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont *needle = allocSmallJson();
 
   // find string in the middle
   freeO(self);
   setTopSO(self, "sheepy");
   setTopSO(needle, "ee");
   r = self->f->findJson(self, needle);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   // find non existing string
   freeO(needle);
   setTopSO(needle, "$");
   ck_assert_ptr_eq(self->f->findJson(self, needle), NULL);
   // non json string
   freeO(needle);
   ck_assert_ptr_eq(self->f->findJson(self, needle), NULL);
   // non json object
   terminateO(needle);
   needle = (smallJsont*) allocSmallInt(1);
   ck_assert_ptr_eq(self->f->findJson(self, needle), NULL);
   terminateO(needle);
   // find NULL
   ck_assert_ptr_eq(self->f->findJson(self, NULL), NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   needle = allocSmallJson();
   setTopSO(needle, "$");
   ck_assert_ptr_eq(self->f->findJson(self, needle), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(self->f->findJson(self, needle), NULL);
   terminateO(needle);
   terminateO(self);
 
 }
 
 
 void indexOfSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*)allocSmallInt(1);
 
   // index
   self->f->pushInt(self, 2);
   self->f->pushInt(self, 0);
   delElemIndexO(self, 1);
   self->f->pushInt(self, 1);
   r = indexOfO(self, value);
   ck_assert_int_eq(r, 2);
   // not index
   smallIntt *v = (smallIntt*) value;
   setValO(v, 0);
   r = indexOfO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = indexOfO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void indexOfUndefinedSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   undefinedt *value = allocUndefined();
 
   // indexOf
   self->f->pushInt(self, 1);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushUndefined(self);
   r = indexOfUndefinedO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = indexOfUndefinedO(self, value);
   ck_assert_int_eq(r, -1);
   // non undefined object
   terminateO(value);
   value = (undefinedt*) allocSmallInt(2);
   r = indexOfUndefinedO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = indexOfUndefinedO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void indexOfBoolSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   bool value = true;
 
   // indexOf
   self->f->pushInt(self, 1);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushBool(self, true);
   r = indexOfBoolO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = indexOfBoolO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfDoubleSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   double value = 2;
 
   // indexOf
   self->f->pushInt(self, 1);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushDouble(self, 2);
   r = indexOfDoubleO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = indexOfDoubleO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfIntSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   int64_t value = 1000;
 
   // indexOf
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushInt(self, 1000);
   r = indexOfIntO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = indexOfIntO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfSSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   const char *value = "asd";
 
   // indexOf
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushS(self, "asd");
   r = indexOfSO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = indexOfSO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = indexOfSO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   // json string
   self = allocSmallJson();
   // indexOf string in the middle
   setTopSO(self, "sheepy");
   ck_assert_int_eq(indexOfSO(self, "ee"), 2);
   // indexOf non existing string
   ck_assert_int_eq(indexOfSO(self, "$"), -1);
   terminateO(self);
 
 }
 
 
 void indexOfCharSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   char value = 'a';
 
   // indexOf
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushS(self, "a");
   r = indexOfCharO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = indexOfCharO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfDictSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallDictt *value = allocSmallDict();
 
   // indexOf
   createAllocateSmallDict(elem);
   elem->f->setInt(elem, "a", 1);
   self->f->pushNFreeDict(self, elem);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushNFreeDict(self, allocSmallDict());
   r = indexOfDictO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = indexOfDictO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallDict object
   terminateO(value);
   value = (smallDictt*) allocSmallInt(2);
   r = indexOfDictO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = indexOfDictO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void indexOfArraySmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallArrayt *value = allocSmallArray();
 
   // indexOf
   createAllocateSmallArray(elem);
   elem->f->pushInt(elem, 1);
   self->f->pushNFreeArray(self, elem);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushNFreeArray(self, allocSmallArray());
   r = indexOfArrayO(self, value);
   ck_assert_int_eq(r, 2);
   // non smallArray object
   terminateO(value);
   value = (smallArrayt*) allocSmallInt(2);
   r = indexOfArrayO(self, value);
   ck_assert_int_eq(r, -1);
   // not indexOf
   emptyO(self);
   r = indexOfArrayO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = indexOfArrayO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void indexOfArraycSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   char **value = listCreateS("a","bb");
 
   // indexOf
   char **elem = listCreateS("!!","@@@");
   self->f->pushNFreeArrayc(self, elem);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushNFreeArrayc(self, listCreateS("a","bb"));
   r = indexOfArraycO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = indexOfArraycO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = indexOfArraycO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   listFreeS(value);
 
 }
 
 
 void indexOfSmallBoolSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   // indexOf
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushBool(self, true);
   r = indexOfSmallBoolO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = indexOfSmallBoolO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallBool object
   terminateO(value);
   value = (smallBoolt*) allocSmallInt(2);
   r = indexOfSmallBoolO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = indexOfSmallBoolO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void indexOfSmallBytesSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallBytes(value);
   pushBufferO(value, &self, 8);
 
   // indexOf
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   createAllocateSmallBytes(elem);
   pushBufferO(elem, &self, 8);
   self->f->pushNFreeSmallBytes(self, elem);
   r = indexOfSmallBytesO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = indexOfSmallBytesO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallBytes object
   terminateO(value);
   value = (smallBytest*) allocSmallInt(2);
   r = indexOfSmallBytesO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = indexOfSmallBytesO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void indexOfSmallDoubleSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallDoublet *value = allocSmallDouble(2);
 
   // indexOf
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushDouble(self, 2);
   r = indexOfSmallDoubleO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = indexOfSmallDoubleO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallDouble object
   terminateO(value);
   value = (smallDoublet*) allocSmallInt(2);
   r = indexOfSmallDoubleO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = indexOfSmallDoubleO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void indexOfSmallIntSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocSmallInt(12);
 
   // indexOf
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushInt(self, 12);
   r = indexOfSmallIntO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = indexOfSmallIntO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallInt object
   terminateO(value);
   value = (smallIntt*) allocSmallBool(true);
   r = indexOfSmallIntO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = indexOfSmallIntO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void indexOfSmallJsonSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   // indexOf json undefined
   createUndefined(u);
   setTopO(value, (baset*)&u);
   self->f->pushUndefined(self);
   r = self->f->indexOfSmallJson(self, value);
   ck_assert_int_eq(r, 0);
   freeO(value);
   // indexOf json bool
   smallBoolt *b = allocSmallBool(true);
   setTopNFreeSmallBoolO(value, b);
   self->f->pushBool(self, true);
   r = self->f->indexOfSmallJson(self, value);
   ck_assert_int_eq(r, 1);
   freeO(value);
   // indexOf json double
   smallDoublet *d = allocSmallDouble(1);
   setTopNFreeSmallDoubleO(value, d);
   self->f->pushDouble(self, 1);
   r = self->f->indexOfSmallJson(self, value);
   ck_assert_int_eq(r, 2);
   freeO(value);
   // indexOf json int
   smallIntt *i = allocSmallInt(1);
   setTopNFreeSmallIntO(value, i);
   self->f->pushInt(self, 1);
   r = self->f->indexOfSmallJson(self, value);
   ck_assert_int_eq(r, 3);
   freeO(value);
   // indexOf json string
   smallStringt *s = allocSmallString("asd");
   setTopNFreeSmallStringO(value, s);
   self->f->pushS(self, "asd");
   r = self->f->indexOfSmallJson(self, value);
   ck_assert_int_eq(r, 4);
   freeO(value);
   // indexOf json dict
   smallDictt *D = allocSmallDict();
   setTopNFreeDictO(value, D);
   self->f->pushNFreeDict(self, allocSmallDict());
   r = self->f->indexOfSmallJson(self, value);
   ck_assert_int_eq(r, 5);
   freeO(value);
   // indexOf json array
   value->f->pushInt(value, 1);
   delElemIndexO(self, 1);
   createAllocateSmallJson(elem);
   elem->f->pushInt(elem, 1);
   self->f->pushNFreeSmallJson(self, elem);
   r = self->f->indexOfSmallJson(self, value);
   ck_assert_int_eq(r, 6);
   // not indexOf
   delElemIndexO(self, 6);
   r = self->f->indexOfSmallJson(self, value);
   ck_assert_int_eq(r, -1);
   // empty json object
   freeO(value);
   r = self->f->indexOfSmallJson(self, value);
   ck_assert_int_eq(r, -1);
   // non smallJson object
   terminateO(value);
   value = (smallJsont*) allocSmallInt(2);
   r = self->f->indexOfSmallJson(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = self->f->indexOfSmallJson(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void indexOfSmallStringSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallStringt *value = allocSmallString("qwe");
 
   // indexOf
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushS(self, "qwe");
   r = self->f->indexOfSmallString(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = self->f->indexOfSmallString(self, value);
   ck_assert_int_eq(r, -1);
   // empty string
   freeO(value);
   r = self->f->indexOfSmallString(self, value);
   ck_assert_int_eq(r, -1);
   // non smallString object
   terminateO(value);
   value = (smallStringt*) allocSmallInt(2);
   r = self->f->indexOfSmallString(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = self->f->indexOfSmallString(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
   // json string
   self = allocSmallJson();
   smallStringt *needle = allocSmallString("ee");
   // indexOf string in the middle
   setTopSO(self, "sheepy");
   ck_assert_int_eq(self->f->indexOfSmallString(self, needle), 2);
   // indexOf non existing string
   setValO(needle, "$");
   ck_assert_int_eq(self->f->indexOfSmallString(self, needle), -1);
   // non smallString object
   terminateO(needle);
   needle = (smallStringt*) allocSmallInt(1);
   ck_assert_int_eq(self->f->indexOfSmallString(self, needle), -1);
   terminateO(needle);
   // indexOf NULL
   ck_assert_int_eq(self->f->indexOfSmallString(self, NULL), -1);
   // empty string
   freeO(self);
   setTopSO(self, "");
   needle = allocSmallString("$");
   ck_assert_int_eq(self->f->indexOfSmallString(self, needle), -1);
   terminateO(needle);
   terminateO(self);
 
 }
 
 
 void indexOfSmallContainerSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallContainer(value);
 
   // indexOf
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   createAllocateSmallContainer(elem);
   self->f->pushNFreeSmallContainer(self, elem);
   r = self->f->indexOfSmallContainer(self, value);
   ck_assert_int_eq(r, -1);
   // not indexOf
   delElemIndexO(self, 2);
   r = self->f->indexOfSmallContainer(self, value);
   ck_assert_int_eq(r, -1);
   // non smallContainer object
   terminateO(value);
   value = (smallContainert*) allocSmallInt(2);
   r = self->f->indexOfSmallContainer(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = self->f->indexOfSmallContainer(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void binarySearchSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*)allocSmallString("4");
 
   // index not trimmed (an element is NULL)
   self->f->pushS(self, "0");
   self->f->pushS(self, "1");
   self->f->pushS(self, "2");
   delElemIndexO(self, 2);
   self->f->pushS(self, "3");
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = binarySearchO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = binarySearchO(self, value);
   ck_assert_int_eq(r, 3);
   smallStringt *v = (smallStringt*) value;
   // index in the lower half of the array
   setValO(v, "1");
   r = binarySearchO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   setValO(v, "asd");
   r = binarySearchO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = binarySearchO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = binarySearchO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void binarySearchUndefinedSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   undefinedt *undefined = (undefinedt*) 1234;
 
   r = binarySearchUndefinedO(self, undefined);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchBoolSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   bool value = true;
 
   // index not trimmed (an element is NULL)
   self->f->pushUndefined(self);
   self->f->pushBool(self, false);
   self->f->pushUndefined(self);
   delElemIndexO(self, 2);
   self->f->pushBool(self, true);
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = binarySearchBoolO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = binarySearchBoolO(self, value);
   ck_assert_int_eq(r, 2);
   // index in the lower half of the array
   value = false;
   r = binarySearchBoolO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   delElemIndexO(self, 1);
   trimO(self);
   r = binarySearchBoolO(self, value);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = binarySearchBoolO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchDoubleSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   double value = 2;
 
   // index not trimmed (an element is NULL)
   self->f->pushUndefined(self);
   self->f->pushDouble(self, 1);
   self->f->pushUndefined(self);
   delElemIndexO(self, 2);
   self->f->pushDouble(self, 2);
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = binarySearchDoubleO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = binarySearchDoubleO(self, value);
   ck_assert_int_eq(r, 2);
   // index in the lower half of the array
   value = 1;
   r = binarySearchDoubleO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   delElemIndexO(self, 1);
   trimO(self);
   r = binarySearchDoubleO(self, value);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = binarySearchDoubleO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchIntSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   int64_t value = 2;
 
   // index not trimmed (an element is NULL)
   self->f->pushUndefined(self);
   self->f->pushInt(self, 1);
   self->f->pushUndefined(self);
   delElemIndexO(self, 2);
   self->f->pushInt(self, 2);
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = binarySearchIntO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = binarySearchIntO(self, value);
   ck_assert_int_eq(r, 2);
   // index in the lower half of the array
   value = 1;
   r = binarySearchIntO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   delElemIndexO(self, 1);
   trimO(self);
   r = binarySearchIntO(self, value);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = binarySearchIntO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchSSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   const char *value = "4";
 
   // index not trimmed (an element is NULL)
   self->f->pushS(self, "0");
   self->f->pushS(self, "1");
   self->f->pushS(self, "2");
   delElemIndexO(self, 2);
   self->f->pushS(self, "3");
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = binarySearchSO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = binarySearchSO(self, value);
   ck_assert_int_eq(r, 3);
   // index in the lower half of the array
   value = "1";
   r = binarySearchSO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   value = "asd";
   r = binarySearchSO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = binarySearchSO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = binarySearchSO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchCharSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   char value = '4';
 
   // index not trimmed (an element is NULL)
   self->f->pushS(self, "0");
   self->f->pushS(self, "1");
   self->f->pushS(self, "2");
   delElemIndexO(self, 2);
   self->f->pushS(self, "3");
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = binarySearchCharO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = binarySearchCharO(self, value);
   ck_assert_int_eq(r, 3);
   // index in the lower half of the array
   value = '1';
   r = binarySearchCharO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   value = 'a';
   r = binarySearchCharO(self, value);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = binarySearchCharO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchDictSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallDictt *value = allocSmallDict();
   value->f->setInt(value, "b", 2);
 
   // index not trimmed (an element is NULL)
   createAllocateSmallDict(elem);
   elem->f->setInt(elem, "a", 1);
   self->f->pushUndefined(self);
   self->f->pushDict(self, elem);
   resetO(elem);
   self->f->pushUndefined(self);
   delElemIndexO(self, 2);
   elem->f->setInt(elem, "b", 2);
   self->f->pushNFreeDict(self, elem);
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = binarySearchDictO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = binarySearchDictO(self, value);
   ck_assert_int_eq(r, 2);
   // index in the lower half of the array
   freeO(value);
   value->f->setInt(value, "a", 1);
   r = binarySearchDictO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   freeO(value);
   r = binarySearchDictO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallDict object
   terminateO(value);
   value = (smallDictt*) allocSmallInt(2);
   r = binarySearchDictO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = binarySearchDictO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = binarySearchDictO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void binarySearchArraySmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self  = allocSmallJson();
   smallArrayt *value = allocSmallArray();
   value->f->pushInt(value, 2);
 
   // index not trimmed (an element is NULL)
   createAllocateSmallArray(elem);
   elem->f->pushInt(elem, 1);
   self->f->pushUndefined(self);
   self->f->pushArray(self, elem);
   resetO(elem);
   self->f->pushUndefined(self);
   delElemIndexO(self, 2);
   elem->f->pushInt(elem, 2);
   self->f->pushNFreeArray(self, elem);
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = binarySearchArrayO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = binarySearchArrayO(self, value);
   ck_assert_int_eq(r, 2);
   // index in the lower half of the array
   freeO(value);
   value->f->pushInt(value, 1);
   r = binarySearchArrayO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   freeO(value);
   r = binarySearchArrayO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallArray object
   terminateO(value);
   value = (smallArrayt*) allocSmallInt(2);
   r = binarySearchArrayO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = binarySearchArrayO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = binarySearchArrayO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void binarySearchArraycSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   char **value      = listCreateS("b");
 
   // index not trimmed (an element is NULL)
   char **elem = listCreateS("a");
   self->f->pushUndefined(self);
   self->f->pushNFreeArrayc(self, elem);
   self->f->pushUndefined(self);
   delElemIndexO(self, 2);
   elem = listCreateS("b");
   self->f->pushNFreeArrayc(self, elem);
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = binarySearchArraycO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = binarySearchArraycO(self, value);
   ck_assert_int_eq(r, 2);
   // index in the lower half of the array
   free(value[0]);
   value[0] = strdup("a");
   r = binarySearchArraycO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   free(value[0]);
   value[0] = strdup("asd");
   r = binarySearchArraycO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = binarySearchArraycO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = binarySearchArraycO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   listFreeS(value);
 
 }
 
 
 void binarySearchSmallBoolSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   // index not trimmed (an element is NULL)
   self->f->pushUndefined(self);
   self->f->pushBool(self, false);
   self->f->pushUndefined(self);
   delElemIndexO(self, 2);
   self->f->pushBool(self, true);
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = binarySearchSmallBoolO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = binarySearchSmallBoolO(self, value);
   ck_assert_int_eq(r, 2);
   // index in the lower half of the array
   setValO(value, false);
   r = binarySearchSmallBoolO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   delElemIndexO(self, 1);
   trimO(self);
   r = binarySearchSmallBoolO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallBool object
   terminateO(value);
   value = (smallBoolt*) allocSmallInt(2);
   r = binarySearchSmallBoolO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = binarySearchArraycO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = binarySearchSmallBoolO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void binarySearchSmallBytesSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallBytes(value);
   pushBufferO(value, "bbc", 4);
 
   // index not trimmed (an element is NULL)
   createAllocateSmallBytes(elem);
   pushBufferO(elem, "abc", 4);
   self->f->pushUndefined(self);
   self->f->pushNFreeSmallBytes(self, elem);
   self->f->pushUndefined(self);
   delElemIndexO(self, 2);
   elem = allocSmallBytes("bbc", 4);
   self->f->pushNFreeSmallBytes(self, elem);
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = binarySearchSmallBytesO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = binarySearchSmallBytesO(self, value);
   ck_assert_int_eq(r, 2);
   // index in the lower half of the array
   freeO(value);
   pushBufferO(value, "abc", 4);
   r = binarySearchSmallBytesO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   freeO(value);
   pushBufferO(value, "###", 4);
   r = binarySearchSmallBytesO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallBytes object
   terminateO(value);
   value = (smallBytest*) allocSmallInt(2);
   r = binarySearchSmallBytesO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = binarySearchSmallBytesO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = binarySearchSmallBytesO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void binarySearchSmallDoubleSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self   = allocSmallJson();
   smallDoublet *value = allocSmallDouble(2);
 
   // index not trimmed (an element is NULL)
   self->f->pushUndefined(self);
   self->f->pushDouble(self, 1);
   self->f->pushUndefined(self);
   delElemIndexO(self, 2);
   self->f->pushDouble(self, 2);
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = binarySearchSmallDoubleO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = binarySearchSmallDoubleO(self, value);
   ck_assert_int_eq(r, 2);
   // index in the lower half of the array
   setValO(value, 1);
   r = binarySearchSmallDoubleO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   delElemIndexO(self, 1);
   trimO(self);
   r = binarySearchSmallDoubleO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallDouble object
   terminateO(value);
   value = (smallDoublet*) allocSmallInt(2);
   r = binarySearchSmallDoubleO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = binarySearchArraycO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = binarySearchSmallDoubleO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void binarySearchSmallIntSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocSmallInt(2);
 
   // index not trimmed (an element is NULL)
   self->f->pushUndefined(self);
   self->f->pushInt(self, 1);
   self->f->pushUndefined(self);
   delElemIndexO(self, 2);
   self->f->pushInt(self, 2);
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = binarySearchSmallIntO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = binarySearchSmallIntO(self, value);
   ck_assert_int_eq(r, 2);
   // index in the lower half of the array
   setValO(value, 1);
   r = binarySearchSmallIntO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   delElemIndexO(self, 1);
   trimO(self);
   r = binarySearchSmallIntO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallInt object
   terminateO(value);
   value = (smallIntt*) allocSmallBool(true);
   r = binarySearchSmallIntO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = binarySearchArraycO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = binarySearchSmallIntO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void binarySearchSmallJsonSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocSmallJson();
   value->f->pushInt(value, 2);
 
   // index not trimmed (an element is NULL)
   self->f->pushUndefined(self);
   createAllocateSmallArray(elem);
   elem->f->pushInt(elem, 1);
   self->f->pushArray(self, elem);
   resetO(elem);
   self->f->pushUndefined(self);
   delElemIndexO(self, 2);
   elem->f->pushInt(elem, 2);
   self->f->pushNFreeArray(self, elem);
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = self->f->binarySearchSmallJson(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = self->f->binarySearchSmallJson(self, value);
   ck_assert_int_eq(r, 2);
   // index in the lower half of the array
   freeO(value);
   value->f->pushInt(value, 1);
   r = self->f->binarySearchSmallJson(self, value);
   ck_assert_int_eq(r, 1);
   // not index (json array)
   delElemIndexO(self, 1);
   trimO(self);
   r = self->f->binarySearchSmallJson(self, value);
   ck_assert_int_eq(r, -1);
   // not index json undefined
   createUndefined(u);
   freeO(value);
   setTopO(value, (baset*)&u);
   r = self->f->binarySearchSmallJson(self, value);
   ck_assert_int_eq(r, -1);
   // not index json bool
   createSmallBool(b);
   freeO(value);
   setTopO(value, (baset*)&b);
   r = self->f->binarySearchSmallJson(self, value);
   ck_assert_int_eq(r, -1);
   // not index json double
   createSmallDouble(d);
   freeO(value);
   setTopO(value, (baset*)&d);
   r = self->f->binarySearchSmallJson(self, value);
   ck_assert_int_eq(r, -1);
   // not index json int
   createSmallInt(i);
   freeO(value);
   setTopO(value, (baset*)&i);
   r = self->f->binarySearchSmallJson(self, value);
   ck_assert_int_eq(r, -1);
   // not index json string
   createSmallString(s);
   freeO(value);
   setTopO(value, (baset*)&s);
   r = self->f->binarySearchSmallJson(self, value);
   ck_assert_int_eq(r, -1);
   // not index json dict
   createSmallDict(D);
   freeO(value);
   setTopO(value, (baset*)&D);
   r = self->f->binarySearchSmallJson(self, value);
   ck_assert_int_eq(r, -1);
   // empty json object
   freeO(value);
   r = self->f->binarySearchSmallJson(self, value);
   ck_assert_int_eq(r, -1);
   // non smallJson object
   terminateO(value);
   value = (smallJsont*) allocSmallInt(2);
   r = self->f->binarySearchSmallJson(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = self->f->binarySearchSmallJson(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = self->f->binarySearchSmallJson(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void binarySearchSmallStringSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self   = allocSmallJson();
   smallStringt *value = allocSmallString("4");
 
   // index not trimmed (an element is NULL)
   self->f->pushS(self, "0");
   self->f->pushS(self, "1");
   self->f->pushS(self, "2");
   delElemIndexO(self, 2);
   self->f->pushS(self, "3");
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = binarySearchSmallStringO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = binarySearchSmallStringO(self, value);
   ck_assert_int_eq(r, 3);
   // index in the lower half of the array
   setValO(value, "1");
   r = binarySearchSmallStringO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   setValO(value, "asd");
   r = binarySearchSmallStringO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallString object
   terminateO(value);
   value = (smallStringt*) allocSmallInt(2);
   r = binarySearchSmallStringO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = binarySearchSmallStringO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = binarySearchSmallStringO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void binarySearchSmallContainerSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallContainer(value);
 
   r = self->f->binarySearchSmallContainer(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void icHasSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*)allocSmallString("a");
 
   // has
   self->f->pushS(self, "A");
   r = icHasO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = icHasO(self, value);
   ck_assert(!r);
   // NULL value
   r = icHasO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void icHasSSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   const char *value = "ASD";
 
   // has
   self->f->pushS(self, "asd");
   r = icHasSO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = icHasSO(self, value);
   ck_assert(!r);
   // NULL value
   r = icHasSO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   // json dict
   self = allocSmallJson();
   self->f->setInt(self, "u", 0);
   ck_assert(!icHasSO(self, "U"));
   ck_assert(icHasSO(self, "u"));
   terminateO(self);
 
 }
 
 
 void icHasCharSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   char value = 'A';
 
   // has
   self->f->pushS(self, "a");
   r = icHasCharO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = icHasCharO(self, value);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void icHasDictSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   smallDictt *value = allocSmallDict();
   value->f->setInt(value, "A", 1);
 
   // has
   createAllocateSmallDict(d);
   d->f->setInt(d, "a", 1);
   self->f->pushNFreeDict(self, d);
   r = icHasDictO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = icHasDictO(self, value);
   ck_assert(!r);
   // NULL value
   r = icHasDictO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void icHasArraySmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   smallArrayt *value = allocSmallArray();
   value->f->pushS(value, "A");
 
   // has
   createAllocateSmallArray(a);
   a->f->pushS(a, "a");
   self->f->pushNFreeArray(self, a);
   r = icHasArrayO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = icHasArrayO(self, value);
   ck_assert(!r);
   // NULL value
   r = icHasArrayO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void icHasArraycSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   char **value = listCreateS("A","BB");
 
   // has
   self->f->pushNFreeArrayc(self, listCreateS("a","bb"));
   r = icHasArraycO(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = icHasArraycO(self, value);
   ck_assert(!r);
   // NULL value
   r = icHasArraycO(self, NULL);
   ck_assert(!r);
   terminateO(self);
   listFreeS(value);
 
 }
 
 
 void icHasSmallStringSmallJsonT(void) {
 
   bool r;
   smallJsont *self   = allocSmallJson();
   smallStringt *value = allocSmallString("QWE");
 
   // has
   self->f->pushS(self, "qwe");
   r = self->f->icHasSmallString(self, value);
   ck_assert(r);
   // not has
   emptyO(self);
   r = self->f->icHasSmallString(self, value);
   ck_assert(!r);
   // NULL value
   r = self->f->icHasSmallString(self, NULL);
   ck_assert(!r);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void icFindSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // icFind string in the middle
   freeO(self);
   setTopSO(self, "sheepy");
   r =  icFindO(self, "EE");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   // find non existing string
   ck_assert_ptr_eq(icFindO(self, "$"), NULL);
   // find NULL
   ck_assert_ptr_eq(icFindO(self, NULL), NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert_ptr_eq(icFindO(self, "$"), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icFindO(self, "$"), NULL);
   terminateO(self);
 
 }
 
 
 void icFindCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // find string in the middle
   freeO(self);
   setTopSO(self, "sheepy");
   r = icFindCharO(self, 'E');
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   // find non existing string
   ck_assert_ptr_eq(icFindCharO(self, '$'), NULL);
   // find 0
   r = icFindCharO(self, 0);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "");
   terminateO(r);
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert_ptr_eq(icFindCharO(self, '$'), NULL);
   ck_assert_ptr_eq(icFindCharO(self, 0), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icFindCharO(self, '$'), NULL);
   ck_assert_ptr_eq(icFindCharO(self, 0), NULL);
   terminateO(self);
 
 }
 
 
 void icFindSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt *needle = allocSmallString("EE");
 
   // find string in the middle
   freeO(self);
   setTopSO(self, "sheepy");
   r = self->f->icFindSmallString(self, needle);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   // find non existing string
   setValO(needle, "$");
   ck_assert_ptr_eq(self->f->icFindSmallString(self, needle), NULL);
   // non smallString object
   terminateO(needle);
   needle = (smallStringt*) allocSmallInt(1);
   ck_assert_ptr_eq(self->f->icFindSmallString(self, needle), NULL);
   terminateO(needle);
   // find NULL
   ck_assert_ptr_eq(self->f->icFindSmallString(self, NULL), NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   needle = allocSmallString("$");
   ck_assert_ptr_eq(self->f->icFindSmallString(self, needle), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(self->f->icFindSmallString(self, needle), NULL);
   terminateO(needle);
   terminateO(self);
 
 }
 
 
 void icFindJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont *needle = allocSmallJson();
 
   // find string in the middle
   freeO(self);
   setTopSO(self, "sheepy");
   setTopSO(needle, "EE");
   r = self->f->icFindJson(self, needle);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   // find non existing string
   freeO(needle);
   setTopSO(needle, "$");
   ck_assert_ptr_eq(self->f->icFindJson(self, needle), NULL);
   // non json string
   freeO(needle);
   ck_assert_ptr_eq(self->f->icFindJson(self, needle), NULL);
   // non json object
   terminateO(needle);
   needle = (smallJsont*) allocSmallInt(1);
   ck_assert_ptr_eq(self->f->icFindJson(self, needle), NULL);
   terminateO(needle);
   // find NULL
   ck_assert_ptr_eq(self->f->icFindJson(self, NULL), NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   needle = allocSmallJson();
   setTopSO(needle, "$");
   ck_assert_ptr_eq(self->f->icFindJson(self, needle), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(self->f->icFindJson(self, needle), NULL);
   terminateO(needle);
   terminateO(self);
 
 }
 
 
 void icIndexOfSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*)allocSmallString("A");
 
   // index
   self->f->pushS(self, "2");
   self->f->pushS(self, "3");
   delElemIndexO(self, 1);
   self->f->pushS(self, "a");
   r = icIndexOfO(self, value);
   ck_assert_int_eq(r, 2);
   // not index
   smallStringt *v = (smallStringt*) value;
   setValO(v, "3");
   r = icIndexOfO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = icIndexOfO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void icIndexOfSSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   const char *value = "ASD";
 
   // indexOf
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushS(self, "asd");
   r = icIndexOfSO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = icIndexOfSO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = icIndexOfSO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   // json string
   self = allocSmallJson();
   // indexOf string in the middle
   setTopSO(self, "sheepy");
   ck_assert_int_eq(icIndexOfSO(self, "EE"), 2);
   // indexOf non existing string
   ck_assert_int_eq(icIndexOfSO(self, "$"), -1);
   terminateO(self);
 
 }
 
 
 void icIndexOfCharSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   char value = 'A';
 
   // indexOf
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushS(self, "a");
   r = icIndexOfCharO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = icIndexOfCharO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icIndexOfDictSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallDictt *value = allocSmallDict();
   value->f->setInt(value, "B", 1);
 
   // indexOf
   createAllocateSmallDict(elem);
   elem->f->setInt(elem, "a", 1);
   self->f->pushDict(self, elem);
   resetO(elem);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   elem->f->setInt(elem, "b", 1);
   self->f->pushNFreeDict(self, elem);
   r = icIndexOfDictO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = icIndexOfDictO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallDict object
   terminateO(value);
   value = (smallDictt*) allocSmallInt(2);
   r = icIndexOfDictO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = icIndexOfDictO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void icIndexOfArraySmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallArrayt *value = allocSmallArray();
   value->f->pushS(value, "A");
 
   // indexOf
   createAllocateSmallArray(elem);
   elem->f->pushInt(elem, 1);
   self->f->pushArray(self, elem);
   resetO(elem);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   elem->f->pushS(elem, "a");
   self->f->pushNFreeArray(self, elem);
   r = icIndexOfArrayO(self, value);
   ck_assert_int_eq(r, 2);
   // value not found
   terminateO(value);
   value = allocSmallArray();
   r = icIndexOfArrayO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallArray object
   terminateO(value);
   value = (smallArrayt*) allocSmallInt(2);
   r = icIndexOfArrayO(self, value);
   ck_assert_int_eq(r, -1);
   // not indexOf
   emptyO(self);
   r = icIndexOfArrayO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = icIndexOfArrayO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void icIndexOfArraycSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   char **value = listCreateS("A","BB");
 
   // indexOf
   char **elem = listCreateS("!!","@@@");
   self->f->pushNFreeArrayc(self, elem);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushNFreeArrayc(self, listCreateS("a","bb"));
   r = icIndexOfArraycO(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = icIndexOfArraycO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = icIndexOfArraycO(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   listFreeS(value);
 
 }
 
 
 void icIndexOfSmallStringSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallStringt *value = allocSmallString("QWE");
 
   // indexOf
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushS(self, "qwe");
   r = self->f->icIndexOfSmallString(self, value);
   ck_assert_int_eq(r, 2);
   // not indexOf
   delElemIndexO(self, 2);
   r = self->f->icIndexOfSmallString(self, value);
   ck_assert_int_eq(r, -1);
   // empty string
   freeO(value);
   r = self->f->icIndexOfSmallString(self, value);
   ck_assert_int_eq(r, -1);
   // non smallString object
   terminateO(value);
   value = (smallStringt*) allocSmallInt(2);
   r = self->f->icIndexOfSmallString(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = self->f->icIndexOfSmallString(self, NULL);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
   // json string
   self = allocSmallJson();
   smallStringt *needle = allocSmallString("EE");
   // indexOf string in the middle
   setTopSO(self, "sheepy");
   ck_assert_int_eq(self->f->icIndexOfSmallString(self, needle), 2);
   // indexOf non existing string
   setValO(needle, "$");
   ck_assert_int_eq(self->f->icIndexOfSmallString(self, needle), -1);
   // non smallString object
   terminateO(needle);
   needle = (smallStringt*) allocSmallInt(1);
   ck_assert_int_eq(self->f->icIndexOfSmallString(self, needle), -1);
   terminateO(needle);
   // empty string
   freeO(self);
   setTopSO(self, "");
   needle = allocSmallString("$");
   ck_assert_int_eq(self->f->icIndexOfSmallString(self, needle), -1);
   terminateO(needle);
   terminateO(self);
 
 }
 
 
 void icBinarySearchSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*)allocSmallString("E");
 
   // index not trimmed (an element is NULL)
   self->f->pushS(self, "a");
   self->f->pushS(self, "b");
   self->f->pushS(self, "c");
   delElemIndexO(self, 2);
   self->f->pushS(self, "d");
   self->f->pushS(self, "e");
   self->f->pushS(self, "f");
   r = icBinarySearchO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = icBinarySearchO(self, value);
   ck_assert_int_eq(r, 3);
   smallStringt *v = (smallStringt*) value;
   // index in the lower half of the array
   setValO(v, "B");
   r = icBinarySearchO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   setValO(v, "asd");
   r = icBinarySearchO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = icBinarySearchO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = icBinarySearchO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void icBinarySearchSSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   const char *value = "E";
 
   // index not trimmed (an element is NULL)
   self->f->pushS(self, "a");
   self->f->pushS(self, "b");
   self->f->pushS(self, "c");
   delElemIndexO(self, 2);
   self->f->pushS(self, "d");
   self->f->pushS(self, "e");
   self->f->pushS(self, "f");
   r = icBinarySearchSO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = icBinarySearchSO(self, value);
   ck_assert_int_eq(r, 3);
   // index in the lower half of the array
   value = "B";
   r = icBinarySearchSO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   value = "asd";
   r = icBinarySearchSO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = icBinarySearchSO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = icBinarySearchSO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icBinarySearchCharSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   char value = 'E';
 
   // index not trimmed (an element is NULL)
   self->f->pushS(self, "a");
   self->f->pushS(self, "b");
   self->f->pushS(self, "c");
   delElemIndexO(self, 2);
   self->f->pushS(self, "d");
   self->f->pushS(self, "e");
   self->f->pushS(self, "f");
   r = icBinarySearchCharO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = icBinarySearchCharO(self, value);
   ck_assert_int_eq(r, 3);
   // index in the lower half of the array
   value = 'B';
   r = icBinarySearchCharO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   value = '1';
   r = icBinarySearchCharO(self, value);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = icBinarySearchCharO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icBinarySearchDictSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   smallDictt *value = allocSmallDict();
   value->f->setInt(value, "B", 2);
 
   // index not trimmed (an element is NULL)
   createAllocateSmallDict(elem);
   elem->f->setInt(elem, "a", 1);
   self->f->pushUndefined(self);
   self->f->pushDict(self, elem);
   resetO(elem);
   self->f->pushUndefined(self);
   delElemIndexO(self, 2);
   elem->f->setInt(elem, "b", 2);
   self->f->pushNFreeDict(self, elem);
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = icBinarySearchDictO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = icBinarySearchDictO(self, value);
   ck_assert_int_eq(r, 2);
   // index in the lower half of the array
   freeO(value);
   value->f->setInt(value, "A", 1);
   r = icBinarySearchDictO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   freeO(value);
   r = icBinarySearchDictO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallDict object
   terminateO(value);
   value = (smallDictt*) allocSmallInt(2);
   r = icBinarySearchDictO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = icBinarySearchDictO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = icBinarySearchDictO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void icBinarySearchArraySmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self  = allocSmallJson();
   smallArrayt *value = allocSmallArray();
   value->f->pushS(value, "B");
 
   // index not trimmed (an element is NULL)
   createAllocateSmallArray(elem);
   elem->f->pushS(elem, "a");
   self->f->pushUndefined(self);
   self->f->pushArray(self, elem);
   resetO(elem);
   self->f->pushUndefined(self);
   delElemIndexO(self, 2);
   elem->f->pushS(elem, "b");
   self->f->pushNFreeArray(self, elem);
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = icBinarySearchArrayO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = icBinarySearchArrayO(self, value);
   ck_assert_int_eq(r, 2);
   // index in the lower half of the array
   freeO(value);
   value->f->pushS(value, "A");
   r = icBinarySearchArrayO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   freeO(value);
   r = icBinarySearchArrayO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallArray object
   terminateO(value);
   value = (smallArrayt*) allocSmallInt(2);
   r = icBinarySearchArrayO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = icBinarySearchArrayO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = icBinarySearchArrayO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void icBinarySearchArraycSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
   char **value      = listCreateS("B");
 
   // index not trimmed (an element is NULL)
   char **elem = listCreateS("a");
   self->f->pushUndefined(self);
   self->f->pushNFreeArrayc(self, elem);
   self->f->pushUndefined(self);
   delElemIndexO(self, 2);
   elem = listCreateS("b");
   self->f->pushNFreeArrayc(self, elem);
   self->f->pushS(self, "4");
   self->f->pushS(self, "5");
   r = icBinarySearchArraycO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = icBinarySearchArraycO(self, value);
   ck_assert_int_eq(r, 2);
   // index in the lower half of the array
   free(value[0]);
   value[0] = strdup("A");
   r = icBinarySearchArraycO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   free(value[0]);
   value[0] = strdup("asd");
   r = icBinarySearchArraycO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = icBinarySearchArraycO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = icBinarySearchArraycO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   listFreeS(value);
 
 }
 
 
 void icBinarySearchSmallStringSmallJsonT(void) {
 
   ssize_t r;
   smallJsont *self   = allocSmallJson();
   smallStringt *value = allocSmallString("E");
 
   // index not trimmed (an element is NULL)
   self->f->pushS(self, "a");
   self->f->pushS(self, "b");
   self->f->pushS(self, "c");
   delElemIndexO(self, 2);
   self->f->pushS(self, "d");
   self->f->pushS(self, "e");
   self->f->pushS(self, "f");
   r = icBinarySearchSmallStringO(self, value);
   ck_assert_int_eq(r, -1);
   // index
   trimO(self);
   r = icBinarySearchSmallStringO(self, value);
   ck_assert_int_eq(r, 3);
   // index in the lower half of the array
   setValO(value, "B");
   r = icBinarySearchSmallStringO(self, value);
   ck_assert_int_eq(r, 1);
   // not index
   setValO(value, "asd");
   r = icBinarySearchSmallStringO(self, value);
   ck_assert_int_eq(r, -1);
   // empty value
   freeO(value);
   r = icBinarySearchSmallStringO(self, value);
   ck_assert_int_eq(r, -1);
   // non smallString object
   terminateO(value);
   value = (smallStringt*) allocSmallInt(2);
   r = icBinarySearchSmallStringO(self, value);
   ck_assert_int_eq(r, -1);
   // NULL value
   r = icBinarySearchSmallStringO(self, NULL);
   ck_assert_int_eq(r, -1);
   // empty array
   emptyO(self);
   r = icBinarySearchSmallStringO(self, value);
   ck_assert_int_eq(r, -1);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void keyBySmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   baset *value;
 
   smallJsont *r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   value = (baset*) allocSmallInt(1);
   r = keyByO(self, value);
   ck_assert_str_eq(r, "1");
   // non existing object
   smallIntt *i = allocSmallInt(2);
   r = keyByO(self, (baset*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = keyByO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyByO(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void keyByUndefinedSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   undefinedt *value;
 
   smallJsont *r2 = self->f->setUndefined(self, "1");
   ck_assert_ptr_ne(r2, null);
   value = allocUndefined();
   r = keyByUndefinedO(self, value);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = keyByUndefinedO(self, value);
   ck_assert_ptr_eq(r, null);
   // non undefined object
   smallIntt *i = allocSmallInt(2);
   r = keyByUndefinedO(self, (undefinedt*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = keyByUndefinedO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyByUndefinedO(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void keyByBoolSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = keyByBoolO(self, true);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = keyByBoolO(self, true);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyByBoolO(self, true);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keyByBoolO(self, true);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void keyByDoubleSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setDouble(self, "1", 2.2);
   ck_assert_ptr_ne(r2, null);
   r = keyByDoubleO(self, 2.2);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = keyByDoubleO(self, 2.2);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyByDoubleO(self, 2.2);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keyByDoubleO(self, 2.2);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void keyByIntSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = keyByIntO(self, 2);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = keyByIntO(self, 2);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyByIntO(self, 2);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keyByIntO(self, 0);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void keyBySSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setS(self, "1", "qwe");
   ck_assert_ptr_ne(r2, null);
   r = keyBySO(self, "qwe");
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = keyBySO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null value
   r = keyBySO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyBySO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keyBySO(self, "");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void keyByCharSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setS(self, "1", "q");
   ck_assert_ptr_ne(r2, null);
   r = keyByCharO(self, 'q');
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = keyByCharO(self, 'q');
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyByCharO(self, 'q');
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keyByCharO(self, 'a');
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void keyByDictSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict = allocSmallDict();
 
   createAllocateSmallDict(d);
   d->f->setS(d, "another", "dict");
   smallJsont *r2 = self->f->setNFreeDict(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeDict(self, "1", dict);
   ck_assert_ptr_ne(r2, null);
   dict = allocSmallDict();
   r = keyByDictO(self, dict);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = keyByDictO(self, dict);
   ck_assert_ptr_eq(r, null);
   // non smallDict object
   smallIntt *i = allocSmallInt(2);
   r = keyByDictO(self, (smallDictt*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = keyByDictO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyByDictO(self, dict);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keyByDictO(self, dict);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(dict);
 
 }
 
 
 void keyByArraySmallJsonT(void) {
 
   char* r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   createAllocateSmallArray(d);
   d->f->pushS(d, "another array");
   smallJsont *r2 = self->f->setNFreeArray(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeArray(self, "1", array);
   ck_assert_ptr_ne(r2, null);
   array = allocSmallArray();
   r = keyByArrayO(self, array);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = keyByArrayO(self, array);
   ck_assert_ptr_eq(r, null);
   // non smallArray object
   smallIntt *i = allocSmallInt(2);
   r = keyByArrayO(self, (smallArrayt*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = keyByArrayO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyByArrayO(self, array);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keyByArrayO(self, array);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(array);
 
 }
 
 
 void keyByArraycSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   char **array     = listCreateS("a","b");
 
   char **d = listCreateS("asd", "zxcv");
   smallJsont *r2 = self->f->setNFreeArrayc(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setArrayc(self, "1", array);
   ck_assert_ptr_ne(r2, null);
   r = keyByArraycO(self, array);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = keyByArraycO(self, array);
   ck_assert_ptr_eq(r, null);
   // null value
   r = keyByArraycO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyByArraycO(self, array);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keyByArraycO(self, array);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   listFreeS(array);
 
 }
 
 
 void keyBySmallBoolSmallJsonT(void) {
 
   char* r;
   smallJsont *self  = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   createAllocateSmallBool(d);
   setValO(d, false);
   smallJsont *r2 = self->f->setNFreeSmallBool(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeSmallBool(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   value = allocSmallBool(true);
   r = keyBySmallBoolO(self, value);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = keyBySmallBoolO(self, value);
   ck_assert_ptr_eq(r, null);
   // non smallBool object
   smallIntt *i = allocSmallInt(2);
   r = keyBySmallBoolO(self, (smallBoolt*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = keyBySmallBoolO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyBySmallBoolO(self, value);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keyBySmallBoolO(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void keyBySmallBytesSmallJsonT(void) {
 
   char* r;
   smallJsont *self   = allocSmallJson();
   smallBytest *value = allocSmallBytes("qwe", sizeof("qwe"));
 
   smallBytest *d = allocSmallBytes("asd", sizeof("asd"));
   smallJsont *r2 = self->f->setNFreeSmallBytes(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeSmallBytes(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   value = allocSmallBytes("qwe", sizeof("qwe"));
   r = keyBySmallBytesO(self, value);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = keyBySmallBytesO(self, value);
   ck_assert_ptr_eq(r, null);
   // empty value
   freeO(value);
   r = keyBySmallBytesO(self, value);
   ck_assert_ptr_eq(r, null);
   // non smallBytes object
   smallIntt *i = allocSmallInt(2);
   r = keyBySmallBytesO(self, (smallBytest*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = keyBySmallBytesO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyBySmallBytesO(self, value);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keyBySmallBytesO(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void keyBySmallDoubleSmallJsonT(void) {
 
   char* r;
   smallJsont *self    = allocSmallJson();
   smallDoublet *value = allocSmallDouble(2.2);
 
   createAllocateSmallDouble(d);
   smallJsont *r2 = self->f->setNFreeSmallDouble(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeSmallDouble(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   value = allocSmallDouble(2.2);
   r = keyBySmallDoubleO(self, value);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = keyBySmallDoubleO(self, value);
   ck_assert_ptr_eq(r, null);
   // non smallDouble object
   smallIntt *i = allocSmallInt(2);
   r = keyBySmallDoubleO(self, (smallDoublet*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = keyBySmallDoubleO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyBySmallDoubleO(self, value);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keyBySmallDoubleO(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void keyBySmallIntSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value = allocSmallInt(2);
 
   createAllocateSmallInt(d);
   smallJsont *r2 = self->f->setNFreeSmallInt(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeSmallInt(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   value = allocSmallInt(2);
   r = keyBySmallIntO(self, value);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = keyBySmallIntO(self, value);
   ck_assert_ptr_eq(r, null);
   // non smallInt object
   smallBoolt *i = allocSmallBool(false);
   r = keyBySmallIntO(self, (smallIntt*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = keyBySmallIntO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyBySmallIntO(self, value);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keyBySmallIntO(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void keyBySmallJsonSmallJsonT(void) {
 
   char* r;
   smallJsont *self  = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   // undefined
   createUndefined(u);
   setTopO(value, (baset*)&u);
   self->f->setUndefined(self, "1");
   r = self->f->keyBySmallJson(self, value);
   ck_assert_str_eq(r, "1");
   freeO(value);
   // bool
   setTopBoolO(value, true);
   self->f->setBool(self, "b", true);
   r = self->f->keyBySmallJson(self, value);
   ck_assert_str_eq(r, "b");
   freeO(value);
   // double
   setTopDoubleO(value, 2.2);
   self->f->setDouble(self, "db", 2.2);
   r = self->f->keyBySmallJson(self, value);
   ck_assert_str_eq(r, "db");
   freeO(value);
   // int
   setTopIntO(value, 2);
   self->f->setInt(self, "i", 2);
   r = self->f->keyBySmallJson(self, value);
   ck_assert_str_eq(r, "i");
   freeO(value);
   // string
   setTopSO(value, "qwe");
   self->f->setS(self, "s", "qwe");
   r = self->f->keyBySmallJson(self, value);
   ck_assert_str_eq(r, "s");
   freeO(value);
   // dict
   smallDictt *D = allocSmallDict();
   setTopNFreeDictO(value, D);
   self->f->setNFreeDict(self, "d", allocSmallDict());
   r = self->f->keyBySmallJson(self, value);
   ck_assert_str_eq(r, "d");
   freeO(value);
   // array
   smallArrayt *a = allocSmallArray();
   setTopNFreeArrayO(value, a);
   self->f->setNFreeArray(self, "a", allocSmallArray());
   r = self->f->keyBySmallJson(self, value);
   ck_assert_str_eq(r, "a");
   freeO(value);
   // empty value
   r = self->f->keyBySmallJson(self, value);
   ck_assert_ptr_eq(r, null);
   // non smallJson object
   smallIntt *i = allocSmallInt(2);
   r = self->f->keyBySmallJson(self, (smallJsont*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = self->f->keyBySmallJson(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = self->f->keyBySmallJson(self, value);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = self->f->keyBySmallJson(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void keyBySmallStringSmallJsonT(void) {
 
   char* r;
   smallJsont *self    = allocSmallJson();
   smallStringt *value = allocSmallString("qwe");
 
   createAllocateSmallString(d);
   smallJsont *r2 = self->f->setNFreeSmallString(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeSmallString(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   value = allocSmallString("qwe");
   r = keyBySmallStringO(self, value);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = keyBySmallStringO(self, value);
   ck_assert_ptr_eq(r, null);
   // empty value
   freeO(value);
   r = keyBySmallStringO(self, value);
   ck_assert_ptr_eq(r, null);
   // non smallString object
   smallIntt *i = allocSmallInt(2);
   r = keyBySmallStringO(self, (smallStringt*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = keyBySmallStringO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyBySmallStringO(self, value);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keyBySmallStringO(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void keyBySmallContainerSmallJsonT(void) {
 
   char* r;
   smallJsont *self       = allocSmallJson();
   smallContainert *value = allocSmallContainer(null);
 
   createAllocateSmallString(d);
   smallJsont *r2 = self->f->setNFreeSmallString(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r = keyBySmallContainerO(self, value);
   ck_assert_ptr_eq(r, null);
   // non smallContainer object
   smallIntt *i = allocSmallInt(2);
   r = keyBySmallContainerO(self, (smallContainert*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = keyBySmallContainerO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = keyBySmallContainerO(self, value);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keyBySmallContainerO(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void icKeyBySmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   baset *value;
 
   smallJsont *r2 = self->f->setS(self, "1", "QQ");
   ck_assert_ptr_ne(r2, null);
   value = (baset*) allocSmallString("qq");
   r = icKeyByO(self, value);
   ck_assert_str_eq(r, "1");
   // non existing object
   smallIntt *i = allocSmallInt(2);
   r = icKeyByO(self, (baset*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = icKeyByO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = icKeyByO(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void icKeyBySSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setS(self, "1", "qwe");
   ck_assert_ptr_ne(r2, null);
   r = icKeyBySO(self, "QWE");
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = icKeyBySO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   // null value
   r = icKeyBySO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = icKeyBySO(self, "qwe");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void icKeyByCharSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setS(self, "1", "q");
   ck_assert_ptr_ne(r2, null);
   r = icKeyByCharO(self, 'Q');
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = icKeyByCharO(self, 'q');
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = icKeyByCharO(self, 'q');
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void icKeyByDictSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict = allocSmallDict();
 
   createAllocateSmallDict(d);
   d->f->setS(d, "another", "dict");
   smallJsont *r2 = self->f->setNFreeDict(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   dict->f->setS(dict, "asd", "asd");
   r2 = self->f->setNFreeDict(self, "1", dict);
   ck_assert_ptr_ne(r2, null);
   dict = allocSmallDict();
   dict->f->setS(dict, "ASD", "asd");
   r = icKeyByDictO(self, dict);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = icKeyByDictO(self, dict);
   ck_assert_ptr_eq(r, null);
   // non smallDict object
   smallIntt *i = allocSmallInt(2);
   r = icKeyByDictO(self, (smallDictt*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = icKeyByDictO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = icKeyByDictO(self, dict);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(dict);
 
 }
 
 
 void icKeyByArraySmallJsonT(void) {
 
   char* r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   createAllocateSmallArray(d);
   d->f->pushS(d, "another array");
   smallJsont *r2 = self->f->setNFreeArray(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   array->f->pushS(array, "the array");
   r2 = self->f->setNFreeArray(self, "1", array);
   ck_assert_ptr_ne(r2, null);
   array = allocSmallArray();
   array->f->pushS(array, "The array");
   r = icKeyByArrayO(self, array);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = icKeyByArrayO(self, array);
   ck_assert_ptr_eq(r, null);
   // non smallArray object
   smallIntt *i = allocSmallInt(2);
   r = icKeyByArrayO(self, (smallArrayt*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = icKeyByArrayO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = icKeyByArrayO(self, array);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(array);
 
 }
 
 
 void icKeyByArraycSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   char **array     = listCreateS("a","b");
 
   char **d = listCreateS("asd", "zxcv");
   smallJsont *r2 = self->f->setNFreeArrayc(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setArrayc(self, "1", array);
   ck_assert_ptr_ne(r2, null);
   iUpperS(&array[0]);
   r = icKeyByArraycO(self, array);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = icKeyByArraycO(self, array);
   ck_assert_ptr_eq(r, null);
   // null value
   r = icKeyByArraycO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = icKeyByArraycO(self, array);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   listFreeS(array);
 
 }
 
 
 void icKeyBySmallStringSmallJsonT(void) {
 
   char* r;
   smallJsont *self    = allocSmallJson();
   smallStringt *value = allocSmallString("qwe");
 
   createAllocateSmallString(d);
   smallJsont *r2 = self->f->setNFreeSmallString(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeSmallString(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   value = allocSmallString("QWE");
   r = icKeyBySmallStringO(self, value);
   ck_assert_str_eq(r, "1");
   // non existing object
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r = icKeyBySmallStringO(self, value);
   ck_assert_ptr_eq(r, null);
   // empty value
   freeO(value);
   r = icKeyBySmallStringO(self, value);
   ck_assert_ptr_eq(r, null);
   // non smallString object
   smallIntt *i = allocSmallInt(2);
   r = icKeyBySmallStringO(self, (smallStringt*)i);
   terminateO(i);
   ck_assert_ptr_eq(r, null);
   // null value
   r = icKeyBySmallStringO(self, null);
   ck_assert_ptr_eq(r, null);
   // empty self
   freeO(self);
   r = icKeyBySmallStringO(self, value);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = icKeyBySmallStringO(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
   terminateO(value);
 
 }
 
 
 void replaceSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "#ee#ee#ad");
 
   // replace string, multiple character new delimeter
   r = replaceO(self, "#","^^", 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = replaceO(self, "##","|", 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = replaceO(self, "#","^^",1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = replaceO(self, "##","|",1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = replaceO(self, "##",NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = replaceO(self, "##",NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   ck_assert_ptr_eq(replaceO(self, "","|",1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(replaceO(self, NULL,"|",1), NULL);
   // empty old delimiter
   ck_assert_ptr_eq(replaceO(self, "","|",1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(replaceO(self, "##","|",1), NULL);
   terminateO(self);
 
 }
 
 
 void replaceCharSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // replace string, multiple character new delimeter
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = replaceCharSO(self, '#',"^^", 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = replaceCharSO(self, '#',"^^",1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = replaceCharSO(self, '#',"|",1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|#ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA#ee##ee#");
   r = replaceCharSO(self, '#',NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = replaceCharSO(self, '#',NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   ck_assert_ptr_eq(replaceCharSO(self, 0,"|",1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(replaceCharSO(self, '#',"|",1), NULL);
   terminateO(self);
 
 }
 
 
 void replaceSCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // replace string, multiple character new delimeter
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = replaceSCharO(self, "#",'^',0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = replaceSCharO(self, "##",'|',0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace string empty char, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = replaceSCharO(self, "##", 0,0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAeeee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = replaceSCharO(self, "#",'^',1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = replaceSCharO(self, "##",'|',1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = replaceSCharO(self, "##",0,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   ck_assert_ptr_eq(replaceSCharO(self, "",'|',1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(replaceSCharO(self, NULL,'|',1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(replaceSCharO(self, "##",'|',1), NULL);
   terminateO(self);
 
 }
 
 
 void replaceCharCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // replace string, multiple character new delimeter
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = replaceCharCharO(self, '#','^', 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = replaceCharCharO(self, '#','^',1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA#ee##ee#");
   r = replaceCharCharO(self, '#','|',1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = replaceCharCharO(self, '#','^',1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   ck_assert_ptr_eq(replaceCharCharO(self, 0,'|',1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(replaceCharCharO(self, '#','|',1), NULL);
   terminateO(self);
 
 }
 
 
 void replaceSmallStringSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "#ee#ee#ad");
   smallStringt *olds = allocSmallString("");
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   setValO(olds, "#");
   setValO(news, "^^");
   r = replaceSmallStringSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   setValO(news, "|");
   r = replaceSmallStringSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   setValO(olds, "#");
   setValO(news, "^^");
   r = replaceSmallStringSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   setValO(news, "|");
   r = replaceSmallStringSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   r = replaceSmallStringSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non smallString object
   terminateO(olds);
   olds = (smallStringt*) allocSmallInt(1);
   r = replaceSmallStringSmallStringO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   terminateO(news);
   olds = allocSmallString("");
   news = (smallStringt*) allocSmallInt(1);
   r = replaceSmallStringSmallStringO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallString("");
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(olds, "##");
   r = replaceSmallStringSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   setValO(olds, "");
   setValO(news, "|");
   ck_assert_ptr_eq(replaceSmallStringSmallStringO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(replaceSmallStringSmallStringO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(replaceSmallStringSmallStringO(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceSmallStringSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "#ee#ee#ad");
   smallStringt *olds = allocSmallString("");
   const char *news;
 
   // replace string, multiple character new delimeter
   setValO(olds, "#");
   news = "^^";
   r = replaceSmallStringSO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   news = "|";
   r = replaceSmallStringSO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   setValO(olds, "#");
   news = "^^";
   r = replaceSmallStringSO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   news = "|";
   r = replaceSmallStringSO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   r = replaceSmallStringSO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non smallString object
   terminateO(olds);
   olds = (smallStringt*) allocSmallInt(1);
   r = replaceSmallStringSO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   olds = allocSmallString("");
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(olds, "##");
   r = replaceSmallStringSO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   setValO(olds, "");
   news = "|";
   ck_assert_ptr_eq(replaceSmallStringSO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(replaceSmallStringSO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(replaceSmallStringSO(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void replaceSmallStringCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "#ee#ee#ad");
   smallStringt *olds = allocSmallString("");
   char news;
 
   // replace string, multiple character new delimeter
   setValO(olds, "#");
   news = '^';
   r = replaceSmallStringCharO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   news = '|';
   r = replaceSmallStringCharO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   setValO(olds, "#");
   news = '^';
   r = replaceSmallStringCharO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   news = '|';
   r = replaceSmallStringCharO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // non smallString object
   terminateO(olds);
   olds = (smallStringt*) allocSmallInt(1);
   r = replaceSmallStringCharO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   olds = allocSmallString("");
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(olds, "##");
   r = replaceSmallStringCharO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   setValO(olds, "");
   news = '|';
   ck_assert_ptr_eq(replaceSmallStringCharO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(replaceSmallStringCharO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(replaceSmallStringCharO(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void replaceSSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "#ee#ee#ad");
   const char *olds;
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   olds = "#";
   setValO(news, "^^");
   r = replaceSSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   olds = "##";
   setValO(news, "|");
   r = replaceSSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   olds = "#";
   setValO(news, "^^");
   r = replaceSSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   olds = "##";
   setValO(news, "|");
   r = replaceSSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   olds = "##";
   r = replaceSSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non smallString object
   terminateO(news);
   news = (smallStringt*) allocSmallInt(1);
   r = replaceSSmallStringO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallString("");
   // empty string
   freeO(self);
   setTopSO(self, "");
   olds = "##";
   r = replaceSSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   olds = "";
   setValO(news, "|");
   ck_assert_ptr_eq(replaceSSmallStringO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(replaceSSmallStringO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(replaceSSmallStringO(self, olds, news,1), NULL);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceCharSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "#ee#ee#ad");
   char olds;
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   olds = '#';
   setValO(news, "^^");
   r = replaceCharSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA#ee#ee");
   olds = '#';
   setValO(news, "|");
   r = replaceCharSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   olds = '#';
   setValO(news, "^^");
   r = replaceCharSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA#ee##ee#");
   olds = '#';
   setValO(news, "|");
   r = replaceCharSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA#ee##ee#");
   olds = '#';
   r = replaceCharSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non smallString object
   terminateO(news);
   news = (smallStringt*) allocSmallInt(1);
   r = replaceCharSmallStringO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallString("");
   // empty string
   freeO(self);
   setTopSO(self, "");
   olds = '#';
   r = replaceCharSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // NULL string
   freeO(self);
   setValO(news, "|");
   ck_assert_ptr_eq(replaceCharSmallStringO(self, olds, news,1), NULL);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceJsonJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "#ee#ee#ad");
   smallJsont *olds = allocSmallJson();
   smallJsont *news = allocSmallJson();
 
   // replace string, multiple character new delimeter
   freeO(olds);
   freeO(news);
   setTopSO(olds, "#");
   setTopSO(news, "^^");
   r = replaceJsonJsonO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   freeO(news);
   setTopSO(olds, "##");
   setTopSO(news, "|");
   r = replaceJsonJsonO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   freeO(olds);
   freeO(news);
   setTopSO(olds, "#");
   setTopSO(news, "^^");
   r = replaceJsonJsonO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   freeO(news);
   setTopSO(olds, "##");
   setTopSO(news, "|");
   r = replaceJsonJsonO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   r = replaceJsonJsonO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non json string
   freeO(olds);
   setTopIntO(olds, 1);
   r = replaceJsonJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   freeO(olds);
   freeO(news);
   setTopSO(olds, "e");
   setTopIntO(news, 1);
   r = replaceJsonJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   // non json object
   terminateO(olds);
   olds = (smallJsont*) allocSmallInt(1);
   r = replaceJsonJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   terminateO(news);
   olds = allocSmallJson();
   news = (smallJsont*) allocSmallInt(1);
   r = replaceJsonJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallJson();
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(olds);
   setTopSO(olds, "##");
   r = replaceJsonJsonO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   freeO(olds);
   freeO(news);
   setTopSO(olds, "");
   setTopSO(news, "|");
   ck_assert_ptr_eq(replaceJsonJsonO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(replaceJsonJsonO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(replaceJsonJsonO(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceJsonSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "#ee#ee#ad");
   smallJsont *olds   = allocSmallJson();
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   freeO(olds);
   setTopSO(olds, "#");
   setValO(news, "^^");
   r = replaceJsonSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   setValO(news, "|");
   r = replaceJsonSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   freeO(olds);
   setTopSO(olds, "#");
   setValO(news, "^^");
   r = replaceJsonSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   setValO(news, "|");
   r = replaceJsonSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   r = replaceJsonSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non json string
   freeO(olds);
   setTopIntO(olds, 1);
   r = replaceJsonSmallStringO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   // non json object
   terminateO(olds);
   olds = (smallJsont*) allocSmallInt(1);
   r = replaceJsonSmallStringO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   terminateO(news);
   olds = allocSmallJson();
   news = (smallStringt*) allocSmallInt(1);
   r = replaceJsonSmallStringO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallString("");
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(olds);
   setTopSO(olds, "##");
   r = replaceJsonSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   freeO(olds);
   setTopSO(olds, "");
   setValO(news, "|");
   ck_assert_ptr_eq(replaceJsonSmallStringO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(replaceJsonSmallStringO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(replaceJsonSmallStringO(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceJsonSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "#ee#ee#ad");
   smallJsont *olds   = allocSmallJson();
   const char *news;
 
   // replace string, multiple character new delimeter
   freeO(olds);
   setTopSO(olds, "#");
   news = "^^";
   r = replaceJsonSO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   news = "|";
   r = replaceJsonSO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   freeO(olds);
   setTopSO(olds, "#");
   news = "^^";
   r = replaceJsonSO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   news = "|";
   r = replaceJsonSO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   r = replaceJsonSO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non json string
   freeO(olds);
   setTopIntO(olds, 1);
   r = replaceJsonSO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   // non json object
   terminateO(olds);
   olds = (smallJsont*) allocSmallInt(1);
   r = replaceJsonSO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   // empty string
   olds = allocSmallJson();
   freeO(self);
   setTopSO(self, "");
   setTopSO(olds, "##");
   r = replaceJsonSO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   freeO(olds);
   setTopSO(olds, "");
   news = "|";
   ck_assert_ptr_eq(replaceJsonSO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(replaceJsonSO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(replaceJsonSO(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void replaceJsonCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "#ee#ee#ad");
   smallJsont *olds   = allocSmallJson();
   char news;
 
   // replace string, multiple character new delimeter
   freeO(olds);
   setTopSO(olds, "#");
   news = '^';
   r = replaceJsonCharO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   news = '|';
   r = replaceJsonCharO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   freeO(olds);
   setTopSO(olds, "#");
   news = '^';
   r = replaceJsonCharO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   news = '|';
   r = replaceJsonCharO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // non json string
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopIntO(olds, 1);
   r = replaceJsonCharO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   // non json object
   terminateO(olds);
   olds = (smallJsont*) allocSmallInt(1);
   r = replaceJsonCharO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   // empty string
   olds = allocSmallJson();
   freeO(self);
   setTopSO(self, "");
   setTopSO(olds, "##");
   r = replaceJsonCharO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   freeO(olds);
   setTopSO(olds, "");
   news = '|';
   ck_assert_ptr_eq(replaceJsonCharO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(replaceJsonCharO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(replaceJsonCharO(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void replaceSmallStringJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "#ee#ee#ad");
   smallStringt *olds = allocSmallString("");
   smallJsont *news   = allocSmallJson();
 
   // replace string, multiple character new delimeter
   freeO(news);
   setValO(olds, "#");
   setTopSO(news, "^^");
   r = self->f->replaceSmallStringJson(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(news);
   setValO(olds, "##");
   setTopSO(news, "|");
   r = self->f->replaceSmallStringJson(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   freeO(news);
   setValO(olds, "#");
   setTopSO(news, "^^");
   r = self->f->replaceSmallStringJson(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(news);
   setValO(olds, "##");
   setTopSO(news, "|");
   r = self->f->replaceSmallStringJson(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   r = self->f->replaceSmallStringJson(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non json string
   freeO(news);
   setTopIntO(news, 1);
   r = self->f->replaceSmallStringJson(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   // non json object
   terminateO(olds);
   olds = (smallStringt*) allocSmallInt(1);
   r = self->f->replaceSmallStringJson(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   terminateO(news);
   olds = allocSmallString("");
   news = (smallJsont*) allocSmallInt(1);
   r = self->f->replaceSmallStringJson(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallJson();
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(olds, "##");
   r = self->f->replaceSmallStringJson(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   freeO(news);
   setValO(olds, "");
   setTopSO(news, "|");
   ck_assert_ptr_eq(self->f->replaceSmallStringJson(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(self->f->replaceSmallStringJson(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(self->f->replaceSmallStringJson(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceSJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "#ee#ee#ad");
   const char *olds;
   smallJsont *news   = allocSmallJson();
 
   // replace string, multiple character new delimeter
   freeO(news);
   olds = "#";
   setTopSO(news, "^^");
   r = replaceSJsonO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(news);
   olds = "##";
   setTopSO(news, "|");
   r = replaceSJsonO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   freeO(news);
   olds = "#";
   setTopSO(news, "^^");
   r = replaceSJsonO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(news);
   olds = "##";
   setTopSO(news, "|");
   r = replaceSJsonO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   olds = "##";
   r = replaceSJsonO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non json string
   freeO(news);
   olds = "e";
   setTopIntO(news, 1);
   r = replaceSJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   // non json object
   terminateO(news);
   news = (smallJsont*) allocSmallInt(1);
   r = replaceSJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallJson();
   // empty string
   freeO(self);
   setTopSO(self, "");
   olds = "##";
   r = replaceSJsonO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   freeO(news);
   olds = "";
   setTopSO(news, "|");
   ck_assert_ptr_eq(replaceSJsonO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(replaceSJsonO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(replaceSJsonO(self, olds, news,1), NULL);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceCharJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "#ee#ee#ad");
   char olds;
   smallJsont *news   = allocSmallJson();
 
   // replace string, multiple character new delimeter
   freeO(news);
   olds = '#';
   setTopSO(news, "^^");
   r = replaceCharJsonO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA#ee#ee");
   freeO(news);
   olds = '#';
   setTopSO(news, "|");
   r = replaceCharJsonO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   freeO(news);
   olds = '#';
   setTopSO(news, "^^");
   r = replaceCharJsonO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA#ee##ee#");
   freeO(news);
   olds = '#';
   setTopSO(news, "|");
   r = replaceCharJsonO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA#ee##ee#");
   olds = '#';
   r = replaceCharJsonO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non json string
   freeO(news);
   olds = 'e';
   setTopIntO(news, 1);
   r = replaceCharJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   // non json object
   terminateO(news);
   news = (smallJsont*) allocSmallInt(1);
   r = replaceCharJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallJson();
   // empty string
   freeO(self);
   setTopSO(self, "");
   olds = '#';
   r = replaceCharJsonO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // NULL string
   freeO(self);
   freeO(news);
   setTopSO(news, "|");
   ck_assert_ptr_eq(replaceCharJsonO(self, olds, news,1), NULL);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceManySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // replace string, multiple character new delimeter
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = replaceManyO(self, "#","^^","ad","AD");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^AD");
   free(s);
   // replace string, empty new delimeter
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = replaceManyO(self, "#","","ad","AD");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "eeeeAD");
   free(s);
   // not enough olds:news pairs
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = replaceManyO(self, "#","","ad");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "eeeead");
   free(s);
   // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = replaceManyO(self, "##",NULL);
   ck_assert_ptr_eq(r, null);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = replaceManyO(self, "##", "");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty string many pairs
   freeO(self);
   setTopSO(self, "");
   r = replaceManyO(self, "##", "", "$$", "");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty string many pairs empty olds
   freeO(self);
   setTopSO(self, "");
   r = replaceManyO(self, "##", "", "", "");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty string and NULL old delimiter
   freeO(self);
   setTopSO(self, "");
   r = replaceManyO(self, NULL,"|");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty string and NULL old delimiter not first - same as replace empty string
   freeO(self);
   setTopSO(self, "");
   r = replaceManyO(self,"##","|", NULL,"|");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   ck_assert_ptr_eq(replaceManyO(self, "","|", "AA", "BB"), NULL);
   // empty old delimiter not first
   ck_assert_ptr_eq(replaceManyO(self, "##","|", "", "BB"), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(replaceManyO(self, "##","|"), NULL);
   terminateO(self);
 
 }
 
 
 void icReplaceSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "BeebeeBad");
 
   // replace string, multiple character new delimeter
   r = icReplaceO(self, "b","^^", 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = icReplaceO(self, "##","|", 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = icReplaceO(self, "#","^^",1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = icReplaceO(self, "##","|",1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = icReplaceO(self, "##",NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = icReplaceO(self, "##",NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   ck_assert_ptr_eq(icReplaceO(self, "","|",1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(icReplaceO(self, NULL,"|",1), NULL);
   // empty old delimiter
   ck_assert_ptr_eq(icReplaceO(self, "","|",1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icReplaceO(self, "##","|",1), NULL);
   terminateO(self);
 
 }
 
 
 void icReplaceCharSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // replace string, multiple character new delimeter
   freeO(self);
   setTopSO(self, "BeebeeBad");
   r = icReplaceCharSO(self, 'B',"^^", 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = icReplaceCharSO(self, '#',"^^",1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = icReplaceCharSO(self, '#',"|",1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|#ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA#ee##ee#");
   r = icReplaceCharSO(self, '#',NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = icReplaceCharSO(self, '#',NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   ck_assert_ptr_eq(icReplaceCharSO(self, 0,"|",1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icReplaceCharSO(self, '#',"|",1), NULL);
   terminateO(self);
 
 }
 
 
 void icReplaceSCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // replace string, multiple character new delimeter
   freeO(self);
   setTopSO(self, "BeebeeBad");
   r = icReplaceSCharO(self, "b",'^',0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = icReplaceSCharO(self, "##",'|',0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace string empty char, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = icReplaceSCharO(self, "##", 0,0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAeeee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = icReplaceSCharO(self, "#",'^',1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = icReplaceSCharO(self, "##",'|',1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = icReplaceSCharO(self, "##",0,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   ck_assert_ptr_eq(icReplaceSCharO(self, "",'|',1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(icReplaceSCharO(self, NULL,'|',1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icReplaceSCharO(self, "##",'|',1), NULL);
   terminateO(self);
 
 }
 
 
 void icReplaceCharCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // replace string, multiple character new delimeter
   freeO(self);
   setTopSO(self, "beeBeebad");
   r = icReplaceCharCharO(self, 'b','^', 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = icReplaceCharCharO(self, '#','^',1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA#ee##ee#");
   r = icReplaceCharCharO(self, '#','|',1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = icReplaceCharCharO(self, '#','^',1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   ck_assert_ptr_eq(icReplaceCharCharO(self, 0,'|',1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icReplaceCharCharO(self, '#','|',1), NULL);
   terminateO(self);
 
 }
 
 
 void icReplaceSmallStringSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "beebeebad");
   smallStringt *olds = allocSmallString("");
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   setValO(olds, "B");
   setValO(news, "^^");
   r = icReplaceSmallStringSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   setValO(news, "|");
   r = icReplaceSmallStringSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   setValO(olds, "#");
   setValO(news, "^^");
   r = icReplaceSmallStringSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   setValO(news, "|");
   r = icReplaceSmallStringSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   r = icReplaceSmallStringSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non smallString object
   terminateO(olds);
   olds = (smallStringt*) allocSmallInt(1);
   r = icReplaceSmallStringSmallStringO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   terminateO(news);
   olds = allocSmallString("");
   news = (smallStringt*) allocSmallInt(1);
   r = icReplaceSmallStringSmallStringO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallString("");
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(olds, "##");
   r = icReplaceSmallStringSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   setValO(olds, "");
   setValO(news, "|");
   ck_assert_ptr_eq(icReplaceSmallStringSmallStringO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(icReplaceSmallStringSmallStringO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icReplaceSmallStringSmallStringO(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceSmallStringSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "beebeebad");
   smallStringt *olds = allocSmallString("");
   const char *news;
 
   // replace string, multiple character new delimeter
   setValO(olds, "B");
   news = "^^";
   r = icReplaceSmallStringSO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   news = "|";
   r = icReplaceSmallStringSO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   setValO(olds, "#");
   news = "^^";
   r = icReplaceSmallStringSO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   news = "|";
   r = icReplaceSmallStringSO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   r = icReplaceSmallStringSO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non smallString object
   terminateO(olds);
   olds = (smallStringt*) allocSmallInt(1);
   r = icReplaceSmallStringSO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   olds = allocSmallString("");
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(olds, "##");
   r = icReplaceSmallStringSO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   setValO(olds, "");
   news = "|";
   ck_assert_ptr_eq(icReplaceSmallStringSO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(icReplaceSmallStringSO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icReplaceSmallStringSO(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void icReplaceSmallStringCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "beebeebad");
   smallStringt *olds = allocSmallString("");
   char news;
 
   // replace string, multiple character new delimeter
   setValO(olds, "B");
   news = '^';
   r = icReplaceSmallStringCharO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   news = '|';
   r = icReplaceSmallStringCharO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   setValO(olds, "#");
   news = '^';
   r = icReplaceSmallStringCharO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   news = '|';
   r = icReplaceSmallStringCharO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // non smallString object
   terminateO(olds);
   olds = (smallStringt*) allocSmallInt(1);
   r = icReplaceSmallStringCharO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   olds = allocSmallString("");
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(olds, "##");
   r = icReplaceSmallStringCharO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   setValO(olds, "");
   news = '|';
   ck_assert_ptr_eq(icReplaceSmallStringCharO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(icReplaceSmallStringCharO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icReplaceSmallStringCharO(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void icReplaceSSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "beebeebad");
   const char *olds;
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   olds = "B";
   setValO(news, "^^");
   r = icReplaceSSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   olds = "##";
   setValO(news, "|");
   r = icReplaceSSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   olds = "#";
   setValO(news, "^^");
   r = icReplaceSSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   olds = "##";
   setValO(news, "|");
   r = icReplaceSSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   olds = "##";
   r = icReplaceSSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non smallString object
   terminateO(news);
   news = (smallStringt*) allocSmallInt(1);
   r = icReplaceSSmallStringO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallString("");
   // empty string
   freeO(self);
   setTopSO(self, "");
   olds = "##";
   r = icReplaceSSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   olds = "";
   setValO(news, "|");
   ck_assert_ptr_eq(icReplaceSSmallStringO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(icReplaceSSmallStringO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icReplaceSSmallStringO(self, olds, news,1), NULL);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceCharSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "beebeebad");
   char olds;
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   olds = 'B';
   setValO(news, "^^");
   r = icReplaceCharSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA#ee#ee");
   olds = '#';
   setValO(news, "|");
   r = icReplaceCharSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   olds = '#';
   setValO(news, "^^");
   r = icReplaceCharSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA#ee##ee#");
   olds = '#';
   setValO(news, "|");
   r = icReplaceCharSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA#ee##ee#");
   olds = '#';
   r = icReplaceCharSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non smallString object
   terminateO(news);
   news = (smallStringt*) allocSmallInt(1);
   r = icReplaceCharSmallStringO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallString("");
   // empty string
   freeO(self);
   setTopSO(self, "");
   olds = '#';
   r = icReplaceCharSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // NULL string
   freeO(self);
   setValO(news, "|");
   ck_assert_ptr_eq(icReplaceCharSmallStringO(self, olds, news,1), NULL);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceJsonJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "BeebeeBad");
   smallJsont *olds = allocSmallJson();
   smallJsont *news = allocSmallJson();
 
   // replace string, multiple character new delimeter
   freeO(olds);
   freeO(news);
   setTopSO(olds, "B");
   setTopSO(news, "^^");
   r = icReplaceJsonJsonO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   freeO(news);
   setTopSO(olds, "##");
   setTopSO(news, "|");
   r = icReplaceJsonJsonO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   freeO(olds);
   freeO(news);
   setTopSO(olds, "#");
   setTopSO(news, "^^");
   r = icReplaceJsonJsonO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   freeO(news);
   setTopSO(olds, "##");
   setTopSO(news, "|");
   r = icReplaceJsonJsonO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   r = icReplaceJsonJsonO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non json string
   freeO(olds);
   setTopIntO(olds, 1);
   r = icReplaceJsonJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   freeO(olds);
   freeO(news);
   setTopSO(olds, "e");
   setTopIntO(news, 1);
   r = icReplaceJsonJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   // non json object
   terminateO(olds);
   olds = (smallJsont*) allocSmallInt(1);
   r = icReplaceJsonJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   terminateO(news);
   olds = allocSmallJson();
   news = (smallJsont*) allocSmallInt(1);
   r = icReplaceJsonJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallJson();
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(olds);
   setTopSO(olds, "##");
   r = icReplaceJsonJsonO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   freeO(olds);
   freeO(news);
   setTopSO(olds, "");
   setTopSO(news, "|");
   ck_assert_ptr_eq(icReplaceJsonJsonO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(icReplaceJsonJsonO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icReplaceJsonJsonO(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceJsonSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "BeebeeBad");
   smallJsont *olds   = allocSmallJson();
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   freeO(olds);
   setTopSO(olds, "B");
   setValO(news, "^^");
   r = icReplaceJsonSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   setValO(news, "|");
   r = icReplaceJsonSmallStringO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   freeO(olds);
   setTopSO(olds, "#");
   setValO(news, "^^");
   r = icReplaceJsonSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   setValO(news, "|");
   r = icReplaceJsonSmallStringO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   r = icReplaceJsonSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non json string
   freeO(olds);
   setTopIntO(olds, 1);
   r = icReplaceJsonSmallStringO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   // non json object
   terminateO(olds);
   olds = (smallJsont*) allocSmallInt(1);
   r = icReplaceJsonSmallStringO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   terminateO(news);
   olds = allocSmallJson();
   news = (smallStringt*) allocSmallInt(1);
   r = icReplaceJsonSmallStringO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallString("");
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(olds);
   setTopSO(olds, "##");
   r = icReplaceJsonSmallStringO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   freeO(olds);
   setTopSO(olds, "");
   setValO(news, "|");
   ck_assert_ptr_eq(icReplaceJsonSmallStringO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(icReplaceJsonSmallStringO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icReplaceJsonSmallStringO(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceJsonSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "BeebeeBad");
   smallJsont *olds   = allocSmallJson();
   const char *news;
 
   // replace string, multiple character new delimeter
   freeO(olds);
   setTopSO(olds, "b");
   news = "^^";
   r = icReplaceJsonSO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   news = "|";
   r = icReplaceJsonSO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   freeO(olds);
   setTopSO(olds, "#");
   news = "^^";
   r = icReplaceJsonSO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   news = "|";
   r = icReplaceJsonSO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   r = icReplaceJsonSO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non json string
   freeO(olds);
   setTopIntO(olds, 1);
   r = icReplaceJsonSO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   // non json object
   terminateO(olds);
   olds = (smallJsont*) allocSmallInt(1);
   r = icReplaceJsonSO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   // empty string
   olds = allocSmallJson();
   freeO(self);
   setTopSO(self, "");
   setTopSO(olds, "##");
   r = icReplaceJsonSO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   freeO(olds);
   setTopSO(olds, "");
   news = "|";
   ck_assert_ptr_eq(icReplaceJsonSO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(icReplaceJsonSO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icReplaceJsonSO(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void icReplaceJsonCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "beeBeebad");
   smallJsont *olds   = allocSmallJson();
   char news;
 
   // replace string, multiple character new delimeter
   freeO(olds);
   setTopSO(olds, "B");
   news = '^';
   r = icReplaceJsonCharO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   news = '|';
   r = icReplaceJsonCharO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   freeO(olds);
   setTopSO(olds, "#");
   news = '^';
   r = icReplaceJsonCharO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopSO(olds, "##");
   news = '|';
   r = icReplaceJsonCharO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // non json string
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(olds);
   setTopIntO(olds, 1);
   r = icReplaceJsonCharO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   // non json object
   terminateO(olds);
   olds = (smallJsont*) allocSmallInt(1);
   r = icReplaceJsonCharO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   // empty string
   olds = allocSmallJson();
   freeO(self);
   setTopSO(self, "");
   setTopSO(olds, "##");
   r = icReplaceJsonCharO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   freeO(olds);
   setTopSO(olds, "");
   news = '|';
   ck_assert_ptr_eq(icReplaceJsonCharO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(icReplaceJsonCharO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icReplaceJsonCharO(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void icReplaceSmallStringJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "BeeBeeBad");
   smallStringt *olds = allocSmallString("");
   smallJsont *news   = allocSmallJson();
 
   // replace string, multiple character new delimeter
   freeO(news);
   setValO(olds, "b");
   setTopSO(news, "^^");
   r = self->f->icReplaceSmallStringJson(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(news);
   setValO(olds, "##");
   setTopSO(news, "|");
   r = self->f->icReplaceSmallStringJson(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   freeO(news);
   setValO(olds, "#");
   setTopSO(news, "^^");
   r = self->f->icReplaceSmallStringJson(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(news);
   setValO(olds, "##");
   setTopSO(news, "|");
   r = self->f->icReplaceSmallStringJson(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   setValO(olds, "##");
   r = self->f->icReplaceSmallStringJson(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non json string
   freeO(news);
   setTopIntO(news, 1);
   r = self->f->icReplaceSmallStringJson(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   // non json object
   terminateO(olds);
   olds = (smallStringt*) allocSmallInt(1);
   r = self->f->icReplaceSmallStringJson(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(olds);
   terminateO(news);
   olds = allocSmallString("");
   news = (smallJsont*) allocSmallInt(1);
   r = self->f->icReplaceSmallStringJson(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallJson();
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(olds, "##");
   r = self->f->icReplaceSmallStringJson(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   freeO(news);
   setValO(olds, "");
   setTopSO(news, "|");
   ck_assert_ptr_eq(self->f->icReplaceSmallStringJson(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(self->f->icReplaceSmallStringJson(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(self->f->icReplaceSmallStringJson(self, olds, news,1), NULL);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceSJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "beebeebad");
   const char *olds;
   smallJsont *news   = allocSmallJson();
 
   // replace string, multiple character new delimeter
   freeO(news);
   olds = "B";
   setTopSO(news, "^^");
   r = icReplaceSJsonO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(news);
   olds = "##";
   setTopSO(news, "|");
   r = icReplaceSJsonO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee#");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   freeO(news);
   olds = "#";
   setTopSO(news, "^^");
   r = icReplaceSJsonO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   freeO(news);
   olds = "##";
   setTopSO(news, "|");
   r = icReplaceSJsonO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   olds = "##";
   r = icReplaceSJsonO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non json string
   freeO(news);
   olds = "e";
   setTopIntO(news, 1);
   r = icReplaceSJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   // non json object
   terminateO(news);
   news = (smallJsont*) allocSmallInt(1);
   r = icReplaceSJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallJson();
   // empty string
   freeO(self);
   setTopSO(self, "");
   olds = "##";
   r = icReplaceSJsonO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "qwe");
   freeO(news);
   olds = "";
   setTopSO(news, "|");
   ck_assert_ptr_eq(icReplaceSJsonO(self, olds, news,1), NULL);
   // NULL old delimiter
   ck_assert_ptr_eq(icReplaceSJsonO(self, NULL, news,1), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icReplaceSJsonO(self, olds, news,1), NULL);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceCharJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "beebeebad");
   char olds;
   smallJsont *news   = allocSmallJson();
 
   // replace string, multiple character new delimeter
   freeO(news);
   olds = 'B';
   setTopSO(news, "^^");
   r = icReplaceCharJsonO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   // replace string, multiple character old delimeter
   freeO(self);
   setTopSO(self, "AA#ee#ee");
   freeO(news);
   olds = '#';
   setTopSO(news, "|");
   r = icReplaceCharJsonO(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee|ee");
   free(s);
   // replace one time at the start of string
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   freeO(news);
   olds = '#';
   setTopSO(news, "^^");
   r = icReplaceCharJsonO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "^^ee#ee#ad");
   free(s);
   // replace one time
   freeO(self);
   setTopSO(self, "AA#ee##ee#");
   freeO(news);
   olds = '#';
   setTopSO(news, "|");
   r = icReplaceCharJsonO(self, olds, news,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AA|ee##ee#");
   free(s);
   // NULL new delimiter, one time: same as empty delimiter
   freeO(self);
   setTopSO(self, "AA#ee##ee#");
   olds = '#';
   r = icReplaceCharJsonO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "AAee##ee#");
   free(s);
   // non json string
   freeO(news);
   olds = 'e';
   setTopIntO(news, 1);
   r = icReplaceCharJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   // non json object
   terminateO(news);
   news = (smallJsont*) allocSmallInt(1);
   r = icReplaceCharJsonO(self, olds, news,1);
   ck_assert_ptr_eq(r, null);
   terminateO(news);
   news = allocSmallJson();
   // empty string
   freeO(self);
   setTopSO(self, "");
   olds = '#';
   r = icReplaceCharJsonO(self, olds, NULL,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // NULL string
   freeO(self);
   freeO(news);
   setTopSO(news, "|");
   ck_assert_ptr_eq(icReplaceCharJsonO(self, olds, news,1), NULL);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceManySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // replace string, multiple character new delimeter
   freeO(self);
   setTopSO(self, "beebeebad");
   r = icReplaceManyO(self, "B","^^","aD","AD");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^AD");
   free(s);
   // replace string, empty new delimeter
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = icReplaceManyO(self, "#","","ad","AD");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "eeeeAD");
   free(s);
   // not enough olds:news pairs
   freeO(self);
   setTopSO(self, "#ee#ee#ad");
   r = icReplaceManyO(self, "#","","ad");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "eeeead");
   free(s);
   // NULL new delimiter: same as only 2 parameters or not enough olds:news pairs
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   r = icReplaceManyO(self, "##",NULL);
   ck_assert_ptr_eq(r, null);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = icReplaceManyO(self, "##", "");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty string many pairs
   freeO(self);
   setTopSO(self, "");
   r = icReplaceManyO(self, "##", "", "$$", "");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty string many pairs empty olds
   freeO(self);
   setTopSO(self, "");
   r = icReplaceManyO(self, "##", "", "", "");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty string and NULL old delimiter
   freeO(self);
   setTopSO(self, "");
   r = icReplaceManyO(self, NULL,"|");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty string and NULL old delimiter not first - same as replace empty string
   freeO(self);
   setTopSO(self, "");
   r = icReplaceManyO(self,"##","|", NULL,"|");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty old delimiter
   freeO(self);
   setTopSO(self, "AA##ee##ee#");
   ck_assert_ptr_eq(icReplaceManyO(self, "","|", "AA", "BB"), NULL);
   // empty old delimiter not first
   ck_assert_ptr_eq(icReplaceManyO(self, "##","|", "", "BB"), NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icReplaceManyO(self, "##","|"), NULL);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallArrayT(void) {
 
   bool r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallArrayt *array = allocSmallArray();
 
   // empty arrays
   setTypeArrayO(self);
   r = self->f->equalSmallArray(self, array);
   ck_assert(r);
   // empty self, non empty array
   array->f->pushInt(array, 1);
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
   // non empty self, empty array
   emptyO(array);
   self->f->pushInt(self, 1);
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
   // different lengths
   array->f->pushInt(array, 1);
   self->f->pushInt(self, 1);
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
   // equal arrays
   array->f->pushInt(array, 1);
   r = self->f->equalSmallArray(self, array);
   ck_assert(r);
   // different int value
   array->f->setAtInt(array, 1, 2);
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
   // array same length with a null element in self
   smallIntt *i = self->f->getAtSmallInt(self, 1);
   removeElemIndexO(self, 1);
   terminateO(i);
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
   // array same length with a null element in both arrays
   i = array->f->getAtSmallInt(array, 1);
   removeElemO(array, 1);
   terminateO(i);
   r = self->f->equalSmallArray(self, array);
   ck_assert(r);
   // elements of different types
   self->f->setAtBool(self, 1, true);
   array->f->setAtInt(array, 1, 1);
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
   // compare bool
   array->f->setAtBool(array, 1, true);
   r = self->f->equalSmallArray(self, array);
   ck_assert(r);
   array->f->setAtBool(array, 1, false);
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
   // compare dict
   createSmallDict(d1);
   createSmallDict(d2);
   self->f->setAtDict(self, 1, &d1);
   array->f->setAtDict(array, 1, &d2);
   r = self->f->equalSmallArray(self, array);
   ck_assert(r);
     // reuse dict container, the data is in self already
   resetO(&d1);
   (&d1)->f->setInt(&d1, "a", 1);
   self->f->setAtDict(self, 1, &d1);
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
   // compare double
   self->f->setAtDouble(self, 1, 0);
   array->f->setAtDouble(array, 1, 0);
   r = self->f->equalSmallArray(self, array);
   ck_assert(r);
   array->f->setAtDouble(array, 1, 10.5);
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
   // compare string
   self->f->setAtS(self, 1, "");
   array->f->setAtS(array, 1, "");
   r = self->f->equalSmallArray(self, array);
   ck_assert(r);
   array->f->setAtS(array, 1, "NO");
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
   // compare array elements
   createSmallArray(a1);
   createSmallArray(a2);
   self->f->setAtArray(self, 1, &a1);
   array->f->setAtArray(array, 1, &a2);
   r = self->f->equalSmallArray(self, array);
   ck_assert(r);
     // reuse Array container, the data is in self already
   resetO(&a1);
   (&a1)->f->pushInt(&a1, 1);
   self->f->setAtArray(self, 1, &a1);
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
   // compare bytes
   createSmallBytes(b1);
   createSmallBytes(b2);
   self->f->setAtSmallBytes(self, 1, &b1);
   array->f->setAtSmallBytes(array, 1, &b2);
   r = self->f->equalSmallArray(self, array);
   ck_assert(r);
     // reuse SmallBytes container, the data is in self already
   b1.B = null;
   pushBufferO(&b1, &self, 2);
   self->f->setAtSmallBytes(self, 1, &b1);
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
     // compare data in both smallBytes elements
   b2.B = null;
   pushBufferO(&b2, (char*)(&self) + 4, 2);
   array->f->setAtSmallBytes(array, 1, &b2);
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
   // non smallArray object
   terminateO(array);
   array = (smallArrayt*) allocSmallInt(2);
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
   // NULL array
   r = self->f->equalSmallArray(self, NULL);
   ck_assert(!r);
   // non json array
   freeO(self);
   setTypeDictO(self);
   ck_assert(!self->f->equalSmallArray(self, array));
   // non smallArray array
   freeO(self);
   setTypeArrayO(self);
   terminateO(array);
   array = (smallArrayt*) allocSmallInt(2);
   r = self->f->equalSmallArray(self, array);
   ck_assert(!r);
   terminateO(array);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonArrayT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   char ** p2 = NULL;
 
   // empty arrays
   setTypeArrayO(self);
   r = self->f->equalArray(self, NULL);
   ck_assert(r);
   // empty self, non empty array
   p2 = listCreateS("a");
   r = self->f->equalArray(self, p2);
   ck_assert(!r);
   // non empty self, empty array
   self->f->pushInt(self, 1);
   listFreeS(p2);
   listEmptyS(p2);
   r = self->f->equalArray(self, p2);
   ck_assert(!r);
   // different lengths
   listPushS(&p2, "a");
   self->f->pushInt(self, 2);
   r = self->f->equalArray(self, p2);
   ck_assert(!r);
   // equal arrays
   emptyO(self);
   self->f->pushS(self, "a");
   r = self->f->equalArray(self, p2);
   ck_assert(r);
   // not string type in self
   self->f->setAtInt(self, 0, 0);
   r = self->f->equalArray(self, p2);
   ck_assert(!r);
   // array same length with a null element in self
   smallIntt *i = self->f->getAtSmallInt(self, 0);
   terminateO(i);
   removeElemIndexO(self, 0);
   r = self->f->equalArray(self, p2);
   ck_assert(!r);
   // different strings
   self->f->setAtS(self, 0, "bb");
   r = self->f->equalArray(self, p2);
   ck_assert(!r);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert(!self->f->equalArray(self, p2));
   listFreeS(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonBaseT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   baset* p2;
 
   // json bool
   setTopBoolO(self, false);
   p2 = (baset*) allocSmallBool(false);
   r = self->f->equalBase(self, p2);
   ck_assert(r);
   freeO(self);
   setTopBoolO(self, true);
   r = self->f->equalBase(self, p2);
   ck_assert(!r);
   terminateO(p2);
   p2 = (baset*) allocSmallBool(true);
   r = self->f->equalBase(self, p2);
   ck_assert(r);
   //  non equal
   terminateO(p2);
   p2 = (baset*) allocSmallString("true ");
   r = self->f->equalBase(self, p2);
   ck_assert(!r);
   // json double
   freeO(self);
   setTopDoubleO(self, 2.2);
   terminateO(p2);
   p2 = (baset*) allocSmallString("2.2");
   r = self->f->equalBase(self, p2);
   ck_assert(r);
   freeO(self);
   setTopDoubleO(self, 2);
   r = self->f->equalBase(self, p2);
   ck_assert(!r);
   terminateO(p2);
   //  p2 is an int so not equal to double (int)2 != (double)2
   //  TODO is this reasonable?
   p2 = (baset*) allocSmallInt(2);
   r = self->f->equalBase(self, p2);
   ck_assert(!r);
   terminateO(p2);
   p2 = (baset*) allocSmallString("asd");
   r = self->f->equalBase(self, p2);
   ck_assert(!r);
   // json int
   freeO(self);
   setTopIntO(self, 2);
   terminateO(p2);
   p2 = (baset*) allocSmallString("2");
   r = self->f->equalBase(self, p2);
   ck_assert(r);
   terminateO(p2);
   p2 = (baset*) allocSmallString("3");
   r = self->f->equalBase(self, p2);
   ck_assert(!r);
   terminateO(p2);
   p2 = (baset*) allocSmallDouble(2);
   r = self->f->equalBase(self, p2);
   ck_assert(!r);
   terminateO(p2);
   p2 = (baset*) allocSmallString("asd");
   r = self->f->equalBase(self, p2);
   ck_assert(!r);
   // json string
   freeO(self);
   setTopSO(self, "12");
   terminateO(p2);
   p2 = (baset*) allocSmallInt(12);
   r = self->f->equalBase(self, p2);
   ck_assert(r);
   // empty self
   freeO(self);
   r = self->f->equalBase(self, p2);
   ck_assert(!r);
   // json dict
   freeO(self);
   setTypeDictO(self);
   terminateO(p2);
   p2 = (baset*) allocSmallInt(12);
   r = self->f->equalBase(self, p2);
   ck_assert(!r);
   terminateO(p2);
   p2 = (baset*) allocSmallDict();
   r = self->f->equalBase(self, p2);
   ck_assert(!r);
   // json array
   freeO(self);
   setTypeArrayO(self);
   terminateO(p2);
   p2 = (baset*) allocSmallInt(12);
   r = self->f->equalBase(self, p2);
   ck_assert(!r);
   self->f->pushInt(self, 1);
   r = self->f->equalBase(self, p2);
   ck_assert(!r);
   terminateO(p2);
   p2 = (baset*) allocSmallArray();
   r = self->f->equalBase(self, p2);
   ck_assert(!r);
   // null object
   freeO(self);
   setTopSO(self, "qwe");
   r = self->f->equalBase(self, null);
   ck_assert(!r);
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonChaT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   r = equalChaO(self,'q');
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "q");
   r = equalChaO(self,'q');
   ck_assert(r);
   // empty strings
   freeO(self);
   r = equalChaO(self, ' ');
   ck_assert(!r);
   // json int
   freeO(self);
   setTopIntO(self, 1);
   r = equalChaO(self,'1');
   ck_assert(r);
   r = equalChaO(self,'2');
   ck_assert(!r);
   r = equalChaO(self,'q');
   ck_assert(!r);
   // non json string or int
   freeO(self);
   setTypeBoolO(self);
   r = equalChaO(self,'2');
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonCharT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   r = equalCharO(self,"qwe");
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "qwe");
   r = equalCharO(self,"qwe");
   ck_assert(r);
   // empty strings
   freeO(self);
   r = equalCharO(self, "");
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalCharO(self, "false");
   ck_assert(r);
   r = equalCharO(self, "true");
   ck_assert(!r);
   freeO(self);
   setTopBoolO(self, true);
   r = equalCharO(self, "false");
   ck_assert(!r);
   r = equalCharO(self, "true");
   ck_assert(r);
   r = equalCharO(self, " true");
   ck_assert(!r);
   // json double
   freeO(self);
   setTopDoubleO(self, 2.2);
   r = equalCharO(self, "2.2");
   ck_assert(r);
   freeO(self);
   setTopDoubleO(self, 2);
   r = equalCharO(self, "2.2");
   ck_assert(!r);
   //  value is an int so not equal to double (int)2 != (double)2
   //  TODO is this reasonable?
   r = equalCharO(self, "2");
   ck_assert(!r);
   r = equalCharO(self, "asd");
   ck_assert(!r);
   // json int
   freeO(self);
   setTopIntO(self, 2);
   r = equalCharO(self, "2");
   ck_assert(r);
   r = equalCharO(self, "3");
   ck_assert(!r);
   r = equalCharO(self, "2.0");
   ck_assert(!r);
   r = equalCharO(self, "asd");
   ck_assert(!r);
   // null object
   freeO(self);
   setTopSO(self, "qwe");
   r = equalCharO(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonBoolT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
 
   // empty json
   r = equalBoolO(self, false);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalBoolO(self, false);
   ck_assert(r);
   // json double
   freeO(self);
   setTopDoubleO(self, 1);
   r = equalBoolO(self, true);
   ck_assert(r);
   // json int
   freeO(self);
   setTopIntO(self, 1);
   r = equalBoolO(self, true);
   ck_assert(r);
   // json string
   freeO(self);
   setTopSO(self, "TRUE");
   r = equalBoolO(self, true);
   ck_assert(r);
   freeO(self);
   setTopSO(self, "FALSE");
   r = equalBoolO(self, true);
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "FALSE ");
   r = equalBoolO(self, false);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonDoubleT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
 
   // empty json
   r = equalDoubleO(self, 0);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalDoubleO(self, 0);
   ck_assert(r);
   // json double
   freeO(self);
   setTopDoubleO(self, 1.2);
   r = equalDoubleO(self, 1.2);
   ck_assert(r);
   // json int
   freeO(self);
   setTopIntO(self, 1);
   r = equalDoubleO(self, 1);
   ck_assert(r);
   // json string
   freeO(self);
   setTopSO(self, "1.0");
   r = equalDoubleO(self, 1);
   ck_assert(r);
   freeO(self);
   setTopSO(self, "1");
   r = equalDoubleO(self, 1);
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "qwe");
   r = equalDoubleO(self, 0);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonInt64T(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
 
   // empty json
   r = equalInt64O(self, 0);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalInt64O(self, 0);
   ck_assert(r);
   // json double
   freeO(self);
   setTopDoubleO(self, 2);
   r = equalInt64O(self, 2);
   ck_assert(r);
   // json int
   freeO(self);
   setTopIntO(self, 2);
   r = equalInt64O(self, 2);
   ck_assert(r);
   // json string
   freeO(self);
   setTopSO(self, "3");
   r = equalInt64O(self, 3);
   ck_assert(r);
   freeO(self);
   setTopSO(self, "1.0");
   r = equalInt64O(self, 1);
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "qwe");
   r = equalInt64O(self, 0);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonInt32T(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
 
   // empty json
   r = equalInt32O(self, 0);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalInt32O(self, 0);
   ck_assert(r);
   // json double
   freeO(self);
   setTopDoubleO(self, 2);
   r = equalInt32O(self, 2);
   ck_assert(r);
   // json int
   freeO(self);
   setTopIntO(self, 2);
   r = equalInt32O(self, 2);
   ck_assert(r);
   // json string
   freeO(self);
   setTopSO(self, "3");
   r = equalInt32O(self, 3);
   ck_assert(r);
   freeO(self);
   setTopSO(self, "1.0");
   r = equalInt32O(self, 1);
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "qwe");
   r = equalInt32O(self, 0);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonUint32T(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
 
   // empty json
   r = equalUint32O(self, 0);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalUint32O(self, 0);
   ck_assert(r);
   // json double
   freeO(self);
   setTopDoubleO(self, 2);
   r = equalUint32O(self, 2);
   ck_assert(r);
   // json int
   freeO(self);
   setTopIntO(self, 2);
   r = equalUint32O(self, 2);
   ck_assert(r);
   // json string
   freeO(self);
   setTopSO(self, "3");
   r = equalUint32O(self, 3);
   ck_assert(r);
   freeO(self);
   setTopSO(self, "1.0");
   r = equalUint32O(self, 1);
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "qwe");
   r = equalUint32O(self, 0);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonUint64T(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
 
   // empty json
   r = equalUint64O(self, 0);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalUint64O(self, 0);
   ck_assert(r);
   // json double
   freeO(self);
   setTopDoubleO(self, 2);
   r = equalUint64O(self, 2);
   ck_assert(r);
   // json int
   freeO(self);
   setTopIntO(self, 2);
   r = equalUint64O(self, 2);
   ck_assert(r);
   // json string
   freeO(self);
   setTopSO(self, "3");
   r = equalUint64O(self, 3);
   ck_assert(r);
   freeO(self);
   setTopSO(self, "1.0");
   r = equalUint64O(self, 1);
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "qwe");
   r = equalUint64O(self, 0);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallBoolT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallBoolt* p2   = allocSmallBool(false);
 
   // empty json
   r = equalSmallBoolO(self, p2);
   ck_assert(!r);
   // not equal
   setTopBoolO(self, true);
   r = equalSmallBoolO(self, p2);
   ck_assert(!r);
   // equal
   setValO(p2, true);
   r = equalSmallBoolO(self, p2);
   ck_assert(r);
   // empty smallBool
   freeO(p2);
   r = equalSmallBoolO(self, p2);
   ck_assert(!r);
   // non smallBool
   terminateO(p2);
   p2 = (smallBoolt*) allocSmallInt(0);
   r = equalSmallBoolO(self, p2);
   ck_assert(!r);
   // null
   r = equalSmallBoolO(self, null);
   ck_assert(!r);
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallBytesT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallBytest* p2  = allocSmallBytes("true", strlen("true"));
 
   // empty json
   ck_assert(!self->f->equalSmallBytes(self, p2));
   // json bool
   setTopBoolO(self, true);
   ck_assert(!self->f->equalSmallBytes(self, p2));
   freeO(p2);
   pushBufferO(p2, "true", sizeof("true"));
   ck_assert(self->f->equalSmallBytes(self, p2));
   freeO(self);
   setTopBoolO(self, false);
   ck_assert(!self->f->equalSmallBytes(self, p2));
   freeO(p2);
   pushBufferO(p2, "false", sizeof("false"));
   ck_assert(self->f->equalSmallBytes(self, p2));
   freeO(self);
   setTopBoolO(self, true);
   ck_assert(!self->f->equalSmallBytes(self, p2));
   freeO(p2);
   pushBufferO(p2, "False", sizeof("False"));
   ck_assert(!self->f->equalSmallBytes(self, p2));
   // json double
   freeO(self);
   setTopDoubleO(self, 2.2);
   freeO(p2);
   pushBufferO(p2, "2.2", strlen("2.2"));
   r = self->f->equalSmallBytes(self, p2);
   ck_assert(!r);
   freeO(p2);
   pushBufferO(p2, "2.2", sizeof("2.2"));
   r = self->f->equalSmallBytes(self, p2);
   ck_assert(r);
   freeO(self);
   setTopDoubleO(self, 2);
   r = self->f->equalSmallBytes(self, p2);
   ck_assert(!r);
   freeO(p2);
   pushBufferO(p2, "2", sizeof("2"));
   r = self->f->equalSmallBytes(self, p2);
   ck_assert(!r);
   freeO(p2);
   pushBufferO(p2, "asd", sizeof("asd"));
   r = self->f->equalSmallBytes(self, p2);
   ck_assert(!r);
   // json int
   freeO(self);
   setTopIntO(self, 2);
   freeO(p2);
   pushBufferO(p2, "2", strlen("2"));
   r = self->f->equalSmallBytes(self, p2);
   ck_assert(!r);
   freeO(p2);
   pushBufferO(p2, "2", sizeof("2"));
   r = self->f->equalSmallBytes(self, p2);
   ck_assert(r);
   freeO(p2);
   pushBufferO(p2, "3", sizeof("3"));
   r = self->f->equalSmallBytes(self, p2);
   ck_assert(!r);
   freeO(p2);
   pushBufferO(p2, "2.0", sizeof("2.0"));
   r = self->f->equalSmallBytes(self, p2);
   ck_assert(!r);
   freeO(p2);
   pushBufferO(p2, "asd", sizeof("asd"));
   r = self->f->equalSmallBytes(self, p2);
   ck_assert(!r);
   // json string
   freeO(self);
   setTopSO(self, "qweert");
   r = self->f->equalSmallBytes(self, p2);
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "asd");
   r = self->f->equalSmallBytes(self, p2);
   ck_assert(r);
   // empty smallBytes
   freeO(p2);
   ck_assert(!self->f->equalSmallBytes(self, p2));
   // non smallBytes
   terminateO(p2);
   p2 = (smallBytest*) allocSmallInt(0);
   ck_assert(!self->f->equalSmallBytes(self, p2));
   // null
   ck_assert(!self->f->equalSmallBytes(self, null));
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallDoubleT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallDoublet* p2 = allocSmallDouble(0);
 
   // empty json
   r = equalSmallDoubleO(self, p2);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalSmallDoubleO(self, p2);
   ck_assert(r);
   // json double
   freeO(self);
   setTopDoubleO(self, 1.2);
   setValO(p2, 1.2);
   r = equalSmallDoubleO(self, p2);
   ck_assert(r);
   // json int
   freeO(self);
   setTopIntO(self, 1);
   setValO(p2, 1);
   r = equalSmallDoubleO(self, p2);
   ck_assert(r);
   // json string
   freeO(self);
   setTopSO(self, "1.0");
   r = equalSmallDoubleO(self, p2);
   ck_assert(r);
   freeO(self);
   setTopSO(self, "1");
   r = equalSmallDoubleO(self, p2);
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "qwe");
   r = equalSmallDoubleO(self, p2);
   ck_assert(!r);
   // empty smallDouble
   freeO(p2);
   ck_assert(!equalSmallDoubleO(self, p2));
   // non smallDouble
   terminateO(p2);
   p2 = (smallDoublet*) allocSmallInt(0);
   ck_assert(!equalSmallDoubleO(self, p2));
   // null
   ck_assert(!equalSmallDoubleO(self, null));
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallIntT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallIntt* p2    = allocSmallInt(0);
 
   // empty json
   r = equalSmallIntO(self, p2);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalSmallIntO(self, p2);
   ck_assert(r);
   // json double
   freeO(self);
   setTopDoubleO(self, 2);
   setValO(p2, 2);
   r = equalSmallIntO(self, p2);
   ck_assert(r);
   // json int
   freeO(self);
   setTopIntO(self, 2);
   r = equalSmallIntO(self, p2);
   ck_assert(r);
   // json string
   freeO(self);
   setTopSO(self, "3");
   setValO(p2, 3);
   r = equalSmallIntO(self, p2);
   ck_assert(r);
   freeO(self);
   setTopSO(self, "1.0");
   setValO(p2, 1);
   r = equalSmallIntO(self, p2);
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "qwe");
   r = equalSmallIntO(self, p2);
   ck_assert(!r);
   // empty smallInt
   freeO(p2);
   ck_assert(!equalSmallIntO(self, p2));
   // non smallInt
   terminateO(p2);
   p2 = (smallIntt*) allocSmallBool(false);
   ck_assert(!equalSmallIntO(self, p2));
   // null
   ck_assert(!equalSmallIntO(self, null));
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallJsonT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallJsont* p2   = allocSmallJson();
 
   // empty json
   r = equalSmallJsonO(self, p2);
   ck_assert(!r);
   // undefined
   setTypeUndefinedO(p2);
   ck_assert(!equalSmallJsonO(self, p2));
   setTypeUndefinedO(self);
   ck_assert(equalSmallJsonO(self, p2));
   // bool
   freeO(self);
   freeO(p2);
   setTopBoolO(self, true);
   setTopBoolO(p2, true);
   ck_assert(equalSmallJsonO(self, p2));
   // double
   freeO(self);
   freeO(p2);
   setTopDoubleO(self, 2.3);
   setTopDoubleO(p2, 2.3);
   ck_assert(equalSmallJsonO(self, p2));
   // int
   freeO(self);
   freeO(p2);
   setTopIntO(self, 2);
   setTopIntO(p2, 2);
   ck_assert(equalSmallJsonO(self, p2));
   // string
   freeO(self);
   freeO(p2);
   setTopSO(self, "");
   setTopSO(p2, "");
   ck_assert(equalSmallJsonO(self, p2));
   // dict
   freeO(self);
   freeO(p2);
   setTypeDictO(self);
   setTypeDictO(p2);
   ck_assert(equalSmallJsonO(self, p2));
   // array
   freeO(self);
   freeO(p2);
   setTypeArrayO(self);
   setTypeArrayO(p2);
   ck_assert(equalSmallJsonO(self, p2));
   // empty smallJson
   freeO(p2);
   ck_assert(!equalSmallJsonO(self, p2));
   // non smallJson
   terminateO(p2);
   p2 = (smallJsont*) allocSmallBool(false);
   ck_assert(!equalSmallJsonO(self, p2));
   // null
   ck_assert(!equalSmallJsonO(self, null));
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallStringT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallStringt* p2 = allocSmallString("");
 
   // empty json
   r = equalSmallStringO(self, p2);
   ck_assert(!r);
   // json bool
   setTypeBoolO(self);
   setValO(p2, "false");
   r = equalSmallStringO(self, p2);
   ck_assert(r);
   setValO(p2, "true");
   r = equalSmallStringO(self, p2);
   ck_assert(!r);
   freeO(self);
   setTopBoolO(self, true);
   setValO(p2, "false");
   r = equalSmallStringO(self, p2);
   ck_assert(!r);
   setValO(p2, "true");
   r = equalSmallStringO(self, p2);
   ck_assert(r);
   setValO(p2, " true");
   r = equalSmallStringO(self, p2);
   ck_assert(!r);
   // json double
   freeO(self);
   setTopDoubleO(self, 2.2);
   setValO(p2, "2.2");
   r = equalSmallStringO(self, p2);
   ck_assert(r);
   freeO(self);
   setTopDoubleO(self, 2);
   r = equalSmallStringO(self, p2);
   ck_assert(!r);
   setValO(p2, "2");
   r = equalSmallStringO(self, p2);
   ck_assert(!r);
   setValO(p2, "asd");
   r = equalSmallStringO(self, p2);
   ck_assert(!r);
   // json int
   freeO(self);
   setTopIntO(self, 2);
   setValO(p2, "2");
   r = equalSmallStringO(self, p2);
   ck_assert(r);
   setValO(p2, "3");
   r = equalSmallStringO(self, p2);
   ck_assert(!r);
   setValO(p2, "2.0");
   r = equalSmallStringO(self, p2);
   ck_assert(!r);
   setValO(p2, "asd");
   r = equalSmallStringO(self, p2);
   ck_assert(!r);
   // json string
   freeO(self);
   setTopSO(self, "");
   r = equalSmallStringO(self, p2);
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "asd");
   r = equalSmallStringO(self, p2);
   ck_assert(r);
   // empty strings
   freeO(self);
   setValO(p2, "");
   r = equalSmallStringO(self, p2);
   ck_assert(!r);
   // empty smallString
   freeO(p2);
   ck_assert(!equalSmallStringO(self, p2));
   // non smallString
   terminateO(p2);
   p2 = (smallStringt*) allocSmallBool(false);
   ck_assert(!equalSmallStringO(self, p2));
   // null
   ck_assert(!equalSmallStringO(self, null));
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallDictT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallDictt* p2   = allocSmallDict();
 
   // empty json
   r = self->f->equalSmallDict(self, p2);
   ck_assert(!r);
   setTypeDictO(self);
   r = self->f->equalSmallDict(self, p2);
   ck_assert(!r);
   // equal
   self->f->setInt(self, "a", 1);
   self->f->setInt(self, "b", 2);
   self->f->setInt(self, "c", 3);
   p2->f->setInt(p2, "b", 2);
   p2->f->setInt(p2, "a", 1);
   p2->f->setInt(p2, "c", 3);
   r = self->f->equalSmallDict(self, p2);
   ck_assert(r);
   // non equal
   p2->f->setInt(p2, "b", 1);
   r = self->f->equalSmallDict(self, p2);
   ck_assert(!r);
   p2->f->del(p2, "b");
   r = self->f->equalSmallDict(self, p2);
   ck_assert(!r);
   // empty smallDict
   freeO(p2);
   ck_assert(!self->f->equalSmallDict(self, p2));
   // non smallDict
   terminateO(p2);
   p2 = (smallDictt*) allocSmallBool(false);
   ck_assert(!self->f->equalSmallDict(self, p2));
   // null
   ck_assert(!self->f->equalSmallDict(self, null));
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void icEqualSmallJsonSmallArrayT(void) {
 
   bool r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallArrayt *array = allocSmallArray();
 
   // empty arrays
   setTypeArrayO(self);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(r);
   // empty self, non empty array
   array->f->pushInt(array, 1);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
   // non empty self, empty array
   emptyO(array);
   self->f->pushInt(self, 1);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
   // different lengths
   array->f->pushInt(array, 1);
   self->f->pushS(self, "a");
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
   // equal arrays
   array->f->pushS(array, "A");
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(r);
   // different int value
   self->f->setAtInt(self, 1, 1);
   array->f->setAtInt(array, 1, 2);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
   // array same length with a null element in self
   smallIntt *i = self->f->getAtSmallInt(self, 1);
   removeElemIndexO(self, 1);
   terminateO(i);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
   // array same length with a null element in both arrays
   i = array->f->getAtSmallInt(array, 1);
   removeElemO(array, 1);
   terminateO(i);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(r);
   // elements of different types
   self->f->setAtBool(self, 1, true);
   array->f->setAtInt(array, 1, 1);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
   // compare bool
   array->f->setAtBool(array, 1, true);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(r);
   array->f->setAtBool(array, 1, false);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
   // compare dict
   createSmallDict(d1);
   createSmallDict(d2);
   self->f->setAtDict(self, 1, &d1);
   array->f->setAtDict(array, 1, &d2);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(r);
     // reuse dict container, the data is in self already
   resetO(&d1);
   (&d1)->f->setInt(&d1, "a", 1);
   self->f->setAtDict(self, 1, &d1);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
   // compare double
   self->f->setAtDouble(self, 1, 0);
   array->f->setAtDouble(array, 1, 0);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(r);
   array->f->setAtDouble(array, 1, 10.5);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
   // compare string
   self->f->setAtS(self, 1, "");
   array->f->setAtS(array, 1, "");
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(r);
   array->f->setAtS(array, 1, "NO");
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
   // compare array elements
   createSmallArray(a1);
   createSmallArray(a2);
   self->f->setAtArray(self, 1, &a1);
   array->f->setAtArray(array, 1, &a2);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(r);
     // reuse Array container, the data is in self already
   resetO(&a1);
   (&a1)->f->pushInt(&a1, 1);
   self->f->setAtArray(self, 1, &a1);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
   // compare bytes
   createSmallBytes(b1);
   createSmallBytes(b2);
   self->f->setAtSmallBytes(self, 1, &b1);
   array->f->setAtSmallBytes(array, 1, &b2);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(r);
     // reuse SmallBytes container, the data is in self already
   b1.B = null;
   pushBufferO(&b1, &self, 2);
   self->f->setAtSmallBytes(self, 1, &b1);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
     // compare data in both smallBytes elements
   b2.B = null;
   pushBufferO(&b2, (char*)(&self) + 4, 2);
   array->f->setAtSmallBytes(array, 1, &b2);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
   // non smallArray object
   terminateO(array);
   array = (smallArrayt*) allocSmallInt(2);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
   // NULL array
   r = self->f->icEqualSmallArray(self, NULL);
   ck_assert(!r);
   // non json array
   freeO(self);
   setTypeDictO(self);
   ck_assert(!self->f->icEqualSmallArray(self, array));
   // non smallArray array
   freeO(self);
   setTypeArrayO(self);
   terminateO(array);
   array = (smallArrayt*) allocSmallInt(2);
   r = self->f->icEqualSmallArray(self, array);
   ck_assert(!r);
   terminateO(array);
   terminateO(self);
 
 }
 
 
 void icEqualSmallJsonArrayT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   char ** p2       = NULL;
 
   // empty arrays
   setTypeArrayO(self);
   r = self->f->icEqualArray(self, NULL);
   ck_assert(r);
   // empty self, non empty array
   p2 = listCreateS("a");
   r = self->f->icEqualArray(self, p2);
   ck_assert(!r);
   // non empty self, empty array
   self->f->pushInt(self, 1);
   listFreeS(p2);
   listEmptyS(p2);
   r = self->f->icEqualArray(self, p2);
   ck_assert(!r);
   // different lengths
   listPushS(&p2, "a");
   self->f->pushInt(self, 2);
   r = self->f->icEqualArray(self, p2);
   ck_assert(!r);
   // equal arrays
   emptyO(self);
   self->f->pushS(self, "A");
   r = self->f->icEqualArray(self, p2);
   ck_assert(r);
   // not string type in self
   self->f->setAtInt(self, 0, 0);
   r = self->f->icEqualArray(self, p2);
   ck_assert(!r);
   // array same length with a null element in self
   smallIntt *i = self->f->getAtSmallInt(self, 0);
   terminateO(i);
   removeElemIndexO(self, 0);
   r = self->f->icEqualArray(self, p2);
   ck_assert(!r);
   // different strings
   self->f->setAtS(self, 0, "bb");
   r = self->f->icEqualArray(self, p2);
   ck_assert(!r);
   // non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert(!self->f->icEqualArray(self, p2));
   listFreeS(p2);
   terminateO(self);
 
 }
 
 
 void icEqualSmallJsonBaseT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   baset* p2;
 
   // json bool
   setTopBoolO(self, false);
   p2 = (baset*) allocSmallBool(false);
   r = self->f->icEqualBase(self, p2);
   ck_assert(r);
   freeO(self);
   setTopBoolO(self, true);
   r = self->f->icEqualBase(self, p2);
   ck_assert(!r);
   terminateO(p2);
   p2 = (baset*) allocSmallBool(true);
   r = self->f->icEqualBase(self, p2);
   ck_assert(r);
   //  non equal
   terminateO(p2);
   p2 = (baset*) allocSmallString("true ");
   r = self->f->icEqualBase(self, p2);
   ck_assert(!r);
   // json double
   freeO(self);
   setTopDoubleO(self, 2.2);
   terminateO(p2);
   p2 = (baset*) allocSmallString("2.2");
   r = self->f->icEqualBase(self, p2);
   ck_assert(r);
   freeO(self);
   setTopDoubleO(self, 2);
   r = self->f->icEqualBase(self, p2);
   ck_assert(!r);
   terminateO(p2);
   //  p2 is an int so not equal to double (int)2 != (double)2
   //  TODO is this reasonable?
   p2 = (baset*) allocSmallInt(2);
   r = self->f->icEqualBase(self, p2);
   ck_assert(!r);
   terminateO(p2);
   p2 = (baset*) allocSmallString("asd");
   r = self->f->icEqualBase(self, p2);
   ck_assert(!r);
   // json int
   freeO(self);
   setTopIntO(self, 2);
   terminateO(p2);
   p2 = (baset*) allocSmallString("2");
   r = self->f->icEqualBase(self, p2);
   ck_assert(r);
   terminateO(p2);
   p2 = (baset*) allocSmallString("3");
   r = self->f->icEqualBase(self, p2);
   ck_assert(!r);
   terminateO(p2);
   p2 = (baset*) allocSmallDouble(2);
   r = self->f->icEqualBase(self, p2);
   ck_assert(!r);
   terminateO(p2);
   p2 = (baset*) allocSmallString("asd");
   r = self->f->icEqualBase(self, p2);
   ck_assert(!r);
   // json string
   freeO(self);
   setTopSO(self, "asd");
   terminateO(p2);
   p2 = (baset*) allocSmallString("ASD");
   r = self->f->icEqualBase(self, p2);
   ck_assert(r);
   // empty self
   freeO(self);
   r = self->f->icEqualBase(self, p2);
   ck_assert(!r);
   //  non smallString p2
   setTopSO(self, "asd");
   terminateO(p2);
   p2 = (baset*) allocSmallBool(false);
   r = self->f->icEqualBase(self, p2);
   ck_assert(!r);
   // json dict
   freeO(self);
   setTypeDictO(self);
   self->f->setS(self, "1", "a");
   terminateO(p2);
   p2 = (baset*) allocSmallInt(12);
   r = self->f->icEqualBase(self, p2);
   ck_assert(!r);
   terminateO(p2);
   smallDictt *d = allocSmallDict();
   d->f->setS(d, "1", "A");
   p2 = (baset*) d;
   r = self->f->icEqualBase(self, p2);
   ck_assert(r);
   // json array
   freeO(self);
   setTypeArrayO(self);
   self->f->pushS(self, "a");
   terminateO(p2);
   p2 = (baset*) allocSmallInt(12);
   r = self->f->icEqualBase(self, p2);
   ck_assert(!r);
   r = self->f->icEqualBase(self, p2);
   ck_assert(!r);
   terminateO(p2);
   smallArrayt *a = allocSmallArray();
   a->f->pushS(a, "A");
   p2 = (baset*) a;
   r = self->f->icEqualBase(self, p2);
   ck_assert(r);
   // null object
   freeO(self);
   setTopSO(self, "qwe");
   r = self->f->icEqualBase(self, null);
   ck_assert(!r);
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void icEqualSmallJsonSmallDictT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallDictt* p2   = allocSmallDict();
 
   // empty json
   r = self->f->icEqualSmallDict(self, p2);
   ck_assert(!r);
   setTypeDictO(self);
   r = self->f->icEqualSmallDict(self, p2);
   ck_assert(!r);
   // equal
   self->f->setS(self, "a", "a");
   self->f->setInt(self, "b", 2);
   self->f->setInt(self, "c", 3);
   p2->f->setInt(p2, "b", 2);
   p2->f->setS(p2, "a", "A");
   p2->f->setInt(p2, "c", 3);
   r = self->f->icEqualSmallDict(self, p2);
   ck_assert(r);
   // non equal
   p2->f->setInt(p2, "b", 1);
   r = self->f->icEqualSmallDict(self, p2);
   ck_assert(!r);
   p2->f->del(p2, "b");
   r = self->f->icEqualSmallDict(self, p2);
   ck_assert(!r);
   // empty smallDict
   freeO(p2);
   ck_assert(!self->f->icEqualSmallDict(self, p2));
   // non smallDict
   terminateO(p2);
   p2 = (smallDictt*) allocSmallBool(false);
   ck_assert(!self->f->icEqualSmallDict(self, p2));
   // null
   ck_assert(!self->f->icEqualSmallDict(self, null));
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void icEqualSmallJsonSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   smallJsont *string = allocSmallJson();
 
   // empty json
   setTopSO(string, "qwe");
   r = icEqualSmallJsonO(self, string);
   ck_assert(!r);
   // equal
   setTopSO(self, "QWE");
   r = icEqualSmallJsonO(self, string);
   ck_assert(r);
   // different length
   freeO(self);
   setTopSO(self, "QWE ");
   r = icEqualSmallJsonO(self, string);
   ck_assert(!r);
   // non json string
   terminateO(string);
   string = (smallJsont*) allocSmallBool(true);
   r = icEqualSmallJsonO(self, string);
   ck_assert(!r);
   // null
   r = icEqualSmallJsonO(self, null);
   ck_assert(!r);
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icEqualSmallJsonSmallStringT(void) {
 
   bool r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt *string = allocSmallString("qwe");
 
   // empty json
   r = icEqualSmallStringO(self, string);
   ck_assert(!r);
   // equal
   setTopSO(self, "QWE");
   r = icEqualSmallStringO(self, string);
   ck_assert(r);
   // different length
   freeO(self);
   setTopSO(self, "QWE ");
   r = icEqualSmallStringO(self, string);
   ck_assert(!r);
   // empty string
   freeO(string);
   r = icEqualSmallStringO(self, string);
   ck_assert(!r);
   // non json string
   terminateO(string);
   string = (smallStringt*) allocSmallBool(true);
   r = icEqualSmallStringO(self, string);
   ck_assert(!r);
   // null
   r = icEqualSmallStringO(self, null);
   ck_assert(!r);
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icEqualSSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // empty json
   r = icEqualSO(self, "qwe");
   ck_assert(!r);
   // equal
   setTopSO(self, "QWE");
   r = icEqualSO(self, "qwe");
   ck_assert(r);
   // different length
   r = icEqualSO(self, "qwe ");
   ck_assert(!r);
   // null
   r = icEqualSO(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void icEqualCharSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "");
 
   r = icEqualCharO(self,'q');
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "q");
   r = icEqualCharO(self,'Q');
   ck_assert(r);
   // empty strings
   freeO(self);
   r = icEqualCharO(self, ' ');
   ck_assert(!r);
   // json int
   freeO(self);
   setTopIntO(self, 1);
   r = icEqualCharO(self,'1');
   ck_assert(r);
   r = icEqualCharO(self,'2');
   ck_assert(!r);
   r = icEqualCharO(self,'q');
   ck_assert(!r);
   // non json string or int
   freeO(self);
   setTypeBoolO(self);
   r = icEqualCharO(self,'2');
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void equalISSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "Ashee|");
 
   // identical strings
   ck_assert(equalISO(self, "shee", 1));
   freeO(self);
   setTopSO(self, "Ashee");
   ck_assert(equalISO(self, "shee", -4));
   // string at index shorter than string2
   ck_assert(!equalISO(self, "shee", 2));
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert(!equalISO(self, "shee", 0));
   ck_assert(equalISO(self, "", 0));
   freeO(self);
   setTopSO(self, "Ashee");
   ck_assert(!equalISO(self, "", 0));
   // index mismatch
   ck_assert(!equalISO(self, "shee", 0));
   // index outside
   ck_assert(!equalISO(self, "shee", 10));
   ck_assert(!equalISO(self, "shee", -10));
   // different strings
   ck_assert(!equalISO(self, "SH",0));
   // empty self
   freeO(self);
   ck_assert(!equalISO(self, "SH",0));
   // NULL string
   freeO(self);
   setTopSO(self, "Ashee");
   ck_assert(!equalISO(self, NULL, 0));
   terminateO(self);
 
 }
 
 
 void equalICharSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "Ashee");
 
   // identical strings
   ck_assert(equalICharO(self, 's', 1));
   ck_assert(equalICharO(self, 's', -4));
   ck_assert(!equalICharO(self, 's', 2));
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert(!equalICharO(self, 's', 0));
   ck_assert(equalICharO(self, 0, 0));
   freeO(self);
   setTopSO(self, "Ashee");
   ck_assert(!equalICharO(self, 0, 0));
   // index mismatch
   ck_assert(!equalICharO(self, 's', 0));
   // index outside
   ck_assert(!equalICharO(self, 's', 10));
   ck_assert(!equalICharO(self, 's', -10));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   ck_assert(!equalICharO(self, 'S',0));
   // NULL string
   ck_assert(!equalICharO(self, 0, 0));
   // empty self
   freeO(self);
   ck_assert(!equalICharO(self, 'S',0));
   terminateO(self);
 
 }
 
 
 void equalIJsonSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "Ashee|");
   smallJsont *string = allocSmallJson();
 
   // identical strings
   setTopSO(string, "shee");
   ck_assert(equalIJsonO(self, string, 1));
   freeO(self);
   setTopSO(self, "Ashee");
   ck_assert(equalIJsonO(self, string, -4));
   // string at index shorter than string2
   ck_assert(!equalIJsonO(self, string, 2));
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert(!equalIJsonO(self, string, 0));
   freeO(string);
   setTopSO(string, "");
   ck_assert(equalIJsonO(self, string, 0));
   freeO(self);
   setTopSO(self, "Ashee");
   ck_assert(!equalIJsonO(self, string, 0));
   // index mismatch
   freeO(string);
   setTopSO(string, "shee");
   ck_assert(!equalIJsonO(self, string, 0));
   // index outside
   ck_assert(!equalIJsonO(self, string, 10));
   ck_assert(!equalIJsonO(self, string, -10));
   // different strings
   freeO(string);
   setTopSO(string, "SH");
   ck_assert(!equalIJsonO(self, string,0));
   // non json string
   freeO(string);
   setTopIntO(string, 1);
   ck_assert(!equalIJsonO(self, string,0));
   // non json object
   terminateO(string);
   string = (smallJsont*) allocSmallInt(2);
   ck_assert(!equalIJsonO(self, string,0));
   // empty self
   terminateO(string);
   string = allocSmallJson();
   setTopSO(string, "SH");
   freeO(self);
   ck_assert(!equalIJsonO(self, string,0));
   // NULL string
   freeO(self);
   setTopSO(self, "Ashee");
   ck_assert(!equalIJsonO(self, NULL, 0));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void equalISmallStringSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "Ashee|");
   smallStringt *string = allocSmallString("shee");
 
   // identical strings
   ck_assert(equalISmallStringO(self, string, 1));
   freeO(self);
   setTopSO(self, "Ashee");
   ck_assert(equalISmallStringO(self, string, -4));
   // string at index shorter than string2
   ck_assert(!equalISmallStringO(self, string, 2));
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert(!equalISmallStringO(self, string, 0));
   setValO(string, "");
   ck_assert(equalISmallStringO(self, string, 0));
   freeO(self);
   setTopSO(self, "Ashee");
   ck_assert(!equalISmallStringO(self, string, 0));
   // index mismatch
   freeO(string);
   setValO(string, "shee");
   ck_assert(!equalISmallStringO(self, string, 0));
   // index outside
   ck_assert(!equalISmallStringO(self, string, 10));
   ck_assert(!equalISmallStringO(self, string, -10));
   // different strings
   setValO(string, "SH");
   ck_assert(!equalISmallStringO(self, string,0));
   // non smallString object
   terminateO(string);
   string = (smallStringt*) allocSmallInt(2);
   ck_assert(!equalISmallStringO(self, string,0));
   // empty self
   terminateO(string);
   string = allocSmallString("SH");
   freeO(self);
   ck_assert(!equalISmallStringO(self, string,0));
   // NULL string
   freeO(self);
   setTopSO(self, "Ashee");
   ck_assert(!equalISmallStringO(self, NULL, 0));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void startsWithSSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
 
   // identical strings
   ck_assert(startsWithSO(self, "shee"));
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert(startsWithSO(self, "shee"));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   ck_assert(!startsWithSO(self, "SH"));
   ck_assert(!startsWithSO(self, "sheep"));
   freeO(self);
   setTopSO(self, "-shee");
   ck_assert(!startsWithSO(self, "shee"));
   // NULL string
   ck_assert(!startsWithSO(self, NULL));
   // empty self
   freeO(self);
   ck_assert(!startsWithSO(self, "shee"));
   terminateO(self);
 
 }
 
 
 void startsWithCharSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
 
   // identical strings
   ck_assert(startsWithCharO(self, 's'));
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert(startsWithCharO(self, 's'));
   freeO(self);
   setTopSO(self, "");
   ck_assert(startsWithCharO(self, 0));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   ck_assert(!startsWithCharO(self, 'S'));
   freeO(self);
   setTopSO(self, "-shee");
   ck_assert(!startsWithCharO(self, 's'));
   freeO(self);
   setTopSO(self, "");
   ck_assert(!startsWithCharO(self, '0'));
   // NULL string
   freeO(self);
   setTopSO(self, "shee");
   ck_assert(!startsWithCharO(self, 0));
   // empty self
   freeO(self);
   ck_assert(!startsWithCharO(self, '0'));
   terminateO(self);
 
 }
 
 
 void startsWithSmallStringSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
   smallStringt *string = allocSmallString("shee");
 
   // identical strings
   ck_assert(startsWithSmallStringO(self, string));
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert(startsWithSmallStringO(self, string));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   setValO(string, "SH");
   ck_assert(!startsWithSmallStringO(self, string));
   setValO(string, "sheep");
   ck_assert(!startsWithSmallStringO(self, string));
   freeO(self);
   setTopSO(self, "-shee");
   setValO(string, "shee");
   ck_assert(!startsWithSmallStringO(self, string));
   // non smallString object
   terminateO(string);
   string = (smallStringt*) allocSmallInt(1);
   ck_assert(!startsWithSmallStringO(self, string));
   terminateO(string);
   string = allocSmallString("shee");
   // NULL string
   ck_assert(!startsWithSmallStringO(self, NULL));
   // empty self
   freeO(self);
   ck_assert(!startsWithSmallStringO(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void startsWithJsonSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
   smallJsont *string = allocSmallJson();
 
   // identical strings
   setTopSO(string, "shee");
   ck_assert(startsWithJsonO(self, string));
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert(startsWithJsonO(self, string));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   freeO(string);
   setTopSO(string, "SH");
   ck_assert(!startsWithJsonO(self, string));
   freeO(string);
   setTopSO(string, "sheep");
   ck_assert(!startsWithJsonO(self, string));
   freeO(self);
   setTopSO(self, "-shee");
   freeO(string);
   setTopSO(string, "shee");
   ck_assert(!startsWithJsonO(self, string));
   // non json string
   freeO(string);
   setTopIntO(string, 1);
   ck_assert(!startsWithJsonO(self, string));
   // non json object
   terminateO(string);
   string = (smallJsont*) allocSmallInt(1);
   ck_assert(!startsWithJsonO(self, string));
   terminateO(string);
   string = allocSmallJson();
   // NULL string
   ck_assert(!startsWithJsonO(self, NULL));
   // empty self
   freeO(self);
   setTopSO(string, "shee");
   ck_assert(!startsWithJsonO(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void endsWithSSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
 
   // identical strings
   ck_assert(endsWithSO(self, "shee"));
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert(endsWithSO(self, "eepy"));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   ck_assert(!endsWithSO(self, "SH"));
   ck_assert(!endsWithSO(self, "sheep"));
   freeO(self);
   setTopSO(self, "shee-");
   ck_assert(!endsWithSO(self, "shee"));
   // NULL string
   ck_assert(!endsWithSO(self, NULL));
   // empty self
   freeO(self);
   ck_assert(!endsWithSO(self, "shee"));
   terminateO(self);
 
 }
 
 
 void endsWithCharSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
 
   // identical strings
   ck_assert(endsWithCharO(self, 'e'));
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert(endsWithCharO(self, 'y'));
   freeO(self);
   setTopSO(self, "");
   ck_assert(endsWithCharO(self, 0));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   ck_assert(!endsWithCharO(self, 'E'));
   ck_assert(!endsWithCharO(self, 'p'));
   freeO(self);
   setTopSO(self, "shee-");
   ck_assert(!endsWithCharO(self, 'e'));
   freeO(self);
   setTopSO(self, "");
   ck_assert(!endsWithCharO(self, '0'));
   // NULL string
   freeO(self);
   setTopSO(self, "a");
   ck_assert(!endsWithCharO(self, 0));
   // empty self
   freeO(self);
   ck_assert(!endsWithCharO(self, '0'));
   terminateO(self);
 
 }
 
 
 void endsWithSmallStringSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
   smallStringt *string = allocSmallString("shee");
 
   // identical strings
   ck_assert(endsWithSmallStringO(self, string));
   freeO(self);
   setTopSO(self, "sheepy");
   setValO(string, "eepy");
   ck_assert(endsWithSmallStringO(self, string));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   ck_assert(!endsWithSmallStringO(self, string));
   setValO(string, "sheep");
   ck_assert(!endsWithSmallStringO(self, string));
   freeO(self);
   setTopSO(self, "shee-");
   setValO(string, "shee");
   ck_assert(!endsWithSmallStringO(self, string));
   // non smallString object
   terminateO(string);
   string = (smallStringt*) allocSmallInt(1);
   ck_assert(!endsWithSmallStringO(self, string));
   terminateO(string);
   string = allocSmallString("shee");
   // NULL string
   ck_assert(!endsWithSmallStringO(self, NULL));
   // empty self
   freeO(self);
   ck_assert(!endsWithSmallStringO(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void endsWithJsonSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
   smallJsont *string = allocSmallJson();
 
   // identical strings
   setTopSO(string, "shee");
   ck_assert(endsWithJsonO(self, string));
   freeO(self);
   setTopSO(self, "sheepy");
   freeO(string);
   setTopSO(string, "eepy");
   ck_assert(endsWithJsonO(self, string));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   freeO(string);
   setTopSO(string, "SH");
   ck_assert(!endsWithJsonO(self, string));
   freeO(string);
   setTopSO(string, "sheep");
   ck_assert(!endsWithJsonO(self, string));
   freeO(self);
   setTopSO(self, "shee-");
   freeO(string);
   setTopSO(string, "shee");
   ck_assert(!endsWithJsonO(self, string));
   // non json string
   freeO(string);
   setTopIntO(string, 1);
   ck_assert(!endsWithJsonO(self, string));
   // non json object
   terminateO(string);
   string = (smallJsont*) allocSmallInt(1);
   ck_assert(!endsWithJsonO(self, string));
   terminateO(string);
   string = allocSmallJson();
   setTopSO(string, "shee");
   // NULL string
   ck_assert(!endsWithJsonO(self, NULL));
   // empty self
   freeO(self);
   ck_assert(!endsWithJsonO(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void countSSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "sheepy");
 
   // positive count
   ck_assert_int_eq(countSO(self, "shee"), 1);
   freeO(self);
   setTopSO(self, "aaa aaa");
   ck_assert_int_eq(countSO(self, "a"), 6);
   ck_assert_int_eq(countSO(self, "aa"), 2);
   // 0 count
   freeO(self);
   setTopSO(self, "shee");
   ck_assert_int_eq(countSO(self, "SH"), 0);
   ck_assert_int_eq(countSO(self, "sheepy"), 0);
   freeO(self);
   setTopSO(self, "aaa aaa");
   ck_assert_int_eq(countSO(self, "ab"), 0);
   // empty string
   ck_assert_int_eq(countSO(self, ""), -1);
   // NULL string
   ck_assert_int_eq(countSO(self, NULL), -1);
   // empty self
   freeO(self);
   ck_assert_int_eq(countSO(self, "ab"), -1);
   terminateO(self);
 
 }
 
 
 void countCharSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
 
   // positive count
   ck_assert_int_eq(countCharO(self, 's'), 1);
   freeO(self);
   setTopSO(self, "aaa aaa");
   ck_assert_int_eq(countCharO(self, 'a'), 6);
   // 0 count
   freeO(self);
   setTopSO(self, "shee");
   ck_assert_int_eq(countCharO(self, 'S'), 0);
   ck_assert_int_eq(countCharO(self, 'y'), 0);
   freeO(self);
   setTopSO(self, "aaa aaa");
   ck_assert_int_eq(countCharO(self, 'b'), 0);
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert_int_eq(countCharO(self, 'a'), 0);
   ck_assert_int_eq(countCharO(self, 0), -1);
   // NULL string
   freeO(self);
   setTopSO(self, "a");
   ck_assert_int_eq(countCharO(self, 0), -1);
   // empty self
   freeO(self);
   ck_assert_int_eq(countCharO(self, 'a'), -1);
   terminateO(self);
 
 }
 
 
 void countSmallStringSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "sheepy");
   smallStringt *string = allocSmallString("shee");
 
   // positive count
   ck_assert_int_eq(countSmallStringO(self, string), 1);
   freeO(self);
   setTopSO(self, "aaa aaa");
   setValO(string, "a");
   ck_assert_int_eq(countSmallStringO(self, string), 6);
   setValO(string, "aa");
   ck_assert_int_eq(countSmallStringO(self, string), 2);
   // 0 count
   freeO(self);
   setTopSO(self, "shee");
   setValO(string, "SH");
   ck_assert_int_eq(countSmallStringO(self, string), 0);
   setValO(string, "sheepy");
   ck_assert_int_eq(countSmallStringO(self, string), 0);
   freeO(self);
   setTopSO(self, "aaa aaa");
   setValO(string, "ab");
   ck_assert_int_eq(countSmallStringO(self, string), 0);
   // non json object
   terminateO(string);
   string = (smallStringt*) allocSmallInt(1);
   ck_assert_int_eq(countSmallStringO(self, string), -1);
   terminateO(string);
   string = allocSmallString("");
   // empty string
   ck_assert_int_eq(countSmallStringO(self, string), -1);
   freeO(string);
   ck_assert_int_eq(countSmallStringO(self, string), -1);
   // NULL string
   ck_assert_int_eq(countSmallStringO(self, NULL), -1);
   // empty self
   freeO(self);
   setValO(string, "ab");
   ck_assert_int_eq(countSmallStringO(self, string), -1);
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void countJsonSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "sheepy");
   smallJsont *string = allocSmallJson();
 
   // positive count
   setTopSO(string, "shee");
   ck_assert_int_eq(countJsonO(self, string), 1);
   freeO(self);
   setTopSO(self, "aaa aaa");
   freeO(string);
   setTopSO(string, "a");
   ck_assert_int_eq(countJsonO(self, string), 6);
   freeO(string);
   setTopSO(string, "aa");
   ck_assert_int_eq(countJsonO(self, string), 2);
   // 0 count
   freeO(self);
   setTopSO(self, "shee");
   freeO(string);
   setTopSO(string, "SH");
   ck_assert_int_eq(countJsonO(self, string), 0);
   freeO(string);
   setTopSO(string, "sheepy");
   ck_assert_int_eq(countJsonO(self, string), 0);
   freeO(self);
   setTopSO(self, "aaa aaa");
   freeO(string);
   setTopSO(string, "ab");
   ck_assert_int_eq(countJsonO(self, string), 0);
   // non json string
   freeO(string);
   setTopIntO(string, -1);
   ck_assert_int_eq(countJsonO(self, string), -1);
   // non json object
   terminateO(string);
   string = (smallJsont*) allocSmallInt(1);
   ck_assert_int_eq(countJsonO(self, string), -1);
   terminateO(string);
   string = allocSmallJson();
   // empty string
   setTopSO(string, "");
   ck_assert_int_eq(countJsonO(self, string), -1);
   // NULL string
   ck_assert_int_eq(countJsonO(self, NULL), -1);
   // empty self
   freeO(self);
   freeO(string);
   setTopSO(string, "ab");
   ck_assert_int_eq(countJsonO(self, string), -1);
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icStartsWithSSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
 
   // identical strings
   ck_assert(icStartsWithSO(self, "shee"));
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert(icStartsWithSO(self, "shee"));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   ck_assert(icStartsWithSO(self, "SH"));
   ck_assert(!icStartsWithSO(self, "sheep"));
   freeO(self);
   setTopSO(self, "-shee");
   ck_assert(!icStartsWithSO(self, "shee"));
   // NULL string
   ck_assert(!icStartsWithSO(self, NULL));
   // empty self
   freeO(self);
   ck_assert(!icStartsWithSO(self, "shee"));
   terminateO(self);
 
 }
 
 
 void icStartsWithCharSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
 
   // identical strings
   ck_assert(icStartsWithCharO(self, 's'));
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert(icStartsWithCharO(self, 's'));
   freeO(self);
   setTopSO(self, "");
   ck_assert(icStartsWithCharO(self, 0));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   ck_assert(icStartsWithCharO(self, 'S'));
   freeO(self);
   setTopSO(self, "-shee");
   ck_assert(!icStartsWithCharO(self, 's'));
   freeO(self);
   setTopSO(self, "");
   ck_assert(!icStartsWithCharO(self, '0'));
   // NULL string
   freeO(self);
   setTopSO(self, "shee");
   ck_assert(!icStartsWithCharO(self, 0));
   // empty self
   freeO(self);
   ck_assert(!icStartsWithCharO(self, '0'));
   terminateO(self);
 
 }
 
 
 void icStartsWithSmallStringSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
   smallStringt *string = allocSmallString("shee");
 
   // identical strings
   ck_assert(icStartsWithSmallStringO(self, string));
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert(icStartsWithSmallStringO(self, string));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   setValO(string, "SH");
   ck_assert(icStartsWithSmallStringO(self, string));
   setValO(string, "sheep");
   ck_assert(!icStartsWithSmallStringO(self, string));
   freeO(self);
   setTopSO(self, "-shee");
   setValO(string, "shee");
   ck_assert(!icStartsWithSmallStringO(self, string));
   // non smallString object
   terminateO(string);
   string = (smallStringt*) allocSmallInt(1);
   ck_assert(!icStartsWithSmallStringO(self, string));
   terminateO(string);
   string = allocSmallString("shee");
   // NULL string
   ck_assert(!icStartsWithSmallStringO(self, NULL));
   // empty self
   freeO(self);
   ck_assert(!icStartsWithSmallStringO(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icStartsWithJsonSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
   smallJsont *string = allocSmallJson();
 
   // identical strings
   setTopSO(string, "shee");
   ck_assert(icStartsWithJsonO(self, string));
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert(icStartsWithJsonO(self, string));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   freeO(string);
   setTopSO(string, "SH");
   ck_assert(icStartsWithJsonO(self, string));
   freeO(string);
   setTopSO(string, "sheep");
   ck_assert(!icStartsWithJsonO(self, string));
   freeO(self);
   setTopSO(self, "-shee");
   freeO(string);
   setTopSO(string, "shee");
   ck_assert(!icStartsWithJsonO(self, string));
   // non json string
   freeO(string);
   setTopIntO(string, 1);
   ck_assert(!icStartsWithJsonO(self, string));
   // non json object
   terminateO(string);
   string = (smallJsont*) allocSmallInt(1);
   ck_assert(!icStartsWithJsonO(self, string));
   terminateO(string);
   string = allocSmallJson();
   // NULL string
   ck_assert(!icStartsWithJsonO(self, NULL));
   // empty self
   freeO(self);
   setTopSO(string, "shee");
   ck_assert(!icStartsWithJsonO(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icEndsWithSSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
 
   // identical strings
   ck_assert(icEndsWithSO(self, "shee"));
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert(icEndsWithSO(self, "EEPY"));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   ck_assert(!icEndsWithSO(self, "SH"));
   ck_assert(!icEndsWithSO(self, "sheep"));
   freeO(self);
   setTopSO(self, "shee-");
   ck_assert(!icEndsWithSO(self, "shee"));
   // NULL string
   ck_assert(!icEndsWithSO(self, NULL));
   // empty self
   freeO(self);
   ck_assert(!icEndsWithSO(self, "shee"));
   terminateO(self);
 
 }
 
 
 void icEndsWithCharSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
 
   // identical strings
   ck_assert(icEndsWithCharO(self, 'e'));
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert(icEndsWithCharO(self, 'y'));
   freeO(self);
   setTopSO(self, "");
   ck_assert(icEndsWithCharO(self, 0));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   ck_assert(icEndsWithCharO(self, 'E'));
   ck_assert(!icEndsWithCharO(self, 'p'));
   freeO(self);
   setTopSO(self, "shee-");
   ck_assert(!icEndsWithCharO(self, 'e'));
   freeO(self);
   setTopSO(self, "");
   ck_assert(!icEndsWithCharO(self, '0'));
   // NULL string
   freeO(self);
   setTopSO(self, "a");
   ck_assert(!icEndsWithCharO(self, 0));
   // empty self
   freeO(self);
   ck_assert(!icEndsWithCharO(self, '0'));
   terminateO(self);
 
 }
 
 
 void icEndsWithSmallStringSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
   smallStringt *string = allocSmallString("shee");
 
   // identical strings
   ck_assert(icEndsWithSmallStringO(self, string));
   freeO(self);
   setTopSO(self, "sheepy");
   setValO(string, "EEPY");
   ck_assert(icEndsWithSmallStringO(self, string));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   ck_assert(!icEndsWithSmallStringO(self, string));
   setValO(string, "sheep");
   ck_assert(!icEndsWithSmallStringO(self, string));
   freeO(self);
   setTopSO(self, "shee-");
   setValO(string, "shee");
   ck_assert(!icEndsWithSmallStringO(self, string));
   // non smallString object
   terminateO(string);
   string = (smallStringt*) allocSmallInt(1);
   ck_assert(!icEndsWithSmallStringO(self, string));
   terminateO(string);
   string = allocSmallString("shee");
   // NULL string
   ck_assert(!icEndsWithSmallStringO(self, NULL));
   // empty self
   freeO(self);
   ck_assert(!icEndsWithSmallStringO(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icEndsWithJsonSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
   smallJsont *string = allocSmallJson();
 
   // identical strings
   setTopSO(string, "shee");
   ck_assert(icEndsWithJsonO(self, string));
   freeO(self);
   setTopSO(self, "sheepy");
   freeO(string);
   setTopSO(string, "EEPY");
   ck_assert(icEndsWithJsonO(self, string));
   // different strings
   freeO(self);
   setTopSO(self, "shee");
   freeO(string);
   setTopSO(string, "SH");
   ck_assert(!icEndsWithJsonO(self, string));
   freeO(string);
   setTopSO(string, "sheep");
   ck_assert(!icEndsWithJsonO(self, string));
   freeO(self);
   setTopSO(self, "shee-");
   freeO(string);
   setTopSO(string, "shee");
   ck_assert(!icEndsWithJsonO(self, string));
   // non json string
   freeO(string);
   setTopIntO(string, 1);
   ck_assert(!icEndsWithJsonO(self, string));
   // non json object
   terminateO(string);
   string = (smallJsont*) allocSmallInt(1);
   ck_assert(!icEndsWithJsonO(self, string));
   terminateO(string);
   string = allocSmallJson();
   setTopSO(string, "shee");
   // NULL string
   ck_assert(!icEndsWithJsonO(self, NULL));
   // empty self
   freeO(self);
   ck_assert(!icEndsWithJsonO(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icCountSSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "sheepy");
 
   // positive count
   ck_assert_int_eq(icCountSO(self, "shee"), 1);
   freeO(self);
   setTopSO(self, "aaa aaa");
   ck_assert_int_eq(icCountSO(self, "a"), 6);
   ck_assert_int_eq(icCountSO(self, "Aa"), 2);
   // 0 icCount
   freeO(self);
   setTopSO(self, "shee");
   ck_assert_int_eq(icCountSO(self, "SH"), 1);
   ck_assert_int_eq(icCountSO(self, "sheepy"), 0);
   freeO(self);
   setTopSO(self, "aaa aaa");
   ck_assert_int_eq(icCountSO(self, "ab"), 0);
   // empty string
   ck_assert_int_eq(icCountSO(self, ""), -1);
   // NULL string
   ck_assert_int_eq(icCountSO(self, NULL), -1);
   // empty self
   freeO(self);
   ck_assert_int_eq(icCountSO(self, "ab"), -1);
   terminateO(self);
 
 }
 
 
 void icCountCharSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "shee");
 
   // positive count
   ck_assert_int_eq(icCountCharO(self, 's'), 1);
   freeO(self);
   setTopSO(self, "aaa aaa");
   ck_assert_int_eq(icCountCharO(self, 'a'), 6);
   // 0 icCount
   freeO(self);
   setTopSO(self, "shee");
   ck_assert_int_eq(icCountCharO(self, 'S'), 1);
   ck_assert_int_eq(icCountCharO(self, 'y'), 0);
   freeO(self);
   setTopSO(self, "aaa aaa");
   ck_assert_int_eq(icCountCharO(self, 'b'), 0);
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert_int_eq(icCountCharO(self, 'a'), 0);
   ck_assert_int_eq(icCountCharO(self, 0), -1);
   // NULL string
   freeO(self);
   setTopSO(self, "a");
   ck_assert_int_eq(icCountCharO(self, 0), -1);
   // empty self
   freeO(self);
   ck_assert_int_eq(icCountCharO(self, 'a'), -1);
   terminateO(self);
 
 }
 
 
 void icCountSmallStringSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "sheepy");
   smallStringt *string = allocSmallString("shee");
 
   // positive count
   ck_assert_int_eq(icCountSmallStringO(self, string), 1);
   freeO(self);
   setTopSO(self, "aaa aaa");
   setValO(string, "a");
   ck_assert_int_eq(icCountSmallStringO(self, string), 6);
   setValO(string, "aa");
   ck_assert_int_eq(icCountSmallStringO(self, string), 2);
   // 0 icCount
   freeO(self);
   setTopSO(self, "shee");
   setValO(string, "SH");
   ck_assert_int_eq(icCountSmallStringO(self, string), 1);
   setValO(string, "sheepy");
   ck_assert_int_eq(icCountSmallStringO(self, string), 0);
   freeO(self);
   setTopSO(self, "aaa aaa");
   setValO(string, "ab");
   ck_assert_int_eq(icCountSmallStringO(self, string), 0);
   // non json object
   terminateO(string);
   string = (smallStringt*) allocSmallInt(1);
   ck_assert_int_eq(icCountSmallStringO(self, string), -1);
   terminateO(string);
   string = allocSmallString("");
   // empty string
   ck_assert_int_eq(icCountSmallStringO(self, string), -1);
   freeO(string);
   ck_assert_int_eq(icCountSmallStringO(self, string), -1);
   // NULL string
   ck_assert_int_eq(icCountSmallStringO(self, NULL), -1);
   // empty self
   freeO(self);
   setValO(string, "ab");
   ck_assert_int_eq(icCountSmallStringO(self, string), -1);
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icCountJsonSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "sheepy");
   smallJsont *string = allocSmallJson();
 
   // positive count
   setTopSO(string, "shee");
   ck_assert_int_eq(icCountJsonO(self, string), 1);
   freeO(self);
   setTopSO(self, "aaa aaa");
   freeO(string);
   setTopSO(string, "a");
   ck_assert_int_eq(icCountJsonO(self, string), 6);
   freeO(string);
   setTopSO(string, "aa");
   ck_assert_int_eq(icCountJsonO(self, string), 2);
   // 0 icCount
   freeO(self);
   setTopSO(self, "shee");
   freeO(string);
   setTopSO(string, "SH");
   ck_assert_int_eq(icCountJsonO(self, string), 1);
   freeO(string);
   setTopSO(string, "sheepy");
   ck_assert_int_eq(icCountJsonO(self, string), 0);
   freeO(self);
   setTopSO(self, "aaa aaa");
   freeO(string);
   setTopSO(string, "ab");
   ck_assert_int_eq(icCountJsonO(self, string), 0);
   // non json string
   freeO(string);
   setTopIntO(string, -1);
   ck_assert_int_eq(icCountJsonO(self, string), -1);
   // non json object
   terminateO(string);
   string = (smallJsont*) allocSmallInt(1);
   ck_assert_int_eq(icCountJsonO(self, string), -1);
   terminateO(string);
   string = allocSmallJson();
   // empty string
   setTopSO(string, "");
   ck_assert_int_eq(icCountJsonO(self, string), -1);
   // NULL string
   ck_assert_int_eq(icCountJsonO(self, NULL), -1);
   // empty self
   freeO(self);
   freeO(string);
   setTopSO(string, "ab");
   ck_assert_int_eq(icCountJsonO(self, string), -1);
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void isNumberSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // number
   freeO(self);
   setTopSO(self, "-12.3");
   ck_assert(isNumberO(self));
   freeO(self);
   setTopSO(self, "-123");
   ck_assert(isNumberO(self));
   freeO(self);
   setTopSO(self, "123");
   ck_assert(isNumberO(self));
   freeO(self);
   setTopSO(self, "1e23");
   ck_assert(isNumberO(self));
   freeO(self);
   setTopSO(self, "12E-3");
   ck_assert(isNumberO(self));
   freeO(self);
   setTopSO(self, ".123");
   ck_assert(isNumberO(self));
   freeO(self);
   setTopSO(self, "-.123");
   ck_assert(isNumberO(self));
   freeO(self);
   setTopSO(self, "1E+32");
   ck_assert(isNumberO(self));
   // not a number
   freeO(self);
   setTopSO(self, ".12e3");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "-.12e3");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "-1-23");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "123-");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "-");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "-123.");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "-1.2.3");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "1-2.3");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "12..3");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, ".12.3");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, ".");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "E12");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "E1E2");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "E1.2");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "1E");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "1E2.3");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "1-");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "1E-");
   ck_assert(!isNumberO(self));
   freeO(self);
   setTopSO(self, "lib123sheepy");
   ck_assert(!isNumberO(self));
   // string without number
   freeO(self);
   setTopSO(self, "s");
   ck_assert(!isNumberO(self));
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert(!isNumberO(self));
   // NULL string
   freeO(self);
   ck_assert(!isNumberO(self));
   terminateO(self);
 
 }
 
 
 void isIntSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // integer
   freeO(self);
   setTopSO(self, "-123");
   ck_assert(isIntO(self));
   freeO(self);
   setTopSO(self, "123");
   ck_assert(isIntO(self));
   // not a integer
   freeO(self);
   setTopSO(self, "1e23");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, "12E-3");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, "-12.3");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, "-1-23");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, "123-");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, "-");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, "-123.");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, ".123");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, "-1.2.3");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, "1-2.3");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, "12..3");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, ".");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, "1E");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, "1-");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, "1E-");
   ck_assert(!isIntO(self));
   freeO(self);
   setTopSO(self, "lib123sheepy");
   ck_assert(!isIntO(self));
   // string without number
   freeO(self);
   setTopSO(self, "s");
   ck_assert(!isIntO(self));
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert(!isIntO(self));
   // NULL string
   freeO(self);
   ck_assert(!isIntO(self));
   terminateO(self);
 
 }
 
 
 void parseIntSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // number
   freeO(self);
   setTopSO(self, "123sheepy");
   ck_assert_int_eq(parseIntO(self), 123);
   freeO(self);
   setTopSO(self, "lib123sheepy");
   ck_assert_int_eq(parseIntO(self), 123);
   freeO(self);
   setTopSO(self, "-123");
   ck_assert_int_eq(parseIntO(self), -123);
   // out of range - TODO check stderr
   freeO(self);
   setTopSO(self, "999999999999999999999999999999999999999");
   parseIntO(self);
   // string without number
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert_int_eq(parseIntO(self), 0);
   // NULL string
   freeO(self);
   ck_assert_int_eq(parseIntO(self), 0);
   terminateO(self);
 
 }
 
 
 void parseDoubleSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // number
   freeO(self);
   setTopSO(self, "123.2sheepy");
   ck_assert_int_eq(parseDoubleO(self), 123);
   freeO(self);
   setTopSO(self, "lib123sheepy");
   ck_assert_int_eq(parseDoubleO(self), 123);
   freeO(self);
   setTopSO(self, "-123");
   ck_assert_int_eq(parseDoubleO(self), -123);
   // out of range - TODO check stderr
   freeO(self);
   setTopSO(self, "999999999999999999999999999999999999999");
   parseDoubleO(self);
   // string without number
   freeO(self);
   setTopSO(self, "sheepy");
   ck_assert_int_eq(parseDoubleO(self), 0);
   // NULL string
   freeO(self);
   ck_assert_int_eq(parseDoubleO(self), 0);
   terminateO(self);
 
 }
 
 
 void intToSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // number
   r = intToO(self, 123);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "123");
   free(s);
   r = intToO(self, -465464123);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "-465464123");
   free(s);
   terminateO(self);
 
 }
 
 
 void doubleToSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // number
   r = doubleToO(self, 123.4);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "1.234000e+02");
   free(s);
   r = doubleToO(self, -4652445e5);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "-4.652445e+11");
   free(s);
   terminateO(self);
 
 }
 
 
 void upperSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "sheepy");
 
   // string
   r = upperO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "SHEEPY");
   free(s);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(upperO(self), NULL);
   terminateO(self);
 
 }
 
 
 void lowerSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "SHeePY");
 
   // string
   r = lowerO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "sheepy");
   free(s);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(lowerO(self), NULL);
   terminateO(self);
 
 }
 
 
 void trimSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // no spaces
   freeO(self);
   setTopSO(self, "SHeePY");
   r = trimO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "SHeePY");
   free(s);
   // heading spaces
   freeO(self);
   setTopSO(self, "  SHeePY");
   r = trimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "SHeePY");
   free(s);
   // trailing spaces
   freeO(self);
   setTopSO(self, "SHeePY	");
   r = trimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "SHeePY");
   free(s);
   // string with spaces in the middle
   freeO(self);
   setTopSO(self, "	SHe ePY	");
   r = trimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "SHe ePY");
   free(s);
   // all spaces
   freeO(self);
   setTopSO(self, "	 	");
   r = trimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = trimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(trimO(self), NULL);
   // json dict
   freeO(self);
   // empty self
   setTypeDictO(self);
   r = trimO(self);
   ck_assert_ptr_ne(r, null);
   self->f->setS(self, "1", "2");
   self->f->setS(self, "3", "4");
   self->f->delElem(self, "3");
   r = trimO(self);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(self), 1);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"2\"}");
   free(s);
   self->f->delElem(self, "1");
   r = trimO(self);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(self), 0);
   s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   // json array
   freeO(self);
   self->f->pushS(self, "qwe");
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   ck_assert_uint_eq(lenO(self), 3);
   delElemIndexO(self, 0);
   delElemIndexO(self, 1);
   r = trimO(self);
   ck_assert_uint_eq(lenO(self), 1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[123]");
   free(s);
   terminateO(self);
 
 }
 
 
 void lTrimSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // no spaces
   freeO(self);
   setTopSO(self, "SHeePY");
   r = lTrimO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "SHeePY");
   free(s);
   // heading spaces
   freeO(self);
   setTopSO(self, "  SHeePY");
   r = lTrimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "SHeePY");
   free(s);
   // trailing spaces
   freeO(self);
   setTopSO(self, "SHeePY	");
   r = lTrimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "SHeePY	");
   free(s);
   // string with spaces in the middle
   freeO(self);
   setTopSO(self, "	SHe ePY	");
   r = lTrimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "SHe ePY	");
   free(s);
   // all spaces
   freeO(self);
   setTopSO(self, "	 	");
   r = lTrimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   freeO(self);
   setTopSO(self, "");
   r = lTrimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(lTrimO(self), NULL);
   terminateO(self);
 
 }
 
 
 void rTrimSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // no spaces
   freeO(self);
   setTopSO(self, "SHeePY");
   r = rTrimO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "SHeePY");
   free(s);
   // heading spaces
   freeO(self);
   setTopSO(self, "  SHeePY");
   r = rTrimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "  SHeePY");
   free(s);
   // trailing spaces
   freeO(self);
   setTopSO(self, "SHeePY	");
   r = rTrimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "SHeePY");
   free(s);
   // string with spaces in the middle
   freeO(self);
   setTopSO(self, "	SHe ePY	");
   r = rTrimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "	SHe ePY");
   free(s);
   // all spaces
   freeO(self);
   setTopSO(self, "	 	");
   r = rTrimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = rTrimO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(rTrimO(self), NULL);
   terminateO(self);
 
 }
 
 
 void keysSmallJsonT(void) {
 
   char** r;
   smallJsont *self = allocG(rtSmallJsont);
 
   self->f->setS(self, "1", "2");
   self->f->setS(self, "3", "4");
   r = keysO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringListSGF(r);
   ck_assert_str_eq(s, "[\"1\",\"3\"]");
   free(s);
   listFreeS(r);
   // empty self
   freeO(self);
   r = keysO(self);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = keysO(self);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void keysSmallStringSmallJsonT(void) {
 
   smallArrayt* r;
   smallJsont *self = allocSmallJson();
 
   self->f->setS(self, "1", "2");
   self->f->setS(self, "3", "4");
   r = keysSmallStringO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"1\",\"3\"]");
   free(s);
   terminateO(r);
   // empty self
   freeO(self);
   r = keysSmallStringO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void valuesSmallJsonT(void) {
 
   smallArrayt* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // empty json
   r = valuesO(self);
   ck_assert_ptr_eq(r, null);
   setTypeDictO(self);
   r = valuesO(self);
   ck_assert_ptr_eq(r, null);
   // values
   self->f->setUndefined(self, "qwe");
   self->f->setS(self, "123", "sheepy");
   r = valuesO(self);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[null,\"sheepy\"]");
   free(s);
   smashO(r);
   terminateO(self);
 
 }
 
 
 void compactSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = compactO(self);
   ck_assert_ptr_eq(r, NULL);
   // add and remove elements
   self->f->pushUndefined(self);
   //  null element
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushBool(self, true);
   createSmallContainer(c);
   self->f->pushSmallContainer(self, &c);
   //  empty dict
   createSmallDict(d);
   self->f->pushDict(self, &d);
   resetO(&d);
   (&d)->f->setInt(&d, "a", 1);
   self->f->pushDict(self, &d);
   self->f->pushDouble(self, 2);
   self->f->pushInt(self, 5);
   self->f->pushS(self, "   ");
   self->f->pushS(self, "asd");
   //  empty Array
   createSmallArray(a);
   self->f->pushArray(self, &a);
   resetO(&a);
   (&a)->f->pushInt(&a, 1);
   self->f->pushArray(self, &a);
   //  empty bytes
   createSmallBytes(b);
   self->f->pushSmallBytes(self, &b);
   smallBytest *B = allocSmallBytes("asd", 4);
   self->f->pushNFreeSmallBytes(self, B);
   r = compactO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_int_eq(lenO(r), 8);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[true,\"<data container>\",{\"a\":1},2.000000e+00,5,\"asd\",[1],[0x61,0x73,0x64,0x00]]");
   free(s);
   // array with blank elements becomes empty after compact
   // self->topA should not be null
   // self->topA should an empty sArray to avoid issues with the setP function
   self->f->free(self);
   self->f->pushS(self, "  ");
   self->f->pushS(self, "");
   r = compactO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_ptr_ne(r->topA, NULL);
   ck_assert_int_eq(lenO(r), 0);
   s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   // empty array
   emptyO(self);
   r = compactO(self);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void isEmptySmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = isEmptyO(self);
   ck_assert(r);
   self->f->setInt(self, "a", 1);
   r = isEmptyO(self);
   ck_assert(!r);
   self->f->delElem(self, "a");
   r = isEmptyO(self);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void isBlankSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // json dict
   setTypeDictO(self);
   r = isBlankO(self);
   ck_assert(r);
   // json string
   freeO(self);
   setTopSO(self, " ");
   r = isBlankO(self);
   ck_assert(r);
   // json array
   freeO(self);
   // bool
   self->f->pushBool(self, true);
   r = isBlankO(self);
   ck_assert(!r);
   // container
   emptyO(self);
   createSmallContainer(c);
   self->f->pushSmallContainer(self, &c);
   r = isBlankO(self);
   ck_assert(!r);
   // blank dict
   emptyO(self);
   createSmallDict(d);
   self->f->pushDict(self, &d);
   r = isBlankO(self);
   ck_assert(r);
   // dict
   emptyO(self);
   resetO(&d);
   (&d)->f->setInt(&d, "a", 1);
   self->f->pushDict(self, &d);
   r = isBlankO(self);
   ck_assert(!r);
   // double
   emptyO(self);
   self->f->pushDouble(self, 0);
   r = isBlankO(self);
   ck_assert(!r);
   // int
   emptyO(self);
   self->f->pushInt(self, 0);
   r = isBlankO(self);
   ck_assert(!r);
   // blank string
   emptyO(self);
   self->f->pushS(self, "   ");
   r = isBlankO(self);
   ck_assert(r);
   // string
   emptyO(self);
   self->f->pushS(self, "asd");
   r = isBlankO(self);
   ck_assert(!r);
   // blank dict
   emptyO(self);
   createSmallArray(a);
   self->f->pushArray(self, &a);
   r = isBlankO(self);
   ck_assert(r);
   // dict
   emptyO(self);
   resetO(&a);
   (&a)->f->pushInt(&a, 1);
   self->f->pushArray(self, &a);
   r = isBlankO(self);
   ck_assert(!r);
   // blank Bytes
   emptyO(self);
   createSmallBytes(b);
   self->f->pushSmallBytes(self, &b);
   r = isBlankO(self);
   ck_assert(r);
   // Bytes
   emptyO(self);
   smallBytest *B = allocSmallBytes("asd", 4);
   self->f->pushNFreeSmallBytes(self, B);
   r = isBlankO(self);
   ck_assert(!r);
   // empty array
   emptyO(self);
   r = isBlankO(self);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 bool fef(void *closure UNUSED, baset *e) {
   bool r = true;
   if   (isOUndefined(e)) r = true;
   elif (isOSmallInt(e)) r = false;
   else {
     static u16 c;
     r = !c;
     c++;
   }
   return r;
 }
 
 void forEachSmallJsonFT(void) {
 
   smallJsont *self = allocSmallJson();
 
   // empty array
   // direct return
   self->f->forEach(self, NULL, fef);
   setTypeArrayO(self);
   self->f->forEach(self, NULL, fef);
   // array with elements
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   //  base class
   createAllocateSmallInt(i);
   i->type = "userclass";
   self->f->push(self, (baset*)i);
   createAllocateSmallInt(j);
   j->type = "userclass";
   self->f->push(self, (baset*)j);
   delElemIndexO(self, 1);
   self->f->pushInt(self, 2);
   self->f->forEach(self, NULL, fef);
   self->f->del(self, 2, 4);
   self->f->forEach(self, NULL, fef);
   terminateO(self);
 
 }
 
 
 bool ef(void *closure UNUSED, u64 i UNUSED, baset *e) {
   bool r = true;
   if   (isOUndefined(e)) r = true;
   elif (isOSmallInt(e)) r = false;
   else {
     static u16 c;
     r = !c;
     c++;
   }
   return r;
 }
 
 void enumerateSmallJsonFT(void) {
 
   smallJsont *self = allocSmallJson();
 
   // empty array
   // direct return
   self->f->enumerate(self, NULL, ef);
   setTypeArrayO(self);
   self->f->enumerate(self, NULL, ef);
   // enumerate elements
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   //  base class
   createAllocateSmallInt(i);
   i->type = "userclass";
   self->f->push(self, (baset*)i);
   createAllocateSmallInt(j);
   j->type = "userclass";
   self->f->push(self, (baset*)j);
   delElemIndexO(self, 1);
   self->f->pushInt(self, 2);
   self->f->enumerate(self, NULL, ef);
   self->f->del(self, 2, 4);
   self->f->enumerate(self, NULL, ef);
   terminateO(self);
 
 }
 
 
 bool enumerateElement(void *closure, char *key UNUSED, baset *element UNUSED) {
   int *c = closure;
   (*c)++;
   return *c != 2 ? true : false;
 }
 
 void enumerateDictSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
   int closure      = 0;
 
   self->f->enumerateDict(self, &closure, enumerateElement);
   self->f->setInt(self, "a", 1);
   self->f->setInt(self, "b", 2);
   self->f->setInt(self, "c", 3);
   self->f->delElem(self, "a");
   self->f->enumerateDict(self, &closure, enumerateElement);
   ck_assert_int_eq(closure, 2);
   // baset object in container
   closure = -2;
   smallIntt *i = allocSmallInt(2);
   i->type = "randomClass";
   self->f->set(self, "d", (baset*)i);
   i = allocSmallInt(3);
   i->type = "randomClass";
   self->f->set(self, "e", (baset*)i);
   self->f->enumerateDict(self, &closure, enumerateElement);
   ck_assert_int_eq(closure, 2);
   terminateO(self);
 
 }
 
 
 void joinSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
 
   // join non string objects
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   r = joinO(self, ";");
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null;123");
   free(s);
   // join strings
   emptyO(self);
   self->f->pushS(self, "a");
   self->f->pushS(self, "b");
   self->f->pushS(self, "c");
   self->f->pushS(self, "d");
   delElemIndexO(self, 1);
   r = joinO(self, ";");
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "a;c;d");
   free(s);
   // null delimiter
   r = joinO(self, NULL);
   ck_assert_ptr_eq(r, NULL);
   // empty array
   emptyO(self);
   r = joinO(self, ";");
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   r = joinO(self, ";");
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void joinCharSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
 
   // join non string objects
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   r = joinCharO(self, ';');
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null;123");
   free(s);
   // join strings
   emptyO(self);
   self->f->pushS(self, "a");
   self->f->pushS(self, "b");
   self->f->pushS(self, "c");
   self->f->pushS(self, "d");
   delElemIndexO(self, 1);
   r = joinCharO(self, ';');
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "a;c;d");
   free(s);
   // empty array
   emptyO(self);
   r = joinCharO(self, ';');
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void joinSmallJsonSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
   smallJsont* delim = allocSmallJson();
 
   // join non string objects
   setTopSO(delim, ";");
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   r = self->f->joinSmallJson(self, delim);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null;123");
   free(s);
   // join strings
   emptyO(self);
   self->f->pushS(self, "a");
   self->f->pushS(self, "b");
   self->f->pushS(self, "c");
   self->f->pushS(self, "d");
   delElemIndexO(self, 1);
   r = self->f->joinSmallJson(self, delim);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "a;c;d");
   free(s);
   // delimiter not a string
   freeO(delim);
   setTopIntO(delim, 1);
   r = self->f->joinSmallJson(self, delim);
   ck_assert_ptr_eq(r, NULL);
   // non smallJson object
   terminateO(delim);
   delim = (smallJsont*) allocSmallInt(2);
   r = self->f->joinSmallJson(self, delim);
   ck_assert_ptr_eq(r, NULL);
   // null delimiter
   r = self->f->joinSmallJson(self, NULL);
   ck_assert_ptr_eq(r, NULL);
   // empty array
   emptyO(self);
   freeO(delim);
   setTopSO(delim, ";");
   r = self->f->joinSmallJson(self, delim);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   terminateO(delim);
 
 }
 
 
 void joinSmallStringSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self   = allocSmallJson();
   smallStringt* delim = allocSmallString(";");
 
   // join non string objects
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   r = joinSmallStringO(self, delim);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null;123");
   free(s);
   // join strings
   emptyO(self);
   self->f->pushS(self, "a");
   self->f->pushS(self, "b");
   self->f->pushS(self, "c");
   self->f->pushS(self, "d");
   delElemIndexO(self, 1);
   r = joinSmallStringO(self, delim);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "a;c;d");
   free(s);
   // delimiter with no string
   freeO(delim);
   r = joinSmallStringO(self, delim);
   ck_assert_ptr_eq(r, NULL);
   // non smallString delim
   terminateO(delim);
   delim = (smallStringt*) allocSmallInt(0);
   r = joinSmallStringO(self, delim);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim);
   // null delimiter
   r = joinSmallStringO(self, NULL);
   ck_assert_ptr_eq(r, NULL);
   // empty array
   emptyO(self);
   delim = allocSmallString(";");
   r = joinSmallStringO(self, delim);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   terminateO(delim);
 
 }
 
 
 void joinSSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   // join non string objects
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   r = self->f->joinS(self, ";");
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "null;123");
   free(r);
   // join strings
   emptyO(self);
   self->f->pushS(self, "a");
   self->f->pushS(self, "b");
   self->f->pushS(self, "c");
   self->f->pushS(self, "d");
   delElemIndexO(self, 1);
   r = self->f->joinS(self, ";");
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "a;c;d");
   free(r);
   // null delimiter
   r = self->f->joinS(self, NULL);
   ck_assert_ptr_eq(r, NULL);
   // empty array
   emptyO(self);
   r = self->f->joinS(self, ";");
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void joinCharSSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   // join non string objects
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   r = joinCharSO(self, ';');
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "null;123");
   free(r);
   // join strings
   emptyO(self);
   self->f->pushS(self, "a");
   self->f->pushS(self, "b");
   self->f->pushS(self, "c");
   self->f->pushS(self, "d");
   delElemIndexO(self, 1);
   r = joinCharSO(self, ';');
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "a;c;d");
   free(r);
   // empty array
   emptyO(self);
   r = joinCharSO(self, ';');
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void joinSmallJsonSSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   smallJsont* delim = allocSmallJson();
 
   // join non string objects
   setTopSO(delim, ";");
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   r = joinSmallJsonSO(self, delim);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "null;123");
   free(r);
   // join strings
   emptyO(self);
   self->f->pushS(self, "a");
   self->f->pushS(self, "b");
   self->f->pushS(self, "c");
   self->f->pushS(self, "d");
   delElemIndexO(self, 1);
   r = joinSmallJsonSO(self, delim);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "a;c;d");
   free(r);
   // delimiter not a string
   freeO(delim);
   setTopIntO(delim, 1);
   r = joinSmallJsonSO(self, delim);
   ck_assert_ptr_eq(r, NULL);
   // non smallJson object
   terminateO(delim);
   delim = (smallJsont*) allocSmallInt(2);
   r = joinSmallJsonSO(self, delim);
   ck_assert_ptr_eq(r, NULL);
   // null delimiter
   r = joinSmallJsonSO(self, NULL);
   ck_assert_ptr_eq(r, NULL);
   // empty array
   emptyO(self);
   freeO(delim);
   setTopSO(delim, ";");
   r = joinSmallJsonSO(self, delim);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   terminateO(delim);
 
 }
 
 
 void joinSmallStringSSmallJsonT(void) {
 
   char* r;
   smallJsont *self   = allocSmallJson();
   smallStringt* delim = allocSmallString(";");
 
   // join non string objects
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   r = joinSmallStringSO(self, delim);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "null;123");
   free(r);
   // join strings
   emptyO(self);
   self->f->pushS(self, "a");
   self->f->pushS(self, "b");
   self->f->pushS(self, "c");
   self->f->pushS(self, "d");
   delElemIndexO(self, 1);
   r = joinSmallStringSO(self, delim);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "a;c;d");
   free(r);
   // delimiter with no string
   freeO(delim);
   r = joinSmallStringSO(self, delim);
   ck_assert_ptr_eq(r, NULL);
   // non smallString delim
   terminateO(delim);
   delim = (smallStringt*) allocSmallInt(0);
   r = joinSmallStringSO(self, delim);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim);
   // null delimiter
   r = joinSmallStringSO(self, NULL);
   ck_assert_ptr_eq(r, NULL);
   // empty array
   emptyO(self);
   delim = allocSmallString(";");
   r = joinSmallStringSO(self, delim);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   terminateO(delim);
 
 }
 
 
 void splitSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   r = splitO(self, "/");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"two\"]");
   free(s);
   terminateO(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = splitO(self, "/");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"one\"]");
   free(s);
   terminateO(r);
   freeO(self);
   setTopSO(self, "one/");
   r = splitO(self, "/");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = splitO(self, "||");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\"]");
   free(s);
   terminateO(r);
   // split with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   r = splitO(self, " ");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\",\"\",\"three\",\"\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe three extract");
   r = splitO(self, "e ");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"AA\",\"thre\",\"extract\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   r = splitO(self, "");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"AAd\"]");
   free(s);
   terminateO(r);
   // empty string
   emptyO(self);
   r = splitO(self, "$");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\"]");
   free(s);
   terminateO(r);
   // NULL list
   freeO(self);
   ck_assert_ptr_eq(splitO(self, ";"), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(splitO(self, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void splitCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   r = splitCharO(self, '/');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"two\"]");
   free(s);
   terminateO(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = splitCharO(self, '/');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"one\"]");
   free(s);
   terminateO(r);
   freeO(self);
   setTopSO(self, "one/");
   r = splitCharO(self, '/');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = splitCharO(self, '|');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\"]");
   free(s);
   terminateO(r);
   // split with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   r = splitCharO(self, ' ');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\",\"\",\"three\",\"\"]");
   free(s);
   terminateO(r);
   // empty string
   emptyO(self);
   r = splitCharO(self, '$');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\"]");
   free(s);
   terminateO(r);
   // NULL list
   freeO(self);
   ck_assert_ptr_eq(splitCharO(self, ';'), NULL);
   terminateO(self);
 
 }
 
 
 void splitSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont *delim  = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   setTopSO(delim, "/");
   r = self->f->splitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"two\"]");
   free(s);
   terminateO(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = self->f->splitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"one\"]");
   free(s);
   terminateO(r);
   freeO(self);
   setTopSO(self, "one/");
   r = self->f->splitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim);
   setTopSO(delim, "||");
   r = self->f->splitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\"]");
   free(s);
   terminateO(r);
   // split with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   freeO(delim);
   setTopSO(delim, " ");
   r = self->f->splitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\",\"\",\"three\",\"\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe three extract");
   freeO(delim);
   setTopSO(delim, "e ");
   r = self->f->splitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"AA\",\"thre\",\"extract\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim);
   setTopSO(delim, "");
   r = self->f->splitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"AAd\"]");
   free(s);
   terminateO(r);
   // empty string
   emptyO(self);
   freeO(delim);
   setTopSO(delim, "$");
   r = self->f->splitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\"]");
   free(s);
   terminateO(r);
   // non json string delimiter
   freeO(delim);
   ck_assert_ptr_eq(self->f->splitSmallJson(self, delim), NULL);
   // non json object delimiter
   terminateO(delim);
   delim = (smallJsont*) allocSmallInt(1);
   ck_assert_ptr_eq(self->f->splitSmallJson(self, delim), NULL);
   terminateO(delim);
   delim  = allocSmallJson();
   // NULL list
   freeO(self);
   freeO(delim);
   setTopSO(delim, ";");
   ck_assert_ptr_eq(self->f->splitSmallJson(self, delim), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(self->f->splitSmallJson(self, NULL), NULL);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void splitSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt *delim = allocSmallString("/");
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   r = self->f->splitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"two\"]");
   free(s);
   terminateO(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = self->f->splitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"one\"]");
   free(s);
   terminateO(r);
   freeO(self);
   setTopSO(self, "one/");
   r = self->f->splitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   setValO(delim, "||");
   r = self->f->splitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\"]");
   free(s);
   terminateO(r);
   // split with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   setValO(delim, " ");
   r = self->f->splitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\",\"\",\"three\",\"\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe three extract");
   setValO(delim, "e ");
   r = self->f->splitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"AA\",\"thre\",\"extract\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim, "");
   r = self->f->splitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"AAd\"]");
   free(s);
   terminateO(r);
   // empty string
   emptyO(self);
   setValO(delim, "$");
   r = self->f->splitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\"]");
   free(s);
   terminateO(r);
   // null string delimiter
   freeO(delim);
   ck_assert_ptr_eq(self->f->splitSmallString(self, delim), NULL);
   // non json object delimiter
   terminateO(delim);
   delim = (smallStringt*) allocSmallInt(1);
   ck_assert_ptr_eq(self->f->splitSmallString(self, delim), NULL);
   terminateO(delim);
   // NULL list
   freeO(self);
   delim  = allocSmallString(";");
   ck_assert_ptr_eq(self->f->splitSmallString(self, delim), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(self->f->splitSmallString(self, NULL), NULL);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void splitSSmallJsonT(void) {
 
   char** r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   r = splitSO(self, "/");
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "two");
   listFreeS(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = splitSO(self, "/");
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "");
   ck_assert_str_eq(r[1], "one");
   listFreeS(r);
   freeO(self);
   setTopSO(self, "one/");
   r = splitSO(self, "/");
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "");
   listFreeS(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = splitSO(self, "||");
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "one/two");
   listFreeS(r);
   // split with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   r = splitSO(self, " ");
   ck_assert_uint_eq(listLengthS(r),4);
   ck_assert_str_eq(r[0], "one/two");
   ck_assert_str_eq(r[1], "");
   ck_assert_str_eq(r[2], "three");
   ck_assert_str_eq(r[3], "");
   listFreeS(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe three extract");
   r = splitSO(self, "e ");
   ck_assert_uint_eq(listLengthS(r),3);
   ck_assert_str_eq(r[0], "AA");
   ck_assert_str_eq(r[1], "thre");
   ck_assert_str_eq(r[2], "extract");
   listFreeS(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   r = splitSO(self, "");
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "AAd");
   listFreeS(r);
   // empty string
   emptyO(self);
   r = splitSO(self, "$");
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "");
   listFreeS(r);
   // NULL list
   freeO(self);
   ck_assert_ptr_eq(splitSO(self, ";"), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(splitSO(self, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void splitCharSSmallJsonT(void) {
 
   char** r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   r = splitCharSO(self, '/');
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "two");
   listFreeS(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = splitCharSO(self, '/');
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "");
   ck_assert_str_eq(r[1], "one");
   listFreeS(r);
   freeO(self);
   setTopSO(self, "one/");
   r = splitCharSO(self, '/');
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "");
   listFreeS(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = splitCharSO(self, '|');
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "one/two");
   listFreeS(r);
   // split with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   r = splitCharSO(self, ' ');
   ck_assert_uint_eq(listLengthS(r),4);
   ck_assert_str_eq(r[0], "one/two");
   ck_assert_str_eq(r[1], "");
   ck_assert_str_eq(r[2], "three");
   ck_assert_str_eq(r[3], "");
   listFreeS(r);
   // empty string
   emptyO(self);
   r = splitCharSO(self, '$');
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "");
   listFreeS(r);
   // NULL list
   freeO(self);
   ck_assert_ptr_eq(splitCharSO(self, ';'), NULL);
   terminateO(self);
 
 }
 
 
 void splitSmallJsonSSmallJsonT(void) {
 
   char** r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont *delim  = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   setTopSO(delim, "/");
   r = splitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "two");
   listFreeS(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = splitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "");
   ck_assert_str_eq(r[1], "one");
   listFreeS(r);
   freeO(self);
   setTopSO(self, "one/");
   r = splitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "");
   listFreeS(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim);
   setTopSO(delim, "||");
   r = splitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "one/two");
   listFreeS(r);
   // split with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   freeO(delim);
   setTopSO(delim, " ");
   r = splitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),4);
   ck_assert_str_eq(r[0], "one/two");
   ck_assert_str_eq(r[1], "");
   ck_assert_str_eq(r[2], "three");
   ck_assert_str_eq(r[3], "");
   listFreeS(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe three extract");
   freeO(delim);
   setTopSO(delim, "e ");
   r = splitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),3);
   ck_assert_str_eq(r[0], "AA");
   ck_assert_str_eq(r[1], "thre");
   ck_assert_str_eq(r[2], "extract");
   listFreeS(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim);
   setTopSO(delim, "");
   r = splitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "AAd");
   listFreeS(r);
   // empty string
   emptyO(self);
   freeO(delim);
   setTopSO(delim, "$");
   r = splitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "");
   listFreeS(r);
   // non json string delimiter
   freeO(delim);
   ck_assert_ptr_eq(splitSmallJsonSO(self, delim), NULL);
   // non json object delimiter
   terminateO(delim);
   delim = (smallJsont*) allocSmallInt(1);
   ck_assert_ptr_eq(splitSmallJsonSO(self, delim), NULL);
   terminateO(delim);
   delim  = allocSmallJson();
   // NULL list
   freeO(self);
   freeO(delim);
   setTopSO(delim, ";");
   ck_assert_ptr_eq(splitSmallJsonSO(self, delim), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(splitSmallJsonSO(self, NULL), NULL);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void splitSmallStringSSmallJsonT(void) {
 
   char** r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt *delim = allocSmallString("/");
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   r = splitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "two");
   listFreeS(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = splitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "");
   ck_assert_str_eq(r[1], "one");
   listFreeS(r);
   freeO(self);
   setTopSO(self, "one/");
   r = splitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "");
   listFreeS(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   setValO(delim, "||");
   r = splitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "one/two");
   listFreeS(r);
   // split with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   setValO(delim, " ");
   r = splitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),4);
   ck_assert_str_eq(r[0], "one/two");
   ck_assert_str_eq(r[1], "");
   ck_assert_str_eq(r[2], "three");
   ck_assert_str_eq(r[3], "");
   listFreeS(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe three extract");
   setValO(delim, "e ");
   r = splitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),3);
   ck_assert_str_eq(r[0], "AA");
   ck_assert_str_eq(r[1], "thre");
   ck_assert_str_eq(r[2], "extract");
   listFreeS(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim, "");
   r = splitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "AAd");
   listFreeS(r);
   // empty string
   emptyO(self);
   setValO(delim, "$");
   r = splitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "");
   listFreeS(r);
   // non smallString object delimiter
   terminateO(delim);
   delim = (smallStringt*) allocSmallInt(1);
   ck_assert_ptr_eq(splitSmallStringSO(self, delim), NULL);
   terminateO(delim);
   // NULL list
   freeO(self);
   delim  = allocSmallString(";");
   ck_assert_ptr_eq(splitSmallStringSO(self, delim), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(splitSmallStringSO(self, NULL), NULL);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void extractSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   r = extractO(self, "/", "|");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = extractO(self, "||", "/");
   ck_assert_ptr_eq(r, NULL);
   // extractO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   r = extractO(self, "/", " ");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   r = extractO(self, "e ", "|");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   r = extractO(self, "", "Ad");
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   r = extractO(self, "A", "");
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = extractO(self, "$", "#");
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "");
   r = extractO(self, "$", "$");
   ck_assert_ptr_eq(r, NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(extractO(self, ";", ","), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractO(self, NULL, ","), NULL);
   ck_assert_ptr_eq(extractO(self, ",", NULL), NULL);
   terminateO(self);
 
 }
 
 
 void extractCharSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   r = extractCharSO(self, '/', "|");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = extractCharSO(self, '|', "/");
   ck_assert_ptr_eq(r, NULL);
   // extractCharSO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   r = extractCharSO(self, '/', " ");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   r = extractCharSO(self, ' ', "|e");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   r = extractCharSO(self, 'A', "");
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = extractCharSO(self, '$', "#");
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "");
   r = extractCharSO(self, '$', "$");
   ck_assert_ptr_eq(r, NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(extractCharSO(self, ';', ","), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractCharSO(self, ',', NULL), NULL);
   terminateO(self);
 
 }
 
 
 void extractSCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   r = extractSCharO(self, "/", '|');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = extractSCharO(self, "||", '/');
   ck_assert_ptr_eq(r, NULL);
   // extractSCharO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   r = extractSCharO(self, "/", ' ');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   r = extractSCharO(self, "e ", '|');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   r = extractSCharO(self, "", 'A');
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = extractSCharO(self, "$", '#');
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "");
   r = extractSCharO(self, "$", '$');
   ck_assert_ptr_eq(r, NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(extractSCharO(self, ";", ','), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractSCharO(self, NULL, ','), NULL);
   terminateO(self);
 
 }
 
 
 void extractCharCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   r = extractCharCharO(self, '/', '|');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = extractCharCharO(self, '|', '/');
   ck_assert_ptr_eq(r, NULL);
   // extractCharCharO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   r = extractCharCharO(self, '/', ' ');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   r = extractCharCharO(self, ' ', '|');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = extractCharCharO(self, '$', '#');
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "");
   r = extractCharCharO(self, '$', '$');
   ck_assert_ptr_eq(r, NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(extractCharCharO(self, ';', ','), NULL);
   terminateO(self);
 
 }
 
 
 void extractSmallJsonSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont* delim1 = allocSmallJson();
   smallJsont* delim2 = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   setTopSO(delim1, "/");
   setTopSO(delim2, "|");
   r = extractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, "||");
   setTopSO(delim2, "/");
   r = extractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // extractSmallJsonSmallJsonO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, "/");
   setTopSO(delim2, " ");
   r = extractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, "e ");
   setTopSO(delim2, "|");
   r = extractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, "");
   setTopSO(delim2, "Ad");
   r = extractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, "A");
   setTopSO(delim2, "");
   r = extractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, "$");
   setTopSO(delim2, "#");
   r = extractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, "$");
   setTopSO(delim2, "$");
   r = extractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json string
   freeO(delim1);
   r = extractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   setTopSO(delim1, "$");
   freeO(delim2);
   r = extractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallJsont*) allocSmallInt(1);
   setTopSO(delim2, "$");
   r = extractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallJson();
   setTopSO(delim1, ";");
   terminateO(delim2);
   delim2 = (smallJsont*) allocSmallInt(1);
   r = extractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallJson();
   // NULL string
   freeO(self);
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, ";");
   setTopSO(delim2, ",");
   ck_assert_ptr_eq(extractSmallJsonSmallJsonO(self, delim1, delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractSmallJsonSmallJsonO(self, NULL, delim2), NULL);
   ck_assert_ptr_eq(extractSmallJsonSmallJsonO(self, delim1, NULL), NULL);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void extractSmallJsonSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont* delim1   = allocSmallJson();
   smallStringt* delim2 = allocSmallString("|");
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   setTopSO(delim1, "/");
   r = extractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim1);
   setTopSO(delim1, "||");
   setValO(delim2, "/");
   r = extractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // extractSmallJsonSmallStringO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   freeO(delim1);
   setTopSO(delim1, "/");
   setValO(delim2, " ");
   r = extractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   freeO(delim1);
   setTopSO(delim1, "e ");
   setValO(delim2, "|");
   r = extractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim1);
   setTopSO(delim1, "");
   setValO(delim2, "Ad");
   r = extractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim1);
   setTopSO(delim1, "A");
   setValO(delim2, "");
   r = extractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(delim1);
   setTopSO(delim1, "$");
   setValO(delim2, "#");
   r = extractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   freeO(delim1);
   setTopSO(delim1, "$");
   setValO(delim2, "$");
   r = extractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json string
   freeO(delim1);
   r = extractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallJsont*) allocSmallInt(1);
   r = extractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallJson();
   setTopSO(delim1, ";");
   terminateO(delim2);
   delim2 = (smallStringt*) allocSmallInt(1);
   r = extractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallString(",");
   // NULL string
   freeO(self);
   freeO(delim1);
   setTopSO(delim1, ";");
   ck_assert_ptr_eq(extractSmallJsonSmallStringO(self, delim1, delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractSmallJsonSmallStringO(self, NULL, delim2), NULL);
   ck_assert_ptr_eq(extractSmallJsonSmallStringO(self, delim1, NULL), NULL);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void extractSmallJsonSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont* delim1 = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   setTopSO(delim1, "/");
   r = extractSmallJsonSO(self, delim1, "|");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim1);
   setTopSO(delim1, "||");
   r = extractSmallJsonSO(self, delim1, "/");
   ck_assert_ptr_eq(r, NULL);
   // extractSmallJsonSO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   freeO(delim1);
   setTopSO(delim1, "/");
   r = extractSmallJsonSO(self, delim1, " ");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   freeO(delim1);
   setTopSO(delim1, "e ");
   r = extractSmallJsonSO(self, delim1, "|");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim1);
   setTopSO(delim1, "");
   r = extractSmallJsonSO(self, delim1, "Ad");
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim1);
   setTopSO(delim1, "A");
   r = extractSmallJsonSO(self, delim1, "");
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(delim1);
   setTopSO(delim1, "$");
   r = extractSmallJsonSO(self, delim1, "#");
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   freeO(delim1);
   setTopSO(delim1, "$");
   r = extractSmallJsonSO(self, delim1, "$");
   ck_assert_ptr_eq(r, NULL);
   // non json string
   freeO(delim1);
   r = extractSmallJsonSO(self, delim1, "$");
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallJsont*) allocSmallInt(1);
   r = extractSmallJsonSO(self, delim1, "$");
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallJson();
   // NULL string
   freeO(self);
   freeO(delim1);
   setTopSO(delim1, ";");
   ck_assert_ptr_eq(extractSmallJsonSO(self, delim1, ","), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractSmallJsonSO(self, NULL, ","), NULL);
   ck_assert_ptr_eq(extractSmallJsonSO(self, delim1, NULL), NULL);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void extractSmallJsonCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont* delim1 = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   setTopSO(delim1, "/");
   r = extractSmallJsonCharO(self, delim1, '|');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim1);
   setTopSO(delim1, "||");
   r = extractSmallJsonCharO(self, delim1, '/');
   ck_assert_ptr_eq(r, NULL);
   // extractSmallJsonCharO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   freeO(delim1);
   setTopSO(delim1, "/");
   r = extractSmallJsonCharO(self, delim1, ' ');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   freeO(delim1);
   setTopSO(delim1, "e ");
   r = extractSmallJsonCharO(self, delim1, '|');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim1);
   setTopSO(delim1, "");
   r = extractSmallJsonCharO(self, delim1, 'd');
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(delim1);
   setTopSO(delim1, "$");
   r = extractSmallJsonCharO(self, delim1, '#');
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   freeO(delim1);
   setTopSO(delim1, "$");
   r = extractSmallJsonCharO(self, delim1, '$');
   ck_assert_ptr_eq(r, NULL);
   // non json string
   freeO(delim1);
   r = extractSmallJsonCharO(self, delim1, '$');
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallJsont*) allocSmallInt(1);
   r = extractSmallJsonCharO(self, delim1, '$');
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallJson();
   // NULL string
   freeO(self);
   freeO(delim1);
   setTopSO(delim1, ";");
   ck_assert_ptr_eq(extractSmallJsonCharO(self, delim1, ','), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractSmallJsonCharO(self, NULL, ','), NULL);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void extractSmallStringSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt* delim1 = allocSmallString("/");
   smallJsont* delim2   = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   setTopSO(delim2, "|");
   r = extractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim2);
   setValO(delim1, "||");
   setTopSO(delim2, "/");
   r = extractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // extractSmallStringSmallJsonO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   freeO(delim2);
   setValO(delim1, "/");
   setTopSO(delim2, " ");
   r = extractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   freeO(delim2);
   setValO(delim1, "e ");
   setTopSO(delim2, "|");
   r = extractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim2);
   setValO(delim1, "");
   setTopSO(delim2, "Ad");
   r = extractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim2);
   setValO(delim1, "A");
   setTopSO(delim2, "");
   r = extractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(delim2);
   setValO(delim1, "$");
   setTopSO(delim2, "#");
   r = extractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   freeO(delim2);
   setValO(delim1, "$");
   setTopSO(delim2, "$");
   r = extractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json string
   freeO(delim2);
   r = extractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallStringt*) allocSmallInt(1);
   setTopSO(delim2, "$");
   r = extractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallString(";");
   terminateO(delim2);
   delim2 = (smallJsont*) allocSmallInt(1);
   r = extractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallJson();
   // NULL string
   freeO(self);
   freeO(delim2);
   setValO(delim1, ";");
   setTopSO(delim2, ",");
   ck_assert_ptr_eq(extractSmallStringSmallJsonO(self, delim1, delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractSmallStringSmallJsonO(self, NULL, delim2), NULL);
   ck_assert_ptr_eq(extractSmallStringSmallJsonO(self, delim1, NULL), NULL);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void extractSmallStringSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt* delim1 = allocSmallString("/");
   smallStringt* delim2 = allocSmallString("|");
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   setValO(delim2, "|");
   r = extractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   setValO(delim1, "||");
   setValO(delim2, "/");
   r = extractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // extractSmallStringSmallStringO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   setValO(delim1, "/");
   setValO(delim2, " ");
   r = extractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   setValO(delim1, "e ");
   setValO(delim2, "|");
   r = extractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim1, "");
   setValO(delim2, "Ad");
   r = extractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim1, "A");
   setValO(delim2, "");
   r = extractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(delim1, "$");
   setValO(delim2, "#");
   r = extractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   setValO(delim1, "$");
   setValO(delim2, "$");
   r = extractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallStringt*) allocSmallInt(1);
   r = extractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallString(";");
   terminateO(delim2);
   delim2 = (smallStringt*) allocSmallInt(1);
   r = extractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallString(",");
   // NULL string
   freeO(self);
   setValO(delim1, ";");
   ck_assert_ptr_eq(extractSmallStringSmallStringO(self, delim1, delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractSmallStringSmallStringO(self, NULL, delim2), NULL);
   ck_assert_ptr_eq(extractSmallStringSmallStringO(self, delim1, NULL), NULL);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void extractSmallStringSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt* delim1 = allocSmallString("/");
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   r = extractSmallStringSO(self, delim1, "|");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   setValO(delim1, "||");
   r = extractSmallStringSO(self, delim1, "/");
   ck_assert_ptr_eq(r, NULL);
   // extractSmallStringSO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   setValO(delim1, "/");
   r = extractSmallStringSO(self, delim1, " ");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   setValO(delim1, "e ");
   r = extractSmallStringSO(self, delim1, "|");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim1, "");
   r = extractSmallStringSO(self, delim1, "Ad");
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim1, "A");
   r = extractSmallStringSO(self, delim1, "");
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(delim1, "$");
   r = extractSmallStringSO(self, delim1, "#");
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   setValO(delim1, "$");
   r = extractSmallStringSO(self, delim1, "$");
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallStringt*) allocSmallInt(1);
   r = extractSmallStringSO(self, delim1, "$");
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallString(";");
   // NULL string
   freeO(self);
   setValO(delim1, ";");
   ck_assert_ptr_eq(extractSmallStringSO(self, delim1, ","), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractSmallStringSO(self, NULL, ","), NULL);
   ck_assert_ptr_eq(extractSmallStringSO(self, delim1, NULL), NULL);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void extractSmallStringCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt* delim1 = allocSmallString("/");
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   r = extractSmallStringCharO(self, delim1, '|');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   setValO(delim1, "||");
   r = extractSmallStringCharO(self, delim1, '/');
   ck_assert_ptr_eq(r, NULL);
   // extractSmallStringCharO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   setValO(delim1, "/");
   r = extractSmallStringCharO(self, delim1, ' ');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   setValO(delim1, "e ");
   r = extractSmallStringCharO(self, delim1, '|');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim1, "");
   r = extractSmallStringCharO(self, delim1, 'A');
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim1, "A");
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(delim1, "$");
   r = extractSmallStringCharO(self, delim1, '#');
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   setValO(delim1, "$");
   r = extractSmallStringCharO(self, delim1, '$');
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallStringt*) allocSmallInt(1);
   r = extractSmallStringCharO(self, delim1, '$');
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallString(";");
   // NULL string
   freeO(self);
   setValO(delim1, ";");
   ck_assert_ptr_eq(extractSmallStringCharO(self, delim1, ','), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractSmallStringCharO(self, NULL, ','), NULL);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void extractSSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont* delim2 = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   setTopSO(delim2, "|");
   r = extractSSmallJsonO(self, "/", delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim2);
   setTopSO(delim2, "/");
   r = extractSSmallJsonO(self, "||", delim2);
   ck_assert_ptr_eq(r, NULL);
   // extractSSmallJsonO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   freeO(delim2);
   setTopSO(delim2, " ");
   r = extractSSmallJsonO(self, "/", delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   freeO(delim2);
   setTopSO(delim2, "|");
   r = extractSSmallJsonO(self, "e ", delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim2);
   setTopSO(delim2, "Ad");
   r = extractSSmallJsonO(self, "", delim2);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim2);
   setTopSO(delim2, "");
   r = extractSSmallJsonO(self, "A", delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(delim2);
   setTopSO(delim2, "#");
   r = extractSSmallJsonO(self, "$", delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   freeO(delim2);
   setTopSO(delim2, "$");
   r = extractSSmallJsonO(self, "$", delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json string
   freeO(delim2);
   r = extractSSmallJsonO(self, "$", delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim2);
   delim2 = (smallJsont*) allocSmallInt(1);
   r = extractSSmallJsonO(self, ";", delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallJson();
   // NULL string
   freeO(self);
   freeO(delim2);
   setTopSO(delim2, ",");
   ck_assert_ptr_eq(extractSSmallJsonO(self, ";", delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractSSmallJsonO(self, NULL, delim2), NULL);
   ck_assert_ptr_eq(extractSSmallJsonO(self, ";", NULL), NULL);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void extractSSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt* delim2 = allocSmallString("|");
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   setValO(delim2, "|");
   r = extractSSmallStringO(self, "/", delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   setValO(delim2, "/");
   r = extractSSmallStringO(self, "||", delim2);
   ck_assert_ptr_eq(r, NULL);
   // extractSSmallStringO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   setValO(delim2, " ");
   r = extractSSmallStringO(self, "/", delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   setValO(delim2, "|");
   r = extractSSmallStringO(self, "e ", delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim2, "Ad");
   r = extractSSmallStringO(self, "", delim2);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim2, "");
   r = extractSSmallStringO(self, "A", delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(delim2, "#");
   r = extractSSmallStringO(self, "$", delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   setValO(delim2, "$");
   r = extractSSmallStringO(self, "$", delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim2);
   delim2 = (smallStringt*) allocSmallInt(1);
   r = extractSSmallStringO(self, ";", delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallString(",");
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(extractSSmallStringO(self, ";", delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractSSmallStringO(self, NULL, delim2), NULL);
   ck_assert_ptr_eq(extractSSmallStringO(self, ";", NULL), NULL);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void extractCharSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont* delim2 = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   setTopSO(delim2, "|");
   r = extractCharSmallJsonO(self, '/', delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim2);
   setTopSO(delim2, "/");
   r = extractCharSmallJsonO(self, '|', delim2);
   ck_assert_ptr_eq(r, NULL);
   // extractCharSmallJsonO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   freeO(delim2);
   setTopSO(delim2, " ");
   r = extractCharSmallJsonO(self, '/', delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   freeO(delim2);
   setTopSO(delim2, "|");
   r = extractCharSmallJsonO(self, ' ', delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim2);
   setTopSO(delim2, "");
   r = extractCharSmallJsonO(self, 'A', delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(delim2);
   setTopSO(delim2, "#");
   r = extractCharSmallJsonO(self, '$', delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   freeO(delim2);
   setTopSO(delim2, "$");
   r = extractCharSmallJsonO(self, '$', delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json string
   freeO(delim2);
   r = extractCharSmallJsonO(self, '$', delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim2);
   delim2 = (smallJsont*) allocSmallInt(1);
   r = extractCharSmallJsonO(self, ';', delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallJson();
   // NULL string
   freeO(self);
   freeO(delim2);
   setTopSO(delim2, ",");
   ck_assert_ptr_eq(extractCharSmallJsonO(self, ';', delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractCharSmallJsonO(self, ';', NULL), NULL);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void extractCharSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt* delim2 = allocSmallString("|");
 
   // string
   freeO(self);
   setTopSO(self, "one/two|");
   setValO(delim2, "|");
   r = extractCharSmallStringO(self, '/', delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   setValO(delim2, "/");
   r = extractCharSmallStringO(self, '|', delim2);
   ck_assert_ptr_eq(r, NULL);
   // extractCharSmallStringO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   setValO(delim2, " ");
   r = extractCharSmallStringO(self, '/', delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e extract");
   setValO(delim2, "|e");
   r = extractCharSmallStringO(self, ' ', delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim2, "");
   r = extractCharSmallStringO(self, 'A', delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(delim2, "#");
   r = extractCharSmallStringO(self, '$', delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   setValO(delim2, "$");
   r = extractCharSmallStringO(self, '$', delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim2);
   delim2 = (smallStringt*) allocSmallInt(1);
   r = extractCharSmallStringO(self, ';', delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallString(",");
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(extractCharSmallStringO(self, ';', delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(extractCharSmallStringO(self, ';', NULL), NULL);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icSplitSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   r = icSplitO(self, "/");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"two\"]");
   free(s);
   terminateO(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = icSplitO(self, "/");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"one\"]");
   free(s);
   terminateO(r);
   freeO(self);
   setTopSO(self, "one/");
   r = icSplitO(self, "/");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = icSplitO(self, "||");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\"]");
   free(s);
   terminateO(r);
   // icSplit with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   r = icSplitO(self, " ");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\",\"\",\"three\",\"\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe three extract");
   r = icSplitO(self, "E ");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"AA\",\"thre\",\"extract\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   r = icSplitO(self, "");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"AAd\"]");
   free(s);
   terminateO(r);
   // empty string
   emptyO(self);
   r = icSplitO(self, "$");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\"]");
   free(s);
   terminateO(r);
   // NULL list
   freeO(self);
   ck_assert_ptr_eq(icSplitO(self, ";"), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icSplitO(self, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void icSplitCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   r = icSplitCharO(self, 'T');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/\",\"wo\"]");
   free(s);
   terminateO(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = icSplitCharO(self, '/');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"one\"]");
   free(s);
   terminateO(r);
   freeO(self);
   setTopSO(self, "one/");
   r = icSplitCharO(self, '/');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = icSplitCharO(self, '|');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\"]");
   free(s);
   terminateO(r);
   // icSplit with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   r = icSplitCharO(self, ' ');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\",\"\",\"three\",\"\"]");
   free(s);
   terminateO(r);
   // empty string
   emptyO(self);
   r = icSplitCharO(self, '$');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\"]");
   free(s);
   terminateO(r);
   // NULL list
   freeO(self);
   ck_assert_ptr_eq(icSplitCharO(self, ';'), NULL);
   terminateO(self);
 
 }
 
 
 void icSplitSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont *delim  = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   setTopSO(delim, "/");
   r = self->f->icSplitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"two\"]");
   free(s);
   terminateO(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = self->f->icSplitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"one\"]");
   free(s);
   terminateO(r);
   freeO(self);
   setTopSO(self, "one/");
   r = self->f->icSplitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim);
   setTopSO(delim, "||");
   r = self->f->icSplitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\"]");
   free(s);
   terminateO(r);
   // icSplit with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   freeO(delim);
   setTopSO(delim, " ");
   r = self->f->icSplitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\",\"\",\"three\",\"\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe three extract");
   freeO(delim);
   setTopSO(delim, "E ");
   r = self->f->icSplitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"AA\",\"thre\",\"extract\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim);
   setTopSO(delim, "");
   r = self->f->icSplitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"AAd\"]");
   free(s);
   terminateO(r);
   // empty string
   emptyO(self);
   freeO(delim);
   setTopSO(delim, "$");
   r = self->f->icSplitSmallJson(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\"]");
   free(s);
   terminateO(r);
   // non json string delimiter
   freeO(delim);
   ck_assert_ptr_eq(self->f->icSplitSmallJson(self, delim), NULL);
   // non json object delimiter
   terminateO(delim);
   delim = (smallJsont*) allocSmallInt(1);
   ck_assert_ptr_eq(self->f->icSplitSmallJson(self, delim), NULL);
   terminateO(delim);
   delim  = allocSmallJson();
   // NULL list
   freeO(self);
   freeO(delim);
   setTopSO(delim, ";");
   ck_assert_ptr_eq(self->f->icSplitSmallJson(self, delim), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(self->f->icSplitSmallJson(self, NULL), NULL);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void icSplitSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt *delim = allocSmallString("/");
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   r = self->f->icSplitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"two\"]");
   free(s);
   terminateO(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = self->f->icSplitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"one\"]");
   free(s);
   terminateO(r);
   freeO(self);
   setTopSO(self, "one/");
   r = self->f->icSplitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   setValO(delim, "||");
   r = self->f->icSplitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\"]");
   free(s);
   terminateO(r);
   // icSplit with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   setValO(delim, " ");
   r = self->f->icSplitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/two\",\"\",\"three\",\"\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe three extract");
   setValO(delim, "E ");
   r = self->f->icSplitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"AA\",\"thre\",\"extract\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim, "");
   r = self->f->icSplitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"AAd\"]");
   free(s);
   terminateO(r);
   // empty string
   emptyO(self);
   setValO(delim, "$");
   r = self->f->icSplitSmallString(self, delim);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\"]");
   free(s);
   terminateO(r);
   // null string delimiter
   freeO(delim);
   ck_assert_ptr_eq(self->f->icSplitSmallString(self, delim), NULL);
   // non json object delimiter
   terminateO(delim);
   delim = (smallStringt*) allocSmallInt(1);
   ck_assert_ptr_eq(self->f->icSplitSmallString(self, delim), NULL);
   terminateO(delim);
   // NULL list
   freeO(self);
   delim  = allocSmallString(";");
   ck_assert_ptr_eq(self->f->icSplitSmallString(self, delim), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(self->f->icSplitSmallString(self, NULL), NULL);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void icSplitSSmallJsonT(void) {
 
   char** r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   r = icSplitSO(self, "/");
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "two");
   listFreeS(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = icSplitSO(self, "/");
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "");
   ck_assert_str_eq(r[1], "one");
   listFreeS(r);
   freeO(self);
   setTopSO(self, "one/");
   r = icSplitSO(self, "/");
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "");
   listFreeS(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = icSplitSO(self, "||");
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "one/two");
   listFreeS(r);
   // icSplit with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   r = icSplitSO(self, " ");
   ck_assert_uint_eq(listLengthS(r),4);
   ck_assert_str_eq(r[0], "one/two");
   ck_assert_str_eq(r[1], "");
   ck_assert_str_eq(r[2], "three");
   ck_assert_str_eq(r[3], "");
   listFreeS(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe three extract");
   r = icSplitSO(self, "E ");
   ck_assert_uint_eq(listLengthS(r),3);
   ck_assert_str_eq(r[0], "AA");
   ck_assert_str_eq(r[1], "thre");
   ck_assert_str_eq(r[2], "extract");
   listFreeS(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   r = icSplitSO(self, "");
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "AAd");
   listFreeS(r);
   // empty string
   emptyO(self);
   r = icSplitSO(self, "$");
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "");
   listFreeS(r);
   // NULL list
   freeO(self);
   ck_assert_ptr_eq(icSplitSO(self, ";"), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icSplitSO(self, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void icSplitCharSSmallJsonT(void) {
 
   char** r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   r = icSplitCharSO(self, 'T');
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one/");
   ck_assert_str_eq(r[1], "wo");
   listFreeS(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = icSplitCharSO(self, '/');
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "");
   ck_assert_str_eq(r[1], "one");
   listFreeS(r);
   freeO(self);
   setTopSO(self, "one/");
   r = icSplitCharSO(self, '/');
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "");
   listFreeS(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = icSplitCharSO(self, '|');
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "one/two");
   listFreeS(r);
   // icSplit with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   r = icSplitCharSO(self, ' ');
   ck_assert_uint_eq(listLengthS(r),4);
   ck_assert_str_eq(r[0], "one/two");
   ck_assert_str_eq(r[1], "");
   ck_assert_str_eq(r[2], "three");
   ck_assert_str_eq(r[3], "");
   listFreeS(r);
   // empty string
   emptyO(self);
   r = icSplitCharSO(self, '$');
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "");
   listFreeS(r);
   // NULL list
   freeO(self);
   ck_assert_ptr_eq(icSplitCharSO(self, ';'), NULL);
   terminateO(self);
 
 }
 
 
 void icSplitSmallJsonSSmallJsonT(void) {
 
   char** r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont *delim  = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   setTopSO(delim, "/");
   r = icSplitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "two");
   listFreeS(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = icSplitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "");
   ck_assert_str_eq(r[1], "one");
   listFreeS(r);
   freeO(self);
   setTopSO(self, "one/");
   r = icSplitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "");
   listFreeS(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim);
   setTopSO(delim, "||");
   r = icSplitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "one/two");
   listFreeS(r);
   // icSplit with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   freeO(delim);
   setTopSO(delim, " ");
   r = icSplitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),4);
   ck_assert_str_eq(r[0], "one/two");
   ck_assert_str_eq(r[1], "");
   ck_assert_str_eq(r[2], "three");
   ck_assert_str_eq(r[3], "");
   listFreeS(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe three extract");
   freeO(delim);
   setTopSO(delim, "E ");
   r = icSplitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),3);
   ck_assert_str_eq(r[0], "AA");
   ck_assert_str_eq(r[1], "thre");
   ck_assert_str_eq(r[2], "extract");
   listFreeS(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim);
   setTopSO(delim, "");
   r = icSplitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "AAd");
   listFreeS(r);
   // empty string
   emptyO(self);
   freeO(delim);
   setTopSO(delim, "$");
   r = icSplitSmallJsonSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "");
   listFreeS(r);
   // non json string delimiter
   freeO(delim);
   ck_assert_ptr_eq(icSplitSmallJsonSO(self, delim), NULL);
   // non json object delimiter
   terminateO(delim);
   delim = (smallJsont*) allocSmallInt(1);
   ck_assert_ptr_eq(icSplitSmallJsonSO(self, delim), NULL);
   terminateO(delim);
   delim  = allocSmallJson();
   // NULL list
   freeO(self);
   freeO(delim);
   setTopSO(delim, ";");
   ck_assert_ptr_eq(icSplitSmallJsonSO(self, delim), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icSplitSmallJsonSO(self, NULL), NULL);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void icSplitSmallStringSSmallJsonT(void) {
 
   char** r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt *delim = allocSmallString("/");
 
   // string
   freeO(self);
   setTopSO(self, "one/two");
   r = icSplitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "two");
   listFreeS(r);
   // delimiter on the edge
   freeO(self);
   setTopSO(self, "/one");
   r = icSplitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "");
   ck_assert_str_eq(r[1], "one");
   listFreeS(r);
   freeO(self);
   setTopSO(self, "one/");
   r = icSplitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "");
   listFreeS(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   setValO(delim, "||");
   r = icSplitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "one/two");
   listFreeS(r);
   // icSplit with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/two  three ");
   setValO(delim, " ");
   r = icSplitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),4);
   ck_assert_str_eq(r[0], "one/two");
   ck_assert_str_eq(r[1], "");
   ck_assert_str_eq(r[2], "three");
   ck_assert_str_eq(r[3], "");
   listFreeS(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe three extract");
   setValO(delim, "E ");
   r = icSplitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),3);
   ck_assert_str_eq(r[0], "AA");
   ck_assert_str_eq(r[1], "thre");
   ck_assert_str_eq(r[2], "extract");
   listFreeS(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim, "");
   r = icSplitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "AAd");
   listFreeS(r);
   // empty string
   emptyO(self);
   setValO(delim, "$");
   r = icSplitSmallStringSO(self, delim);
   ck_assert_uint_eq(listLengthS(r),1);
   ck_assert_str_eq(r[0], "");
   listFreeS(r);
   // non smallString object delimiter
   terminateO(delim);
   delim = (smallStringt*) allocSmallInt(1);
   ck_assert_ptr_eq(icSplitSmallStringSO(self, delim), NULL);
   terminateO(delim);
   // NULL list
   freeO(self);
   delim  = allocSmallString(";");
   ck_assert_ptr_eq(icSplitSmallStringSO(self, delim), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icSplitSmallStringSO(self, NULL), NULL);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void icExtractSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   r = icExtractO(self, "E", "S");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = icExtractO(self, "||", "/");
   ck_assert_ptr_eq(r, NULL);
   // icExtractO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   r = icExtractO(self, "/", " ");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   r = icExtractO(self, "e ", "|");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   r = icExtractO(self, "", "Ad");
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   r = icExtractO(self, "A", "");
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = icExtractO(self, "$", "#");
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "");
   r = icExtractO(self, "$", "$");
   ck_assert_ptr_eq(r, NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icExtractO(self, ";", ","), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractO(self, NULL, ","), NULL);
   ck_assert_ptr_eq(icExtractO(self, ",", NULL), NULL);
   terminateO(self);
 
 }
 
 
 void icExtractCharSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   r = icExtractCharSO(self, 'E', "S");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = icExtractCharSO(self, '|', "/");
   ck_assert_ptr_eq(r, NULL);
   // icExtractCharSO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   r = icExtractCharSO(self, '/', " ");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   r = icExtractCharSO(self, ' ', "|e");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   r = icExtractCharSO(self, 'A', "");
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = icExtractCharSO(self, '$', "#");
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "");
   r = icExtractCharSO(self, '$', "$");
   ck_assert_ptr_eq(r, NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icExtractCharSO(self, ';', ","), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractCharSO(self, ',', NULL), NULL);
   terminateO(self);
 
 }
 
 
 void icExtractSCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   r = icExtractSCharO(self, "E", 'S');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = icExtractSCharO(self, "||", '/');
   ck_assert_ptr_eq(r, NULL);
   // icExtractSCharO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   r = icExtractSCharO(self, "/", ' ');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   r = icExtractSCharO(self, "e ", '|');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   r = icExtractSCharO(self, "", 'A');
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = icExtractSCharO(self, "$", '#');
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "");
   r = icExtractSCharO(self, "$", '$');
   ck_assert_ptr_eq(r, NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icExtractSCharO(self, ";", ','), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractSCharO(self, NULL, ','), NULL);
   terminateO(self);
 
 }
 
 
 void icExtractCharCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   r = icExtractCharCharO(self, 'E', 'S');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   r = icExtractCharCharO(self, '|', '/');
   ck_assert_ptr_eq(r, NULL);
   // icExtractCharCharO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   r = icExtractCharCharO(self, '/', ' ');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   r = icExtractCharCharO(self, ' ', '|');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty string
   freeO(self);
   setTopSO(self, "");
   r = icExtractCharCharO(self, '$', '#');
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "");
   r = icExtractCharCharO(self, '$', '$');
   ck_assert_ptr_eq(r, NULL);
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icExtractCharCharO(self, ';', ','), NULL);
   terminateO(self);
 
 }
 
 
 void icExtractSmallJsonSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont* delim1 = allocSmallJson();
   smallJsont* delim2 = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   setTopSO(delim1, "E");
   setTopSO(delim2, "S");
   r = icExtractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, "||");
   setTopSO(delim2, "/");
   r = icExtractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // icExtractSmallJsonSmallJsonO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, "/");
   setTopSO(delim2, " ");
   r = icExtractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, "e ");
   setTopSO(delim2, "|");
   r = icExtractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, "");
   setTopSO(delim2, "Ad");
   r = icExtractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, "A");
   setTopSO(delim2, "");
   r = icExtractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, "$");
   setTopSO(delim2, "#");
   r = icExtractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, "$");
   setTopSO(delim2, "$");
   r = icExtractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json string
   freeO(delim1);
   r = icExtractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   setTopSO(delim1, "$");
   freeO(delim2);
   r = icExtractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallJsont*) allocSmallInt(1);
   setTopSO(delim2, "$");
   r = icExtractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallJson();
   setTopSO(delim1, ";");
   terminateO(delim2);
   delim2 = (smallJsont*) allocSmallInt(1);
   r = icExtractSmallJsonSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallJson();
   // NULL string
   freeO(self);
   freeO(delim1);
   freeO(delim2);
   setTopSO(delim1, ";");
   setTopSO(delim2, ",");
   ck_assert_ptr_eq(icExtractSmallJsonSmallJsonO(self, delim1, delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractSmallJsonSmallJsonO(self, NULL, delim2), NULL);
   ck_assert_ptr_eq(icExtractSmallJsonSmallJsonO(self, delim1, NULL), NULL);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icExtractSmallJsonSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont* delim1   = allocSmallJson();
   smallStringt* delim2 = allocSmallString("S");
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   setTopSO(delim1, "E");
   r = icExtractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim1);
   setTopSO(delim1, "||");
   setValO(delim2, "/");
   r = icExtractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // icExtractSmallJsonSmallStringO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   freeO(delim1);
   setTopSO(delim1, "/");
   setValO(delim2, " ");
   r = icExtractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   freeO(delim1);
   setTopSO(delim1, "e ");
   setValO(delim2, "|");
   r = icExtractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim1);
   setTopSO(delim1, "");
   setValO(delim2, "Ad");
   r = icExtractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim1);
   setTopSO(delim1, "A");
   setValO(delim2, "");
   r = icExtractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(delim1);
   setTopSO(delim1, "$");
   setValO(delim2, "#");
   r = icExtractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   freeO(delim1);
   setTopSO(delim1, "$");
   setValO(delim2, "$");
   r = icExtractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json string
   freeO(delim1);
   r = icExtractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallJsont*) allocSmallInt(1);
   r = icExtractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallJson();
   setTopSO(delim1, ";");
   terminateO(delim2);
   delim2 = (smallStringt*) allocSmallInt(1);
   r = icExtractSmallJsonSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallString(",");
   // NULL string
   freeO(self);
   freeO(delim1);
   setTopSO(delim1, ";");
   ck_assert_ptr_eq(icExtractSmallJsonSmallStringO(self, delim1, delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractSmallJsonSmallStringO(self, NULL, delim2), NULL);
   ck_assert_ptr_eq(icExtractSmallJsonSmallStringO(self, delim1, NULL), NULL);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icExtractSmallJsonSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont* delim1 = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   setTopSO(delim1, "E");
   r = icExtractSmallJsonSO(self, delim1, "S");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim1);
   setTopSO(delim1, "||");
   r = icExtractSmallJsonSO(self, delim1, "/");
   ck_assert_ptr_eq(r, NULL);
   // icExtractSmallJsonSO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   freeO(delim1);
   setTopSO(delim1, "/");
   r = icExtractSmallJsonSO(self, delim1, " ");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   freeO(delim1);
   setTopSO(delim1, "e ");
   r = icExtractSmallJsonSO(self, delim1, "|");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim1);
   setTopSO(delim1, "");
   r = icExtractSmallJsonSO(self, delim1, "Ad");
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim1);
   setTopSO(delim1, "A");
   r = icExtractSmallJsonSO(self, delim1, "");
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(delim1);
   setTopSO(delim1, "$");
   r = icExtractSmallJsonSO(self, delim1, "#");
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   freeO(delim1);
   setTopSO(delim1, "$");
   r = icExtractSmallJsonSO(self, delim1, "$");
   ck_assert_ptr_eq(r, NULL);
   // non json string
   freeO(delim1);
   r = icExtractSmallJsonSO(self, delim1, "$");
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallJsont*) allocSmallInt(1);
   r = icExtractSmallJsonSO(self, delim1, "$");
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallJson();
   // NULL string
   freeO(self);
   freeO(delim1);
   setTopSO(delim1, ";");
   ck_assert_ptr_eq(icExtractSmallJsonSO(self, delim1, ","), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractSmallJsonSO(self, NULL, ","), NULL);
   ck_assert_ptr_eq(icExtractSmallJsonSO(self, delim1, NULL), NULL);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void icExtractSmallJsonCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont* delim1 = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   setTopSO(delim1, "E");
   r = icExtractSmallJsonCharO(self, delim1, 'S');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim1);
   setTopSO(delim1, "||");
   r = icExtractSmallJsonCharO(self, delim1, '/');
   ck_assert_ptr_eq(r, NULL);
   // icExtractSmallJsonCharO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   freeO(delim1);
   setTopSO(delim1, "/");
   r = icExtractSmallJsonCharO(self, delim1, ' ');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   freeO(delim1);
   setTopSO(delim1, "e ");
   r = icExtractSmallJsonCharO(self, delim1, '|');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim1);
   setTopSO(delim1, "");
   r = icExtractSmallJsonCharO(self, delim1, 'd');
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(delim1);
   setTopSO(delim1, "$");
   r = icExtractSmallJsonCharO(self, delim1, '#');
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   freeO(delim1);
   setTopSO(delim1, "$");
   r = icExtractSmallJsonCharO(self, delim1, '$');
   ck_assert_ptr_eq(r, NULL);
   // non json string
   freeO(delim1);
   r = icExtractSmallJsonCharO(self, delim1, '$');
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallJsont*) allocSmallInt(1);
   r = icExtractSmallJsonCharO(self, delim1, '$');
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallJson();
   // NULL string
   freeO(self);
   freeO(delim1);
   setTopSO(delim1, ";");
   ck_assert_ptr_eq(icExtractSmallJsonCharO(self, delim1, ','), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractSmallJsonCharO(self, NULL, ','), NULL);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void icExtractSmallStringSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt* delim1 = allocSmallString("E");
   smallJsont* delim2   = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   setTopSO(delim2, "S");
   r = icExtractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim2);
   setValO(delim1, "||");
   setTopSO(delim2, "/");
   r = icExtractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // icExtractSmallStringSmallJsonO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   freeO(delim2);
   setValO(delim1, "/");
   setTopSO(delim2, " ");
   r = icExtractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   freeO(delim2);
   setValO(delim1, "e ");
   setTopSO(delim2, "|");
   r = icExtractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim2);
   setValO(delim1, "");
   setTopSO(delim2, "Ad");
   r = icExtractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim2);
   setValO(delim1, "A");
   setTopSO(delim2, "");
   r = icExtractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(delim2);
   setValO(delim1, "$");
   setTopSO(delim2, "#");
   r = icExtractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   freeO(delim2);
   setValO(delim1, "$");
   setTopSO(delim2, "$");
   r = icExtractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json string
   freeO(delim2);
   r = icExtractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallStringt*) allocSmallInt(1);
   setTopSO(delim2, "$");
   r = icExtractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallString(";");
   terminateO(delim2);
   delim2 = (smallJsont*) allocSmallInt(1);
   r = icExtractSmallStringSmallJsonO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallJson();
   // NULL string
   freeO(self);
   freeO(delim2);
   setValO(delim1, ";");
   setTopSO(delim2, ",");
   ck_assert_ptr_eq(icExtractSmallStringSmallJsonO(self, delim1, delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractSmallStringSmallJsonO(self, NULL, delim2), NULL);
   ck_assert_ptr_eq(icExtractSmallStringSmallJsonO(self, delim1, NULL), NULL);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icExtractSmallStringSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt* delim1 = allocSmallString("E");
   smallStringt* delim2 = allocSmallString("|");
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   setValO(delim2, "S");
   r = icExtractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   setValO(delim1, "||");
   setValO(delim2, "/");
   r = icExtractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // icExtractSmallStringSmallStringO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   setValO(delim1, "/");
   setValO(delim2, " ");
   r = icExtractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   setValO(delim1, "e ");
   setValO(delim2, "|");
   r = icExtractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim1, "");
   setValO(delim2, "Ad");
   r = icExtractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim1, "A");
   setValO(delim2, "");
   r = icExtractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(delim1, "$");
   setValO(delim2, "#");
   r = icExtractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   setValO(delim1, "$");
   setValO(delim2, "$");
   r = icExtractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallStringt*) allocSmallInt(1);
   r = icExtractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallString(";");
   terminateO(delim2);
   delim2 = (smallStringt*) allocSmallInt(1);
   r = icExtractSmallStringSmallStringO(self, delim1, delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallString(",");
   // NULL string
   freeO(self);
   setValO(delim1, ";");
   ck_assert_ptr_eq(icExtractSmallStringSmallStringO(self, delim1, delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractSmallStringSmallStringO(self, NULL, delim2), NULL);
   ck_assert_ptr_eq(icExtractSmallStringSmallStringO(self, delim1, NULL), NULL);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icExtractSmallStringSSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt* delim1 = allocSmallString("E");
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   r = icExtractSmallStringSO(self, delim1, "S");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   setValO(delim1, "||");
   r = icExtractSmallStringSO(self, delim1, "/");
   ck_assert_ptr_eq(r, NULL);
   // icExtractSmallStringSO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   setValO(delim1, "/");
   r = icExtractSmallStringSO(self, delim1, " ");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   setValO(delim1, "e ");
   r = icExtractSmallStringSO(self, delim1, "|");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim1, "");
   r = icExtractSmallStringSO(self, delim1, "Ad");
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim1, "A");
   r = icExtractSmallStringSO(self, delim1, "");
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(delim1, "$");
   r = icExtractSmallStringSO(self, delim1, "#");
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   setValO(delim1, "$");
   r = icExtractSmallStringSO(self, delim1, "$");
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallStringt*) allocSmallInt(1);
   r = icExtractSmallStringSO(self, delim1, "$");
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallString(";");
   // NULL string
   freeO(self);
   setValO(delim1, ";");
   ck_assert_ptr_eq(icExtractSmallStringSO(self, delim1, ","), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractSmallStringSO(self, NULL, ","), NULL);
   ck_assert_ptr_eq(icExtractSmallStringSO(self, delim1, NULL), NULL);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void icExtractSmallStringCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt* delim1 = allocSmallString("E");
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   r = icExtractSmallStringCharO(self, delim1, 'S');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   setValO(delim1, "||");
   r = icExtractSmallStringCharO(self, delim1, '/');
   ck_assert_ptr_eq(r, NULL);
   // icExtractSmallStringCharO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   setValO(delim1, "/");
   r = icExtractSmallStringCharO(self, delim1, ' ');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   setValO(delim1, "e ");
   r = icExtractSmallStringCharO(self, delim1, '|');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim1, "");
   r = icExtractSmallStringCharO(self, delim1, 'A');
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim1, "A");
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(delim1, "$");
   r = icExtractSmallStringCharO(self, delim1, '#');
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   setValO(delim1, "$");
   r = icExtractSmallStringCharO(self, delim1, '$');
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim1);
   delim1 = (smallStringt*) allocSmallInt(1);
   r = icExtractSmallStringCharO(self, delim1, '$');
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim1);
   delim1 = allocSmallString(";");
   // NULL string
   freeO(self);
   setValO(delim1, ";");
   ck_assert_ptr_eq(icExtractSmallStringCharO(self, delim1, ','), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractSmallStringCharO(self, NULL, ','), NULL);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void icExtractSSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont* delim2 = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   setTopSO(delim2, "S");
   r = icExtractSSmallJsonO(self, "E", delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim2);
   setTopSO(delim2, "/");
   r = icExtractSSmallJsonO(self, "||", delim2);
   ck_assert_ptr_eq(r, NULL);
   // icExtractSSmallJsonO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   freeO(delim2);
   setTopSO(delim2, " ");
   r = icExtractSSmallJsonO(self, "/", delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   freeO(delim2);
   setTopSO(delim2, "|");
   r = icExtractSSmallJsonO(self, "e ", delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim2);
   setTopSO(delim2, "Ad");
   r = icExtractSSmallJsonO(self, "", delim2);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim2);
   setTopSO(delim2, "");
   r = icExtractSSmallJsonO(self, "A", delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(delim2);
   setTopSO(delim2, "#");
   r = icExtractSSmallJsonO(self, "$", delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   freeO(delim2);
   setTopSO(delim2, "$");
   r = icExtractSSmallJsonO(self, "$", delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json string
   freeO(delim2);
   r = icExtractSSmallJsonO(self, "$", delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim2);
   delim2 = (smallJsont*) allocSmallInt(1);
   r = icExtractSSmallJsonO(self, ";", delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallJson();
   // NULL string
   freeO(self);
   freeO(delim2);
   setTopSO(delim2, ",");
   ck_assert_ptr_eq(icExtractSSmallJsonO(self, ";", delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractSSmallJsonO(self, NULL, delim2), NULL);
   ck_assert_ptr_eq(icExtractSSmallJsonO(self, ";", NULL), NULL);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icExtractSSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt* delim2 = allocSmallString("|");
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   setValO(delim2, "S");
   r = icExtractSSmallStringO(self, "E", delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   setValO(delim2, "/");
   r = icExtractSSmallStringO(self, "||", delim2);
   ck_assert_ptr_eq(r, NULL);
   // icExtractSSmallStringO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   setValO(delim2, " ");
   r = icExtractSSmallStringO(self, "/", delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   setValO(delim2, "|");
   r = icExtractSSmallStringO(self, "e ", delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim2, "Ad");
   r = icExtractSSmallStringO(self, "", delim2);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim2, "");
   r = icExtractSSmallStringO(self, "A", delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(delim2, "#");
   r = icExtractSSmallStringO(self, "$", delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   setValO(delim2, "$");
   r = icExtractSSmallStringO(self, "$", delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim2);
   delim2 = (smallStringt*) allocSmallInt(1);
   r = icExtractSSmallStringO(self, ";", delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallString(",");
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icExtractSSmallStringO(self, ";", delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractSSmallStringO(self, NULL, delim2), NULL);
   ck_assert_ptr_eq(icExtractSSmallStringO(self, ";", NULL), NULL);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icExtractCharSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallJsont* delim2 = allocSmallJson();
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   setTopSO(delim2, "S");
   r = icExtractCharSmallJsonO(self, 'E', delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   freeO(delim2);
   setTopSO(delim2, "/");
   r = icExtractCharSmallJsonO(self, '|', delim2);
   ck_assert_ptr_eq(r, NULL);
   // icExtractCharSmallJsonO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   freeO(delim2);
   setTopSO(delim2, " ");
   r = icExtractCharSmallJsonO(self, '/', delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   freeO(delim2);
   setTopSO(delim2, "|");
   r = icExtractCharSmallJsonO(self, ' ', delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   freeO(delim2);
   setTopSO(delim2, "");
   r = icExtractCharSmallJsonO(self, 'A', delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   freeO(delim2);
   setTopSO(delim2, "#");
   r = icExtractCharSmallJsonO(self, '$', delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   freeO(delim2);
   setTopSO(delim2, "$");
   r = icExtractCharSmallJsonO(self, '$', delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json string
   freeO(delim2);
   r = icExtractCharSmallJsonO(self, '$', delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim2);
   delim2 = (smallJsont*) allocSmallInt(1);
   r = icExtractCharSmallJsonO(self, ';', delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallJson();
   // NULL string
   freeO(self);
   freeO(delim2);
   setTopSO(delim2, ",");
   ck_assert_ptr_eq(icExtractCharSmallJsonO(self, ';', delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractCharSmallJsonO(self, ';', NULL), NULL);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icExtractCharSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "");
   smallStringt* delim2 = allocSmallString("|");
 
   // string
   freeO(self);
   setTopSO(self, "one/twos");
   setValO(delim2, "S");
   r = icExtractCharSmallStringO(self, 'E', delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   // delimiter not found
   freeO(self);
   setTopSO(self, "one/two");
   setValO(delim2, "/");
   r = icExtractCharSmallStringO(self, '|', delim2);
   ck_assert_ptr_eq(r, NULL);
   // icExtractCharSmallStringO with several delimiters after each other
   freeO(self);
   setTopSO(self, "one/ two  /three ");
   setValO(delim2, " ");
   r = icExtractCharSmallStringO(self, '/', delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"\",\"three\"]");
   free(s);
   terminateO(r);
   // multiple character delimiter
   freeO(self);
   setTopSO(self, "AAe thre|e icExtract");
   setValO(delim2, "|e");
   r = icExtractCharSmallStringO(self, ' ', delim2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"thre\"]");
   free(s);
   terminateO(r);
   // empty delimiter
   freeO(self);
   setTopSO(self, "AAd");
   setValO(delim2, "");
   r = icExtractCharSmallStringO(self, 'A', delim2);
   ck_assert_ptr_eq(r, NULL);
   // empty string
   freeO(self);
   setTopSO(self, "");
   setValO(delim2, "#");
   r = icExtractCharSmallStringO(self, '$', delim2);
   ck_assert_ptr_eq(r, NULL);
   // delim1 = delim2
   freeO(self);
   setTopSO(self, "$qwe$");
   setValO(delim2, "$");
   r = icExtractCharSmallStringO(self, '$', delim2);
   ck_assert_ptr_eq(r, NULL);
   // non json object
   terminateO(delim2);
   delim2 = (smallStringt*) allocSmallInt(1);
   r = icExtractCharSmallStringO(self, ';', delim2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(delim2);
   delim2 = allocSmallString(",");
   // NULL string
   freeO(self);
   ck_assert_ptr_eq(icExtractCharSmallStringO(self, ';', delim2), NULL);
   // NULL delimiter
   freeO(self);
   setTopSO(self, "test");
   ck_assert_ptr_eq(icExtractCharSmallStringO(self, ';', NULL), NULL);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void colorSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "qwe");
 
   r = colorO(self, RED);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, RED"qwe"RST);
   free(s);
   // null color
   r = colorO(self, null);
   ck_assert_ptr_eq(r, NULL);
   // empty self
   freeO(self);
   r = colorO(self, RED);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void colordSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   setTopSO(self, "qwe");
 
   r = colordO(self, RED);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, RED"qwe"RST);
   free(r);
   // empty string
   emptyO(self);
   r = colordO(self, RED);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "");
   free(r);
   // null color
   r = colordO(self, null);
   ck_assert_ptr_eq(r, NULL);
   // empty self
   freeO(self);
   r = colordO(self, RED);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void zipSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *array1 = allocSmallArray();
   smallArrayt *array2 = allocSmallArray();
 
   // non json array or dict
   setTypeBoolO(self);
   r = zipO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   // json array
   // zip arrays
   //   empty self
   freeO(self);
   array1->f->pushS(array1, "a");
   array2->f->pushInt(array2, 1);
   r = zipO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",1]]");
   free(s);
   disposeO(array1);
   disposeO(array2);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array1->f->pushS(array1, "a");
   array1->f->pushS(array1, "b");
   array2->f->pushInt(array2, 1);
   array2->f->pushInt(array2, 2);
   array2->f->pushInt(array2, 3);
   r = zipO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   //    delete the element not in self
   delElemO(array2, 2);
   // empty arrays
   disposeO(array2);
   r = zipO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   disposeO(array1);
   r = zipO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   // array1 and array2 same element count
   array1->f->pushS(array1, "aa");
   array1->f->pushS(array1, "bb");
   array2->f->pushInt(array2, 11);
   array2->f->pushInt(array2, 22);
   delElemO(array1, 1);
   r = zipO(self, array1, array2);
   delElemO(array2, 1);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]");
   free(s);
   // but an element is NULL
   // non smallArray objects
   smashO(array1);
   array1 = (smallArrayt*) allocSmallInt(2);
   r = zipO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array1);
   array1 = allocSmallArray();
   smashO(array2);
   array2 = (smallArrayt*) allocSmallInt(2);
   r = zipO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array2);
   array2 = allocSmallArray();
   // NULL arrays
   r = zipO(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = zipO(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   smashO(array1);
   smashO(array2);
   // json dict
   self = allocSmallJson();
   setTypeDictO(self);
   smallArrayt *keys   = allocSmallArray();
   smallArrayt *values = allocSmallArray();
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys->f->pushS(keys, "a");
   keys->f->pushS(keys, "b");
   keys->f->pushS(keys, "c");
   values->f->pushInt(values, 1);
   values->f->pushInt(values, 2);
   r = zipO(self, keys, values);
   terminateO(keys);
   smashO(values);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":1,\"b\":2}");
   free(s);
   // keys array with non string objects
   keys   = allocSmallArray();
   values = allocSmallArray();
   keys->f->pushInt(keys, 1);
   values->f->pushInt(values, 1);
   r = zipO(self, keys, values);
   ck_assert_ptr_eq(r, NULL);
   terminateO(keys);
   terminateO(values);
   // empty values
   keys   = allocSmallArray();
   values = allocSmallArray();
   keys->f->pushInt(keys, 1);
   r = zipO(self, keys, values);
   ck_assert_ptr_eq(r, self);
   terminateO(keys);
   terminateO(values);
   terminateO(self);
 
 }
 
 
 void zipArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char** array1;
   smallArrayt *array2 = allocSmallArray();
 
   // non json array or dict
   setTypeBoolO(self);
   array1 = listCreateS("a");
   r = zipArrayO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   // json array
   // zip arrays
   //   empty self
   freeO(self);
   array2->f->pushInt(array2, 1);
   r       = zipArrayO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",1]]");
   free(s);
   freen(array1);
   disposeO(array2);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array1  = listCreateS("a", "b");
   array2->f->pushInt(array2, 1);
   array2->f->pushInt(array2, 2);
   array2->f->pushInt(array2, 3);
   r = zipArrayO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   //    delete the element not in self
   delElemO(array2, 2);
   // empty arrays
   disposeO(array2);
   r = zipArrayO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   iListRemoveS(&array1, 0, 2);
   r = zipArrayO(self, array1, array2);
   free(array1);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   // array1 and array2 same element count
   array1 = listCreateS("aa", "bb");
   array2->f->pushInt(array2, 11);
   array2->f->pushInt(array2, 22);
   iListDelElemS(&array1, 1);
   r = zipArrayO(self, array1, array2);
   delElemO(array2, 1);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]");
   free(s);
   // but an element is NULL
   // non smallArray objects
   smashO(array2);
   array2 = (smallArrayt*) allocSmallInt(2);
   r = zipArrayO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array2);
   array2 = allocSmallArray();
   // NULL arrays
   r = zipArrayO(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = zipArrayO(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   free(array1);
   smashO(array2);
   // json dict
   self = allocSmallJson();
   char** keys;
   smallArrayt *values = allocSmallArray();
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys = listCreateS("a", "b", "c");
   values->f->pushInt(values, 1);
   values->f->pushInt(values, 2);
   r = zipArrayO(self, keys, values);
   listFreeS(keys);
   smashO(values);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":1,\"b\":2}");
   free(s);
   // empty values
   keys   = listCreateS("a");
   values = allocSmallArray();
   r = zipArrayO(self, keys, values);
   ck_assert_ptr_eq(r, self);
   listFreeS(keys);
   terminateO(values);
   terminateO(self);
 
 }
 
 
 void zipCArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   const char* array1[] = {"a", "b", null};
   smallArrayt *array2  = allocSmallArray();
 
   // non json array or dict
   setTypeBoolO(self);
   r = zipCArrayO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   // json array
   // zip arrays
   //   empty self
   freeO(self);
   array2->f->pushInt(array2, 1);
   r       = zipCArrayO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",1]]");
   free(s);
   disposeO(array2);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array2->f->pushInt(array2, 1);
   array2->f->pushInt(array2, 2);
   array2->f->pushInt(array2, 3);
   r = zipCArrayO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   //    delete the element not in self
   delElemO(array2, 2);
   // empty arrays
   disposeO(array2);
   r = zipCArrayO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   array1[0] = null;
   r = zipCArrayO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   // array1 and array2 same element count
   array1[0] = "aa";
   array1[1] = null;
   array2->f->pushInt(array2, 11);
   array2->f->pushInt(array2, 22);
   r = zipCArrayO(self, array1, array2);
   delElemO(array2, 1);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]");
   free(s);
   // but an element is NULL
   // non smallArray objects
   smashO(array2);
   array2 = (smallArrayt*) allocSmallInt(2);
   r = zipCArrayO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array2);
   array2 = allocSmallArray();
   // NULL arrays
   r = zipCArrayO(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = zipCArrayO(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   smashO(array2);
   // json dict
   self = allocSmallJson();
   const char* keys[] = {"a", "b", "c", null};
   smallArrayt *values = allocSmallArray();
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   values->f->pushInt(values, 1);
   values->f->pushInt(values, 2);
   r = zipCArrayO(self, keys, values);
   smashO(values);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":1,\"b\":2}");
   free(s);
   // empty values
   values = allocSmallArray();
   r = zipCArrayO(self, keys, values);
   ck_assert_ptr_eq(r, self);
   terminateO(values);
   terminateO(self);
 
 }
 
 
 void zipCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *array1 = allocSmallArray();
   char** array2;
 
   // non json array or dict
   setTypeBoolO(self);
   array2 = listCreateS("1");
   r = zipCharO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   // json array
   // zip arrays
   //   empty self
   freeO(self);
   array1->f->pushS(array1, "a");
   r       = zipCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"1\"]]");
   free(s);
   disposeO(array1);
   freen(array2);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array1->f->pushS(array1, "a");
   array1->f->pushS(array1, "b");
   array2  = listCreateS("1", "2", "3");
   r = zipCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   //    delete the element not in self
   iListDelElemS(&array2, 2);
   // empty arrays
   iListRemoveS(&array2, 0, 2);
   r = zipCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   disposeO(array1);
   r = zipCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   free(array2);
   // array1 and array2 same element count
   array1->f->pushS(array1, "aa");
   array1->f->pushS(array1, "bb");
   array2  = listCreateS("11", "22");
   delElemO(array1, 1);
   r = zipCharO(self, array1, array2);
   iListDelElemS(&array2, 1);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]");
   free(s);
   // but an element is NULL
   // non smallJson objects
   smashO(array1);
   array1 = (smallArrayt*) allocSmallInt(2);
   r = zipCharO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array1);
   array1 = allocSmallArray();
   // NULL arrays
   r = zipCharO(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = zipCharO(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   smashO(array1);
   free(array2);
   // json dict
   self = allocSmallJson();
   smallArrayt *keys = allocSmallArray();
   char** values;
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys->f->pushS(keys, "a");
   keys->f->pushS(keys, "b");
   keys->f->pushS(keys, "c");
   values = listCreateS("1", "2");
   r = zipCharO(self, keys, values);
   terminateO(keys);
   listFreeS(values);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":\"1\",\"b\":\"2\"}");
   free(s);
   // keys array with non string objects
   keys   = allocSmallArray();
   keys->f->pushInt(keys, 1);
   values = listCreateS("1");
   r = zipCharO(self, keys, values);
   ck_assert_ptr_eq(r, NULL);
   terminateO(keys);
   listFreeS(values);
   // empty values
   keys   = allocSmallArray();
   keys->f->pushInt(keys, 1);
   listEmptyS(values);
   r = zipCharO(self, keys, values);
   ck_assert_ptr_eq(r, self);
   terminateO(keys);
   listFreeS(values);
   terminateO(self);
 
 }
 
 
 void zipCCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocSmallJson();
   smallArrayt *array1  = allocSmallArray();
   const char* array2[] = {"1", "2", "3", null};
 
   // non json array or dict
   setTypeBoolO(self);
   r = zipCCharO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   // json array
   // zip arrays
   //   empty self
   freeO(self);
   array1->f->pushS(array1, "a");
   r       = zipCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"1\"]]");
   free(s);
   disposeO(array1);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array1->f->pushS(array1, "a");
   array1->f->pushS(array1, "b");
   r = zipCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   // empty arrays
   array2[0] = null;
   r = zipCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   disposeO(array1);
   array2[0] = "1";
   r = zipCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   // array1 and array2 same element count
   array1->f->pushS(array1, "aa");
   array1->f->pushS(array1, "bb");
   array2[0] = "11";
   array2[1] = "22";
   array2[2] = null;
   delElemO(array1, 1);
   r = zipCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]");
   free(s);
   // but an element is NULL
   // non smallJson objects
   smashO(array1);
   array1 = (smallArrayt*) allocSmallInt(2);
   r = zipCCharO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array1);
   array1 = allocSmallArray();
   // NULL arrays
   r = zipCCharO(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = zipCCharO(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   smashO(array1);
   // json dict
   self = allocSmallJson();
   smallArrayt *keys = allocSmallArray();
   const char* values[] = {"1", "2", null};
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys->f->pushS(keys, "a");
   keys->f->pushS(keys, "b");
   keys->f->pushS(keys, "c");
   r = zipCCharO(self, keys, values);
   terminateO(keys);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":\"1\",\"b\":\"2\"}");
   free(s);
   // keys array with non string objects
   keys   = allocSmallArray();
   keys->f->pushInt(keys, 1);
   r = zipCCharO(self, keys, values);
   ck_assert_ptr_eq(r, NULL);
   terminateO(keys);
   // empty values
   keys   = allocSmallArray();
   keys->f->pushInt(keys, 1);
   values[0] = null;
   r = zipCCharO(self, keys, values);
   ck_assert_ptr_eq(r, self);
   terminateO(keys);
   terminateO(self);
 
 }
 
 
 void zipArrayCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char** array1;
   char** array2;
 
   // non json array or dict
   setTypeBoolO(self);
   array1 = listCreateS("a");
   array2 = listCreateS("1");
   r = zipArrayCharO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   // json array
   // zip arrays
   //   empty self
   freeO(self);
   r       = zipArrayCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"1\"]]");
   free(s);
   freen(array1);
   freen(array2);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array1  = listCreateS("a", "b");
   array2  = listCreateS("1", "2", "3");
   r = zipArrayCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   //    delete the element not in self
   iListDelElemS(&array2, 2);
   // empty arrays
   iListRemoveS(&array2, 0, 2);
   r = zipArrayCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   iListRemoveS(&array1, 0, 2);
   r = zipArrayCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   free(array1);
   free(array2);
   // array1 and array2 same element count
   array1 = listCreateS("aa", "bb");
   array2 = listCreateS("11", "22");
   iListDelElemS(&array1, 1);
   r = zipArrayCharO(self, array1, array2);
   iListDelElemS(&array2, 1);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]");
   free(s);
   // but an element is NULL
   // NULL arrays
   r = zipArrayCharO(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = zipArrayCharO(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   free(array1);
   free(array2);
   // json dict
   self = allocSmallJson();
   char** keys;
   char** values;
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys   = listCreateS("a", "b", "c");
   values = listCreateS("1", "2");
   r = zipArrayCharO(self, keys, values);
   listFreeS(keys);
   listFreeS(values);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":\"1\",\"b\":\"2\"}");
   free(s);
   // empty values
   keys = listCreateS("a", "b", "c");
   listEmptyS(values);
   r = zipArrayCharO(self, keys, values);
   ck_assert_ptr_eq(r, self);
   listFreeS(keys);
   listFreeS(values);
   terminateO(self);
 
 }
 
 
 void zipCArrayCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   const char* array1[] = {"a", "b", null};
   char** array2;
 
   // non json array or dict
   setTypeBoolO(self);
   array2 = listCreateS("1");
   r = zipCArrayCharO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   // json array
   // zip arrays
   //   empty self
   freeO(self);
   r       = zipCArrayCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"1\"]]");
   free(s);
   freen(array2);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array2  = listCreateS("1", "2", "3");
   r = zipCArrayCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   //    delete the element not in self
   iListDelElemS(&array2, 2);
   // empty arrays
   iListRemoveS(&array2, 0, 2);
   r = zipCArrayCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   array1[0] = null;
   r = zipCArrayCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   free(array2);
   // array1 and array2 same element count
   array1[0] = "aa";
   array1[1] = null;
   array2 = listCreateS("11", "22");
   r = zipCArrayCharO(self, array1, array2);
   iListDelElemS(&array2, 1);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]");
   free(s);
   // but an element is NULL
   // NULL arrays
   r = zipCArrayCharO(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = zipCArrayCharO(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   free(array2);
   // json dict
   self = allocSmallJson();
   const char* keys[] = {"a", "b", "c", null};
   char** values;
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   values = listCreateS("1", "2");
   r = zipCArrayCharO(self, keys, values);
   listFreeS(values);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":\"1\",\"b\":\"2\"}");
   free(s);
   // empty values
   listEmptyS(values);
   r = zipCArrayCharO(self, keys, values);
   ck_assert_ptr_eq(r, self);
   listFreeS(values);
   terminateO(self);
 
 }
 
 
 void zipArrayCCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char** array1;
   const char* array2[] = {"1", "2", "3", null};
 
   // non json array or dict
   setTypeBoolO(self);
   array1 = listCreateS("a");
   r = zipArrayCCharO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   // json array
   // zip arrays
   //   empty self
   freeO(self);
   r       = zipArrayCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"1\"]]");
   free(s);
   freen(array1);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array1  = listCreateS("a", "b");
   r = zipArrayCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   // empty arrays
   array2[0] = null;
   r = zipArrayCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   iListRemoveS(&array1, 0, 2);
   array2[0] = "11";
   r = zipArrayCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   free(array1);
   // array1 and array2 same element count
   array1 = listCreateS("aa", "bb");
   array2[1] = "22";
   iListDelElemS(&array1, 1);
   r = zipArrayCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]");
   free(s);
   // but an element is NULL
   // NULL arrays
   r = zipArrayCCharO(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = zipArrayCCharO(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   free(array1);
   // json dict
   self = allocSmallJson();
   char** keys;
   const char* values[] = {"1", "2", null};
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys   = listCreateS("a", "b", "c");
   r = zipArrayCCharO(self, keys, values);
   listFreeS(keys);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":\"1\",\"b\":\"2\"}");
   free(s);
   // empty values
   keys = listCreateS("a", "b", "c");
   values[0] = null;
   r = zipArrayCCharO(self, keys, values);
   ck_assert_ptr_eq(r, self);
   listFreeS(keys);
   terminateO(self);
 
 }
 
 
 void zipCArrayCCharSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   const char* array1[] = {"a", "b", null};
   const char* array2[] = {"1", "2", "3", null};
 
   // non json array or dict
   setTypeBoolO(self);
   r = zipCArrayCCharO(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   // json array
   // zip arrays
   //   empty self
   freeO(self);
   array1[1] = null;
   r       = zipCArrayCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"1\"]]");
   free(s);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array1[1] = "b";
   r = zipCArrayCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   // empty arrays
   array2[0] = null;
   r = zipCArrayCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   array1[0] = null;
   array2[0] = "11";
   r = zipCArrayCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   // array1 and array2 same element count
   array1[0] = "aa";
   array1[1] = null;
   array2[1] = "22";
   r = zipCArrayCCharO(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]");
   free(s);
   // but an element is NULL
   // NULL arrays
   r = zipCArrayCCharO(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = zipCArrayCCharO(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   // json dict
   self = allocSmallJson();
   const char* keys[]   = {"a", "b", "c", null};
   const char* values[] = {"1", "2", null};
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   r = zipCArrayCCharO(self, keys, values);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":\"1\",\"b\":\"2\"}");
   free(s);
   // empty values
   values[0] = null;
   r = zipCArrayCCharO(self, keys, values);
   ck_assert_ptr_eq(r, self);
   terminateO(self);
 
 }
 
 
 void zipJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallJsont *keys   = allocSmallJson();
   smallJsont *values = allocSmallJson();
 
   // non json array or dict
   setTypeBoolO(self);
   r = self->f->zipJson(self, keys, values);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   // json array
   smallJsont *array1 = allocSmallJson();
   smallJsont *array2 = allocSmallJson();
   // zip arrays
   //   empty self
   array1->f->pushS(array1, "a");
   array2->f->pushInt(array2, 1);
   r = self->f->zipJson(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",1]]");
   free(s);
   disposeO(array1);
   disposeO(array2);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array1->f->pushS(array1, "a");
   array1->f->pushS(array1, "b");
   array2->f->pushInt(array2, 1);
   array2->f->pushInt(array2, 2);
   array2->f->pushInt(array2, 3);
   r       = self->f->zipJson(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   //    delete the element not in self
   delElemIndexO(array2, 2);
   // empty arrays
   disposeO(array1);
   r = self->f->zipJson(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   disposeO(array2);
   array1->f->pushS(array1, "a");
   r = self->f->zipJson(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   array2->f->pushInt(array2, 1);
   delElemIndexO(array2, 0);
   r = self->f->zipJson(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"a\"]]");
   free(s);
   disposeO(array1);
   trimO(array2);
   // array1 and array2 same element count
   array1->f->pushS(array1, "aa");
   array1->f->pushS(array1, "bb");
   array2->f->pushInt(array2, 11);
   array2->f->pushInt(array2, 22);
   delElemIndexO(array1, 1);
   r = self->f->zipJson(self, array1, array2);
   delElemIndexO(array2, 1);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"a\"],[\"aa\",11]]");
   free(s);
   // but an element is NULL
   // non smallJson objects
   smashO(array1);
   array1 = (smallJsont*) allocSmallInt(2);
   r = self->f->zipJson(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array1);
   array1 = allocSmallJson();
   smashO(array2);
   array2 = (smallJsont*) allocSmallInt(2);
   r = self->f->zipJson(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array2);
   array2 = allocSmallJson();
   // NULL arrays
   r = self->f->zipJson(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = self->f->zipJson(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   smashO(array1);
   smashO(array2);
   // json dict
   self = allocSmallJson();
   // zip arrays
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys->f->pushS(keys, "a");
   keys->f->pushS(keys, "b");
   keys->f->pushS(keys, "c");
   values->f->pushInt(values, 1);
   values->f->pushInt(values, 2);
   r = self->f->zipJson(self, keys, values);
   terminateO(keys);
   smashO(values);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":1,\"b\":2}");
   free(s);
   // keys array with non string objects
   keys   = allocSmallJson();
   values = allocSmallJson();
   keys->f->pushInt(keys, 1);
   values->f->pushInt(values, 1);
   r = self->f->zipJson(self, keys, values);
   ck_assert_ptr_eq(r, NULL);
   terminateO(keys);
   terminateO(values);
   // empty values
   keys   = allocSmallJson();
   values = allocSmallJson();
   keys->f->pushInt(keys, 1);
   values->f->pushInt(values, 1);
   delElemIndexO(values, 0);
   trimO(values);
   r = self->f->zipJson(self, keys, values);
   ck_assert_ptr_eq(r, self);
   terminateO(keys);
   // non json array keys
   keys   = allocSmallJson();
   setTopIntO(keys, 1);
   r = self->f->zipJson(self, keys, values);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   // non json array values
   keys   = allocSmallJson();
   keys->f->pushInt(keys, 1);
   freeO(values);
   setTopIntO(values, 1);
   r = self->f->zipJson(self, keys, values);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   terminateO(values);
   // non smallJson object
   keys = (smallJsont*) allocSmallInt(1);
   values = allocSmallJson();
   r = self->f->zipJson(self, keys, values);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   keys   = allocSmallJson();
   terminateO(values);
   values = (smallJsont*) allocSmallInt(2);
   r = self->f->zipJson(self, keys, values);
   ck_assert_ptr_eq(r, null);
   // null
   r = self->f->zipJson(self, null, values);
   ck_assert_ptr_eq(r, null);
   r = self->f->zipJson(self, keys, null);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   terminateO(values);
   terminateO(self);
 
 }
 
 
 void zipJsonSmallArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   smallJsont *keys    = allocSmallJson();
   smallArrayt *values = allocSmallArray();
   smallJsont *array1  = allocSmallJson();
   smallArrayt *array2 = allocSmallArray();
 
   // non json array or dict
   setTypeBoolO(self);
   r = self->f->zipJsonSmallArray(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   // json array
   // zip arrays
   //   empty self
   freeO(self);
   array1->f->pushS(array1, "a");
   array2->f->pushInt(array2, 1);
   r = self->f->zipJsonSmallArray(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",1]]");
   free(s);
   disposeO(array1);
   disposeO(array2);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array1->f->pushS(array1, "a");
   array1->f->pushS(array1, "b");
   array2->f->pushInt(array2, 1);
   array2->f->pushInt(array2, 2);
   array2->f->pushInt(array2, 3);
   r = self->f->zipJsonSmallArray(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   //    delete the element not in self
   delElemO(array2, 2);
   // empty arrays
   disposeO(array2);
   r = self->f->zipJsonSmallArray(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   disposeO(array1);
   setTypeArrayO(array1);
   r = self->f->zipJsonSmallArray(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   // array1 and array2 same element count
   array1->f->pushS(array1, "aa");
   array1->f->pushS(array1, "bb");
   array2->f->pushInt(array2, 11);
   array2->f->pushInt(array2, 22);
   delElemIndexO(array1, 1);
   r = self->f->zipJsonSmallArray(self, array1, array2);
   delElemO(array2, 1);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]");
   free(s);
   // but an element is NULL
   // non smallArray objects
   smashO(array1);
   array1 = (smallJsont*) allocSmallInt(2);
   r = self->f->zipJsonSmallArray(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array1);
   array1 = allocSmallJson();
   setTypeArrayO(array1);
   smashO(array2);
   array2 = (smallArrayt*) allocSmallInt(2);
   r = self->f->zipJsonSmallArray(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array2);
   array2 = allocSmallArray();
   // NULL arrays
   r = self->f->zipJsonSmallArray(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = self->f->zipJsonSmallArray(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   smashO(array1);
   smashO(array2);
   // json dict
   self = allocSmallJson();
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys->f->pushS(keys, "a");
   keys->f->pushS(keys, "b");
   keys->f->pushS(keys, "c");
   values->f->pushInt(values, 1);
   values->f->pushInt(values, 2);
   r = self->f->zipJsonSmallArray(self, keys, values);
   terminateO(keys);
   smashO(values);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":1,\"b\":2}");
   free(s);
   // keys array with non string objects
   keys   = allocSmallJson();
   values = allocSmallArray();
   keys->f->pushInt(keys, 1);
   values->f->pushInt(values, 1);
   r = self->f->zipJsonSmallArray(self, keys, values);
   ck_assert_ptr_eq(r, NULL);
   terminateO(keys);
   terminateO(values);
   // empty values
   keys   = allocSmallJson();
   values = allocSmallArray();
   keys->f->pushInt(keys, 1);
   r = self->f->zipJsonSmallArray(self, keys, values);
   ck_assert_ptr_eq(r, self);
   terminateO(keys);
   // non json array keys
   keys   = allocSmallJson();
   setTopIntO(keys, 1);
   r = self->f->zipJsonSmallArray(self, keys, values);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   // non smallArray object
   keys = (smallJsont*) allocSmallInt(1);
   r = self->f->zipJsonSmallArray(self, keys, values);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   keys   = allocSmallJson();
   terminateO(values);
   values = (smallArrayt*) allocSmallInt(2);
   r = self->f->zipJsonSmallArray(self, keys, values);
   ck_assert_ptr_eq(r, null);
   // null
   r = self->f->zipJsonSmallArray(self, null, values);
   ck_assert_ptr_eq(r, null);
   r = self->f->zipJsonSmallArray(self, keys, null);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   terminateO(values);
   terminateO(self);
 
 }
 
 
 void zipJsonArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *keys = allocSmallJson();
   char** values;
   smallJsont *array1 = allocSmallJson();
   char** array2;
 
   // non json array or dict
   setTypeBoolO(self);
   setTypeArrayO(array1);
   array2 = listCreateS("1");
   r = self->f->zipJsonArray(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   // json array
   // zip arrays
   //   empty self
   freeO(self);
   array1->f->pushS(array1, "a");
   r       = self->f->zipJsonArray(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"1\"]]");
   free(s);
   disposeO(array1);
   freen(array2);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array1->f->pushS(array1, "a");
   array1->f->pushS(array1, "b");
   array2  = listCreateS("1", "2", "3");
   r = self->f->zipJsonArray(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   //    delete the element not in self
   iListDelElemS(&array2, 2);
   // empty arrays
   iListRemoveS(&array2, 0, 2);
   r = self->f->zipJsonArray(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   disposeO(array1);
   setTypeArrayO(array1);
   r = self->f->zipJsonArray(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   free(array2);
   // array1 and array2 same element count
   array1->f->pushS(array1, "aa");
   array1->f->pushS(array1, "bb");
   array2  = listCreateS("11", "22");
   delElemIndexO(array1, 1);
   r = self->f->zipJsonArray(self, array1, array2);
   iListDelElemS(&array2, 1);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]");
   free(s);
   // but an element is NULL
   // non smallJson objects
   smashO(array1);
   array1 = (smallJsont*) allocSmallInt(2);
   r = self->f->zipJsonArray(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array1);
   array1 = allocSmallJson();
   setTypeArrayO(array1);
   // NULL arrays
   r = self->f->zipJsonArray(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = self->f->zipJsonArray(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   smashO(array1);
   free(array2);
   // json dict
   self = allocSmallJson();
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys->f->pushS(keys, "a");
   keys->f->pushS(keys, "b");
   keys->f->pushS(keys, "c");
   values = listCreateS("1", "2");
   r = self->f->zipJsonArray(self, keys, values);
   terminateO(keys);
   listFreeS(values);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":\"1\",\"b\":\"2\"}");
   free(s);
   // keys array with non string objects
   keys   = allocSmallJson();
   keys->f->pushInt(keys, 1);
   values = listCreateS("1");
   r = self->f->zipJsonArray(self, keys, values);
   ck_assert_ptr_eq(r, NULL);
   terminateO(keys);
   listFreeS(values);
   // empty values
   keys   = allocSmallJson();
   keys->f->pushInt(keys, 1);
   listEmptyS(values);
   r = self->f->zipJsonArray(self, keys, values);
   ck_assert_ptr_eq(r, self);
   terminateO(keys);
   // non json array keys
   keys   = allocSmallJson();
   setTopIntO(keys, 1);
   r = self->f->zipJsonArray(self, keys, values);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   // non smallArray object
   keys = (smallJsont*) allocSmallInt(1);
   r = self->f->zipJsonArray(self, keys, values);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   keys   = allocSmallJson();
   // null
   r = self->f->zipJsonArray(self, null, values);
   ck_assert_ptr_eq(r, null);
   r = self->f->zipJsonArray(self, keys, null);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   listFreeS(values);
   terminateO(self);
 
 }
 
 
 void zipJsonCArraySmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocSmallJson();
   smallJsont *keys     = allocSmallJson();
   const char* values[] = {"1", "2", null};
   smallJsont *array1   = allocSmallJson();
   const char* array2[] = {"1", "2", "3", null};
 
   // non json array or dict
   setTypeBoolO(self);
   setTypeArrayO(array1);
   r = self->f->zipJsonCArray(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   // json array
   // zip arrays
   //   empty self
   freeO(self);
   array1->f->pushS(array1, "a");
   r       = self->f->zipJsonCArray(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"1\"]]");
   free(s);
   disposeO(array1);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array1->f->pushS(array1, "a");
   array1->f->pushS(array1, "b");
   r = self->f->zipJsonCArray(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   // empty arrays
   array2[0] = null;
   r = self->f->zipJsonCArray(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   disposeO(array1);
   setTypeArrayO(array1);
   array2[0] = "11";
   r = self->f->zipJsonCArray(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   // array1 and array2 same element count
   array1->f->pushS(array1, "aa");
   array1->f->pushS(array1, "bb");
   array2[1] = "22";
   delElemIndexO(array1, 1);
   r = self->f->zipJsonCArray(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"],[\"aa\",\"11\"]]");
   free(s);
   // but an element is NULL
   // non smallJson objects
   smashO(array1);
   array1 = (smallJsont*) allocSmallInt(2);
   r = self->f->zipJsonCArray(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array1);
   array1 = allocSmallJson();
   setTypeArrayO(array1);
   // NULL arrays
   r = self->f->zipJsonCArray(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = self->f->zipJsonCArray(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   smashO(array1);
   // json dict
   self = allocSmallJson();
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys->f->pushS(keys, "a");
   keys->f->pushS(keys, "b");
   keys->f->pushS(keys, "c");
   r = self->f->zipJsonCArray(self, keys, values);
   terminateO(keys);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":\"1\",\"b\":\"2\"}");
   free(s);
   // keys array with non string objects
   keys   = allocSmallJson();
   keys->f->pushInt(keys, 1);
   r = self->f->zipJsonCArray(self, keys, values);
   ck_assert_ptr_eq(r, NULL);
   terminateO(keys);
   // empty values
   keys   = allocSmallJson();
   keys->f->pushInt(keys, 1);
   values[0] = null;
   r = self->f->zipJsonCArray(self, keys, values);
   ck_assert_ptr_eq(r, self);
   values[0] = "1";
   terminateO(keys);
   // non json array keys
   keys   = allocSmallJson();
   setTopIntO(keys, 1);
   r = self->f->zipJsonCArray(self, keys, values);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   // non smallArray object
   keys = (smallJsont*) allocSmallInt(1);
   r = self->f->zipJsonCArray(self, keys, values);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   keys   = allocSmallJson();
   // null
   r = self->f->zipJsonCArray(self, null, values);
   ck_assert_ptr_eq(r, null);
   r = self->f->zipJsonCArray(self, keys, null);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   terminateO(self);
 
 }
 
 
 void zipSmallArrayJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *keys  = allocSmallArray();
   smallJsont *values = allocSmallJson();
 
   // non json array or dict
   setTypeBoolO(self);
   r = self->f->zipSmallArrayJson(self, keys, values);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   // json array
   smallArrayt *array1 = allocSmallArray();
   smallJsont *array2  = allocSmallJson();
   // zip arrays
   //   empty self
   array1->f->pushS(array1, "a");
   array2->f->pushInt(array2, 1);
   r = self->f->zipSmallArrayJson(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",1]]");
   free(s);
   disposeO(array1);
   disposeO(array2);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array1->f->pushS(array1, "a");
   array1->f->pushS(array1, "b");
   array2->f->pushInt(array2, 1);
   array2->f->pushInt(array2, 2);
   array2->f->pushInt(array2, 3);
   r       = self->f->zipSmallArrayJson(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   //    delete the element not in self
   delElemIndexO(array2, 2);
   // empty arrays
   disposeO(array1);
   r = self->f->zipSmallArrayJson(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   disposeO(array2);
   array1->f->pushS(array1, "a");
   r = self->f->zipSmallArrayJson(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   array2->f->pushInt(array2, 1);
   delElemIndexO(array2, 0);
   r = self->f->zipSmallArrayJson(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"a\"]]");
   free(s);
   disposeO(array1);
   trimO(array2);
   // array1 and array2 same element count
   array1->f->pushS(array1, "aa");
   array1->f->pushS(array1, "bb");
   array2->f->pushInt(array2, 11);
   array2->f->pushInt(array2, 22);
   delElemO(array1, 1);
   r = self->f->zipSmallArrayJson(self, array1, array2);
   delElemIndexO(array2, 1);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"a\"],[\"aa\",11]]");
   free(s);
   // but an element is NULL
   // non smallJson objects
   smashO(array1);
   array1 = (smallArrayt*) allocSmallInt(2);
   r = self->f->zipSmallArrayJson(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array1);
   array1 = allocSmallArray();
   smashO(array2);
   array2 = (smallJsont*) allocSmallInt(2);
   r = self->f->zipSmallArrayJson(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array2);
   array2 = allocSmallJson();
   // NULL arrays
   r = self->f->zipSmallArrayJson(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = self->f->zipSmallArrayJson(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   smashO(array1);
   smashO(array2);
   // json dict
   self = allocSmallJson();
   // zip arrays
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys->f->pushS(keys, "a");
   keys->f->pushS(keys, "b");
   keys->f->pushS(keys, "c");
   values->f->pushInt(values, 1);
   values->f->pushInt(values, 2);
   r = self->f->zipSmallArrayJson(self, keys, values);
   terminateO(keys);
   smashO(values);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":1,\"b\":2}");
   free(s);
   // keys array with non string objects
   keys   = allocSmallArray();
   values = allocSmallJson();
   keys->f->pushInt(keys, 1);
   values->f->pushInt(values, 1);
   r = self->f->zipSmallArrayJson(self, keys, values);
   ck_assert_ptr_eq(r, NULL);
   terminateO(keys);
   terminateO(values);
   // empty values
   keys   = allocSmallArray();
   values = allocSmallJson();
   keys->f->pushInt(keys, 1);
   values->f->pushInt(values, 1);
   delElemIndexO(values, 0);
   trimO(values);
   r = self->f->zipSmallArrayJson(self, keys, values);
   ck_assert_ptr_eq(r, self);
   terminateO(keys);
   // non smallArray object
   keys = (smallArrayt*) allocSmallInt(1);
   r = self->f->zipSmallArrayJson(self, keys, values);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   keys   = allocSmallArray();
   terminateO(values);
   // non json array
   values = allocSmallJson();
   setTopIntO(values, 1);
   r = self->f->zipSmallArrayJson(self, keys, values);
   ck_assert_ptr_eq(r, null);
   terminateO(values);
   // non smallJson values
   values = (smallJsont*) allocSmallInt(2);
   r = self->f->zipSmallArrayJson(self, keys, values);
   ck_assert_ptr_eq(r, null);
   // null
   r = self->f->zipSmallArrayJson(self, null, values);
   ck_assert_ptr_eq(r, null);
   r = self->f->zipSmallArrayJson(self, keys, null);
   ck_assert_ptr_eq(r, null);
   terminateO(keys);
   terminateO(values);
   terminateO(self);
 
 }
 
 
 void zipArrayJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   char** keys;
   smallJsont *values = allocSmallJson();
   char** array1;
   smallJsont *array2 = allocSmallJson();
 
   // non json array or dict
   setTypeBoolO(self);
   array1 = listCreateS("a");
   r = self->f->zipArrayJson(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   // json array
   // zip arrays
   //   empty self
   freeO(self);
   array2->f->pushInt(array2, 1);
   r       = self->f->zipArrayJson(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",1]]");
   free(s);
   freen(array1);
   disposeO(array2);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array1  = listCreateS("a", "b");
   array2->f->pushInt(array2, 1);
   array2->f->pushInt(array2, 2);
   array2->f->pushInt(array2, 3);
   r = self->f->zipArrayJson(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   //    delete the element not in self
   delElemIndexO(array2, 2);
   // empty arrays
   disposeO(array2);
   setTypeArrayO(array2);
   r = self->f->zipArrayJson(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   iListRemoveS(&array1, 0, 2);
   r = self->f->zipArrayJson(self, array1, array2);
   free(array1);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   // array1 and array2 same element count
   array1 = listCreateS("aa", "bb");
   array2->f->pushInt(array2, 11);
   array2->f->pushInt(array2, 22);
   iListDelElemS(&array1, 1);
   r = self->f->zipArrayJson(self, array1, array2);
   delElemIndexO(array2, 1);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]");
   free(s);
   // but an element is NULL
   // non smallArray objects
   smashO(array2);
   array2 = (smallJsont*) allocSmallInt(2);
   r = self->f->zipArrayJson(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array2);
   array2 = allocSmallJson();
   // NULL arrays
   r = self->f->zipArrayJson(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = self->f->zipArrayJson(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   free(array1);
   smashO(array2);
   // json dict
   self = allocSmallJson();
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys = listCreateS("a", "b", "c");
   values->f->pushInt(values, 1);
   values->f->pushInt(values, 2);
   r = self->f->zipArrayJson(self, keys, values);
   listFreeS(keys);
   smashO(values);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":1,\"b\":2}");
   free(s);
   // empty values
   keys   = listCreateS("a");
   values = allocSmallJson();
   values->f->pushInt(values, 1);
   delElemIndexO(values, 0);
   trimO(values);
   r = self->f->zipArrayJson(self, keys, values);
   ck_assert_ptr_eq(r, self);
   terminateO(values);
   // non json array
   values = allocSmallJson();
   setTopIntO(values, 1);
   r = self->f->zipArrayJson(self, keys, values);
   ck_assert_ptr_eq(r, null);
   terminateO(values);
   // non smallJson values
   values = (smallJsont*) allocSmallInt(2);
   r = self->f->zipArrayJson(self, keys, values);
   ck_assert_ptr_eq(r, null);
   // null
   r = self->f->zipArrayJson(self, null, values);
   ck_assert_ptr_eq(r, null);
   r = self->f->zipArrayJson(self, keys, null);
   ck_assert_ptr_eq(r, null);
   listFreeS(keys);
   terminateO(values);
   terminateO(self);
 
 }
 
 
 void zipCArrayJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   const char* keys[] = {"a", "b", "c", null};
   smallJsont *values = allocSmallJson();
   const char* array1[] = {"a", "b", null};
   smallJsont *array2 = allocSmallJson();
 
   // non json array or dict
   setTypeBoolO(self);
   r = self->f->zipCArrayJson(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   // json array
   // zip arrays
   //   empty self
   freeO(self);
   array2->f->pushInt(array2, 1);
   r       = self->f->zipCArrayJson(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",1]]");
   free(s);
   disposeO(array2);
   freeO(self);
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array2->f->pushInt(array2, 1);
   array2->f->pushInt(array2, 2);
   array2->f->pushInt(array2, 3);
   r = self->f->zipCArrayJson(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   //    delete the element not in self
   delElemIndexO(array2, 2);
   // empty arrays
   disposeO(array2);
   setTypeArrayO(array2);
   r = self->f->zipCArrayJson(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   array1[0] = null;
   r = self->f->zipCArrayJson(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   // array1 and array2 same element count
   array1[0] = "aa";
   array1[1] = null;
   array2->f->pushInt(array2, 11);
   array2->f->pushInt(array2, 22);
   r = self->f->zipCArrayJson(self, array1, array2);
   delElemIndexO(array2, 1);
   ck_assert_ptr_ne(r, NULL);
   //  some elements were zipped
   s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2],[\"aa\",11]]");
   free(s);
   // but an element is NULL
   // non smallArray objects
   smashO(array2);
   array2 = (smallJsont*) allocSmallInt(2);
   r = self->f->zipCArrayJson(self, array1, array2);
   ck_assert_ptr_eq(r, NULL);
   terminateO(array2);
   array2 = allocSmallJson();
   // NULL arrays
   r = self->f->zipCArrayJson(self, NULL, array2);
   ck_assert_ptr_eq(r, NULL);
   r = self->f->zipCArrayJson(self, array1, NULL);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   smashO(array2);
   // json dict
   self = allocSmallJson();
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   values->f->pushInt(values, 1);
   values->f->pushInt(values, 2);
   r = self->f->zipCArrayJson(self, keys, values);
   smashO(values);
   ck_assert_ptr_ne(r, NULL);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":1,\"b\":2}");
   free(s);
   // empty values
   values = allocSmallJson();
   values->f->pushInt(values, 1);
   delElemIndexO(values, 0);
   trimO(values);
   r = self->f->zipCArrayJson(self, keys, values);
   ck_assert_ptr_eq(r, self);
   terminateO(values);
   // non json array
   values = allocSmallJson();
   setTopIntO(values, 1);
   r = self->f->zipCArrayJson(self, keys, values);
   ck_assert_ptr_eq(r, null);
   terminateO(values);
   // non smallJson values
   values = (smallJsont*) allocSmallInt(2);
   r = self->f->zipCArrayJson(self, keys, values);
   ck_assert_ptr_eq(r, null);
   // null
   r = self->f->zipCArrayJson(self, null, values);
   ck_assert_ptr_eq(r, null);
   r = self->f->zipCArrayJson(self, keys, null);
   ck_assert_ptr_eq(r, null);
   terminateO(values);
   terminateO(self);
 
 }
 
 
 void iterStartSmallJsonT(void) {
 
   baset* r;
   smallJsont *self = allocSmallJson();
 
   // non json array or dict
   setTypeBoolO(self);
   r = iterStartO(self);
   ck_assert_ptr_eq(r, NULL);
   freeO(self);
   // json array
   // array with sObjects
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   r = iterStartO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOUndefined(r));
   // start again
   r = iterStartO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOUndefined(r));
   // array with objects from other classes
   emptyO(self);
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   smallJsont *r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, NULL);
   r = iterStartO(self);
   ck_assert_ptr_ne(r, NULL);
   // array with all deleted elements
   emptyO(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 0);
   r = iterStartO(self);
   ck_assert_ptr_eq(r, NULL);
   // empty array
   emptyO(self);
   r = iterStartO(self);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   // json dict
   self = allocSmallJson();
   // dict with keys and values
   self->f->setInt(self, "a", 1);
   self->f->setInt(self, "b", 2);
   r = iterStartO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOSmallInt(r));
   // dict with objects from other classes
   emptyO(self);
   ip = allocSmallInt(2);
   ip->type = "anothertype";
   self->f->set(self, "d", (baset*)ip);
   r = iterStartO(self);
   ck_assert_ptr_ne(r, NULL);
   // dict with deleted elements
   self->f->setInt(self, "a", 1);
   self->f->delElem(self, "d");
   r = iterStartO(self);
   ck_assert_ptr_ne(r, NULL);
   // call iterStart again to trigger if (self->iterElementDataType != SH_DT_BASET) finishO(self->iterElement);
   r = iterStartO(self);
   ck_assert_ptr_ne(r, NULL);
   // empty self
   emptyO(self);
   r = iterStartO(self);
   ck_assert_ptr_eq(r, NULL);
   emptyO(self);
   r = iterStartO(self);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void iterStartKeySmallJsonT(void) {
 
   const char* r;
   smallJsont *self = allocSmallJson();
 
   // non json dict
   r = iterStartKeyO(self);
   ck_assert_ptr_eq(r, NULL);
   // json dict
   // dict with keys and values
   self->f->setInt(self, "a", 1);
   self->f->setInt(self, "b", 2);
   r = iterStartKeyO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "a");
   // dict with objects from other classes
   emptyO(self);
   smallIntt *ip = allocSmallInt(2);
   ip->type = "anothertype";
   self->f->set(self, "d", (baset*)ip);
   r = iterStartKeyO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "d");
   // dict with deleted elements
   self->f->setInt(self, "a", 1);
   self->f->delElem(self, "d");
   r = iterStartKeyO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "a");
   // call iterStart again to trigger if (self->iterElementDataType != SH_DT_BASET) finishO(self->iterElement);
   r = iterStartKeyO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "a");
   // empty self
   emptyO(self);
   r = iterStartKeyO(self);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void iterStartLastSmallJsonT(void) {
 
   baset* r;
   smallJsont *self = allocSmallJson();
 
   // non json array
   r = iterStartLastO(self);
   ck_assert_ptr_eq(r, NULL);
   // array with sObjects
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   r = iterStartLastO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOSmallBool(r));
   // start again
   r = iterStartLastO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOSmallBool(r));
   // array with objects from other classes
   emptyO(self);
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   smallJsont *r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, NULL);
   r = iterStartLastO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOType(r, "anothertype"));
   // array with all deleted elements
   emptyO(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 0);
   r = iterStartLastO(self);
   ck_assert_ptr_eq(r, NULL);
   // empty array
   emptyO(self);
   r = iterStartLastO(self);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void iterStartFromSmallJsonT(void) {
 
   baset* r;
   smallJsont *self = allocSmallJson();
 
   // non json array
   r = iterStartFromO(self, 0);
   ck_assert_ptr_eq(r, NULL);
   // array with sObjects
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   r = iterStartFromO(self, 1);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOSmallBool(r));
   // start again
   r = iterStartFromO(self, 1);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOSmallBool(r));
   // array with objects from other classes
   emptyO(self);
   self->f->pushUndefined(self);
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   smallJsont *r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, NULL);
   r = iterStartFromO(self, -1);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOType(r, "anothertype"));
   // index outside array
   r = iterStartFromO(self, 2);
   ck_assert_ptr_eq(r, NULL);
   r = iterStartFromO(self, -3);
   ck_assert_ptr_eq(r, NULL);
   // array with all deleted elements
   // except the ones before the start index
   emptyO(self);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   delElemIndexO(self, 2);
   r = iterStartFromO(self, 1);
   ck_assert_ptr_eq(r, NULL);
   // array with all deleted elements
   emptyO(self);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 0);
   delElemIndexO(self, 1);
   delElemIndexO(self, 2);
   r = iterStartFromO(self, 1);
   ck_assert_ptr_eq(r, NULL);
   // empty array
   emptyO(self);
   r = iterStartFromO(self, 1);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void iterStartFromStepSmallJsonT(void) {
 
   baset* r;
   smallJsont *self = allocSmallJson();
 
   // non json array
   r = iterStartFromStepO(self, 0, 1);
   ck_assert_ptr_eq(r, NULL);
   // array with sObjects
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   r = iterStartFromStepO(self, 1, 2);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOSmallBool(r));
   // start again
   r = iterStartFromStepO(self, 1, 2);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOSmallBool(r));
   // array with objects from other classes
   emptyO(self);
   self->f->pushUndefined(self);
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   smallJsont *r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, NULL);
   r = iterStartFromStepO(self, -1, 2);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOType(r, "anothertype"));
   // index outside array
   r = iterStartFromStepO(self, 2, 1);
   ck_assert_ptr_eq(r, NULL);
   r = iterStartFromStepO(self, -3, 1);
   ck_assert_ptr_eq(r, NULL);
   // array with all deleted elements
   // except the ones before the start index
   emptyO(self);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   delElemIndexO(self, 2);
   r = iterStartFromStepO(self, 1, 1);
   ck_assert_ptr_eq(r, NULL);
   //    negative step
   r = iterStartFromStepO(self, 1, -1);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOUndefined(r));
   // array with all deleted elements
   emptyO(self);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 0);
   delElemIndexO(self, 1);
   delElemIndexO(self, 2);
   r = iterStartFromStepO(self, 1, 2);
   ck_assert_ptr_eq(r, NULL);
   // empty array
   emptyO(self);
   r = iterStartFromStepO(self, 1, 1);
   ck_assert_ptr_eq(r, NULL);
   // step 0
   self->f->pushUndefined(self);
   r = iterStartFromStepO(self, 0, 0);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void iterNextSmallJsonT(void) {
 
   baset* r;
   smallJsont *self = allocSmallJson();
 
   // json array
   // array with sObjects
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   r = iterStartO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOUndefined(r));
   r = iterNextO(self);
   ck_assert(isOSmallBool(r));
   // array with objects from other classes
   emptyO(self);
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   smallJsont *r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, NULL);
   createAllocateSmallInt(ip2);
   ip2->type = "anothertype2";
   setValG(ip2, 11);
   r2        = self->f->push(self, (baset*)ip2);
   ck_assert_ptr_ne(r2, NULL);
   r = iterStartO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOType(r, "anothertype"));
   r = iterNextO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r->type, "anothertype2");
   //    iteration ended
   r = iterNextO(self);
   ck_assert_ptr_eq(r, NULL);
   // array with all deleted elements
   emptyO(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 0);
   r = iterStartO(self);
   ck_assert_ptr_eq(r, NULL);
   // empty array
   emptyO(self);
   r = iterStartO(self);
   ck_assert_ptr_eq(r, NULL);
   // empty array, uninitialized iterator
   emptyO(self);
   r = iterNextO(self);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   // json dict
   self = allocSmallJson();
   // dict with keys and values
   self->f->setInt(self, "a", 1);
   self->f->setInt(self, "b", 2);
   r = iterStartO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOSmallInt(r));
   smallIntt *i = (smallIntt*)r;
   ck_assert_int_eq(getValO(i), 1);
   r = iterNextO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOSmallInt(r));
   i = (smallIntt*)r;
   ck_assert_int_eq(getValO(i), 2);
   // dict with objects from other classes
   emptyO(self);
   ip = allocSmallInt(2);
   ip->type = "anothertype";
   self->f->set(self, "d", (baset*)ip);
   self->f->setInt(self, "a", 1);
   ip = allocSmallInt(3);
   ip->type = "anothertype2";
   self->f->set(self, "e", (baset*)ip);
   self->f->setInt(self, "b", 2);
   self->f->delElem(self, "a");
   self->f->delElem(self, "b");
   r = iterStartO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOType(r, "anothertype"));
   r = iterNextO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isOType(r, "anothertype2"));
   //    iteration ended
   r = iterNextO(self);
   ck_assert_ptr_eq(r, NULL);
   // empty self, uninitialized iterator
   emptyO(self);
   r = iterNextO(self);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void iterNextKeySmallJsonT(void) {
 
   const char* r;
   smallJsont *self = allocSmallJson();
 
   // non json dict
   r = iterNextKeyO(self);
   ck_assert_ptr_eq(r, NULL);
   // json dict
   // dict with keys and values
   self->f->setInt(self, "a", 1);
   self->f->setInt(self, "b", 2);
   r = iterStartKeyO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "a");
   r = iterNextKeyO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "b");
   // dict with objects from other classes
   emptyO(self);
   smallIntt *ip = allocSmallInt(2);
   ip->type = "anothertype";
   self->f->set(self, "d", (baset*)ip);
   self->f->setInt(self, "a", 1);
   ip = allocSmallInt(3);
   ip->type = "anothertype2";
   self->f->set(self, "e", (baset*)ip);
   self->f->setInt(self, "b", 2);
   self->f->delElem(self, "a");
   self->f->delElem(self, "b");
   r = iterStartKeyO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "d");
   r = iterNextKeyO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "e");
   //    iteration ended
   r = iterNextKeyO(self);
   ck_assert_ptr_eq(r, NULL);
   // empty self
   emptyO(self);
   r = iterNextKeyO(self);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void iterElementSmallJsonT(void) {
 
   baset* r;
   smallJsont *self = allocSmallJson();
 
   // start iteration
   self->f->pushUndefined(self);
   r         = iterStartO(self);
   ck_assert_ptr_ne(r, NULL);
   baset *r2 = iterElementO(self);
   ck_assert_ptr_eq(r, r2);
   ck_assert_str_eq(r->type, "undefined");
   // end iteration
   r = iterNextO(self);
   ck_assert_ptr_eq(r, NULL);
   r = iterElementO(self);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void iterKeySmallJsonT(void) {
 
   const char* r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "a", 1);
   baset *r2 = iterStartO(self);
   ck_assert_ptr_ne(r2, NULL);
   r = iterKeyO(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "a");
   // empty self
   freeO(self);
   r = iterKeyO(self);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void iterIndexSmallJsonT(void) {
 
   ssize_t r;
   baset* r2;
   smallJsont *self = allocSmallJson();
 
   // start iteration
   self->f->pushUndefined(self);
   r2 = iterStartO(self);
   ck_assert_ptr_ne(r2, NULL);
   ck_assert_str_eq(r2->type, "undefined");
   r  = iterIndexO(self);
   ck_assert_int_eq(r, 0);
   // end iteration
   r2 = iterNextO(self);
   ck_assert_ptr_eq(r2, NULL);
   r = iterIndexO(self);
   ck_assert_int_eq(r, -1);
   // empty self
   freeO(self);
   r = iterIndexO(self);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void iterStepSmallJsonT(void) {
 
   int64_t r;
   baset* r2;
   smallJsont *self = allocSmallJson();
 
   // start iteration
   self->f->pushUndefined(self);
   r2 = iterStartO(self);
   ck_assert_ptr_ne(r2, NULL);
   ck_assert_str_eq(r2->type, "undefined");
   r  = iterStepO(self);
   ck_assert_int_eq(r, 1);
   // start iterator twice and
   // set step
   r2 =iterStartFromStepO(self, 0, 10);
   ck_assert_ptr_ne(r2, NULL);
   ck_assert_str_eq(r2->type, "undefined");
   r  = iterStepO(self);
   ck_assert_int_eq(r, 10);
   // empty self
   freeO(self);
   r = iterStepO(self);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void getUndefinedSmallJsonT(void) {
 
   undefinedt* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setUndefined(self, "1");
   ck_assert_ptr_ne(r2, null);
   r = self->f->getUndefined(self, "1");
   ck_assert_ptr_ne(r, null);
   finishO(r);
   // path
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setUndefined(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r2, null);
   r = self->f->getUndefined(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   finishO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getUndefined(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getUndefined(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getUndefined(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getUndefined(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getUndefined(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // non undefined object
   r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getUndefined(self, "1");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getUndefined(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getUndefined(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getBoolSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getBool(self, "1");
   ck_assert(r);
   // non bool object
   r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getBool(self, "1");
   ck_assert(!r);
   // null key
   r = self->f->getBool(self, null);
   ck_assert(!r);
 	// empty self
   freeO(self);
   r = self->f->getBool(self, "1");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void getBoolPSmallJsonT(void) {
 
   bool* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getBoolP(self, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert(*r);
   // non bool object
   r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getBoolP(self, "1");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getBoolP(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getBoolP(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getDoubleSmallJsonT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setDouble(self, "1", 2.2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getDouble(self, "1");
   ck_assert(r == 2.2);
   // non double object
   r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getDouble(self, "1");
   ck_assert(r == 0);
   // null key
   r = self->f->getDouble(self, null);
   ck_assert(!r);
 	// empty self
   freeO(self);
   r = self->f->getDouble(self, "1");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void getDoublePSmallJsonT(void) {
 
   double* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setDouble(self, "1", 2.2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getDoubleP(self, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert(*r == 2.2);
   // non double object
   r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getDoubleP(self, "1");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getDoubleP(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getDoubleP(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getIntSmallJsonT(void) {
 
   int64_t r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getInt(self, "1");
   ck_assert_int_eq(r, 2);
   // non int object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getInt(self, "1");
   ck_assert(!r);
   // null key
   r = self->f->getInt(self, null);
   ck_assert(!r);
 	// empty self
   freeO(self);
   r = self->f->getInt(self, "1");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void getIntPSmallJsonT(void) {
 
   int64_t* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getIntP(self, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 2);
   // non int object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getIntP(self, "1");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getIntP(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getIntP(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getInt32SmallJsonT(void) {
 
   int32_t r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getInt32(self, "1");
   ck_assert_int_eq(r, 2);
   // non int object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getInt32(self, "1");
   ck_assert(!r);
   // null key
   r = self->f->getInt32(self, null);
   ck_assert(!r);
 	// empty self
   freeO(self);
   r = self->f->getInt32(self, "1");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void getInt32PSmallJsonT(void) {
 
   int32_t* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getInt32P(self, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 2);
   // non int object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getInt32P(self, "1");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getInt32P(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getInt32P(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getUintSmallJsonT(void) {
 
   uint64_t r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getUint(self, "1");
   ck_assert_int_eq(r, 2);
   // non int object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getUint(self, "1");
   ck_assert(!r);
   // null key
   r = self->f->getUint(self, null);
   ck_assert(!r);
 	// empty self
   freeO(self);
   r = self->f->getUint(self, "1");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void getUintPSmallJsonT(void) {
 
   uint64_t* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getUintP(self, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 2);
   // non int object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getUintP(self, "1");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getUintP(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getUintP(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getUint32SmallJsonT(void) {
 
   uint32_t r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getUint32(self, "1");
   ck_assert_int_eq(r, 2);
   // non int object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getUint32(self, "1");
   ck_assert(!r);
   // null key
   r = self->f->getUint32(self, null);
   ck_assert(!r);
 	// empty self
   freeO(self);
   r = self->f->getUint32(self, "1");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void getUint32PSmallJsonT(void) {
 
   uint32_t* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getUint32P(self, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 2);
   // non int object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getUint32P(self, "1");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getUint32P(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getUint32P(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getSSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setS(self, "1", "qwe");
   ck_assert_ptr_ne(r2, null);
   r = self->f->getS(self, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "qwe");
   // non string object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getS(self, "1");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getS(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getS(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getDictSmallJsonT(void) {
 
   smallDictt* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallDict(D);
   smallJsont *r2 = self->f->setNFreeDict(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getDict(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   // non dict object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getDict(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallDictt *dict = allocSmallDict();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setDict(self, "\"array\"[0].\"key\"", dict);
   ck_assert_ptr_ne(r2, null);
   finishO(dict);
   r = self->f->getDict(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   finishO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getDict(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getDict(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getDict(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getDict(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getDict(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getDict(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getDict(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getArraySmallJsonT(void) {
 
   smallArrayt* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallArray(D);
   smallJsont *r2 = self->f->setNFreeArray(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getArray(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   // non Array object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getArray(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallArrayt *array = allocSmallArray();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setArray(self, "\"array\"[0].\"key\"", array);
   ck_assert_ptr_ne(r2, null);
   finishO(array);
   r = self->f->getArray(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   finishO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getArray(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getArray(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getArray(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getArray(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getArray(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getArray(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getArray(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getSmallBoolSmallJsonT(void) {
 
   smallBoolt* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallBool(D);
   smallJsont *r2 = self->f->setNFreeSmallBool(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallBool(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "false");
   free(s);
   // non SmallBool object
   r2 = self->f->setInt(self, "1", 0);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallBool(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallBoolt *value = allocSmallBool(true);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallBool(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getSmallBool(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   finishO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getSmallBool(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getSmallBool(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getSmallBool(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getSmallBool(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getSmallBool(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getSmallBool(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getSmallBool(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getSmallBytesSmallJsonT(void) {
 
   smallBytest* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallBytes(D);
   smallJsont *r2 = self->f->setNFreeSmallBytes(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallBytes(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   // non SmallBytes object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallBytes(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallBytest *value = allocSmallBytes("qwf", sizeof("qwf"));
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallBytes(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getSmallBytes(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   finishO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getSmallBytes(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getSmallBytes(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getSmallBytes(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getSmallBytes(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getSmallBytes(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getSmallBytes(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getSmallBytes(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getSmallDoubleSmallJsonT(void) {
 
   smallDoublet* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallDouble(D);
   smallJsont *r2 = self->f->setNFreeSmallDouble(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallDouble(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "0.000000e+00");
   free(s);
   // non SmallDouble object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallDouble(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallDoublet *value = allocSmallDouble(1.2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallDouble(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getSmallDouble(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   finishO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getSmallDouble(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getSmallDouble(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getSmallDouble(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getSmallDouble(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getSmallDouble(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getSmallDouble(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getSmallDouble(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getSmallIntSmallJsonT(void) {
 
   smallIntt* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallInt(D);
   smallJsont *r2 = self->f->setNFreeSmallInt(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallInt(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "0");
   free(s);
   // non SmallInt object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallInt(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallIntt *value = allocSmallInt(1);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallInt(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getSmallInt(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   finishO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getSmallInt(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getSmallInt(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getSmallInt(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getSmallInt(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getSmallInt(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getSmallInt(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getSmallInt(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallJson(D);
   smallJsont *r2 = self->f->setNFreeSmallJson(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallJson(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallJson(self, "1");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   // non SmallJson object
   smallContainert *c = allocSmallContainer(NULL);
   r2 = self->f->setNFreeSmallContainer(self, "1", c);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallJson(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallJsont *value = allocSmallJson();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setSmallJson(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   r = self->f->getSmallJson(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   finishO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getSmallJson(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getSmallJson(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getSmallJson(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getSmallJson(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getSmallJson(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getSmallJson(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getSmallJson(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getSmallStringSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallString(D);
   smallJsont *r2 = self->f->setNFreeSmallString(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallString(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // non SmallString object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallString(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallStringt *value = allocSmallString("asd");
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallString(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getSmallString(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   finishO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getSmallString(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getSmallString(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getSmallString(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getSmallString(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getSmallString(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getSmallString(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getSmallString(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getVoidSmallJsonT(void) {
 
   void* r;
   smallJsont *self = allocSmallJson();
 
   smallContainert* D = allocSmallContainer(&r);
   smallJsont *r2 = self->f->setNFreeSmallContainer(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getVoid(self, "1");
   ck_assert_ptr_eq(r, &r);
   // non container object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getVoid(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallContainert *value = allocSmallContainer(&r);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallContainer(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getVoid(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getVoid(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getVoid(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getVoid(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getVoid(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getVoid(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getVoid(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getVoid(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getSmallContainerSmallJsonT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallContainer(D);
   smallJsont *r2 = self->f->setNFreeSmallContainer(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallContainer(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   // other base class
   smallIntt *t = allocSmallInt(2);
   t->type = "randomClass";
   r2 = self->f->setNFree(self, "1", (baset*)t);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallContainer(self, "1");
   ck_assert_ptr_eq(r, null);
   // non SmallContainer object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getSmallContainer(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallContainert *value = allocSmallContainer(null);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallContainer(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getSmallContainer(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   finishO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getSmallContainer(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getSmallContainer(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getSmallContainer(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getSmallContainer(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getSmallContainer(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getSmallContainer(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getSmallContainer(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getNDupSmallJsonT(void) {
 
   baset* r;
   smallJsont *self = allocSmallJson();
 
   smallIntt *c   = allocSmallInt(2);
   smallJsont *r2 = self->f->setNFree(self, "1", (baset*) c);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDup(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   // other base class
   smallIntt *t = allocSmallInt(3);
   t->type = "randomClass";
   r2 = self->f->setNFree(self, "1", (baset*)t);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDup(self, "1");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "3");
   free(s);
   // path
   smallIntt *value = allocSmallInt(1);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallInt(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getNDup(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getNDup(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getNDup(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getNDup(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getNDup(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getNDup(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getNDup(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getNDup(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getNDupUndefinedSmallJsonT(void) {
 
   undefinedt* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setUndefined(self, "1");
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupUndefined(self, "1");
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   // non undefined object
   r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupUndefined(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setUndefined(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupUndefined(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getNDupUndefined(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getNDupUndefined(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getNDupUndefined(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getNDupUndefined(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getNDupUndefined(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getNDupUndefined(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getNDupUndefined(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getNDupBoolSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupBool(self, "1");
   ck_assert(r);
   // non bool object
   r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupBool(self, "1");
   ck_assert(!r);
   // null key
   r = self->f->getNDupBool(self, null);
   ck_assert(!r);
 	// empty self
   freeO(self);
   r = self->f->getNDupBool(self, "1");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void getNDupDoubleSmallJsonT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setDouble(self, "1", 2.2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupDouble(self, "1");
   ck_assert(r == 2.2);
   // non double object
   r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupDouble(self, "1");
   ck_assert(r == 0);
   // null key
   r = self->f->getNDupDouble(self, null);
   ck_assert(r == 0);
 	// empty self
   freeO(self);
   r = self->f->getNDupDouble(self, "1");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void getNDupIntSmallJsonT(void) {
 
   int64_t r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupInt(self, "1");
   ck_assert_int_eq(r, 2);
   // non int object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupInt(self, "1");
   ck_assert(!r);
   // null key
   r = self->f->getNDupInt(self, null);
   ck_assert_int_eq(r, 0);
 	// empty self
   freeO(self);
   r = self->f->getNDupInt(self, "1");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void getNDupInt32SmallJsonT(void) {
 
   int32_t r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupInt32(self, "1");
   ck_assert_int_eq(r, 2);
   // non int object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupInt32(self, "1");
   ck_assert(!r);
   // null key
   r = self->f->getNDupInt32(self, null);
   ck_assert_int_eq(r, 0);
 	// empty self
   freeO(self);
   r = self->f->getNDupInt32(self, "1");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void getNDupUintSmallJsonT(void) {
 
   uint64_t r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupUint(self, "1");
   ck_assert_int_eq(r, 2);
   // non int object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupUint(self, "1");
   ck_assert(!r);
   // null key
   r = self->f->getNDupUint(self, null);
   ck_assert_int_eq(r, 0);
 	// empty self
   freeO(self);
   r = self->f->getNDupUint(self, "1");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void getNDupUint32SmallJsonT(void) {
 
   uint32_t r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupUint32(self, "1");
   ck_assert_int_eq(r, 2);
   // non int object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupUint32(self, "1");
   ck_assert(!r);
   // null key
   r = self->f->getNDupUint32(self, null);
   ck_assert_int_eq(r, 0);
 	// empty self
   freeO(self);
   r = self->f->getNDupUint32(self, "1");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void getNDupSSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setS(self, "1", "qwe");
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupS(self, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "qwe");
   free(r);
   // non string object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupS(self, "1");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getNDupS(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getNDupS(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getNDupDictSmallJsonT(void) {
 
   smallDictt* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallDict(D);
   smallJsont *r2 = self->f->setNFreeDict(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupDict(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   // non dict object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupDict(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallDictt *dict = allocSmallDict();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setDict(self, "\"array\"[0].\"key\"", dict);
   ck_assert_ptr_ne(r2, null);
   finishO(dict);
   r = self->f->getNDupDict(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getNDupDict(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getNDupDict(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getNDupDict(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getNDupDict(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getNDupDict(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getNDupDict(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getNDupDict(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getNDupArraySmallJsonT(void) {
 
   smallArrayt* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallArray(D);
   smallJsont *r2 = self->f->setNFreeArray(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupArray(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   // non Array object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupArray(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallArrayt *array = allocSmallArray();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setArray(self, "\"array\"[0].\"key\"", array);
   ck_assert_ptr_ne(r2, null);
   finishO(array);
   r = self->f->getNDupArray(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getNDupArray(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getNDupArray(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getNDupArray(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getNDupArray(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getNDupArray(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getNDupArray(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getNDupArray(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getNDupSmallBoolSmallJsonT(void) {
 
   smallBoolt* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallBool(D);
   smallJsont *r2 = self->f->setNFreeSmallBool(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallBool(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "false");
   free(s);
   // non SmallBool object
   r2 = self->f->setInt(self, "1", 0);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallBool(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallBoolt *value = allocSmallBool(true);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallBool(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getNDupSmallBool(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getNDupSmallBool(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getNDupSmallBool(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getNDupSmallBool(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getNDupSmallBool(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getNDupSmallBool(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getNDupSmallBool(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getNDupSmallBool(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getNDupSmallBytesSmallJsonT(void) {
 
   smallBytest* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallBytes(D);
   smallJsont *r2 = self->f->setNFreeSmallBytes(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallBytes(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   // non SmallBytes object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallBytes(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallBytest *value = allocSmallBytes("qwf", sizeof("qwf"));
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallBytes(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getNDupSmallBytes(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getNDupSmallBytes(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getNDupSmallBytes(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getNDupSmallBytes(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getNDupSmallBytes(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getNDupSmallBytes(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getNDupSmallBytes(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getNDupSmallBytes(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getNDupSmallDoubleSmallJsonT(void) {
 
   smallDoublet* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallDouble(D);
   smallJsont *r2 = self->f->setNFreeSmallDouble(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallDouble(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "0.000000e+00");
   free(s);
   // non SmallDouble object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallDouble(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallDoublet *value = allocSmallDouble(1.2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallDouble(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getNDupSmallDouble(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getNDupSmallDouble(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getNDupSmallDouble(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getNDupSmallDouble(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getNDupSmallDouble(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getNDupSmallDouble(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getNDupSmallDouble(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getNDupSmallDouble(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getNDupSmallIntSmallJsonT(void) {
 
   smallIntt* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallInt(D);
   smallJsont *r2 = self->f->setNFreeSmallInt(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallInt(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "0");
   free(s);
   // non SmallInt object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallInt(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallIntt *value = allocSmallInt(1);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallInt(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getNDupSmallInt(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getNDupSmallInt(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getNDupSmallInt(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getNDupSmallInt(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getNDupSmallInt(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getNDupSmallInt(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getNDupSmallInt(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getNDupSmallInt(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getNDupSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallJson(D);
   smallJsont *r2 = self->f->setNFreeSmallJson(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallJson(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallJson(self, "1");
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   // non SmallJson object
   smallContainert *c = allocSmallContainer(NULL);
   r2 = self->f->setNFreeSmallContainer(self, "1", c);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallJson(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallJsont *value = allocSmallJson();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->setSmallJson(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   r = self->f->getNDupSmallJson(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getNDupSmallJson(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getNDupSmallJson(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getNDupSmallJson(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getNDupSmallJson(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getNDupSmallJson(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getNDupSmallJson(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getNDupSmallJson(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getNDupSmallStringSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallString(D);
   smallJsont *r2 = self->f->setNFreeSmallString(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallString(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // non SmallString object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallString(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallStringt *value = allocSmallString("asd");
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallString(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getNDupSmallString(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getNDupSmallString(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getNDupSmallString(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getNDupSmallString(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getNDupSmallString(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getNDupSmallString(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getNDupSmallString(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getNDupSmallString(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getNDupVoidSmallJsonT(void) {
 
   void* r;
   smallJsont *self = allocSmallJson();
 
   smallContainert* D = allocSmallContainer(&r);
   smallJsont *r2 = self->f->setNFreeSmallContainer(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupVoid(self, "1");
   // result is null because the duplicate function in the container
   // is not set.
   ck_assert_ptr_eq(r, null);
   // non container object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupVoid(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallContainert *value = allocSmallContainer(&r);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallContainer(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getNDupVoid(self, "\"array\"[0].\"key\"");
   // result is null because the duplicate function in the container
   // is not set.
   ck_assert_ptr_eq(r, null);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getNDupVoid(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getNDupVoid(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getNDupVoid(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getNDupVoid(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getNDupVoid(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getNDupVoid(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getNDupVoid(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getNDupSmallContainerSmallJsonT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallContainer(D);
   smallJsont *r2 = self->f->setNFreeSmallContainer(self, "1", D);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallContainer(self, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   // other base class
   smallIntt *t = allocSmallInt(2);
   t->type = "randomClass";
   r2 = self->f->setNFree(self, "1", (baset*)t);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallContainer(self, "1");
   ck_assert_ptr_eq(r, null);
   // non SmallContainer object
   r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getNDupSmallContainer(self, "1");
   ck_assert_ptr_eq(r, null);
   // path
   smallContainert *value = allocSmallContainer(null);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setSmallContainer(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = self->f->getNDupSmallContainer(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->getNDupSmallContainer(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->getNDupSmallContainer(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->getNDupSmallContainer(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->getNDupSmallContainer(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->getNDupSmallContainer(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // null key
   r = self->f->getNDupSmallContainer(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->getNDupSmallContainer(self, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getAtSmallJsonT(void) {
 
   baset* r;
   smallJsont *self = allocG(rtSmallJsont);
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(getAtO(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallDict(e2);
   r2 = self->f->pushDict(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallDict(e4);
   r2 = self->f->pushDict(self, &e4);
   ck_assert_ptr_ne(r2, null);
   // positive index
   r       = getAtO(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{}]");
   free(s);
   // negative index
   r = getAtO(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{}]");
   free(s);
   // index outside
   ck_assert_ptr_eq(getAtO(self, 20), NULL);
   ck_assert_ptr_eq(getAtO(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(getAtO(self, 0), NULL);
   ck_assert_ptr_eq(getAtO(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtUndefinedSmallJsonT(void) {
 
   undefinedt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtUndefined(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtUndefined(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,null,3,null]");
   free(s);
   // negative index
   r = self->f->getAtUndefined(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,null,3,null]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtUndefined(self,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,null,3,null,11]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtUndefined(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtUndefined(self, -6), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtUndefined(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtUndefined(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtBoolSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtBool(self,1);
   ck_assert(r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true]");
   free(s);
   // negative index
   r = self->f->getAtBool(self,-1);
   ck_assert(r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtBool(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtBool(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtBool(self, 20));
   ck_assert(!self->f->getAtBool(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtBool(self, 0));
   ck_assert(!self->f->getAtBool(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtBoolPSmallJsonT(void) {
 
   bool* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtBoolP(self,1);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true]");
   free(s);
   // negative index
   r = self->f->getAtBoolP(self,-1);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtBoolP(self,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtBoolP(self,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtBoolP(self, 20));
   ck_assert(!self->f->getAtBoolP(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtBoolP(self, 0));
   ck_assert(!self->f->getAtBoolP(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtDoubleSmallJsonT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushDouble(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushDouble(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtDouble(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]");
   free(s);
   // negative index
   r = self->f->getAtDouble(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtDouble(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtDouble(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtDouble(self, 20));
   ck_assert(!self->f->getAtDouble(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtDouble(self, 0));
   ck_assert(!self->f->getAtDouble(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtDoublePSmallJsonT(void) {
 
   double* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushDouble(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushDouble(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtDoubleP(self,1);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]");
   free(s);
   // negative index
   r = self->f->getAtDoubleP(self,-1);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtDoubleP(self,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtDoubleP(self,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtDoubleP(self, 20));
   ck_assert(!self->f->getAtDoubleP(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtDoubleP(self, 0));
   ck_assert(!self->f->getAtDoubleP(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtIntSmallJsonT(void) {
 
   int64_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtInt(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative index
   r = self->f->getAtInt(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = self->f->getAtInt(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtInt(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtInt(self, 20));
   ck_assert(!self->f->getAtInt(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtInt(self, 0));
   ck_assert(!self->f->getAtInt(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtIntPSmallJsonT(void) {
 
   int64_t* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtIntP(self,1);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative index
   r = self->f->getAtIntP(self,-1);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = self->f->getAtIntP(self,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtIntP(self,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtIntP(self, 20));
   ck_assert(!self->f->getAtIntP(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtIntP(self, 0));
   ck_assert(!self->f->getAtIntP(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtInt32SmallJsonT(void) {
 
   int32_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtInt32(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative index
   r = self->f->getAtInt32(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = self->f->getAtInt32(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtInt32(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtInt32(self, 20));
   ck_assert(!self->f->getAtInt32(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtInt32(self, 0));
   ck_assert(!self->f->getAtInt32(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtInt32PSmallJsonT(void) {
 
   int32_t* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtInt32P(self,1);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative index
   r = self->f->getAtInt32P(self,-1);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = self->f->getAtInt32P(self,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtInt32P(self,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtInt32P(self, 20));
   ck_assert(!self->f->getAtInt32P(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtInt32P(self, 0));
   ck_assert(!self->f->getAtInt32P(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtUintSmallJsonT(void) {
 
   uint64_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtUint(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative index
   r = self->f->getAtUint(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = self->f->getAtUint(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtUint(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtUint(self, 20));
   ck_assert(!self->f->getAtUint(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtUint(self, 0));
   ck_assert(!self->f->getAtUint(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtUintPSmallJsonT(void) {
 
   uint64_t* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtUintP(self,1);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative index
   r = self->f->getAtUintP(self,-1);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = self->f->getAtUintP(self,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtUintP(self,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtUintP(self, 20));
   ck_assert(!self->f->getAtUintP(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtUintP(self, 0));
   ck_assert(!self->f->getAtUintP(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtUint32SmallJsonT(void) {
 
   uint32_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtUint32(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative index
   r = self->f->getAtUint32(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = self->f->getAtUint32(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtUint32(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtUint32(self, 20));
   ck_assert(!self->f->getAtUint32(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtUint32(self, 0));
   ck_assert(!self->f->getAtUint32(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtUint32PSmallJsonT(void) {
 
   uint32_t* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtUint32P(self,1);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative index
   r = self->f->getAtUint32P(self,-1);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = self->f->getAtUint32P(self,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtUint32P(self,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtUint32P(self, 20));
   ck_assert(!self->f->getAtUint32P(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtUint32P(self, 0));
   ck_assert(!self->f->getAtUint32P(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtSSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushS(self, "2");
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushS(self, "4");
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtS(self,1);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "2");
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]");
   free(s);
   // negative index
   r = self->f->getAtS(self,-1);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "4");
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtS(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtS(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtS(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtS(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtS(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtS(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtDictSmallJsonT(void) {
 
   smallDictt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtDict(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallDict(e2);
   r2 = self->f->pushDict(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallDict(e4);
   r2 = self->f->pushDict(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtDict(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{}]");
   free(s);
   // negative index
   r = self->f->getAtDict(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{}]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtDict(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{},11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtDict(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{},11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtDict(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtDict(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtDict(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtDict(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtArraySmallJsonT(void) {
 
   smallArrayt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtArray(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallArray(e2);
   r2 = self->f->pushArray(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallArray(e4);
   r2 = self->f->pushArray(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtArray(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[]]");
   free(s);
   // negative index
   r = self->f->getAtArray(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[]]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtArray(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[],11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtArray(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtArray(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtArray(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtArray(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtArray(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtSmallBoolSmallJsonT(void) {
 
   smallBoolt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtSmallBool(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallBool(e2);
   r2 = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallBool(e4);
   r2 = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtSmallBool(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true]");
   free(s);
   // negative index
   r = self->f->getAtSmallBool(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtSmallBool(self,2);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtSmallBool(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtSmallBool(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtSmallBool(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtSmallBool(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtSmallBool(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtSmallBytesSmallJsonT(void) {
 
   smallBytest* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtSmallBytes(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallBytes(e2);
   r2 = self->f->pushSmallBytes(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallBytes(e4);
   r2 = self->f->pushSmallBytes(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtSmallBytes(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[]]");
   free(s);
   // negative index
   r = self->f->getAtSmallBytes(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[]]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtSmallBytes(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[],11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtSmallBytes(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtSmallBytes(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtSmallBytes(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtSmallBytes(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtSmallBytes(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtSmallDoubleSmallJsonT(void) {
 
   smallDoublet* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtSmallDouble(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallDouble(e2);
   r2 = self->f->pushSmallDouble(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallDouble(e4);
   r2 = self->f->pushSmallDouble(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtSmallDouble(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "0.000000e+00");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]");
   free(s);
   // negative index
   r = self->f->getAtSmallDouble(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "0.000000e+00");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtSmallDouble(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtSmallDouble(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtSmallDouble(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtSmallDouble(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtSmallDouble(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtSmallDouble(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtSmallIntSmallJsonT(void) {
 
   smallIntt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtSmallInt(self, 0), null);
   // add elements to self
   r2 = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   createSmallInt(e2);
   r2 = self->f->pushSmallInt(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   createSmallInt(e4);
   r2 = self->f->pushSmallInt(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtSmallInt(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "0");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true,0,true,0]");
   free(s);
   // negative index
   r = self->f->getAtSmallInt(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "0");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true,0,true,0]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = self->f->getAtSmallInt(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtSmallInt(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtSmallInt(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtSmallInt(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtSmallInt(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtSmallInt(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtSmallJson(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallJson(e2);
   r2 = self->f->pushSmallJson(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallJson(e4);
   r2 = self->f->pushSmallJson(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtSmallJson(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{}]");
   free(s);
   // negative index
   r = self->f->getAtSmallJson(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{}]");
   free(s);
   // wrong object type
   createSmallBytes(I);
   r2 = self->f->pushSmallBytes(self, &I);
   r = self->f->getAtSmallJson(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{},[]]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtSmallJson(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{},[],\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtSmallJson(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtSmallJson(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtSmallJson(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtSmallJson(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtSmallStringSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtSmallString(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallString(e2);
   r2 = self->f->pushSmallString(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallString(e4);
   r2 = self->f->pushSmallString(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtSmallString(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"\",3,\"\"]");
   free(s);
   // negative index
   r = self->f->getAtSmallString(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"\",3,\"\"]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtSmallString(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"\",3,\"\",11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtSmallString(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"\",3,\"\",11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtSmallString(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtSmallString(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtSmallString(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtSmallString(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtVoidSmallJsonT(void) {
 
   void* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtVoid(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = pushVoidSmallJsonG(self, &r);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = pushVoidSmallJsonG(self, &self);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtVoid(self,1);
   ck_assert_ptr_eq(r, &r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]");
   free(s);
   // negative index
   r = self->f->getAtVoid(self,-1);
   ck_assert_ptr_eq(r, &self);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtVoid(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtVoid(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtVoid(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtVoid(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtVoid(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtVoid(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtSmallContainerSmallJsonT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtSmallContainer(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallContainer(e2);
   r2 = self->f->pushSmallContainer(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallContainer(e4);
   r2 = self->f->pushSmallContainer(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtSmallContainer(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]");
   free(s);
   // negative index
   r = self->f->getAtSmallContainer(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtSmallContainer(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtSmallContainer(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtSmallContainer(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtSmallContainer(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtSmallContainer(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtSmallContainer(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallJsonT(void) {
 
   baset* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtNDup(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDup(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative index
   r = self->f->getAtNDup(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "4");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // undefined object
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDup(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,null]");
   free(s);
   // container
   createSmallContainer(c);
   r2 = self->f->pushSmallContainer(self, &c);
   r = self->f->getAtNDup(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,null,\"<data container>\"]");
   free(s);
   // base object in container
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->push(self, (baset*)I);
   r = self->f->getAtNDup(self,-1);
   ck_assert_ptr_ne(r, null);
   // r->type is not anothertype, because the duplicate function is from the smallInt class
   ck_assert_str_eq(r->type, "smallInt");
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "11");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,null,\"<data container>\",\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtNDup(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtNDup(self, -8), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtNDup(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtNDup(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtNDupUndefinedSmallJsonT(void) {
 
   undefinedt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupUndefined(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,null,3,null]");
   free(s);
   // negative index
   r = self->f->getAtNDupUndefined(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,null,3,null]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupUndefined(self,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,null,3,null,11]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, -6), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupUndefined(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtNDupBoolSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupBool(self,1);
   ck_assert(r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true]");
   free(s);
   // negative index
   r = self->f->getAtNDupBool(self,-1);
   ck_assert(r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtNDupBool(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupBool(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtNDupBool(self, 20));
   ck_assert(!self->f->getAtNDupBool(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtNDupBool(self, 0));
   ck_assert(!self->f->getAtNDupBool(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtNDupDoubleSmallJsonT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushDouble(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushDouble(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupDouble(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]");
   free(s);
   // negative index
   r = self->f->getAtNDupDouble(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtNDupDouble(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupDouble(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4.000000e+00,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtNDupDouble(self, 20));
   ck_assert(!self->f->getAtNDupDouble(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtNDupDouble(self, 0));
   ck_assert(!self->f->getAtNDupDouble(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtNDupIntSmallJsonT(void) {
 
   int64_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupInt(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative index
   r = self->f->getAtNDupInt(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = self->f->getAtNDupInt(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupInt(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtNDupInt(self, 20));
   ck_assert(!self->f->getAtNDupInt(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtNDupInt(self, 0));
   ck_assert(!self->f->getAtNDupInt(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtNDupInt32SmallJsonT(void) {
 
   int32_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupInt32(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative index
   r = self->f->getAtNDupInt32(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = self->f->getAtNDupInt32(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupInt32(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtNDupInt32(self, 20));
   ck_assert(!self->f->getAtNDupInt32(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtNDupInt32(self, 0));
   ck_assert(!self->f->getAtNDupInt32(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtNDupUintSmallJsonT(void) {
 
   uint64_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupUint(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative index
   r = self->f->getAtNDupUint(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = self->f->getAtNDupUint(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupUint(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtNDupUint(self, 20));
   ck_assert(!self->f->getAtNDupUint(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtNDupUint(self, 0));
   ck_assert(!self->f->getAtNDupUint(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtNDupUint32SmallJsonT(void) {
 
   uint32_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupUint32(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative index
   r = self->f->getAtNDupUint32(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = self->f->getAtNDupUint32(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupUint32(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!self->f->getAtNDupUint32(self, 20));
   ck_assert(!self->f->getAtNDupUint32(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!self->f->getAtNDupUint32(self, 0));
   ck_assert(!self->f->getAtNDupUint32(self, -1));
   terminateO(self);
 
 }
 
 
 void getAtNDupSSmallJsonT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushS(self, "2");
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushS(self, "4");
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupS(self,1);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "2");
   free(r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]");
   free(s);
   // negative index
   r = self->f->getAtNDupS(self,-1);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "4");
   free(r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"2\",3,\"4\"]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtNDupS(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupS(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"2\",3,\"4\",11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtNDupS(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupS(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtNDupS(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupS(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtNDupDictSmallJsonT(void) {
 
   smallDictt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtNDupDict(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallDict(e2);
   r2 = self->f->pushDict(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallDict(e4);
   r2 = self->f->pushDict(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupDict(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{}]");
   free(s);
   // negative index
   r = self->f->getAtNDupDict(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{}]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtNDupDict(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{},11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupDict(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{},11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtNDupDict(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupDict(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtNDupDict(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupDict(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtNDupArraySmallJsonT(void) {
 
   smallArrayt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtNDupArray(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallArray(e2);
   r2 = self->f->pushArray(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallArray(e4);
   r2 = self->f->pushArray(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupArray(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[]]");
   free(s);
   // negative index
   r = self->f->getAtNDupArray(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[]]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtNDupArray(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[],11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupArray(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtNDupArray(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupArray(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtNDupArray(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupArray(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallBoolSmallJsonT(void) {
 
   smallBoolt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallBool(e2);
   r2 = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallBool(e4);
   r2 = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupSmallBool(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true]");
   free(s);
   // negative index
   r = self->f->getAtNDupSmallBool(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtNDupSmallBool(self,2);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupSmallBool(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,true,3,true,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupSmallBool(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallBytesSmallJsonT(void) {
 
   smallBytest* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallBytes(e2);
   r2 = self->f->pushSmallBytes(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallBytes(e4);
   r2 = self->f->pushSmallBytes(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupSmallBytes(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[]]");
   free(s);
   // negative index
   r = self->f->getAtNDupSmallBytes(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[]]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtNDupSmallBytes(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[],11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupSmallBytes(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,[],3,[],11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupSmallBytes(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallDoubleSmallJsonT(void) {
 
   smallDoublet* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallDouble(e2);
   r2 = self->f->pushSmallDouble(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallDouble(e4);
   r2 = self->f->pushSmallDouble(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupSmallDouble(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "0.000000e+00");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]");
   free(s);
   // negative index
   r = self->f->getAtNDupSmallDouble(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "0.000000e+00");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtNDupSmallDouble(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupSmallDouble(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,0.000000e+00,3,0.000000e+00,11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupSmallDouble(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallIntSmallJsonT(void) {
 
   smallIntt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, 0), null);
   // add elements to self
   r2 = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   createSmallInt(e2);
   r2 = self->f->pushSmallInt(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   createSmallInt(e4);
   r2 = self->f->pushSmallInt(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupSmallInt(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "0");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true,0,true,0]");
   free(s);
   // negative index
   r = self->f->getAtNDupSmallInt(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "0");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true,0,true,0]");
   free(s);
   // wrong object type
   createSmallDouble(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallDouble(self, &I);
   r = self->f->getAtNDupSmallInt(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupSmallInt(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[true,0,true,0,1.100000e+01,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupSmallInt(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallJson(e2);
   r2 = self->f->pushSmallJson(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallJson(e4);
   r2 = self->f->pushSmallJson(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupSmallJson(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{}]");
   free(s);
   // negative index
   r = self->f->getAtNDupSmallJson(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{}]");
   free(s);
   // wrong object type
   createSmallBytes(I);
   r2 = self->f->pushSmallBytes(self, &I);
   r = self->f->getAtNDupSmallJson(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{},[]]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupSmallJson(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,{},3,{},[],\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupSmallJson(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallStringSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallString(e2);
   r2 = self->f->pushSmallString(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallString(e4);
   r2 = self->f->pushSmallString(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupSmallString(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"\",3,\"\"]");
   free(s);
   // negative index
   r = self->f->getAtNDupSmallString(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"\",3,\"\"]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtNDupSmallString(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"\",3,\"\",11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupSmallString(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"\",3,\"\",11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupSmallString(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtNDupVoidSmallJsonT(void) {
 
   void* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtNDupVoid(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = pushVoidSmallJsonG(self, &r);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = pushVoidSmallJsonG(self, &self);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupVoid(self,1);
   // duplicate function is not set so the data is not duplicated
   ck_assert_ptr_eq(r, NULL);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]");
   free(s);
   // negative index
   r = self->f->getAtNDupVoid(self,-1);
   // duplicate function is not set so the data is not duplicated
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtNDupVoid(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupVoid(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtNDupVoid(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupVoid(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtNDupVoid(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupVoid(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallContainerSmallJsonT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, 0), null);
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   createSmallContainer(e2);
   r2 = self->f->pushSmallContainer(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   createSmallContainer(e4);
   r2 = self->f->pushSmallContainer(self, &e4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = self->f->getAtNDupSmallContainer(self,1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]");
   free(s);
   // negative index
   r = self->f->getAtNDupSmallContainer(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\"]");
   free(s);
   // wrong object type
   createSmallInt(I);
   setValG(&I, 11);
   r2 = self->f->pushSmallInt(self, &I);
   r = self->f->getAtNDupSmallContainer(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = self->f->getAtNDupSmallContainer(self,-1);
   ck_assert_ptr_eq(r, NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,\"<data container>\",3,\"<data container>\",11,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, 20), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, -7), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, 0), NULL);
   ck_assert_ptr_eq(self->f->getAtNDupSmallContainer(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void getNumSmallJsonT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert(getNumO(self, 0) == 0);
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setS(self, "3", "2");
   ck_assert_ptr_ne(r2, null);
   r = getNumO(self, "1");
   ck_assert(r == 1);
   r = getNumO(self, "2");
   ck_assert(r == 2.2);
   // not a number
   r = getNumO(self, "3");
   ck_assert(r == 0);
   // path
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r2 = self->f->setInt(self, "\"array\"[0].\"key\"", 123);
   ck_assert_ptr_ne(r2, null);
   r = getNumO(self, "\"array\"[0].\"key\"");
   ck_assert_int_eq(r, 123);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = getNumO(self, "1");
   ck_assert(r == 0);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = getNumO(self, "1");
   ck_assert(r == 0);
   // non existing dict path
   freeO(self);
   r = getNumO(self, "\"1\"[1]");
   ck_assert(r == 0);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = getNumO(self, "\"1\".\"1\"");
   ck_assert(r == 0);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = getNumO(self, "\"2\".\"1\".[12]");
   ck_assert(r == 0);
   // null key
   r = getNumO(self, null);
   ck_assert(r == 0);
 	// empty self
   freeO(self);
   r = getNumO(self, "1");
   ck_assert(r == 0);
   terminateO(self);
 
 }
 
 
 void getNumAtSmallJsonT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   // non json array
   ck_assert(!getNumAtO(self, 0));
   // add elements to self
   r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushDouble(self, 2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r2, null);
 
   // positive index
   r       = getNumAtO(self,1);
   ck_assert(r==2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4]");
   free(s);
   // negative index
   r = getNumAtO(self,-1);
   ck_assert(r==4);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4]");
   free(s);
   // wrong object type of another user class
   //   User classes are stored in containers transparently
   createAllocateSmallInt(ip);
   ip->type = "anothertype";
   setValG(ip, 11);
   r2 = self->f->push(self, (baset*)ip);
   ck_assert_ptr_ne(r2, null);
   r = getNumAtO(self,-1);
   ck_assert(!r);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2.000000e+00,3,4,\"<data container>\"]");
   free(s);
   // index outside
   ck_assert(!getNumAtO(self, 20));
   ck_assert(!getNumAtO(self, -7));
   // empty list
   emptyO(self);
   ck_assert(!getNumAtO(self, 0));
   ck_assert(!getNumAtO(self, -1));
   terminateO(self);
 
 }
 
 
 void delElemSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   self->f->setBool(self, "lib", true);
   // delete element
   r = delElemO(self, "lib");
   ck_assert_ptr_ne(r, null);
   smallBoolt *oBool3 = (smallBoolt *)self->f->get(self, "lib");
   ck_assert_ptr_eq(oBool3, NULL);
   // path
   baset *value = (baset*) allocSmallInt(2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->set(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   r = delElemO(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = delElemO(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = delElemO(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = delElemO(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = delElemO(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = delElemO(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // delete non existing element
   r = delElemO(self, NULL);
   ck_assert_ptr_eq(r, null);
   r = delElemO(self, "non existing");
   ck_assert_ptr_ne(r, null);
   terminateO(self);
 
 }
 
 
 void delSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // json string
   // empty string
   setTopSO(self, "");
   r = delO(self, 0,1);
   ck_assert_ptr_eq(r, null);
   // del
   freeO(self);
   setTopSO(self, "sheepy");
   r = delO(self, 0,2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "eepy");
   free(s);
   // negative index
   freeO(self);
   setTopSO(self, "sheepy");
   r = delO(self, -2,0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "shee");
   free(s);
   // positive and negative indexes
   freeO(self);
   setTopSO(self, "sheepy");
   r = delO(self, 2,-2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "shpy");
   free(s);
   // start = end
   freeO(self);
   setTopSO(self, "sheepy");
   r = delO(self, 2,-4);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sheepy");
   free(s);
   // delete entire string
   freeO(self);
   setTopSO(self, "sheepy");
   r = delO(self, 0,0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // end of string
   freeO(self);
   setTopSO(self, "sheepy");
   r = delO(self, 2,6);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sh");
   free(s);
   // NULL string
   freeO(self);
   r = delO(self, 2,-4);
   ck_assert_ptr_eq(r, NULL);
   // start outside string
   freeO(self);
   setTopSO(self, "sheepy");
   r = delO(self, 20,-4);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "sheepy");
   free(s);
   r = delO(self, -20,-4);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "eepy");
   free(s);
   // end outside string
   freeO(self);
   setTopSO(self, "sheepy");
   r = delO(self, 2,40);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sh");
   free(s);
   freeO(self);
   setTopSO(self, "sheepy");
   r = delO(self, 2,-40);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "sheepy");
   free(s);
   // end before start
   freeO(self);
   setTopSO(self, "sheepy");
   r = delO(self, 4,2);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "sheepy");
   free(s);
   terminateO(self);
   // json array
   self = allocSmallJson();
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   // del
   r = delO(self,1,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[null,5345]");
   free(s);
   terminateO(self);
     // start outside
   self = allocSmallJson();
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = delO(self,20,-1);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]");
   free(s);
   terminateO(self);
     // start negative and outside
   self = allocSmallJson();
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = delO(self,-20,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[123,\"sheepy\",5345]");
   free(s);
   terminateO(self);
     // end outside
   self = allocSmallJson();
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = delO(self,2,40);
   ck_assert_ptr_ne(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[null,123]");
   free(s);
   terminateO(self);
     // end negative and outside
   self = allocSmallJson();
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = delO(self,2,-40);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]");
   free(s);
   terminateO(self);
     // end before start
   self = allocSmallJson();
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = delO(self,3,2);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]");
   free(s);
   terminateO(self);
     // negative start last element
   self = allocSmallJson();
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = delO(self,-1,0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[null,123,\"sheepy\"]");
   free(s);
   terminateO(self);
     // start = end
   self = allocSmallJson();
   self->f->pushUndefined(self);
   self->f->pushInt(self, 123);
   self->f->pushS(self, "sheepy");
   self->f->pushInt(self, 5345);
   r = delO(self,1,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]");
   free(s);
   terminateO(self);
     // empty list
   self = allocSmallJson();
   r = delO(self,0,0);
   ck_assert_ptr_eq(r, null);
   setTypeArrayO(self);
   r = delO(self,0,0);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void delElemIndexSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // non json array
   r = delElemIndexO(self, 0);
   ck_assert_ptr_eq(r, null);
   // json string
   // del
   freeO(self);
   setTopSO(self, "sheepy");
   r = delElemIndexO(self, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "heepy");
   free(s);
   freeO(self);
   setTopSO(self, "sheepy");
   r = delElemIndexO(self, 5);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sheep");
   free(s);
   // negative index
   freeO(self);
   setTopSO(self, "sheepy");
   r = delElemIndexO(self, -1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sheep");
   free(s);
   freeO(self);
   setTopSO(self, "sheepy");
   r = delElemIndexO(self, -6);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "heepy");
   free(s);
   // index outside string
   freeO(self);
   setTopSO(self, "sheepy");
   r = delElemIndexO(self, 6);
   ck_assert_ptr_eq(r, null);
   r = delElemIndexO(self, -7);
   ck_assert_ptr_eq(r, null);
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert_ptr_eq(delElemIndexO(self, 0), null);
   // null string
   freeO(self);
   ck_assert_ptr_eq(delElemIndexO(self, 0), null);
   terminateO(self);
   // json array
   self = allocSmallJson();
   setTypeArrayO(self);
   // empty array
   ck_assert_ptr_eq(delElemIndexO(self, 0), null);
   // outside positive and negative
   self->f->pushS(self, "");
   ck_assert_ptr_eq(delElemIndexO(self, 1), null);
   ck_assert_ptr_eq(delElemIndexO(self, -2), null);
   // del
   ck_assert_ptr_ne(delElemIndexO(self, -1), null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void removeElemSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   smallIntt *i = allocSmallInt(1);
   r = self->f->setSmallInt(self, "1", i);
   ck_assert_ptr_ne(r, null);
   r = self->f->removeElem(self, "1");
   ck_assert_ptr_ne(r, null);
   terminateO(i);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   // path
   baset *value = (baset*) allocSmallInt(2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   r = self->f->set(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r, null);
   r = self->f->removeElem(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   terminateO(value);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = self->f->removeElem(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = self->f->removeElem(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = self->f->removeElem(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = self->f->removeElem(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = self->f->removeElem(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   delElemO(self, "2");
   // non existing key
   r = self->f->removeElem(self, "1");
   ck_assert_ptr_ne(r, null);
   freeO(&a); // self->f->setArray(self, "1", &a) above allocates an sArray
   s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   // null key
   r = self->f->removeElem(self, null);
   ck_assert_ptr_eq(r, null);
 	// empty self
   freeO(self);
   r = self->f->removeElem(self, "qwe");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void removeSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // non json array or string
   ck_assert_ptr_eq(removeO(self, 0, 1), null);
   // json string -> same code as delO json string
   // empty string
   setTopSO(self, "");
   r = removeO(self, 0,1);
   ck_assert_ptr_eq(r, null);
   // del
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeO(self, 0,2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "eepy");
   free(s);
   // negative index
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeO(self, -2,0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "shee");
   free(s);
   // positive and negative indexes
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeO(self, 2,-2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "shpy");
   free(s);
   // start = end
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeO(self, 2,-4);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sheepy");
   free(s);
   // delete entire string
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeO(self, 0,0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   // end of string
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeO(self, 2,6);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sh");
   free(s);
   // NULL string
   freeO(self);
   r = removeO(self, 2,-4);
   ck_assert_ptr_eq(r, NULL);
   // start outside string
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeO(self, 20,-4);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "sheepy");
   free(s);
   r = removeO(self, -20,-4);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "eepy");
   free(s);
   // end outside string
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeO(self, 2,40);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sh");
   free(s);
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeO(self, 2,-40);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "sheepy");
   free(s);
   // end before start
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeO(self, 4,2);
   ck_assert_ptr_eq(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "sheepy");
   free(s);
   terminateO(self);
   // json array
   self = allocSmallJson();
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   smallIntt *e[4];
   arange(i,e) {
     e[i] = self->f->getAtSmallInt(self, i);
   }
 
   // negative index
   r = removeO(self, 1, -1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,4]");
   free(s);
   // start outside
   ck_assert_ptr_eq(removeO(self, 20, -4), NULL);
   // end outside
   r = removeO(self, 0, 40);
   ck_assert_ptr_ne(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   arange(i,e) {
     terminateO(e[i]);
   }
   // end negative and outside
   //   remove elements with NULL (set by removeO)
   trimO(self);
   //   add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
   arange(i,e) {
     e[i] = self->f->getAtSmallInt(self, i);
   }
   ck_assert_ptr_eq(removeO(self, 2, -40), NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // end before start
   ck_assert_ptr_eq(removeO(self, 3, 2), NULL);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   // negative start last element
   r = removeO(self, -1, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3]");
   free(s);
   // negative start and outside
   r = removeO(self, -10, 1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,3]");
   free(s);
   // start = end
   r = removeO(self, 1, 1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[2,3]");
   free(s);
   // remove all
   r = removeO(self, 0, 0);
   ck_assert_ptr_ne(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[]");
   free(s);
   arange(i,e) {
     terminateO(e[i]);
   }
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(removeO(self, 0, 0), NULL);
   ck_assert_ptr_eq(removeO(self, -1, 0), NULL);
   terminateO(self);
 
 }
 
 
 void removeElemIndexSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // non json array
   r = removeElemIndexO(self, 0);
   ck_assert_ptr_eq(r, null);
   // json string
   // del
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeElemIndexO(self, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "heepy");
   free(s);
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeElemIndexO(self, 5);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sheep");
   free(s);
   // negative index
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeElemIndexO(self, -1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "sheep");
   free(s);
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeElemIndexO(self, -6);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "heepy");
   free(s);
   // index outside string
   freeO(self);
   setTopSO(self, "sheepy");
   r = removeElemIndexO(self, 6);
   ck_assert_ptr_eq(r, null);
   r = removeElemIndexO(self, -7);
   ck_assert_ptr_eq(r, null);
   // empty string
   freeO(self);
   setTopSO(self, "");
   ck_assert_ptr_eq(removeElemIndexO(self, 0), null);
   // null string
   freeO(self);
   ck_assert_ptr_eq(removeElemIndexO(self, 0), null);
   terminateO(self);
   // json array
   self = allocSmallJson();
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
 
   smallIntt *e[2];
   e[0] = self->f->getAtSmallInt(self, 1);
   e[1] = self->f->getAtSmallInt(self, 3);
 
   // positive index
   r       = removeElemIndexO(self,1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3,4]");
   free(s);
   // negative index
   r = removeElemIndexO(self,-1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,3]");
   free(s);
   terminateO(e[0]);
   terminateO(e[1]);
   // index outside
   ck_assert_ptr_eq(removeElemIndexO(self, 20), NULL);
   ck_assert_ptr_eq(removeElemIndexO(self, -5), NULL);
   // empty list
   emptyO(self);
   ck_assert_ptr_eq(removeElemIndexO(self, 0), NULL);
   ck_assert_ptr_eq(removeElemIndexO(self, -1), NULL);
   terminateO(self);
 
 }
 
 
 void stringifySmallStringSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // stringifySmallJson is tested in cSmallJsonT
   // this test checks the parts not tested in cSmallJsonT
   // json dict
   self->f->setS(self, "\\\\", "\\erw\\\"");
   r = stringifySmallStringO(self, 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{\n  \"\\\\\": \"\\\\erw\\\\\\\"\"\n}\n");
   free(s);
   // json array
   freeO(self);
   self->f->pushS(self, "\\\\ewq\\\"");
   r = stringifySmallStringO(self, 2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[\n  \"\\\\\\\\ewq\\\\\\\"\"\n]\n");
   free(s);
   terminateO(self);
 
 }
 
 
 void toYMLSmallStringSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   self->f->pushS(self, "qwe");
   r = toYMLSmallStringO(self, 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "---\n  - qwe\n");
   free(s);
   terminateO(r);
   // blank and empty keys should have quotes
   freeO(self);
   self->f->setS(self, "", "empty");
   self->f->setS(self, "  ", "blank");
   r = toYMLSmallStringO(self, 2);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "---\n  \"\": empty\n  \"  \": blank\n");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void parseSmallJsonSmallJsonT(void) {
 
   bool r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallJsont *input = allocSmallJson();
 
   // non json string
   r = self->f->parseSmallJson(self, input);
   ck_assert(!r);
   // json string
   setTopSO(input, "true");
   r = self->f->parseSmallJson(self, input);
   ck_assert(r);
   terminateO(input);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "true");
   free(s);
   // non json object
   input = (smallJsont*) allocSmallInt(123);
   r = self->f->parseSmallJson(self, input);
   ck_assert(!r);
   terminateO(input);
   // null
   r = self->f->parseSmallJson(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void parseSmallStringSmallJsonT(void) {
 
   bool r;
   smallJsont *self    = allocG(rtSmallJsont);
   smallStringt *input = allocSmallString("true");
 
   // string
   r = self->f->parseSmallString(self, input);
   ck_assert(r);
   terminateO(input);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "true");
   free(s);
   // non smallString object
   input = (smallStringt*) allocSmallInt(123);
   r = self->f->parseSmallString(self, input);
   ck_assert(!r);
   terminateO(input);
   // null
   r = self->f->parseSmallString(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void parseYMLSmallJsonSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   smallJsont *input = allocSmallJson();
 
   // non json string
   r = self->f->parseYMLSmallJson(self, input);
   ck_assert(!r);
   // json string
   setTopSO(input, "---\n - qwe");
   r = self->f->parseYMLSmallJson(self, input);
   ck_assert(r);
   terminateO(input);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   // non json object
   input = (smallJsont*) allocSmallInt(123);
   r = self->f->parseYMLSmallJson(self, input);
   ck_assert(!r);
   terminateO(input);
   // null
   r = self->f->parseYMLSmallJson(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void parseYMLSmallStringSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   smallStringt *input = allocSmallString("---\n - qwe");
 
   // string
   r = self->f->parseYMLSmallString(self, input);
   ck_assert(r);
   terminateO(input);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   // non smallString object
   input = (smallStringt*) allocSmallInt(123);
   r = self->f->parseYMLSmallString(self, input);
   ck_assert(!r);
   terminateO(input);
   // null
   r = self->f->parseYMLSmallString(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void logSmallJsonT(void) {
 
   smallJsont *self = allocSmallJson();
 
   // only prints to stdout
   logO(self);
   terminateO(self);
 
 }
 
 
 void readFileSmallJsonT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
 
   self->f->setS(self, "key", "value");
   writeFileO(self, "read.JSON");
   writeFileO(self, "read.YML");
   writeFileO(self, "read.BIN");
   // read files
   freeO(self);
   ck_assert_ptr_ne(readFileO(self, "read.JSON"), null);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"key\":\"value\"}");
   free(s);
   freeO(self);
   ck_assert_ptr_ne(readFileO(self, "read.YML"), null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"key\":\"value\"}");
   free(s);
   freeO(self);
   ck_assert_ptr_ne(readFileO(self, "read.BIN"), null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"key\":\"value\"}");
   free(s);
   freeO(self);
   rmAll("read.JSON");
   rmAll("read.YML");
   rmAll("read.BIN");
   // non existing files
   ck_assert_ptr_eq(readFileO(self, "nonexisting.json"), null);
   ck_assert_ptr_eq(readFileO(self, "nonexisting.Yml"), null);
   ck_assert_ptr_eq(readFileO(self, "nonexisting.Bin"), null);
   // invalid extension, not json, yml or bin
   ck_assert_ptr_eq(readFileO(self, "libsheepyCSmallArray.h"), null);
   // null filename
   ck_assert_ptr_eq(readFileO(self, null), null);
   terminateO(self);
 
 }
 
 
 void readFileSmallStringSmallJsonT(void) {
 
   smallJsont *self       = allocG(rtSmallJsont);
   smallStringt *filePath = allocSmallString("read.json");
 
   self->f->setS(self, "key", "value");
   writeFileO(self, "read.json");
   freeO(self);
   ck_assert_ptr_ne(self->f->readFileSmallString(self, filePath), null);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"key\":\"value\"}");
   free(s);
   freeO(self);
   rmAll("read.json");
   // non smallString object
   terminateO(filePath);
   filePath = (smallStringt*) allocSmallInt(123);
   ck_assert_ptr_eq(self->f->readFileSmallString(self, filePath), null);
   terminateO(filePath);
   // null path
   ck_assert_ptr_eq(self->f->readFileSmallString(self, null), null);
   terminateO(self);
 
 }
 
 
 void readFileJsonSmallJsonT(void) {
 
   smallJsont *self     = allocG(rtSmallJsont);
   smallJsont *filePath = allocSmallJson();
 
   setTopSO(filePath, "read.json");
   self->f->setS(self, "key", "value");
   writeFileO(self, "read.json");
   freeO(self);
   ck_assert_ptr_ne(readFileJsonO(self, filePath), null);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"key\":\"value\"}");
   free(s);
   freeO(self);
   rmAll("read.json");
   // non json string
   freeO(filePath);
   setTypeBoolO(filePath);
   ck_assert_ptr_eq(readFileJsonO(self, filePath), null);
   // non smallJson object
   terminateO(filePath);
   filePath = (smallJsont*) allocSmallInt(123);
   ck_assert_ptr_eq(readFileJsonO(self, filePath), null);
   terminateO(filePath);
   // null path
   ck_assert_ptr_eq(readFileJsonO(self, null), null);
   terminateO(self);
 
 }
 
 
 void readStreamSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   FILE *fp;
 
   // stream
   fp = fopen("file.json", "r");
   r = readStreamO(self, fp);
   fclose(fp);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"dasd\":\"asd\",\"asd\":234,\"dict\":{\"array\":[1,1],\"asd\":true,\"float\":3.434000e+01},\"bool\":false,\"zzz\":null}");
   free(s);
   // empty stream, error because it is not valid json
   emptyO(self);
   fp = fopen("../chmodTest.null", "r");
   r = readStreamO(self, fp);
   fclose(fp);
   ck_assert_ptr_eq(r, NULL);
   ck_assert(isEmptyO(self));
   // NULL stream
   ck_assert_ptr_eq(readStreamO(self, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void writeFileSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   r = writeFileO(self, "smallDictFile.json");
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.json"));
   char *s = readFileToS("smallDictFile.json");
   ck_assert_str_eq(s, "{\n  \"\": 1,\n  \"b\": 2\n}\n");
   free(s);
   rmAll("smallDictFile.json");
   r = writeFileO(self, "smallDictFile.yml");
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.yml"));
   freeO(self);
   ck_assert_ptr_ne(readFileO(self, "smallDictFile.yml"), null);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"\":1,\"b\":2}");
   free(s);
   rmAll("smallDictFile.yml");
   r = writeFileO(self, "smallDictFile.bin");
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.bin"));
   freeO(self);
   readFileO(self, "smallDictFile.bin");
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"\":1,\"b\":2}");
   free(s);
   rmAll("smallDictFile.bin");
   // write readonly path
   ck_assert(!writeFileO(self, "/readOnlyFileTest.bin"));
   // blank file path
   r = writeFileO(self, "   ");
   ck_assert(!r);
   // null file path
   r = writeFileO(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void writeFileSmallStringSmallJsonT(void) {
 
   bool r;
   smallJsont *self       = allocSmallJson();
   smallStringt *filePath = allocSmallString("smallDictFile.json");
 
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   r = self->f->writeFileSmallString(self, filePath);
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.json"));
   char *s = readFileToS("smallDictFile.json");
   ck_assert_str_eq(s, "{\n  \"\": 1,\n  \"b\": 2\n}\n");
   free(s);
   rmAll("smallDictFile.json");
   // blank path
   setValO(filePath, "   ");
   r = self->f->writeFileSmallString(self, filePath);
   ck_assert(!r);
   // non smallString object
   terminateO(filePath);
   filePath = (smallStringt*) allocSmallInt(2);
   r = self->f->writeFileSmallString(self, filePath);
   ck_assert(!r);
   // null path
   r = self->f->writeFileSmallString(self, null);
   ck_assert(!r);
   terminateO(filePath);
   terminateO(self);
 
 }
 
 
 void writeFileJsonSmallJsonT(void) {
 
   bool r;
   smallJsont *self     = allocSmallJson();
   smallJsont *filePath = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   setTopSO(filePath, "smallDictFile.json");
   r = self->f->writeFileJson(self, filePath);
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.json"));
   char *s = readFileToS("smallDictFile.json");
   ck_assert_str_eq(s, "{\n  \"\": 1,\n  \"b\": 2\n}\n");
   free(s);
   rmAll("smallDictFile.json");
   // blank path
   freeO(filePath);
   setTopSO(filePath, "   ");
   r = self->f->writeFileJson(self, filePath);
   ck_assert(!r);
   // non json string
   freeO(filePath);
   setTopIntO(filePath, 2);
   r = self->f->writeFileJson(self, filePath);
   ck_assert(!r);
   // non json object
   terminateO(filePath);
   filePath = (smallJsont*) allocSmallInt(2);
   r = self->f->writeFileJson(self, filePath);
   ck_assert(!r);
   // null path
   r = self->f->writeFileJson(self, null);
   ck_assert(!r);
   terminateO(filePath);
   terminateO(self);
 
 }
 
 
 void writeStreamSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   FILE *fp;
 
   // write textOutTest.null
   fp = fopen("file.json", "r");
   smallJsont *r2 = readStreamO(self, fp);
   fclose(fp);
   ck_assert_ptr_ne(r2, NULL);
   fp = fopen("outTest.json", "w");
   r = writeStreamO(self, fp);
   ck_assert(r);
   fclose(fp);
     // check textOutTest.null
   fp = fopen("outTest.json", "r");
   r2 = readStreamO(self, fp);
   fclose(fp);
   ck_assert_ptr_ne(r2, NULL);
   char *s = toStringO(r2);
   ck_assert_str_eq(s, "{\"dasd\":\"asd\",\"asd\":234,\"dict\":{\"array\":[1,1],\"asd\":true,\"float\":3.434000e+01},\"bool\":false,\"zzz\":null}");
   free(s);
   // wrong stream: read instead of write
   fp = fopen("outTest.json", "r");
   ck_assert(!writeStreamO(self, fp));
   fclose(fp);
   // null stream
   ck_assert(!writeStreamO(self, null));
   rmAll("outTest.json");
   terminateO(self);
 
 }
 
 
 void appendFileSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   // append json
   writeFileS("smallDictFile.json", "-");
   r = appendFileO(self, "smallDictFile.json");
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.json"));
   char *s = readFileToS("smallDictFile.json");
   ck_assert_str_eq(s, "-{\n  \"\": 1,\n  \"b\": 2\n}\n");
   free(s);
   rmAll("smallDictFile.json");
   // append yml
   writeFileS("smallDictFile.yml", "-");
   r = appendFileO(self, "smallDictFile.yml");
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.yml"));
   s = readFileToS("smallDictFile.yml");
   ck_assert_str_eq(s, "----\n  \"\": 1\n  b: 2\n");
   free(s);
   rmAll("smallDictFile.yml");
   // append json string
   writeFileS("smallDictFile", "-");
   freeO(self);
   setTopSO(self, "qwe");
   r = appendFileO(self, "smallDictFile");
   ck_assert(r);
   ck_assert(fileExists("smallDictFile"));
   s = readFileToS("smallDictFile");
   ck_assert_str_eq(s, "-qwe");
   free(s);
   rmAll("smallDictFile");
   // append json array
   writeFileS("smallDictFile", "-");
   freeO(self);
   self->f->pushS(self, "qwe");
   self->f->pushS(self, "asd");
   r = appendFileO(self, "smallDictFile");
   ck_assert(r);
   ck_assert(fileExists("smallDictFile"));
   s = readFileToS("smallDictFile");
   ck_assert_str_eq(s, "-qwe\nasd\n");
   free(s);
   rmAll("smallDictFile");
   // read only path
   r = appendFileO(self, "/readOnlyAppend");
   ck_assert(!r);
   // append json int should not work
   // blank file path
   r = appendFileO(self, "   ");
   ck_assert(!r);
   // null file path
   r = appendFileO(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void appendFileSmallStringSmallJsonT(void) {
 
   bool r;
   smallJsont *self       = allocSmallJson();
   smallStringt *filePath = allocSmallString("smallDictFile.json");
 
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   writeFileS("smallDictFile.json", "-");
   r = self->f->appendFileSmallString(self, filePath);
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.json"));
   char *s = readFileToS("smallDictFile.json");
   ck_assert_str_eq(s, "-{\n  \"\": 1,\n  \"b\": 2\n}\n");
   free(s);
   rmAll("smallDictFile.json");
   // blank path
   setValO(filePath, "   ");
   r = self->f->appendFileSmallString(self, filePath);
   ck_assert(!r);
   // non smallString object
   terminateO(filePath);
   filePath = (smallStringt*) allocSmallInt(2);
   r = self->f->appendFileSmallString(self, filePath);
   ck_assert(!r);
   // null path
   r = self->f->appendFileSmallString(self, null);
   ck_assert(!r);
   terminateO(filePath);
   terminateO(self);
 
 }
 
 
 void appendFileJsonSmallJsonT(void) {
 
   int r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallJsont *filePath = allocSmallJson();
 
   setTopSO(filePath, "smallDictFile.json");
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   writeFileS("smallDictFile.json", "-");
   r = appendFileJsonO(self, filePath);
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.json"));
   char *s = readFileToS("smallDictFile.json");
   ck_assert_str_eq(s, "-{\n  \"\": 1,\n  \"b\": 2\n}\n");
   free(s);
   rmAll("smallDictFile.json");
   // blank path
   freeO(filePath);
   setTopSO(filePath, "   ");
   r = appendFileJsonO(self, filePath);
   ck_assert(!r);
   // non smallJson object
   terminateO(filePath);
   filePath = (smallJsont*) allocSmallInt(2);
   r = appendFileJsonO(self, filePath);
   ck_assert(!r);
   // null path
   r = appendFileJsonO(self, null);
   ck_assert(!r);
   terminateO(filePath);
   terminateO(self);
 
 }
 
 
 void readTextSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // text
   r = readTextO(self, "../textTest.null");
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   // non empty and non json array
   freeO(self);
   setTypeIntO(self);
   r = readTextO(self, "../textTest.null");
   ck_assert_ptr_eq(r, NULL);
   // empty text
   setTypeArrayO(self);
   emptyO(self);
   r = readTextO(self, "../chmodTest.null");
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isEmptyO(self));
   // NULL path
   r = readTextO(self, NULL);
   ck_assert_ptr_eq(r, NULL);
   // non existing path
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   r = readTextO(self, "../nonExistingFile");
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void readTextSmallStringSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self       = allocSmallJson();
   smallStringt *filePath = allocSmallString("");
 
   // text
   setValO(filePath, "../textTest.null");
   r = readTextSmallStringO(self, filePath);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   // empty text
   emptyO(self);
   setValO(filePath, "../chmodTest.null");
   r = readTextSmallStringO(self, filePath);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isEmptyO(self));
   // NULL path
   r = readTextSmallStringO(self, NULL);
   ck_assert_ptr_eq(r, NULL);
   // non existing path
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   setValO(filePath, "../nonExistingFile");
   r = readTextSmallStringO(self, filePath);
   ck_assert_ptr_eq(r, NULL);
   // blank file path
   setValO(filePath, "  ");
   r = readTextSmallStringO(self, filePath);
   ck_assert_ptr_eq(r, NULL);
   // non smallString object
   terminateO(filePath);
   filePath = (smallStringt*) allocSmallInt(2);
   r = readTextSmallStringO(self, filePath);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   terminateO(filePath);
 
 }
 
 
 void readTextJsonSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallJsont *filePath = allocSmallJson();
 
   // text
   freeO(filePath);
   setTopSO(filePath, "../textTest.null");
   r = readTextJsonO(self, filePath);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   // empty text
   emptyO(self);
   freeO(filePath);
   setTopSO(filePath, "../chmodTest.null");
   r = readTextJsonO(self, filePath);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isEmptyO(self));
   // NULL path
   r = readTextJsonO(self, NULL);
   ck_assert_ptr_eq(r, NULL);
   // non existing path
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   freeO(filePath);
   setTopSO(filePath, "../nonExistingFile");
   r = readTextJsonO(self, filePath);
   ck_assert_ptr_eq(r, NULL);
   // blank file path
   freeO(filePath);
   setTopSO(filePath, "  ");
   r = readTextJsonO(self, filePath);
   ck_assert_ptr_eq(r, NULL);
   // non smallString object
   terminateO(filePath);
   filePath = (smallJsont*) allocSmallInt(2);
   r = readTextJsonO(self, filePath);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
   terminateO(filePath);
 
 }
 
 
 void readTextStreamSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   FILE *fp;
 
   // stream
   fp = fopen("../textTest.null", "r");
   r = self->f->readTextStream(self, fp);
   fclose(fp);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   // non empty and non json array
   freeO(self);
   setTypeIntO(self);
   fp = fopen("../chmodTest.null", "r");
   ck_assert_ptr_eq(self->f->readTextStream(self, fp), NULL);
   // empty stream
   setTypeArrayO(self);
   r = self->f->readTextStream(self, fp);
   fclose(fp);
   ck_assert_ptr_ne(r, NULL);
   ck_assert(isEmptyO(self));
   // NULL stream
   ck_assert_ptr_eq(self->f->readTextStream(self, NULL), NULL);
   terminateO(self);
 
 }
 
 
 void writeTextSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // write textOutTest.null
   smallJsont *r2 = readTextO(self, "../textTest.null");
   ck_assert_ptr_ne(r2, NULL);
   r = writeTextO(self, "../textOutTest.null");
   ck_assert(r);
     // check textOutTest.null
   emptyO(self);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   char *s = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   // read only path
   r = writeTextO(self, "/readOnlyPath");
   ck_assert(!r);
   // non empty and non json array
   freeO(self);
   setTypeIntO(self);
   r = writeTextO(self, "../textOutTest.null");
   ck_assert(!r);
   // empty text
   setTypeArrayO(self);
   emptyO(self);
   r = writeTextO(self, "../textOutTest.null");
   ck_assert(!r);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   s  = toStringO(r2);
   ck_assert_str_eq(s, "[]");
   free(s);
   // non existing file
     // make sure the file doesnt exist
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   self->f->pushS(self, "qwe");
   ck_assert(writeTextO(self, "../nonExistingFile"));
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   // NULL path
   ck_assert(!writeTextO(self, NULL));
   terminateO(self);
 
 }
 
 
 void writeTextSmallStringSmallJsonT(void) {
 
   bool r;
   smallJsont *self       = allocSmallJson();
   smallStringt *filePath = allocSmallString("");
 
   // write textOutTest.null
   smallJsont *r2 = readTextO(self, "../textTest.null");
   ck_assert_ptr_ne(r2, NULL);
   setValO(filePath, "../textOutTest.null");
   r = writeTextSmallStringO(self, filePath);
   ck_assert(r);
     // check textOutTest.null
   emptyO(self);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   char *s = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   // empty array
   emptyO(self);
   setValO(filePath, "../textOutTest.null");
   r = writeTextSmallStringO(self, filePath);
   ck_assert(!r);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   s  = toStringO(r2);
   ck_assert_str_eq(s, "[]");
   free(s);
   // non existing file
     // make sure the file doesnt exist
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   self->f->pushS(self, "qwe");
   setValO(filePath, "../nonExistingFile");
   ck_assert(writeTextSmallStringO(self, filePath));
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   // non smallJson object
   terminateO(filePath);
   filePath = (smallStringt*) allocSmallInt(2);
   r = writeTextSmallStringO(self, filePath);
   ck_assert(!r);
   // NULL path
   ck_assert(!writeTextSmallStringO(self, NULL));
   terminateO(self);
   terminateO(filePath);
 
 }
 
 
 void writeTextJsonSmallJsonT(void) {
 
   bool r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallJsont *filePath = allocSmallJson();
 
   // write textOutTest.null
   smallJsont *r2 = readTextO(self, "../textTest.null");
   ck_assert_ptr_ne(r2, NULL);
   freeO(filePath);
   setTopSO(filePath, "../textOutTest.null");
   r = writeTextJsonO(self, filePath);
   ck_assert(r);
     // check textOutTest.null
   emptyO(self);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   char *s = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   // empty array
   emptyO(self);
   freeO(filePath);
   setTopSO(filePath, "../textOutTest.null");
   r = writeTextJsonO(self, filePath);
   ck_assert(!r);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   s  = toStringO(r2);
   ck_assert_str_eq(s, "[]");
   free(s);
   // non existing file
     // make sure the file doesnt exist
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   self->f->pushS(self, "qwe");
   freeO(filePath);
   setTopSO(filePath, "../nonExistingFile");
   ck_assert(writeTextJsonO(self, filePath));
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   // non smallJson object
   terminateO(filePath);
   filePath = (smallJsont*) allocSmallInt(2);
   r = writeTextJsonO(self, filePath);
   ck_assert(!r);
   // NULL path
   ck_assert(!writeTextJsonO(self, NULL));
   rmAll("../textOutTest.null");
   terminateO(self);
   terminateO(filePath);
 
 }
 
 
 void writeTextStreamSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   FILE *fp;
 
   // non json array
   fp = fopen("../textTest.null", "r");
   r = self->f->writeTextStream(self, fp);
   ck_assert(!r);
   // write textOutTest.null
   smallJsont *r2 = self->f->readTextStream(self, fp);
   fclose(fp);
   ck_assert_ptr_ne(r2, NULL);
   fp = fopen("../textOutTest.null", "w");
   r = self->f->writeTextStream(self, fp);
   ck_assert(r);
   // empty array
   emptyO(self);
   ck_assert(!self->f->writeTextStream(self, fp));
   fclose(fp);
     // check textOutTest.null
   fp = fopen("../textOutTest.null", "r");
   r2 = self->f->readTextStream(self, fp);
   fclose(fp);
   ck_assert_ptr_ne(r2, NULL);
   char *s = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void appendTextSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // append to textOutTest.null
   smallJsont *r2 = readTextO(self, "../textTest.null");
   ck_assert_ptr_ne(r2, NULL);
   r = writeTextO(self, "../textOutTest.null");
   ck_assert(r);
   emptyO(self);
   self->f->pushS(self, "A");
   self->f->pushS(self, "B");
   r = appendTextO(self, "../textOutTest.null");
     // check textOutTest.null
   emptyO(self);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   char *s = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]");
   free(s);
   // non existing file
     // make sure the file doesnt exist
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   ck_assert(appendTextO(self, "../nonExistingFile"));
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   // empty array
   emptyO(self);
   r = appendTextO(self, "../textOutTest.null");
   ck_assert(!r);
     // check textOutTest.null
   emptyO(self);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   s  = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]");
   free(s);
   // blank path
   ck_assert(!appendTextO(self, "  "));
   // NULL path
   ck_assert(!appendTextO(self, NULL));
   // non empty json and non json array
   freeO(self);
   setTypeBoolO(self);
   ck_assert(!appendTextO(self, "appendTest.txt"));
   terminateO(self);
 
 }
 
 
 void appendTextSmallStringSmallJsonT(void) {
 
   bool r;
   smallJsont *self      = allocSmallJson();
   smallStringt *filePath = allocSmallString("");
 
   // append to textOutTest.null
   smallJsont *r2 = readTextO(self, "../textTest.null");
   ck_assert_ptr_ne(r2, NULL);
   r = writeTextO(self, "../textOutTest.null");
   ck_assert(r);
   emptyO(self);
   self->f->pushS(self, "A");
   self->f->pushS(self, "B");
   setValO(filePath, "../textOutTest.null");
   r = appendTextSmallStringO(self, filePath);
     // check textOutTest.null
   emptyO(self);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   char *s = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]");
   free(s);
   // non existing file
     // make sure the file doesnt exist
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   setValO(filePath, "../nonExistingFile");
   ck_assert(appendTextSmallStringO(self, filePath));
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   // empty array
   emptyO(self);
   r = appendTextSmallStringO(self, filePath);
   ck_assert(!r);
     // check textOutTest.null
   emptyO(self);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   s  = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]");
   free(s);
   // blank path
   setValO(filePath, "   ");
   ck_assert(!appendTextSmallStringO(self, filePath));
   // non smallString object
   terminateO(filePath);
   filePath = (smallStringt*) allocSmallInt(2);
   r = appendTextSmallStringO(self, filePath);
   ck_assert(!r);
   // NULL path
   ck_assert(!appendTextSmallStringO(self, NULL));
   terminateO(self);
   terminateO(filePath);
 
 }
 
 
 void appendTextJsonSmallJsonT(void) {
 
   bool r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallJsont *filePath = allocSmallJson();
 
   // append to textOutTest.null
   smallJsont *r2 = readTextO(self, "../textTest.null");
   ck_assert_ptr_ne(r2, NULL);
   r = writeTextO(self, "../textOutTest.null");
   ck_assert(r);
   emptyO(self);
   self->f->pushS(self, "A");
   self->f->pushS(self, "B");
   freeO(filePath);
   setTopSO(filePath, "../textOutTest.null");
   r = appendTextJsonO(self, filePath);
     // check textOutTest.null
   emptyO(self);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   char *s = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]");
   free(s);
   // non existing file
     // make sure the file doesnt exist
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   freeO(filePath);
   setTopSO(filePath, "../nonExistingFile");
   ck_assert(appendTextJsonO(self, filePath));
   if (fileExists("../nonExistingFile"))
     rmAll("../nonExistingFile");
   // empty array
   emptyO(self);
   r = appendTextJsonO(self, filePath);
   ck_assert(!r);
     // check textOutTest.null
   emptyO(self);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   s  = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]");
   free(s);
   // blank path
   freeO(filePath);
   setTopSO(filePath, "   ");
   ck_assert(!appendTextJsonO(self, filePath));
   // non smallString object
   terminateO(filePath);
   filePath = (smallJsont*) allocSmallInt(2);
   r = appendTextJsonO(self, filePath);
   ck_assert(!r);
   // NULL path
   ck_assert(!appendTextJsonO(self, NULL));
   terminateO(self);
   terminateO(filePath);
 
 }
 
 
 void typeStringSmallJsonT(void) {
 
   const char* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   self->f->setBool(self, "lib", true);
   r = typeStringO(self, "lib");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "bool");
   // path
   baset *value = (baset*) allocSmallInt(2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   smallJsont *r2 = self->f->set(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = typeStringO(self, "\"array\"[0].\"key\"");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "int");
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = typeStringO(self, "1");
   ck_assert_ptr_eq(r, null);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = typeStringO(self, "1");
   ck_assert_ptr_eq(r, null);
   // non existing dict path
   freeO(self);
   r = typeStringO(self, "\"1\"[1]");
   ck_assert_ptr_eq(r, null);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = typeStringO(self, "\"1\".\"1\"");
   ck_assert_ptr_eq(r, null);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = typeStringO(self, "\"2\".\"1\".[12]");
   ck_assert_ptr_eq(r, null);
   // non existing element
   r = typeStringO(self, "randomKey");
   ck_assert_ptr_eq(r, null);
   // null key
   r = typeStringO(self, null);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void typeSmallStringSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   r = typeSmallStringO(self, "");
   ck_assert_str_eq(ssGet(r), "int");
   terminateO(r);
   // non existing key
   r = typeSmallStringO(self, "asd");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void typeAtStringSmallJsonT(void) {
 
   const char* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // empty self
   r = typeAtStringO(self, 0);
   ck_assert_str_eq(r, "not a sheepy object");
   terminateO(self);
 
 }
 
 
 void typeAtSmallStringSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
 
   // empty array
   r = typeAtSmallStringO(self, 0);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "not a sheepy object");
   free(s);
   terminateO(self);
   terminateO(r);
 
 }
 
 
 void typeStringKCharSmallJsonT(void) {
 
   const char* r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   r = typeStringKCharO(self, 'b');
   ck_assert_str_eq(r, "int");
   terminateO(self);
 
 }
 
 
 void typeSmallStringKCharSmallJsonT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   r = typeSmallStringKCharO(self, 'b');
   ck_assert_str_eq(ssGet(r), "int");
   terminateO(r);
   // non existing key
   r = typeSmallStringKCharO(self, 'a');
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void typeSmallJsonT(void) {
 
   char r;
   smallJsont *self = allocG(rtSmallJsont);
 
   self->f->setBool(self, "lib", true);
   r = typeO(self, "lib");
   ck_assert_int_eq(r, 2);
   // path
   baset *value = (baset*) allocSmallInt(2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   smallJsont *r2 = self->f->set(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = typeO(self, "\"array\"[0].\"key\"");
   ck_assert_int_eq(r, 7);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = typeO(self, "1");
   ck_assert(!r);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = typeO(self, "1");
   ck_assert(!r);
   // non existing dict path
   freeO(self);
   r = typeO(self, "\"1\"[1]");
   ck_assert(!r);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = typeO(self, "\"1\".\"1\"");
   ck_assert(!r);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = typeO(self, "\"2\".\"1\".[12]");
   ck_assert(!r);
   // non existing element
   r = typeO(self, "randomKey");
   ck_assert(!r);
   // null key
   r = typeO(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void typeKCharSmallJsonT(void) {
 
   char r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   r = typeKCharO(self, 'b');
   ck_assert_int_eq(r, 7);
   terminateO(self);
 
 }
 
 
 void typeAtSmallJsonT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
 
   // non json array
   ck_assert_int_eq(typeAtO(self, 0), 0);
   // empty json array
   setTypeArrayO(self);
   ck_assert_int_eq(typeAtO(self, 0), 0);
   // type
   self->f->pushInt(self, 1);
   ck_assert_int_eq(typeAtO(self, 0), 7);
   // outside
   ck_assert_int_eq(typeAtO(self, 1), 0);
   ck_assert_int_eq(typeAtO(self, -2), 0);
   terminateO(self);
 
 }
 
 
 void typeStringsSmallJsonT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // non json array or dict
   setTypeBoolO(self);
   r = typeStringsO(self);
   ck_assert_ptr_eq(r, null);
   // json dict
   freeO(self);
   self->f->setUndefined(self, "u");
   self->f->setS(self, "s", "s");
   self->f->setInt(self, "i", 123);
   r = typeStringsO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"u\":\"undefined\",\"s\":\"string\",\"i\":\"int\"}");
   free(s);
   terminateO(r);
   // json array
   freeO(self);
   self->f->pushUndefined(self);
   self->f->pushS(self,"qwe");
   self->f->pushInt(self,123);
   r = typeStringsO(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"undefined\",\"string\",\"int\"]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void typesSmallJsonT(void) {
 
   smallBytest* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // non json array
   r = typesO(self);
   ck_assert_ptr_eq(r, null);
   // empty json array
   setTypeArrayO(self);
   r = typesO(self);
   ck_assert_ptr_eq(r, null);
   // json array with elements
   self->f->pushUndefined(self);
   self->f->pushS(self,"qwe");
   self->f->pushInt(self,123);
   r = typesO(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[0x01,0x08,0x07]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void isETypeAtSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // non json array
   r = isETypeAtO(self, 0, "undefined");
   ck_assert(!r);
   // json array
   self->f->pushUndefined(self);
   r = isETypeAtO(self, 0, "undefined");
   ck_assert(r);
   // NULL type
   emptyO(self);
   r = isETypeAtO(self, 0, NULL);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEUndefinedAtSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // non json array
   r = isEUndefinedAtO(self, 0);
   ck_assert(!r);
   // array
   self->f->pushUndefined(self);
   self->f->pushS(self, "");
   r = isEUndefinedAtO(self, 0);
   ck_assert(r);
   r = isEUndefinedAtO(self, -1);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEBoolAtSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // non json array
   r = isEBoolAtO(self, 0);
   ck_assert(!r);
   // array
   self->f->pushBool(self, true);
   self->f->pushS(self, "");
   r = isEBoolAtO(self, 0);
   ck_assert(r);
   r = isEBoolAtO(self, -1);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEContainerAtSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // non json array
   r = isEContainerAtO(self, 0);
   ck_assert(!r);
   // array
   createSmallContainer(c);
   self->f->pushSmallContainer(self, &c);
   self->f->pushS(self, "");
   r = isEContainerAtO(self, 0);
   ck_assert(r);
   r = isEContainerAtO(self, -1);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEDictAtSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // non json array
   r = isEDictAtO(self, 0);
   ck_assert(!r);
   // array
   createSmallDict(d);
   self->f->pushDict(self, &d);
   self->f->pushS(self, "");
   r = isEDictAtO(self, 0);
   ck_assert(r);
   r = isEDictAtO(self, -1);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEDoubleAtSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // non json array
   r = isEDoubleAtO(self, 0);
   ck_assert(!r);
   // array
   self->f->pushDouble(self, 1);
   self->f->pushS(self, "");
   r = isEDoubleAtO(self, 0);
   ck_assert(r);
   r = isEDoubleAtO(self, -1);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEIntAtSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // non json array
   r = isEIntAtO(self, 0);
   ck_assert(!r);
   // array
   self->f->pushInt(self, 1);
   self->f->pushS(self, "");
   r = isEIntAtO(self, 0);
   ck_assert(r);
   r = isEIntAtO(self, -1);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEStringAtSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // non json array
   r = isEStringAtO(self, 0);
   ck_assert(!r);
   // array
   self->f->pushUndefined(self);
   self->f->pushS(self, "");
   r = isEStringAtO(self, -1);
   ck_assert(r);
   r = isEStringAtO(self, 0);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEFaststringAtSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // non json array
   r = isEFaststringAtO(self, 0);
   ck_assert(!r);
   // array
   self->f->pushUndefined(self);
   self->f->pushS(self, "");
   r = isEFaststringAtO(self, -1);
   ck_assert(!r);
   r = isEFaststringAtO(self, 0);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEArrayAtSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // non json array
   r = isEArrayAtO(self, 0);
   ck_assert(!r);
   // array
   createSmallArray(a);
   self->f->pushArray(self, &a);
   self->f->pushS(self, "");
   r = isEArrayAtO(self, 0);
   ck_assert(r);
   r = isEArrayAtO(self, -1);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEBytesAtSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // non json array
   r = isEBytesAtO(self, 0);
   ck_assert(!r);
   // array
   createSmallBytes(b);
   self->f->pushSmallBytes(self, &b);
   self->f->pushS(self, "");
   r = isEBytesAtO(self, 0);
   ck_assert(r);
   r = isEBytesAtO(self, -1);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isETypeSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   r = isETypeO(self, "", "int");
   ck_assert(r);
   // path
   baset *value = (baset*) allocSmallInt(2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   smallJsont *r2 = self->f->set(self, "\"array\"[0].\"key\"", value);
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = isETypeO(self, "\"array\"[0].\"key\"", "int");
   ck_assert(r);
   r = isETypeO(self, "\"array\"[0].\"key\"", "bool");
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = isETypeO(self, "1", "bool");
   ck_assert(!r);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = isETypeO(self, "1", "array");
   ck_assert(!r);
   // non existing dict path
   freeO(self);
   r = isETypeO(self, "\"1\"[1]", "int");
   ck_assert(!r);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = isETypeO(self, "\"1\".\"1\"", "int");
   ck_assert(!r);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = isETypeO(self, "\"2\".\"1\".[12]", "int");
   ck_assert(!r);
   // non existing element
   r = isETypeO(self, "randomKey", "int");
   ck_assert(!r);
   // null type
   r = isETypeO(self, "", null);
   ck_assert(!r);
   // null key
   r = isETypeO(self, null, "int");
   ck_assert(!r);
   // empty dict
   freeO(self);
   r = isETypeO(self, "", "int");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEUndefinedSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   self->f->setUndefined(self, "b");
   r = isEUndefinedO(self, "b");
   ck_assert(r);
   r = isEUndefinedO(self, "");
   ck_assert(!r);
   // path
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   smallJsont *r2 = self->f->setUndefined(self, "\"array\"[0].\"key\"");
   r2             = self->f->setS(self, "\"array\"[0].\"s\"", "asd");
   ck_assert_ptr_ne(r2, null);
   r = isEUndefinedO(self, "\"array\"[0].\"key\"");
   ck_assert(r);
   r = isEUndefinedO(self, "\"array\"[0].\"s\"");
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = isEUndefinedO(self, "1");
   ck_assert(!r);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = isEUndefinedO(self, "1");
   ck_assert(!r);
   // non existing dict path
   freeO(self);
   r = isEUndefinedO(self, "\"1\"[1]");
   ck_assert(!r);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = isEUndefinedO(self, "\"1\".\"1\"");
   ck_assert(!r);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = isEUndefinedO(self, "\"2\".\"1\".[12]");
   ck_assert(!r);
   // non existing key
   r = isEUndefinedO(self, "qwe");
   ck_assert(!r);
   // empty dict
   freeO(self);
   r = isEUndefinedO(self, "");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEBoolSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   self->f->setBool(self, "b", true);
   r = isEBoolO(self, "b");
   ck_assert(r);
   r = isEBoolO(self, "");
   ck_assert(!r);
   // path
   baset *value = (baset*) allocSmallBool(true);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   smallJsont *r2 = self->f->set(self, "\"array\"[0].\"key\"", value);
   r2             = self->f->setUndefined(self, "\"array\"[0].\"s\"");
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = isEBoolO(self, "\"array\"[0].\"key\"");
   ck_assert(r);
   r = isEBoolO(self, "\"array\"[0].\"s\"");
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = isEBoolO(self, "1");
   ck_assert(!r);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = isEBoolO(self, "1");
   ck_assert(!r);
   // non existing dict path
   freeO(self);
   r = isEBoolO(self, "\"1\"[1]");
   ck_assert(!r);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = isEBoolO(self, "\"1\".\"1\"");
   ck_assert(!r);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = isEBoolO(self, "\"2\".\"1\".[12]");
   ck_assert(!r);
   // non existing key
   r = isEBoolO(self, "qwe");
   ck_assert(!r);
   // empty dict
   freeO(self);
   r = isEBoolO(self, "");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEContainerSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   self->f->setInt(self, "", 1);
   self->f->setBool(self, "b", true);
   self->f->setSmallContainer(self, "c", &c);
   r = isEContainerO(self, "c");
   ck_assert(r);
   r = isEContainerO(self, "b");
   ck_assert(!r);
   // path
   baset *value = (baset*) allocSmallContainer(null);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   smallJsont *r2 = self->f->set(self, "\"array\"[0].\"key\"", value);
   r2             = self->f->setUndefined(self, "\"array\"[0].\"s\"");
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = isEContainerO(self, "\"array\"[0].\"key\"");
   ck_assert(r);
   r = isEContainerO(self, "\"array\"[0].\"s\"");
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = isEContainerO(self, "1");
   ck_assert(!r);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = isEContainerO(self, "1");
   ck_assert(!r);
   // non existing dict path
   freeO(self);
   r = isEContainerO(self, "\"1\"[1]");
   ck_assert(!r);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = isEContainerO(self, "\"1\".\"1\"");
   ck_assert(!r);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = isEContainerO(self, "\"2\".\"1\".[12]");
   ck_assert(!r);
   // non existing key
   r = isEContainerO(self, "qwe");
   ck_assert(!r);
   // empty dict
   freeO(self);
   r = isEContainerO(self, "");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEDictSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   createSmallDict(D);
   self->f->setDict(self, "b", &D);
   r = isEDictO(self, "b");
   ck_assert(r);
   r = isEDictO(self, "");
   ck_assert(!r);
   // path
   baset *value = (baset*) allocSmallDict();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   smallJsont *r2 = self->f->set(self, "\"array\"[0].\"key\"", value);
   r2             = self->f->setUndefined(self, "\"array\"[0].\"s\"");
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = isEDictO(self, "\"array\"[0].\"key\"");
   ck_assert(r);
   r = isEDictO(self, "\"array\"[0].\"s\"");
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = isEDictO(self, "1");
   ck_assert(!r);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = isEDictO(self, "1");
   ck_assert(!r);
   // non existing dict path
   freeO(self);
   r = isEDictO(self, "\"1\"[1]");
   ck_assert(!r);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = isEDictO(self, "\"1\".\"1\"");
   ck_assert(!r);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = isEDictO(self, "\"2\".\"1\".[12]");
   ck_assert(!r);
   // non existing key
   r = isEDictO(self, "qwe");
   ck_assert(!r);
   // empty dict
   freeO(self);
   r = isEDictO(self, "");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEDoubleSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   self->f->setDouble(self, "b", 2.2);
   r = isEDoubleO(self, "b");
   ck_assert(r);
   r = isEDoubleO(self, "");
   ck_assert(!r);
   // path
   baset *value = (baset*) allocSmallDouble(2.2);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   smallJsont *r2 = self->f->set(self, "\"array\"[0].\"key\"", value);
   r2             = self->f->setUndefined(self, "\"array\"[0].\"s\"");
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = isEDoubleO(self, "\"array\"[0].\"key\"");
   ck_assert(r);
   r = isEDoubleO(self, "\"array\"[0].\"s\"");
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = isEDoubleO(self, "1");
   ck_assert(!r);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = isEDoubleO(self, "1");
   ck_assert(!r);
   // non existing dict path
   freeO(self);
   r = isEDoubleO(self, "\"1\"[1]");
   ck_assert(!r);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = isEDoubleO(self, "\"1\".\"1\"");
   ck_assert(!r);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = isEDoubleO(self, "\"2\".\"1\".[12]");
   ck_assert(!r);
   // non existing key
   r = isEDoubleO(self, "qwe");
   ck_assert(!r);
   // empty dict
   freeO(self);
   r = isEDoubleO(self, "");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEIntSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->setBool(self, "", true);
   self->f->setInt(self, "b", 2);
   r = isEIntO(self, "b");
   ck_assert(r);
   r = isEIntO(self, "");
   ck_assert(!r);
   // path
   baset *value = (baset*) allocSmallInt(123);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   smallJsont *r2 = self->f->set(self, "\"array\"[0].\"key\"", value);
   r2             = self->f->setUndefined(self, "\"array\"[0].\"s\"");
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = isEIntO(self, "\"array\"[0].\"key\"");
   ck_assert(r);
   r = isEIntO(self, "\"array\"[0].\"s\"");
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = isEIntO(self, "1");
   ck_assert(!r);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = isEIntO(self, "1");
   ck_assert(!r);
   // non existing dict path
   freeO(self);
   r = isEIntO(self, "\"1\"[1]");
   ck_assert(!r);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = isEIntO(self, "\"1\".\"1\"");
   ck_assert(!r);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = isEIntO(self, "\"2\".\"1\".[12]");
   ck_assert(!r);
   // non existing key
   r = isEIntO(self, "qwe");
   ck_assert(!r);
   // empty dict
   freeO(self);
   r = isEIntO(self, "");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEStringSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   self->f->setS(self, "b", "!@#");
   r = isEStringO(self, "b");
   ck_assert(r);
   r = isEStringO(self, "");
   ck_assert(!r);
   // path
   baset *value = (baset*) allocSmallString("qwe");
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   smallJsont *r2 = self->f->set(self, "\"array\"[0].\"key\"", value);
   r2             = self->f->setUndefined(self, "\"array\"[0].\"s\"");
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = isEStringO(self, "\"array\"[0].\"key\"");
   ck_assert(r);
   r = isEStringO(self, "\"array\"[0].\"s\"");
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = isEStringO(self, "1");
   ck_assert(!r);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = isEStringO(self, "1");
   ck_assert(!r);
   // non existing dict path
   freeO(self);
   r = isEStringO(self, "\"1\"[1]");
   ck_assert(!r);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = isEStringO(self, "\"1\".\"1\"");
   ck_assert(!r);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = isEStringO(self, "\"2\".\"1\".[12]");
   ck_assert(!r);
   // non existing key
   r = isEStringO(self, "qwe");
   ck_assert(!r);
   // empty dict
   freeO(self);
   r = isEStringO(self, "");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEFaststringSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   r = isEFaststringO(self, "");
   ck_assert(!r);
   // path
   baset *value = (baset*) allocSmallBool(true);
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   smallJsont *r2 = self->f->set(self, "\"array\"[0].\"key\"", value);
   r2             = self->f->setUndefined(self, "\"array\"[0].\"s\"");
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = isEFaststringO(self, "\"array\"[0].\"key\"");
   ck_assert(!r);
   r = isEFaststringO(self, "\"array\"[0].\"s\"");
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = isEFaststringO(self, "1");
   ck_assert(!r);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = isEFaststringO(self, "1");
   ck_assert(!r);
   // non existing dict path
   freeO(self);
   r = isEFaststringO(self, "\"1\"[1]");
   ck_assert(!r);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = isEFaststringO(self, "\"1\".\"1\"");
   ck_assert(!r);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = isEFaststringO(self, "\"2\".\"1\".[12]");
   ck_assert(!r);
   // non existing key
   r = isEFaststringO(self, "qwe");
   ck_assert(!r);
   // empty dict
   freeO(self);
   r = isEFaststringO(self, "");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEArraySmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   createSmallArray(A);
   self->f->setInt(self, "", 1);
   self->f->setArray(self, "b", &A);
   r = isEArrayO(self, "b");
   ck_assert(r);
   r = isEArrayO(self, "");
   ck_assert(!r);
   // path
   baset *value = (baset*) allocSmallArray();
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   smallJsont *r2 = self->f->set(self, "\"array\"[0].\"key\"", value);
   r2             = self->f->setUndefined(self, "\"array\"[0].\"s\"");
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = isEArrayO(self, "\"array\"[0].\"key\"");
   ck_assert(r);
   r = isEArrayO(self, "\"array\"[0].\"s\"");
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = isEArrayO(self, "1");
   ck_assert(!r);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = isEArrayO(self, "1");
   ck_assert(!r);
   // non existing dict path
   freeO(self);
   r = isEArrayO(self, "\"1\"[1]");
   ck_assert(!r);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = isEArrayO(self, "\"1\".\"1\"");
   ck_assert(!r);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = isEArrayO(self, "\"2\".\"1\".[12]");
   ck_assert(!r);
   // non existing key
   r = isEArrayO(self, "qwe");
   ck_assert(!r);
   // empty dict
   freeO(self);
   r = isEArrayO(self, "");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void isEBytesSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   createSmallBytes(b);
   self->f->setInt(self, "", 1);
   self->f->setSmallBytes(self, "b", &b);
   r = isEBytesO(self, "b");
   ck_assert(r);
   r = isEBytesO(self, "");
   ck_assert(!r);
   // path
   baset *value = (baset*) allocSmallBytes("", sizeof(""));
   createSmallArray(a);
   createSmallDict(d);
   a.f->pushDict(&a, &d);
   self->f->setArray(self, "array", &a);
   smallJsont *r2 = self->f->set(self, "\"array\"[0].\"key\"", value);
   r2             = self->f->setUndefined(self, "\"array\"[0].\"s\"");
   ck_assert_ptr_ne(r2, null);
   finishO(value);
   r = isEBytesO(self, "\"array\"[0].\"key\"");
   ck_assert(r);
   r = isEBytesO(self, "\"array\"[0].\"s\"");
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = isEBytesO(self, "1");
   ck_assert(!r);
   // json array
   freeO(self);
   setTypeArrayO(self);
   r = isEBytesO(self, "1");
   ck_assert(!r);
   // non existing dict path
   freeO(self);
   r = isEBytesO(self, "\"1\"[1]");
   ck_assert(!r);
   //   dict path but the object is an array
   resetO(&a);
   self->f->setArray(self, "1", &a);
   r = isEBytesO(self, "\"1\".\"1\"");
   ck_assert(!r);
   //   dict object in path but the key doesn't exists
   resetO(&d);
   self->f->setDict(self, "2", &d);
   r = isEBytesO(self, "\"2\".\"1\".[12]");
   ck_assert(!r);
   // non existing key
   r = isEBytesO(self, "qwe");
   ck_assert(!r);
   // empty dict
   freeO(self);
   r = isEBytesO(self, "");
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void areAllETypeSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->setBool(self, "a", true);
   self->f->setBool(self, "b", true);
   r = areAllETypeO(self, "bool");
   ck_assert(r);
   self->f->setInt(self, "c", 2);
   r = areAllETypeO(self, "bool");
   ck_assert(!r);
   // null type
   r = areAllETypeO(self, null);
   ck_assert(!r);
   // empty self
   freeO(self);
   setTypeDictO(self);
   r = areAllETypeO(self, "bool");
   ck_assert(!r);
   self->f->setS(self, "a", "");
   self->f->delElem(self, "a");
   r = areAllETypeO(self, "string");
   ck_assert(!r);
   // json array
   freeO(self);
   // empty array
   r = areAllETypeO(self, "undefined");
   ck_assert(!r);
   setTypeArrayO(self);
   r = areAllETypeO(self, "undefined");
   ck_assert(!r);
   // array
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   r = areAllETypeO(self, "undefined");
   ck_assert(!r);
   trimO(self);
   r = areAllETypeO(self, "undefined");
   ck_assert(r);
   // NULL type
   r = areAllETypeO(self, NULL);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void areAllEUndefinedSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // array
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   self->f->pushUndefined(self);
   r = areAllEUndefinedO(self);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void areAllEBoolSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   // array
   self->f->pushBool(self, true);
   self->f->pushBool(self, true);
   self->f->pushBool(self, true);
   r = areAllEBoolO(self);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void areAllEContainerSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   self->f->pushSmallContainer(self, &c);
   r = areAllEContainerO(self);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void areAllEDictSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   createSmallDict(d);
   self->f->pushDict(self, &d);
   r = areAllEDictO(self);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void areAllEDoubleSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushDouble(self, 1);
   r = areAllEDoubleO(self);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void areAllEIntSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushInt(self, 1);
   r = areAllEIntO(self);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void areAllEStringSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushS(self, "");
   r = areAllEStringO(self);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void areAllEFaststringSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushS(self, "");
   r = areAllEFaststringO(self);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void areAllEArraySmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   createSmallArray(a);
   self->f->pushArray(self, &a);
   r = areAllEArrayO(self);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void areAllEBytesSmallJsonT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   createSmallBytes(b);
   self->f->pushSmallBytes(self, &b);
   r = areAllEBytesO(self);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void duplicateSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushInt(self, 1);
   iterStartO(self);
   r = duplicateSmallJsonG(self);
   char *s = toStringO(r);
   ck_assert_int_eq(r->iterIndex, 0);
   terminateO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   // with iterator
   freeO(self);
   self->f->setS(self, "qwe", "asd");
   iterStartO(self);
   r = duplicateSmallJsonG(self);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"qwe\":\"asd\"}");
   free(s);
   ck_assert_str_eq(r->iterKey, "qwe");
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void freeSmallJsonGT(void) {
 
   smallJsont *self = allocSmallJson();
 
   self->f->pushInt(self, 1);
   freeSmallJsonG(self);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // value is a smallJson
   // undefined
   createAllocateSmallJson(js);
   createUndefined(u);
   setTopO(js, (baset*)&u);
   r = setTopSmallJsonG(self, (baset*) js);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   resetO(js);
   freeO(self);
   // bool
   setTopBoolO(js, true);
   r = setTopSmallJsonG(self, (baset*) js);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   resetO(js);
   freeO(self);
   // double
   setTopDoubleO(js, 2.2);
   r = setTopSmallJsonG(self, (baset*) js);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "2.200000e+00");
   free(s);
   resetO(js);
   freeO(self);
   // int
   setTopIntO(js, 2);
   r = setTopSmallJsonG(self, (baset*) js);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   resetO(js);
   freeO(self);
   // string
   setTopSO(js, "qwe");
   r = setTopSmallJsonG(self, (baset*) js);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   resetO(js);
   freeO(self);
   // dict
   js->f->setS(js, "1", "2");
   r = setTopSmallJsonG(self, (baset*) js);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"2\"}");
   free(s);
   resetO(js);
   freeO(self);
   // array
   js->f->pushS(js, "qwe");
   r = setTopSmallJsonG(self, (baset*) js);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   resetO(js);
   terminateO(js);
   terminateO(self);
 
 }
 
 
 void setTopBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopBoolSmallJsonG(self, true);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopDoubleSmallJsonG(self, 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2.000000e+00");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopIntSmallJsonG(self, 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopStringSmallJsonG(self, "qwe");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopCharSmallJsonG(self, 'X');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "X");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   smallDictt *value = allocSmallDict();
 
   r = setTopDictSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishG(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   smallArrayt *value = allocSmallArray();
 
   r = setTopArraySmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishG(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   char **value     = listCreateS("a","bb");
 
   r = setTopArraycSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   listFreeS(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"a\",\"bb\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopCArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocG(rtSmallJsont);
   const char *value[] = {"a", "bb", null};
 
   r = setTopCArraycSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"a\",\"bb\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopSmallBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallBoolt *value = allocSmallBool(true);
 
   r = setTopSmallBoolSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishG(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopSmallDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocG(rtSmallJsont);
   smallDoublet *value = allocSmallDouble(2);
 
   r = setTopSmallDoubleSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishG(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2.000000e+00");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopSmallIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   smallIntt *value = allocSmallInt(2);
 
   r = setTopSmallIntSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishG(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallJsont *value = allocSmallJson();
 
   r = setTopSmallJsonSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishG(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocG(rtSmallJsont);
   smallStringt *value = allocSmallString("qwe");
 
   r = setTopSmallStringSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishG(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   baset *value     = (baset*)allocSmallInt(2);
 
   r = setTopNFreeSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopNFreeBoolSmallJsonG(self, true);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopNFreeDoubleSmallJsonG(self, 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2.000000e+00");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = setTopNFreeIntSmallJsonG(self, 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   char *value      = strdup("qwe");
 
   r = setTopNFreeStringSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallDictt *value = allocSmallDict();
 
   r = setTopNFreeDictSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallArrayt *value = allocSmallArray();
 
   r = setTopNFreeArraySmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   char **value     = listCreateS("a","bb");
 
   r = setTopNFreeArraycSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"a\",\"bb\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeSmallBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallBoolt *value = allocSmallBool(true);
 
   r = setTopNFreeSmallBoolSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeSmallDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocG(rtSmallJsont);
   smallDoublet *value = allocSmallDouble(2);
 
   r = setTopNFreeSmallDoubleSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2.000000e+00");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeSmallIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   smallIntt *value = allocSmallInt(2);
 
   r = setTopNFreeSmallIntSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallJsont *value = allocSmallJson();
 
   r = setTopNFreeSmallJsonSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setTopNFreeSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocG(rtSmallJsont);
   smallStringt *value = allocSmallString("qwe");
 
   r = setTopNFreeSmallStringSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   terminateO(self);
 
 }
 
 
 void fromArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   char *array[] = {"1", "22", "333"};
   r = fromArraySmallJsonG(self, array, 3);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"1\",\"22\",\"333\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void fromCArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   const char *array[] = {"1", "22", "333"};
   r = fromCArraySmallJsonG(self, array, 3);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"1\",\"22\",\"333\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void getTopSmallJsonGT(void) {
 
   baset*        r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 987);
   r = getTopSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r->type, "smallInt");
   finishO(r);
   terminateO(self);
 
 }
 
 
 void getTopUndefinedSmallJsonGT(void) {
 
   undefinedt*   r  = allocUndefined();;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopO(self, (baset*) r);
   finishO(r);
   r = getTopUndefinedSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   terminateO(self);
 
 }
 
 
 void getTopBoolSmallJsonGT(void) {
 
   bool          r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopBoolO(self, true);
   r = getTopBoolSmallJsonG(self, true);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void getTopBoolPSmallJsonGT(void) {
 
   bool*         r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopBoolO(self, true);
   r = getTopBoolPSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r);
   terminateO(self);
 
 }
 
 
 void getTopDoubleSmallJsonGT(void) {
 
   double        r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopDoubleO(self, 2);
   r = getTopDoubleSmallJsonG(self, 0);
   ck_assert(r==2);
   terminateO(self);
 
 }
 
 
 void getTopDoublePSmallJsonGT(void) {
 
   double*       r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopDoubleO(self, 2);
   r = getTopDoublePSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r==2);
   terminateO(self);
 
 }
 
 
 void getTopIntSmallJsonGT(void) {
 
   int64_t       r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopIntSmallJsonG(self, 0);
   ck_assert_int_eq(r, 3);
   terminateO(self);
 
 }
 
 
 void getTopIntPSmallJsonGT(void) {
 
   int64_t*      r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopIntPSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 3);
   terminateO(self);
 
 }
 
 
 void getTopInt32SmallJsonGT(void) {
 
   int32_t       r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopInt32SmallJsonG(self, 0);
   ck_assert_int_eq(r, 3);
   terminateO(self);
 
 }
 
 
 void getTopInt32PSmallJsonGT(void) {
 
   int32_t*      r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopInt32PSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 3);
   terminateO(self);
 
 }
 
 
 void getTopUintSmallJsonGT(void) {
 
   uint64_t      r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopUintSmallJsonG(self, 0);
   ck_assert_int_eq(r, 3);
   terminateO(self);
 
 }
 
 
 void getTopUintPSmallJsonGT(void) {
 
   uint64_t*     r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopUintPSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 3);
   terminateO(self);
 
 }
 
 
 void getTopUint32SmallJsonGT(void) {
 
   uint32_t      r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopUint32SmallJsonG(self, 0);
   ck_assert_int_eq(r, 3);
   terminateO(self);
 
 }
 
 
 void getTopUint32PSmallJsonGT(void) {
 
   uint32_t*     r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopIntO(self, 3);
   r = getTopUint32PSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 3);
   terminateO(self);
 
 }
 
 
 void getTopSSmallJsonGT(void) {
 
   char*         r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopStringO(self, "qwe");
   r = getTopSSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "qwe");
   terminateO(self);
 
 }
 
 
 void getTopDictSmallJsonGT(void) {
 
   smallDictt*   r  = allocSmallDict();
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopNFreeDictO(self, r);
   r = getTopDictSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(self);
 
 }
 
 
 void getTopArraySmallJsonGT(void) {
 
   smallArrayt*  r  = allocSmallArray();
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopNFreeArrayO(self, r);
   r = getTopArraySmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void getTopSmallBoolSmallJsonGT(void) {
 
   smallBoolt*   r  = allocSmallBool(true);
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopNFreeSmallBoolO(self, r);
   r = getTopSmallBoolSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(self);
 
 }
 
 
 void getTopSmallDoubleSmallJsonGT(void) {
 
   smallDoublet* r  = allocSmallDouble(2);
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopNFreeSmallDoubleO(self, r);
   r = getTopSmallDoubleSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "2.000000e+00");
   free(s);
   terminateO(self);
 
 }
 
 
 void getTopSmallIntSmallJsonGT(void) {
 
   smallIntt*    r  = allocSmallInt(2);
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopNFreeSmallIntO(self, r);
   r = getTopSmallIntSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void getTopSmallStringSmallJsonGT(void) {
 
   smallStringt* r  = allocSmallString("qwe");
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopNFreeSmallStringO(self, r);
   r = getTopSmallStringSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*) allocSmallInt(1);
 
   r = pushSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushUndefinedSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = pushUndefinedSmallJsonG(self, NULL);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = pushBoolSmallJsonG(self, true);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = pushDoubleSmallJsonG(self, 1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = pushIntSmallJsonG(self, 1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = pushSSmallJsonG(self, "qwe");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = pushCharSmallJsonG(self, 'Q');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"Q\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict  = allocSmallDict();
 
   r = pushDictSmallJsonG(self, dict);
   ck_assert_ptr_ne(r, null);
   finishO(dict);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   r = pushArraySmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   finishO(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array      = listCreateS("a","bb");
 
   r = pushArraycSmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   listFreeS(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"bb\"]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushCArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   const char *array[] = {"a", "bb", NULL};
 
   r = pushCArraycSmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"bb\"]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushVoidSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // NULL value
   r = pushVoidSmallJsonG(self, NULL);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   // value
   r = pushVoidSmallJsonG(self, r);
   s = toStringO(r);
   ck_assert_str_eq(s, "[null,\"<data container>\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSmallBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   r = pushSmallBoolSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSmallBytesSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBytest *value = allocSmallBytes("qwe", 3);
 
   r = pushSmallBytesSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[0x71,0x77,0x65]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSmallDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDoublet *value = allocSmallDouble(1);
 
   r = pushSmallDoubleSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSmallIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocSmallInt(1);
 
   r = pushSmallIntSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   r = pushSmallJsonSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   smallStringt *string = allocSmallString("qwe");
 
   r = pushSmallStringSmallJsonG(self, string);
   ck_assert_ptr_ne(r, null);
   finishO(string);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushSmallContainerSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   r = pushSmallContainerSmallJsonG(self, &c);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*) allocSmallInt(1);
 
   r = pushNFreeSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeUndefinedSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   undefinedt *value = allocUndefined();
 
   r = pushNFreeUndefinedSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = pushNFreeSSmallJsonG(self, strdup("qwe"));
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict  = allocSmallDict();
 
   r = pushNFreeDictSmallJsonG(self, dict);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   r = pushNFreeArraySmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array      = listCreateS("a","bb");
 
   r = pushNFreeArraycSmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"bb\"]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   r = pushNFreeSmallBoolSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallBytesSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBytest *value = allocSmallBytes("qwe", 3);
 
   r = pushNFreeSmallBytesSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[0x71,0x77,0x65]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDoublet *value = allocSmallDouble(1);
 
   r = pushNFreeSmallDoubleSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocSmallInt(1);
 
   r = pushNFreeSmallIntSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   r = pushNFreeSmallJsonSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *string = allocSmallString("qwe");
 
   r = pushNFreeSmallStringSmallJsonG(self, string);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void pushNFreeSmallContainerSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallContainer(c);
   r = pushNFreeSmallContainerSmallJsonG(self, c);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void popSmallJsonGT(void) {
 
   baset*           r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = popSmallJsonG(self, NULL);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "1");
   free(s);
   terminateO(self);
 
 }
 
 
 void popUndefinedSmallJsonGT(void) {
 
   undefinedt*      r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   r = popUndefinedSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   terminateO(self);
 
 }
 
 
 void popBoolSmallJsonGT(void) {
 
   bool             r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
   r = popBoolSmallJsonG(self, null);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void popDoubleSmallJsonGT(void) {
 
   double           r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushDouble(self, 2.0);
   ck_assert_ptr_ne(r2, null);
   r = popDoubleSmallJsonG(self, 0);
   ck_assert(r==2.0);
   terminateO(self);
 
 }
 
 
 void popIntSmallJsonGT(void) {
 
   int64_t          r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = popIntSmallJsonG(self, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void popInt32SmallJsonGT(void) {
 
   int32_t          r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = popInt32SmallJsonG(self, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void popUintSmallJsonGT(void) {
 
   uint64_t         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = popUintSmallJsonG(self, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void popUint32SmallJsonGT(void) {
 
   uint32_t         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = popUint32SmallJsonG(self, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void popSSmallJsonGT(void) {
 
   char*            r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushS(self, "2");
   ck_assert_ptr_ne(r2, null);
   r = popSSmallJsonG(self, null);
   ck_assert_str_eq(r, "2");
   free(r);
   terminateO(self);
 
 }
 
 
 void popDictSmallJsonGT(void) {
 
   smallDictt*      r;
   smallJsont *self = allocSmallJson();
 
   createSmallDict(d);
   smallJsont *r2   = self->f->pushDict(self, &d);
   ck_assert_ptr_ne(r2, null);
   r = popDictSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void popArraySmallJsonGT(void) {
 
   smallArrayt*     r;
   smallJsont *self = allocSmallJson();
 
   createSmallArray(a);
   smallJsont *r2   = self->f->pushArray(self, &a);
   ck_assert_ptr_ne(r2, null);
   r = popArraySmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void popSmallBoolSmallJsonGT(void) {
 
   smallBoolt*      r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   r = popSmallBoolSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void popSmallBytesSmallJsonGT(void) {
 
   smallBytest*      r;
   smallJsont *self = allocSmallJson();
 
   createSmallBytes(b);
   smallJsont *r2   = self->f->pushSmallBytes(self, &b);
   ck_assert_ptr_ne(r2, null);
   r = popSmallBytesSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void popSmallDoubleSmallJsonGT(void) {
 
   smallDoublet*    r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushDouble(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = popSmallDoubleSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "1.000000e+00");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void popSmallIntSmallJsonGT(void) {
 
   smallIntt*       r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = popSmallIntSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "1");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void popSmallJsonSmallJsonGT(void) {
 
   smallJsont*      r;
   smallJsont *self = allocSmallJson();
 
   createSmallJson(j);
   smallJsont *r2   = self->f->pushSmallJson(self, &j);
   ck_assert_ptr_ne(r2, null);
   r = popSmallJsonSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void popSmallStringSmallJsonGT(void) {
 
   smallStringt*    r;
   smallJsont *self = allocSmallJson();
 
   createSmallString(S);
   smallJsont *r2   = self->f->pushSmallString(self, &S);
   ck_assert_ptr_ne(r2, null);
   r = popSmallStringSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void popVoidSmallJsonGT(void) {
 
   void*            r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   setValO(&c, &r);
   smallJsont *r2   = self->f->pushSmallContainer(self, &c);
   ck_assert_ptr_ne(r2, null);
   r = popVoidSmallJsonG(self, null);
   ck_assert_ptr_eq(r, &r);
   terminateO(self);
 
 }
 
 
 void popSmallContainerSmallJsonGT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   smallJsont *r2   = self->f->pushSmallContainer(self, &c);
   ck_assert_ptr_ne(r2, null);
   r = popSmallContainerSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void setSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value     = (baset*) allocSmallInt(2);
 
   r = setSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setUndefinedSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = setUndefinedSmallJsonG(self, "1", null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":null}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = setBoolSmallJsonG(self, "1", true);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":true}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = setDoubleSmallJsonG(self, "1", 2.2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2.200000e+00}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = setIntSmallJsonG(self, "1", 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = setSSmallJsonG(self, "1", "qwe");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"qwe\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = setCharSmallJsonG(self, "1", 'x');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"x\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict = allocSmallDict();
 
   r = setDictSmallJsonG(self, "1", dict);
   ck_assert_ptr_ne(r, null);
   finishO(dict);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{}}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   r = setArraySmallJsonG(self, "1", array);
   ck_assert_ptr_ne(r, null);
   finishO(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[]}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array     = listCreateS("a", "b");
 
   r = setArraycSmallJsonG(self, "1", array);
   ck_assert_ptr_ne(r, null);
   listFreeS(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[\"a\",\"b\"]}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setCArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   const char *array[] = {"a", "b", null};
 
   r = setCArraycSmallJsonG(self, "1", array);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[\"a\",\"b\"]}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setVoidSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = setVoidSmallJsonG(self, "1", null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":null}");
   free(s);
   r = setVoidSmallJsonG(self, "1", &r);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"<data container>\"}");
   free(s);
   // null key
   r = setVoidSmallJsonG(self, null, &r);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void setSmallBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   r = setSmallBoolSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":true}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setSmallBytesSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallBytest *value = allocSmallBytes("qwe", sizeof("qwe"));
 
   r = setSmallBytesSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[0x71,0x77,0x65,0x00]}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setSmallDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   smallDoublet *value = allocSmallDouble(2.2);
 
   r = setSmallDoubleSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2.200000e+00}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setSmallIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value = allocSmallInt(2);
 
   r = setSmallIntSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   setTopIntO(value, 2);
   r = setSmallJsonSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocSmallJson();
   smallStringt *string = allocSmallString("qwe");
 
   r = setSmallStringSmallJsonG(self, "1", string);
   ck_assert_ptr_ne(r, null);
   finishO(string);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"qwe\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setSmallContainerSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self           = allocSmallJson();
   smallContainert *container = allocSmallContainer(null);
 
   r = setSmallContainerSmallJsonG(self, "1", container);
   ck_assert_ptr_ne(r, null);
   finishO(container);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value;
 
   value   = (baset*)allocUndefined();
   r = setNFreeSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":null}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreeUndefinedSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self      = allocSmallJson();
   undefinedt *undefined = allocUndefined();
 
   r = setNFreeUndefinedSmallJsonG(self, "1", undefined);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":null}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreeSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char *string     = strdup("qwe");
 
   r = setNFreeSSmallJsonG(self, "1", string);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"qwe\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreeDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict = allocSmallDict();
 
   r = setNFreeDictSmallJsonG(self, "1", dict);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{}}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreeArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   r = setNFreeArraySmallJsonG(self, "1", array);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[]}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreeArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array     = listCreateS("a", "b");
 
   r = setNFreeArraycSmallJsonG(self, "1", array);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[\"a\",\"b\"]}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   r = setNFreeSmallBoolSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":true}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallBytesSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallBytest *value = allocSmallBytes("qwe", sizeof("qwe"));
 
   r = setNFreeSmallBytesSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[0x71,0x77,0x65,0x00]}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   smallDoublet *value = allocSmallDouble(2.2);
 
   r = setNFreeSmallDoubleSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2.200000e+00}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value = allocSmallInt(2);
 
   r = setNFreeSmallIntSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   setTopIntO(value, 2);
   r = setNFreeSmallJsonSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":2}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocSmallJson();
   smallStringt *string = allocSmallString("qwe");
 
   r = setNFreeSmallStringSmallJsonG(self, "1", string);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"qwe\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreeSmallContainerSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self           = allocSmallJson();
   smallContainert *container = allocSmallContainer(null);
 
   r = setNFreeSmallContainerSmallJsonG(self, "1", container);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setPDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict;
 
   dict = allocSmallDict();
   r    = self->f->setDict(self, "1", dict);
   ck_assert_ptr_ne(r, null);
   dict->f->setInt(dict, "a", 1);
   r    = setPDictSmallJsonG(self, "1", dict);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{\"a\":1}}");
   free(s);
   finishO(dict);
   terminateO(self);
 
 }
 
 
 void setPArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *array;
 
   array   = allocSmallArray();
   r       = self->f->setArray(self, "1", array);
   ck_assert_ptr_ne(r, null);
   array->f->pushInt(array, 1);
   r       = setPArraySmallJsonG(self, "1", array);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[1]}");
   free(s);
   finishO(array);
   terminateO(self);
 
 }
 
 
 void setPSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *json;
 
   json    = allocSmallJson();
   r       = self->f->setSmallJson(self, "1", json);
   ck_assert_ptr_ne(r, null);
   json->f->setInt(json, "a", 1);
   r       = setPSmallJsonSmallJsonG(self, "1", json);
   ck_assert_ptr_ne(r, null);
   finishO(json);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{\"a\":1}}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setPSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *string;
 
   string = allocSmallString("");
   r      = self->f->setSmallString(self, "1", string);
   ck_assert_ptr_ne(r, null);
   string->f->appendS(string, "s");
   r      = setPSmallStringSmallJsonG(self, "1", string);
   ck_assert_ptr_ne(r, null);
   finishO(string);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"s\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreePDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *value;
 
   value   = allocSmallDict();
   r       = self->f->setDict(self, "1", value);
   ck_assert_ptr_ne(r, null);
   value->f->setInt(value, "a", 1);
   r       = setNFreePDictSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{\"a\":1}}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreePArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *value;
 
   value   = allocSmallArray();
   r       = self->f->setArray(self, "1", value);
   ck_assert_ptr_ne(r, null);
   value->f->pushInt(value, 2);
   r       = setNFreePArraySmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":[2]}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreePSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value;
 
   value   = allocSmallJson();
   r       = self->f->setSmallJson(self, "1", value);
   ck_assert_ptr_ne(r, null);
   value->f->setInt(value, "a", 1);
   r       = setNFreePSmallJsonSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":{\"a\":1}}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setNFreePSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *value;
 
   value = allocSmallString("");
   r       = self->f->setSmallString(self, "1", value);
   ck_assert_ptr_ne(r, null);
   value->f->appendS(value, "2");
   r       = setNFreePSmallStringSmallJsonG(self, "1", value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"2\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*) allocSmallInt(1);
 
   r       = pushSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   value   = (baset*) allocSmallInt(2);
   r       = setAtSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[2]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtUndefinedSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*) allocSmallInt(1);
 
   r       = pushSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *v = strdup("freed by setAtUndefinedSmallJsonG");
   r = setAtUndefinedSmallJsonG(self, 0, v);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = pushBoolSmallJsonG(self, true);
   ck_assert_ptr_ne(r, null);
   r = setAtBoolSmallJsonG(self, 0, false);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[false]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = pushDoubleSmallJsonG(self, 1);
   ck_assert_ptr_ne(r, null);
   r = setAtDoubleSmallJsonG(self, 0, 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[2.000000e+00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = pushIntSmallJsonG(self, 1);
   ck_assert_ptr_ne(r, null);
   r = setAtIntSmallJsonG(self, 0, 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[2]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = pushSSmallJsonG(self, "qwe");
   ck_assert_ptr_ne(r, null);
   r = setAtSSmallJsonG(self, 0, "asd");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"asd\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = pushCharSmallJsonG(self, 'Q');
   ck_assert_ptr_ne(r, null);
   r = setAtCharSmallJsonG(self, 0, 'x');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"x\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict  = allocSmallDict();
 
   r = pushDictSmallJsonG(self, dict);
   ck_assert_ptr_ne(r, null);
   resetO(dict);
   dict->f->setInt(dict, "a", 1);
   r = setAtDictSmallJsonG(self, 0, dict);
   ck_assert_ptr_ne(r, null);
   finishO(dict);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{\"a\":1}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   r = pushArraySmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   resetO(array);
   array->f->pushInt(array, 1);
   r = setAtArraySmallJsonG(self, 0, array);
   ck_assert_ptr_ne(r, null);
   finishO(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[1]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array      = listCreateS("a","bb");
 
   r     = pushArraycSmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   listFreeS(array);
   array = listCreateS("1","22");
   r     = setAtArraycSmallJsonG(self, 0, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   listFreeS(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"1\",\"22\"]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtCArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   const char *array[] = {"a", "bb", NULL};
 
   r = pushCArraycSmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   const char *array2[] = {"1", "22", NULL};
   r = setAtCArraycSmallJsonG(self, 0, array2);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"1\",\"22\"]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtVoidSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // NULL value
   r = pushVoidSmallJsonG(self, NULL);
   ck_assert_ptr_ne(r, null);
   r = setAtVoidSmallJsonG(self, 0, null);
   ck_assert_ptr_ne(r, null);
   r = setAtVoidSmallJsonG(self, 0, r);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtSmallBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   r = pushBoolSmallJsonG(self, false);
   ck_assert_ptr_ne(r, null);
   r = setAtSmallBoolSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtSmallBytesSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBytest *value = allocSmallBytes("qwe", 3);
 
   r = pushSmallBytesSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   value = allocSmallBytes("asd", 3);
   r = setAtSmallBytesSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[0x61,0x73,0x64]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtSmallDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDoublet *value = allocSmallDouble(1);
 
   r = pushDoubleSmallJsonG(self, 2);
   ck_assert_ptr_ne(r, null);
   r = setAtSmallDoubleSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
 
   terminateO(self);
 
 }
 
 
 void setAtSmallIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocSmallInt(1);
 
   r = pushIntSmallJsonG(self, 2);
   ck_assert_ptr_ne(r, null);
   r = setAtSmallIntSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   r = pushSmallJsonSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   value = allocSmallJson();
   value->f->setInt(value, "a", 1);
   r = setAtSmallJsonSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{\"a\":1}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *string = allocSmallString("qwe");
 
   r = pushSSmallJsonG(self, "asd");
   ck_assert_ptr_ne(r, null);
   r = setAtSmallStringSmallJsonG(self, 0, string);
   ck_assert_ptr_ne(r, null);
   finishO(string);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtSmallContainerSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   r = pushSmallContainerSmallJsonG(self, &c);
   ck_assert_ptr_ne(r, null);
   createSmallContainer(c2);
   r = setAtSmallContainerSmallJsonG(self, 0, &c2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*) allocSmallInt(1);
 
   r       = pushSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   value   = (baset*) allocSmallInt(2);
   r       = setAtNFreeSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[2]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtNFreeUndefinedSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*) allocSmallInt(1);
 
   r       = pushSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   r = setAtNFreeUndefinedSmallJsonG(self, 0, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = pushSSmallJsonG(self, "qwe");
   ck_assert_ptr_ne(r, null);
   r = setAtNFreeSSmallJsonG(self, 0, strdup("asd"));
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"asd\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtNFreeDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict  = allocSmallDict();
 
   r = pushDictSmallJsonG(self, dict);
   ck_assert_ptr_ne(r, null);
   resetO(dict);
   dict->f->setInt(dict, "a", 1);
   r = setAtNFreeDictSmallJsonG(self, 0, dict);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{\"a\":1}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtNFreeArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   r = pushArraySmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   resetO(array);
   array->f->pushInt(array, 1);
   r = setAtNFreeArraySmallJsonG(self, 0, array);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[1]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtNFreeArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array      = listCreateS("a","bb");
 
   r     = pushArraycSmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   listFreeS(array);
   array = listCreateS("1","22");
   r     = setAtNFreeArraycSmallJsonG(self, 0, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"1\",\"22\"]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   r = pushBoolSmallJsonG(self, false);
   ck_assert_ptr_ne(r, null);
   r = setAtNFreeSmallBoolSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallBytesSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBytest *value = allocSmallBytes("qwe", 3);
 
   r = pushSmallBytesSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   value = allocSmallBytes("asd", 3);
   r = setAtNFreeSmallBytesSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[0x61,0x73,0x64]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDoublet *value = allocSmallDouble(1);
 
   r = pushDoubleSmallJsonG(self, 2);
   ck_assert_ptr_ne(r, null);
   r = setAtNFreeSmallDoubleSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocSmallInt(1);
 
   r = pushIntSmallJsonG(self, 2);
   ck_assert_ptr_ne(r, null);
   r = setAtNFreeSmallIntSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   r = pushSmallJsonSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   value = allocSmallJson();
   value->f->setInt(value, "a", 1);
   r = setAtNFreeSmallJsonSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{\"a\":1}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *string = allocSmallString("qwe");
 
   r = pushSSmallJsonG(self, "asd");
   ck_assert_ptr_ne(r, null);
   r = setAtNFreeSmallStringSmallJsonG(self, 0, string);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setAtNFreeSmallContainerSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   r = pushSmallContainerSmallJsonG(self, &c);
   ck_assert_ptr_ne(r, null);
   createAllocateSmallContainer(c2);
   r = setAtNFreeSmallContainerSmallJsonG(self, 0, c2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setPAtDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict  = allocSmallDict();
 
   r = pushDictSmallJsonG(self, dict);
   ck_assert_ptr_ne(r, null);
   finishO(dict);
   dict = getAtDictSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(dict, null);
   dict->f->setInt(dict, "a", 1);
   r = setPAtDictSmallJsonG(self, 0, dict);
   ck_assert_ptr_ne(r, null);
   finishO(dict);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{\"a\":1}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setPAtArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   r = pushArraySmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   finishO(array);
   array = getAtArraySmallJsonG(self, null, 0);
   ck_assert_ptr_ne(array, null);
   array->f->pushInt(array, 1);
   r = setPAtArraySmallJsonG(self, 0, array);
   ck_assert_ptr_ne(r, null);
   finishO(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[1]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setPAtSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   r = pushSmallJsonSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   value = getAtSmallJsonSmallJsonG(self, null, 0);
   value->f->setInt(value, "a", 1);
   r = setPAtSmallJsonSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{\"a\":1}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setPAtSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *string;
 
   r = pushSSmallJsonG(self, "asd");
   ck_assert_ptr_ne(r, null);
   string = getAtSmallStringSmallJsonG(self, null, 0);
   setValO(string, "qwe");
   r = setPAtSmallStringSmallJsonG(self, 0, string);
   ck_assert_ptr_ne(r, null);
   finishO(string);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setPAtNFreeDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict  = allocSmallDict();
 
   r = pushDictSmallJsonG(self, dict);
   ck_assert_ptr_ne(r, null);
   finishO(dict);
   dict = getAtDictSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(dict, null);
   dict->f->setInt(dict, "a", 1);
   r = setPAtNFreeDictSmallJsonG(self, 0, dict);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{\"a\":1}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setPAtNFreeArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   r = pushArraySmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   finishO(array);
   array = getAtArraySmallJsonG(self, null, 0);
   ck_assert_ptr_ne(array, null);
   array->f->pushInt(array, 1);
   r = setPAtNFreeArraySmallJsonG(self, 0, array);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[1]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setPAtNFreeSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   r = pushSmallJsonSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   value = getAtSmallJsonSmallJsonG(self, null, 0);
   value->f->setInt(value, "a", 1);
   r = setPAtNFreeSmallJsonSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{\"a\":1}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void setPAtNFreeSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *string;
 
   r = pushSSmallJsonG(self, "asd");
   ck_assert_ptr_ne(r, null);
   string = getAtSmallStringSmallJsonG(self, null, 0);
   setValO(string, "qwe");
   r = setPAtNFreeSmallStringSmallJsonG(self, 0, string);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void getSmallJsonGT(void) {
 
   baset*      r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "1", 2);
   r = getSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void getUndefinedSmallJsonGT(void) {
 
   undefinedt*      r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setUndefined(self, "1");
   ck_assert_ptr_ne(r2, null);
   r = getUndefinedSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   finishO(r);
   terminateO(self);
 
 }
 
 
 void getBoolSmallJsonGT(void) {
 
   bool             r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = getBoolSmallJsonG(self, false, "1");
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void getBoolPSmallJsonGT(void) {
 
   bool*            r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = getBoolPSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert(*r);
   terminateO(self);
 
 }
 
 
 void getDoubleSmallJsonGT(void) {
 
   double           r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setDouble(self, "1", 2.2);
   ck_assert_ptr_ne(r2, null);
   r = getDoubleSmallJsonG(self, 0, "1");
   ck_assert(r == 2.2);
   terminateO(self);
 
 }
 
 
 void getDoublePSmallJsonGT(void) {
 
   double*          r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setDouble(self, "1", 2.2);
   ck_assert_ptr_ne(r2, null);
   r = getDoublePSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert(*r == 2.2);
   terminateO(self);
 
 }
 
 
 void getIntSmallJsonGT(void) {
 
   int64_t          r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = getIntSmallJsonG(self, 0, "1");
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getIntPSmallJsonGT(void) {
 
   int64_t*         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = getIntPSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 2);
   terminateO(self);
 
 }
 
 
 void getInt32SmallJsonGT(void) {
 
   int32_t          r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = getInt32SmallJsonG(self, 0, "1");
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getInt32PSmallJsonGT(void) {
 
   int32_t*         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = getInt32PSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 2);
   terminateO(self);
 
 }
 
 
 void getUintSmallJsonGT(void) {
 
   uint64_t         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = getUintSmallJsonG(self, 0, "1");
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getUintPSmallJsonGT(void) {
 
   uint64_t*        r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = getUintPSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 2);
   terminateO(self);
 
 }
 
 
 void getUint32SmallJsonGT(void) {
 
   uint32_t         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = getUint32SmallJsonG(self, 0, "1");
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getUint32PSmallJsonGT(void) {
 
   uint32_t*        r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = getUint32PSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 2);
   terminateO(self);
 
 }
 
 
 void getSSmallJsonGT(void) {
 
   char*            r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setS(self, "1", "qwe");
   ck_assert_ptr_ne(r2, null);
   r = getSSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "qwe");
   terminateO(self);
 
 }
 
 
 void getDictSmallJsonGT(void) {
 
   smallJsont* r2;
   smallDictt*      r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict = allocSmallDict();
 
   r2 = self->f->setNFreeDict(self, "1", dict);
   ck_assert_ptr_ne(r2, null);
   r = getDictSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(self);
 
 }
 
 
 void getArraySmallJsonGT(void) {
 
   smallArrayt *r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   smallJsont *r2 = self->f->setNFreeArray(self, "1", array);
   ck_assert_ptr_ne(r2, null);
   r = getArraySmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void getSmallBoolSmallJsonGT(void) {
 
   smallBoolt*      r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = getSmallBoolSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(self);
 
 }
 
 
 void getSmallBytesSmallJsonGT(void) {
 
   smallBytest*     r;
   smallJsont *self   = allocSmallJson();
   smallBytest *value = allocSmallBytes("qwe", sizeof("qwe"));
 
   smallJsont *r2 = self->f->setNFreeSmallBytes(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   r = getSmallBytesSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "[0x71,0x77,0x65,0x00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void getSmallDoubleSmallJsonGT(void) {
 
   smallDoublet*    r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setDouble(self, "1", 2.2);
   ck_assert_ptr_ne(r2, null);
   r = getSmallDoubleSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "2.200000e+00");
   free(s);
   terminateO(self);
 
 }
 
 
 void getSmallIntSmallJsonGT(void) {
 
   smallIntt*       r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = getSmallIntSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void getSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   setTopIntO(value, 2);
   smallJsont *r2 = self->f->setNFreeSmallJson(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   r = getSmallJsonSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void getSmallStringSmallJsonGT(void) {
 
   smallStringt*    r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setS(self, "1", "qwe");
   ck_assert_ptr_ne(r2, null);
   r = getSmallStringSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   terminateO(self);
 
 }
 
 
 void getVoidSmallJsonGT(void) {
 
   void*            r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   setValO(&c, &r);
   smallJsont *r2 = self->f->setSmallContainer(self, "1", &c);
   ck_assert_ptr_ne(r2, null);
   r = getVoidSmallJsonG(self, null, "1");
   ck_assert_ptr_eq(r, &r);
   terminateO(self);
 
 }
 
 
 void getSmallContainerSmallJsonGT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   setValO(&c, &r);
   smallJsont *r2 = self->f->setSmallContainer(self, "1", &c);
   ck_assert_ptr_ne(r2, null);
   r = getSmallContainerSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   terminateO(self);
 
 }
 
 
 void getNDupSmallJsonGT(void) {
 
   baset*           r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "1", 2);
   r = getNDupSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void getNDupUndefinedSmallJsonGT(void) {
 
   undefinedt*      r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setUndefined(self, "1");
   ck_assert_ptr_ne(r2, null);
   r = getNDupUndefinedSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void getNDupBoolSmallJsonGT(void) {
 
   bool             r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = getNDupBoolSmallJsonG(self, false, "1");
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void getNDupDoubleSmallJsonGT(void) {
 
   double           r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setDouble(self, "1", 2.2);
   ck_assert_ptr_ne(r2, null);
   r = getNDupDoubleSmallJsonG(self, 0, "1");
   ck_assert(r == 2.2);
   terminateO(self);
 
 }
 
 
 void getNDupIntSmallJsonGT(void) {
 
   int64_t          r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = getNDupIntSmallJsonG(self, 0, "1");
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getNDupInt32SmallJsonGT(void) {
 
   int32_t          r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = getNDupInt32SmallJsonG(self, 0, "1");
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getNDupUintSmallJsonGT(void) {
 
   uint64_t         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = getNDupUintSmallJsonG(self, 0, "1");
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getNDupUint32SmallJsonGT(void) {
 
   uint32_t         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = getNDupUint32SmallJsonG(self, 0, "1");
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getNDupSSmallJsonGT(void) {
 
   char*            r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setS(self, "1", "qwe");
   ck_assert_ptr_ne(r2, null);
   r = getNDupSSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(r, "qwe");
   free(r);
   terminateO(self);
 
 }
 
 
 void getNDupDictSmallJsonGT(void) {
 
   smallJsont* r2;
   smallDictt*      r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict = allocSmallDict();
 
   r2 = self->f->setNFreeDict(self, "1", dict);
   ck_assert_ptr_ne(r2, null);
   r = getNDupDictSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(self);
 
 }
 
 
 void getNDupArraySmallJsonGT(void) {
 
   smallArrayt*     r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   smallJsont *r2 = self->f->setNFreeArray(self, "1", array);
   ck_assert_ptr_ne(r2, null);
   r = getNDupArraySmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void getNDupSmallBoolSmallJsonGT(void) {
 
   smallBoolt*      r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = getNDupSmallBoolSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(self);
 
 }
 
 
 void getNDupSmallBytesSmallJsonGT(void) {
 
   smallBytest*     r;
   smallJsont *self   = allocSmallJson();
   smallBytest *value = allocSmallBytes("qwe", sizeof("qwe"));
 
   smallJsont *r2 = self->f->setNFreeSmallBytes(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   r = getNDupSmallBytesSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[0x71,0x77,0x65,0x00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void getNDupSmallDoubleSmallJsonGT(void) {
 
   smallDoublet*    r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setDouble(self, "1", 2.2);
   ck_assert_ptr_ne(r2, null);
   r = getNDupSmallDoubleSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "2.200000e+00");
   free(s);
   terminateO(self);
 
 }
 
 
 void getNDupSmallIntSmallJsonGT(void) {
 
   smallIntt*       r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = getNDupSmallIntSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void getNDupSmallJsonSmallJsonGT(void) {
 
   smallJsont*      r;
   smallJsont *self  = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   setTopIntO(value, 2);
   smallJsont *r2 = self->f->setNFreeSmallJson(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   r = getNDupSmallJsonSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   terminateO(self);
 
 }
 
 
 void getNDupSmallStringSmallJsonGT(void) {
 
   smallStringt*    r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setS(self, "1", "qwe");
   ck_assert_ptr_ne(r2, null);
   r = getNDupSmallStringSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   terminateO(self);
 
 }
 
 
 void getNDupVoidSmallJsonGT(void) {
 
   void*            r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   setValO(&c, &r);
   smallJsont *r2 = self->f->setSmallContainer(self, "1", &c);
   ck_assert_ptr_ne(r2, null);
   r = getNDupVoidSmallJsonG(self, null, "1");
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void getNDupSmallContainerSmallJsonGT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   setValO(&c, &r);
   smallJsont *r2 = self->f->setSmallContainer(self, "1", &c);
   ck_assert_ptr_ne(r2, null);
   r = getNDupSmallContainerSmallJsonG(self, null, "1");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   terminateO(self);
 
 }
 
 
 void getAtSmallJsonGT(void) {
 
   baset*           r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = getAtSmallJsonG(self, NULL, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "1");
   free(s);
   terminateO(self);
 
 }
 
 
 void getAtUndefinedSmallJsonGT(void) {
 
   undefinedt*      r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   r = getAtUndefinedSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   finishO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   terminateO(self);
 
 }
 
 
 void getAtBoolSmallJsonGT(void) {
 
   bool             r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
   r = getAtBoolSmallJsonG(self, null, 0);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void getAtBoolPSmallJsonGT(void) {
 
   bool*            r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
   r = getAtBoolPSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r);
   terminateO(self);
 
 }
 
 
 void getAtDoubleSmallJsonGT(void) {
 
   double           r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushDouble(self, 2.0);
   ck_assert_ptr_ne(r2, null);
   r = getAtDoubleSmallJsonG(self, 0, 0);
   ck_assert(r==2.0);
   terminateO(self);
 
 }
 
 
 void getAtDoublePSmallJsonGT(void) {
 
   double*          r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushDouble(self, 2.0);
   ck_assert_ptr_ne(r2, null);
   r = getAtDoublePSmallJsonG(self, 0, 0);
   ck_assert_ptr_ne(r, null);
   ck_assert(*r==2.0);
   terminateO(self);
 
 }
 
 
 void getAtIntSmallJsonGT(void) {
 
   int64_t          r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = getAtIntSmallJsonG(self, 0, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getAtIntPSmallJsonGT(void) {
 
   int64_t*         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = getAtIntPSmallJsonG(self, 0, 0);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 2);
   terminateO(self);
 
 }
 
 
 void getAtInt32SmallJsonGT(void) {
 
   int32_t          r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = getAtInt32SmallJsonG(self, 0, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getAtInt32PSmallJsonGT(void) {
 
   int32_t*         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = getAtInt32PSmallJsonG(self, 0, 0);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 2);
   terminateO(self);
 
 }
 
 
 void getAtUintSmallJsonGT(void) {
 
   uint64_t         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = getAtUintSmallJsonG(self, 0, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getAtUintPSmallJsonGT(void) {
 
   uint64_t*        r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = getAtUintPSmallJsonG(self, 0, 0);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 2);
   terminateO(self);
 
 }
 
 
 void getAtUint32SmallJsonGT(void) {
 
   uint32_t         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = getAtUint32SmallJsonG(self, 0, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getAtUint32PSmallJsonGT(void) {
 
   uint32_t*        r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = getAtUint32PSmallJsonG(self, 0, 0);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(*r, 2);
   terminateO(self);
 
 }
 
 
 void getAtSSmallJsonGT(void) {
 
   char*            r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushS(self, "2");
   ck_assert_ptr_ne(r2, null);
   r = getAtSSmallJsonG(self, null, 0);
   ck_assert_str_eq(r, "2");
   terminateO(self);
 
 }
 
 
 void getAtDictSmallJsonGT(void) {
 
   smallDictt*      r;
   smallJsont *self = allocSmallJson();
 
   createSmallDict(d);
   smallJsont *r2   = self->f->pushDict(self, &d);
   ck_assert_ptr_ne(r2, null);
   r = getAtDictSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   finishO(r);
   terminateO(self);
 
 }
 
 
 void getAtArraySmallJsonGT(void) {
 
   smallArrayt*     r;
   smallJsont *self = allocSmallJson();
 
   createSmallArray(a);
   smallJsont *r2   = self->f->pushArray(self, &a);
   ck_assert_ptr_ne(r2, null);
   r = getAtArraySmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   finishO(r);
   terminateO(self);
 
 }
 
 
 void getAtSmallBoolSmallJsonGT(void) {
 
   smallBoolt*      r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   r = getAtSmallBoolSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   finishO(r);
   terminateO(self);
 
 }
 
 
 void getAtSmallBytesSmallJsonGT(void) {
 
   smallBytest*      r;
   smallJsont *self = allocSmallJson();
 
   createSmallBytes(b);
   smallJsont *r2   = self->f->pushSmallBytes(self, &b);
   ck_assert_ptr_ne(r2, null);
   r = getAtSmallBytesSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   finishO(r);
   terminateO(self);
 
 }
 
 
 void getAtSmallDoubleSmallJsonGT(void) {
 
   smallDoublet*    r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushDouble(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = getAtSmallDoubleSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "1.000000e+00");
   free(s);
   finishO(r);
   terminateO(self);
 
 }
 
 
 void getAtSmallIntSmallJsonGT(void) {
 
   smallIntt*       r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = getAtSmallIntSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "1");
   free(s);
   finishO(r);
   terminateO(self);
 
 }
 
 
 void getAtSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   createSmallJson(j);
   smallJsont *r2   = self->f->pushSmallJson(self, &j);
   ck_assert_ptr_ne(r2, null);
   r = getAtSmallJsonSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   finishO(r);
   terminateO(self);
 
 }
 
 
 void getAtSmallStringSmallJsonGT(void) {
 
   smallStringt*    r;
   smallJsont *self = allocSmallJson();
 
   createSmallString(S);
   smallJsont *r2   = self->f->pushSmallString(self, &S);
   ck_assert_ptr_ne(r2, null);
   r = getAtSmallStringSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   finishO(r);
   terminateO(self);
 
 }
 
 
 void getAtVoidSmallJsonGT(void) {
 
   void*            r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   setValO(&c, &r);
   smallJsont *r2   = self->f->pushSmallContainer(self, &c);
   ck_assert_ptr_ne(r2, null);
   r = getAtVoidSmallJsonG(self, null, 0);
   ck_assert_ptr_eq(r, &r);
   terminateO(self);
 
 }
 
 
 void getAtSmallContainerSmallJsonGT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   smallJsont *r2   = self->f->pushSmallContainer(self, &c);
   ck_assert_ptr_ne(r2, null);
   r = getAtSmallContainerSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   finishO(r);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallJsonGT(void) {
 
   baset*           r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupSmallJsonG(self, NULL, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "1");
   free(s);
   terminateO(self);
 
 }
 
 
 void getAtNDupUndefinedSmallJsonGT(void) {
 
   undefinedt*      r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupUndefinedSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   terminateO(self);
 
 }
 
 
 void getAtNDupBoolSmallJsonGT(void) {
 
   bool             r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupBoolSmallJsonG(self, null, 0);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void getAtNDupDoubleSmallJsonGT(void) {
 
   double           r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushDouble(self, 2.0);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupDoubleSmallJsonG(self, 0, 0);
   ck_assert(r==2.0);
   terminateO(self);
 
 }
 
 
 void getAtNDupIntSmallJsonGT(void) {
 
   int64_t          r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupIntSmallJsonG(self, 0, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getAtNDupInt32SmallJsonGT(void) {
 
   int32_t          r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupInt32SmallJsonG(self, 0, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getAtNDupUintSmallJsonGT(void) {
 
   uint64_t         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupUintSmallJsonG(self, 0, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getAtNDupUint32SmallJsonGT(void) {
 
   uint32_t         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupUint32SmallJsonG(self, 0, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void getAtNDupSSmallJsonGT(void) {
 
   char*            r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushS(self, "2");
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupSSmallJsonG(self, null, 0);
   ck_assert_str_eq(r, "2");
   free(r);
   terminateO(self);
 
 }
 
 
 void getAtNDupDictSmallJsonGT(void) {
 
   smallDictt*      r;
   smallJsont *self = allocSmallJson();
 
   createSmallDict(d);
   smallJsont *r2   = self->f->pushDict(self, &d);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupDictSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void getAtNDupArraySmallJsonGT(void) {
 
   smallArrayt*     r;
   smallJsont *self = allocSmallJson();
 
   createSmallArray(a);
   smallJsont *r2   = self->f->pushArray(self, &a);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupArraySmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallBoolSmallJsonGT(void) {
 
   smallBoolt*      r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupSmallBoolSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallBytesSmallJsonGT(void) {
 
   smallBytest*      r;
   smallJsont *self = allocSmallJson();
 
   createSmallBytes(b);
   smallJsont *r2   = self->f->pushSmallBytes(self, &b);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupSmallBytesSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallDoubleSmallJsonGT(void) {
 
   smallDoublet*    r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushDouble(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupSmallDoubleSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "1.000000e+00");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallIntSmallJsonGT(void) {
 
   smallIntt*       r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupSmallIntSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "1");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallJsonSmallJsonGT(void) {
 
   smallJsont*      r;
   smallJsont *self = allocSmallJson();
 
   createSmallJson(j);
   smallJsont *r2   = self->f->pushSmallJson(self, &j);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupSmallJsonSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallStringSmallJsonGT(void) {
 
   smallStringt*    r;
   smallJsont *self = allocSmallJson();
 
   createSmallString(S);
   smallJsont *r2   = self->f->pushSmallString(self, &S);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupSmallStringSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void getAtNDupVoidSmallJsonGT(void) {
 
   void*            r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   setValO(&c, &r);
   smallJsont *r2   = self->f->pushSmallContainer(self, &c);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupVoidSmallJsonG(self, null, 0);
   ck_assert_ptr_eq(r, NULL);
   terminateO(self);
 
 }
 
 
 void getAtNDupSmallContainerSmallJsonGT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   smallJsont *r2   = self->f->pushSmallContainer(self, &c);
   ck_assert_ptr_ne(r2, null);
   r = getAtNDupSmallContainerSmallJsonG(self, null, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void getNumSmallJsonGT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setS(self, "3", "2");
   ck_assert_ptr_ne(r2, null);
   r = getNumSmallJsonG(self, "1");
   ck_assert(r == 1);
   r = getNumSmallJsonG(self, "2");
   ck_assert(r == 2.2);
   terminateO(self);
 
 }
 
 
 void getNumAtSmallJsonGT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->pushDouble(self, 1);
   ck_assert_ptr_ne(r2, NULL);
   r  = getNumAtSmallJsonG(self, 0);
   ck_assert(r==1);
   terminateO(self);
 
 }
 
 
 void delKeySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r, null);
   r = delKeySmallJsonG(self, "2", 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":1}");
   free(s);
   terminateO(self);
 
 }
 
 
 void delSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
   r = delSmallJsonG(self, 1, -1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,4]");
   free(s);
   terminateO(self);
 
 }
 
 
 void delElemSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r, null);
   r = delElemSmallJsonG(self, "2");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":1}");
   free(s);
   terminateO(self);
 
 }
 
 
 void delElemIndexSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
   r = delElemIndexSmallJsonG(self, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[2,3,4]");
   free(s);
   r = delElemIndexSmallJsonG(self, -1);
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "[2,3]");
   free(s);
   r = delElemIndexSmallJsonG(self, 5);
   ck_assert_ptr_eq(r, null);
   r = delElemIndexSmallJsonG(self, -5);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void prependSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*) allocSmallInt(1);
 
   r = prependSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependUndefinedSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = prependUndefinedSmallJsonG(self, NULL);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = prependBoolSmallJsonG(self, true);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = prependDoubleSmallJsonG(self, 1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = prependIntSmallJsonG(self, 1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = prependSSmallJsonG(self, "qwe");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = prependCharSmallJsonG(self, 'Q');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"Q\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict  = allocSmallDict();
 
   r = prependDictSmallJsonG(self, dict);
   ck_assert_ptr_ne(r, null);
   finishO(dict);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   r = prependArraySmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   finishO(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array      = listCreateS("a","bb");
 
   r = prependArraycSmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   listFreeS(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"bb\"]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependCArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   const char *array[] = {"a", "bb", NULL};
 
   r = prependCArraycSmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"bb\"]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependVoidSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // NULL value
   r = prependVoidSmallJsonG(self, NULL);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   // value
   r = prependVoidSmallJsonG(self, r);
   s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\",null]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependSmallBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   r = prependSmallBoolSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependSmallBytesSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBytest *value = allocSmallBytes("qwe", 3);
 
   r = prependSmallBytesSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[0x71,0x77,0x65]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependSmallDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDoublet *value = allocSmallDouble(1);
 
   r = prependSmallDoubleSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependSmallIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocSmallInt(1);
 
   r = prependSmallIntSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   r = prependSmallJsonSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   smallStringt *string = allocSmallString("qwe");
 
   r = prependSmallStringSmallJsonG(self, string);
   ck_assert_ptr_ne(r, null);
   finishO(string);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependSmallContainerSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   r = prependSmallContainerSmallJsonG(self, &c);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value = (baset*) allocSmallInt(1);
 
   r = prependNFreeSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeUndefinedSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   undefinedt *value = allocUndefined();
 
   r = prependNFreeUndefinedSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = prependNFreeSSmallJsonG(self, strdup("qwe"));
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict  = allocSmallDict();
 
   r = prependNFreeDictSmallJsonG(self, dict);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   r = prependNFreeArraySmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array      = listCreateS("a","bb");
 
   r = prependNFreeArraycSmallJsonG(self, array);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 1);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"bb\"]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   r = prependNFreeSmallBoolSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallBytesSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBytest *value = allocSmallBytes("qwe", 3);
 
   r = prependNFreeSmallBytesSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[[0x71,0x77,0x65]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDoublet *value = allocSmallDouble(1);
 
   r = prependNFreeSmallDoubleSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocSmallInt(1);
 
   r = prependNFreeSmallIntSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   r = prependNFreeSmallJsonSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallStringt *string = allocSmallString("qwe");
 
   r = prependNFreeSmallStringSmallJsonG(self, string);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void prependNFreeSmallContainerSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallContainer(c);
   r = prependNFreeSmallContainerSmallJsonG(self, c);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void dequeueSmallJsonGT(void) {
 
   baset*           r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = dequeueSmallJsonG(self, NULL);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "1");
   free(s);
   terminateO(self);
 
 }
 
 
 void dequeueUndefinedSmallJsonGT(void) {
 
   undefinedt*      r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   r = dequeueUndefinedSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   terminateO(self);
 
 }
 
 
 void dequeueBoolSmallJsonGT(void) {
 
   bool             r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushBool(self, TRUE);
   ck_assert_ptr_ne(r2, null);
   r = dequeueBoolSmallJsonG(self, null);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void dequeueDoubleSmallJsonGT(void) {
 
   double           r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushDouble(self, 2.0);
   ck_assert_ptr_ne(r2, null);
   r = dequeueDoubleSmallJsonG(self, 0);
   ck_assert(r==2.0);
   terminateO(self);
 
 }
 
 
 void dequeueIntSmallJsonGT(void) {
 
   int64_t          r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = dequeueIntSmallJsonG(self, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void dequeueInt32SmallJsonGT(void) {
 
   int32_t          r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = dequeueInt32SmallJsonG(self, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void dequeueUintSmallJsonGT(void) {
 
   uint64_t         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = dequeueUintSmallJsonG(self, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void dequeueUint32SmallJsonGT(void) {
 
   uint32_t         r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = dequeueUint32SmallJsonG(self, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void dequeueSSmallJsonGT(void) {
 
   char*            r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushS(self, "2");
   ck_assert_ptr_ne(r2, null);
   r = dequeueSSmallJsonG(self, null);
   ck_assert_str_eq(r, "2");
   free(r);
   terminateO(self);
 
 }
 
 
 void dequeueDictSmallJsonGT(void) {
 
   smallDictt*      r;
   smallJsont *self = allocSmallJson();
 
   createSmallDict(d);
   smallJsont *r2   = self->f->pushDict(self, &d);
   ck_assert_ptr_ne(r2, null);
   r = dequeueDictSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void dequeueArraySmallJsonGT(void) {
 
   smallArrayt*     r;
   smallJsont *self = allocSmallJson();
 
   createSmallArray(a);
   smallJsont *r2   = self->f->pushArray(self, &a);
   ck_assert_ptr_ne(r2, null);
   r = dequeueArraySmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void dequeueSmallBoolSmallJsonGT(void) {
 
   smallBoolt*      r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   r = dequeueSmallBoolSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void dequeueSmallBytesSmallJsonGT(void) {
 
   smallBytest*      r;
   smallJsont *self = allocSmallJson();
 
   createSmallBytes(b);
   smallJsont *r2   = self->f->pushSmallBytes(self, &b);
   ck_assert_ptr_ne(r2, null);
   r = dequeueSmallBytesSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void dequeueSmallDoubleSmallJsonGT(void) {
 
   smallDoublet*    r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushDouble(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = dequeueSmallDoubleSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "1.000000e+00");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void dequeueSmallIntSmallJsonGT(void) {
 
   smallIntt*       r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2   = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = dequeueSmallIntSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "1");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void dequeueSmallJsonSmallJsonGT(void) {
 
   smallJsont*      r;
   smallJsont *self = allocSmallJson();
 
   createSmallJson(j);
   smallJsont *r2   = self->f->pushSmallJson(self, &j);
   ck_assert_ptr_ne(r2, null);
   r = dequeueSmallJsonSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void dequeueSmallStringSmallJsonGT(void) {
 
   smallStringt*    r;
   smallJsont *self = allocSmallJson();
 
   createSmallString(S);
   smallJsont *r2   = self->f->pushSmallString(self, &S);
   ck_assert_ptr_ne(r2, null);
   r = dequeueSmallStringSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void dequeueVoidSmallJsonGT(void) {
 
   void*            r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   setValO(&c, &r);
   smallJsont *r2   = self->f->pushSmallContainer(self, &c);
   ck_assert_ptr_ne(r2, null);
   r = dequeueVoidSmallJsonG(self, null);
   ck_assert_ptr_eq(r, &r);
   terminateO(self);
 
 }
 
 
 void dequeueSmallContainerSmallJsonGT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(c);
   smallJsont *r2   = self->f->pushSmallContainer(self, &c);
   ck_assert_ptr_ne(r2, null);
   r = dequeueSmallContainerSmallJsonG(self, null);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void reverseSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushInt(self, 1);
   self->f->pushInt(self, 2);
   r = reverseSmallJsonG(self);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[2,1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void mergeDictSmallJsonGT(void) {
 
   smallJsont*  r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallDictt *value = allocSmallDict();
 
   self->f->setS(self, "1", "2");
   self->f->setS(self, "3", "4");
   value->f->setS(value, "3", "#");
   value->f->setInt(value, "4", 0);
   r = mergeDictSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"2\",\"3\":\"#\",\"4\":0}");
   free(s);
   smashO(value);
   terminateO(self);
 
 }
 
 
 void mergeDictNSmashSmallJsonGT(void) {
 
   smallJsont*  r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallDictt *value = allocSmallDict();
 
   self->f->setS(self, "1", "2");
   self->f->setS(self, "3", "4");
   value->f->setS(value, "3", "#");
   value->f->setInt(value, "4", 0);
   r = mergeDictNSmashSmallJsonG(self, value);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"1\":\"2\",\"3\":\"#\",\"4\":0}");
   free(s);
   terminateO(self);
 
 }
 
 
 void mergeSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *json  = allocSmallJson();
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   json->f->pushInt(json, 1);
   json->f->pushInt(json, 2);
   r = mergeSmallJsonG(self, json);
   ck_assert_ptr_ne(r, NULL);
   smashO(json);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,1,2]");
   free(s);
   terminateO(self);
 
 }
 
 
 void mergeNSmashSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *json  = allocSmallJson();
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   json->f->pushInt(json, 1);
   json->f->pushInt(json, 2);
   r = mergeNSmashSmallJsonG(self, json);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,1,2]");
   free(s);
   terminateO(self);
 
 }
 
 
 void appendSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   array->f->pushInt(array, 1);
   array->f->pushInt(array, 2);
   r = appendSmallJsonG(self, array);
   ck_assert_ptr_ne(r, NULL);
   smashO(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,1,2]");
   free(s);
   terminateO(self);
 
 }
 
 
 void appendNSmashSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   array->f->pushInt(array, 1);
   array->f->pushInt(array, 2);
   r = appendNSmashSmallJsonG(self, array);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,1,2]");
   free(s);
   terminateO(self);
 
 }
 
 
 void appendArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array      = listCreateS("1", "2");
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = appendArraySmallJsonG(self, array);
   ck_assert_ptr_ne(r, NULL);
   listFreeS(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"1\",\"2\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void appendNSmashArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array      = listCreateS("1", "2");
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = appendNSmashArraySmallJsonG(self, array);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"1\",\"2\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void appendCArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   const char *array[] = {"1", "2", null};
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = appendCArraySmallJsonG(self, array);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,\"1\",\"2\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void shiftSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   array->f->pushInt(array, 1);
   array->f->pushInt(array, 2);
   r = shiftSmallJsonG(self, array);
   ck_assert_ptr_ne(r, NULL);
   smashO(array);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,2,1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void shiftNSmashSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   array->f->pushInt(array, 1);
   array->f->pushInt(array, 2);
   r = shiftNSmashSmallJsonG(self, array);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,2,1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void shiftSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *json  = allocSmallJson();
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   json->f->pushInt(json, 1);
   json->f->pushInt(json, 2);
   r = shiftSmallJsonSmallJsonG(self, json);
   ck_assert_ptr_ne(r, NULL);
   smashO(json);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,2,1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void shiftNSmashSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *json  = allocSmallJson();
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   json->f->pushInt(json, 1);
   json->f->pushInt(json, 2);
   r = shiftNSmashSmallJsonSmallJsonG(self, json);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[1,2,1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void addSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   createAllocateSmallArray(a);
 
   // add an element to check that the second array is added
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // add array
   a->f->pushInt(a, 2);
   r = addSmallJsonG(self, a);
   smashO(a);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   terminateO(self);
 
 }
 
 
 void addJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   smallJsont *a    = allocSmallJson();
 
   // add an element to check that the second array is added
   // at the end
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
 
   // add array
   a->f->pushInt(a, 2);
   r = addJsonSmallJsonG(self, a);
   smashO(a);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[1,2]");
   free(s);
   terminateO(self);
 
 }
 
 
 void sliceSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
   r = sliceSmallJsonG(self, 1, -1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[2,3]");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
   r = cropSmallJsonG(self, 1, -1);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[2,3]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,4]");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropSSmallJsonGT(void) {
 
   char* s;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "sheepy");
   s = cropSSmallJsonG(self, 0,2);
   ck_assert_str_eq(s, "sh");
   ck_assert_str_eq(sjGet(self), "eepy");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropSmallStringSmallJsonGT(void) {
 
   smallStringt* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "sheepy");
   r = cropSmallStringSmallJsonG(self, 0,2);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(ssGet(r), "sh");
   ck_assert_str_eq(sjGet(self), "eepy");
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallJsonGT(void) {
 
   baset* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallJsonG(self, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "1");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemAtUndefinedSmallJsonGT(void) {
 
   undefinedt* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->pushUndefined(self);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtUndefinedSmallJsonG(self, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemAtBoolSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtBoolSmallJsonG(self, 0);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void cropElemAtDoubleSmallJsonGT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->pushDouble(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtDoubleSmallJsonG(self, 0);
   ck_assert(r==1);
   terminateO(self);
 
 }
 
 
 void cropElemAtIntSmallJsonGT(void) {
 
   int64_t r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtIntSmallJsonG(self, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void cropElemAtInt32SmallJsonGT(void) {
 
   int32_t r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtInt32SmallJsonG(self, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void cropElemAtUintSmallJsonGT(void) {
 
   uint64_t r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtUintSmallJsonG(self, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void cropElemAtUint32SmallJsonGT(void) {
 
   uint32_t r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtUint32SmallJsonG(self, 0);
   ck_assert_int_eq(r, 2);
   terminateO(self);
 
 }
 
 
 void cropElemAtSSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->pushS(self, "qwe");
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSSmallJsonG(self, 0);
   ck_assert_str_eq(r, "qwe");
   free(r);
   terminateO(self);
 
 }
 
 
 void cropElemAtCharSmallJsonGT(void) {
 
   char r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "sheepy");
   r = cropElemAtCharSmallJsonG(self, 0);
   ck_assert_int_eq(r, 's');
   ck_assert_str_eq(sjGet(self), "heepy");
   terminateO(self);
 
 }
 
 
 void cropElemAtDictSmallJsonGT(void) {
 
   smallDictt* r;
   smallJsont *self = allocSmallJson();
 
   createSmallDict(d);
   (&d)->f->setInt(&d, "a", 1);
   smallJsont *r2 = self->f->pushDict(self, &d);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtDictSmallJsonG(self, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{\"a\":1}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemAtArraySmallJsonGT(void) {
 
   smallArrayt* r;
   smallJsont *self = allocSmallJson();
 
   r = allocSmallArray();
   r->f->pushInt(r, 1);
   smallJsont *r2 = self->f->pushNFreeArray(self, r);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtArraySmallJsonG(self, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallBoolSmallJsonGT(void) {
 
   smallBoolt* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->pushBool(self, true);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallBoolSmallJsonG(self, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallBytesSmallJsonGT(void) {
 
   smallBytest* r;
   smallJsont *self = allocSmallJson();
 
   r = allocSmallBytes("qwe", 3);
   smallJsont *r2 = self->f->pushNFreeSmallBytes(self, r);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallBytesSmallJsonG(self, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[0x71,0x77,0x65]");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallDoubleSmallJsonGT(void) {
 
   smallDoublet* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->pushDouble(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallDoubleSmallJsonG(self, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "1.000000e+00");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallIntSmallJsonGT(void) {
 
   smallIntt* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallIntSmallJsonG(self, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "1");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = allocSmallJson();
   r->f->setInt(r, "a", 1);
   smallJsont *r2 = self->f->pushNFreeSmallJson(self, r);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallJsonSmallJsonG(self, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{\"a\":1}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallStringSmallJsonGT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->pushS(self, "qwe");
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallStringSmallJsonG(self, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemAtVoidSmallJsonGT(void) {
 
   void* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = pushVoidSmallJsonG(self, &r);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtVoidSmallJsonG(self, 0);
   ck_assert_ptr_eq(r, &r);
   terminateO(self);
 
 }
 
 
 void cropElemAtSmallContainerSmallJsonGT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
 
   createSmallContainer(e2);
   smallJsont *r2 = self->f->pushSmallContainer(self, &e2);
   ck_assert_ptr_ne(r2, null);
   r = cropElemAtSmallContainerSmallJsonG(self, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallJsonGT(void) {
 
   baset* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setS(self, "3", "2");
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setUndefined(self, "u");
   ck_assert_ptr_ne(r2, null);
   createSmallContainer(c);
   r2 = self->f->setSmallContainer(self, "c", &c);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "b", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   // crop string
   r = cropElemKeySmallJsonG(self, "3");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"u\":null,\"c\":\"<data container>\",\"b\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeyUndefinedSmallJsonGT(void) {
 
   undefinedt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setUndefined(self, "u");
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyUndefinedSmallJsonG(self, "u");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "null");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeyBoolSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setBool(self, "b", true);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyBoolSmallJsonG(self, "b");
   ck_assert(r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeyDoubleSmallJsonGT(void) {
 
   double r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "b", 3.3);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyDoubleSmallJsonG(self, "b");
   ck_assert(r == 3.3);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeyIntSmallJsonGT(void) {
 
   int64_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setInt(self, "b", 2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyIntSmallJsonG(self, "b");
   ck_assert_int_eq(r, 2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeyInt32SmallJsonGT(void) {
 
   int32_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setInt(self, "b", 2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyInt32SmallJsonG(self, "b");
   ck_assert_int_eq(r, 2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeyUintSmallJsonGT(void) {
 
   uint64_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setInt(self, "b", 2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyUintSmallJsonG(self, "b");
   ck_assert_int_eq(r, 2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeyUint32SmallJsonGT(void) {
 
   uint32_t r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setInt(self, "b", 2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyUint32SmallJsonG(self, "b");
   ck_assert_int_eq(r, 2);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeySSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setS(self, "b", "qwe");
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySSmallJsonG(self, "b");
   ck_assert_str_eq(r, "qwe");
   free(r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeyDictSmallJsonGT(void) {
 
   smallDictt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallDict(d);
   r2 = self->f->setNFreeDict(self, "b", d);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyDictSmallJsonG(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeyArraySmallJsonGT(void) {
 
   smallArrayt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallArray(d);
   r2 = self->f->setNFreeArray(self, "b", d);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyArraySmallJsonG(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallBoolSmallJsonGT(void) {
 
   smallBoolt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setBool(self, "b", true);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySmallBoolSmallJsonG(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "true");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallBytesSmallJsonGT(void) {
 
   smallBytest* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallBytes(d);
   r2 = self->f->setNFreeSmallBytes(self, "b", d);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySmallBytesSmallJsonG(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallDoubleSmallJsonGT(void) {
 
   smallDoublet* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "b", 3.3);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySmallDoubleSmallJsonG(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "3.300000e+00");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallIntSmallJsonGT(void) {
 
   smallIntt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setInt(self, "b", 2);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySmallIntSmallJsonG(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "2");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallBytes(b);
   r2 = self->f->setNFreeSmallBytes(self, "2", b);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallJson(d);
   r2 = self->f->setNFreeSmallJson(self, "b", d);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySmallJsonSmallJsonG(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{}");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":[],\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallStringSmallJsonGT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setS(self, "b", "qwe");
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySmallStringSmallJsonG(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "qwe");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeyVoidSmallJsonGT(void) {
 
   void* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   smallContainert *c = allocSmallContainer(&r);
   r2 = self->f->setNFreeSmallContainer(self, "b", c);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeyVoidSmallJsonG(self, "b");
   ck_assert_ptr_eq(r, &r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void cropElemKeySmallContainerSmallJsonGT(void) {
 
   smallContainert* r;
   smallJsont *self = allocSmallJson();
   smallJsont *r2;
 
   r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setDouble(self, "2", 2.2);
   ck_assert_ptr_ne(r2, null);
   smallContainert *c = allocSmallContainer(&r);
   r2 = self->f->setNFreeSmallContainer(self, "b", c);
   ck_assert_ptr_ne(r2, null);
   createAllocateSmallInt(I);
   setValG(I, 11);
   I->type = "anothertype";
   r2 = self->f->set(self, "B", (baset*)I);
   ck_assert_ptr_ne(r2, null);
   r = cropElemKeySmallContainerSmallJsonG(self, "b");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "<data smallContainer>");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "{\"1\":1,\"2\":2.200000e+00,\"B\":\"<data container>\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void copySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // add elements to self
   r = self->f->pushInt(self, 1);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 2);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 3);
   ck_assert_ptr_ne(r, null);
   r = self->f->pushInt(self, 4);
   ck_assert_ptr_ne(r, null);
   r = copySmallJsonG(self, 1, -1);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenO(r), 2);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "[2,3]");
   free(s);
   s = toStringO(self);
   ck_assert_str_eq(s, "[1,2,3,4]");
   free(s);
   terminateO(self);
 
 }
 
 
 void insertSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocSmallJson();
   smallArrayt *toInsert = allocSmallArray();
 
   toInsert->f->pushInt(toInsert, 3);
   r = insertSmallJsonG(self, 0, toInsert);
   smashO(toInsert);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   terminateO(self);
 
 }
 
 
 void insertNSmashSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocSmallJson();
   smallArrayt *toInsert = allocSmallArray();
 
   toInsert->f->pushInt(toInsert, 3);
   r = insertNSmashSmallJsonG(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   terminateO(self);
 
 }
 
 
 void insertSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   setTypeArrayO(self);
   smallJsont *toInsert = allocSmallJson();
 
   toInsert->f->pushInt(toInsert, 3);
   r = insertSmallJsonSmallJsonG(self, 0, toInsert);
   smashO(toInsert);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   terminateO(self);
 
 }
 
 
 void insertNSmashSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   setTypeArrayO(self);
   smallJsont *toInsert = allocSmallJson();
 
   toInsert->f->pushInt(toInsert, 3);
   r = insertNSmashSmallJsonSmallJsonG(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[3]");
   free(s);
   terminateO(self);
 
 }
 
 
 void insertStringSmallJsonGT(void) {
 
   smallJsont*    r;
   smallJsont *self       = allocG(rtSmallJsont);
   smallStringt *toInsert = allocSmallString("lib");
 
   setTopSO(self, "sheepy");
   r = insertStringSmallJsonG(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "libsheepy");
   free(s);
   terminateO(toInsert);
   terminateO(self);
 
 }
 
 
 void insertSSmallJsonGT(void) {
 
   smallJsont*    r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "sheepy");
   r = insertSSmallJsonG(self, 0, "lib");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "libsheepy");
   free(s);
   terminateO(self);
 
 }
 
 
 void insertNFreeSmallJsonGT(void) {
 
   smallJsont*    r;
   smallJsont *self       = allocG(rtSmallJsont);
   smallStringt *toInsert = allocSmallString("lib");
 
   setTopSO(self, "sheepy");
   r = insertNFreeStringSmallJsonG(self, 0, toInsert);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "libsheepy");
   free(s);
   terminateO(self);
 
 }
 
 
 void insertSNFreeStringSmallJsonGT(void) {
 
   smallJsont*    r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "sheepy");
   r = insertNFreeSSmallJsonG(self, 0, strdup("lib"));
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "libsheepy");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value      = (baset*) allocSmallInt(8);
 
   r = injectSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[8]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectUndefinedSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = injectUndefinedSmallJsonG(self, 0, null);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = injectBoolSmallJsonG(self, 0, true);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = injectDoubleSmallJsonG(self, 0, 1);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = injectIntSmallJsonG(self, 0, 2);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[2]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = injectSSmallJsonG(self, 0, "qwe");
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = injectCharSmallJsonG(self, 0, 'a');
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[\"a\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   createSmallDict(d);
   r = injectDictSmallJsonG(self, 0, &d);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   createSmallArray(a);
   r = injectArraySmallJsonG(self, 0, &a);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array      = listCreateS("a","b");
 
   r = injectArraycSmallJsonG(self, 0, array);
   ck_assert_ptr_ne(r, null);
   listFreeS(array);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"b\"]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectCArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   const char *array[] = {"a","b",null};
 
   r = injectCArraycSmallJsonG(self, 0, array);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"b\"]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectVoidSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = injectVoidSmallJsonG(self, 0, null);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   r = injectVoidSmallJsonG(self, 0, &r);
   ck_assert_ptr_ne(r, null);
   s  = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\",null]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectSmallBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   smallBoolt *b = allocSmallBool(true);
   r = injectSmallBoolSmallJsonG(self, 0, b);
   ck_assert_ptr_ne(r, null);
   finishO(b);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectSmallBytesSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBytest *b    = allocSmallBytes("qwe", 3);
 
   r = injectSmallBytesSmallJsonG(self, 0, b);
   ck_assert_ptr_ne(r, null);
   finishO(b);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[[0x71,0x77,0x65]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectSmallDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallDoublet *value = allocSmallDouble(1);
 
   r = injectSmallDoubleSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectSmallIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocSmallInt(1);
 
   r = injectSmallIntSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallJsont *string = allocSmallJson();
 
   r = injectSmallJsonSmallJsonG(self, 0, string);
   ck_assert_ptr_ne(r, null);
   finishO(string);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   smallStringt *string = allocSmallString("qwe");
 
   r = injectSmallStringSmallJsonG(self, 0, string);
   ck_assert_ptr_ne(r, null);
   finishO(string);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectSmallContainerSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self      = allocSmallJson();
   smallContainert *value = allocSmallContainer(null);
 
   r = injectSmallContainerSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   finishO(value);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   baset *value      = (baset*) allocSmallInt(8);
 
   r = injectNFreeSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[8]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectNFreeUndefinedSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateUndefined(u);
   r = injectNFreeUndefinedSmallJsonG(self, 0, u);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[null]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectNFreeSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char *string      = strdup("qwe");
 
   r = injectNFreeSSmallJsonG(self, 0, string);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectNFreeDictSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallDict(d);
   r = injectNFreeDictSmallJsonG(self, 0, d);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectNFreeArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   createAllocateSmallArray(a);
   r = injectNFreeArraySmallJsonG(self, 0, a);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[[]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectNFreeArraycSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char **array      = listCreateS("a","b");
 
   r = injectNFreeArraycSmallJsonG(self, 0, array);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[[\"a\",\"b\"]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallBoolSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   smallBoolt *b = allocSmallBool(true);
   r = injectNFreeSmallBoolSmallJsonG(self, 0, b);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[true]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallBytesSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallBytest *b    = allocSmallBytes("qwe", 3);
 
   r = injectNFreeSmallBytesSmallJsonG(self, 0, b);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[[0x71,0x77,0x65]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallDoubleSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallDoublet *value = allocSmallDouble(1);
 
   r = injectNFreeSmallDoubleSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1.000000e+00]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallIntSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value  = allocSmallInt(1);
 
   r = injectNFreeSmallIntSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[1]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self  = allocSmallJson();
   smallJsont *string = allocSmallJson();
 
   r = injectNFreeSmallJsonSmallJsonG(self, 0, string);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[{}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   smallStringt *string = allocSmallString("qwe");
 
   r = injectNFreeSmallStringSmallJsonG(self, 0, string);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void injectNFreeSmallContainerSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallContainert *value = allocSmallContainer(null);
 
   r = injectNFreeSmallContainerSmallJsonG(self, 0, value);
   ck_assert_ptr_ne(r, null);
   char *s  = toStringO(r);
   ck_assert_str_eq(s, "[\"<data container>\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void uniqSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   self->f->pushNFreeDict(self, allocSmallDict());
   self->f->pushDouble(self, 1);
   self->f->pushInt(self, 2);
   self->f->pushS(self, "");
   self->f->pushNFreeArray(self, allocSmallArray());
   self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4));
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   self->f->pushNFreeDict(self, allocSmallDict());
   self->f->pushDouble(self, 1);
   self->f->pushInt(self, 2);
   self->f->pushS(self, "");
   self->f->pushNFreeArray(self, allocSmallArray());
   self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4));
   r = uniqSmallJsonG(self, 0);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"\",[],[0x71,0x77,0x65,0x00]]");
   free(s);
   // json string
   freeO(self);
   setTopSO(self, "/qwd///");
   r = uniqSmallJsonG(self, '/');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "/qwd/");
   free(s);
   terminateO(self);
 
 }
 
 
 void sortSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushS(self, "bb");
   self->f->pushS(self, "a");
   r = sortSmallJsonG(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"a\",\"bb\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void sortFSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   // sort dict
   smallDictt *d[4];
   arange(i,d) d[i] = allocSmallDict();
   d[0]->f->setInt(d[0], "a", 1);
   d[1]->f->setInt(d[1], "a", 0);
   d[3]->f->setInt(d[3], "a", 0);
   d[3]->f->setInt(d[3], "b", 0);
   arange(i,d) self->f->pushNFreeDict(self, d[i]);
   r = sortFSmallJsonG(self, sortFOCmp);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[{},{\"a\":0},{\"a\":1},{\"a\":0,\"b\":0}]");
   free(s);
   terminateO(self);
 
 }
 
 
 void icSortSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushS(self, "bb");
   self->f->pushS(self, "A");
   r = icSortSmallJsonG(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"A\",\"bb\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void icUniqSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   self->f->pushNFreeDict(self, allocSmallDict());
   self->f->pushDouble(self, 1);
   self->f->pushInt(self, 2);
   self->f->pushS(self, "ASD");
   self->f->pushNFreeArray(self, allocSmallArray());
   self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4));
   self->f->pushUndefined(self);
   self->f->pushBool(self, true);
   self->f->pushNFreeDict(self, allocSmallDict());
   self->f->pushDouble(self, 1);
   self->f->pushInt(self, 2);
   self->f->pushS(self, "asd");
   self->f->pushNFreeArray(self, allocSmallArray());
   self->f->pushNFreeSmallBytes(self, allocSmallBytes("qwe",4));
   r = icUniqSmallJsonG(self, 0);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[null,true,{},1.000000e+00,2,\"ASD\",[],[0x71,0x77,0x65,0x00]]");
   free(s);
   // json string
   freeO(self);
   setTopSO(self, "/qQwd///");
   r = icUniqSmallJsonG(self, 'q');
   ck_assert_ptr_ne(r, null);
   s = toStringO(r);
   ck_assert_str_eq(s, "/qwd///");
   free(s);
   terminateO(self);
 
 }
 
 
 void hasSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasUndefinedSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasUndefinedSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasBoolSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasBoolSmallJsonG(self, true);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasDoubleSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasDoubleSmallJsonG(self, 1);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasIntSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasIntSmallJsonG(self, 1);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasSSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasSSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasCharSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasCharSmallJsonG(self, ' ');
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasDictSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasDictSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasArraySmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasArraySmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasArraycSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasArraycSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasCArraycSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasCArraycSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasSmallBoolSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasSmallBoolSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasSmallBytesSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasSmallBytesSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasSmallDoubleSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasSmallDoubleSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasSmallIntSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasSmallIntSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasSmallJsonSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasSmallJsonSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasSmallStringSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasSmallStringSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void hasSmallContainerSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = hasSmallContainerSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void findSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // find string in the middle
   freeO(self);
   setTopSO(self, "sheepy");
   r =  findSmallJsonG(self, "ee");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void findCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // find string in the middle
   setTopSO(self, "sheepy");
   r = findCharSmallJsonG(self, 'e');
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void findSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt *needle = allocSmallString("ee");
 
   // find string in the middle
   setTopSO(self, "sheepy");
   r = findSmallStringSmallJsonG(self, needle);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   terminateO(needle);
   terminateO(self);
 
 }
 
 
 void findJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallJsont *needle = allocSmallJson();
 
   // find string in the middle
   setTopSO(self, "sheepy");
   setTopSO(needle, "ee");
   r = findJsonSmallJsonG(self, needle);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   terminateO(needle);
   terminateO(self);
 
 }
 
 
 void indexOfSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfUndefinedSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfUndefinedSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfBoolSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfBoolSmallJsonG(self, false);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfDoubleSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfDoubleSmallJsonG(self, 0);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfIntSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfIntSmallJsonG(self, 0);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfSSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfSSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfCharSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfCharSmallJsonG(self, ' ');
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfDictSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfDictSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfArraySmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfArraySmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfArraycSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfArraycSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfCArraycSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfCArraycSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfSmallBoolSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfSmallBoolSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfSmallBytesSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfSmallBytesSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfSmallDoubleSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfSmallDoubleSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfSmallIntSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfSmallIntSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfSmallJsonSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfSmallJsonSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfSmallStringSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfSmallStringSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void indexOfSmallContainerSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = indexOfSmallContainerSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchUndefinedSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchUndefinedSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchBoolSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchBoolSmallJsonG(self, false);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchDoubleSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchDoubleSmallJsonG(self, 0);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchIntSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchIntSmallJsonG(self, 0);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchSSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchSSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchCharSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchCharSmallJsonG(self, ' ');
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchDictSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchDictSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchArraySmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchArraySmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchArraycSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchArraycSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchCArraycSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchCArraycSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchSmallBoolSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchSmallBoolSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchSmallBytesSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchSmallBytesSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchSmallDoubleSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchSmallDoubleSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchSmallIntSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchSmallIntSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchSmallJsonSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchSmallJsonSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchSmallStringSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchSmallStringSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void binarySearchSmallContainerSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = binarySearchSmallContainerSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icHasSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = icHasSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void icHasSSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = icHasSSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void icHasCharSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = icHasCharSmallJsonG(self, 'a');
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void icHasDictSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = icHasDictSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void icHasArraySmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = icHasArraySmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void icHasArraycSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = icHasArraycSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void icHasCArraycSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = icHasCArraycSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void icHasSmallStringSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = icHasSmallStringSmallJsonG(self, null);
   ck_assert(!r);
   terminateO(self);
 
 }
 
 
 void icFindSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // icFind string in the middle
   setTopSO(self, "sheepy");
   r =  icFindSmallJsonG(self, "EE");
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void icFindCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // find string in the middle
   setTopSO(self, "sheepy");
   r = icFindCharSmallJsonG(self, 'E');
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void icFindSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt *needle = allocSmallString("EE");
 
   // find string in the middle
   setTopSO(self, "sheepy");
   r = icFindSmallStringSmallJsonG(self, needle);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   terminateO(needle);
   terminateO(self);
 
 }
 
 
 void icFindJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallJsont *needle = allocSmallJson();
 
   // find string in the middle
   setTopSO(self, "sheepy");
   setTopSO(needle, "EE");
   r = icFindJsonSmallJsonG(self, needle);
   ck_assert_ptr_ne(r, null);
   ck_assert_str_eq(sjGet(r), "eepy");
   terminateO(r);
   terminateO(needle);
   terminateO(self);
 
 }
 
 
 void icIndexOfSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icIndexOfSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icIndexOfSSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icIndexOfSSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icIndexOfCharSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icIndexOfCharSmallJsonG(self, 'A');
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icIndexOfDictSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icIndexOfDictSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icIndexOfArraySmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icIndexOfArraySmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icIndexOfArraycSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icIndexOfArraycSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icIndexOfCArraycSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icIndexOfCArraycSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icIndexOfSmallStringSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icIndexOfSmallStringSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icBinarySearchSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icBinarySearchSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icBinarySearchSSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icBinarySearchSSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icBinarySearchCharSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icBinarySearchCharSmallJsonG(self, 'a');
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icBinarySearchDictSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icBinarySearchDictSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icBinarySearchArraySmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icBinarySearchArraySmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icBinarySearchArraycSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icBinarySearchArraycSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icBinarySearchCArraycSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icBinarySearchCArraycSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void icBinarySearchSmallStringSmallJsonGT(void) {
 
   ssize_t r;
   smallJsont *self = allocSmallJson();
 
   r = icBinarySearchSmallStringSmallJsonG(self, null);
   ck_assert_int_eq(r, -1);
   terminateO(self);
 
 }
 
 
 void keyBySmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   baset *value;
 
   smallJsont *r2 = self->f->setInt(self, "1", 1);
   ck_assert_ptr_ne(r2, null);
   value = (baset*) allocSmallInt(1);
   r = keyBySmallJsonG(self, value);
   ck_assert_str_eq(r, "1");
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void keyByUndefinedSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   undefinedt *value;
 
   smallJsont *r2 = self->f->setUndefined(self, "1");
   ck_assert_ptr_ne(r2, null);
   value = allocUndefined();
   r = keyByUndefinedSmallJsonG(self, value);
   ck_assert_str_eq(r, "1");
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void keyByBoolSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setBool(self, "1", true);
   ck_assert_ptr_ne(r2, null);
   r = keyByBoolSmallJsonG(self, true);
   ck_assert_str_eq(r, "1");
   terminateO(self);
 
 }
 
 
 void keyByDoubleSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setDouble(self, "1", 2.2);
   ck_assert_ptr_ne(r2, null);
   r = keyByDoubleSmallJsonG(self, 2.2);
   ck_assert_str_eq(r, "1");
   terminateO(self);
 
 }
 
 
 void keyByIntSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setInt(self, "1", 2);
   ck_assert_ptr_ne(r2, null);
   r = keyByIntSmallJsonG(self, 2);
   ck_assert_str_eq(r, "1");
   terminateO(self);
 
 }
 
 
 void keyBySSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setS(self, "1", "qwe");
   ck_assert_ptr_ne(r2, null);
   r = keyBySSmallJsonG(self, "qwe");
   ck_assert_str_eq(r, "1");
   terminateO(self);
 
 }
 
 
 void keyByCharSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setS(self, "1", "q");
   ck_assert_ptr_ne(r2, null);
   r = keyByCharSmallJsonG(self, 'q');
   ck_assert_str_eq(r, "1");
   terminateO(self);
 
 }
 
 
 void keyByDictSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict = allocSmallDict();
 
   createAllocateSmallDict(d);
   d->f->setS(d, "another", "dict");
   smallJsont *r2 = self->f->setNFreeDict(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeDict(self, "1", dict);
   ck_assert_ptr_ne(r2, null);
   dict = allocSmallDict();
   r = keyByDictSmallJsonG(self, dict);
   ck_assert_str_eq(r, "1");
   terminateO(dict);
   terminateO(self);
 
 }
 
 
 void keyByArraySmallJsonGT(void) {
 
   char* r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   createAllocateSmallArray(d);
   d->f->pushS(d, "another array");
   smallJsont *r2 = self->f->setNFreeArray(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeArray(self, "1", array);
   ck_assert_ptr_ne(r2, null);
   array = allocSmallArray();
   r = keyByArraySmallJsonG(self, array);
   ck_assert_str_eq(r, "1");
   terminateO(array);
   terminateO(self);
 
 }
 
 
 void keyByArraycSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   char **array     = listCreateS("a","b");
 
   char **d = listCreateS("asd", "zxcv");
   smallJsont *r2 = self->f->setNFreeArrayc(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setArrayc(self, "1", array);
   ck_assert_ptr_ne(r2, null);
   r = keyByArraycSmallJsonG(self, array);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "1");
   listFreeS(array);
   terminateO(self);
 
 }
 
 
 void keyByCArraycSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   char **array     = listCreateS("a","b");
   const char *a[]  = {"a", "b", null};
 
   char **d = listCreateS("asd", "zxcv");
   smallJsont *r2 = self->f->setNFreeArrayc(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setArrayc(self, "1", array);
   ck_assert_ptr_ne(r2, null);
   r = keyByCArraycSmallJsonG(self, a);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "1");
   listFreeS(array);
   terminateO(self);
 
 }
 
 
 void keyBySmallBoolSmallJsonGT(void) {
 
   char* r;
   smallJsont *self  = allocSmallJson();
   smallBoolt *value = allocSmallBool(true);
 
   createAllocateSmallBool(d);
   setValO(d, false);
   smallJsont *r2 = self->f->setNFreeSmallBool(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeSmallBool(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   value = allocSmallBool(true);
   r = keyBySmallBoolSmallJsonG(self, value);
   ck_assert_str_eq(r, "1");
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void keyBySmallBytesSmallJsonGT(void) {
 
   char* r;
   smallJsont *self   = allocSmallJson();
   smallBytest *value = allocSmallBytes("qwe", sizeof("qwe"));
 
   smallBytest *d = allocSmallBytes("asd", sizeof("asd"));
   smallJsont *r2 = self->f->setNFreeSmallBytes(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeSmallBytes(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   value = allocSmallBytes("qwe", sizeof("qwe"));
   r = keyBySmallBytesSmallJsonG(self, value);
   ck_assert_str_eq(r, "1");
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void keyBySmallDoubleSmallJsonGT(void) {
 
   char* r;
   smallJsont *self    = allocSmallJson();
   smallDoublet *value = allocSmallDouble(2.2);
 
   createAllocateSmallDouble(d);
   smallJsont *r2 = self->f->setNFreeSmallDouble(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeSmallDouble(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   value = allocSmallDouble(2.2);
   r = keyBySmallDoubleSmallJsonG(self, value);
   ck_assert_str_eq(r, "1");
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void keyBySmallIntSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   smallIntt *value = allocSmallInt(2);
 
   createAllocateSmallInt(d);
   smallJsont *r2 = self->f->setNFreeSmallInt(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeSmallInt(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   value = allocSmallInt(2);
   r = keyBySmallIntSmallJsonG(self, value);
   ck_assert_str_eq(r, "1");
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void keyBySmallJsonSmallJsonGT(void) {
 
   char* r;
   smallJsont *self  = allocSmallJson();
   smallJsont *value = allocSmallJson();
 
   createUndefined(u);
   setTopO(value, (baset*)&u);
   self->f->setUndefined(self, "1");
   r = keyBySmallJsonSmallJsonG(self, value);
   ck_assert_str_eq(r, "1");
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void keyBySmallStringSmallJsonGT(void) {
 
   char* r;
   smallJsont *self    = allocSmallJson();
   smallStringt *value = allocSmallString("qwe");
 
   createAllocateSmallString(d);
   smallJsont *r2 = self->f->setNFreeSmallString(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeSmallString(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   value = allocSmallString("qwe");
   r = keyBySmallStringSmallJsonG(self, value);
   ck_assert_str_eq(r, "1");
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void keyBySmallContainerSmallJsonGT(void) {
 
   char* r;
   smallJsont *self       = allocSmallJson();
   smallContainert *value = allocSmallContainer(null);
 
   createAllocateSmallString(d);
   smallJsont *r2 = self->f->setNFreeSmallString(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r = keyBySmallContainerSmallJsonG(self, value);
   ck_assert_ptr_eq(r, null);
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void icKeyBySmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   baset *value;
 
   smallJsont *r2 = self->f->setS(self, "1", "QQ");
   ck_assert_ptr_ne(r2, null);
   value = (baset*) allocSmallString("qq");
   r = icKeyBySmallJsonG(self, value);
   ck_assert_str_eq(r, "1");
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void icKeyBySSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setS(self, "1", "qwe");
   ck_assert_ptr_ne(r2, null);
   r = icKeyBySSmallJsonG(self, "QWE");
   ck_assert_str_eq(r, "1");
   terminateO(self);
 
 }
 
 
 void icKeyByCharSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = self->f->setS(self, "1", "q");
   ck_assert_ptr_ne(r2, null);
   r = icKeyByCharSmallJsonG(self, 'Q');
   ck_assert_str_eq(r, "1");
   terminateO(self);
 
 }
 
 
 void icKeyByDictSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   smallDictt *dict = allocSmallDict();
 
   createAllocateSmallDict(d);
   d->f->setS(d, "another", "dict");
   smallJsont *r2 = self->f->setNFreeDict(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   dict->f->setS(dict, "asd", "asd");
   r2 = self->f->setNFreeDict(self, "1", dict);
   ck_assert_ptr_ne(r2, null);
   dict = allocSmallDict();
   dict->f->setS(dict, "ASD", "asd");
   r = icKeyByDictSmallJsonG(self, dict);
   ck_assert_str_eq(r, "1");
   terminateO(dict);
   terminateO(self);
 
 }
 
 
 void icKeyByArraySmallJsonGT(void) {
 
   char* r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *array = allocSmallArray();
 
   createAllocateSmallArray(d);
   d->f->pushS(d, "another array");
   smallJsont *r2 = self->f->setNFreeArray(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   array->f->pushS(array, "the array");
   r2 = self->f->setNFreeArray(self, "1", array);
   ck_assert_ptr_ne(r2, null);
   array = allocSmallArray();
   array->f->pushS(array, "The array");
   r = icKeyByArraySmallJsonG(self, array);
   ck_assert_str_eq(r, "1");
   terminateO(array);
   terminateO(self);
 
 }
 
 
 void icKeyByArraycSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   char **array     = listCreateS("a","b");
 
   char **d = listCreateS("asd", "zxcv");
   smallJsont *r2 = self->f->setNFreeArrayc(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setArrayc(self, "1", array);
   ck_assert_ptr_ne(r2, null);
   iUpperS(&array[0]);
   r = icKeyByArraycSmallJsonG(self, array);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "1");
   listFreeS(array);
   terminateO(self);
 
 }
 
 
 void icKeyByCArraycSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
   const char *a2[] = {"a","b",null};
   char **array     = listCreateS("a","b");
 
   char **d = listCreateS("asd", "zxcv");
   smallJsont *r2 = self->f->setNFreeArrayc(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setArrayc(self, "1", array);
   ck_assert_ptr_ne(r2, null);
   iUpperS(&array[0]);
   r = icKeyByCArraycSmallJsonG(self, a2);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_str_eq(r, "1");
   listFreeS(array);
   terminateO(self);
 
 }
 
 
 void icKeyBySmallStringSmallJsonGT(void) {
 
   char* r;
   smallJsont *self    = allocSmallJson();
   smallStringt *value = allocSmallString("qwe");
 
   createAllocateSmallString(d);
   smallJsont *r2 = self->f->setNFreeSmallString(self, "d", d);
   ck_assert_ptr_ne(r2, null);
   r2 = self->f->setNFreeSmallString(self, "1", value);
   ck_assert_ptr_ne(r2, null);
   value = allocSmallString("QWE");
   r = icKeyBySmallStringSmallJsonG(self, value);
   ck_assert_str_eq(r, "1");
   terminateO(value);
   terminateO(self);
 
 }
 
 
 void replaceSmallJsonGT(void) {
 
   smallJsont*  r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "#ee#ee#ad");
 
   // replace string, multiple character new delimeter
   r = replaceSmallJsonG(self, "#","^^", 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(self);
 
 }
 
 
 void replaceCharSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // replace string, multiple character new delimeter
   setTopSO(self, "#ee#ee#ad");
   r = replaceCharSSmallJsonG(self, '#',"^^", 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(self);
 
 }
 
 
 void replaceSCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // replace string, multiple character new delimeter
   setTopSO(self, "#ee#ee#ad");
   r = replaceSCharSmallJsonG(self, "#",'^',0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   terminateO(self);
 
 }
 
 
 void replaceCharCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // replace string, multiple character new delimeter
   setTopSO(self, "#ee#ee#ad");
   r = replaceCharCharSmallJsonG(self, '#','^', 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   terminateO(self);
 
 }
 
 
 void replaceSmallStringSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "#ee#ee#ad");
   smallStringt *olds = allocSmallString("");
   smallStringt *news = allocSmallString("");
 
   setValO(olds, "#");
   setValO(news, "^^");
   r = replaceSmallStringSmallStringSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceSmallStringSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "#ee#ee#ad");
   smallStringt *olds = allocSmallString("");
   const char *news;
 
   // replace string, multiple character new delimeter
   setValO(olds, "#");
   news = "^^";
   r = replaceSmallStringSSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void replaceSmallStringCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "#ee#ee#ad");
   smallStringt *olds = allocSmallString("");
   char news;
 
   // replace string, multiple character new delimeter
   setValO(olds, "#");
   news = '^';
   r = replaceSmallStringCharSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void replaceSSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "#ee#ee#ad");
   const char *olds;
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   olds = "#";
   setValO(news, "^^");
   r = replaceSSmallStringSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceCharSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "#ee#ee#ad");
   char olds;
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   olds = '#';
   setValO(news, "^^");
   r = replaceCharSmallStringSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceJsonJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "#ee#ee#ad");
   smallJsont *olds = allocSmallJson();
   smallJsont *news = allocSmallJson();
 
   // replace string, multiple character new delimeter
   setTopSO(olds, "#");
   setTopSO(news, "^^");
   r = replaceJsonJsonSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceJsonSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "#ee#ee#ad");
   smallJsont *olds   = allocSmallJson();
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   freeO(olds);
   setTopSO(olds, "#");
   setValO(news, "^^");
   r = replaceJsonSmallStringSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceJsonSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "#ee#ee#ad");
   smallJsont *olds   = allocSmallJson();
   const char *news;
 
   // replace string, multiple character new delimeter
   freeO(olds);
   setTopSO(olds, "#");
   news = "^^";
   r = replaceJsonSSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void replaceJsonCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "#ee#ee#ad");
   smallJsont *olds = allocSmallJson();
   char news;
 
   // replace string, multiple character new delimeter
   freeO(olds);
   setTopSO(olds, "#");
   news = '^';
   r = replaceJsonCharSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void replaceSmallStringJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "#ee#ee#ad");
   smallStringt *olds = allocSmallString("");
   smallJsont *news   = allocSmallJson();
 
   // replace string, multiple character new delimeter
   setValO(olds, "#");
   setTopSO(news, "^^");
   r = replaceSmallStringJsonSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceSJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "#ee#ee#ad");
   const char *olds;
   smallJsont *news = allocSmallJson();
 
   // replace string, multiple character new delimeter
   olds = "#";
   setTopSO(news, "^^");
   r = replaceSJsonSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void replaceCharJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "#ee#ee#ad");
   char olds;
   smallJsont *news = allocSmallJson();
 
   // replace string, multiple character new delimeter
   olds = '#';
   setTopSO(news, "^^");
   r = replaceCharJsonSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceSmallJsonGT(void) {
 
   smallJsont*  r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "BeebeeBad");
 
   // replace string, multiple character new delimeter
   r = icReplaceSmallJsonG(self, "b","^^", 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(self);
 
 }
 
 
 void icReplaceCharSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "");
 
   // replace string, multiple character new delimeter
   freeO(self);
   setTopSO(self, "BeebeeBad");
   r = icReplaceCharSSmallJsonG(self, 'B',"^^", 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(self);
 
 }
 
 
 void icReplaceSCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "");
 
   // replace string, multiple character new delimeter
   freeO(self);
   setTopSO(self, "BeebeeBad");
   r = icReplaceSCharSmallJsonG(self, "b",'^',0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   terminateO(self);
 
 }
 
 
 void icReplaceCharCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "");
 
   // replace string, multiple character new delimeter
   freeO(self);
   setTopSO(self, "beeBeebad");
   r = icReplaceCharCharSmallJsonG(self, 'b','^', 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   terminateO(self);
 
 }
 
 
 void icReplaceSmallStringSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "beebeebad");
   smallStringt *olds = allocSmallString("");
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   setValO(olds, "B");
   setValO(news, "^^");
   r = icReplaceSmallStringSmallStringSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceSmallStringSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "beebeebad");
   smallStringt *olds = allocSmallString("");
   const char *news;
 
   // replace string, multiple character new delimeter
   setValO(olds, "B");
   news = "^^";
   r = icReplaceSmallStringSSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void icReplaceSmallStringCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "beebeebad");
   smallStringt *olds = allocSmallString("");
   char news;
 
   // replace string, multiple character new delimeter
   setValO(olds, "B");
   news = '^';
   r = icReplaceSmallStringCharSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void icReplaceSSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "beebeebad");
   const char *olds;
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   olds = "B";
   setValO(news, "^^");
   r = icReplaceSSmallStringSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceCharSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "beebeebad");
   char olds;
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   olds = 'B';
   setValO(news, "^^");
   r = icReplaceCharSmallStringSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceJsonJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "BeebeeBad");
   smallJsont *olds = allocSmallJson();
   smallJsont *news = allocSmallJson();
 
   // replace string, multiple character new delimeter
   freeO(olds);
   freeO(news);
   setTopSO(olds, "B");
   setTopSO(news, "^^");
   r = icReplaceJsonJsonSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceJsonSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "BeebeeBad");
   smallJsont *olds   = allocSmallJson();
   smallStringt *news = allocSmallString("");
 
   // replace string, multiple character new delimeter
   freeO(olds);
   setTopSO(olds, "B");
   setValO(news, "^^");
   r = icReplaceJsonSmallStringSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceJsonSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "BeebeeBad");
   smallJsont *olds   = allocSmallJson();
   const char *news;
 
   // replace string, multiple character new delimeter
   freeO(olds);
   setTopSO(olds, "b");
   news = "^^";
   r = icReplaceJsonSSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void icReplaceJsonCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "beeBeebad");
   smallJsont *olds   = allocSmallJson();
   char news;
 
   // replace string, multiple character new delimeter
   freeO(olds);
   setTopSO(olds, "B");
   news = '^';
   r = icReplaceJsonCharSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^ee^ee^ad");
   free(s);
   terminateO(olds);
   terminateO(self);
 
 }
 
 
 void icReplaceSmallStringJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "BeeBeeBad");
   smallStringt *olds = allocSmallString("");
   smallJsont *news   = allocSmallJson();
 
   // replace string, multiple character new delimeter
   freeO(news);
   setValO(olds, "b");
   setTopSO(news, "^^");
   r = icReplaceSmallStringJsonSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(olds);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceSJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "beebeebad");
   const char *olds;
   smallJsont *news   = allocSmallJson();
 
   // replace string, multiple character new delimeter
   freeO(news);
   olds = "B";
   setTopSO(news, "^^");
   r = icReplaceSJsonSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void icReplaceCharJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "beebeebad");
   char olds;
   smallJsont *news   = allocSmallJson();
 
   // replace string, multiple character new delimeter
   freeO(news);
   olds = 'B';
   setTopSO(news, "^^");
   r = icReplaceCharJsonSmallJsonG(self, olds, news, 0);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "^^ee^^ee^^ad");
   free(s);
   terminateO(news);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallArrayGT(void) {
 
   bool r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallArrayt *array = allocSmallArray();
 
   // empty arrays
   setTypeArrayO(self);
   r = equalSmallJsonSmallArrayG(self, array);
   ck_assert(r);
   // empty self, non empty array
   array->f->pushInt(array, 1);
   r = equalSmallJsonSmallArrayG(self, array);
   ck_assert(!r);
   terminateO(array);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonArrayGT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   char ** p2       = NULL;
 
   // empty arrays
   setTypeArrayO(self);
   r = equalSmallJsonArrayG(self, NULL);
   ck_assert(r);
   // empty self, non empty array
   p2 = listCreateS("a");
   r = equalSmallJsonArrayG(self, p2);
   ck_assert(!r);
   listFreeS(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonCArrayGT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   const char *p2[] = {"a", null};
 
   self->f->pushS(self, "a");
   r = equalSmallJsonCArrayG(self, p2);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonBaseGT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   baset* p2;
 
   // json bool
   setTopBoolO(self, false);
   p2 = (baset*) allocSmallBool(false);
   r = equalSmallJsonBaseG(self, p2);
   ck_assert(r);
   freeO(self);
   setTopBoolO(self, true);
   r = equalSmallJsonBaseG(self, p2);
   ck_assert(!r);
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonChaGT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   setTopSO(self, "");
 
   r = equalSmallJsonChaG(self,'q');
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "q");
   r = equalSmallJsonChaG(self,'q');
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonCharGT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   setTopSO(self, "");
 
   r = equalSmallJsonCharG(self,"qwe");
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "qwe");
   r = equalSmallJsonCharG(self,"qwe");
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonBoolGT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
 
   // empty json
   r = equalSmallJsonBoolG(self, false);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalSmallJsonBoolG(self, false);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonDoubleGT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
 
   // empty json
   r = equalSmallJsonDoubleG(self, 0);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalSmallJsonDoubleG(self, 0);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonInt64GT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
 
   // empty json
   r = equalSmallJsonInt64G(self, 0);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalSmallJsonInt64G(self, 0);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonInt32GT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
 
   // empty json
   r = equalSmallJsonInt32G(self, 0);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalSmallJsonInt32G(self, 0);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonUint32GT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
 
   // empty json
   r = equalSmallJsonUint32G(self, 0);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalSmallJsonUint32G(self, 0);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonUint64GT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
 
   // empty json
   r = equalSmallJsonUint64G(self, 0);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalSmallJsonUint64G(self, 0);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallBoolGT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallBoolt* p2   = allocSmallBool(false);
 
   // empty json
   r = equalSmallJsonSmallBoolG(self, p2);
   ck_assert(!r);
   // not equal
   setTopBoolO(self, true);
   r = equalSmallJsonSmallBoolG(self, p2);
   ck_assert(!r);
   // equal
   setValO(p2, true);
   r = equalSmallJsonSmallBoolG(self, p2);
   ck_assert(r);
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallBytesGT(void) {
 
   smallJsont* self = allocG(rtSmallJsont);
   smallBytest* p2  = allocSmallBytes("true", strlen("true"));
 
   // empty json
   ck_assert(!equalSmallJsonSmallBytesG(self, p2));
   // json bool
   setTopBoolO(self, true);
   ck_assert(!equalSmallJsonSmallBytesG(self, p2));
   freeO(p2);
   pushBufferO(p2, "true", sizeof("true"));
   ck_assert(equalSmallJsonSmallBytesG(self, p2));
   freeO(self);
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallDoubleGT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallDoublet* p2 = allocSmallDouble(0);
 
   // empty json
   r = equalSmallJsonSmallDoubleG(self, p2);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalSmallJsonSmallDoubleG(self, p2);
   ck_assert(r);
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallIntGT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallIntt* p2    = allocSmallInt(0);
 
   // empty json
   r = equalSmallJsonSmallIntG(self, p2);
   ck_assert(!r);
   // json bool
   freeO(self);
   setTypeBoolO(self);
   r = equalSmallJsonSmallIntG(self, p2);
   ck_assert(r);
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallJsonGT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallJsont* p2   = allocSmallJson();
 
   // empty json
   r = equalSmallJsonSmallJsonG(self, p2);
   ck_assert(!r);
   // undefined
   setTypeUndefinedO(p2);
   ck_assert(!equalSmallJsonSmallJsonG(self, p2));
   setTypeUndefinedO(self);
   ck_assert(equalSmallJsonSmallJsonG(self, p2));
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallStringGT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallStringt* p2 = allocSmallString("");
 
   // empty json
   r = equalSmallJsonSmallStringG(self, p2);
   ck_assert(!r);
   // json bool
   setTypeBoolO(self);
   setValO(p2, "false");
   r = equalSmallJsonSmallStringG(self, p2);
   ck_assert(r);
   setValO(p2, "true");
   r = equalSmallJsonSmallStringG(self, p2);
   ck_assert(!r);
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void equalSmallJsonSmallDictGT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallDictt* p2   = allocSmallDict();
 
   // empty json
   r = equalSmallJsonSmallDictG(self, p2);
   ck_assert(!r);
   setTypeDictO(self);
   r = equalSmallJsonSmallDictG(self, p2);
   ck_assert(!r);
   // equal
   self->f->setInt(self, "a", 1);
   self->f->setInt(self, "b", 2);
   self->f->setInt(self, "c", 3);
   p2->f->setInt(p2, "b", 2);
   p2->f->setInt(p2, "a", 1);
   p2->f->setInt(p2, "c", 3);
   r = equalSmallJsonSmallDictG(self, p2);
   ck_assert(r);
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void icEqualSmallJsonSmallArrayGT(void) {
 
   bool r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallArrayt *array = allocSmallArray();
 
   self->f->pushS(self, "a");
   array->f->pushS(array, "A");
   r = icEqualSmallJsonSmallArrayG(self, array);
   ck_assert(r);
   terminateO(array);
   terminateO(self);
 
 }
 
 
 void icEqualSmallJsonArrayGT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   char ** p2       = NULL;
 
   listPushS(&p2, "a");
   self->f->pushS(self, "A");
   r = icEqualSmallJsonArrayG(self, p2);
   ck_assert(r);
   listFreeS(p2);
   terminateO(self);
 
 }
 
 
 void icEqualSmallJsonCArrayGT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   const char *p2[] = {"a", null};
 
   self->f->pushS(self, "A");
   r = icEqualSmallJsonCArrayG(self, p2);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void icEqualSmallJsonBaseGT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   baset* p2;
 
   // json bool
   setTopBoolO(self, false);
   p2 = (baset*) allocSmallBool(false);
   r = icEqualSmallJsonBaseG(self, p2);
   ck_assert(r);
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void icEqualSmallJsonSmallDictGT(void) {
 
   bool r;
   smallJsont* self = allocG(rtSmallJsont);
   smallDictt* p2   = allocSmallDict();
 
   // equal
   self->f->setS(self, "a", "a");
   self->f->setInt(self, "b", 2);
   self->f->setInt(self, "c", 3);
   p2->f->setInt(p2, "b", 2);
   p2->f->setS(p2, "a", "A");
   p2->f->setInt(p2, "c", 3);
   r = icEqualSmallJsonSmallDictG(self, p2);
   ck_assert(r);
   terminateO(p2);
   terminateO(self);
 
 }
 
 
 void icEqualSmallJsonSmallJsonGT(void) {
 
   bool r;
   smallJsont* self   = allocG(rtSmallJsont);
   smallJsont *string = allocSmallJson();
 
   setTopSO(string, "qwe");
   setTopSO(self, "QWE");
   r = icEqualSmallJsonSmallJsonG(self, string);
   ck_assert(r);
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icEqualSmallJsonSmallStringGT(void) {
 
   bool r;
   smallJsont* self     = allocG(rtSmallJsont);
   smallStringt *string = allocSmallString("qwe");
 
   setTopSO(self, "QWE");
   r = icEqualSmallJsonSmallStringG(self, string);
   ck_assert(r);
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icEqualCharSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "");
 
   r = icEqualCharSmallJsonG(self,'q');
   ck_assert(!r);
   freeO(self);
   setTopSO(self, "q");
   r = icEqualCharSmallJsonG(self,'Q');
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void icEqualSSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
 
   // empty json
   r = icEqualSSmallJsonG(self, "qwe");
   ck_assert(!r);
   // equal
   setTopSO(self, "QWE");
   r = icEqualSSmallJsonG(self, "qwe");
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void equalISSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "Ashee|");
 
   ck_assert(equalISSmallJsonG(self, "shee", 1));
   terminateO(self);
 
 }
 
 
 void equalICharSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "Ashee");
 
   // identical strings
   ck_assert(equalICharSmallJsonG(self, 's', 1));
   terminateO(self);
 
 }
 
 
 void equalIJsonSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "Ashee|");
   smallJsont *string = allocSmallJson();
 
   // identical strings
   setTopSO(string, "shee");
   ck_assert(equalIJsonSmallJsonG(self, string, 1));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void equalISmallStringSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "Ashee|");
   smallStringt *string = allocSmallString("shee");
 
   // identical strings
   ck_assert(equalISmallStringSmallJsonG(self, string, 1));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void startsWithSSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "sheepy");
   ck_assert(startsWithSSmallJsonG(self, "shee"));
   terminateO(self);
 
 }
 
 
 void startsWithCharSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "shee");
 
   // identical strings
   ck_assert(startsWithCharSmallJsonG(self, 's'));
   terminateO(self);
 
 }
 
 
 void startsWithSmallStringSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "sheepy");
   smallStringt *string = allocSmallString("shee");
 
   // identical strings
   ck_assert(startsWithSmallStringSmallJsonG(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void startsWithJsonSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "sheepy");
   smallJsont *string = allocSmallJson();
 
   // identical strings
   setTopSO(string, "shee");
   ck_assert(startsWithJsonSmallJsonG(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void endsWithSSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "sheepy");
 
   ck_assert(endsWithSSmallJsonG(self, "eepy"));
   terminateO(self);
 
 }
 
 
 void endsWithCharSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "shee");
 
   // identical strings
   ck_assert(endsWithCharSmallJsonG(self, 'e'));
   terminateO(self);
 
 }
 
 
 void endsWithSmallStringSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "shee");
   smallStringt *string = allocSmallString("hee");
 
   // identical strings
   ck_assert(endsWithSmallStringSmallJsonG(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void endsWithJsonSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "shee");
   smallJsont *string = allocSmallJson();
 
   // identical strings
   setTopSO(string, "hee");
   ck_assert(endsWithJsonSmallJsonG(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void countSSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "sheepy");
 
   // positive count
   ck_assert_int_eq(countSSmallJsonG(self, "shee"), 1);
   terminateO(self);
 
 }
 
 
 void countCharSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "shee");
 
   // positive count
   ck_assert_int_eq(countCharSmallJsonG(self, 's'), 1);
   terminateO(self);
 
 }
 
 
 void countSmallStringSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "sheepy");
   smallStringt *string = allocSmallString("shee");
 
   // positive count
   ck_assert_int_eq(countSmallStringSmallJsonG(self, string), 1);
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void countJsonSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "sheepy");
   smallJsont *string = allocSmallJson();
 
   // positive count
   setTopSO(string, "shee");
   ck_assert_int_eq(countJsonSmallJsonG(self, string), 1);
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icStartsWithSSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "shee");
 
   ck_assert(icStartsWithSSmallJsonG(self, "SH"));
   terminateO(self);
 
 }
 
 
 void icStartsWithCharSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "shee");
 
   ck_assert(icStartsWithCharSmallJsonG(self, 'S'));
   terminateO(self);
 
 }
 
 
 void icStartsWithSmallStringSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "shee");
   smallStringt *string = allocSmallString("SH");
 
   ck_assert(icStartsWithSmallStringSmallJsonG(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icStartsWithJsonSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "shee");
   smallJsont *string = allocSmallJson();
 
   setTopSO(string, "SH");
   ck_assert(icStartsWithJsonSmallJsonG(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icEndsWithSSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "sheepy");
   ck_assert(icEndsWithSSmallJsonG(self, "EEPY"));
   terminateO(self);
 
 }
 
 
 void icEndsWithCharSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "shee");
 
   ck_assert(icEndsWithCharSmallJsonG(self, 'E'));
   terminateO(self);
 
 }
 
 
 void icEndsWithSmallStringSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "sheepy");
   smallStringt *string = allocSmallString("EEPY");
 
   ck_assert(icEndsWithSmallStringSmallJsonG(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icEndsWithJsonSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "sheepy");
   smallJsont *string = allocSmallJson();
 
   setTopSO(string, "EEPY");
   ck_assert(icEndsWithJsonSmallJsonG(self, string));
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icCountSSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "sheepy");
 
   ck_assert_int_eq(icCountSSmallJsonG(self, "SH"), 1);
   terminateO(self);
 
 }
 
 
 void icCountCharSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "shee");
 
   ck_assert_int_eq(icCountCharSmallJsonG(self, 'S'), 1);
   terminateO(self);
 
 }
 
 
 void icCountSmallStringSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "sheepy");
   smallStringt *string = allocSmallString("SHEE");
 
   ck_assert_int_eq(icCountSmallStringSmallJsonG(self, string), 1);
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void icCountJsonSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "sheepy");
   smallJsont *string = allocSmallJson();
 
   setTopSO(string, "SH");
   ck_assert_int_eq(icCountJsonSmallJsonG(self, string), 1);
   terminateO(string);
   terminateO(self);
 
 }
 
 
 void isNumberSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "-12.3");
   ck_assert(isNumberSmallJsonG(self));
   terminateO(self);
 
 }
 
 
 void isIntSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "-123");
   ck_assert(isIntSmallJsonG(self));
   terminateO(self);
 
 }
 
 
 void parseIntSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "123sheepy");
   ck_assert_int_eq(parseIntSmallJsonG(self), 123);
   terminateO(self);
 
 }
 
 
 void parseDoubleSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "123.2sheepy");
   ck_assert_int_eq(parseDoubleSmallJsonG(self), 123);
   terminateO(self);
 
 }
 
 
 void intToSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = intToSmallJsonG(self, 123);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "123");
   free(s);
   terminateO(self);
 
 }
 
 
 void doubleToSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = doubleToSmallJsonG(self, 123.4);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "1.234000e+02");
   free(s);
   terminateO(self);
 
 }
 
 
 void lenSmallJsonGT(void) {
 
   size_t r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushInt(self, 1);
   r = lenSmallJsonG(self);
   ck_assert_int_eq(r, 1);
   terminateO(self);
 
 }
 
 
 void upperSmallJsonGT(void) {
 
   smallJsont*    r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "sheepy");
 
   // string
   r = upperSmallJsonG(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "SHEEPY");
   free(s);
   terminateO(self);
 
 }
 
 
 void lowerSmallJsonGT(void) {
 
   smallJsont*    r;
   smallJsont *self = allocG(rtSmallJsont);
   setTopSO(self, "SHeePY");
 
   // string
   r = lowerSmallJsonG(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "sheepy");
   free(s);
   terminateO(self);
 
 }
 
 
 void trimSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushInt(self, 1);
   delElemIndexO(self, 0);
   r = trimSmallJsonG(self);
   ck_assert_ptr_ne(r, null);
   ck_assert_int_eq(lenSmallJsonG(self), 0);
   terminateO(self);
 
 }
 
 
 void lTrimSmallJsonGT(void) {
 
   smallJsont*    r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "  SHeePY");
   r = lTrimSmallJsonG(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "SHeePY");
   free(s);
   terminateO(self);
 
 }
 
 
 void rTrimSmallJsonGT(void) {
 
   smallJsont*    r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "SHeePY	");
   r = rTrimSmallJsonG(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "SHeePY");
   free(s);
   terminateO(self);
 
 }
 
 
 void compactSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushUndefined(self);
   //  null element
   self->f->pushUndefined(self);
   delElemIndexO(self, 1);
   self->f->pushBool(self, true);
   createSmallContainer(c);
   self->f->pushSmallContainer(self, &c);
   //  empty dict
   createSmallDict(d);
   self->f->pushDict(self, &d);
   resetO(&d);
   (&d)->f->setInt(&d, "a", 1);
   self->f->pushDict(self, &d);
   self->f->pushDouble(self, 2);
   self->f->pushInt(self, 5);
   self->f->pushS(self, "   ");
   self->f->pushS(self, "asd");
   //  empty Array
   createSmallArray(a);
   self->f->pushArray(self, &a);
   resetO(&a);
   (&a)->f->pushInt(&a, 1);
   self->f->pushArray(self, &a);
   //  empty bytes
   createSmallBytes(b);
   self->f->pushSmallBytes(self, &b);
   smallBytest *B = allocSmallBytes("asd", 4);
   self->f->pushNFreeSmallBytes(self, B);
   r = compactSmallJsonG(self);
   ck_assert_ptr_ne(r, NULL);
   ck_assert_int_eq(lenO(r), 8);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[true,\"<data container>\",{\"a\":1},2.000000e+00,5,\"asd\",[1],[0x61,0x73,0x64,0x00]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void emptySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushInt(self, 1);
   r = emptySmallJsonG(self);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(self);
 
 }
 
 
 void isEmptySmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = isEmptySmallJsonG(self);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void isBlankSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   r = isBlankSmallJsonG(self);
   ck_assert(r);
   terminateO(self);
 
 }
 
 
 void joinSmallJsonGT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushS(self, "a");
   self->f->pushS(self, "b");
   r = joinSmallJsonG(self, "|");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "a|b");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void joinCharSmallJsonGT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
 
   self->f->pushS(self, "a");
   self->f->pushS(self, "b");
   r = joinCharSmallJsonG(self, '|');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "a|b");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void joinSmallJsonSmallJsonGT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
 
   r = joinSmallJsonSmallJsonG(self, null);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void joinSmallStringSmallJsonGT(void) {
 
   smallStringt* r;
   smallJsont *self = allocSmallJson();
 
   r = joinSmallStringSmallJsonG(self, null);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void joinSSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   r = joinSSmallJsonG(self, null);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void joinCharSSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   r = joinCharSSmallJsonG(self, '#');
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void joinSmallJsonSSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   r = joinSmallJsonSSmallJsonG(self, null);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void joinSmallStringSSmallJsonGT(void) {
 
   char* r;
   smallJsont *self = allocSmallJson();
 
   r = joinSmallStringSSmallJsonG(self, null);
   ck_assert_ptr_eq(r, null);
   terminateO(self);
 
 }
 
 
 void splitSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/two");
   r = splitSmallJsonG(self, "/");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"two\"]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void splitCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/two");
   r = splitCharSmallJsonG(self, '/');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"two\"]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void splitSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   smallJsont *delim  = allocSmallJson();
 
   setTopSO(self, "one/two");
   setTopSO(delim, "/");
   r = splitSmallJsonSmallJsonG(self, delim);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void splitSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   smallStringt *delim = allocSmallString("/");
 
   setTopSO(self, "one/two");
   r = splitSmallStringSmallJsonG(self, delim);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void splitSSmallJsonGT(void) {
 
   char** r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/two");
   r = splitSSmallJsonG(self, "/");
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "two");
   listFreeS(r);
   terminateO(self);
 
 }
 
 
 void splitCharSSmallJsonGT(void) {
 
   char** r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/two");
   r = splitCharSSmallJsonG(self, '/');
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "two");
   listFreeS(r);
   terminateO(self);
 
 }
 
 
 void splitSmallJsonSSmallJsonGT(void) {
 
   char** r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallJsont *delim = allocSmallJson();
 
   setTopSO(self, "one/two");
   setTopSO(delim, "/");
   r = splitSmallJsonSSmallJsonG(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "two");
   listFreeS(r);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void splitSmallStringSSmallJsonGT(void) {
 
   char** r;
   smallJsont *self    = allocG(rtSmallJsont);
   smallStringt *delim = allocSmallString("/");
 
   setTopSO(self, "one/two");
   r = splitSmallStringSSmallJsonG(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "two");
   listFreeS(r);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void extractSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/two|");
   r = extractSmallJsonG(self, "/", "|");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void extractCharSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/two|");
   r = extractCharSSmallJsonG(self, '/', "|");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void extractSCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/two|");
   r = extractSCharSmallJsonG(self, "/", '|');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void extractCharCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/two|");
   r = extractCharCharSmallJsonG(self, '/', '|');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void extractSmallJsonSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallJsont* delim1 = allocSmallJson();
   smallJsont* delim2 = allocSmallJson();
 
   setTopSO(self, "one/two|");
   setTopSO(delim1, "/");
   setTopSO(delim2, "|");
   r = extractSmallJsonSmallJsonSmallJsonG(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void extractSmallJsonSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallJsont* delim1   = allocSmallJson();
   smallStringt* delim2 = allocSmallString("|");
 
   setTopSO(self, "one/two|");
   setTopSO(delim1, "/");
   r = extractSmallJsonSmallStringSmallJsonG(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void extractSmallJsonSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallJsont* delim1 = allocSmallJson();
 
   setTopSO(self, "one/two|");
   setTopSO(delim1, "/");
   r = extractSmallJsonSSmallJsonG(self, delim1, "|");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void extractSmallJsonCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallJsont* delim1 = allocSmallJson();
 
   setTopSO(self, "one/two|");
   setTopSO(delim1, "/");
   r = extractSmallJsonCharSmallJsonG(self, delim1, '|');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void extractSmallStringSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt* delim1 = allocSmallString("/");
   smallJsont* delim2   = allocSmallJson();
 
   setTopSO(self, "one/two|");
   setTopSO(delim2, "|");
   r = extractSmallStringSmallJsonSmallJsonG(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void extractSmallStringSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt* delim1 = allocSmallString("/");
   smallStringt* delim2 = allocSmallString("|");
 
   setTopSO(self, "one/two|");
   r = extractSmallStringSmallStringSmallJsonG(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void extractSmallStringSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt* delim1 = allocSmallString("/");
 
   setTopSO(self, "one/two|");
   r = extractSmallStringSSmallJsonG(self, delim1, "|");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void extractSmallStringCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt* delim1 = allocSmallString("/");
 
   setTopSO(self, "one/two|");
   r = extractSmallStringCharSmallJsonG(self, delim1, '|');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void extractSSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallJsont* delim2 = allocSmallJson();
 
   setTopSO(self, "one/two|");
   setTopSO(delim2, "|");
   r = extractSSmallJsonSmallJsonG(self, "/", delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void extractSSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt* delim2 = allocSmallString("|");
 
   setTopSO(self, "one/two|");
   setValO(delim2, "|");
   r = extractSSmallStringSmallJsonG(self, "/", delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void extractCharSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallJsont* delim2 = allocSmallJson();
 
   setTopSO(self, "one/two|");
   setTopSO(delim2, "|");
   r = extractCharSmallJsonSmallJsonG(self, '/', delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void extractCharSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt* delim2 = allocSmallString("|");
 
   setTopSO(self, "one/two|");
   setValO(delim2, "|");
   r = extractCharSmallStringSmallJsonG(self, '/', delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icSplitSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/two");
   r = icSplitSmallJsonG(self, "/");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"two\"]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void icSplitCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/two");
   r = icSplitCharSmallJsonG(self, 'T');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one/\",\"wo\"]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void icSplitSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   smallJsont *delim  = allocSmallJson();
 
   setTopSO(self, "one/two");
   setTopSO(delim, "/");
   r = icSplitSmallJsonSmallJsonG(self, delim);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void icSplitSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   smallStringt *delim = allocSmallString("/");
 
   setTopSO(self, "one/two");
   r = icSplitSmallStringSmallJsonG(self, delim);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"one\",\"two\"]");
   free(s);
   terminateO(r);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void icSplitSSmallJsonGT(void) {
 
   char** r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/two");
   r = icSplitSSmallJsonG(self, "/");
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "two");
   listFreeS(r);
   terminateO(self);
 
 }
 
 
 void icSplitCharSSmallJsonGT(void) {
 
   char** r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/two");
   r = icSplitCharSSmallJsonG(self, 'T');
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one/");
   ck_assert_str_eq(r[1], "wo");
   listFreeS(r);
   terminateO(self);
 
 }
 
 
 void icSplitSmallJsonSSmallJsonGT(void) {
 
   char** r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallJsont *delim = allocSmallJson();
 
   setTopSO(self, "one/two");
   setTopSO(delim, "/");
   r = icSplitSmallJsonSSmallJsonG(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "two");
   listFreeS(r);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void icSplitSmallStringSSmallJsonGT(void) {
 
   char** r;
   smallJsont *self    = allocG(rtSmallJsont);
   smallStringt *delim = allocSmallString("/");
 
   setTopSO(self, "one/two");
   r = icSplitSmallStringSSmallJsonG(self, delim);
   ck_assert_uint_eq(listLengthS(r),2);
   ck_assert_str_eq(r[0], "one");
   ck_assert_str_eq(r[1], "two");
   listFreeS(r);
   terminateO(delim);
   terminateO(self);
 
 }
 
 
 void icExtractSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/twos");
   r = icExtractSmallJsonG(self, "E", "S");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void icExtractCharSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/twos");
   r = icExtractCharSSmallJsonG(self, 'E', "S");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void icExtractSCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/twos");
   r = icExtractSCharSmallJsonG(self, "E", 'S');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void icExtractCharCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   setTopSO(self, "one/twos");
   r = icExtractCharCharSmallJsonG(self, 'E', 'S');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void icExtractSmallJsonSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallJsont* delim1 = allocSmallJson();
   smallJsont* delim2 = allocSmallJson();
 
   setTopSO(self, "one/twos");
   setTopSO(delim1, "E");
   setTopSO(delim2, "S");
   r = icExtractSmallJsonSmallJsonSmallJsonG(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icExtractSmallJsonSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallJsont* delim1   = allocSmallJson();
   smallStringt* delim2 = allocSmallString("S");
 
   setTopSO(self, "one/twos");
   setTopSO(delim1, "E");
   r = icExtractSmallJsonSmallStringSmallJsonG(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icExtractSmallJsonSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallJsont* delim1 = allocSmallJson();
 
   setTopSO(self, "one/twos");
   setTopSO(delim1, "E");
   r = icExtractSmallJsonSSmallJsonG(self, delim1, "S");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void icExtractSmallJsonCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallJsont* delim1 = allocSmallJson();
 
   setTopSO(self, "one/twos");
   setTopSO(delim1, "E");
   r = icExtractSmallJsonCharSmallJsonG(self, delim1, 'S');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void icExtractSmallStringSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt* delim1 = allocSmallString("E");
   smallJsont* delim2   = allocSmallJson();
 
   setTopSO(self, "one/twos");
   setTopSO(delim2, "S");
   r = icExtractSmallStringSmallJsonSmallJsonG(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icExtractSmallStringSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt* delim1 = allocSmallString("E");
   smallStringt* delim2 = allocSmallString("|");
 
   setTopSO(self, "one/twos");
   setValO(delim2, "S");
   r = icExtractSmallStringSmallStringSmallJsonG(self, delim1, delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icExtractSmallStringSSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt* delim1 = allocSmallString("E");
 
   setTopSO(self, "one/twos");
   r = icExtractSmallStringSSmallJsonG(self, delim1, "S");
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void icExtractSmallStringCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt* delim1 = allocSmallString("E");
 
   setTopSO(self, "one/twos");
   r = icExtractSmallStringCharSmallJsonG(self, delim1, 'S');
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(delim1);
   terminateO(self);
 
 }
 
 
 void icExtractSSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallJsont* delim2 = allocSmallJson();
 
   setTopSO(self, "one/twos");
   setTopSO(delim2, "S");
   r = icExtractSSmallJsonSmallJsonG(self, "E", delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icExtractSSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt* delim2 = allocSmallString("|");
 
   setTopSO(self, "one/twos");
   setValO(delim2, "S");
   r = icExtractSSmallStringSmallJsonG(self, "E", delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icExtractCharSmallJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   smallJsont* delim2 = allocSmallJson();
 
   setTopSO(self, "one/twos");
   setTopSO(delim2, "S");
   r = icExtractCharSmallJsonSmallJsonG(self, 'E', delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void icExtractCharSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallStringt* delim2 = allocSmallString("|");
 
   setTopSO(self, "one/twos");
   setValO(delim2, "S");
   r = icExtractCharSmallStringSmallJsonG(self, 'E', delim2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"/two\"]");
   free(s);
   terminateO(r);
   terminateO(delim2);
   terminateO(self);
 
 }
 
 
 void zipSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallArrayt *array1 = allocSmallArray();
   smallArrayt *array2 = allocSmallArray();
 
   // zip arrays
   // add an element to self
   // array1 has 2 elements
   // array2 has 3 elements
   // only 2 elements are zipped
   self->f->pushS(self, "qwe");
   array1->f->pushS(array1, "a");
   array1->f->pushS(array1, "b");
   array2->f->pushInt(array2, 1);
   array2->f->pushInt(array2, 2);
   array2->f->pushInt(array2, 3);
   r = zipSmallJsonG(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",1],[\"b\",2]]");
   free(s);
   //    delete the element not in self
   delElemO(array2, 2);
   terminateO(self);
   smashO(array1);
   smashO(array2);
 
 }
 
 
 void zipArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char** array1;
   smallArrayt *array2 = allocSmallArray();
 
   self->f->pushS(self, "qwe");
   array1  = listCreateS("a", "b");
   array2->f->pushS(array2, "1");
   array2->f->pushS(array2, "2");
   r = zipArraySmallJsonG(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   terminateO(self);
   free(array1);
   smashO(array2);
 
 }
 
 
 void zipCArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   const char* array1[] = {"a", "b", null};
   smallArrayt *array2  = allocSmallArray();
 
   self->f->pushS(self, "qwe");
   array2->f->pushS(array2, "1");
   array2->f->pushS(array2, "2");
   r = zipCArraySmallJsonG(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   terminateO(self);
   smashO(array2);
 
 }
 
 
 void zipCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *array1 = allocSmallArray();
   char** array2;
 
   self->f->pushS(self, "qwe");
   array1->f->pushS(array1, "a");
   array1->f->pushS(array1, "b");
   array2  = listCreateS("1", "2");
   r = zipCharSmallJsonG(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   terminateO(self);
   smashO(array1);
   free(array2);
 
 }
 
 
 void zipCCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   smallArrayt *array1  = allocSmallArray();
   const char* array2[] = {"1", "2", "3", null};
 
   self->f->pushS(self, "qwe");
   array1->f->pushS(array1, "a");
   array1->f->pushS(array1, "b");
   r = zipCCharSmallJsonG(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   terminateO(self);
   smashO(array1);
 
 }
 
 
 void zipArrayCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   char** array1;
   char** array2;
 
   self->f->pushS(self, "qwe");
   array1  = listCreateS("a", "b");
   array2  = listCreateS("1", "2");
   r = zipArrayCharSmallJsonG(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   terminateO(self);
   free(array1);
   free(array2);
 
 }
 
 
 void zipArrayCCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   char** array1;
   const char* array2[] = {"1", "2", "3", null};
 
   self->f->pushS(self, "qwe");
   array1  = listCreateS("a", "b");
   r = zipArrayCCharSmallJsonG(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   terminateO(self);
   free(array1);
 
 }
 
 
 void zipCArrayCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   const char* array1[] = {"a", "b", null};
   char** array2;
 
   self->f->pushS(self, "qwe");
   array2  = listCreateS("1", "2");
   r = zipCArrayCharSmallJsonG(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   terminateO(self);
   free(array2);
 
 }
 
 
 void zipCArrayCCharSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   const char* array1[] = {"a", "b", null};
   const char* array2[] = {"1", "2", "3", null};
 
   self->f->pushS(self, "qwe");
   r = zipCArrayCCharSmallJsonG(self, array1, array2);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"qwe\",[\"a\",\"1\"],[\"b\",\"2\"]]");
   free(s);
   terminateO(self);
 
 }
 
 
 void zipJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallJsont *keys   = allocSmallJson();
   smallJsont *values = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys->f->pushS(keys, "a");
   keys->f->pushS(keys, "b");
   keys->f->pushS(keys, "c");
   values->f->pushInt(values, 1);
   values->f->pushInt(values, 2);
   r = zipJsonSmallJsonG(self, keys, values);
   terminateO(keys);
   smashO(values);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":1,\"b\":2}");
   free(s);
   terminateO(self);
 
 }
 
 
 void zipJsonSmallArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self    = allocSmallJson();
   smallJsont *keys    = allocSmallJson();
   smallArrayt *values = allocSmallArray();
 
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys->f->pushS(keys, "a");
   keys->f->pushS(keys, "b");
   keys->f->pushS(keys, "c");
   values->f->pushInt(values, 1);
   values->f->pushInt(values, 2);
   r = zipJsonSmallArraySmallJsonG(self, keys, values);
   terminateO(keys);
   smashO(values);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":1,\"b\":2}");
   free(s);
   terminateO(self);
 
 }
 
 
 void zipJsonArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
   smallJsont *keys = allocSmallJson();
   char **values;
 
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys->f->pushS(keys, "a");
   keys->f->pushS(keys, "b");
   keys->f->pushS(keys, "c");
   values = listCreateS("1", "2");
   r = zipJsonArraySmallJsonG(self, keys, values);
   terminateO(keys);
   listFreeS(values);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":\"1\",\"b\":\"2\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void zipJsonCArraySmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallJsont *keys     = allocSmallJson();
   const char* values[] = {"1", "2", null};
 
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys->f->pushS(keys, "a");
   keys->f->pushS(keys, "b");
   keys->f->pushS(keys, "c");
   r = zipJsonCArraySmallJsonG(self, keys, values);
   terminateO(keys);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":\"1\",\"b\":\"2\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void zipSmallArrayJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   smallArrayt *keys  = allocSmallArray();
   smallJsont *values = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys->f->pushS(keys, "a");
   keys->f->pushS(keys, "b");
   keys->f->pushS(keys, "c");
   values->f->pushInt(values, 1);
   values->f->pushInt(values, 2);
   r = zipSmallArrayJsonSmallJsonG(self, keys, values);
   terminateO(keys);
   smashO(values);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":1,\"b\":2}");
   free(s);
   terminateO(self);
 
 }
 
 
 void zipArrayJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocSmallJson();
   char** keys;
   smallJsont *values = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   keys = listCreateS("a", "b", "c");
   values->f->pushInt(values, 1);
   values->f->pushInt(values, 2);
   r = zipArrayJsonSmallJsonG(self, keys, values);
   listFreeS(keys);
   smashO(values);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":1,\"b\":2}");
   free(s);
   terminateO(self);
 
 }
 
 
 void zipCArrayJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self   = allocG(rtSmallJsont);
   const char* keys[] = {"a", "b", "c", null};
   smallJsont *values = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   // 3 elements in keys
   // 2 elements in values
   // only 2 key/values are zipped
   values->f->pushInt(values, 1);
   values->f->pushInt(values, 2);
   r = zipCArrayJsonSmallJsonG(self, keys, values);
   smashO(values);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"\":1,\"a\":1,\"b\":2}");
   free(s);
   terminateO(self);
 
 }
 
 
 void stringifySmallStringSmallJsonGT(void) {
 
   smallStringt* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   self->f->setS(self, "\\\\", "\\erw\\\"");
   r = stringifySmallStringSmallJsonG(self, 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   terminateO(r);
   ck_assert_str_eq(s, "{\n  \"\\\\\": \"\\\\erw\\\\\\\"\"\n}\n");
   free(s);
   terminateO(self);
 
 }
 
 
 void toYMLSmallStringSmallJsonGT(void) {
 
   smallStringt* r;
   smallJsont *self = allocG(rtSmallJsont);
 
   self->f->pushS(self, "qwe");
   r = toYMLSmallStringSmallJsonG(self, 2);
   ck_assert_ptr_ne(r, null);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "---\n  - qwe\n");
   free(s);
   terminateO(r);
   terminateO(self);
 
 }
 
 
 void parseSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
 
   r = parseSmallJsonG(self, "true");
   ck_assert(r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(self);
 
 }
 
 
 void parseSmallJsonSmallJsonGT(void) {
 
   bool r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallJsont *input = allocSmallJson();
 
   // non json string
   r = parseSmallJsonSmallJsonG(self, input);
   ck_assert(!r);
   // json string
   setTopSO(input, "true");
   r = parseSmallJsonSmallJsonG(self, input);
   ck_assert(r);
   terminateO(input);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(self);
 
 }
 
 
 void parseSmallStringSmallJsonGT(void) {
 
   bool r;
   smallJsont *self    = allocG(rtSmallJsont);
   smallStringt *input = allocSmallString("true");
 
   // string
   r = parseSmallStringSmallJsonG(self, input);
   ck_assert(r);
   terminateO(input);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(self);
 
 }
 
 
 void parseYMLSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
 
   //r = parseYMLSmallJsonG(self);
   r = parseYMLSmallJsonG(self, "---\n - qwe");
   ck_assert(r);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void parseYMLSmallJsonSmallJsonGT(void) {
 
   bool r;
   smallJsont *self  = allocG(rtSmallJsont);
   smallJsont *input = allocSmallJson();
 
   // non json string
   r = parseYMLSmallJsonSmallJsonG(self, input);
   ck_assert(!r);
   // json string
   setTopSO(input, "---\n - qwe");
   r = parseYMLSmallJsonSmallJsonG(self, input);
   ck_assert(r);
   terminateO(input);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void parseYMLSmallStringSmallJsonGT(void) {
 
   bool r;
   smallJsont *self    = allocG(rtSmallJsont);
   smallStringt *input = allocSmallString("---\n - qwe");
 
   // string
   r = parseYMLSmallStringSmallJsonG(self, input);
   ck_assert(r);
   terminateO(input);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "[\"qwe\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void logSmallJsonGT(void) {
 
   smallJsont *self = allocSmallJson();
 
   self->f->pushS(self, "qwe");
   self->f->pushS(self, "asd");
   delElemIndexO(self, 0);
   logSmallJsonG(self);
   terminateO(self);
 
 }
 
 
 void readFileSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
 
   self->f->setS(self, "key", "value");
   writeFileO(self, "read.JSON");
   freeO(self);
   ck_assert_ptr_ne(readFileSmallJsonG(self, "read.JSON"), null);
   rmAll("read.JSON");
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"key\":\"value\"}");
   free(s);
   terminateO(self);
 
 }
 
 
 void readFileSmallStringSmallJsonGT(void) {
 
   smallJsont *self = allocG(rtSmallJsont);
   smallStringt *filePath = allocSmallString("read.json");
 
   self->f->setS(self, "key", "value");
   writeFileO(self, "read.json");
   freeO(self);
   ck_assert_ptr_ne(readFileSmallStringSmallJsonG(self, filePath), null);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"key\":\"value\"}");
   free(s);
   rmAll("read.json");
   terminateO(filePath);
   terminateO(self);
 
 }
 
 
 void readFileJsonSmallJsonGT(void) {
 
   smallJsont *self     = allocG(rtSmallJsont);
   smallJsont *filePath = allocSmallJson();
 
   setTopSO(filePath, "read.json");
   self->f->setS(self, "key", "value");
   writeFileO(self, "read.json");
   freeO(self);
   ck_assert_ptr_ne(readFileJsonSmallJsonG(self, filePath), null);
   char *s = toStringO(self);
   ck_assert_str_eq(s, "{\"key\":\"value\"}");
   free(s);
   rmAll("read.json");
   terminateO(filePath);
   terminateO(self);
 
 }
 
 
 void readStreamSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   FILE *fp;
 
   // stream
   fp = fopen("file.json", "r");
   r = readStreamSmallJsonG(self, fp);
   fclose(fp);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "{\"dasd\":\"asd\",\"asd\":234,\"dict\":{\"array\":[1,1],\"asd\":true,\"float\":3.434000e+01},\"bool\":false,\"zzz\":null}");
   free(s);
   terminateO(self);
 
 }
 
 
 void writeFileSmallJsonGT(void) {
 
   int r;
   smallJsont *self = allocG(rtSmallJsont);
 
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   r = writeFileSmallJsonG(self, "smallDictFile.json");
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.json"));
   char *s = readFileToS("smallDictFile.json");
   ck_assert_str_eq(s, "{\n  \"\": 1,\n  \"b\": 2\n}\n");
   free(s);
   rmAll("smallDictFile.json");
   terminateO(self);
 
 }
 
 
 void writeFileSmallStringSmallJsonGT(void) {
 
   bool        r;
   smallJsont *self = allocSmallJson();
   smallStringt *filePath = allocSmallString("smallDictFile.json");
 
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   r = writeFileSmallStringSmallJsonG(self, filePath);
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.json"));
   char *s = readFileToS("smallDictFile.json");
   ck_assert_str_eq(s, "{\n  \"\": 1,\n  \"b\": 2\n}\n");
   free(s);
   rmAll("smallDictFile.json");
   terminateO(filePath);
   terminateO(self);
 
 }
 
 
 void writeFileJsonSmallJsonGT(void) {
 
   bool        r;
   smallJsont *self     = allocSmallJson();
   smallJsont *filePath = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   setTopSO(filePath, "smallDictFile.json");
   r = writeFileJsonSmallJsonG(self, filePath);
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.json"));
   char *s = readFileToS("smallDictFile.json");
   ck_assert_str_eq(s, "{\n  \"\": 1,\n  \"b\": 2\n}\n");
   free(s);
   rmAll("smallDictFile.json");
   terminateO(filePath);
   terminateO(self);
 
 }
 
 
 void writeStreamSmallJsonGT(void) {
 
   int r;
   smallJsont *self = allocG(rtSmallJsont);
   FILE *fp;
 
   // write textOutTest.null
   fp = fopen("file.json", "r");
   smallJsont *r2 = readStreamO(self, fp);
   fclose(fp);
   ck_assert_ptr_ne(r2, NULL);
   fp = fopen("outTest.json", "w");
   r = writeStreamSmallJsonG(self, fp);
   ck_assert(r);
   fclose(fp);
     // check textOutTest.null
   fp = fopen("outTest.json", "r");
   r2 = readStreamO(self, fp);
   fclose(fp);
   ck_assert_ptr_ne(r2, NULL);
   char *s = toStringO(r2);
   ck_assert_str_eq(s, "{\"dasd\":\"asd\",\"asd\":234,\"dict\":{\"array\":[1,1],\"asd\":true,\"float\":3.434000e+01},\"bool\":false,\"zzz\":null}");
   free(s);
   rmAll("outTest.json");
   terminateO(self);
 
 }
 
 
 void appendFileSmallJsonGT(void) {
 
   bool        r;
   smallJsont *self = allocSmallJson();
 
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   writeFileS("smallDictFile.json", "-");
   r = appendFileSmallJsonG(self, "smallDictFile.json");
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.json"));
   char *s = readFileToS("smallDictFile.json");
   ck_assert_str_eq(s, "-{\n  \"\": 1,\n  \"b\": 2\n}\n");
   free(s);
   rmAll("smallDictFile.json");
   terminateO(self);
 
 }
 
 
 void appendFileSmallStringSmallJsonGT(void) {
 
   bool        r;
   smallJsont *self       = allocSmallJson();
   smallStringt *filePath = allocSmallString("smallDictFile.json");
 
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   writeFileS("smallDictFile.json", "-");
   r = appendFileSmallStringSmallJsonG(self, filePath);
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.json"));
   char *s = readFileToS("smallDictFile.json");
   ck_assert_str_eq(s, "-{\n  \"\": 1,\n  \"b\": 2\n}\n");
   free(s);
   rmAll("smallDictFile.json");
   terminateO(filePath);
   terminateO(self);
 
 }
 
 
 void appendFileJsonSmallJsonGT(void) {
 
   int r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallJsont *filePath = allocSmallJson();
 
   setTopSO(filePath, "smallDictFile.json");
   self->f->setInt(self, "", 1);
   self->f->setInt(self, "b", 2);
   writeFileS("smallDictFile.json", "-");
   r = appendFileJsonSmallJsonG(self, filePath);
   ck_assert(r);
   ck_assert(fileExists("smallDictFile.json"));
   char *s = readFileToS("smallDictFile.json");
   ck_assert_str_eq(s, "-{\n  \"\": 1,\n  \"b\": 2\n}\n");
   free(s);
   rmAll("smallDictFile.json");
   terminateO(filePath);
   terminateO(self);
 
 }
 
 
 void readTextSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocSmallJson();
 
   r = readTextSmallJsonG(self, "../textTest.null");
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void readTextSmallStringSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self       = allocSmallJson();
   smallStringt *filePath = allocSmallString("");
 
   // text
   setValO(filePath, "../textTest.null");
   r = readTextSmallStringSmallJsonG(self, filePath);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   terminateO(self);
   terminateO(filePath);
 
 }
 
 
 void readTextJsonSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallJsont *filePath = allocSmallJson();
 
   // text
   setTopSO(filePath, "../textTest.null");
   r = readTextJsonSmallJsonG(self, filePath);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   terminateO(filePath);
   terminateO(self);
 
 }
 
 
 void readTextStreamSmallJsonGT(void) {
 
   smallJsont* r;
   smallJsont *self = allocG(rtSmallJsont);
   FILE *fp;
 
   fp = fopen("../textTest.null", "r");
   r = readTextStreamSmallJsonG(self, fp);
   fclose(fp);
   ck_assert_ptr_ne(r, NULL);
   char *s = toStringO(r);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   terminateO(self);
 
 }
 
 
 void writeTextSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocSmallJson();
 
   smallJsont *r2 = readTextO(self, "../textTest.null");
   ck_assert_ptr_ne(r2, NULL);
   r = writeTextSmallJsonG(self, "../textOutTest.null");
   ck_assert(r);
     // check textOutTest.null
   emptyO(self);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   char *s = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   rmAll("../textOutTest.null");
   terminateO(self);
 
 }
 
 
 void writeTextSmallStringSmallJsonGT(void) {
 
   bool r;
   smallJsont *self      = allocSmallJson();
   smallStringt *filePath = allocSmallString("");
 
   // write textOutTest.null
   smallJsont *r2 = readTextO(self, "../textTest.null");
   ck_assert_ptr_ne(r2, NULL);
   setValO(filePath, "../textOutTest.null");
   r = writeTextSmallStringSmallJsonG(self, filePath);
   ck_assert(r);
     // check textOutTest.null
   emptyO(self);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   char *s = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   rmAll("../textOutTest.null");
   terminateO(self);
   terminateO(filePath);
 
 }
 
 
 void writeTextJsonSmallJsonGT(void) {
 
   bool r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallJsont *filePath = allocSmallJson();
 
   // write textOutTest.null
   smallJsont *r2 = readTextO(self, "../textTest.null");
   ck_assert_ptr_ne(r2, NULL);
   freeO(filePath);
   setTopSO(filePath, "../textOutTest.null");
   r = writeTextJsonSmallJsonG(self, filePath);
   ck_assert(r);
     // check textOutTest.null
   emptyO(self);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   char *s = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\"]");
   free(s);
   rmAll("../textOutTest.null");
   terminateO(filePath);
   terminateO(self);
 
 }
 
 
 void writeTextStreamSmallJsonGT(void) {
 
   bool r;
   smallJsont *self = allocG(rtSmallJsont);
   FILE *fp;
 
   // non json array
   fp = fopen("../textTest.null", "r");
   r = writeTextStreamSmallJsonG(self, fp);
   ck_assert(!r);
   // write textOutTest.null
   smallJsont *r2 = self->f->readTextStream(self, fp);
   fclose(fp);
   ck_assert_ptr_ne(r2, NULL);
   fp = fopen("../textOutTest.null", "w");
   r = writeTextStreamSmallJsonG(self, fp);
   fclose(fp);
   ck_assert(r);
   rmAll("../textOutTest.null");
   terminateO(self);
 
 }
 
 
 void appendTextSmallStringSmallJsonGT(void) {
 
   bool r;
   smallJsont *self       = allocSmallJson();
   smallStringt *filePath = allocSmallString("");
 
   // append to textOutTest.null
   smallJsont *r2 = readTextO(self, "../textTest.null");
   ck_assert_ptr_ne(r2, NULL);
   r = writeTextO(self, "../textOutTest.null");
   ck_assert(r);
   emptyO(self);
   self->f->pushS(self, "A");
   self->f->pushS(self, "B");
   setValO(filePath, "../textOutTest.null");
   r = appendTextSmallStringSmallJsonG(self, filePath);
     // check textOutTest.null
   emptyO(self);
   r2 = readTextO(self, "../textOutTest.null");
   char *s = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]");
   free(s);
   terminateO(self);
   terminateO(filePath);
 
 }
 
 
 void appendTextJsonSmallJsonGT(void) {
 
   bool r;
   smallJsont *self     = allocG(rtSmallJsont);
   smallJsont *filePath = allocSmallJson();
 
   // append to textOutTest.null
   smallJsont *r2 = readTextO(self, "../textTest.null");
   ck_assert_ptr_ne(r2, NULL);
   r = writeTextO(self, "../textOutTest.null");
   ck_assert(r);
   emptyO(self);
   self->f->pushS(self, "A");
   self->f->pushS(self, "B");
   freeO(filePath);
   setTopSO(filePath, "../textOutTest.null");
   r = appendTextJsonSmallJsonG(self, filePath);
     // check textOutTest.null
   emptyO(self);
   r2 = readTextO(self, "../textOutTest.null");
   ck_assert_ptr_ne(r2, NULL);
   char *s = toStringO(r2);
   ck_assert_str_eq(s, "[\"LINE 1\",\"ANOTHER line\",\"A\",\"B\"]");
   free(s);
   rmAll("../textOutTest.null");
   terminateO(filePath);
   terminateO(self);
 
 }
 
 
 void cSmallJsonT(void) {
 
   // local object
   createSmallJson(obj);
   ck_assert_str_eq(obj.type, "smallJson");
   // object
   createAllocateSmallJson(obj2);
   ck_assert_str_eq(obj2->type, "smallJson");
   // toString
   char *s = obj2->f->toString(obj2);
   ck_assert_str_eq(s, "{}");
   free(s);
   createAllocateSmallInt(oInt);
   oInt->f->set(oInt, 123);
   obj2->f->set(obj2, "int", (baset *) oInt);
   finishO(oInt);
   initiateAllocateSmallInt(&oInt);
   oInt->f->set(oInt, 123);
   obj2->f->set(obj2, "int2", (baset *) oInt);
   finishO(oInt);
     // no effect - no push to dictionary
   initiateAllocateSmallInt(&oInt);
   obj2->f->push(obj2, (baset *) oInt);
   finishO(oInt);
   s = obj2->f->toString(obj2);
   ck_assert_str_eq(s, "{\"int\":123,\"int2\":123}");
   free(s);
   terminateO(obj2);
   initiateAllocateSmallJson(&obj2);
   smallJsont *r = obj2->f->push(obj2, null);
   ck_assert_ptr_eq(r, null);
   createAllocateSmallInt(oInt2);
   oInt2->f->set(oInt2, 123);
   obj2->f->push(obj2, (baset *) oInt2);
   finishO(oInt2);
   initiateAllocateSmallInt(&oInt2);
   oInt2->f->set(oInt2, 123);
   obj2->f->push(obj2, (baset *) oInt2);
   finishO(oInt2);
     // no effect - no set with key to array
   initiateAllocateSmallInt(&oInt2);
   obj2->f->set(obj2, "noEffect", (baset *) oInt2);
   finishO(oInt2);
   s = obj2->f->toString(obj2);
   ck_assert_str_eq(s, "[123,123]");
   free(s);
   // duplicate
   smallJsont *o;
   o = obj2->f->duplicate(obj2);
   s = toStringO(o);
   ck_assert_str_eq(s, "[123,123]");
   free(s);
   terminateO(o);
   terminateO(obj2);
   initiateAllocateSmallJson(&obj2);
   createAllocateSmallInt(oInt3);
   oInt3->f->set(oInt3, 123);
   obj2->f->set(obj2, "int", (baset *) oInt3);
   finishO(oInt3);
   o = obj2->f->duplicate(obj2);
   s = toStringO(o);
   ck_assert_str_eq(s, "{\"int\":123}");
   free(s);
   terminateO(o);
   // dispose
     // array
   initiateAllocateSmallJson(&o);
   initiateAllocateSmallInt(&oInt);
   oInt->f->set(oInt, 123);
   o->f->push(o, (baset*)oInt);
   finishO(oInt);
   ck_assert_uint_eq(o->topA->count, 1);
   smallt *i = sArrayGetTiny(o->topA, 0);
   o->f->dispose(o);
   ck_assert_ptr_eq(o->topA, NULL);
   sFree(i);
   terminateO(o);
     // dictionary
   initiateAllocateSmallJson(&o);
   initiateAllocateSmallInt(&oInt);
   oInt->f->set(oInt, 123);
   o->f->set(o, "in", (baset*)oInt);
   finishO(oInt);
   ck_assert_uint_eq(o->top->count, 1);
   smallt *data = o->top->elements.data;
   sFree(data);
   o->f->dispose(o);
   ck_assert_ptr_eq(o->top, NULL);
   terminateO(o);
   // smash
   initiateAllocateSmallJson(&o);
     // array
   initiateAllocateSmallInt(&oInt);
   oInt->f->set(oInt, 123);
   o->f->push(o, (baset*)oInt);
   finishO(oInt);
   ck_assert_uint_eq(o->topA->count, 1);
   i = sArrayGetTiny(o->topA, 0);
   o->f->smash(&o);
   ck_assert_ptr_eq(o, NULL);
   sFree(i);
     // dict
   initiateAllocateSmallJson(&o);
   initiateAllocateSmallInt(&oInt);
   oInt->f->set(oInt, 123);
   o->f->set(o, "in", (baset*)oInt);
   finishO(oInt);
   ck_assert_uint_eq(o->top->count, 1);
   data = o->top->elements.data;
   sFree(data);
   o->f->smash(&o);
   ck_assert_ptr_eq(o, NULL);
   // setType*
   initiateAllocateSmallJson(&o);
   o->f->setTypeUndefined(o);
   ck_assert_str_eq(o->f->getTopType(o), "undefined");
   o->f->setTypeBool(o);
   ck_assert_str_eq(o->f->getTopType(o), "bool");
   o->f->setTypeDouble(o);
   ck_assert_str_eq(o->f->getTopType(o), "double");
   o->f->setTypeInt(o);
   ck_assert_str_eq(o->f->getTopType(o), "int");
   o->f->setTypeString(o);
   ck_assert_str_eq(o->f->getTopType(o), "string");
   o->f->setTypeDict(o);
   ck_assert_str_eq(o->f->getTopType(o), "dict");
   o->f->setTypeArray(o);
   ck_assert_str_eq(o->f->getTopType(o), "array");
   terminateO(o);
   // getTopTypeJson setTopJson getTopJson - undefined bool double int string
   baset *b;
   smallJsont *o2;
   initiateAllocateSmallJson(&o);
   ck_assert_ptr_eq(o->f->getTopType(o), NULL);
     // non json object
   createAllocateSmallContainer(jcontainer);
       // setTop
         // null value
   ck_assert_ptr_eq(o->f->setTop(o, null), null);
   o->f->setTop(o, (baset *)jcontainer);
   terminateO(jcontainer);
   ck_assert_ptr_eq(o->f->getTopType(o), NULL);
       // getTop
   b = o->f->getTop(o);
   ck_assert_ptr_eq(b, NULL);
     // undefined
   createAllocateUndefined(jUndef);
       // setTop
   o->f->setTop(o, (baset *)jUndef);
   finishO(jUndef);
       // getTopType
   ck_assert_str_eq(o->f->getTopType(o), "undefined");
       // getTop
   b = o->f->getTop(o);
   ck_assert_str_eq(b->type, "undefined");
   finishO(b);
       // duplicateO
   o2 = duplicateO(o);
       // toStringO
   s  = toStringO(o2);
   ck_assert_str_eq(s, "null");
   free(s);
       // stringify
   s = o->f->stringify(o,2);
   ck_assert_str_eq(s, "null");
   free(s);
       // toYML
   s = o->f->toYML(o,2);
   ck_assert_str_eq(s, "---\n  null");
   free(s);
       // smash
   o2->f->smash(&o2);
       // freeO
   freeO(o);
   ck_assert_ptr_eq(o->f->getTopType(o), NULL);
   terminateO(o);
     // cBool
   initiateAllocateSmallJson(&o);
   createAllocateSmallBool(jBool);
       // setTop
   o->f->setTop(o, (baset *)jBool);
   finishO(jBool);
       // getTopType
   ck_assert_str_eq(o->f->getTopType(o), "bool");
       // getTop
   b = o->f->getTop(o);
   ck_assert_str_eq(b->type, "smallBool");
   finishO(b);
       // duplicateO
   o2 = duplicateO(o);
       // toStringO
   s  = toStringO(o2);
   ck_assert_str_eq(s, "false");
   free(s);
       // stringify
   s = o->f->stringify(o,2);
   ck_assert_str_eq(s, "false");
   free(s);
       // toYML
   s = o->f->toYML(o,2);
   ck_assert_str_eq(s, "---\n  false");
   free(s);
       // smash
   o2->f->smash(&o2);
       // freeO
   freeO(o);
   ck_assert_ptr_eq(o->f->getTopType(o), NULL);
   terminateO(o);
     // cDouble
   initiateAllocateSmallJson(&o);
   createAllocateSmallDouble(jDouble);
       // setTop
   o->f->setTop(o, (baset *)jDouble);
   finishO(jDouble);
       // getTopType
   ck_assert_str_eq(o->f->getTopType(o), "double");
       // getTop
   b = o->f->getTop(o);
   ck_assert_str_eq(b->type, "smallDouble");
   finishO(b);
       // duplicateO
   o2 = duplicateO(o);
       // toStringO
   s  = toStringO(o2);
   ck_assert_str_eq(s, "0.000000e+00");
   free(s);
       // stringify
   s = o->f->stringify(o,2);
   ck_assert_str_eq(s, "0.000000e+00");
   free(s);
       // toYML
   s = o->f->toYML(o,2);
   ck_assert_str_eq(s, "---\n  0.000000e+00");
   free(s);
       // smash
   o2->f->smash(&o2);
       // freeO
   freeO(o);
   ck_assert_ptr_eq(o->f->getTopType(o), NULL);
   terminateO(o);
     // cInt
   initiateAllocateSmallJson(&o);
   createAllocateSmallInt(jInt);
       // setTop
   o->f->setTop(o, (baset *)jInt);
   finishO(jInt);
       // getTopType
   ck_assert_str_eq(o->f->getTopType(o), "int");
       // getTop
   b = o->f->getTop(o);
   ck_assert_str_eq(b->type, "smallInt");
   finishO(b);
       // duplicateO
   o2 = duplicateO(o);
       // toStringO
   s  = toStringO(o2);
   ck_assert_str_eq(s, "0");
   free(s);
       // stringify
   s = o->f->stringify(o,2);
   ck_assert_str_eq(s, "0");
   free(s);
       // toYML
   s = o->f->toYML(o,2);
   ck_assert_str_eq(s, "---\n  0");
   free(s);
       // smash
   o2->f->smash(&o2);
       // freeO
   freeO(o);
   ck_assert_ptr_eq(o->f->getTopType(o), NULL);
   terminateO(o);
     // string
   initiateAllocateSmallJson(&o);
   createAllocateSmallString(jString);
   jString->f->set(jString, "sheepy");
       // setTop
   o->f->setTop(o, (baset *)jString);
   finishO(jString);
       // getTopType
   ck_assert_str_eq(o->f->getTopType(o), "string");
       // getTop
   b = o->f->getTop(o);
   ck_assert_str_eq(b->type, "smallString");
   finishO(b);
       // duplicateO
   o2 = duplicateO(o);
       // toStringO
   s  = toStringO(o2);
   ck_assert_str_eq(s, "sheepy");
   free(s);
       // stringify
   s = o->f->stringify(o,2);
   ck_assert_str_eq(s, "\"sheepy\"");
   free(s);
       // toYML
   s = o->f->toYML(o,2);
   ck_assert_str_eq(s, "---\n  \"sheepy\"");
   free(s);
       // smash
   o2->f->smash(&o2);
       // freeO
   freeO(o);
   ck_assert_ptr_eq(o->f->getTopType(o), NULL);
   terminateO(o);
     // dict
   initiateAllocateSmallJson(&o);
   o->f->setS(o, "1", "2");
   createAllocateSmallDict(jdict);
       // setTop
         // start iteration before setTop to check if
         // iterElement is finished
   iterStartO(o);
         // set json type to SMALLJSON_IS_EMPTY because as of today
         // setTop only works when the object is empty
   o->topIsA = 0;
   o->f->setTop(o, (baset *)jdict);
   finishO(jdict);
       // getTopType
   ck_assert_str_eq(o->f->getTopType(o), "dict");
       // getTop
   b = o->f->getTop(o);
   ck_assert_str_eq(b->type, "smallDict");
   finishO(b);
       // duplicateO
   o2 = duplicateO(o);
       // toStringO
   s  = toStringO(o2);
   ck_assert_str_eq(s, "{}");
   free(s);
       // stringify
   s = o->f->stringify(o,2);
   ck_assert_str_eq(s, "{}\n");
   free(s);
       // toYML
   s = o->f->toYML(o,2);
   ck_assert_str_eq(s, "---\n  {}\n");
   free(s);
       // smash
   o2->f->smash(&o2);
       // freeO
   freeO(o);
   ck_assert_ptr_eq(o->f->getTopType(o), NULL);
   terminateO(o);
     // array
   initiateAllocateSmallJson(&o);
   createAllocateSmallArray(jArray);
       // setTop
   o->f->setTop(o, (baset *)jArray);
   finishO(jArray);
       // getTopType
   ck_assert_str_eq(o->f->getTopType(o), "array");
       // getTop
   b = o->f->getTop(o);
   ck_assert_str_eq(b->type, "smallArray");
   finishO(b);
       // duplicateO
   o2 = duplicateO(o);
       // toStringO
   s  = toStringO(o2);
   ck_assert_str_eq(s, "[]");
   free(s);
       // stringify
   s = o->f->stringify(o,2);
   ck_assert_str_eq(s, "[]\n");
   free(s);
       // toYML
   s = o->f->toYML(o,2);
   ck_assert_str_eq(s, "---\n  []\n");
   free(s);
       // smash
   o2->f->smash(&o2);
       // freeO
   freeO(o);
   ck_assert_ptr_eq(o->f->getTopType(o), NULL);
   terminateO(o);
   // get
   smallIntt *in = (smallIntt *) obj2->f->get(obj2, "int");
   ck_assert(in->value->value == 123);
   createAllocateSmallDict(oD2);
   smallIntt *in2 = duplicateO(in);
   oD2->f->set(oD2, "int", (baset *)in2);
   finishO(in2);
   in2 = duplicateO(in);
   oD2->f->set(oD2, "int2", (baset *)in2);
   finishO(in2);
   obj2->f->set(obj2, "dict", (baset *)oD2);
   finishO(oD2);
   createAllocateSmallArray(oTA2);
   in2 = duplicateO(in);
   oTA2->f->push(oTA2, (baset *)in2);
   finishO(in2);
   in2 = duplicateO(in);
   oTA2->f->push(oTA2, (baset *)in2);
   finishO(in2);
   smashO(in);
   obj2->f->set(obj2, "array", (baset *)oTA2);
   finishO(oTA2);
     // get dict element
   in = (smallIntt *) obj2->f->get(obj2, "\"dict\".\"int2\"");
   ck_assert(in->value->value == 123);
   smashO(in);
     // non existing element
   in = (smallIntt *) obj2->f->get(obj2, "\"dict\".\"void\"");
   ck_assert_ptr_eq(in, NULL);
     // missing " at the end
   in = (smallIntt *) obj2->f->get(obj2, "\"dict\".\"int2");
   ck_assert_ptr_eq(in, NULL);
     // get array element
   in = (smallIntt *) obj2->f->get(obj2, "\"array\"[0]");
   ck_assert(in->value->value == 123);
   smashO(in);
     // missing ] at the end
   in = (smallIntt *) obj2->f->get(obj2, "\"array\"[0");
   ck_assert_ptr_eq(in, NULL);
     // json array
   createAllocateSmallJson(json);
   createAllocateSmallInt(oInt4);
   oInt4->f->set(oInt4, 345);
   json->f->push(json, (baset *) oInt4);
   finishO(oInt4);
   in = (smallIntt *) json->f->get(json, "[0]");
   ck_assert(in->value->value == 345);
   smashO(in);
   // set get json path
   createSmallJson(jpath);
     // dict is top
   jpath.f->parse(&jpath, "{ \"a\": {\"a\": true}, \"b\": 234, \"c\": [\"qwe\",32]}");
       // get non existing element in 'c' array
   b = jpath.f->get(&jpath,"\"c\"[3]");
   ck_assert_ptr_eq(b, NULL);
   finishO(b);
       // dictionary keys should not be unescaped
   createSmallBool(ba);
   jpath.f->set(&jpath, "b\\\\", cBa(&ba));
   jBool = (smallBoolt*)jpath.f->get(&jpath,"b\\\\");
   ck_assert(jBool->value->value == false);
   finishO(jBool);
       // keys in json paths should be unescaped
   createSmallBool(bb);
   bb.f->set(&bb, true);
   jpath.f->set(&jpath, "\"b\\\\\"", (baset*)&bb);
   jBool = (smallBoolt*)jpath.f->get(&jpath,"\"b\\\\\"");
   ck_assert(jBool->value->value == true);
   finishO(jBool);
   freeO(&jpath);
     // array is top
     // get dict in dict
   jpath.f->parse(&jpath, "[1,{\"a\": {\"a\": true}, \"b\": 234, \"c\": [\"qwe\",32]}, [[11],22,33]]");
   b = jpath.f->get(&jpath,"[1].\"a\"");
   ck_assert_str_eq(b->type, "smallDict");
   finishO(b);
     // get bool in dict
   jBool = (smallBoolt*)jpath.f->get(&jpath,"[1]\"a\"\"a\"");
   ck_assert(jBool->value->value == true);
   finishO(jBool);
     // get array in array
   jArray = (smallArrayt*)jpath.f->get(&jpath,"[2][0]");
   ck_assert_str_eq(jArray->type, "smallArray");
   ck_assert_uint_eq(lenO(jArray), 1);
   finishG(jArray);
     // get element in array
   in = (smallIntt*)(jpath.f->get(&jpath,"[2][0][0]"));
   ck_assert_uint_eq(in->value->value, 11);
   finishG(in);
     // set element in array with negative index
   createSmallBool(be);
   jpath.f->set(&jpath, "[-1][0][0]", (baset*)&be);
     // get element in array with negative index
   jBool = (smallBoolt*)jpath.f->get(&jpath,"[-1][0][0]");
   ck_assert(jBool->value->value == false);
   finishG(jBool);
     // set new element in dict
   createSmallBool(b2);
   o2 = jpath.f->set(&jpath, "[1]\"a\"\"b\\\"\"", (baset*)&b2);
   ck_assert_ptr_ne(o2, NULL);
   jBool = (smallBoolt*)jpath.f->get(&jpath,"[1]\"a\"\"b\\\"\"");
   ck_assert(jBool->value->value == false);
   finishG(jBool);
   createSmallBool(b3);
   o2 = jpath.f->set(&jpath, "[1]\"a\"\"b\\\\\"", (baset*)&b3);
   ck_assert_ptr_ne(o2, NULL);
   jBool = (smallBoolt*)jpath.f->get(&jpath,"[1]\"a\"\"b\\\\\"");
   ck_assert(jBool->value->value == false);
   finishG(jBool);
     // escape key in json path
     // \\\""
   char *ks = jpath.f->makeKey(&jpath, "\\\\\\\"\"");
   ck_assert_str_eq(ks, "\"\\\\\\\\\\\\\\\"\\\"\"");
   createSmallBool(b4);
   iPrependS(&ks, "[1]");
   o2 = jpath.f->set(&jpath, ks, (baset*)&b4);
   ck_assert_ptr_ne(o2, NULL);
   jBool = (smallBoolt*)jpath.f->get(&jpath,ks);
   ck_assert(jBool->value->value == false);
   finishG(jBool);
   free(ks);
     // wrong path
   b = jpath.f->get(&jpath,"[3][0][0]");
   ck_assert_ptr_eq(b, NULL);
   finishG(b);
     // missing index
   b = jpath.f->get(&jpath,"[][0][0]");
   ck_assert_ptr_eq(b, NULL);
   finishG(b);
     // try to assign dictionary key to array, wrong
   createSmallBool(b0);
   o2 = jpath.f->set(&jpath, "[2][0]\"sdf\\\"", (baset*)&b0);
   ck_assert_ptr_eq(o2, NULL);
   freeO(&jpath);
   // len
   initiateAllocateSmallJson(&o);
   ck_assert_uint_eq(o->f->len(o), 0);
   o->f->setTypeUndefined(o);
   ck_assert_uint_eq(o->f->len(o), 1);
   o->f->setTypeBool(o);
   ck_assert_uint_eq(o->f->len(o), 1);
   o->f->setTypeDouble(o);
   ck_assert_uint_eq(o->f->len(o), 1);
   o->f->setTypeInt(o);
   ck_assert_uint_eq(o->f->len(o), 1);
   o->f->setTypeString(o);
   ck_assert_uint_eq(o->f->len(o), 0);
   o->f->setTypeDict(o);
   ck_assert_uint_eq(o->f->len(o), 0);
   o->f->setTypeArray(o);
   ck_assert_uint_eq(o->f->len(o), 0);
   terminateO(o);
   // empty
   initiateAllocateSmallJson(&o);
     // empty empty
   o->f->empty(o);
   o->f->setTypeString(o);
   sFree((smallt *)o->topS);
   o->topS = allocSStringTiny("er");
   o->f->empty(o);
   ck_assert_uint_eq(o->f->len(o), 0);
   o->f->setTypeDict(o);
   initiateAllocateSmallInt(&in);
   o->f->set(o, "wer", (baset *)in);
   finishO(in);
   o->f->empty(o);
   ck_assert_uint_eq(o->f->len(o), 0);
   o->f->setTypeArray(o);
   initiateAllocateSmallInt(&in);
   o->f->push(o, (baset *)in);
   finishO(in);
   o->f->empty(o);
   ck_assert_uint_eq(o->f->len(o), 0);
   terminateO(o);
   // stringify
     // array
   initiateAllocateSmallString(&jString);
   jString->f->set(jString, "sheepy");
   json->f->push(json, (baset *) jString);
   finishO(jString);
   initiateAllocateSmallDict(&jdict);
   json->f->push(json, (baset *) jdict);
   finishO(jdict);
   initiateAllocateSmallArray(&jArray);
   json->f->push(json, (baset *) jArray);
   finishO(jArray);
   initiateAllocateSmallDict(&jdict);
   initiateAllocateSmallString(&jString);
   jString->f->set(jString, "sheepy");
   jdict->f->set(jdict, "string", (baset *) jString);
   finishO(jString);
   initiateAllocateSmallContainer(&jcontainer);
   jdict->f->set(jdict, "container", (baset *) jcontainer);
   finishO(jcontainer);
   json->f->push(json, (baset *) jdict);
   finishO(jdict);
   initiateAllocateSmallArray(&jArray);
   initiateAllocateSmallString(&jString);
   jString->f->set(jString, "sheepy");
   jArray->f->push(jArray, (baset *) jString);
   finishO(jString);
   initiateAllocateSmallContainer(&jcontainer);
   jArray->f->push(jArray, (baset *) jcontainer);
   finishO(jcontainer);
   json->f->push(json, (baset *) jArray);
   finishO(jArray);
 
   s = json->f->stringify(json, 2);
   ck_assert_str_eq(s, "[\n  345,\n  \"sheepy\",\n  {},\n  [],\n  {\n    \"string\": \"sheepy\",\n    \"container\": \"<data container>\"\n  },\n  [\n    \"sheepy\",\n    \"<data container>\"\n  ]\n]\n");
   free(s);
     // empty
   createAllocateSmallJson(json2);
   s = json2->f->stringify(json2, 2);
   ck_assert_str_eq(s, "{}");
   free(s);
     // dict
   initiateAllocateSmallString(&jString);
   jString->f->set(jString, "sheepy");
   json2->f->set(json2, "s", (baset *) jString);
   finishO(jString);
   initiateAllocateSmallDict(&jdict);
   json2->f->set(json2, "d",(baset *) jdict);
   finishO(jdict);
   initiateAllocateSmallArray(&jArray);
   json2->f->set(json2, "a", (baset *) jArray);
   finishO(jArray);
   initiateAllocateSmallDict(&jdict);
   initiateAllocateSmallString(&jString);
   jString->f->set(jString, "sheepy");
   jdict->f->set(jdict, "string", (baset *) jString);
   finishO(jString);
   initiateAllocateSmallContainer(&jcontainer);
   jdict->f->set(jdict, "container", (baset *) jcontainer);
   finishO(jcontainer);
   json2->f->set(json2, "d2",(baset *) jdict);
   finishO(jdict);
   initiateAllocateSmallArray(&jArray);
   initiateAllocateSmallString(&jString);
   jString->f->set(jString, "sheepy");
   jArray->f->push(jArray, (baset *) jString);
   finishO(jString);
   initiateAllocateSmallContainer(&jcontainer);
   jArray->f->push(jArray, (baset *) jcontainer);
   finishO(jcontainer);
   json2->f->set(json2, "a2", (baset *) jArray);
   finishO(jArray);
   initiateAllocateSmallInt(&oInt4);
   oInt4->f->set(oInt4, 345);
   json2->f->set(json2, "int", (baset *) oInt4);
   finishO(oInt4);
   s = json2->f->stringify(json2, 2);
   ck_assert_str_eq(s, "{\n  \"s\": \"sheepy\",\n  \"d\": {},\n  \"a\": [],\n  \"d2\": {\n    \"string\": \"sheepy\",\n    \"container\": \"<data container>\"\n  },\n  \"a2\": [\n    \"sheepy\",\n    \"<data container>\"\n  ],\n  \"int\": 345\n}\n");
   free(s);
   // toYML
     // array
   s = json->f->toYML(json, 2);
   ck_assert_str_eq(s, "---\n  - 345\n  - sheepy\n  - {}\n  - []\n  - string: sheepy\n    container: \"<data container>\"\n  - - sheepy\n    - \"<data container>\"\n");
   free(s);
     // empty
   createAllocateSmallJson(json3);
   s = json3->f->toYML(json3, 2);
   ck_assert_str_eq(s, "---\n");
   free(s);
   terminateO(json3);
     // dict
   s = json2->f->toYML(json2, 2);
   ck_assert_str_eq(s, "---\n  s: sheepy\n  d:\n    {}\n  a:\n    []\n  d2:\n    string: sheepy\n    container: \"<data container>\"\n  a2:\n    - sheepy\n    - \"<data container>\"\n  int: 345\n");
   free(s);
   terminateO(json2);
   terminateO(json);
   // parse
     // top null - undefined
   initiateAllocateSmallJson(&json);
   json->f->parse(json, "null");
   ck_assert_str_eq(json->f->getTopType(json), "undefined");
   terminateO(json);
     // top bool
   initiateAllocateSmallJson(&json);
   json->f->parse(json, "true");
   ck_assert_str_eq(json->f->getTopType(json), "bool");
   terminateO(json);
     // top double
   initiateAllocateSmallJson(&json);
   json->f->parse(json, "0.01");
   ck_assert_str_eq(json->f->getTopType(json), "double");
   terminateO(json);
     // top int
   initiateAllocateSmallJson(&json);
   json->f->parse(json, "10");
   ck_assert_str_eq(json->f->getTopType(json), "int");
   terminateO(json);
     // top string
   initiateAllocateSmallJson(&json);
   json->f->parse(json, "\"wef\"");
   ck_assert_str_eq(json->f->getTopType(json), "string");
   terminateO(json);
     // from file dictionary
   char **file = readText("file.json");
   char *jsonText = join(file, "\n");
   createAllocateSmallJson(jsOfromF);
   jsOfromF->f->parse(jsOfromF, jsonText);
   s = toStringO(jsOfromF);
   //printf("JSON FILE: %s\n", s);
   ck_assert_str_eq(s, "{\"dasd\":\"asd\",\"asd\":234,\"dict\":{\"array\":[1,1],\"asd\":true,\"float\":3.434000e+01},\"bool\":false,\"zzz\":null}");
   free(s);
   free(jsonText);
   listFreeS(file);
   terminateO(jsOfromF);
     // json array top
   file = readText("fileA.json");
   jsonText = join(file, "\n");
   initiateAllocateSmallJson(&jsOfromF);
   jsOfromF->f->parse(jsOfromF, jsonText);
   s = toStringO(jsOfromF);
   ck_assert_str_eq(s, "[\"asd\",234,{\"array\":[1,1],\"asd\":true,\"float\":3.434000e+01}]");
   free(s);
   free(jsonText);
   listFreeS(file);
   terminateO(jsOfromF);
     // wrong json incomplete dict
   initiateAllocateSmallJson(&json);
   json->f->parse(json, "{\"wef\": {");
   s = toStringO(json);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(json);
     // wrong json incomplete array
   initiateAllocateSmallJson(&json);
   json->f->parse(json, "{\"wef\": [");
   s = toStringO(json);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(json);
     // wrong json incomplete string
   initiateAllocateSmallJson(&json);
   json->f->parse(json, "{\"wef\": \"wer");
   s = toStringO(json);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(json);
     // wrong json incomplete top dict
   initiateAllocateSmallJson(&json);
   json->f->parse(json, "{ \"wef");
   s = toStringO(json);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(json);
     // wrong json incomplete top array
   initiateAllocateSmallJson(&json);
   json->f->parse(json, "[\"wef");
   s = toStringO(json);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(json);
     // wrong json incomplete top string
   initiateAllocateSmallJson(&json);
   json->f->parse(json, "\"wef");
   s = toStringO(json);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(json);
   // parseYML
     // yml only top dict or array - NO: top null undefined top bool top double top int top string
     // from file dictionary
   file = readText("file.yml");
   jsonText = join(file, "\n");
   initiateAllocateSmallJson(&jsOfromF);
   jsOfromF->f->parseYML(jsOfromF, jsonText);
   s = toStringO(jsOfromF);
   ck_assert_str_eq(s, "{\"dict\":{\"array\":[1,1],\"float\":3.434000e+01,\"asd\":true},\"dasd\":\"asd\",\"asd\":234,\"bool\":false,\"zzz\":null}");
   free(s);
   free(jsonText);
   listFreeS(file);
   terminateO(jsOfromF);
     // json array top
   file = readText("fileA.yml");
   jsonText = join(file, "\n");
   initiateAllocateSmallJson(&jsOfromF);
   jsOfromF->f->parseYML(jsOfromF, jsonText);
   s = toStringO(jsOfromF);
   //printf("JSON FILE: %s\n", toStringO(jsOfromF));
   ck_assert_str_eq(s, "[{\"dict\":\"hello\",\"array\":[1,1],\"float\":3.434000e+01,\"asd\":true},\"asd\",234]");
   free(s);
   free(jsonText);
   listFreeS(file);
   terminateO(jsOfromF);
   // serial deserial
   smallBytest *B;
   initiateAllocateSmallJson(&o);
   ck_assert_ptr_eq(o->f->serial(o), NULL);
     // non json object
   initiateAllocateSmallContainer(&jcontainer);
   o->f->setTop(o, (baset *)jcontainer);
   ck_assert_ptr_eq(o->f->serial(o), NULL);
   terminateO(jcontainer);
     // undefined
   undefinedt *oU = allocUndefined();
   o->f->setTop(o, (baset *)oU);
   finishO(oU);
   B = o->f->serial(o);
   s = sToString((smallt *) B->B);
   ck_assert_str_eq(s, "[0x01]");
   free(s);
   freeO(o);
   o->f->deserial(o, B);
   s = toStringO(o);
   ck_assert_str_eq(s, "null");
   free(s);
   terminateO(B);
   terminateO(o);
     // Bool
   initiateAllocateSmallJson(&o);
   smallBoolt *oBool = allocSmallBool(true);
   o->f->setTop(o, (baset *)oBool);
   finishO(oBool);
   B = o->f->serial(o);
   s = sToString((smallt *) B->B);
   ck_assert_str_eq(s, "[0x02,0x01]");
   free(s);
   o->f->deserial(o, B);
   s = toStringO(o);
   ck_assert_str_eq(s, "true");
   free(s);
   terminateO(B);
   terminateO(o);
     // Double
   initiateAllocateSmallJson(&o);
   smallDoublet *od = allocSmallDouble(10);
   o->f->setTop(o, (baset *)od);
   finishO(od);
   B = o->f->serial(o);
   s = sToString((smallt *) B->B);
   ck_assert_str_eq(s, "[0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x24,0x40]");
   free(s);
   o->f->deserial(o, B);
   s = toStringO(o);
   ck_assert_str_eq(s, "1.000000e+01");
   free(s);
   terminateO(B);
   terminateO(o);
     // Int
   initiateAllocateSmallJson(&o);
   oInt = allocSmallInt(85);
   o->f->setTop(o, (baset *)oInt);
   finishO(oInt);
   B = o->f->serial(o);
   s = sToString((smallt *) B->B);
   ck_assert_str_eq(s, "[0x07,0x55,0x00,0x00,0x00,0x00,0x00,0x00,0x00]");
   free(s);
   o->f->deserial(o, B);
   s = toStringO(o);
   ck_assert_str_eq(s, "85");
   free(s);
   terminateO(B);
   terminateO(o);
     // string
   initiateAllocateSmallJson(&o);
   smallStringt *st = allocSmallString("sheepy");
   o->f->setTop(o, (baset *)st);
   finishO(st);
   B = o->f->serial(o);
   s = sToString((smallt *) B->B);
   ck_assert_str_eq(s, "[0x08,0x73,0x68,0x65,0x65,0x70,0x79,0x00]");
   free(s);
   o->f->deserial(o, B);
   s = toStringO(o);
   ck_assert_str_eq(s, "sheepy");
   free(s);
   terminateO(B);
   terminateO(o);
     // dict
   initiateAllocateSmallJson(&o);
   smallDictt *sDD = allocSmallDict();
   o->f->setTop(o, (baset *)sDD);
   finishO(sDD);
   B = o->f->serial(o);
   s = sToString((smallt *) B->B);
   ck_assert_str_eq(s, "[0x04,0x00,0x00,0x00,0x00]");
   free(s);
   o->f->deserial(o, B);
   s = toStringO(o);
   ck_assert_str_eq(s, "{}");
   free(s);
   terminateO(B);
   terminateO(o);
     // array
   initiateAllocateSmallJson(&o);
   smallArrayt *sAA = allocSmallArray();
   o->f->setTop(o, (baset *)sAA);
   finishO(sAA);
   B = o->f->serial(o);
   s = sToString((smallt *) B->B);
   ck_assert_str_eq(s, "[0x0a,0x00,0x00,0x00,0x00]");
   free(s);
   o->f->deserial(o, B);
   s = toStringO(o);
   ck_assert_str_eq(s, "[]");
   free(s);
   terminateO(B);
   terminateO(o);
     // deserial non json object
   initiateAllocateSmallJson(&o);
   initiateAllocateSmallBytes(&B);
   sContainert *c = allocSContainer(NULL);
   B->B = sSerial((smallt *) c);
   sFree((smallt *) c);
   o->f->deserial(o, B);
   ck_assert_uint_eq(o->topIsA, 0/*=JSON_IS_EMPTY*/);
   terminateO(B);
   terminateO(o);
     // deserial empty sBytest
   initiateAllocateSmallJson(&o);
   initiateAllocateSmallBytes(&B);
   o->f->deserial(o, B);
   ck_assert_uint_eq(o->topIsA, 0/*=JSON_IS_EMPTY*/);
   terminateO(B);
   terminateO(o);
     // NULL object
   initiateAllocateSmallJson(&o);
   o->f->setTypeUndefined(o);
   sFree((smallt *) o->topU);
   o->topU = NULL;
   ck_assert_ptr_eq(o->f->serial(o),NULL);
   o->f->deserial(o, NULL);
   terminateO(o);
   // free local object
   obj.f->free(&obj);
   ck_assert_str_eq(obj.type, "smallJson");
   // free object
   obj2->f->terminate(&obj2);
   ck_assert_ptr_eq(obj2, NULL);
   initiateAllocateSmallJson(&o);
   terminateO(o);
   ck_assert_ptr_eq(o, NULL);
     // undefined
   initiateAllocateSmallJson(&o);
   o->f->setTypeUndefined(o);
   terminateO(o);
   ck_assert_ptr_eq(o, NULL);
     // bool
   initiateAllocateSmallJson(&o);
   o->f->setTypeBool(o);
   terminateO(o);
   ck_assert_ptr_eq(o, NULL);
     // double
   initiateAllocateSmallJson(&o);
   o->f->setTypeDouble(o);
   terminateO(o);
   ck_assert_ptr_eq(o, NULL);
     // int
   initiateAllocateSmallJson(&o);
   o->f->setTypeInt(o);
   terminateO(o);
   ck_assert_ptr_eq(o, NULL);
     // string
   initiateAllocateSmallJson(&o);
   o->f->setTypeString(o);
   terminateO(o);
   ck_assert_ptr_eq(o, NULL);
     // dict
   initiateAllocateSmallJson(&o);
   o->f->setTypeDict(o);
   terminateO(o);
   ck_assert_ptr_eq(o, NULL);
     // array
   initiateAllocateSmallJson(&o);
   o->f->setTypeArray(o);
   terminateO(o);
   ck_assert_ptr_eq(o, NULL);
 
 }
 
 
 
 
 int main(int n UNUSED, char**v UNUSED) {
 // disable btrace to make the test run faster
 btraceDisable();
 createSJFT();
 getsoSmallJsonT();
 setsoSmallJsonT();
 mirrorSmallJsonT();
 setTopBoolSmallJsonT();
 setTopDoubleSmallJsonT();
 setTopIntSmallJsonT();
 setTopStringSmallJsonT();
 setTopCharSmallJsonT();
 setTopDictSmallJsonT();
 setTopArraySmallJsonT();
 setTopArraycSmallJsonT();
 setTopSmallBoolSmallJsonT();
 setTopSmallDoubleSmallJsonT();
 setTopSmallIntSmallJsonT();
 setTopSmallJsonSmallJsonT();
 setTopSmallStringSmallJsonT();
 setTopNFreeSmallJsonT();
 setTopNFreeBoolSmallJsonT();
 setTopNFreeDoubleSmallJsonT();
 setTopNFreeIntSmallJsonT();
 setTopNFreeStringSmallJsonT();
 setTopNFreeDictSmallJsonT();
 setTopNFreeArraySmallJsonT();
 setTopNFreeArraycSmallJsonT();
 setTopNFreeSmallBoolSmallJsonT();
 setTopNFreeSmallDoubleSmallJsonT();
 setTopNFreeSmallIntSmallJsonT();
 setTopNFreeSmallJsonSmallJsonT();
 setTopNFreeSmallStringSmallJsonT();
 fromArraySmallJsonT();
 fromArrayNFreeSmallJsonT();
 fromArrayDictSmallJsonT();
 toArrayDictSmallJsonT();
 getTopUndefinedSmallJsonT();
 getTopBoolSmallJsonT();
 getTopBoolPSmallJsonT();
 getTopDoubleSmallJsonT();
 getTopDoublePSmallJsonT();
 getTopIntSmallJsonT();
 getTopIntPSmallJsonT();
 getTopInt32SmallJsonT();
 getTopInt32PSmallJsonT();
 getTopUintSmallJsonT();
 getTopUintPSmallJsonT();
 getTopUint32SmallJsonT();
 getTopUint32PSmallJsonT();
 getTopSSmallJsonT();
 getTopDictSmallJsonT();
 getTopArraySmallJsonT();
 getTopSmallBoolSmallJsonT();
 getTopSmallDoubleSmallJsonT();
 getTopSmallIntSmallJsonT();
 getTopSmallStringSmallJsonT();
 keyIsSmallJsonT();
 keyIsSSmallJsonT();
 makeKeySmallJsonT();
 iMakeKeySmallJsonT();
 bMakeKeySmallJsonT();
 bLMakeKeySmallJsonT();
 makeKeyLenSmallJsonT();
 setSmallJsonT();
 setUndefinedSmallJsonT();
 setBoolSmallJsonT();
 setDoubleSmallJsonT();
 setIntSmallJsonT();
 setSSmallJsonT();
 setCharSmallJsonT();
 setDictSmallJsonT();
 setArraySmallJsonT();
 setArraycSmallJsonT();
 setSmallBoolSmallJsonT();
 setSmallBytesSmallJsonT();
 setSmallDoubleSmallJsonT();
 setSmallIntSmallJsonT();
 setSmallJsonSmallJsonT();
 setSmallStringSmallJsonT();
 setSmallContainerSmallJsonT();
 setNFreeSmallJsonT();
 setNFreeUndefinedSmallJsonT();
 setNFreeSSmallJsonT();
 setNFreeDictSmallJsonT();
 setNFreeArraySmallJsonT();
 setNFreeArraycSmallJsonT();
 setNFreeSmallBoolSmallJsonT();
 setNFreeSmallBytesSmallJsonT();
 setNFreeSmallDoubleSmallJsonT();
 setNFreeSmallIntSmallJsonT();
 setNFreeSmallJsonSmallJsonT();
 setNFreeSmallStringSmallJsonT();
 setNFreeSmallContainerSmallJsonT();
 setPDictSmallJsonT();
 setPArraySmallJsonT();
 setPSmallJsonSmallJsonT();
 setPSmallStringSmallJsonT();
 setNFreePDictSmallJsonT();
 setNFreePArraySmallJsonT();
 setNFreePSmallJsonSmallJsonT();
 setNFreePSmallStringSmallJsonT();
 setAtSmallJsonT();
 setAtUndefinedSmallJsonT();
 setAtBoolSmallJsonT();
 setAtDoubleSmallJsonT();
 setAtIntSmallJsonT();
 setAtSSmallJsonT();
 setAtCharSmallJsonT();
 setAtDictSmallJsonT();
 setAtArraySmallJsonT();
 setAtArraycSmallJsonT();
 setAtSmallBoolSmallJsonT();
 setAtSmallBytesSmallJsonT();
 setAtSmallDoubleSmallJsonT();
 setAtSmallIntSmallJsonT();
 setAtSmallJsonSmallJsonT();
 setAtSmallStringSmallJsonT();
 setAtSmallContainerSmallJsonT();
 setAtNFreeSmallJsonT();
 setAtNFreeUndefinedSmallJsonT();
 setAtNFreeSSmallJsonT();
 setAtNFreeDictSmallJsonT();
 setAtNFreeArraySmallJsonT();
 setAtNFreeArraycSmallJsonT();
 setAtNFreeSmallBoolSmallJsonT();
 setAtNFreeSmallBytesSmallJsonT();
 setAtNFreeSmallDoubleSmallJsonT();
 setAtNFreeSmallIntSmallJsonT();
 setAtNFreeSmallJsonSmallJsonT();
 setAtNFreeSmallStringSmallJsonT();
 setAtNFreeSmallContainerSmallJsonT();
 setPAtDictSmallJsonT();
 setPAtArraySmallJsonT();
 setPAtSmallJsonSmallJsonT();
 setPAtSmallStringSmallJsonT();
 setPAtNFreeDictSmallJsonT();
 setPAtNFreeArraySmallJsonT();
 setPAtNFreeSmallJsonSmallJsonT();
 setPAtNFreeSmallStringSmallJsonT();
 pushUndefinedSmallJsonT();
 pushBoolSmallJsonT();
 pushDoubleSmallJsonT();
 pushIntSmallJsonT();
 pushSSmallJsonT();
 pushCharSmallJsonT();
 pushDictSmallJsonT();
 pushArraySmallJsonT();
 pushArraycSmallJsonT();
 pushSmallBoolSmallJsonT();
 pushSmallBytesSmallJsonT();
 pushSmallDoubleSmallJsonT();
 pushSmallIntSmallJsonT();
 pushSmallJsonSmallJsonT();
 pushSmallStringSmallJsonT();
 pushSmallContainerSmallJsonT();
 pushNFreeSmallJsonT();
 pushNFreeUndefinedSmallJsonT();
 pushNFreeSSmallJsonT();
 pushNFreeDictSmallJsonT();
 pushNFreeArraySmallJsonT();
 pushNFreeArraycSmallJsonT();
 pushNFreeSmallBoolSmallJsonT();
 pushNFreeSmallBytesSmallJsonT();
 pushNFreeSmallDoubleSmallJsonT();
 pushNFreeSmallIntSmallJsonT();
 pushNFreeSmallJsonSmallJsonT();
 pushNFreeSmallStringSmallJsonT();
 pushNFreeSmallContainerSmallJsonT();
 pushManySmallJsonT();
 pushManySSmallJsonT();
 pushNFreeManySmallJsonT();
 pushNFreeManySSmallJsonT();
 popSmallJsonT();
 popUndefinedSmallJsonT();
 popBoolSmallJsonT();
 popDoubleSmallJsonT();
 popIntSmallJsonT();
 popInt32SmallJsonT();
 popUintSmallJsonT();
 popUint32SmallJsonT();
 popSSmallJsonT();
 popDictSmallJsonT();
 popArraySmallJsonT();
 popSmallBoolSmallJsonT();
 popSmallBytesSmallJsonT();
 popSmallDoubleSmallJsonT();
 popSmallIntSmallJsonT();
 popSmallJsonSmallJsonT();
 popSmallStringSmallJsonT();
 popVoidSmallJsonT();
 popSmallContainerSmallJsonT();
 popNumSmallJsonT();
 prependSmallJsonT();
 prependUndefinedSmallJsonT();
 prependBoolSmallJsonT();
 prependDoubleSmallJsonT();
 prependIntSmallJsonT();
 prependSSmallJsonT();
 prependCharSmallJsonT();
 prependDictSmallJsonT();
 prependArraySmallJsonT();
 prependArraycSmallJsonT();
 prependSmallBoolSmallJsonT();
 prependSmallBytesSmallJsonT();
 prependSmallDoubleSmallJsonT();
 prependSmallIntSmallJsonT();
 prependSmallJsonSmallJsonT();
 prependSmallStringSmallJsonT();
 prependSmallContainerSmallJsonT();
 prependNFreeSmallJsonT();
 prependNFreeUndefinedSmallJsonT();
 prependNFreeSSmallJsonT();
 prependNFreeDictSmallJsonT();
 prependNFreeArraySmallJsonT();
 prependNFreeArraycSmallJsonT();
 prependNFreeSmallBoolSmallJsonT();
 prependNFreeSmallBytesSmallJsonT();
 prependNFreeSmallDoubleSmallJsonT();
 prependNFreeSmallIntSmallJsonT();
 prependNFreeSmallJsonSmallJsonT();
 prependNFreeSmallStringSmallJsonT();
 prependNFreeSmallContainerSmallJsonT();
 dequeueSmallJsonT();
 dequeueUndefinedSmallJsonT();
 dequeueBoolSmallJsonT();
 dequeueDoubleSmallJsonT();
 dequeueIntSmallJsonT();
 dequeueInt32SmallJsonT();
 dequeueUintSmallJsonT();
 dequeueUint32SmallJsonT();
 dequeueSSmallJsonT();
 dequeueDictSmallJsonT();
 dequeueArraySmallJsonT();
 dequeueSmallBoolSmallJsonT();
 dequeueSmallBytesSmallJsonT();
 dequeueSmallDoubleSmallJsonT();
 dequeueSmallIntSmallJsonT();
 dequeueSmallJsonSmallJsonT();
 dequeueSmallStringSmallJsonT();
 dequeueVoidSmallJsonT();
 dequeueSmallContainerSmallJsonT();
 dequeueNumSmallJsonT();
 reverseSmallJsonT();
 catSmallJsonT();
 mergeDictSmallJsonT();
 mergeDictNSmashSmallJsonT();
 mergeSmallJsonT();
 mergeNSmashSmallJsonT();
 appendSmallJsonT();
 appendNSmashSmallJsonT();
 appendArraySmallJsonT();
 appendNSmashArraySmallJsonT();
 shiftSmallJsonT();
 shiftNSmashSmallJsonT();
 shiftSmallJsonSmallJsonT();
 shiftNSmashSmallJsonSmallJsonT();
 addSmallJsonT();
 addJsonSmallJsonT();
 sliceSmallJsonT();
 cropSmallJsonT();
 cropSSmallJsonT();
 cropSmallStringSmallJsonT();
 cropElemAtSmallJsonT();
 cropElemAtUndefinedSmallJsonT();
 cropElemAtBoolSmallJsonT();
 cropElemAtDoubleSmallJsonT();
 cropElemAtIntSmallJsonT();
 cropElemAtInt32SmallJsonT();
 cropElemAtUintSmallJsonT();
 cropElemAtUint32SmallJsonT();
 cropElemAtSSmallJsonT();
 cropElemAtCharSmallJsonT();
 cropElemAtDictSmallJsonT();
 cropElemAtArraySmallJsonT();
 cropElemAtSmallBoolSmallJsonT();
 cropElemAtSmallBytesSmallJsonT();
 cropElemAtSmallDoubleSmallJsonT();
 cropElemAtSmallIntSmallJsonT();
 cropElemAtSmallJsonSmallJsonT();
 cropElemAtSmallStringSmallJsonT();
 cropElemAtVoidSmallJsonT();
 cropElemAtSmallContainerSmallJsonT();
 cropElemKeySmallJsonT();
 cropElemKeyUndefinedSmallJsonT();
 cropElemKeyBoolSmallJsonT();
 cropElemKeyDoubleSmallJsonT();
 cropElemKeyIntSmallJsonT();
 cropElemKeyInt32SmallJsonT();
 cropElemKeyUintSmallJsonT();
 cropElemKeyUint32SmallJsonT();
 cropElemKeySSmallJsonT();
 cropElemKeyDictSmallJsonT();
 cropElemKeyArraySmallJsonT();
 cropElemKeySmallBoolSmallJsonT();
 cropElemKeySmallBytesSmallJsonT();
 cropElemKeySmallDoubleSmallJsonT();
 cropElemKeySmallIntSmallJsonT();
 cropElemKeySmallJsonSmallJsonT();
 cropElemKeySmallStringSmallJsonT();
 cropElemKeyVoidSmallJsonT();
 cropElemKeySmallContainerSmallJsonT();
 copySmallJsonT();
 insertSmallJsonT();
 insertNSmashSmallJsonT();
 insertSmallJsonSmallJsonT();
 insertNSmashSmallJsonSmallJsonT();
 insertStringSmallJsonT();
 insertSSmallJsonT();
 insertNFreeStringSmallJsonT();
 insertSNFreeSmallJsonT();
 injectSmallJsonT();
 injectUndefinedSmallJsonT();
 injectBoolSmallJsonT();
 injectDoubleSmallJsonT();
 injectIntSmallJsonT();
 injectSSmallJsonT();
 injectCharSmallJsonT();
 injectDictSmallJsonT();
 injectArraySmallJsonT();
 injectArraycSmallJsonT();
 injectSmallBoolSmallJsonT();
 injectSmallBytesSmallJsonT();
 injectSmallDoubleSmallJsonT();
 injectSmallIntSmallJsonT();
 injectSmallJsonSmallJsonT();
 injectSmallStringSmallJsonT();
 injectSmallContainerSmallJsonT();
 injectNFreeSmallJsonT();
 injectNFreeUndefinedSmallJsonT();
 injectNFreeSSmallJsonT();
 injectNFreeDictSmallJsonT();
 injectNFreeArraySmallJsonT();
 injectNFreeArraycSmallJsonT();
 injectNFreeSmallBoolSmallJsonT();
 injectNFreeSmallBytesSmallJsonT();
 injectNFreeSmallDoubleSmallJsonT();
 injectNFreeSmallIntSmallJsonT();
 injectNFreeSmallJsonSmallJsonT();
 injectNFreeSmallStringSmallJsonT();
 injectNFreeSmallContainerSmallJsonT();
 uniqSmallJsonT();
 sortSmallJsonT();
 icSortSmallJsonT();
 sortFSmallJsonT();
 icUniqSmallJsonT();
 uniqCharSmallJsonT();
 icUniqCharSmallJsonT();
 hasSmallJsonT();
 hasUndefinedSmallJsonT();
 hasBoolSmallJsonT();
 hasDoubleSmallJsonT();
 hasIntSmallJsonT();
 hasSSmallJsonT();
 hasCharSmallJsonT();
 hasDictSmallJsonT();
 hasArraySmallJsonT();
 hasArraycSmallJsonT();
 hasSmallBoolSmallJsonT();
 hasSmallBytesSmallJsonT();
 hasSmallDoubleSmallJsonT();
 hasSmallIntSmallJsonT();
 hasSmallJsonSmallJsonT();
 hasSmallStringSmallJsonT();
 hasSmallContainerSmallJsonT();
 findSmallJsonT();
 findCharSmallJsonT();
 findSmallStringSmallJsonT();
 findJsonSmallJsonT();
 indexOfSmallJsonT();
 indexOfUndefinedSmallJsonT();
 indexOfBoolSmallJsonT();
 indexOfDoubleSmallJsonT();
 indexOfIntSmallJsonT();
 indexOfSSmallJsonT();
 indexOfCharSmallJsonT();
 indexOfDictSmallJsonT();
 indexOfArraySmallJsonT();
 indexOfArraycSmallJsonT();
 indexOfSmallBoolSmallJsonT();
 indexOfSmallBytesSmallJsonT();
 indexOfSmallDoubleSmallJsonT();
 indexOfSmallIntSmallJsonT();
 indexOfSmallJsonSmallJsonT();
 indexOfSmallStringSmallJsonT();
 indexOfSmallContainerSmallJsonT();
 binarySearchSmallJsonT();
 binarySearchUndefinedSmallJsonT();
 binarySearchBoolSmallJsonT();
 binarySearchDoubleSmallJsonT();
 binarySearchIntSmallJsonT();
 binarySearchSSmallJsonT();
 binarySearchCharSmallJsonT();
 binarySearchDictSmallJsonT();
 binarySearchArraySmallJsonT();
 binarySearchArraycSmallJsonT();
 binarySearchSmallBoolSmallJsonT();
 binarySearchSmallBytesSmallJsonT();
 binarySearchSmallDoubleSmallJsonT();
 binarySearchSmallIntSmallJsonT();
 binarySearchSmallJsonSmallJsonT();
 binarySearchSmallStringSmallJsonT();
 binarySearchSmallContainerSmallJsonT();
 icHasSmallJsonT();
 icHasSSmallJsonT();
 icHasCharSmallJsonT();
 icHasDictSmallJsonT();
 icHasArraySmallJsonT();
 icHasArraycSmallJsonT();
 icHasSmallStringSmallJsonT();
 icFindSmallJsonT();
 icFindCharSmallJsonT();
 icFindSmallStringSmallJsonT();
 icFindJsonSmallJsonT();
 icIndexOfSmallJsonT();
 icIndexOfSSmallJsonT();
 icIndexOfCharSmallJsonT();
 icIndexOfDictSmallJsonT();
 icIndexOfArraySmallJsonT();
 icIndexOfArraycSmallJsonT();
 icIndexOfSmallStringSmallJsonT();
 icBinarySearchSmallJsonT();
 icBinarySearchSSmallJsonT();
 icBinarySearchCharSmallJsonT();
 icBinarySearchDictSmallJsonT();
 icBinarySearchArraySmallJsonT();
 icBinarySearchArraycSmallJsonT();
 icBinarySearchSmallStringSmallJsonT();
 keyBySmallJsonT();
 keyByUndefinedSmallJsonT();
 keyByBoolSmallJsonT();
 keyByDoubleSmallJsonT();
 keyByIntSmallJsonT();
 keyBySSmallJsonT();
 keyByCharSmallJsonT();
 keyByDictSmallJsonT();
 keyByArraySmallJsonT();
 keyByArraycSmallJsonT();
 keyBySmallBoolSmallJsonT();
 keyBySmallBytesSmallJsonT();
 keyBySmallDoubleSmallJsonT();
 keyBySmallIntSmallJsonT();
 keyBySmallJsonSmallJsonT();
 keyBySmallStringSmallJsonT();
 keyBySmallContainerSmallJsonT();
 icKeyBySmallJsonT();
 icKeyBySSmallJsonT();
 icKeyByCharSmallJsonT();
 icKeyByDictSmallJsonT();
 icKeyByArraySmallJsonT();
 icKeyByArraycSmallJsonT();
 icKeyBySmallStringSmallJsonT();
 replaceSmallJsonT();
 replaceCharSSmallJsonT();
 replaceSCharSmallJsonT();
 replaceCharCharSmallJsonT();
 replaceSmallStringSmallStringSmallJsonT();
 replaceSmallStringSSmallJsonT();
 replaceSmallStringCharSmallJsonT();
 replaceSSmallStringSmallJsonT();
 replaceCharSmallStringSmallJsonT();
 replaceJsonJsonSmallJsonT();
 replaceJsonSmallStringSmallJsonT();
 replaceJsonSSmallJsonT();
 replaceJsonCharSmallJsonT();
 replaceSmallStringJsonSmallJsonT();
 replaceSJsonSmallJsonT();
 replaceCharJsonSmallJsonT();
 replaceManySmallJsonT();
 icReplaceSmallJsonT();
 icReplaceCharSSmallJsonT();
 icReplaceSCharSmallJsonT();
 icReplaceCharCharSmallJsonT();
 icReplaceSmallStringSmallStringSmallJsonT();
 icReplaceSmallStringSSmallJsonT();
 icReplaceSmallStringCharSmallJsonT();
 icReplaceSSmallStringSmallJsonT();
 icReplaceCharSmallStringSmallJsonT();
 icReplaceJsonJsonSmallJsonT();
 icReplaceJsonSmallStringSmallJsonT();
 icReplaceJsonSSmallJsonT();
 icReplaceJsonCharSmallJsonT();
 icReplaceSmallStringJsonSmallJsonT();
 icReplaceSJsonSmallJsonT();
 icReplaceCharJsonSmallJsonT();
 icReplaceManySmallJsonT();
 equalSmallJsonSmallArrayT();
 equalSmallJsonArrayT();
 equalSmallJsonBaseT();
 equalSmallJsonChaT();
 equalSmallJsonCharT();
 equalSmallJsonBoolT();
 equalSmallJsonDoubleT();
 equalSmallJsonInt64T();
 equalSmallJsonInt32T();
 equalSmallJsonUint32T();
 equalSmallJsonUint64T();
 equalSmallJsonSmallBoolT();
 equalSmallJsonSmallBytesT();
 equalSmallJsonSmallDoubleT();
 equalSmallJsonSmallIntT();
 equalSmallJsonSmallJsonT();
 equalSmallJsonSmallStringT();
 equalSmallJsonSmallDictT();
 icEqualSmallJsonSmallArrayT();
 icEqualSmallJsonArrayT();
 icEqualSmallJsonBaseT();
 icEqualSmallJsonSmallDictT();
 icEqualSmallJsonSmallJsonT();
 icEqualSmallJsonSmallStringT();
 icEqualSSmallJsonT();
 icEqualCharSmallJsonT();
 equalISSmallJsonT();
 equalICharSmallJsonT();
 equalIJsonSmallJsonT();
 equalISmallStringSmallJsonT();
 startsWithSSmallJsonT();
 startsWithCharSmallJsonT();
 startsWithSmallStringSmallJsonT();
 startsWithJsonSmallJsonT();
 endsWithSSmallJsonT();
 endsWithCharSmallJsonT();
 endsWithSmallStringSmallJsonT();
 endsWithJsonSmallJsonT();
 countSSmallJsonT();
 countCharSmallJsonT();
 countSmallStringSmallJsonT();
 countJsonSmallJsonT();
 icStartsWithSSmallJsonT();
 icStartsWithCharSmallJsonT();
 icStartsWithSmallStringSmallJsonT();
 icStartsWithJsonSmallJsonT();
 icEndsWithSSmallJsonT();
 icEndsWithCharSmallJsonT();
 icEndsWithSmallStringSmallJsonT();
 icEndsWithJsonSmallJsonT();
 icCountSSmallJsonT();
 icCountCharSmallJsonT();
 icCountSmallStringSmallJsonT();
 icCountJsonSmallJsonT();
 isNumberSmallJsonT();
 isIntSmallJsonT();
 parseIntSmallJsonT();
 parseDoubleSmallJsonT();
 intToSmallJsonT();
 doubleToSmallJsonT();
 upperSmallJsonT();
 lowerSmallJsonT();
 trimSmallJsonT();
 lTrimSmallJsonT();
 rTrimSmallJsonT();
 keysSmallJsonT();
 keysSmallStringSmallJsonT();
 valuesSmallJsonT();
 compactSmallJsonT();
 isEmptySmallJsonT();
 isBlankSmallJsonT();
 forEachSmallJsonFT();
 enumerateSmallJsonFT();
 enumerateDictSmallJsonT();
 joinSmallJsonT();
 joinCharSmallJsonT();
 joinSmallJsonSmallJsonT();
 joinSmallStringSmallJsonT();
 joinSSmallJsonT();
 joinCharSSmallJsonT();
 joinSmallJsonSSmallJsonT();
 joinSmallStringSSmallJsonT();
 splitSmallJsonT();
 splitCharSmallJsonT();
 splitSmallJsonSmallJsonT();
 splitSmallStringSmallJsonT();
 splitSSmallJsonT();
 splitCharSSmallJsonT();
 splitSmallJsonSSmallJsonT();
 splitSmallStringSSmallJsonT();
 extractSmallJsonT();
 extractCharSSmallJsonT();
 extractSCharSmallJsonT();
 extractCharCharSmallJsonT();
 extractSmallJsonSmallJsonSmallJsonT();
 extractSmallJsonSmallStringSmallJsonT();
 extractSmallJsonSSmallJsonT();
 extractSmallJsonCharSmallJsonT();
 extractSmallStringSmallJsonSmallJsonT();
 extractSmallStringSmallStringSmallJsonT();
 extractSmallStringSSmallJsonT();
 extractSmallStringCharSmallJsonT();
 extractSSmallJsonSmallJsonT();
 extractSSmallStringSmallJsonT();
 extractCharSmallJsonSmallJsonT();
 extractCharSmallStringSmallJsonT();
 icSplitSmallJsonT();
 icSplitCharSmallJsonT();
 icSplitSmallJsonSmallJsonT();
 icSplitSmallStringSmallJsonT();
 icSplitSSmallJsonT();
 icSplitCharSSmallJsonT();
 icSplitSmallJsonSSmallJsonT();
 icSplitSmallStringSSmallJsonT();
 icExtractSmallJsonT();
 icExtractCharSSmallJsonT();
 icExtractSCharSmallJsonT();
 icExtractCharCharSmallJsonT();
 icExtractSmallJsonSmallJsonSmallJsonT();
 icExtractSmallJsonSmallStringSmallJsonT();
 icExtractSmallJsonSSmallJsonT();
 icExtractSmallJsonCharSmallJsonT();
 icExtractSmallStringSmallJsonSmallJsonT();
 icExtractSmallStringSmallStringSmallJsonT();
 icExtractSmallStringSSmallJsonT();
 icExtractSmallStringCharSmallJsonT();
 icExtractSSmallJsonSmallJsonT();
 icExtractSSmallStringSmallJsonT();
 icExtractCharSmallJsonSmallJsonT();
 icExtractCharSmallStringSmallJsonT();
 colorSmallJsonT();
 colordSmallJsonT();
 zipSmallJsonT();
 zipArraySmallJsonT();
 zipCArraySmallJsonT();
 zipCharSmallJsonT();
 zipCCharSmallJsonT();
 zipArrayCharSmallJsonT();
 zipCArrayCharSmallJsonT();
 zipArrayCCharSmallJsonT();
 zipCArrayCCharSmallJsonT();
 zipJsonSmallJsonT();
 zipJsonSmallArraySmallJsonT();
 zipJsonArraySmallJsonT();
 zipJsonCArraySmallJsonT();
 zipSmallArrayJsonSmallJsonT();
 zipArrayJsonSmallJsonT();
 zipCArrayJsonSmallJsonT();
 iterStartSmallJsonT();
 iterStartKeySmallJsonT();
 iterStartLastSmallJsonT();
 iterStartFromSmallJsonT();
 iterStartFromStepSmallJsonT();
 iterNextSmallJsonT();
 iterNextKeySmallJsonT();
 iterElementSmallJsonT();
 iterKeySmallJsonT();
 iterIndexSmallJsonT();
 iterStepSmallJsonT();
 getUndefinedSmallJsonT();
 getBoolSmallJsonT();
 getBoolPSmallJsonT();
 getDoubleSmallJsonT();
 getDoublePSmallJsonT();
 getIntSmallJsonT();
 getIntPSmallJsonT();
 getInt32SmallJsonT();
 getInt32PSmallJsonT();
 getUintSmallJsonT();
 getUintPSmallJsonT();
 getUint32SmallJsonT();
 getUint32PSmallJsonT();
 getSSmallJsonT();
 getDictSmallJsonT();
 getArraySmallJsonT();
 getSmallBoolSmallJsonT();
 getSmallBytesSmallJsonT();
 getSmallDoubleSmallJsonT();
 getSmallIntSmallJsonT();
 getSmallJsonSmallJsonT();
 getSmallStringSmallJsonT();
 getVoidSmallJsonT();
 getSmallContainerSmallJsonT();
 getNDupSmallJsonT();
 getNDupUndefinedSmallJsonT();
 getNDupBoolSmallJsonT();
 getNDupDoubleSmallJsonT();
 getNDupIntSmallJsonT();
 getNDupInt32SmallJsonT();
 getNDupUintSmallJsonT();
 getNDupUint32SmallJsonT();
 getNDupSSmallJsonT();
 getNDupDictSmallJsonT();
 getNDupArraySmallJsonT();
 getNDupSmallBoolSmallJsonT();
 getNDupSmallBytesSmallJsonT();
 getNDupSmallDoubleSmallJsonT();
 getNDupSmallIntSmallJsonT();
 getNDupSmallJsonSmallJsonT();
 getNDupSmallStringSmallJsonT();
 getNDupVoidSmallJsonT();
 getNDupSmallContainerSmallJsonT();
 getAtSmallJsonT();
 getAtUndefinedSmallJsonT();
 getAtBoolSmallJsonT();
 getAtBoolPSmallJsonT();
 getAtDoubleSmallJsonT();
 getAtDoublePSmallJsonT();
 getAtIntSmallJsonT();
 getAtIntPSmallJsonT();
 getAtInt32SmallJsonT();
 getAtInt32PSmallJsonT();
 getAtUintSmallJsonT();
 getAtUintPSmallJsonT();
 getAtUint32SmallJsonT();
 getAtUint32PSmallJsonT();
 getAtSSmallJsonT();
 getAtDictSmallJsonT();
 getAtArraySmallJsonT();
 getAtSmallBoolSmallJsonT();
 getAtSmallBytesSmallJsonT();
 getAtSmallDoubleSmallJsonT();
 getAtSmallIntSmallJsonT();
 getAtSmallJsonSmallJsonT();
 getAtSmallStringSmallJsonT();
 getAtVoidSmallJsonT();
 getAtSmallContainerSmallJsonT();
 getAtNDupSmallJsonT();
 getAtNDupUndefinedSmallJsonT();
 getAtNDupBoolSmallJsonT();
 getAtNDupDoubleSmallJsonT();
 getAtNDupIntSmallJsonT();
 getAtNDupInt32SmallJsonT();
 getAtNDupUintSmallJsonT();
 getAtNDupUint32SmallJsonT();
 getAtNDupSSmallJsonT();
 getAtNDupDictSmallJsonT();
 getAtNDupArraySmallJsonT();
 getAtNDupSmallBoolSmallJsonT();
 getAtNDupSmallBytesSmallJsonT();
 getAtNDupSmallDoubleSmallJsonT();
 getAtNDupSmallIntSmallJsonT();
 getAtNDupSmallJsonSmallJsonT();
 getAtNDupSmallStringSmallJsonT();
 getAtNDupVoidSmallJsonT();
 getAtNDupSmallContainerSmallJsonT();
 getNumSmallJsonT();
 getNumAtSmallJsonT();
 delElemSmallJsonT();
 delSmallJsonT();
 delElemIndexSmallJsonT();
 removeElemSmallJsonT();
 removeSmallJsonT();
 removeElemIndexSmallJsonT();
 stringifySmallStringSmallJsonT();
 toYMLSmallStringSmallJsonT();
 parseSmallJsonSmallJsonT();
 parseSmallStringSmallJsonT();
 parseYMLSmallJsonSmallJsonT();
 parseYMLSmallStringSmallJsonT();
 logSmallJsonT();
 readFileSmallJsonT();
 readFileSmallStringSmallJsonT();
 readFileJsonSmallJsonT();
 readStreamSmallJsonT();
 writeFileSmallJsonT();
 writeFileSmallStringSmallJsonT();
 writeFileJsonSmallJsonT();
 writeStreamSmallJsonT();
 appendFileSmallJsonT();
 appendFileSmallStringSmallJsonT();
 appendFileJsonSmallJsonT();
 readTextSmallJsonT();
 readTextSmallStringSmallJsonT();
 readTextJsonSmallJsonT();
 readTextStreamSmallJsonT();
 writeTextSmallJsonT();
 writeTextSmallStringSmallJsonT();
 writeTextJsonSmallJsonT();
 writeTextStreamSmallJsonT();
 appendTextSmallJsonT();
 appendTextSmallStringSmallJsonT();
 appendTextJsonSmallJsonT();
 typeStringSmallJsonT();
 typeSmallStringSmallJsonT();
 typeAtStringSmallJsonT();
 typeAtSmallStringSmallJsonT();
 typeStringKCharSmallJsonT();
 typeSmallStringKCharSmallJsonT();
 typeSmallJsonT();
 typeKCharSmallJsonT();
 typeAtSmallJsonT();
 typeStringsSmallJsonT();
 typesSmallJsonT();
 isETypeAtSmallJsonT();
 isEUndefinedAtSmallJsonT();
 isEBoolAtSmallJsonT();
 isEContainerAtSmallJsonT();
 isEDictAtSmallJsonT();
 isEDoubleAtSmallJsonT();
 isEIntAtSmallJsonT();
 isEStringAtSmallJsonT();
 isEFaststringAtSmallJsonT();
 isEArrayAtSmallJsonT();
 isEBytesAtSmallJsonT();
 isETypeSmallJsonT();
 isEUndefinedSmallJsonT();
 isEBoolSmallJsonT();
 isEContainerSmallJsonT();
 isEDictSmallJsonT();
 isEDoubleSmallJsonT();
 isEIntSmallJsonT();
 isEStringSmallJsonT();
 isEFaststringSmallJsonT();
 isEArraySmallJsonT();
 isEBytesSmallJsonT();
 areAllETypeSmallJsonT();
 areAllEUndefinedSmallJsonT();
 areAllEBoolSmallJsonT();
 areAllEContainerSmallJsonT();
 areAllEDictSmallJsonT();
 areAllEDoubleSmallJsonT();
 areAllEIntSmallJsonT();
 areAllEStringSmallJsonT();
 areAllEFaststringSmallJsonT();
 areAllEArraySmallJsonT();
 areAllEBytesSmallJsonT();
 duplicateSmallJsonGT();
 freeSmallJsonGT();
 setTopSmallJsonGT();
 setTopBoolSmallJsonGT();
 setTopDoubleSmallJsonGT();
 setTopIntSmallJsonGT();
 setTopStringSmallJsonGT();
 setTopCharSmallJsonGT();
 setTopDictSmallJsonGT();
 setTopArraySmallJsonGT();
 setTopArraycSmallJsonGT();
 setTopCArraycSmallJsonGT();
 setTopSmallBoolSmallJsonGT();
 setTopSmallDoubleSmallJsonGT();
 setTopSmallIntSmallJsonGT();
 setTopSmallJsonSmallJsonGT();
 setTopSmallStringSmallJsonGT();
 setTopNFreeSmallJsonGT();
 setTopNFreeBoolSmallJsonGT();
 setTopNFreeDoubleSmallJsonGT();
 setTopNFreeIntSmallJsonGT();
 setTopNFreeStringSmallJsonGT();
 setTopNFreeDictSmallJsonGT();
 setTopNFreeArraySmallJsonGT();
 setTopNFreeArraycSmallJsonGT();
 setTopNFreeSmallBoolSmallJsonGT();
 setTopNFreeSmallDoubleSmallJsonGT();
 setTopNFreeSmallIntSmallJsonGT();
 setTopNFreeSmallJsonSmallJsonGT();
 setTopNFreeSmallStringSmallJsonGT();
 fromArraySmallJsonGT();
 fromCArraySmallJsonGT();
 getTopSmallJsonGT();
 getTopUndefinedSmallJsonGT();
 getTopBoolSmallJsonGT();
 getTopBoolPSmallJsonGT();
 getTopDoubleSmallJsonGT();
 getTopDoublePSmallJsonGT();
 getTopIntSmallJsonGT();
 getTopIntPSmallJsonGT();
 getTopInt32SmallJsonGT();
 getTopInt32PSmallJsonGT();
 getTopUintSmallJsonGT();
 getTopUintPSmallJsonGT();
 getTopUint32SmallJsonGT();
 getTopUint32PSmallJsonGT();
 getTopSSmallJsonGT();
 getTopDictSmallJsonGT();
 getTopArraySmallJsonGT();
 getTopSmallBoolSmallJsonGT();
 getTopSmallDoubleSmallJsonGT();
 getTopSmallIntSmallJsonGT();
 getTopSmallStringSmallJsonGT();
 pushSmallJsonGT();
 pushUndefinedSmallJsonGT();
 pushBoolSmallJsonGT();
 pushDoubleSmallJsonGT();
 pushIntSmallJsonGT();
 pushSSmallJsonGT();
 pushCharSmallJsonGT();
 pushDictSmallJsonGT();
 pushArraySmallJsonGT();
 pushArraycSmallJsonGT();
 pushCArraycSmallJsonGT();
 pushVoidSmallJsonGT();
 pushSmallBoolSmallJsonGT();
 pushSmallBytesSmallJsonGT();
 pushSmallDoubleSmallJsonGT();
 pushSmallIntSmallJsonGT();
 pushSmallJsonSmallJsonGT();
 pushSmallStringSmallJsonGT();
 pushSmallContainerSmallJsonGT();
 pushNFreeSmallJsonGT();
 pushNFreeUndefinedSmallJsonGT();
 pushNFreeSSmallJsonGT();
 pushNFreeDictSmallJsonGT();
 pushNFreeArraySmallJsonGT();
 pushNFreeArraycSmallJsonGT();
 pushNFreeSmallBoolSmallJsonGT();
 pushNFreeSmallBytesSmallJsonGT();
 pushNFreeSmallDoubleSmallJsonGT();
 pushNFreeSmallIntSmallJsonGT();
 pushNFreeSmallJsonSmallJsonGT();
 pushNFreeSmallStringSmallJsonGT();
 pushNFreeSmallContainerSmallJsonGT();
 popSmallJsonGT();
 popUndefinedSmallJsonGT();
 popBoolSmallJsonGT();
 popDoubleSmallJsonGT();
 popIntSmallJsonGT();
 popInt32SmallJsonGT();
 popUintSmallJsonGT();
 popUint32SmallJsonGT();
 popSSmallJsonGT();
 popDictSmallJsonGT();
 popArraySmallJsonGT();
 popSmallBoolSmallJsonGT();
 popSmallBytesSmallJsonGT();
 popSmallDoubleSmallJsonGT();
 popSmallIntSmallJsonGT();
 popSmallJsonSmallJsonGT();
 popSmallStringSmallJsonGT();
 popVoidSmallJsonGT();
 popSmallContainerSmallJsonGT();
 setSmallJsonGT();
 setUndefinedSmallJsonGT();
 setBoolSmallJsonGT();
 setDoubleSmallJsonGT();
 setIntSmallJsonGT();
 setSSmallJsonGT();
 setCharSmallJsonGT();
 setDictSmallJsonGT();
 setArraySmallJsonGT();
 setArraycSmallJsonGT();
 setCArraycSmallJsonGT();
 setVoidSmallJsonGT();
 setSmallBoolSmallJsonGT();
 setSmallBytesSmallJsonGT();
 setSmallDoubleSmallJsonGT();
 setSmallIntSmallJsonGT();
 setSmallJsonSmallJsonGT();
 setSmallStringSmallJsonGT();
 setSmallContainerSmallJsonGT();
 setNFreeSmallJsonGT();
 setNFreeUndefinedSmallJsonGT();
 setNFreeSSmallJsonGT();
 setNFreeDictSmallJsonGT();
 setNFreeArraySmallJsonGT();
 setNFreeArraycSmallJsonGT();
 setNFreeSmallBoolSmallJsonGT();
 setNFreeSmallBytesSmallJsonGT();
 setNFreeSmallDoubleSmallJsonGT();
 setNFreeSmallIntSmallJsonGT();
 setNFreeSmallJsonSmallJsonGT();
 setNFreeSmallStringSmallJsonGT();
 setNFreeSmallContainerSmallJsonGT();
 setPDictSmallJsonGT();
 setPArraySmallJsonGT();
 setPSmallJsonSmallJsonGT();
 setPSmallStringSmallJsonGT();
 setNFreePDictSmallJsonGT();
 setNFreePArraySmallJsonGT();
 setNFreePSmallJsonSmallJsonGT();
 setNFreePSmallStringSmallJsonGT();
 setAtSmallJsonGT();
 setAtUndefinedSmallJsonGT();
 setAtBoolSmallJsonGT();
 setAtDoubleSmallJsonGT();
 setAtIntSmallJsonGT();
 setAtSSmallJsonGT();
 setAtCharSmallJsonGT();
 setAtDictSmallJsonGT();
 setAtArraySmallJsonGT();
 setAtArraycSmallJsonGT();
 setAtCArraycSmallJsonGT();
 setAtVoidSmallJsonGT();
 setAtSmallBoolSmallJsonGT();
 setAtSmallBytesSmallJsonGT();
 setAtSmallDoubleSmallJsonGT();
 setAtSmallIntSmallJsonGT();
 setAtSmallJsonSmallJsonGT();
 setAtSmallStringSmallJsonGT();
 setAtSmallContainerSmallJsonGT();
 setAtNFreeSmallJsonGT();
 setAtNFreeUndefinedSmallJsonGT();
 setAtNFreeSSmallJsonGT();
 setAtNFreeDictSmallJsonGT();
 setAtNFreeArraySmallJsonGT();
 setAtNFreeArraycSmallJsonGT();
 setAtNFreeSmallBoolSmallJsonGT();
 setAtNFreeSmallBytesSmallJsonGT();
 setAtNFreeSmallDoubleSmallJsonGT();
 setAtNFreeSmallIntSmallJsonGT();
 setAtNFreeSmallJsonSmallJsonGT();
 setAtNFreeSmallStringSmallJsonGT();
 setAtNFreeSmallContainerSmallJsonGT();
 setPAtDictSmallJsonGT();
 setPAtArraySmallJsonGT();
 setPAtSmallJsonSmallJsonGT();
 setPAtSmallStringSmallJsonGT();
 setPAtNFreeDictSmallJsonGT();
 setPAtNFreeArraySmallJsonGT();
 setPAtNFreeSmallJsonSmallJsonGT();
 setPAtNFreeSmallStringSmallJsonGT();
 getSmallJsonGT();
 getUndefinedSmallJsonGT();
 getBoolSmallJsonGT();
 getBoolPSmallJsonGT();
 getDoubleSmallJsonGT();
 getDoublePSmallJsonGT();
 getIntSmallJsonGT();
 getIntPSmallJsonGT();
 getInt32SmallJsonGT();
 getInt32PSmallJsonGT();
 getUintSmallJsonGT();
 getUintPSmallJsonGT();
 getUint32SmallJsonGT();
 getUint32PSmallJsonGT();
 getSSmallJsonGT();
 getDictSmallJsonGT();
 getArraySmallJsonGT();
 getSmallBoolSmallJsonGT();
 getSmallBytesSmallJsonGT();
 getSmallDoubleSmallJsonGT();
 getSmallIntSmallJsonGT();
 getSmallJsonSmallJsonGT();
 getSmallStringSmallJsonGT();
 getVoidSmallJsonGT();
 getSmallContainerSmallJsonGT();
 getNDupSmallJsonGT();
 getNDupUndefinedSmallJsonGT();
 getNDupBoolSmallJsonGT();
 getNDupDoubleSmallJsonGT();
 getNDupIntSmallJsonGT();
 getNDupInt32SmallJsonGT();
 getNDupUintSmallJsonGT();
 getNDupUint32SmallJsonGT();
 getNDupSSmallJsonGT();
 getNDupDictSmallJsonGT();
 getNDupArraySmallJsonGT();
 getNDupSmallBoolSmallJsonGT();
 getNDupSmallBytesSmallJsonGT();
 getNDupSmallDoubleSmallJsonGT();
 getNDupSmallIntSmallJsonGT();
 getNDupSmallJsonSmallJsonGT();
 getNDupSmallStringSmallJsonGT();
 getNDupVoidSmallJsonGT();
 getNDupSmallContainerSmallJsonGT();
 getAtSmallJsonGT();
 getAtUndefinedSmallJsonGT();
 getAtBoolSmallJsonGT();
 getAtBoolPSmallJsonGT();
 getAtDoubleSmallJsonGT();
 getAtDoublePSmallJsonGT();
 getAtIntSmallJsonGT();
 getAtIntPSmallJsonGT();
 getAtInt32SmallJsonGT();
 getAtInt32PSmallJsonGT();
 getAtUintSmallJsonGT();
 getAtUintPSmallJsonGT();
 getAtUint32SmallJsonGT();
 getAtUint32PSmallJsonGT();
 getAtSSmallJsonGT();
 getAtDictSmallJsonGT();
 getAtArraySmallJsonGT();
 getAtSmallBoolSmallJsonGT();
 getAtSmallBytesSmallJsonGT();
 getAtSmallDoubleSmallJsonGT();
 getAtSmallIntSmallJsonGT();
 getAtSmallJsonSmallJsonGT();
 getAtSmallStringSmallJsonGT();
 getAtVoidSmallJsonGT();
 getAtSmallContainerSmallJsonGT();
 getAtNDupSmallJsonGT();
 getAtNDupUndefinedSmallJsonGT();
 getAtNDupBoolSmallJsonGT();
 getAtNDupDoubleSmallJsonGT();
 getAtNDupIntSmallJsonGT();
 getAtNDupInt32SmallJsonGT();
 getAtNDupUintSmallJsonGT();
 getAtNDupUint32SmallJsonGT();
 getAtNDupSSmallJsonGT();
 getAtNDupDictSmallJsonGT();
 getAtNDupArraySmallJsonGT();
 getAtNDupSmallBoolSmallJsonGT();
 getAtNDupSmallBytesSmallJsonGT();
 getAtNDupSmallDoubleSmallJsonGT();
 getAtNDupSmallIntSmallJsonGT();
 getAtNDupSmallJsonSmallJsonGT();
 getAtNDupSmallStringSmallJsonGT();
 getAtNDupVoidSmallJsonGT();
 getAtNDupSmallContainerSmallJsonGT();
 getNumSmallJsonGT();
 getNumAtSmallJsonGT();
 delKeySmallJsonGT();
 delSmallJsonGT();
 delElemSmallJsonGT();
 delElemIndexSmallJsonGT();
 prependSmallJsonGT();
 prependUndefinedSmallJsonGT();
 prependBoolSmallJsonGT();
 prependDoubleSmallJsonGT();
 prependIntSmallJsonGT();
 prependSSmallJsonGT();
 prependCharSmallJsonGT();
 prependDictSmallJsonGT();
 prependArraySmallJsonGT();
 prependArraycSmallJsonGT();
 prependCArraycSmallJsonGT();
 prependVoidSmallJsonGT();
 prependSmallBoolSmallJsonGT();
 prependSmallBytesSmallJsonGT();
 prependSmallDoubleSmallJsonGT();
 prependSmallIntSmallJsonGT();
 prependSmallJsonSmallJsonGT();
 prependSmallStringSmallJsonGT();
 prependSmallContainerSmallJsonGT();
 prependNFreeSmallJsonGT();
 prependNFreeUndefinedSmallJsonGT();
 prependNFreeSSmallJsonGT();
 prependNFreeDictSmallJsonGT();
 prependNFreeArraySmallJsonGT();
 prependNFreeArraycSmallJsonGT();
 prependNFreeSmallBoolSmallJsonGT();
 prependNFreeSmallBytesSmallJsonGT();
 prependNFreeSmallDoubleSmallJsonGT();
 prependNFreeSmallIntSmallJsonGT();
 prependNFreeSmallJsonSmallJsonGT();
 prependNFreeSmallStringSmallJsonGT();
 prependNFreeSmallContainerSmallJsonGT();
 dequeueSmallJsonGT();
 dequeueUndefinedSmallJsonGT();
 dequeueBoolSmallJsonGT();
 dequeueDoubleSmallJsonGT();
 dequeueIntSmallJsonGT();
 dequeueInt32SmallJsonGT();
 dequeueUintSmallJsonGT();
 dequeueUint32SmallJsonGT();
 dequeueSSmallJsonGT();
 dequeueDictSmallJsonGT();
 dequeueArraySmallJsonGT();
 dequeueSmallBoolSmallJsonGT();
 dequeueSmallBytesSmallJsonGT();
 dequeueSmallDoubleSmallJsonGT();
 dequeueSmallIntSmallJsonGT();
 dequeueSmallJsonSmallJsonGT();
 dequeueSmallStringSmallJsonGT();
 dequeueVoidSmallJsonGT();
 dequeueSmallContainerSmallJsonGT();
 reverseSmallJsonGT();
 mergeDictSmallJsonGT();
 mergeDictNSmashSmallJsonGT();
 mergeSmallJsonGT();
 mergeNSmashSmallJsonGT();
 appendSmallJsonGT();
 appendNSmashSmallJsonGT();
 appendArraySmallJsonGT();
 appendNSmashArraySmallJsonGT();
 appendCArraySmallJsonGT();
 shiftSmallJsonGT();
 shiftNSmashSmallJsonGT();
 shiftSmallJsonSmallJsonGT();
 shiftNSmashSmallJsonSmallJsonGT();
 addSmallJsonGT();
 addJsonSmallJsonGT();
 sliceSmallJsonGT();
 cropSmallJsonGT();
 cropSSmallJsonGT();
 cropSmallStringSmallJsonGT();
 cropElemAtSmallJsonGT();
 cropElemAtUndefinedSmallJsonGT();
 cropElemAtBoolSmallJsonGT();
 cropElemAtDoubleSmallJsonGT();
 cropElemAtIntSmallJsonGT();
 cropElemAtInt32SmallJsonGT();
 cropElemAtUintSmallJsonGT();
 cropElemAtUint32SmallJsonGT();
 cropElemAtSSmallJsonGT();
 cropElemAtCharSmallJsonGT();
 cropElemAtDictSmallJsonGT();
 cropElemAtArraySmallJsonGT();
 cropElemAtSmallBoolSmallJsonGT();
 cropElemAtSmallBytesSmallJsonGT();
 cropElemAtSmallDoubleSmallJsonGT();
 cropElemAtSmallIntSmallJsonGT();
 cropElemAtSmallJsonSmallJsonGT();
 cropElemAtSmallStringSmallJsonGT();
 cropElemAtVoidSmallJsonGT();
 cropElemAtSmallContainerSmallJsonGT();
 cropElemKeySmallJsonGT();
 cropElemKeyUndefinedSmallJsonGT();
 cropElemKeyBoolSmallJsonGT();
 cropElemKeyDoubleSmallJsonGT();
 cropElemKeyIntSmallJsonGT();
 cropElemKeyInt32SmallJsonGT();
 cropElemKeyUintSmallJsonGT();
 cropElemKeyUint32SmallJsonGT();
 cropElemKeySSmallJsonGT();
 cropElemKeyDictSmallJsonGT();
 cropElemKeyArraySmallJsonGT();
 cropElemKeySmallBoolSmallJsonGT();
 cropElemKeySmallBytesSmallJsonGT();
 cropElemKeySmallDoubleSmallJsonGT();
 cropElemKeySmallIntSmallJsonGT();
 cropElemKeySmallJsonSmallJsonGT();
 cropElemKeySmallStringSmallJsonGT();
 cropElemKeyVoidSmallJsonGT();
 cropElemKeySmallContainerSmallJsonGT();
 copySmallJsonGT();
 insertSmallJsonGT();
 insertNSmashSmallJsonGT();
 insertSmallJsonSmallJsonGT();
 insertNSmashSmallJsonSmallJsonGT();
 insertStringSmallJsonGT();
 insertSSmallJsonGT();
 insertNFreeSmallJsonGT();
 insertSNFreeStringSmallJsonGT();
 injectSmallJsonGT();
 injectUndefinedSmallJsonGT();
 injectBoolSmallJsonGT();
 injectDoubleSmallJsonGT();
 injectIntSmallJsonGT();
 injectSSmallJsonGT();
 injectCharSmallJsonGT();
 injectDictSmallJsonGT();
 injectArraySmallJsonGT();
 injectArraycSmallJsonGT();
 injectCArraycSmallJsonGT();
 injectVoidSmallJsonGT();
 injectSmallBoolSmallJsonGT();
 injectSmallBytesSmallJsonGT();
 injectSmallDoubleSmallJsonGT();
 injectSmallIntSmallJsonGT();
 injectSmallJsonSmallJsonGT();
 injectSmallStringSmallJsonGT();
 injectSmallContainerSmallJsonGT();
 injectNFreeSmallJsonGT();
 injectNFreeUndefinedSmallJsonGT();
 injectNFreeSSmallJsonGT();
 injectNFreeDictSmallJsonGT();
 injectNFreeArraySmallJsonGT();
 injectNFreeArraycSmallJsonGT();
 injectNFreeSmallBoolSmallJsonGT();
 injectNFreeSmallBytesSmallJsonGT();
 injectNFreeSmallDoubleSmallJsonGT();
 injectNFreeSmallIntSmallJsonGT();
 injectNFreeSmallJsonSmallJsonGT();
 injectNFreeSmallStringSmallJsonGT();
 injectNFreeSmallContainerSmallJsonGT();
 uniqSmallJsonGT();
 sortSmallJsonGT();
 sortFSmallJsonGT();
 icSortSmallJsonGT();
 icUniqSmallJsonGT();
 hasSmallJsonGT();
 hasUndefinedSmallJsonGT();
 hasBoolSmallJsonGT();
 hasDoubleSmallJsonGT();
 hasIntSmallJsonGT();
 hasSSmallJsonGT();
 hasCharSmallJsonGT();
 hasDictSmallJsonGT();
 hasArraySmallJsonGT();
 hasArraycSmallJsonGT();
 hasCArraycSmallJsonGT();
 hasSmallBoolSmallJsonGT();
 hasSmallBytesSmallJsonGT();
 hasSmallDoubleSmallJsonGT();
 hasSmallIntSmallJsonGT();
 hasSmallJsonSmallJsonGT();
 hasSmallStringSmallJsonGT();
 hasSmallContainerSmallJsonGT();
 findSmallJsonGT();
 findCharSmallJsonGT();
 findSmallStringSmallJsonGT();
 findJsonSmallJsonGT();
 indexOfSmallJsonGT();
 indexOfUndefinedSmallJsonGT();
 indexOfBoolSmallJsonGT();
 indexOfDoubleSmallJsonGT();
 indexOfIntSmallJsonGT();
 indexOfSSmallJsonGT();
 indexOfCharSmallJsonGT();
 indexOfDictSmallJsonGT();
 indexOfArraySmallJsonGT();
 indexOfArraycSmallJsonGT();
 indexOfCArraycSmallJsonGT();
 indexOfSmallBoolSmallJsonGT();
 indexOfSmallBytesSmallJsonGT();
 indexOfSmallDoubleSmallJsonGT();
 indexOfSmallIntSmallJsonGT();
 indexOfSmallJsonSmallJsonGT();
 indexOfSmallStringSmallJsonGT();
 indexOfSmallContainerSmallJsonGT();
 binarySearchSmallJsonGT();
 binarySearchUndefinedSmallJsonGT();
 binarySearchBoolSmallJsonGT();
 binarySearchDoubleSmallJsonGT();
 binarySearchIntSmallJsonGT();
 binarySearchSSmallJsonGT();
 binarySearchCharSmallJsonGT();
 binarySearchDictSmallJsonGT();
 binarySearchArraySmallJsonGT();
 binarySearchArraycSmallJsonGT();
 binarySearchCArraycSmallJsonGT();
 binarySearchSmallBoolSmallJsonGT();
 binarySearchSmallBytesSmallJsonGT();
 binarySearchSmallDoubleSmallJsonGT();
 binarySearchSmallIntSmallJsonGT();
 binarySearchSmallJsonSmallJsonGT();
 binarySearchSmallStringSmallJsonGT();
 binarySearchSmallContainerSmallJsonGT();
 icHasSmallJsonGT();
 icHasSSmallJsonGT();
 icHasCharSmallJsonGT();
 icHasDictSmallJsonGT();
 icHasArraySmallJsonGT();
 icHasArraycSmallJsonGT();
 icHasCArraycSmallJsonGT();
 icHasSmallStringSmallJsonGT();
 icFindSmallJsonGT();
 icFindCharSmallJsonGT();
 icFindSmallStringSmallJsonGT();
 icFindJsonSmallJsonGT();
 icIndexOfSmallJsonGT();
 icIndexOfSSmallJsonGT();
 icIndexOfCharSmallJsonGT();
 icIndexOfDictSmallJsonGT();
 icIndexOfArraySmallJsonGT();
 icIndexOfArraycSmallJsonGT();
 icIndexOfCArraycSmallJsonGT();
 icIndexOfSmallStringSmallJsonGT();
 icBinarySearchSmallJsonGT();
 icBinarySearchSSmallJsonGT();
 icBinarySearchCharSmallJsonGT();
 icBinarySearchDictSmallJsonGT();
 icBinarySearchArraySmallJsonGT();
 icBinarySearchArraycSmallJsonGT();
 icBinarySearchCArraycSmallJsonGT();
 icBinarySearchSmallStringSmallJsonGT();
 keyBySmallJsonGT();
 keyByUndefinedSmallJsonGT();
 keyByBoolSmallJsonGT();
 keyByDoubleSmallJsonGT();
 keyByIntSmallJsonGT();
 keyBySSmallJsonGT();
 keyByCharSmallJsonGT();
 keyByDictSmallJsonGT();
 keyByArraySmallJsonGT();
 keyByArraycSmallJsonGT();
 keyByCArraycSmallJsonGT();
 keyBySmallBoolSmallJsonGT();
 keyBySmallBytesSmallJsonGT();
 keyBySmallDoubleSmallJsonGT();
 keyBySmallIntSmallJsonGT();
 keyBySmallJsonSmallJsonGT();
 keyBySmallStringSmallJsonGT();
 keyBySmallContainerSmallJsonGT();
 icKeyBySmallJsonGT();
 icKeyBySSmallJsonGT();
 icKeyByCharSmallJsonGT();
 icKeyByDictSmallJsonGT();
 icKeyByArraySmallJsonGT();
 icKeyByArraycSmallJsonGT();
 icKeyByCArraycSmallJsonGT();
 icKeyBySmallStringSmallJsonGT();
 replaceSmallJsonGT();
 replaceCharSSmallJsonGT();
 replaceSCharSmallJsonGT();
 replaceCharCharSmallJsonGT();
 replaceSmallStringSmallStringSmallJsonGT();
 replaceSmallStringSSmallJsonGT();
 replaceSmallStringCharSmallJsonGT();
 replaceSSmallStringSmallJsonGT();
 replaceCharSmallStringSmallJsonGT();
 replaceJsonJsonSmallJsonGT();
 replaceJsonSmallStringSmallJsonGT();
 replaceJsonSSmallJsonGT();
 replaceJsonCharSmallJsonGT();
 replaceSmallStringJsonSmallJsonGT();
 replaceSJsonSmallJsonGT();
 replaceCharJsonSmallJsonGT();
 icReplaceSmallJsonGT();
 icReplaceCharSSmallJsonGT();
 icReplaceSCharSmallJsonGT();
 icReplaceCharCharSmallJsonGT();
 icReplaceSmallStringSmallStringSmallJsonGT();
 icReplaceSmallStringSSmallJsonGT();
 icReplaceSmallStringCharSmallJsonGT();
 icReplaceSSmallStringSmallJsonGT();
 icReplaceCharSmallStringSmallJsonGT();
 icReplaceJsonJsonSmallJsonGT();
 icReplaceJsonSmallStringSmallJsonGT();
 icReplaceJsonSSmallJsonGT();
 icReplaceJsonCharSmallJsonGT();
 icReplaceSmallStringJsonSmallJsonGT();
 icReplaceSJsonSmallJsonGT();
 icReplaceCharJsonSmallJsonGT();
 equalSmallJsonSmallArrayGT();
 equalSmallJsonArrayGT();
 equalSmallJsonCArrayGT();
 equalSmallJsonBaseGT();
 equalSmallJsonChaGT();
 equalSmallJsonCharGT();
 equalSmallJsonBoolGT();
 equalSmallJsonDoubleGT();
 equalSmallJsonInt64GT();
 equalSmallJsonInt32GT();
 equalSmallJsonUint32GT();
 equalSmallJsonUint64GT();
 equalSmallJsonSmallBoolGT();
 equalSmallJsonSmallBytesGT();
 equalSmallJsonSmallDoubleGT();
 equalSmallJsonSmallIntGT();
 equalSmallJsonSmallJsonGT();
 equalSmallJsonSmallStringGT();
 equalSmallJsonSmallDictGT();
 icEqualSmallJsonSmallArrayGT();
 icEqualSmallJsonArrayGT();
 icEqualSmallJsonCArrayGT();
 icEqualSmallJsonBaseGT();
 icEqualSmallJsonSmallDictGT();
 icEqualSmallJsonSmallJsonGT();
 icEqualSmallJsonSmallStringGT();
 icEqualCharSmallJsonGT();
 icEqualSSmallJsonGT();
 equalISSmallJsonGT();
 equalICharSmallJsonGT();
 equalIJsonSmallJsonGT();
 equalISmallStringSmallJsonGT();
 startsWithSSmallJsonGT();
 startsWithCharSmallJsonGT();
 startsWithSmallStringSmallJsonGT();
 startsWithJsonSmallJsonGT();
 endsWithSSmallJsonGT();
 endsWithCharSmallJsonGT();
 endsWithSmallStringSmallJsonGT();
 endsWithJsonSmallJsonGT();
 countSSmallJsonGT();
 countCharSmallJsonGT();
 countSmallStringSmallJsonGT();
 countJsonSmallJsonGT();
 icStartsWithSSmallJsonGT();
 icStartsWithCharSmallJsonGT();
 icStartsWithSmallStringSmallJsonGT();
 icStartsWithJsonSmallJsonGT();
 icEndsWithSSmallJsonGT();
 icEndsWithCharSmallJsonGT();
 icEndsWithSmallStringSmallJsonGT();
 icEndsWithJsonSmallJsonGT();
 icCountSSmallJsonGT();
 icCountCharSmallJsonGT();
 icCountSmallStringSmallJsonGT();
 icCountJsonSmallJsonGT();
 isNumberSmallJsonGT();
 isIntSmallJsonGT();
 parseIntSmallJsonGT();
 parseDoubleSmallJsonGT();
 intToSmallJsonGT();
 doubleToSmallJsonGT();
 lenSmallJsonGT();
 upperSmallJsonGT();
 lowerSmallJsonGT();
 trimSmallJsonGT();
 lTrimSmallJsonGT();
 rTrimSmallJsonGT();
 compactSmallJsonGT();
 emptySmallJsonGT();
 isEmptySmallJsonGT();
 isBlankSmallJsonGT();
 joinSmallJsonGT();
 joinCharSmallJsonGT();
 joinSmallJsonSmallJsonGT();
 joinSmallStringSmallJsonGT();
 joinSSmallJsonGT();
 joinCharSSmallJsonGT();
 joinSmallJsonSSmallJsonGT();
 joinSmallStringSSmallJsonGT();
 splitSmallJsonGT();
 splitCharSmallJsonGT();
 splitSmallJsonSmallJsonGT();
 splitSmallStringSmallJsonGT();
 splitSSmallJsonGT();
 splitCharSSmallJsonGT();
 splitSmallJsonSSmallJsonGT();
 splitSmallStringSSmallJsonGT();
 extractSmallJsonGT();
 extractCharSSmallJsonGT();
 extractSCharSmallJsonGT();
 extractCharCharSmallJsonGT();
 extractSmallJsonSmallJsonSmallJsonGT();
 extractSmallJsonSmallStringSmallJsonGT();
 extractSmallJsonSSmallJsonGT();
 extractSmallJsonCharSmallJsonGT();
 extractSmallStringSmallJsonSmallJsonGT();
 extractSmallStringSmallStringSmallJsonGT();
 extractSmallStringSSmallJsonGT();
 extractSmallStringCharSmallJsonGT();
 extractSSmallJsonSmallJsonGT();
 extractSSmallStringSmallJsonGT();
 extractCharSmallJsonSmallJsonGT();
 extractCharSmallStringSmallJsonGT();
 icSplitSmallJsonGT();
 icSplitCharSmallJsonGT();
 icSplitSmallJsonSmallJsonGT();
 icSplitSmallStringSmallJsonGT();
 icSplitSSmallJsonGT();
 icSplitCharSSmallJsonGT();
 icSplitSmallJsonSSmallJsonGT();
 icSplitSmallStringSSmallJsonGT();
 icExtractSmallJsonGT();
 icExtractCharSSmallJsonGT();
 icExtractSCharSmallJsonGT();
 icExtractCharCharSmallJsonGT();
 icExtractSmallJsonSmallJsonSmallJsonGT();
 icExtractSmallJsonSmallStringSmallJsonGT();
 icExtractSmallJsonSSmallJsonGT();
 icExtractSmallJsonCharSmallJsonGT();
 icExtractSmallStringSmallJsonSmallJsonGT();
 icExtractSmallStringSmallStringSmallJsonGT();
 icExtractSmallStringSSmallJsonGT();
 icExtractSmallStringCharSmallJsonGT();
 icExtractSSmallJsonSmallJsonGT();
 icExtractSSmallStringSmallJsonGT();
 icExtractCharSmallJsonSmallJsonGT();
 icExtractCharSmallStringSmallJsonGT();
 zipSmallJsonGT();
 zipArraySmallJsonGT();
 zipCArraySmallJsonGT();
 zipCharSmallJsonGT();
 zipCCharSmallJsonGT();
 zipArrayCharSmallJsonGT();
 zipArrayCCharSmallJsonGT();
 zipCArrayCharSmallJsonGT();
 zipCArrayCCharSmallJsonGT();
 zipJsonSmallJsonGT();
 zipJsonSmallArraySmallJsonGT();
 zipJsonArraySmallJsonGT();
 zipJsonCArraySmallJsonGT();
 zipSmallArrayJsonSmallJsonGT();
 zipArrayJsonSmallJsonGT();
 zipCArrayJsonSmallJsonGT();
 stringifySmallStringSmallJsonGT();
 toYMLSmallStringSmallJsonGT();
 parseSmallJsonGT();
 parseSmallJsonSmallJsonGT();
 parseSmallStringSmallJsonGT();
 parseYMLSmallJsonGT();
 parseYMLSmallJsonSmallJsonGT();
 parseYMLSmallStringSmallJsonGT();
 logSmallJsonGT();
 readFileSmallJsonGT();
 readFileSmallStringSmallJsonGT();
 readFileJsonSmallJsonGT();
 readStreamSmallJsonGT();
 writeFileSmallJsonGT();
 writeFileSmallStringSmallJsonGT();
 writeFileJsonSmallJsonGT();
 writeStreamSmallJsonGT();
 appendFileSmallJsonGT();
 appendFileSmallStringSmallJsonGT();
 appendFileJsonSmallJsonGT();
 readTextSmallJsonGT();
 readTextSmallStringSmallJsonGT();
 readTextJsonSmallJsonGT();
 readTextStreamSmallJsonGT();
 writeTextSmallJsonGT();
 writeTextSmallStringSmallJsonGT();
 writeTextJsonSmallJsonGT();
 writeTextStreamSmallJsonGT();
 appendTextSmallStringSmallJsonGT();
 appendTextJsonSmallJsonGT();
 cSmallJsonT();
 
 finalizeSmallDict();
 finalizeSmallArray();
 finalizeSmallJson();
 finalizeUndefined();
 finalizeSmallBytes();
 finalizeSmallBool();
 finalizeSmallContainer();
 finalizeSmallDouble();
 finalizeSmallInt();
 finalizeSmallString();
 }