libsheepyObjectTest.c

Go to the documentation of this file.

#include <stdlib.h>
#include <stdio.h>
#include <check.h>

//START MEM TEST ANCHOR

#include "../libsheepy.h"
#include "../libsheepyObject.h"

#ifdef __GNUC__
#define UNUSED __attribute__ ((unused))
#else
#define UNUSED
#endif

// TODO redirect stderr

START_TEST(cSmallDictT)

  // local object
  createSmallDict(obj);
  ck_assert_str_eq(obj.type, "smallDict");
  // object
  createAllocateSmallDict(obj2);
  ck_assert_str_eq(obj2->type, "smallDict");
  // toString
  char *s = obj2->f->toString(obj2);
  ck_assert_str_eq(s, "{}");
  free(s);
  // duplicate
  smallDictt *o;
  createAllocateSmallBool(oBool2);
  oBool2->f->set(oBool2, true);
  obj2->f->set(obj2, "lib", (baset *)oBool2);
  finishO(oBool2);
  o = obj2->f->duplicate(obj2);
  smallBoolt *oBool3;
  oBool3 = (smallBoolt *)o->f->get(o, "lib");
  ck_assert_ptr_ne(oBool3, NULL);
  ck_assert(oBool3->value->value == true);
  finishO(oBool3);
  terminateO(o);
  // toString
  createAllocateUndefined(oU);
  obj2->f->set(obj2, "u", (baset *)oU);
  finishO(oU);
  createAllocateSmallString(oStr);
  oStr->f->set(oStr, "sheepy");
  obj2->f->set(obj2, "str", (baset *)oStr);
  finishO(oStr);
  s = obj2->f->toString(obj2);
  ck_assert_str_eq(s, "{\"lib\":true,\"u\":null,\"str\":\"sheepy\"}");
  free(s);
  // dispose
  o                = obj2->f->duplicate(obj2);
  undefinedt *u    = (undefinedt *) o->f->get(o, "u");
  smallStringt *st = (smallStringt *) o->f->get(o, "str");
  oBool2           = (smallBoolt *) o->f->get(o, "lib");
  smallt *data     = sDictGetTiny(o->d, "u");
  sFree(data);
  data  = sDictGetTiny(o->d, "str");
  sFree(data);
  data  = sDictGetTiny(o->d, "lib");
  sFree(data);
  o->f->dispose(o);
  ck_assert_uint_eq(o->f->len(o), 0);
  terminateO(u);
  smashO(st);
  smashO(oBool2);
  terminateO(o);
  // smash
  o      = obj2->f->duplicate(obj2);
  u      = (undefinedt *) o->f->get(o, "u");
  st     = (smallStringt *) o->f->get(o, "str");
  oBool2 = (smallBoolt *) o->f->get(o, "lib");
  data  = sDictGetTiny(o->d, "u");
  sFree(data);
  data  = sDictGetTiny(o->d, "str");
  sFree(data);
  data  = sDictGetTiny(o->d, "lib");
  sFree(data);
  o->f->smash(&o);
  terminateO(u);
  smashO(st);
  smashO(oBool2);
  ck_assert_ptr_eq(o, NULL);
  // set NULL (not possible)
  obj2->f->set(obj2, NULL, NULL);
  obj2->f->set(obj2, "no", NULL);
  ck_assert_uint_eq(obj2->f->len(obj2), 3);
  // get non existing element
  oBool3 = (smallBoolt *)obj2->f->get(obj2, "non existing");
  ck_assert_ptr_eq(oBool3, NULL);
  ck_assert_ptr_eq(obj2->f->get(obj2, NULL), NULL);
  // delete element
  obj2->f->del(obj2, "lib");
  oBool3 = (smallBoolt *)obj2->f->get(obj2, "lib");
  ck_assert_ptr_eq(oBool3, NULL);
  // delete non existing element
  obj2->f->del(obj2, NULL);
  obj2->f->del(obj2, "non existing");
  // has
  ck_assert(!obj2->f->has(obj2, "qwe"));
  ck_assert(!obj2->f->has(obj2, NULL));
  ck_assert(obj2->f->has(obj2, "u"));
  // keys
  char **keys = obj2->f->keys(obj2);
  size_t len  = listLengthS(keys);
  ck_assert_uint_eq(len, 2);
  ck_assert_str_eq(keys[0], "u");
  ck_assert_str_eq(keys[1], "str");
  listFreeS(keys);
    // empty dict
  initiateAllocateSmallDict(&o);
  keys = o->f->keys(o);
  ck_assert_ptr_eq(keys, NULL);
  terminateO(o);
  // values
  smallArrayt *values = obj2->f->values(obj2);
  s  = toStringO(values);
  ck_assert_str_eq(s, "[null,\"sheepy\"]");
  free(s);
  values->f->smash(&values);
    // empty dict
  initiateAllocateSmallDict(&o);
  values = o->f->values(o);
  ck_assert_ptr_eq(values, NULL);
  terminateO(o);
  // merge
  smallDictt *oM;
  o = obj2->f->duplicate(obj2);
  initiateAllocateSmallDict(&oM);
  initiateAllocateSmallString(&st);
  st->f->set(st, "SHEEPY MERGED");
  oM->f->set(oM, "str", (baset *) st);
  finishO(st);
  s = toStringO(o);
  ck_assert_str_eq(s, "{\"u\":null,\"str\":\"sheepy\"}");
  free(s);
  o->f->merge(o, oM);
  s = toStringO(o);
  ck_assert_str_eq(s, "{\"u\":null,\"str\":\"SHEEPY MERGED\"}");
  free(s);
  oM->f->smash(&oM);
  terminateO(o);
    // empty dict
  o = obj2->f->duplicate(obj2);
  initiateAllocateSmallDict(&oM);
  s = toStringO(o);
  ck_assert_str_eq(s, "{\"u\":null,\"str\":\"sheepy\"}");
  free(s);
  o->f->merge(o, oM);
  s = toStringO(o);
  ck_assert_str_eq(s, "{\"u\":null,\"str\":\"sheepy\"}");
  free(s);
  oM->f->smash(&oM);
  terminateO(o);
    // NULL dict
  o = obj2->f->duplicate(obj2);
  s = toStringO(o);
  ck_assert_str_eq(s, "{\"u\":null,\"str\":\"sheepy\"}");
  free(s);
  o->f->merge(o, NULL);
  s = toStringO(o);
  ck_assert_str_eq(s, "{\"u\":null,\"str\":\"sheepy\"}");
  free(s);
  terminateO(o);
  // append
  o = obj2->f->duplicate(obj2);
  initiateAllocateSmallDict(&oM);
  initiateAllocateSmallString(&st);
  initiateAllocateUndefined(&oU);
  st->f->set(st, "SHEEPY MERGED");
  oM->f->set(oM, "str", (baset *) st);
  finishO(st);
  oM->f->set(oM, "u2", (baset *) oU);
  finishO(oU);
  s = toStringO(o);
  ck_assert_str_eq(s, "{\"u\":null,\"str\":\"sheepy\"}");
  free(s);
  o->f->append(o, oM);
  s = toStringO(o);
  ck_assert_str_eq(s, "{\"u\":null,\"str\":\"sheepy\",\"u2\":null}");
  free(s);
  data  = sDictGetTiny(oM->d, "str");
  sFree(data);
  oM->f->smash(&oM);
  terminateO(o);
    // empty dict
  o = obj2->f->duplicate(obj2);
  initiateAllocateSmallDict(&oM);
  s = toStringO(o);
  ck_assert_str_eq(s, "{\"u\":null,\"str\":\"sheepy\"}");
  free(s);
  o->f->append(o, oM);
  s = toStringO(o);
  ck_assert_str_eq(s, "{\"u\":null,\"str\":\"sheepy\"}");
  free(s);
  oM->f->smash(&oM);
  terminateO(o);
    // NULL dict
  o = obj2->f->duplicate(obj2);
  s = toStringO(o);
  ck_assert_str_eq(s, "{\"u\":null,\"str\":\"sheepy\"}");
  free(s);
  o->f->append(o, NULL);
  s = toStringO(o);
  ck_assert_str_eq(s, "{\"u\":null,\"str\":\"sheepy\"}");
  free(s);
  terminateO(o);
  // len
  ck_assert_uint_eq(obj2->f->len(obj2), 2);
    // empty dict
  initiateAllocateSmallDict(&o);
  ck_assert_uint_eq(o->f->len(o), 0);
  terminateO(o);
  // empty
  o = obj2->f->duplicate(obj2);
  o->f->empty(o);
  ck_assert_uint_eq(o->f->len(o), 0);
  terminateO(o);
  // typeString type typeStrings
  initiateAllocateSmallDict(&oM);
  o = allocSmallDict();
  oU = allocUndefined();
  o->f->set(o, "u", (baset *)oU);
  finishO(oU);
  st = allocSmallString("sheepy");
  o->f->set(o, "str", (baset *) st);
  finishO(st);
  oBool2 = allocSmallBool(true);
  o->f->set(o, "b", (baset *)oBool2);
  finishO(oBool2);
  oBool2 = allocSmallBool(true);
  o->f->set(o, "B", (baset *)oBool2);
  finishO(oBool2);
  o->f->del(o, "B");
    // typeString
  s = (char *)o->f->typeString(o, "b");
  ck_assert_str_eq(s, "bool");
      // non existing key
  ck_assert_ptr_eq(o->f->typeString(o, "B"), NULL);
      // empty object
  ck_assert_ptr_eq(oM->f->typeString(oM, "B"), NULL);
    // type
  char c;
  c = o->f->type(o, "str");
  ck_assert_uint_eq(c, STRING);
      // non existing key
  ck_assert(!o->f->type(o, "B"));
      // empty object
  ck_assert(!oM->f->type(oM, "B"));
    // typeStrings
  smallDictt *oT = o->f->typeStrings(o);
  s = toStringO(oT);
  ck_assert_str_eq(s, "{\"u\":\"undefined\",\"str\":\"string\",\"b\":\"bool\"}");
  free(s);
  terminateO(oT);
    // empty object
  oT = oM->f->typeStrings(oM);
  ck_assert_ptr_eq(oT, NULL);
  terminateO(o);
  terminateO(oM);
  // free local object
  obj.f->free(&obj);
  ck_assert_str_eq(obj.type, "smallDict");
  // free object
  obj2->f->terminate(&obj2);
  ck_assert_ptr_eq(obj2, NULL);

END_TEST


START_TEST(cSmallJsonT)

  // 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);
  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
  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);
  createAllocateSmallDict(jdict);
      // setTop
  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);
  pErrorNULL(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);

END_TEST


START_TEST(cSmallArrayT)

  // local object
  createSmallArray(obj);
  ck_assert_str_eq(obj.type, "smallArray");
  // object
  createAllocateSmallArray(obj2);
  ck_assert_str_eq(obj2->type, "smallArray");
  // toString
  char *s = obj2->f->toString(obj2);
  ck_assert_str_eq(s, "[]");
  free(s);
  createAllocateUndefined(oU);
  obj2->f->push(obj2, (baset *)oU);
  finishO(oU);
  createAllocateSmallInt(oInt);
  oInt->f->set(oInt, 123);
  obj2->f->push(obj2, (baset *)oInt);
  finishO(oInt);
  createAllocateSmallString(oStr);
  oStr->f->set(oStr, "sheepy");
  obj2->f->push(obj2, (baset *)oStr);
  finishO(oStr);
  s = obj2->f->toString(obj2);
  ck_assert_str_eq(s, "[null,123,\"sheepy\"]");
  free(s);
    // delete an element
  smallArrayt *o2;
  o2 = obj2->f->duplicate(obj2);
  o2->f->delElem(o2, 0);
  s = o2->f->toString(o2);
  ck_assert_str_eq(s, "[123,\"sheepy\"]");
  free(s);
  terminateO(o2);
  // duplicate
  smallArrayt *o;
  o = obj2->f->duplicate(obj2);
  undefinedt *u;
  u = (undefinedt *) o->f->getAt(o, 0);
  ck_assert(isOType(u, "undefined"));
  terminateO(u);
  smallIntt *in;
  in = (smallIntt *) o->f->getAt(o, 1);
  ck_assert(in->value->value == 123);
  smashO(in);
  smallStringt *st;
  st = (smallStringt *) o->f->getAt(o, 2);
  bool r = strEq(st->f->get(st), "sheepy");
  ck_assert(r);
  smashO(st);
  terminateO(o);
    // delete an element
  o2 = obj2->f->duplicate(obj2);
  o2->f->delElem(o2, 0);
  o = o2->f->duplicate(o2);
  in = (smallIntt *) o->f->getAt(o, 0);
  ck_assert(in->value->value == 123);
  smashO(in);
  st = (smallStringt *) o->f->getAt(o, 1);
  r = strEq(st->f->get(st), "sheepy");
  ck_assert(r);
  smashO(st);
  terminateO(o);
  terminateO(o2);
  // fromArray
  initiateAllocateSmallArray(&o);
  char *array[] = {"1", "22", "333"};
  char *arrayNULL[] = {"1", NULL, "333"};
    // copy array to list
  o->f->fromArray(o, (void *)array, 3);
  ck_assert_uint_eq(o->f->len(o),3);
  smallStringt *strFrom;
  strFrom = (smallStringt*) o->f->getAt(o,0);
  ck_assert_str_eq(strFrom->f->get(strFrom), "1");
  smashO(strFrom);
  strFrom = (smallStringt*) o->f->getAt(o,1);
  ck_assert_str_eq(strFrom->f->get(strFrom), "22");
  smashO(strFrom);
  strFrom = (smallStringt*) o->f->getAt(o,2);
  ck_assert_str_eq(strFrom->f->get(strFrom), "333");
  smashO(strFrom);
    // array with NULL inside
  o->f->fromArray(o, (void *)arrayNULL, 3);
  ck_assert_uint_eq(o->f->len(o),3);
  strFrom = (smallStringt*) o->f->getAt(o,0);
  ck_assert_str_eq(strFrom->f->get(strFrom), "1");
  smashO(strFrom);
  strFrom = (smallStringt*) o->f->getAt(o,1);
  ck_assert_ptr_eq(strFrom, NULL);
  strFrom = (smallStringt*) o->f->getAt(o,2);
  ck_assert_str_eq(strFrom->f->get(strFrom), "333");
  smashO(strFrom);
    // char** list
  char **shpList = listCreateS("lib", "sheepy");
  o->f->fromArray(o, shpList, 0);
  ck_assert_uint_eq(o->f->len(o),2);
  listFreeS(shpList);
    // NULL pointer to list - list not changed
  o->f->fromArray(o, (void *)arrayNULL, 3);
  o->f->fromArray(o, NULL, 3);
  ck_assert_uint_eq(o->f->len(o),3);
  strFrom = (smallStringt*) o->f->getAt(o,0);
  ck_assert_str_eq(strFrom->f->get(strFrom), "1");
  smashO(strFrom);
  strFrom = (smallStringt*) o->f->getAt(o,1);
  ck_assert_ptr_eq(strFrom, NULL);
  strFrom = (smallStringt*) o->f->getAt(o,2);
  ck_assert_str_eq(strFrom->f->get(strFrom), "333");
  smashO(strFrom);
  terminateO(o);
  // push
  o = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 654);
  o->f->push(o, (baset *)in);
  finishO(in);
  in = (smallIntt *) o->f->getAt(o, 3);
  ck_assert_uint_eq(o->f->len(o), 4);
  ck_assert_uint_eq(in->value->value, 654);
  smashO(in);
    // NULL
  o->f->push(o, NULL);
  ck_assert_uint_eq(o->f->len(o), 4);
  terminateO(o);
  // pop
  o = obj2->f->duplicate(obj2);
  ck_assert_uint_eq(o->f->len(o), 3);
  st = (smallStringt *) o->f->pop(o);
  ck_assert_uint_eq(o->f->len(o), 2);
  ck_assert_str_eq(st->f->get(st), "sheepy");
  terminateO(st);
  in = (smallIntt *) o->f->pop(o);
  ck_assert_uint_eq(in->value->value, 123);
  terminateO(in);
  u = (undefinedt *) o->f->pop(o);
  ck_assert(isOType(u, "undefined"));
  terminateO(u);
    // empty list
  u = (undefinedt *) o->f->pop(o);
  ck_assert_ptr_eq(u,NULL);
    // after initialize
  o->f->free(o);
  ck_assert_uint_eq(o->f->len(o), 0);
  u = (undefinedt *) o->f->pop(o);
  ck_assert_uint_eq(o->f->len(o), 0);
  ck_assert_ptr_eq(u,NULL);
  terminateO(o);
  // append
  o  = obj2->f->duplicate(obj2);
  o2 = obj2->f->duplicate(obj2);
  in = (smallIntt *) o2->f->getAt(o2, 1);
  in->value->value = 789;
  o2->f->setAt(o2, 1, (baset *)in);
  finishO(in);
  o->f->append(o, o2);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]");
  free(s);
    // same list
  o->f->append(o, o);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]");
  free(s);
  o->f->free(o);
  o2->f->smash(&o2);
    // empty list + list
  o2 = obj2->f->duplicate(obj2);
  in = (smallIntt *) o2->f->getAt(o2, 1);
  in->value->value = 789;
  o2->f->setAt(o2, 1, (baset *)in);
  finishO(in);
  o->f->append(o, o2);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,789,\"sheepy\"]");
  free(s);
    // list + empty list
  o2->f->dispose(o2);
  o->f->append(o, o2);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,789,\"sheepy\"]");
  free(s);
    // empty list + empty list
  o->f->free(o);
  o->f->append(o, o2);
  s = toStringO(o);
  ck_assert_str_eq(s, "[]");
  free(s);
  terminateO(o2);
    // NULL list
  o->f->append(o, NULL);
  s = toStringO(o);
  ck_assert_str_eq(s, "[]");
  free(s);
  terminateO(o);
  // slice
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->slice(o,1,-1);
  s = toStringO(o);
  ck_assert_str_eq(s, "[123,\"sheepy\"]");
  free(s);
  terminateO(o);
    // start outside
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->slice(o,20,-1);
  s = toStringO(o);
  ck_assert_str_eq(s, "[]");
  free(s);
  terminateO(o);
    // start negative and outside
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->slice(o,-20,1);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null]");
  free(s);
  terminateO(o);
    // end outside
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->slice(o,2,40);
  s = toStringO(o);
  ck_assert_str_eq(s, "[\"sheepy\",5345]");
  free(s);
  terminateO(o);
    // end negative and outside
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->slice(o,2,-40);
  s = toStringO(o);
  ck_assert_str_eq(s, "[]");
  free(s);
  terminateO(o);
    // end before start
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->slice(o,3,2);
  s = toStringO(o);
  ck_assert_str_eq(s, "[]");
  free(s);
  terminateO(o);
    // negative start last element
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->slice(o,-1,0);
  s = toStringO(o);
  ck_assert_str_eq(s, "[5345]");
  free(s);
  terminateO(o);
    // start = end
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->slice(o,1,1);
  s = toStringO(o);
  ck_assert_str_eq(s, "[]");
  free(s);
  terminateO(o);
    // empty list
  initiateAllocateSmallArray(&o);
  o->f->slice(o,0,0);
  s = toStringO(o);
  ck_assert_str_eq(s, "[]");
  free(s);
  terminateO(o);
  // insert
  o  = obj2->f->duplicate(obj2);
  o2 = obj2->f->duplicate(obj2);
  in = (smallIntt *) o2->f->getAt(o2, 1);
  in->value->value = 789;
  o2->f->setAt(o2, 1, (baset *)in);
  finishO(in);
  o->f->insert(o, 0, o2);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,789,\"sheepy\",null,123,\"sheepy\"]");
  free(s);
  terminateO(o);
  o2->f->smash(&o2);
    // negative index
  o  = obj2->f->duplicate(obj2);
  o2 = obj2->f->duplicate(obj2);
  in = (smallIntt *) o2->f->getAt(o2, 1);
  in->value->value = 789;
  o2->f->setAt(o2, 1, (baset *)in);
  finishO(in);
  o->f->insert(o, -1, o2);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]");
  free(s);
  terminateO(o);
  o2->f->smash(&o2);
    // edge
  o  = obj2->f->duplicate(obj2);
  o2 = obj2->f->duplicate(obj2);
  in = (smallIntt *) o2->f->getAt(o2, 1);
  in->value->value = 789;
  o2->f->setAt(o2, 1, (baset *)in);
  finishO(in);
  o->f->insert(o, 3, o2);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,123,\"sheepy\",null,789,\"sheepy\"]");
  free(s);
  terminateO(o);
  o2->f->smash(&o2);
    // outside
  o  = obj2->f->duplicate(obj2);
  o2 = obj2->f->duplicate(obj2);
  in = (smallIntt *) o2->f->getAt(o2, 1);
  in->value->value = 789;
  o2->f->setAt(o2, 1, (baset *)in);
  finishO(in);
  o->f->insert(o, 4, o2);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,123,\"sheepy\"]");
  free(s);
  o->f->insert(o, -5, o2);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,123,\"sheepy\"]");
  free(s);
  terminateO(o);
  terminateO(o2);
    // negative index in a one element list
  o  = obj2->f->duplicate(obj2);
  o2 = obj2->f->duplicate(obj2);
  in = (smallIntt *) o2->f->getAt(o2, 1);
  in->value->value = 789;
  o2->f->setAt(o2, 1, (baset *)in);
  finishO(in);
  o->f->delElem(o, 1);
  o->f->delElem(o, 2);
  o->f->trim(o);
  o->f->insert(o, -1, o2);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,null,789,\"sheepy\"]");
  free(s);
  terminateO(o);
  o2->f->smash(&o2);
    // empty list
  initiateAllocateSmallArray(&o);
  o2 = obj2->f->duplicate(obj2);
  in = (smallIntt *) o2->f->getAt(o2, 1);
  in->value->value = 789;
  o2->f->setAt(o2, 1, (baset *)in);
  finishO(in);
  o->f->insert(o, 0, o2);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,789,\"sheepy\"]");
  free(s);
  terminateO(o);
  o2->f->dispose(o2);
    // empty insert list
  o  = obj2->f->duplicate(obj2);
  o->f->insert(o, 0, o2);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,123,\"sheepy\"]");
  free(s);
  terminateO(o);
  o2->f->smash(&o2);
    //NULL insert
  o  = obj2->f->duplicate(obj2);
  o->f->insert(o, 0, NULL);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,123,\"sheepy\"]");
  free(s);
  terminateO(o);
  // del
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->del(o,1,-1);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,5345]");
  free(s);
  terminateO(o);
    // start outside
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->del(o,20,-1);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]");
  free(s);
  terminateO(o);
    // start negative and outside
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->del(o,-20,1);
  s = toStringO(o);
  ck_assert_str_eq(s, "[123,\"sheepy\",5345]");
  free(s);
  terminateO(o);
    // end outside
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->del(o,2,40);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,123]");
  free(s);
  terminateO(o);
    // end negative and outside
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->del(o,2,-40);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]");
  free(s);
  terminateO(o);
    // end before start
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->del(o,3,2);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]");
  free(s);
  terminateO(o);
    // negative start last element
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->del(o,-1,0);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,123,\"sheepy\"]");
  free(s);
  terminateO(o);
    // start = end
  o  = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  in->f->set(in, 5345);
  o->f->push(o, (baset *) in);
  finishO(in);
  o->f->del(o,1,1);
  s = toStringO(o);
  ck_assert_str_eq(s, "[null,123,\"sheepy\",5345]");
  free(s);
  terminateO(o);
    // empty list
  initiateAllocateSmallArray(&o);
  o->f->del(o,0,0);
  s = toStringO(o);
  ck_assert_str_eq(s, "[]");
  free(s);
  terminateO(o);
  // len
  ck_assert_uint_eq(obj2->f->len(obj2), 3);
  // trim
  o = obj2->f->duplicate(obj2);
  ck_assert_uint_eq(o->f->len(o), 3);
  st = (smallStringt *) o->f->pop(o);
  terminateO(st);
  o->f->delElem(o, 0);
  o->f->trim(o);
  ck_assert_uint_eq(o->f->len(o), 1);
  s = toStringO(o);
  ck_assert_str_eq(s, "[123]");
  free(s);
  terminateO(o);
  // getAt
  o = obj2->f->duplicate(obj2);
  u = (undefinedt *) o->f->getAt(o, 0);
  ck_assert_str_eq(u->type, "undefined");
  terminateO(u);
  st = (smallStringt *) o->f->getAt(o, -1);
  ck_assert_str_eq(st->type, "smallString");
  smashO(st);
    // outside
  u = (undefinedt *) o->f->getAt(o, 4);
  ck_assert_ptr_eq(u, NULL);
  u = (undefinedt *) o->f->getAt(o, -4);
  ck_assert_ptr_eq(u, NULL);
  terminateO(o);
    // empty
  initiateAllocateSmallArray(&o);
  u = (undefinedt *) o->f->getAt(o, 0);
  ck_assert_ptr_eq(u, NULL);
  terminateO(o);
  // setAt
  o = obj2->f->duplicate(obj2);
  initiateAllocateSmallInt(&in);
  o->f->setAt(o, 0, (baset *) in);
  finishO(in);
  s = toStringO(o);
  ck_assert_str_eq(s, "[0,123,\"sheepy\"]");
  free(s);
  initiateAllocateSmallInt(&in);
  o->f->setAt(o, -1, (baset *) in);
  finishO(in);
  s = toStringO(o);
  ck_assert_str_eq(s, "[0,123,0]");
  free(s);
    // outside
  o->f->setAt(o, 4, (baset *) in);
  s = toStringO(o);
  ck_assert_str_eq(s, "[0,123,0]");
  free(s);
  o->f->setAt(o, -4, (baset *) in);
  s = toStringO(o);
  ck_assert_str_eq(s, "[0,123,0]");
  free(s);
  terminateO(o);
  // empty
  o = obj2->f->duplicate(obj2);
  o->f->empty(o);
  ck_assert(o->f->isEmpty(o));
  terminateO(o);
  // isEmpty
  o = obj2->f->duplicate(obj2);
  ck_assert(!o->f->isEmpty(o));
  terminateO(o);
  initiateAllocateSmallArray(&o);
  ck_assert(o->f->isEmpty(o));
  terminateO(o);
  // typeString type typeStrings types
  initiateAllocateSmallArray(&o2);
  o  = allocSmallArray();
  oU = allocUndefined();
  o->f->push(o, (baset *)oU);
  finishO(oU);
  oInt = allocSmallInt(123);
  o->f->push(o, (baset *)oInt);
  finishO(oInt);
  oStr = allocSmallString("sheepy");
  o->f->push(o, (baset *)oStr);
  finishO(oStr);
  o->f->push(o, NULL);
    // typeString
  s = (char *)o->f->typeString(o, 0);
  ck_assert_str_eq(s, "undefined");
    // type
  char c = o->f->type(o, 2);
  ck_assert_uint_eq(c, STRING);
      // negative index
  c = o->f->type(o, -2);
  ck_assert_uint_eq(c, INT);
      // outside
  ck_assert(!o->f->type(o, 10));
  ck_assert(!o->f->type(o, -14));
      // NULL element
  c = o->f->type(o, 0);
  ck_assert_uint_eq(c, UNDEFINED);
      // empty object
  ck_assert(!o2->f->type(o2, 0));
    // typeStrings
  const char **l = o->f->typeStrings(o);
  s = joinCS(l, ",");
  ck_assert_str_eq(s, "undefined,int,string");
  free(s);
  free(l);
      // empty object
  ck_assert_ptr_eq(o2->f->typeStrings(o2), NULL);
    // types
  smallBytest *B = o->f->types(o);
  s = sToStringTiny((smallt *)B->B);
  ck_assert_str_eq(s, "[0x01,0x07,0x08]");
  free(s);
      // empty object
  ck_assert_ptr_eq(o2->f->types(o2), NULL);
  terminateO(B);
  terminateO(o);
  terminateO(o2);
  // free local object
  obj.f->free(&obj);
  ck_assert_str_eq(obj.type, "smallArray");
  // free object
  obj2->f->terminate(&obj2);
  ck_assert_ptr_eq(obj2, NULL);
  // init NULL
  initiateAllocateSmallArray(NULL);

END_TEST


START_TEST(cUndefinedT)

  // local object
  createUndefined(obj);
  ck_assert_str_eq(obj.type, "undefined");
  // object
  createAllocateUndefined(obj2);
  ck_assert_str_eq(obj2->type, "undefined");
  // toString
  char *s = obj2->f->toString(obj2);
  ck_assert_str_eq(s, "null");
  free(s);
  // duplicate
  undefinedt *o;
  o = obj2->f->duplicate(obj2);
  terminateO(o);
  // free local object
  obj.f->free(&obj);
  ck_assert_str_eq(obj.type, "undefined");
  // free object
  obj2->f->terminate(&obj2);
  ck_assert_ptr_eq(obj2, NULL);

END_TEST



START_TEST(cSmallBytesT)

  // local object
  createSmallBytes(obj);
  ck_assert_str_eq(obj.type, "smallBytes");
  // object
  createAllocateSmallBytes(obj2);
  ck_assert_str_eq(obj2->type, "smallBytes");
  // alloc - pushBuffer
  smallBytest *obj3 = allocSmallBytes(NULL, 0);
  terminateO(obj3);
  // toString
  char *s = obj2->f->toString(obj2);
  ck_assert_str_eq(s, "[]");
  free(s);
  // duplicate
  obj2->B = allocSBytes();
  sBytesPush(&(obj2->B), 2);
  obj3 = duplicateO(obj2);
  ck_assert_uint_eq(obj3->B->data, 2);
  terminateO(obj3);
  // get
  obj3 = duplicateO(obj2);
  char *r = obj3->f->get(obj3);
  ck_assert_uint_eq(*r, 2);
  terminateO(obj3);
  // push
  obj3 = duplicateO(obj2);
  obj3->f->push(obj3, 4);
  r = obj3->f->get(obj3);
  ck_assert_uint_eq(r[1], 4);
  terminateO(obj3);
  // getAt
  obj3 = duplicateO(obj2);
  char c = obj3->f->getAt(obj3,0);
  ck_assert_uint_eq(c, 2);
  c = obj3->f->getAt(obj3,1);
  ck_assert_uint_eq(c, 0);
  terminateO(obj3);
    // NULL
  initiateAllocateSmallBytes(&obj3);
  c = obj3->f->getAt(obj3,0);
  ck_assert_uint_eq(c, 0);
  terminateO(obj3);
  // free local object
  obj.f->free(&obj);
  ck_assert_str_eq(obj.type, "smallBytes");
  // free object
  obj2->f->terminate(&obj2);
  ck_assert_ptr_eq(obj2, NULL);

END_TEST


START_TEST(putsOT)

  createAllocateSmallArray(l);

  // object
  putsO(l);
  // NULL
  putsO(NULL);

  terminateO(l);

END_TEST


START_TEST(execOT)

  createAllocateSmallArray(l);

  // command
  execO("ls libsheepyObjectTest.c", l, NULL);
  ck_assert_uint_eq(l->f->len(l),1);
  ck_assert_str_eq(l->f->getAtS(l, 0), "libsheepyObjectTest.c");
  freeO(l);

  // invalid command
  execO("randomComand", l, NULL);
  ck_assert_uint_eq(l->f->len(l),0);
  terminateO(l);
  // NULL command
  ck_assert_int_eq(execO(NULL, NULL, NULL), 0);

END_TEST


START_TEST(walkDirOT)

  smallArrayt *l;

  // existing directory
  l = walkDirO("../dirTest.null");
  ck_assert_uint_eq(l->f->len(l),3);
  ck_assert_str_eq(l->f->getAtS(l, 0), "../dirTest.null/one");
  ck_assert_str_eq(l->f->getAtS(l, 1), "../dirTest.null/two/four");
  ck_assert_str_eq(l->f->getAtS(l, 2), "../dirTest.null/two/three");
  terminateO(l);
  // empty path
  ck_assert_ptr_eq(walkDirO(""), NULL);
  // non existing directory
  l = walkDirO("nonExisting.null");
  ck_assert(l->f->isEmpty(l));
  terminateO(l);
  // NULL path
  ck_assert_ptr_eq(walkDirO(NULL), NULL);

END_TEST


START_TEST(expandHomeOT)

  // no ~/
  createAllocateSmallString(v);
  v->f->set(v, "sheepy");
  expandHomeO(v);
  ck_assert(v->f->equalS(v, "sheepy"));
  terminateO(v);
  // NULL var
  expandHomeO(NULL);

END_TEST


START_TEST(chDirOT)

  // change directory
  smallStringt *c;
  c = getCwdO();
  createAllocateSmallString(v);
  v->f->set(v, "../dirTest.null");
  ck_assert(chDirO(v));
  char *s = getCwd();
  bool r = (size_t)findS(s, "dirTest.null");
  ck_assert(r);
  chDirO(c);
  free(s);
  terminateO(c);
  // non existing dir
  createAllocateSmallString(n);
  n->f->set(n, "RandomNonExistingDir");
  ck_assert(!chDirO(n));
  // NULL path
  ck_assert(!chDirO(NULL));
  terminateO(v);
  terminateO(n);

END_TEST


START_TEST(fileExistsOT)

  createAllocateSmallArray(sA);
  char **l = listCreateS("../libsheepyTest.c", "wefwepfk34.c", "../../src", "");
  sA->f->fromArrayNFree(sA, l, 0);
  // detect existing file
  smallStringt *S = sA->f->getAtSmallString(sA, 0);
  ck_assert(fileExistsO(S));
  finishO(S);
  // non existing file
  S = sA->f->getAtSmallString(sA, 1);
  ck_assert(!fileExistsO(S));
  finishO(S);
  // folder
  S = sA->f->getAtSmallString(sA, 2);
  ck_assert(fileExistsO(S));
  finishO(S);
  // empty path
  S = sA->f->getAtSmallString(sA, 3);
  ck_assert(!fileExistsO(S));
  finishO(S);
  // NULL path
  ck_assert(!fileExistsO(NULL));
  terminateO(sA);

END_TEST


START_TEST(fileChmodOT)

  // existing file
  createAllocateSmallString(v);
  v->f->set(v, "../chmodTest.null");
  ck_assert(fileChmodO(v, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH));
  ck_assert(fileChmodO(v, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH));
  // non existing file
  createAllocateSmallString(n);
  n->f->set(n, "qweqwe_null");
  ck_assert(!fileChmodO(n, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH));
  // empty path
  createAllocateSmallString(e);
  e->f->set(e, "");
  ck_assert(!fileChmodO(e,0));
  // NULL path
  ck_assert(!fileChmodO(NULL,0));
  terminateO(v);
  terminateO(n);
  terminateO(e);

END_TEST


START_TEST(fileSizeOT)

  // existing file
  createAllocateSmallString(s);
  s->f->set(s, "../sizeTest.null");
  ck_assert_uint_eq(fileSizeO(s), 743);
  // empty file
  createAllocateSmallString(v);
  v->f->set(v, "../chmodTest.null");
  ck_assert_uint_eq(fileSizeO(v), 0);
  // non existing file
  createAllocateSmallString(n);
  n->f->set(n, "qweqwe_null");
  ck_assert_int_eq(fileSizeO(n), -1);
  // empty path
  createAllocateSmallString(e);
  e->f->set(e, "");
  ck_assert_int_eq(fileSizeO(e), -1);
  // NULL path
  ck_assert_int_eq(fileSizeO(NULL), -1);
  terminateO(s);
  terminateO(v);
  terminateO(n);
  terminateO(e);

END_TEST


START_TEST(mkdirParentsOT)

  // directory
  pError0(rmAll("mkdirTest.null/null"));
  createAllocateSmallString(s);
  s->f->set(s, "mkdirTest.null/null");
  ck_assert_int_eq(mkdirParentsO(s),1);
  // not allowed
  createAllocateSmallString(v);
  v->f->set(v, "/usr/null");
  ck_assert_int_eq(mkdirParentsO(v),0);
  // empty path
  createAllocateSmallString(e);
  e->f->set(e, "");
  ck_assert_int_eq(mkdirParentsO(e),0);
  // NULL path
  ck_assert_int_eq(mkdirParentsO(NULL),0);
  terminateO(s);
  terminateO(e);
  terminateO(v);

END_TEST


START_TEST(rmAllOT)

  // directory
  createAllocateSmallString(s);
  s->f->set(s, "rmAllTest.null/null");
  pError0(mkdirParents("rmAllTest.null/null"));
  ck_assert_int_eq(rmAllO(s),1);
  // empty path
  createAllocateSmallString(e);
  e->f->set(e,"");
  ck_assert_int_eq(rmAllO(e),0);
  // too little permissions
  createAllocateSmallString(v);
  v->f->set(v,"/var/lock");
  ck_assert_int_eq(rmAllO(v),0);
  // NULL path
  ck_assert_int_eq(rmAllO(NULL),0);
  terminateO(s);
  terminateO(e);
  terminateO(v);


END_TEST


START_TEST(copyOT)

  // file
  createAllocateSmallString(s);
  createAllocateSmallString(d);
  s->f->set(s, "../chmodTest.null");
  d->f->set(d, "../copyTest.null");
  ck_assert_int_eq(copyO(s, d),1);
  bool r = fileExists("../copyTest.null");
  ck_assert(r);
  // too little permissions
  pError0(fileChmod("../copyTest.null", 1));
  ck_assert_int_eq(copyO(d, d),0);
  pError0(fileChmod("../copyTest.null", 777));
  pError0(rmAll("../copyTest.null"));
  // empty path
  createAllocateSmallString(e);
  e->f->set(e, "");
  ck_assert_int_eq(copyO(e, d),0);
  ck_assert(!fileExists("copyTest.null"));
  ck_assert_int_eq(copyO(s, e),0);
  ck_assert(!fileExists("copyTest.null"));
  // NULL path
  ck_assert_int_eq(copyO(NULL, d),0);
  ck_assert_int_eq(copyO(s, NULL),0);
  ck_assert_int_eq(copyO(NULL, NULL),0);
  terminateO(s);
  terminateO(d);
  terminateO(e);

END_TEST


START_TEST(randomSOT)

  // get random string
  smallStringt *s = randomSO(10);
  ck_assert_ptr_ne(s, NULL);
  terminateO(s);
  // invalid length (0)
  ck_assert_ptr_eq(randomSO(0), NULL);

  randomUrandomClose();

END_TEST


START_TEST(randomAlphaNumSOT)

  // get random string
  smallStringt *s = randomAlphaNumSO(10);
  ck_assert_ptr_ne(s, NULL);
  terminateO(s);
  // invalid length (0)
  ck_assert_ptr_eq(randomAlphaNumSO(0), NULL);

  randomUrandomClose();

END_TEST


START_TEST(readLineOT)

  FILE *fp;
  smallStringt *s;

  // file with data
  fp = fopen("../textTest.null", "r");
  s = readLineO(fp);
  fclose(fp);
  ck_assert_str_eq(s->f->get(s), "LINE 1");
  terminateO(s);
  // empty file or end of stream
  fp = fopen("../chmodTest.null", "r");
  s = readLineO(fp);
  fclose(fp);
  ck_assert_str_eq(ssGet(s), "");
  terminateO(s);
  // NULL stream
  ck_assert_ptr_eq(readLineO(NULL), NULL);


END_TEST


START_TEST(toSmalltT)

  smallStringt *s;
  smallIntt *i;

  // undefined
  createAllocateUndefined(u);
  sUndefinedt *su = (sUndefinedt *) toSmallt((baset *)u);
  finishO(u);
  ck_assert(isSType(su, UNDEFINED));
  sFree((smallt *) su);
  // smallArray
  createAllocateSmallArray(a);
  initiateAllocateSmallString(&s);
  s->f->set(s, "sheepy");
  a->f->push(a, (baset *) s);
  finishO(s);
  initiateAllocateSmallInt(&i);
  i->f->set(i, 20);
  a->f->push(a, (baset *) i);
  finishO(i);
  sArrayt *sa = (sArrayt *) toSmallt((baset *)a);
  finishO(a);
  ck_assert_uint_eq(sa->count, 2);
  char *S = sToString((smallt *) sa);
  ck_assert_str_eq(S, "[\"sheepy\",20]");
  free(S);
  sFree((smallt *) sa);
  // smallDict
  createAllocateSmallDict(d);
  initiateAllocateSmallString(&s);
  s->f->set(s, "sheepy");
  d->f->set(d, "s", (baset *) s);
  finishO(s);
  initiateAllocateSmallInt(&i);
  i->f->set(i, 20);
  d->f->set(d, "i", (baset *) i);
  finishO(i);
  sDictt *sd = (sDictt *) toSmallt((baset *)d);
  finishO(d);
  ck_assert_uint_eq(sd->count, 2);
  S = sToString((smallt *) sd);
  ck_assert_str_eq(S, "{\"s\":\"sheepy\",\"i\":20}");
  free(S);
  sFree((smallt *) sd);
  // smallJson
  createAllocateSmallJson(j);
  smallt *so = toSmallt((baset *)j);
  ck_assert_ptr_ne(so, NULL);
  ck_assert_int_eq(so->type, CONTAINER);
  ck_assert_ptr_eq(((sContainert*)so)->data, j);
  sFree(so); // sFree does terminateO(j); because smallJson is stored in a container
  // NULL
  ck_assert_ptr_eq(toSmallt(NULL), NULL);

END_TEST


START_TEST(toBasetT)

  // bool
  sBoolt *sb    = allocSBool(true);
  smallBoolt *b = (smallBoolt *) toBaset((smallt *)sb);
  ck_assert(b->value->value);
  terminateO(b);
  // container
  sContainert *sc = allocSContainer(strdup("sheepy"));
  smallContainert *c = (smallContainert *) toBaset((smallt *)sc);
  ck_assert_str_eq(c->data->data, "sheepy");
  free(c->data->data);
  terminateO(c);
  // double
  sDoublet     *sD = allocSDouble(10);
  smallDoublet *D  = (smallDoublet *) toBaset((smallt *)sD);
  ck_assert_uint_eq((uint)D->value->value, 10);
  terminateO(D);
  // int
  sIntt     *si = allocSInt(10);
  smallIntt  *i = (smallIntt *) toBaset((smallt *)si);
  ck_assert_uint_eq(i->value->value, 10);
  terminateO(i);
  // string
  sStringt      *ss = allocSStringTiny("sheepy");
  smallStringt   *s = (smallStringt *) toBaset((smallt *)ss);
  char           *r = ssGet(s);
  ck_assert_str_eq(r, "sheepy");
  terminateO(s);
  // undefined
  sUndefinedt *su = allocSUndefined();
  undefinedt   *u = (undefinedt *) toBaset((smallt *)su);
  ck_assert(isOType(u, "undefined"));
  sFree((smallt *) su);
  terminateO(u);
  // smallArray
  sArrayt *sa    = allocSArray();
  ss             = allocSStringTiny("sheepy");
  sArrayPushTiny(&sa, (smallt *) ss);
  si             = allocSInt(20);
  sArrayPushTiny(&sa, (smallt *) si);
  smallArrayt *a = (smallArrayt *) toBaset((smallt *)sa);
  ck_assert_uint_eq(a->a->count, 2);
  char *S = toStringO(a);
  ck_assert_str_eq(S, "[\"sheepy\",20]");
  free(S);
  terminateO(a);
  // smallDict
  sDictt *sd    = allocSDict();
  ss            = allocSStringTiny("sheepy");
  sDictPushTiny(&sd, "s", (smallt *) ss);
  si            = allocSInt(20);
  sDictPushTiny(&sd, "i", (smallt *) si);
  smallDictt *d = (smallDictt *) toBaset((smallt *)sd);
  ck_assert_uint_eq(d->d->count, 2);
  S = toStringO(d);
  ck_assert_str_eq(S, "{\"s\":\"sheepy\",\"i\":20}");
  free(S);
  terminateO(d);
  // NULL
  ck_assert_ptr_eq(toBaset(NULL), NULL);

END_TEST





Suite * libsheepySuite(void) {
  Suite *s;
  TCase *tc_core;

  s = suite_create("libsheepy");

  /* Core test case */
  tc_core = tcase_create("Object");

  setLogMode(LOG_VERBOSE);

  // disable btrace to make the test run faster
  btraceDisable();
  tcase_add_test(tc_core, cSmallDictT);
  tcase_add_test(tc_core, cSmallJsonT);
  tcase_add_test(tc_core, cSmallArrayT);
  tcase_add_test(tc_core, cUndefinedT);
  tcase_add_test(tc_core, cSmallBytesT);
  tcase_add_test(tc_core, putsOT);
  tcase_add_test(tc_core, execOT);
  tcase_add_test(tc_core, walkDirOT);
  tcase_add_test(tc_core, expandHomeOT);
  tcase_add_test(tc_core, chDirOT);
  tcase_add_test(tc_core, fileExistsOT);
  tcase_add_test(tc_core, fileChmodOT);
  tcase_add_test(tc_core, fileSizeOT);
  tcase_add_test(tc_core, mkdirParentsOT);
  tcase_add_test(tc_core, rmAllOT);
  tcase_add_test(tc_core, copyOT);
  tcase_add_test(tc_core, randomSOT);
  tcase_add_test(tc_core, randomAlphaNumSOT);
  tcase_add_test(tc_core, readLineOT);
  tcase_add_test(tc_core, toSmalltT);
  tcase_add_test(tc_core, toBasetT);


  suite_add_tcase(s, tc_core);

  return s;
}

int main(int ARGC UNUSED, char** ARGV UNUSED) {
  int number_failed;
  Suite *s;
  SRunner *sr;

  s = libsheepySuite();
  sr = srunner_create(s);

  srunner_run_all(sr, CK_NORMAL);
  number_failed = srunner_ntests_failed(sr);
  srunner_free(sr);

  exit((number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE);
}