#include <stdlib.h>
#include <stdio.h>
#include <check.h>
#include "../libsheepy.h"
#include "../libsheepyObject.h"

Include dependency graph for libsheepyObjectTest.c:

Macros
#define	UNUSED

Functions
	createSmallDict (obj)

	ck_assert_str_eq (obj.type, "smallDict")

	createAllocateSmallDict (obj2)

	ck_assert_str_eq (obj2->type, "smallDict")

	ck_assert_str_eq (s, "{}")

	free (s)

	createAllocateSmallBool (oBool2)

oBool2 f	set (oBool2, true)

obj2 f	set (obj2, "lib",(baset *) oBool2)

	finishO (oBool2)

	ck_assert_ptr_ne (oBool3, NULL)

	ck_assert (oBool3->value->value==true)

	finishO (oBool3)

	terminateO (o)

	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)

	ck_assert_str_eq (s, "{\ib\true,\\null,\tr\\heepy\")

	sFree (data)

o f	dispose (o)

	ck_assert_uint_eq (o->f->len(o), 0)

	terminateO (u)

	smashO (st)

	smashO (oBool2)

	ck_assert_ptr_eq (o, NULL)

obj2 f	set (obj2, NULL, NULL)

obj2 f	set (obj2, "no", NULL)

	ck_assert_uint_eq (obj2->f->len(obj2), 3)

	ck_assert_ptr_eq (oBool3, NULL)

	ck_assert_ptr_eq (obj2->f->get(obj2, NULL), NULL)

obj2 f	del (obj2, "lib")

obj2 f	del (obj2, NULL)

obj2 f	del (obj2, "non existing")

	ck_assert (!obj2->f->has(obj2, "qwe"))

	ck_assert (!obj2->f->has(obj2, NULL))

	ck_assert (obj2->f->has(obj2, "u"))

	ck_assert_uint_eq (len, 2)

	ck_assert_str_eq (keys[0], "u")

	ck_assert_str_eq (keys[1], "str")

	listFreeS (keys)

	ck_assert_ptr_eq (keys, NULL)

	ck_assert_str_eq (s, "[null,\heepy\")

	ck_assert_ptr_eq (values, NULL)

st f	set (st, "SHEEPY MERGED")

oM f	set (oM, "str",(baset *) st)

	finishO (st)

	ck_assert_str_eq (s, "{\\null,\tr\\heepy\")

o f	merge (o, oM)

	ck_assert_str_eq (s, "{\\null,\tr\\HEEPY MERGED\")

o f	merge (o, NULL)

oM f	set (oM, "u2",(baset *) oU)

o f	append (o, oM)

	ck_assert_str_eq (s, "{\\null,\tr\\heepy\\2\null}")

o f	append (o, NULL)

	ck_assert_uint_eq (obj2->f->len(obj2), 2)

o f	empty (o)

o f	set (o, "u",(baset *) oU)

o f	set (o, "str",(baset *) st)

o f	set (o, "b",(baset *) oBool2)

o f	set (o, "B",(baset *) oBool2)

o f	del (o, "B")

	ck_assert_str_eq (s, "bool")

	ck_assert_ptr_eq (o->f->typeString(o, "B"), NULL)

	ck_assert_ptr_eq (oM->f->typeString(oM, "B"), NULL)

	ck_assert_uint_eq (c, STRING)

	ck_assert (!o->f->type(o, "B"))

	ck_assert (!oM->f->type(oM, "B"))

	ck_assert_str_eq (s, "{\\\ndefined\\tr\\tring\\\\ool\")

	terminateO (oT)

	ck_assert_ptr_eq (oT, NULL)

	terminateO (oM)

	ck_assert_ptr_eq (obj2, NULL)

END_TEST	createSmallJson (obj)

	ck_assert_str_eq (obj.type, "smallJson")

	createAllocateSmallJson (obj2)

	ck_assert_str_eq (obj2->type, "smallJson")

	createAllocateSmallInt (oInt)

oInt f	set (oInt, 123)

obj2 f	set (obj2, "int",(baset *) oInt)

	finishO (oInt)

obj2 f	set (obj2, "int2",(baset *) oInt)

obj2 f	push (obj2,(baset *) oInt)

	ck_assert_str_eq (s, "{\nt\123,\nt2\123}")

	terminateO (obj2)

	createAllocateSmallInt (oInt2)

oInt2 f	set (oInt2, 123)

	finishO (oInt2)

obj2 f	set (obj2, "noEffect",(baset *) oInt2)

	ck_assert_str_eq (s, "[123,123]")

	createAllocateSmallInt (oInt3)

oInt3 f	set (oInt3, 123)

	finishO (oInt3)

	ck_assert_str_eq (s, "{\nt\123}")

o f	push (o,(baset *) oInt)

	ck_assert_uint_eq (o->topA->count, 1)

	ck_assert_ptr_eq (o->topA, NULL)

	sFree (i)

o f	set (o, "in",(baset *) oInt)

	ck_assert_uint_eq (o->top->count, 1)

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")

	ck_assert_ptr_eq (o->f->getTopType(o), NULL)

	createAllocateSmallContainer (jcontainer)

o f	setTop (o,(baset *) jcontainer)

	terminateO (jcontainer)

	ck_assert_ptr_eq (b, NULL)

	createAllocateUndefined (jUndef)

	finishO (jUndef)

	ck_assert_str_eq (b->type, "undefined")

	finishO (b)

	ck_assert_str_eq (s, "null")

	ck_assert_str_eq (s, "---\ null")

	freeO (o)

	createAllocateSmallBool (jBool)

	finishO (jBool)

	ck_assert_str_eq (b->type, "smallBool")

	ck_assert_str_eq (s, "false")

	ck_assert_str_eq (s, "---\ false")

	createAllocateSmallDouble (jDouble)

	finishO (jDouble)

	ck_assert_str_eq (b->type, "smallDouble")

	ck_assert_str_eq (s, "0.000000e+00")

	ck_assert_str_eq (s, "---\ 0.000000e+00")

	createAllocateSmallInt (jInt)

	finishO (jInt)

	ck_assert_str_eq (b->type, "smallInt")

	ck_assert_str_eq (s, "0")

	ck_assert_str_eq (s, "---\ 0")

	createAllocateSmallString (jString)

jString f	set (jString, "sheepy")

	finishO (jString)

	ck_assert_str_eq (b->type, "smallString")

	ck_assert_str_eq (s, "sheepy")

	ck_assert_str_eq (s, "\heepy\)

	ck_assert_str_eq (s, "---\ \heepy\)

	createAllocateSmallDict (jdict)

	finishO (jdict)

	ck_assert_str_eq (b->type, "smallDict")

	ck_assert_str_eq (s, "{}\)

	ck_assert_str_eq (s, "---\ {}\)

	createAllocateSmallArray (jArray)

	finishO (jArray)

	ck_assert_str_eq (b->type, "smallArray")

	ck_assert_str_eq (s, "[]")

	ck_assert_str_eq (s, "[]\)

	ck_assert_str_eq (s, "---\ []\)

	ck_assert (in->value->value==123)

	createAllocateSmallDict (oD2)

oD2 f	set (oD2, "int",(baset *) in2)

	finishO (in2)

oD2 f	set (oD2, "int2",(baset *) in2)

obj2 f	set (obj2, "dict",(baset *) oD2)

	finishO (oD2)

	createAllocateSmallArray (oTA2)

oTA2 f	push (oTA2,(baset *) in2)

	smashO (in)

obj2 f	set (obj2, "array",(baset *) oTA2)

	finishO (oTA2)

	ck_assert_ptr_eq (in, NULL)

	createAllocateSmallJson (json)

	createAllocateSmallInt (oInt4)

oInt4 f	set (oInt4, 345)

json f	push (json,(baset *) oInt4)

	finishO (oInt4)

	createSmallJson (jpath)

	createSmallBool (ba)

jpath f set &	jpath (&ba)

	ck_assert (jBool->value->value==false)

	createSmallBool (bb)

jpath f set &	jpath (baset *)&bb

	ck_assert_str_eq (jArray->type, "smallArray")

	ck_assert_uint_eq (lenO(jArray), 1)

	finishG (jArray)

	ck_assert_uint_eq (in->value->value, 11)

	finishG (in)

	createSmallBool (be)

	finishG (jBool)

	createSmallBool (b2)

	ck_assert_ptr_ne (o2, NULL)

	createSmallBool (b3)

	ck_assert_str_eq (ks, "\\\\\\")

	createSmallBool (b4)

	pErrorNULL (iPrependS(&ks, "[1]"))

	free (ks)

	finishG (b)

	createSmallBool (b0)

	ck_assert_ptr_eq (o2, NULL)

	ck_assert_uint_eq (o->f->len(o), 1)

	sFree ((smallt *) o->topS)

o f	set (o, "wer",(baset *) in)

	finishO (in)

jdict f	set (jdict, "string",(baset *) jString)

jdict f	set (jdict, "container",(baset *) jcontainer)

	finishO (jcontainer)

jArray f	push (jArray,(baset *) jString)

	ck_assert_str_eq (s, "[\ 345,\ \heepy\\ {},\ [],\ {\ \tring\ \heepy\\ \ontainer\ \data container>\ },\ [\ \heepy\\ \data container>\ ]\\)

	createAllocateSmallJson (json2)

json2 f	set (json2, "s",(baset *) jString)

json2 f	set (json2, "d",(baset *) jdict)

json2 f	set (json2, "a",(baset *) jArray)

json2 f	set (json2, "d2",(baset *) jdict)

json2 f	set (json2, "a2",(baset *) jArray)

json2 f	set (json2, "int",(baset *) oInt4)

	ck_assert_str_eq (s, "{\ \\ \heepy\\ \\ {},\ \\ [],\ \2\ {\ \tring\ \heepy\\ \ontainer\ \data container>\ },\ \2\ [\ \heepy\\ \data container>\ ],\ \nt\ 345\\)

	ck_assert_str_eq (s, "---\ - 345\ - sheepy\ - {}\ - []\ - string: sheepy\ container: \data container>\ - - sheepy\ - \data container>\")

	createAllocateSmallJson (json3)

	terminateO (json3)

	ck_assert_str_eq (s, "---\ s: sheepy\ d:\ {}\ a:\ []\ d2:\ string: sheepy\ container: \data container>\ a2:\ - sheepy\ - \data container>\ int: 345\)

	terminateO (json2)

	terminateO (json)

json f	parse (json, "null")

	ck_assert_str_eq (json->f->getTopType(json), "undefined")

json f	parse (json, "true")

	ck_assert_str_eq (json->f->getTopType(json), "bool")

json f	parse (json, "0.01")

	ck_assert_str_eq (json->f->getTopType(json), "double")

json f	parse (json, "10")

	ck_assert_str_eq (json->f->getTopType(json), "int")

json f	parse (json, "\ef\)

	ck_assert_str_eq (json->f->getTopType(json), "string")

	createAllocateSmallJson (jsOfromF)

jsOfromF f	parse (jsOfromF, jsonText)

	ck_assert_str_eq (s, "{\asd\\sd\\sd\234,\ict\{\rray\[1,1],\sd\true,\loat\3.434000e+01},\ool\false,\zz\null}")

	free (jsonText)

	listFreeS (file)

	terminateO (jsOfromF)

	ck_assert_str_eq (s, "[\sd\234,{\rray\[1,1],\sd\true,\loat\3.434000e+01}]")

json f	parse (json, "{\ef\ {")

json f	parse (json, "[\ef")

json f	parse (json, "\ef")

jsOfromF f	parseYML (jsOfromF, jsonText)

	ck_assert_str_eq (s, "{\ict\{\rray\[1,1],\loat\3.434000e+01,\sd\true},\asd\\sd\\sd\234,\ool\false,\zz\null}")

	ck_assert_str_eq (s, "[{\ict\\ello\\rray\[1,1],\loat\3.434000e+01,\sd\true},\sd\234]")

	ck_assert_str_eq (s, "[0x01]")

o f	deserial (o, B)

	terminateO (B)

	finishO (oBool)

	ck_assert_str_eq (s, "[0x02,0x01]")

	ck_assert_str_eq (s, "true")

	finishO (od)

	ck_assert_str_eq (s, "[0x06,0x00,0x00,0x00,0x00,0x00,0x00,0x24,0x40]")

	ck_assert_str_eq (s, "1.000000e+01")

	ck_assert_str_eq (s, "[0x07,0x55,0x00,0x00,0x00,0x00,0x00,0x00,0x00]")

	ck_assert_str_eq (s, "85")

	ck_assert_str_eq (s, "[0x08,0x73,0x68,0x65,0x65,0x70,0x79,0x00]")

	finishO (sDD)

	ck_assert_str_eq (s, "[0x04,0x00,0x00,0x00,0x00]")

	finishO (sAA)

	ck_assert_str_eq (s, "[0x0a,0x00,0x00,0x00,0x00]")

	sFree ((smallt *) c)

	ck_assert_uint_eq (o->topIsA, 0)

o f	deserial (o, NULL)

END_TEST	createSmallArray (obj)

	ck_assert_str_eq (obj.type, "smallArray")

	createAllocateSmallArray (obj2)

	ck_assert_str_eq (obj2->type, "smallArray")

	ck_assert_str_eq (s, "[null,123,\heepy\")

o2 f	delElem (o2, 0)

	ck_assert_str_eq (s, "[123,\heepy\")

	terminateO (o2)

	ck_assert (isOType(u, "undefined"))

	ck_assert (r)

o f	fromArray (o,(void *) array, 3)

	ck_assert_uint_eq (o->f->len(o), 3)

	ck_assert_str_eq (strFrom->f->get(strFrom), "1")

	smashO (strFrom)

	ck_assert_str_eq (strFrom->f->get(strFrom), "22")

	ck_assert_str_eq (strFrom->f->get(strFrom), "333")

	ck_assert_ptr_eq (strFrom, NULL)

o f	fromArray (o, shpList, 0)

	ck_assert_uint_eq (o->f->len(o), 2)

	listFreeS (shpList)

o f	fromArray (o, NULL, 3)

in f	set (in, 654)

	ck_assert_uint_eq (o->f->len(o), 4)

	ck_assert_uint_eq (in->value->value, 654)

o f	push (o, NULL)

	ck_assert_str_eq (st->f->get(st), "sheepy")

	terminateO (st)

	ck_assert_uint_eq (in->value->value, 123)

	terminateO (in)

	ck_assert_ptr_eq (u, NULL)

o f	free (o)

o2 f	setAt (o2, 1,(baset *) in)

o f	append (o, o2)

	ck_assert_str_eq (s, "[null,123,\heepy\null,789,\heepy\")

o f	append (o, o)

	ck_assert_str_eq (s, "[null,789,\heepy\")

o2 f	dispose (o2)

in f	set (in, 5345)

o f	slice (o, 1,-1)

o f	slice (o, 20,-1)

o f	slice (o,-20, 1)

	ck_assert_str_eq (s, "[null]")

o f	slice (o, 2, 40)

	ck_assert_str_eq (s, "[\heepy\5345]")

o f	slice (o, 2,-40)

o f	slice (o, 3, 2)

o f	slice (o,-1, 0)

	ck_assert_str_eq (s, "[5345]")

o f	slice (o, 1, 1)

o f	slice (o, 0, 0)

o f	insert (o, 0, o2)

	ck_assert_str_eq (s, "[null,789,\heepy\null,123,\heepy\")

o f	insert (o, -1, o2)

o f	insert (o, 3, o2)

o f	insert (o, 4, o2)

o f	delElem (o, 1)

o f	delElem (o, 2)

o f	trim (o)

	ck_assert_str_eq (s, "[null,null,789,\heepy\")

o f	insert (o, 0, NULL)

o f	del (o, 1,-1)

	ck_assert_str_eq (s, "[null,5345]")

o f	del (o, 20,-1)

	ck_assert_str_eq (s, "[null,123,\heepy\5345]")

o f	del (o,-20, 1)

	ck_assert_str_eq (s, "[123,\heepy\5345]")

o f	del (o, 2, 40)

	ck_assert_str_eq (s, "[null,123]")

o f	del (o, 2,-40)

o f	del (o, 3, 2)

o f	del (o,-1, 0)

o f	del (o, 1, 1)

o f	del (o, 0, 0)

o f	delElem (o, 0)

	ck_assert_str_eq (s, "[123]")

	ck_assert_str_eq (u->type, "undefined")

	ck_assert_str_eq (st->type, "smallString")

o f	setAt (o, 0,(baset *) in)

	ck_assert_str_eq (s, "[0,123,\heepy\")

o f	setAt (o, -1,(baset *) in)

	ck_assert_str_eq (s, "[0,123,0]")

o f	setAt (o, 4,(baset *) in)

	ck_assert (o->f->isEmpty(o))

	ck_assert (!o->f->isEmpty(o))

	ck_assert_str_eq (s, "undefined")

	ck_assert_uint_eq (c, INT)

	ck_assert (!o->f->type(o, 10))

	ck_assert (!o->f->type(o, -14))

	ck_assert_uint_eq (c, UNDEFINED)

	ck_assert (!o2->f->type(o2, 0))

	ck_assert_str_eq (s, "undefined,int,string")

	free (l)

	ck_assert_ptr_eq (o2->f->typeStrings(o2), NULL)

	ck_assert_str_eq (s, "[0x01,0x07,0x08]")

	initiateAllocateSmallArray (NULL)

END_TEST	createUndefined (obj)

	ck_assert_str_eq (obj.type, "undefined")

	createAllocateUndefined (obj2)

	ck_assert_str_eq (obj2->type, "undefined")

END_TEST	createSmallBytes (obj)

	ck_assert_str_eq (obj.type, "smallBytes")

	createAllocateSmallBytes (obj2)

	ck_assert_str_eq (obj2->type, "smallBytes")

	terminateO (obj3)

	ck_assert_uint_eq (obj3->B->data, 2)

obj3 f	push (obj3, 4)

	ck_assert_uint_eq (r[1], 4)

	ck_assert_uint_eq (c, 2)

	ck_assert_uint_eq (c, 0)

END_TEST	createAllocateSmallArray (l)

	putsO (l)

	putsO (NULL)

	terminateO (l)

	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)

	execO ("randomComand", l, NULL)

	ck_assert_uint_eq (l->f->len(l), 0)

	ck_assert_int_eq (execO(NULL, NULL, NULL), 0)

	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")

	ck_assert_ptr_eq (walkDirO(""), NULL)

	ck_assert (l->f->isEmpty(l))

	ck_assert_ptr_eq (walkDirO(NULL), NULL)

END_TEST	createAllocateSmallString (v)

v f	set (v, "sheepy")

	expandHomeO (v)

	ck_assert (v->f->equalS(v, "sheepy"))

	terminateO (v)

	expandHomeO (NULL)

v f	set (v, "../dirTest.null")

	ck_assert (chDirO(v))

	chDirO (c)

	terminateO (c)

	createAllocateSmallString (n)

n f	set (n, "RandomNonExistingDir")

	ck_assert (!chDirO(n))

	ck_assert (!chDirO(NULL))

	terminateO (n)

END_TEST	createAllocateSmallArray (sA)

sA f	fromArrayNFree (sA, l, 0)

	ck_assert (fileExistsO(S))

	finishO (S)

	ck_assert (!fileExistsO(S))

	terminateO (sA)

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))

n f	set (n, "qweqwe_null")

	ck_assert (!fileChmodO(n, S_IRUSR\|S_IWUSR\|S_IRGRP\|S_IROTH))

	createAllocateSmallString (e)

e f	set (e, "")

	ck_assert (!fileChmodO(e, 0))

	ck_assert (!fileChmodO(NULL, 0))

	terminateO (e)

END_TEST	createAllocateSmallString (s)

s f	set (s, "../sizeTest.null")

	ck_assert_uint_eq (fileSizeO(s), 743)

	ck_assert_uint_eq (fileSizeO(v), 0)

	ck_assert_int_eq (fileSizeO(n), -1)

	ck_assert_int_eq (fileSizeO(e), -1)

	ck_assert_int_eq (fileSizeO(NULL), -1)

	terminateO (s)

END_TEST	pError0 (rmAll("mkdirTest.null/null"))

s f	set (s, "mkdirTest.null/null")

	ck_assert_int_eq (mkdirParentsO(s), 1)

v f	set (v, "/usr/null")

	ck_assert_int_eq (mkdirParentsO(v), 0)

	ck_assert_int_eq (mkdirParentsO(e), 0)

	ck_assert_int_eq (mkdirParentsO(NULL), 0)

s f	set (s, "rmAllTest.null/null")

	pError0 (mkdirParents("rmAllTest.null/null"))

	ck_assert_int_eq (rmAllO(s), 1)

	ck_assert_int_eq (rmAllO(e), 0)

v f	set (v,"/var/lock")

	ck_assert_int_eq (rmAllO(v), 0)

	ck_assert_int_eq (rmAllO(NULL), 0)

	createAllocateSmallString (d)

s f	set (s, "../chmodTest.null")

d f	set (d, "../copyTest.null")

	ck_assert_int_eq (copyO(s, d), 1)

	pError0 (fileChmod("../copyTest.null", 1))

	ck_assert_int_eq (copyO(d, d), 0)

	pError0 (fileChmod("../copyTest.null", 777))

	pError0 (rmAll("../copyTest.null"))

	ck_assert_int_eq (copyO(e, d), 0)

	ck_assert (!fileExists("copyTest.null"))

	ck_assert_int_eq (copyO(s, e), 0)

	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 (d)

	ck_assert_ptr_ne (s, NULL)

	ck_assert_ptr_eq (randomSO(0), NULL)

	randomUrandomClose ()
	close /dev/urandom in libsheepy call this function when random are not needed anymore More...

	ck_assert_ptr_eq (randomAlphaNumSO(0), NULL)

	fclose (fp)

	ck_assert_str_eq (s->f->get(s), "LINE 1")

	ck_assert_str_eq (ssGet(s), "")

	ck_assert_ptr_eq (readLineO(NULL), NULL)

	createAllocateUndefined (u)

	finishO (u)

	ck_assert (isSType(su, UNDEFINED))

	createAllocateSmallArray (a)

s f	set (s, "sheepy")

a f	push (a,(baset *) s)

	finishO (s)

i f	set (i, 20)

	finishO (i)

	finishO (a)

	ck_assert_uint_eq (sa->count, 2)

	ck_assert_str_eq (S, "[\heepy\20]")

	free (S)

	createAllocateSmallDict (d)

d f	set (d, "s",(baset *) s)

d f	set (d, "i",(baset *) i)

	finishO (d)

	ck_assert_uint_eq (sd->count, 2)

	ck_assert_str_eq (S, "{\\\heepy\\\20}")

	createAllocateSmallJson (j)

	ck_assert_ptr_ne (so, NULL)

	ck_assert_int_eq (so->type, CONTAINER)

	ck_assert_ptr_eq (((sContainert *) so) ->data, j)

	sFree (so)

	ck_assert_ptr_eq (toSmallt(NULL), NULL)

	ck_assert (b->value->value)

	terminateO (b)

	ck_assert_str_eq (c->data->data, "sheepy")

	free (c->data->data)

	ck_assert_uint_eq ((uint) D->value->value, 10)

	terminateO (D)

	ck_assert_uint_eq (i->value->value, 10)

	terminateO (i)

	ck_assert_str_eq (r, "sheepy")

sArrayPushTiny &	sa (smallt *) ss

	ck_assert_uint_eq (a->a->count, 2)

	terminateO (a)

sDictPushTiny &	sd (smallt *) ss

	ck_assert_uint_eq (d->d->count, 2)

	ck_assert_ptr_eq (toBaset(NULL), NULL)

END_TEST Suite *	libsheepySuite (void)

int	main (int ARGC UNUSED, char **ARGV UNUSED)

Variables
char *	s = obj2->f->toString(obj2)

smallDictt *	o = obj2->f->duplicate(obj2)

smallBoolt *	oBool3 = (smallBoolt *)o->f->get(o, "lib")

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")

char **	keys = obj2->f->keys(obj2)

size_t	len = listLengthS(keys)

smallArrayt *	values = obj2->f->values(obj2)

smallDictt *	oM

initiateAllocateUndefined &	oU = allocUndefined()

char	c = o->f->type(o, "str")

smallDictt *	oT = o->f->typeStrings(o)

obj f free &	obj

obj2 f terminate &	obj2

initiateAllocateSmallInt &	oInt = allocSmallInt(85)

initiateAllocateSmallInt &	oInt2

smallt *	i = sArrayGetTiny(o->topA, 0)

baset *	b = o->f->getTop(o)

smallJsont *	o2 = duplicateO(o)

smallIntt *	in = (smallIntt *) obj2->f->get(obj2, "int")

smallIntt *	in2 = duplicateO(in)

jpath f parse &[\"qwe\,32]	jpath

	jBool = (smallBoolt*)jpath.f->get(&jpath,"b\\\\")

bb f set &	bb

	jArray = (smallArrayt*)jpath.f->get(&jpath,"[2][0]")

char *	ks = jpath.f->makeKey(&jpath, "\\\\\\\"\"")

o	topS = allocSStringTiny("er")

initiateAllocateSmallString &	jString

initiateAllocateSmallDict &	jdict

initiateAllocateSmallContainer &	jcontainer

initiateAllocateSmallInt &	oInt4

initiateAllocateSmallJson &	json

char **	file = readText("file.json")

char *	jsonText = join(file, "\n")

initiateAllocateSmallJson &	jsOfromF

smallBytest *	B = o->f->serial(o)

smallBoolt *	oBool = allocSmallBool(true)

smallDoublet *	od = allocSmallDouble(10)

smallDictt *	sDD = allocSmallDict()

smallArrayt *	sAA = allocSmallArray()

o	topU = NULL

bool	r = strEq(st->f->get(st), "sheepy")

char *	array [] = {"1", "22", "333"}

char *	arrayNULL [] = {"1", NULL, "333"}

smallStringt *	strFrom = (smallStringt*) o->f->getAt(o,0)

char **	shpList = listCreateS("lib", "sheepy")

in value	value = 789

	oStr = allocSmallString("sheepy")

const char **	l = o->f->typeStrings(o)

smallBytest *	obj3 = allocSmallBytes(NULL, 0)

smallStringt *	S = sA->f->getAtSmallString(sA, 0)

END_TEST FILE *	fp = fopen("../textTest.null", "r")

sUndefinedt *	su = (sUndefinedt ) toSmallt((baset )u)

sArrayt *	sa = (sArrayt ) toSmallt((baset )a)

sDictt *	sd = (sDictt ) toSmallt((baset )d)

smallt *	so = toSmallt((baset *)j)

END_TEST sBoolt *	sb = allocSBool(true)

sContainert *	sc = allocSContainer(strdup("sheepy"))

sDoublet *	sD = allocSDouble(10)

smallDoublet *	D = (smallDoublet ) toBaset((smallt )sD)

sIntt *	si = allocSInt(10)

sStringt *	ss = allocSStringTiny("sheepy")

smallArrayt *	a = (smallArrayt ) toBaset((smallt )sa)

smallDictt *	d = (smallDictt ) toBaset((smallt )sd)

Macro Definition Documentation

◆ UNUSED

#define UNUSED

Definition at line 13 of file libsheepyObjectTest.c.

Function Documentation

◆ createSmallDict()

createSmallDict ( obj )

◆ ck_assert_str_eq() [1/113]

ck_assert_str_eq	(	obj.	type,
		"smallDict"
	)

◆ createAllocateSmallDict() [1/4]

createAllocateSmallDict ( obj2 )

◆ ck_assert_str_eq() [2/113]

ck_assert_str_eq	(	obj2->	type,
		"smallDict"
	)

◆ ck_assert_str_eq() [3/113]

ck_assert_str_eq	(	s	,
		"{}"
	)

◆ free() [1/7]

free ( s )

Here is the caller graph for this function:

◆ createAllocateSmallBool() [1/2]

createAllocateSmallBool ( oBool2 )

◆ set() [1/55]

oBool2 f set	(	oBool2	,
		true
	)

◆ set() [2/55]

obj2 f set	(	obj2	,
		"lib"	,
		(baset *)	oBool2
	)

◆ finishO() [1/32]

finishO ( oBool2 )

◆ ck_assert_ptr_ne() [1/4]

ck_assert_ptr_ne	(	oBool3	,
		NULL
	)

◆ ck_assert() [1/30]

ck_assert ( oBool3->value-> value = =true )

◆ finishO() [2/32]

finishO ( oBool3 )

◆ terminateO() [1/27]

terminateO ( o )

◆ createAllocateUndefined() [1/4]

createAllocateUndefined ( oU )

◆ set() [3/55]

obj2 f set	(	obj2	,
		"u"	,
		(baset *)	oU
	)

◆ finishO() [3/32]

finishO ( oU )

◆ createAllocateSmallString() [1/7]

createAllocateSmallString ( oStr )

◆ set() [4/55]

oStr f set	(	oStr	,
		"sheepy"
	)

◆ set() [5/55]

obj2 f set	(	obj2	,
		"str"	,
		(baset *)	oStr
	)

◆ finishO() [4/32]

finishO ( oStr )

◆ ck_assert_str_eq() [4/113]

ck_assert_str_eq ( s )

◆ sFree() [1/5]

sFree ( data )

◆ dispose() [1/2]

o f dispose ( o )

◆ ck_assert_uint_eq() [1/33]

ck_assert_uint_eq	(	o->f->	leno,
		0
	)

◆ terminateO() [2/27]

terminateO ( u )

◆ smashO() [1/4]

smashO ( st )

◆ smashO() [2/4]

smashO ( oBool2 )

◆ ck_assert_ptr_eq() [1/25]

ck_assert_ptr_eq	(	o	,
		NULL
	)

◆ set() [6/55]

obj2 f set	(	obj2	,
		NULL	,
		NULL
	)

◆ set() [7/55]

obj2 f set	(	obj2	,
		"no"	,
		NULL
	)

◆ ck_assert_uint_eq() [2/33]

ck_assert_uint_eq	(	obj2->f->	lenobj2,
		3
	)

◆ ck_assert_ptr_eq() [2/25]

ck_assert_ptr_eq	(	oBool3	,
		NULL
	)

◆ ck_assert_ptr_eq() [3/25]

ck_assert_ptr_eq	(	obj2->f->	getobj2, NULL,
		NULL
	)

◆ del() [1/13]

obj2 f del	(	obj2	,
		"lib"
	)

◆ del() [2/13]

obj2 f del	(	obj2	,
		NULL
	)

◆ del() [3/13]

obj2 f del	(	obj2	,
		"non existing"
	)

◆ ck_assert() [2/30]

ck_assert ( !obj2->f-> hasobj2, "qwe" )

◆ ck_assert() [3/30]

ck_assert ( !obj2->f-> hasobj2, NULL )

◆ ck_assert() [4/30]

ck_assert ( obj2->f-> hasobj2, "u" )

◆ ck_assert_uint_eq() [3/33]

ck_assert_uint_eq	(	len	,
		2
	)

◆ ck_assert_str_eq() [5/113]

ck_assert_str_eq	(	keys	[0],
		"u"
	)

◆ ck_assert_str_eq() [6/113]

ck_assert_str_eq	(	keys	[1],
		"str"
	)

◆ listFreeS() [1/3]

listFreeS ( keys )

◆ ck_assert_ptr_eq() [4/25]

ck_assert_ptr_eq	(	keys	,
		NULL
	)

◆ ck_assert_str_eq() [7/113]

ck_assert_str_eq	(	s	,
		"[	null,
		\heepy\"
	)

◆ ck_assert_ptr_eq() [5/25]

ck_assert_ptr_eq	(	values	,
		NULL
	)

◆ set() [8/55]

st f set	(	st	,
		"SHEEPY MERGED"
	)

◆ set() [9/55]

oM f set	(	oM	,
		"str"	,
		(baset *)	st
	)

◆ finishO() [5/32]

finishO ( st )

◆ ck_assert_str_eq() [8/113]

ck_assert_str_eq ( s )

◆ merge() [1/2]

o f merge	(	o	,
		oM
	)

◆ ck_assert_str_eq() [9/113]

ck_assert_str_eq ( s )

◆ merge() [2/2]

o f merge	(	o	,
		NULL
	)

◆ set() [10/55]

oM f set	(	oM	,
		"u2"	,
		(baset *)	oU
	)

◆ append() [1/4]

o f append	(	o	,
		oM
	)

◆ ck_assert_str_eq() [10/113]

ck_assert_str_eq	(	s	,
		"{\ull,\\eepy\\ll}"
	)

◆ append() [2/4]

o f append	(	o	,
		NULL
	)

◆ ck_assert_uint_eq() [4/33]

ck_assert_uint_eq	(	obj2->f->	lenobj2,
		2
	)

◆ empty()

o f empty ( o )

Here is the caller graph for this function:

◆ set() [11/55]

o f set	(	o	,
		"u"	,
		(baset *)	oU
	)

◆ set() [12/55]

o f set	(	o	,
		"str"	,
		(baset *)	st
	)

◆ set() [13/55]

o f set	(	o	,
		"b"	,
		(baset *)	oBool2
	)

◆ set() [14/55]

o f set	(	o	,
		"B"	,
		(baset *)	oBool2
	)

◆ del() [4/13]

o f del	(	o	,
		"B"
	)

◆ ck_assert_str_eq() [11/113]

ck_assert_str_eq	(	s	,
		"bool"
	)

◆ ck_assert_ptr_eq() [6/25]

ck_assert_ptr_eq	(	o->f->	typeStringo, "B",
		NULL
	)

◆ ck_assert_ptr_eq() [7/25]

ck_assert_ptr_eq	(	oM->f->	typeStringoM, "B",
		NULL
	)

◆ ck_assert_uint_eq() [5/33]

ck_assert_uint_eq	(	c	,
		STRING
	)

◆ ck_assert() [5/30]

ck_assert ( !o->f-> typeo, "B" )

◆ ck_assert() [6/30]

ck_assert ( !oM->f-> typeoM, "B" )

◆ ck_assert_str_eq() [12/113]

ck_assert_str_eq ( s )

◆ terminateO() [3/27]

terminateO ( oT )

◆ ck_assert_ptr_eq() [8/25]

ck_assert_ptr_eq	(	oT	,
		NULL
	)

◆ terminateO() [4/27]

terminateO ( oM )

◆ ck_assert_ptr_eq() [9/25]

ck_assert_ptr_eq	(	obj2	,
		NULL
	)

◆ createSmallJson() [1/2]

END_TEST createSmallJson ( obj )

◆ ck_assert_str_eq() [13/113]

ck_assert_str_eq	(	obj.	type,
		"smallJson"
	)

◆ createAllocateSmallJson() [1/6]

createAllocateSmallJson ( obj2 )

◆ ck_assert_str_eq() [14/113]

ck_assert_str_eq	(	obj2->	type,
		"smallJson"
	)

◆ createAllocateSmallInt() [1/5]

createAllocateSmallInt ( oInt )

◆ set() [15/55]

oInt f set	(	oInt	,
		123
	)

◆ set() [16/55]

obj2 f set	(	obj2	,
		"int"	,
		(baset *)	oInt
	)

◆ finishO() [6/32]

finishO ( oInt )

◆ set() [17/55]

obj2 f set	(	obj2	,
		"int2"	,
		(baset *)	oInt
	)

◆ push() [1/8]

obj2 f push	(	obj2	,
		(baset *)	oInt
	)

◆ ck_assert_str_eq() [15/113]

ck_assert_str_eq	(	s	,
		"{\\3,\2\3}"
	)

◆ terminateO() [5/27]

terminateO ( obj2 )

◆ createAllocateSmallInt() [2/5]

createAllocateSmallInt ( oInt2 )

◆ set() [18/55]

oInt2 f set	(	oInt2	,
		123
	)

◆ finishO() [7/32]

finishO ( oInt2 )

◆ set() [19/55]

obj2 f set	(	obj2	,
		"noEffect"	,
		(baset *)	oInt2
	)

◆ ck_assert_str_eq() [16/113]

ck_assert_str_eq	(	s	,
		""	[123, 123]
	)

◆ createAllocateSmallInt() [3/5]

createAllocateSmallInt ( oInt3 )

◆ set() [20/55]

oInt3 f set	(	oInt3	,
		123
	)

◆ finishO() [8/32]

finishO ( oInt3 )

◆ ck_assert_str_eq() [17/113]

ck_assert_str_eq	(	s	,
		"{\\3}"
	)

◆ push() [2/8]

o f push	(	o	,
		(baset *)	oInt
	)

◆ ck_assert_uint_eq() [6/33]

ck_assert_uint_eq	(	o->topA->	count,
		1
	)

◆ ck_assert_ptr_eq() [10/25]

ck_assert_ptr_eq	(	o->	topA,
		NULL
	)

◆ sFree() [2/5]

sFree ( i )

◆ set() [21/55]

o f set	(	o	,
		"in"	,
		(baset *)	oInt
	)

◆ ck_assert_uint_eq() [7/33]

ck_assert_uint_eq	(	o->top->	count,
		1
	)

◆ setTypeUndefined()

o f setTypeUndefined ( o )

◆ ck_assert_str_eq() [18/113]

ck_assert_str_eq	(	o->f->	getTopTypeo,
		"undefined"
	)

◆ setTypeBool()

o f setTypeBool ( o )

◆ ck_assert_str_eq() [19/113]

ck_assert_str_eq	(	o->f->	getTopTypeo,
		"bool"
	)

◆ setTypeDouble()

o f setTypeDouble ( o )

◆ ck_assert_str_eq() [20/113]

ck_assert_str_eq	(	o->f->	getTopTypeo,
		"double"
	)

◆ setTypeInt()

o f setTypeInt ( o )

◆ ck_assert_str_eq() [21/113]

ck_assert_str_eq	(	o->f->	getTopTypeo,
		"int"
	)

◆ setTypeString()

o f setTypeString ( o )

◆ ck_assert_str_eq() [22/113]

ck_assert_str_eq	(	o->f->	getTopTypeo,
		"string"
	)

◆ setTypeDict()

o f setTypeDict ( o )

◆ ck_assert_str_eq() [23/113]

ck_assert_str_eq	(	o->f->	getTopTypeo,
		"dict"
	)

◆ setTypeArray()

o f setTypeArray ( o )

◆ ck_assert_str_eq() [24/113]

ck_assert_str_eq	(	o->f->	getTopTypeo,
		"array"
	)

◆ ck_assert_ptr_eq() [11/25]

ck_assert_ptr_eq	(	o->f->	getTopTypeo,
		NULL
	)

◆ createAllocateSmallContainer()

createAllocateSmallContainer ( jcontainer )

Here is the caller graph for this function:

◆ setTop()

o f setTop	(	o	,
		(baset *)	jcontainer
	)

◆ terminateO() [6/27]

terminateO ( jcontainer )

◆ ck_assert_ptr_eq() [12/25]

ck_assert_ptr_eq	(	b	,
		NULL
	)

◆ createAllocateUndefined() [2/4]

createAllocateUndefined ( jUndef )

◆ finishO() [9/32]

finishO ( jUndef )

◆ ck_assert_str_eq() [25/113]

ck_assert_str_eq	(	b->	type,
		"undefined"
	)

◆ finishO() [10/32]

finishO ( b )

◆ ck_assert_str_eq() [26/113]

ck_assert_str_eq	(	s	,
		"null"
	)

◆ ck_assert_str_eq() [27/113]

ck_assert_str_eq	(	s	,
		"---\ull"
	)

◆ freeO() [1/2]

freeO ( o )

◆ createAllocateSmallBool() [2/2]

createAllocateSmallBool ( jBool )

◆ finishO() [11/32]

finishO ( jBool )

◆ ck_assert_str_eq() [28/113]

ck_assert_str_eq	(	b->	type,
		"smallBool"
	)

◆ ck_assert_str_eq() [29/113]

ck_assert_str_eq	(	s	,
		"false"
	)

◆ ck_assert_str_eq() [30/113]

ck_assert_str_eq	(	s	,
		"---\alse"
	)

◆ createAllocateSmallDouble()

createAllocateSmallDouble ( jDouble )

Here is the caller graph for this function:

◆ finishO() [12/32]

finishO ( jDouble )

◆ ck_assert_str_eq() [31/113]

ck_assert_str_eq	(	b->	type,
		"smallDouble"
	)

◆ ck_assert_str_eq() [32/113]

ck_assert_str_eq	(	s	,
		"0.000000e+00"
	)

◆ ck_assert_str_eq() [33/113]

ck_assert_str_eq	(	s	,
		"---\.000000e+00"
	)

◆ createAllocateSmallInt() [4/5]

createAllocateSmallInt ( jInt )

◆ finishO() [13/32]

finishO ( jInt )

◆ ck_assert_str_eq() [34/113]

ck_assert_str_eq	(	b->	type,
		"smallInt"
	)

◆ ck_assert_str_eq() [35/113]

ck_assert_str_eq	(	s	,
		"0"
	)

◆ ck_assert_str_eq() [36/113]

ck_assert_str_eq	(	s	,
		"---\"
	)

◆ createAllocateSmallString() [2/7]

createAllocateSmallString ( jString )

◆ set() [22/55]

jString f set	(	jString	,
		"sheepy"
	)

◆ finishO() [14/32]

finishO ( jString )

◆ ck_assert_str_eq() [37/113]

ck_assert_str_eq	(	b->	type,
		"smallString"
	)

◆ ck_assert_str_eq() [38/113]

ck_assert_str_eq	(	s	,
		"sheepy"
	)

◆ ck_assert_str_eq() [39/113]

ck_assert_str_eq	(	s	,
		"\epy\
	)

◆ ck_assert_str_eq() [40/113]

ck_assert_str_eq	(	s	,
		"---\eepy\
	)

◆ createAllocateSmallDict() [2/4]

createAllocateSmallDict ( jdict )

◆ finishO() [15/32]

finishO ( jdict )

◆ ck_assert_str_eq() [41/113]

ck_assert_str_eq	(	b->	type,
		"smallDict"
	)

◆ ck_assert_str_eq() [42/113]

ck_assert_str_eq	(	s	,
		"{}\
	)

◆ ck_assert_str_eq() [43/113]

ck_assert_str_eq	(	s	,
		"---\}\
	)

◆ createAllocateSmallArray() [1/6]

createAllocateSmallArray ( jArray )

◆ finishO() [16/32]

finishO ( jArray )

◆ ck_assert_str_eq() [44/113]

ck_assert_str_eq	(	b->	type,
		"smallArray"
	)

◆ ck_assert_str_eq() [45/113]

ck_assert_str_eq	(	s	,
		""	[]
	)

◆ ck_assert_str_eq() [46/113]

ck_assert_str_eq	(	s	,
		"\	[]
	)

◆ ck_assert_str_eq() [47/113]

ck_assert_str_eq	(	s	,
		"---\	[]
	)

◆ ck_assert() [7/30]

ck_assert ( in->value-> value = =123 )

◆ createAllocateSmallDict() [3/4]

createAllocateSmallDict ( oD2 )

◆ set() [23/55]

oD2 f set	(	oD2	,
		"int"	,
		(baset *)	in2
	)

◆ finishO() [17/32]

finishO ( in2 )

◆ set() [24/55]

oD2 f set	(	oD2	,
		"int2"	,
		(baset *)	in2
	)

◆ set() [25/55]

obj2 f set	(	obj2	,
		"dict"	,
		(baset *)	oD2
	)

◆ finishO() [18/32]

finishO ( oD2 )

◆ createAllocateSmallArray() [2/6]

createAllocateSmallArray ( oTA2 )

◆ push() [3/8]

oTA2 f push	(	oTA2	,
		(baset *)	in2
	)

◆ smashO() [3/4]

smashO ( in )

◆ set() [26/55]

obj2 f set	(	obj2	,
		"array"	,
		(baset *)	oTA2
	)

◆ finishO() [19/32]

finishO ( oTA2 )

◆ ck_assert_ptr_eq() [13/25]

ck_assert_ptr_eq	(	in	,
		NULL
	)

◆ createAllocateSmallJson() [2/6]

createAllocateSmallJson ( json )

◆ createAllocateSmallInt() [5/5]

createAllocateSmallInt ( oInt4 )

◆ set() [27/55]

oInt4 f set	(	oInt4	,
		345
	)

◆ push() [4/8]

json f push	(	json	,
		(baset *)	oInt4
	)

◆ finishO() [20/32]

finishO ( oInt4 )

◆ createSmallJson() [2/2]

createSmallJson ( jpath )

◆ createSmallBool() [1/7]

createSmallBool ( ba )

◆ jpath() [1/2]

jpath f set& jpath ( & ba )

◆ ck_assert() [8/30]

ck_assert ( jBool->value-> value = =false )

◆ createSmallBool() [2/7]

createSmallBool ( bb )

◆ jpath() [2/2]

jpath f set& jpath ( baset * ) &

◆ ck_assert_str_eq() [48/113]

ck_assert_str_eq	(	jArray->	type,
		"smallArray"
	)

◆ ck_assert_uint_eq() [8/33]

ck_assert_uint_eq	(	lenO(jArray)	,
		1
	)

◆ finishG() [1/4]

finishG ( jArray )

◆ ck_assert_uint_eq() [9/33]

ck_assert_uint_eq	(	in->value->	value,
		11
	)

◆ finishG() [2/4]

finishG ( in )

◆ createSmallBool() [3/7]

createSmallBool ( be )

◆ finishG() [3/4]

finishG ( jBool )

◆ createSmallBool() [4/7]

createSmallBool ( b2 )

◆ ck_assert_ptr_ne() [2/4]

ck_assert_ptr_ne	(	o2	,
		NULL
	)

◆ createSmallBool() [5/7]

createSmallBool ( b3 )

◆ ck_assert_str_eq() [49/113]

ck_assert_str_eq	(	ks	,
		"\\
	)

◆ createSmallBool() [6/7]

createSmallBool ( b4 )

◆ pErrorNULL()

pErrorNULL ( iPrependS &, "[1]" ks )

Here is the caller graph for this function:

◆ free() [2/7]

free ( ks )

◆ finishG() [4/4]

finishG ( b )

◆ createSmallBool() [7/7]

createSmallBool ( b0 )

◆ ck_assert_ptr_eq() [14/25]

ck_assert_ptr_eq	(	o2	,
		NULL
	)

◆ ck_assert_uint_eq() [10/33]

ck_assert_uint_eq	(	o->f->	leno,
		1
	)

◆ sFree() [3/5]

sFree ( (smallt *) o-> topS )

◆ set() [28/55]

o f set	(	o	,
		"wer"	,
		(baset *)	in
	)

◆ finishO() [21/32]

finishO ( in )

◆ set() [29/55]

jdict f set	(	jdict	,
		"string"	,
		(baset *)	jString
	)

◆ set() [30/55]

jdict f set	(	jdict	,
		"container"	,
		(baset *)	jcontainer
	)

◆ finishO() [22/32]

finishO ( jcontainer )

◆ push() [5/8]

jArray f push	(	jArray	,
		(baset *)	jString
	)

◆ ck_assert_str_eq() [50/113]

ck_assert_str_eq	(	s	,
		"	[\ 345,\ \heepy\\ {},\ [],
		\ {\ \tring\ \heepy\\ \ontainer\ \data container >\ }	,
		\ \\	[\ \heepy\\ \data container >\]
	)

◆ createAllocateSmallJson() [3/6]

createAllocateSmallJson ( json2 )

◆ set() [31/55]

json2 f set	(	json2	,
		"s"	,
		(baset *)	jString
	)

◆ set() [32/55]

json2 f set	(	json2	,
		"d"	,
		(baset *)	jdict
	)

◆ set() [33/55]

json2 f set	(	json2	,
		"a"	,
		(baset *)	jArray
	)

◆ set() [34/55]

json2 f set	(	json2	,
		"d2"	,
		(baset *)	jdict
	)

◆ set() [35/55]

json2 f set	(	json2	,
		"a2"	,
		(baset *)	jArray
	)

◆ set() [36/55]

json2 f set	(	json2	,
		"int"	,
		(baset *)	oInt4
	)

◆ ck_assert_str_eq() [51/113]

ck_assert_str_eq ( s )

◆ ck_assert_str_eq() [52/113]

ck_assert_str_eq	(	s	,
		"---\ 345\ sheepy\ {}\ \ []string: sheepy\ontainer: \ta	container,
		\ - - sheepy\ - \data	container,
		\"
	)

◆ createAllocateSmallJson() [4/6]

createAllocateSmallJson ( json3 )

◆ terminateO() [7/27]

terminateO ( json3 )

◆ ck_assert_str_eq() [53/113]

ck_assert_str_eq	(	s	,
		"---\: sheepy\:\}\:\ []d2:\tring: sheepy\ontainer: \ta	container,
		\ a2:\ - sheepy\ - \data	container,
		\ int:345\
	)

◆ terminateO() [8/27]

terminateO ( json2 )

◆ terminateO() [9/27]

terminateO ( json )

◆ parse() [1/9]

json f parse	(	json	,
		"null"
	)

◆ ck_assert_str_eq() [54/113]

ck_assert_str_eq	(	json->f->	getTopTypejson,
		"undefined"
	)

◆ parse() [2/9]

json f parse	(	json	,
		"true"
	)

◆ ck_assert_str_eq() [55/113]

ck_assert_str_eq	(	json->f->	getTopTypejson,
		"bool"
	)

◆ parse() [3/9]

json f parse	(	json	,
		"0.01"
	)

◆ ck_assert_str_eq() [56/113]

ck_assert_str_eq	(	json->f->	getTopTypejson,
		"double"
	)

◆ parse() [4/9]

json f parse	(	json	,
		"10"
	)

◆ ck_assert_str_eq() [57/113]

ck_assert_str_eq	(	json->f->	getTopTypejson,
		"int"
	)

◆ parse() [5/9]

json f parse	(	json	,
		"\\
	)

◆ ck_assert_str_eq() [58/113]

ck_assert_str_eq	(	json->f->	getTopTypejson,
		"string"
	)

◆ createAllocateSmallJson() [5/6]

createAllocateSmallJson ( jsOfromF )

◆ parse() [6/9]

jsOfromF f parse	(	jsOfromF	,
		jsonText
	)

◆ ck_assert_str_eq() [59/113]

ck_assert_str_eq	(	s	,
		"{\d\d\d\4,\t\ray\,1],\\ue,\at\434000e+01},\l\lse,\\ll}"
	)

◆ free() [3/7]

free ( jsonText )

◆ listFreeS() [2/3]

listFreeS ( file )

◆ terminateO() [10/27]

terminateO ( jsOfromF )

◆ ck_assert_str_eq() [60/113]

ck_assert_str_eq	(	s	,
		"	[\sd\234,{\rray\[1, 1],
		\sd\	true,
		\loat\3.434000e+01}]"
	)

◆ parse() [7/9]

json f parse ( json )

◆ parse() [8/9]

json f parse	(	json	,
		"[\"
	)

◆ parse() [9/9]

json f parse	(	json	,
		"\"
	)

◆ parseYML()

jsOfromF f parseYML	(	jsOfromF	,
		jsonText
	)

◆ ck_assert_str_eq() [61/113]

ck_assert_str_eq	(	s	,
		"{\t\ray\,1],\at\434000e+01,\\ue},\d\d\d\4,\l\lse,\\ll}"
	)

◆ ck_assert_str_eq() [62/113]

ck_assert_str_eq	(	s	,
		"	[{\ict\\ello\\rray\[1, 1],
		\loat\3.434000e+	01,
		\sd\true}	,
		\sd\234]"
	)

◆ ck_assert_str_eq() [63/113]

ck_assert_str_eq	(	s	,
		""	[0x01]
	)

◆ deserial() [1/2]

o f deserial	(	o	,
		B
	)

◆ terminateO() [11/27]

terminateO ( B )

◆ finishO() [23/32]

finishO ( oBool )

◆ ck_assert_str_eq() [64/113]

ck_assert_str_eq	(	s	,
		""	[0x02, 0x01]
	)

◆ ck_assert_str_eq() [65/113]

ck_assert_str_eq	(	s	,
		"true"
	)

◆ finishO() [24/32]

finishO ( od )

◆ ck_assert_str_eq() [66/113]

ck_assert_str_eq	(	s	,
		""	[0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0x40]
	)

◆ ck_assert_str_eq() [67/113]

ck_assert_str_eq	(	s	,
		"1.000000e+01"
	)

◆ ck_assert_str_eq() [68/113]

ck_assert_str_eq	(	s	,
		""	[0x07, 0x55, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
	)

◆ ck_assert_str_eq() [69/113]

ck_assert_str_eq	(	s	,
		"85"
	)

◆ ck_assert_str_eq() [70/113]

ck_assert_str_eq	(	s	,
		""	[0x08, 0x73, 0x68, 0x65, 0x65, 0x70, 0x79, 0x00]
	)

◆ finishO() [25/32]

finishO ( sDD )

◆ ck_assert_str_eq() [71/113]

ck_assert_str_eq	(	s	,
		""	[0x04, 0x00, 0x00, 0x00, 0x00]
	)

◆ finishO() [26/32]

finishO ( sAA )

◆ ck_assert_str_eq() [72/113]

ck_assert_str_eq	(	s	,
		""	[0x0a, 0x00, 0x00, 0x00, 0x00]
	)

◆ sFree() [4/5]

sFree ( (smallt *) c )

◆ ck_assert_uint_eq() [11/33]

ck_assert_uint_eq	(	o->	topIsA,
		0
	)

◆ deserial() [2/2]

o f deserial	(	o	,
		NULL
	)

◆ createSmallArray()

END_TEST createSmallArray ( obj )

Here is the caller graph for this function:

◆ ck_assert_str_eq() [73/113]

ck_assert_str_eq	(	obj.	type,
		"smallArray"
	)

◆ createAllocateSmallArray() [3/6]

createAllocateSmallArray ( obj2 )

◆ ck_assert_str_eq() [74/113]

ck_assert_str_eq	(	obj2->	type,
		"smallArray"
	)

◆ ck_assert_str_eq() [75/113]

ck_assert_str_eq	(	s	,
		"[	null,
		123	,
		\heepy\"
	)

◆ delElem() [1/4]

o2 f delElem	(	o2	,
		0
	)

◆ ck_assert_str_eq() [76/113]

ck_assert_str_eq	(	s	,
		"[	123,
		\heepy\"
	)

◆ terminateO() [12/27]

terminateO ( o2 )

◆ ck_assert() [9/30]

ck_assert ( isOType(u, "undefined") )

◆ ck_assert() [10/30]

ck_assert ( r )

◆ fromArray() [1/3]

o f fromArray	(	o	,
		(void *)	array,
		3
	)

◆ ck_assert_uint_eq() [12/33]

ck_assert_uint_eq	(	o->f->	leno,
		3
	)

◆ ck_assert_str_eq() [77/113]

ck_assert_str_eq	(	strFrom->f->	getstrFrom,
		"1"
	)

◆ smashO() [4/4]

smashO ( strFrom )

◆ ck_assert_str_eq() [78/113]

ck_assert_str_eq	(	strFrom->f->	getstrFrom,
		"22"
	)

◆ ck_assert_str_eq() [79/113]

ck_assert_str_eq	(	strFrom->f->	getstrFrom,
		"333"
	)

◆ ck_assert_ptr_eq() [15/25]

ck_assert_ptr_eq	(	strFrom	,
		NULL
	)

◆ fromArray() [2/3]

o f fromArray	(	o	,
		shpList	,
		0
	)

◆ ck_assert_uint_eq() [13/33]

ck_assert_uint_eq	(	o->f->	leno,
		2
	)

◆ listFreeS() [3/3]

listFreeS ( shpList )

◆ fromArray() [3/3]

o f fromArray	(	o	,
		NULL	,
		3
	)

◆ set() [37/55]

in f set	(	in	,
		654
	)

◆ ck_assert_uint_eq() [14/33]

ck_assert_uint_eq	(	o->f->	leno,
		4
	)

◆ ck_assert_uint_eq() [15/33]

ck_assert_uint_eq	(	in->value->	value,
		654
	)

◆ push() [6/8]

o f push	(	o	,
		NULL
	)

◆ ck_assert_str_eq() [80/113]

ck_assert_str_eq	(	st->f->	getst,
		"sheepy"
	)

◆ terminateO() [13/27]

terminateO ( st )

◆ ck_assert_uint_eq() [16/33]

ck_assert_uint_eq	(	in->value->	value,
		123
	)

◆ terminateO() [14/27]

terminateO ( in )

◆ ck_assert_ptr_eq() [16/25]

ck_assert_ptr_eq	(	u	,
		NULL
	)

◆ free() [4/7]

o f free ( o )

◆ setAt() [1/4]

o2 f setAt	(	o2	,
		1	,
		(baset *)	in
	)

◆ append() [3/4]

o f append	(	o	,
		o2
	)

◆ ck_assert_str_eq() [81/113]

ck_assert_str_eq	(	s	,
		"[	null,
		123	,
		\heepy\	null,
		789	,
		\heepy\"
	)

◆ append() [4/4]

o f append	(	o	,
		o
	)

◆ ck_assert_str_eq() [82/113]

ck_assert_str_eq	(	s	,
		"[	null,
		789	,
		\heepy\"
	)

◆ dispose() [2/2]

o2 f dispose ( o2 )

◆ set() [38/55]

in f set	(	in	,
		5345
	)

◆ slice() [1/9]

o f slice	(	o	,
		1	,
		-	1
	)

◆ slice() [2/9]

o f slice	(	o	,
		20	,
		-	1
	)

◆ slice() [3/9]

o f slice	(	o	,
		-	20,
		1
	)

◆ ck_assert_str_eq() [83/113]

ck_assert_str_eq	(	s	,
		""	[null]
	)

◆ slice() [4/9]

o f slice	(	o	,
		2	,
		40
	)

◆ ck_assert_str_eq() [84/113]

ck_assert_str_eq	(	s	,
		""	[\heepy\5345]
	)

◆ slice() [5/9]

o f slice	(	o	,
		2	,
		-	40
	)

◆ slice() [6/9]

o f slice	(	o	,
		3	,
		2
	)

◆ slice() [7/9]

o f slice	(	o	,
		-	1,
		0
	)

◆ ck_assert_str_eq() [85/113]

ck_assert_str_eq	(	s	,
		""	[5345]
	)

◆ slice() [8/9]

o f slice	(	o	,
		1	,
		1
	)

◆ slice() [9/9]

o f slice	(	o	,
		0	,
		0
	)

◆ insert() [1/5]

o f insert	(	o	,
		0	,
		o2
	)

◆ ck_assert_str_eq() [86/113]

ck_assert_str_eq	(	s	,
		"[	null,
		789	,
		\heepy\	null,
		123	,
		\heepy\"
	)

◆ insert() [2/5]

o f insert	(	o	,
		-	1,
		o2
	)

◆ insert() [3/5]

o f insert	(	o	,
		3	,
		o2
	)

◆ insert() [4/5]

o f insert	(	o	,
		4	,
		o2
	)

◆ delElem() [2/4]

o f delElem	(	o	,
		1
	)

◆ delElem() [3/4]

o f delElem	(	o	,
		2
	)

◆ trim()

o f trim ( o )

Here is the caller graph for this function:

◆ ck_assert_str_eq() [87/113]

ck_assert_str_eq	(	s	,
		"[	null,
		null	,
		789	,
		\heepy\"
	)

◆ insert() [5/5]

o f insert	(	o	,
		0	,
		NULL
	)

◆ del() [5/13]

o f del	(	o	,
		1	,
		-	1
	)

◆ ck_assert_str_eq() [88/113]

ck_assert_str_eq	(	s	,
		""	[null, 5345]
	)

◆ del() [6/13]

o f del	(	o	,
		20	,
		-	1
	)

◆ ck_assert_str_eq() [89/113]

ck_assert_str_eq	(	s	,
		""	[null, 123,\heepy\5345]
	)

◆ del() [7/13]

o f del	(	o	,
		-	20,
		1
	)

◆ ck_assert_str_eq() [90/113]

ck_assert_str_eq	(	s	,
		""	[123,\heepy\5345]
	)

◆ del() [8/13]

o f del	(	o	,
		2	,
		40
	)

◆ ck_assert_str_eq() [91/113]

ck_assert_str_eq	(	s	,
		""	[null, 123]
	)

◆ del() [9/13]

o f del	(	o	,
		2	,
		-	40
	)

◆ del() [10/13]

o f del	(	o	,
		3	,
		2
	)

◆ del() [11/13]

o f del	(	o	,
		-	1,
		0
	)

◆ del() [12/13]

o f del	(	o	,
		1	,
		1
	)

◆ del() [13/13]

o f del	(	o	,
		0	,
		0
	)

◆ delElem() [4/4]

o f delElem	(	o	,
		0
	)

◆ ck_assert_str_eq() [92/113]

ck_assert_str_eq	(	s	,
		""	[123]
	)

◆ ck_assert_str_eq() [93/113]

ck_assert_str_eq	(	u->	type,
		"undefined"
	)

◆ ck_assert_str_eq() [94/113]

ck_assert_str_eq	(	st->	type,
		"smallString"
	)

◆ setAt() [2/4]

o f setAt	(	o	,
		0	,
		(baset *)	in
	)

◆ ck_assert_str_eq() [95/113]

ck_assert_str_eq	(	s	,
		"[	0,
		123	,
		\heepy\"
	)

◆ setAt() [3/4]

o f setAt	(	o	,
		-	1,
		(baset *)	in
	)

◆ ck_assert_str_eq() [96/113]

ck_assert_str_eq	(	s	,
		""	[0, 123, 0]
	)

◆ setAt() [4/4]

o f setAt	(	o	,
		4	,
		(baset *)	in
	)

◆ ck_assert() [11/30]

ck_assert ( o->f-> isEmptyo )

◆ ck_assert() [12/30]

ck_assert ( !o->f-> isEmptyo )

◆ ck_assert_str_eq() [97/113]

ck_assert_str_eq	(	s	,
		"undefined"
	)

◆ ck_assert_uint_eq() [17/33]

ck_assert_uint_eq	(	c	,
		INT
	)

◆ ck_assert() [13/30]

ck_assert ( !o->f-> typeo, 10 )

◆ ck_assert() [14/30]

ck_assert ( !o->f-> typeo, -14 )

◆ ck_assert_uint_eq() [18/33]

ck_assert_uint_eq	(	c	,
		UNDEFINED
	)

◆ ck_assert() [15/30]

ck_assert ( !o2->f-> typeo2, 0 )

◆ ck_assert_str_eq() [98/113]

ck_assert_str_eq	(	s	,
		"	undefined,
		int	,
		string"
	)

◆ free() [5/7]

free ( l )

◆ ck_assert_ptr_eq() [17/25]

ck_assert_ptr_eq	(	o2->f->	typeStringso2,
		NULL
	)

◆ ck_assert_str_eq() [99/113]

ck_assert_str_eq	(	s	,
		""	[0x01, 0x07, 0x08]
	)

◆ initiateAllocateSmallArray()

initiateAllocateSmallArray ( NULL )

◆ createUndefined()

END_TEST createUndefined ( obj )

◆ ck_assert_str_eq() [100/113]

ck_assert_str_eq	(	obj.	type,
		"undefined"
	)

◆ createAllocateUndefined() [3/4]

createAllocateUndefined ( obj2 )

◆ ck_assert_str_eq() [101/113]

ck_assert_str_eq	(	obj2->	type,
		"undefined"
	)

◆ createSmallBytes()

END_TEST createSmallBytes ( obj )

◆ ck_assert_str_eq() [102/113]

ck_assert_str_eq	(	obj.	type,
		"smallBytes"
	)

◆ createAllocateSmallBytes()

createAllocateSmallBytes ( obj2 )

Here is the caller graph for this function:

◆ ck_assert_str_eq() [103/113]

ck_assert_str_eq	(	obj2->	type,
		"smallBytes"
	)

◆ terminateO() [15/27]

terminateO ( obj3 )

◆ ck_assert_uint_eq() [19/33]

ck_assert_uint_eq	(	obj3->B->	data,
		2
	)

◆ push() [7/8]

obj3 f push	(	obj3	,
		4
	)

◆ ck_assert_uint_eq() [20/33]

ck_assert_uint_eq	(	r	[1],
		4
	)

◆ ck_assert_uint_eq() [21/33]

ck_assert_uint_eq	(	c	,
		2
	)

◆ ck_assert_uint_eq() [22/33]

ck_assert_uint_eq	(	c	,
		0
	)

◆ createAllocateSmallArray() [4/6]

END_TEST createAllocateSmallArray ( l )

◆ putsO() [1/2]

putsO ( l )

◆ putsO() [2/2]

putsO ( NULL )

◆ terminateO() [16/27]

terminateO ( l )

◆ execO() [1/2]

execO	(	"ls libsheepyObjectTest.c"	,
		l	,
		NULL
	)

◆ ck_assert_uint_eq() [23/33]

ck_assert_uint_eq	(	l->f->	lenl,
		1
	)

◆ ck_assert_str_eq() [104/113]

ck_assert_str_eq	(	l->f->	getAtSl, 0,
		"libsheepyObjectTest.c"
	)

◆ freeO() [2/2]

freeO ( l )

◆ execO() [2/2]

execO	(	"randomComand"	,
		l	,
		NULL
	)

◆ ck_assert_uint_eq() [24/33]

ck_assert_uint_eq	(	l->f->	lenl,
		0
	)

◆ ck_assert_int_eq() [1/20]

ck_assert_int_eq	(	execO(NULL, NULL, NULL)	,
		0
	)

◆ ck_assert_uint_eq() [25/33]

ck_assert_uint_eq	(	l->f->	lenl,
		3
	)

◆ ck_assert_str_eq() [105/113]

ck_assert_str_eq	(	l->f->	getAtSl, 0,
		"../dirTest.null/one"
	)

◆ ck_assert_str_eq() [106/113]

ck_assert_str_eq	(	l->f->	getAtSl, 1,
		"../dirTest.null/two/four"
	)

◆ ck_assert_str_eq() [107/113]

ck_assert_str_eq	(	l->f->	getAtSl, 2,
		"../dirTest.null/two/three"
	)

◆ ck_assert_ptr_eq() [18/25]

ck_assert_ptr_eq	(	walkDirO("")	,
		NULL
	)

◆ ck_assert() [16/30]

ck_assert ( l->f-> isEmptyl )

◆ ck_assert_ptr_eq() [19/25]

ck_assert_ptr_eq	(	walkDirO(NULL)	,
		NULL
	)

◆ createAllocateSmallString() [3/7]

createAllocateSmallString ( v )

◆ set() [39/55]

v f set	(	v	,
		"sheepy"
	)

◆ expandHomeO() [1/2]

expandHomeO ( v )

◆ ck_assert() [17/30]

ck_assert ( v->f-> equalSv, "sheepy" )

◆ terminateO() [17/27]

terminateO ( v )

◆ expandHomeO() [2/2]

expandHomeO ( NULL )

◆ set() [40/55]

v f set	(	v	,
		"../dirTest.null"
	)

◆ ck_assert() [18/30]

ck_assert ( chDirO(v) )

◆ chDirO()

chDirO ( c )

◆ terminateO() [18/27]

terminateO ( c )

◆ createAllocateSmallString() [4/7]

createAllocateSmallString ( n )

◆ set() [41/55]

n f set	(	n	,
		"RandomNonExistingDir"
	)

◆ ck_assert() [19/30]

ck_assert ( ! chDirOn )

◆ ck_assert() [20/30]

ck_assert ( ! chDirONULL )

◆ terminateO() [19/27]

terminateO ( n )

◆ createAllocateSmallArray() [5/6]

END_TEST createAllocateSmallArray ( sA )

◆ fromArrayNFree()

sA f fromArrayNFree	(	sA	,
		l	,
		0
	)

◆ ck_assert() [21/30]

ck_assert ( fileExistsO(S) )

◆ finishO() [27/32]

finishO ( S )

◆ ck_assert() [22/30]

ck_assert ( ! fileExistsOS )

◆ terminateO() [20/27]

terminateO ( sA )

◆ set() [42/55]

v f set	(	v	,
		"../chmodTest.null"
	)

◆ ck_assert() [23/30]

◆ ck_assert() [24/30]

ck_assert ( fileChmodO(v, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH) )

◆ set() [43/55]

n f set	(	n	,
		"qweqwe_null"
	)

◆ ck_assert() [25/30]

ck_assert ( ! fileChmodOn, S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH )

◆ createAllocateSmallString() [5/7]

createAllocateSmallString ( e )

◆ set() [44/55]

e f set	(	e	,
		""
	)

◆ ck_assert() [26/30]

ck_assert ( ! fileChmodOe, 0 )

◆ ck_assert() [27/30]

ck_assert ( ! fileChmodONULL, 0 )

◆ terminateO() [21/27]

terminateO ( e )

◆ createAllocateSmallString() [6/7]

END_TEST createAllocateSmallString ( s )

◆ set() [45/55]

s f set	(	s	,
		"../sizeTest.null"
	)

◆ ck_assert_uint_eq() [26/33]

ck_assert_uint_eq	(	fileSizeO(s)	,
		743
	)

◆ ck_assert_uint_eq() [27/33]

ck_assert_uint_eq	(	fileSizeO(v)	,
		0
	)

◆ ck_assert_int_eq() [2/20]

ck_assert_int_eq	(	fileSizeO(n)	,
		-	1
	)

◆ ck_assert_int_eq() [3/20]

ck_assert_int_eq	(	fileSizeO(e)	,
		-	1
	)

◆ ck_assert_int_eq() [4/20]

ck_assert_int_eq	(	fileSizeO(NULL)	,
		-	1
	)

◆ terminateO() [22/27]

terminateO ( s )

◆ pError0() [1/5]

END_TEST pError0 ( rmAll("mkdirTest.null/null") )

◆ set() [46/55]

s f set	(	s	,
		"mkdirTest.null/null"
	)

◆ ck_assert_int_eq() [5/20]

ck_assert_int_eq	(	mkdirParentsO(s)	,
		1
	)

◆ set() [47/55]

v f set	(	v	,
		"/usr/null"
	)

◆ ck_assert_int_eq() [6/20]

ck_assert_int_eq	(	mkdirParentsO(v)	,
		0
	)

◆ ck_assert_int_eq() [7/20]

ck_assert_int_eq	(	mkdirParentsO(e)	,
		0
	)

◆ ck_assert_int_eq() [8/20]

ck_assert_int_eq	(	mkdirParentsO(NULL)	,
		0
	)

◆ set() [48/55]

s f set	(	s	,
		"rmAllTest.null/null"
	)

◆ pError0() [2/5]

pError0 ( mkdirParents("rmAllTest.null/null") )

◆ ck_assert_int_eq() [9/20]

ck_assert_int_eq	(	rmAllO(s)	,
		1
	)

◆ ck_assert_int_eq() [10/20]

ck_assert_int_eq	(	rmAllO(e)	,
		0
	)

◆ set() [49/55]

v f set	(	v	,
		"/var/lock"
	)

◆ ck_assert_int_eq() [11/20]

ck_assert_int_eq	(	rmAllO(v)	,
		0
	)

◆ ck_assert_int_eq() [12/20]

ck_assert_int_eq	(	rmAllO(NULL)	,
		0
	)

◆ createAllocateSmallString() [7/7]

createAllocateSmallString ( d )

◆ set() [50/55]

s f set	(	s	,
		"../chmodTest.null"
	)

◆ set() [51/55]

d f set	(	d	,
		"../copyTest.null"
	)

◆ ck_assert_int_eq() [13/20]

ck_assert_int_eq	(	copyO(s, d)	,
		1
	)

◆ pError0() [3/5]

pError0 ( fileChmod("../copyTest.null", 1) )

◆ ck_assert_int_eq() [14/20]

ck_assert_int_eq	(	copyO(d, d)	,
		0
	)

◆ pError0() [4/5]

pError0 ( fileChmod("../copyTest.null", 777) )

◆ pError0() [5/5]

pError0 ( rmAll("../copyTest.null") )

◆ ck_assert_int_eq() [15/20]

ck_assert_int_eq	(	copyO(e, d)	,
		0
	)

◆ ck_assert() [28/30]

ck_assert ( ! fileExists"copyTest.null" )

◆ ck_assert_int_eq() [16/20]

ck_assert_int_eq	(	copyO(s, e)	,
		0
	)

◆ ck_assert_int_eq() [17/20]

ck_assert_int_eq	(	copyO(NULL, d)	,
		0
	)

◆ ck_assert_int_eq() [18/20]

ck_assert_int_eq	(	copyO(s, NULL)	,
		0
	)

◆ ck_assert_int_eq() [19/20]

ck_assert_int_eq	(	copyO(NULL, NULL)	,
		0
	)

◆ terminateO() [23/27]

terminateO ( d )

◆ ck_assert_ptr_ne() [3/4]

ck_assert_ptr_ne	(	s	,
		NULL
	)

◆ ck_assert_ptr_eq() [20/25]

ck_assert_ptr_eq	(	randomSO(0)	,
		NULL
	)

◆ randomUrandomClose()

randomUrandomClose ( )

close /dev/urandom in libsheepy call this function when random are not needed anymore

Definition at line 5916 of file libsheepy.c.

◆ ck_assert_ptr_eq() [21/25]

ck_assert_ptr_eq	(	randomAlphaNumSO(0)	,
		NULL
	)

◆ fclose()

fclose ( fp )

Here is the caller graph for this function:

◆ ck_assert_str_eq() [108/113]

ck_assert_str_eq	(	s->f->	gets,
		"LINE 1"
	)

◆ ck_assert_str_eq() [109/113]

ck_assert_str_eq	(	ssGet(s)	,
		""
	)

◆ ck_assert_ptr_eq() [22/25]

ck_assert_ptr_eq	(	readLineO(NULL)	,
		NULL
	)

◆ createAllocateUndefined() [4/4]

createAllocateUndefined ( u )

◆ finishO() [28/32]

finishO ( u )

◆ ck_assert() [29/30]

ck_assert ( isSType(su, UNDEFINED) )

◆ createAllocateSmallArray() [6/6]

createAllocateSmallArray ( a )

◆ set() [52/55]

s f set	(	s	,
		"sheepy"
	)

◆ push() [8/8]

a f push	(	a	,
		(baset *)	s
	)

◆ finishO() [29/32]

finishO ( s )

◆ set() [53/55]

i f set	(	i	,
		20
	)

◆ finishO() [30/32]

finishO ( i )

◆ finishO() [31/32]

finishO ( a )

◆ ck_assert_uint_eq() [28/33]

ck_assert_uint_eq	(	sa->	count,
		2
	)

◆ ck_assert_str_eq() [110/113]

ck_assert_str_eq	(	S	,
		""	[\heepy\20]
	)

◆ free() [6/7]

free ( S )

◆ createAllocateSmallDict() [4/4]

createAllocateSmallDict ( d )

◆ set() [54/55]

d f set	(	d	,
		"s"	,
		(baset *)	s
	)

◆ set() [55/55]

d f set	(	d	,
		"i"	,
		(baset *)	i
	)

◆ finishO() [32/32]

finishO ( d )

◆ ck_assert_uint_eq() [29/33]

ck_assert_uint_eq	(	sd->	count,
		2
	)

◆ ck_assert_str_eq() [111/113]

ck_assert_str_eq	(	S	,
		"{\eepy\0}"
	)

◆ createAllocateSmallJson() [6/6]

createAllocateSmallJson ( j )

◆ ck_assert_ptr_ne() [4/4]

ck_assert_ptr_ne	(	so	,
		NULL
	)

◆ ck_assert_int_eq() [20/20]

ck_assert_int_eq	(	so->	type,
		CONTAINER
	)

◆ ck_assert_ptr_eq() [23/25]

ck_assert_ptr_eq	(	((sContainert *) so) ->	data,
		j
	)

◆ sFree() [5/5]

sFree ( so )

◆ ck_assert_ptr_eq() [24/25]

ck_assert_ptr_eq	(	toSmallt(NULL)	,
		NULL
	)

◆ ck_assert() [30/30]

ck_assert ( b->value-> value )

◆ terminateO() [24/27]

terminateO ( b )

◆ ck_assert_str_eq() [112/113]

ck_assert_str_eq	(	c->data->	data,
		"sheepy"
	)

◆ free() [7/7]

free ( c->data-> data )

◆ ck_assert_uint_eq() [30/33]

ck_assert_uint_eq	(	(uint) D->value->	value,
		10
	)

◆ terminateO() [25/27]

terminateO ( D )

◆ ck_assert_uint_eq() [31/33]

ck_assert_uint_eq	(	i->value->	value,
		10
	)

◆ terminateO() [26/27]

terminateO ( i )

◆ ck_assert_str_eq() [113/113]

ck_assert_str_eq	(	r	,
		"sheepy"
	)

◆ sa()

sArrayPushTiny& sa ( smallt * )

◆ ck_assert_uint_eq() [32/33]

ck_assert_uint_eq	(	a->a->	count,
		2
	)

◆ terminateO() [27/27]

terminateO ( a )

◆ sd()

sDictPushTiny& sd ( smallt * )

◆ ck_assert_uint_eq() [33/33]

ck_assert_uint_eq	(	d->d->	count,
		2
	)

◆ ck_assert_ptr_eq() [25/25]

ck_assert_ptr_eq	(	toBaset(NULL)	,
		NULL
	)

◆ libsheepySuite()

END_TEST Suite* libsheepySuite ( void )

Definition at line 2343 of file libsheepyObjectTest.c.

Here is the call graph for this function:

Here is the caller graph for this function:

◆ main()

int main	(	int ARGC	UNUSED,
		char **ARGV	UNUSED
	)

Definition at line 2384 of file libsheepyObjectTest.c.

Here is the call graph for this function:

Variable Documentation

◆ s

smallStringt * s = obj2->f->toString(obj2)

Examples:: /home/rlp/git/sw/libsheepy/release/tpool.h.

Definition at line 27 of file libsheepyObjectTest.c.

◆ o

undefinedt * o = obj2->f->duplicate(obj2)

Definition at line 31 of file libsheepyObjectTest.c.

◆ oBool3

oBool3 = (smallBoolt *)o->f->get(o, "lib")

Definition at line 37 of file libsheepyObjectTest.c.

◆ u

undefinedt * u = (undefinedt *) o->f->get(o, "u")

Definition at line 56 of file libsheepyObjectTest.c.

◆ st

smallStringt * st = (smallStringt *) o->f->get(o, "str")

Definition at line 57 of file libsheepyObjectTest.c.

◆ oBool2

oBool2 = (smallBoolt *) o->f->get(o, "lib")

Definition at line 58 of file libsheepyObjectTest.c.

◆ data

data = sDictGetTiny(o->d, "u")

Definition at line 59 of file libsheepyObjectTest.c.

◆ keys

keys = obj2->f->keys(obj2)

Definition at line 107 of file libsheepyObjectTest.c.

◆ len

size_t len = listLengthS(keys)

Definition at line 108 of file libsheepyObjectTest.c.

◆ values

values f smash & values = obj2->f->values(obj2)

Definition at line 119 of file libsheepyObjectTest.c.

◆ oM

initiateAllocateSmallDict & oM

Definition at line 130 of file libsheepyObjectTest.c.

◆ oU

undefinedt * oU = allocUndefined()

Definition at line 172 of file libsheepyObjectTest.c.

◆ c

smallContainert * c = o->f->type(o, "str")

Definition at line 246 of file libsheepyObjectTest.c.

◆ oT

oT = o->f->typeStrings(o)

Definition at line 254 of file libsheepyObjectTest.c.

◆ obj

obj f free & obj

Definition at line 265 of file libsheepyObjectTest.c.

◆ obj2

obj2 f terminate & obj2

Definition at line 268 of file libsheepyObjectTest.c.

◆ oInt

initiateAllocateSmallInt & oInt = allocSmallInt(85)

Definition at line 290 of file libsheepyObjectTest.c.

◆ oInt2

initiateAllocateSmallInt & oInt2

Definition at line 307 of file libsheepyObjectTest.c.

◆ i

smallIntt * i = sArrayGetTiny(o->topA, 0)

Definition at line 344 of file libsheepyObjectTest.c.

◆ b

smallBoolt * b = o->f->getTop(o)

Definition at line 402 of file libsheepyObjectTest.c.

◆ o2

initiateAllocateSmallArray & o2 = duplicateO(o)

Definition at line 403 of file libsheepyObjectTest.c.

◆ in

initiateAllocateSmallInt & in = (smallIntt *) obj2->f->get(obj2, "int")

Definition at line 640 of file libsheepyObjectTest.c.

◆ in2

in2 = duplicateO(in)

Definition at line 643 of file libsheepyObjectTest.c.

◆ jpath

freeO & jpath

Definition at line 690 of file libsheepyObjectTest.c.

◆ jBool

jBool = (smallBoolt*)jpath.f->get(&jpath,"b\\\\")

Definition at line 698 of file libsheepyObjectTest.c.

◆ bb

bb f set& bb

Definition at line 703 of file libsheepyObjectTest.c.

◆ jArray

initiateAllocateSmallArray & jArray = (smallArrayt*)jpath.f->get(&jpath,"[2][0]")

Definition at line 720 of file libsheepyObjectTest.c.

◆ ks

char* ks = jpath.f->makeKey(&jpath, "\\\\\\\"\"")

Definition at line 750 of file libsheepyObjectTest.c.

◆ topS

o topS = allocSStringTiny("er")

Definition at line 797 of file libsheepyObjectTest.c.

◆ jString

initiateAllocateSmallString & jString

Definition at line 815 of file libsheepyObjectTest.c.

◆ jdict

initiateAllocateSmallDict & jdict

Definition at line 819 of file libsheepyObjectTest.c.

◆ jcontainer

initiateAllocateSmallContainer & jcontainer

Definition at line 830 of file libsheepyObjectTest.c.

◆ oInt4

initiateAllocateSmallInt& oInt4

Definition at line 885 of file libsheepyObjectTest.c.

◆ json

initiateAllocateSmallJson & json

Definition at line 911 of file libsheepyObjectTest.c.

◆ file

file = readText("file.json")

Definition at line 936 of file libsheepyObjectTest.c.

◆ jsonText

jsonText = join(file, "\n")

Definition at line 937 of file libsheepyObjectTest.c.

◆ jsOfromF

initiateAllocateSmallJson & jsOfromF

Definition at line 950 of file libsheepyObjectTest.c.

◆ B

obj2 B = o->f->serial(o)

Definition at line 1026 of file libsheepyObjectTest.c.

◆ oBool

smallBoolt* oBool = allocSmallBool(true)

Definition at line 1051 of file libsheepyObjectTest.c.

◆ od

smallDoublet* od = allocSmallDouble(10)

Definition at line 1066 of file libsheepyObjectTest.c.

◆ sDD

smallDictt* sDD = allocSmallDict()

Definition at line 1111 of file libsheepyObjectTest.c.

◆ sAA

smallArrayt* sAA = allocSmallArray()

Definition at line 1126 of file libsheepyObjectTest.c.

◆ topU

o topU = NULL

Definition at line 1160 of file libsheepyObjectTest.c.

◆ r

char * r = strEq(st->f->get(st), "sheepy")

Definition at line 1259 of file libsheepyObjectTest.c.

◆ array

char* array[] = {"1", "22", "333"}

Definition at line 1278 of file libsheepyObjectTest.c.

◆ arrayNULL

char* arrayNULL[] = {"1", NULL, "333"}

Definition at line 1279 of file libsheepyObjectTest.c.

◆ strFrom

strFrom = (smallStringt*) o->f->getAt(o,0)

Definition at line 1283 of file libsheepyObjectTest.c.

◆ shpList

char** shpList = listCreateS("lib", "sheepy")

Definition at line 1305 of file libsheepyObjectTest.c.

◆ value

in value value = 789

Definition at line 1363 of file libsheepyObjectTest.c.

◆ oStr

oStr = allocSmallString("sheepy")

Definition at line 1774 of file libsheepyObjectTest.c.

◆ l

char ** l = o->f->typeStrings(o)

Definition at line 1796 of file libsheepyObjectTest.c.

◆ obj3

initiateAllocateSmallBytes & obj3 = allocSmallBytes(NULL, 0)

Definition at line 1861 of file libsheepyObjectTest.c.

◆ S

char * S = sA->f->getAtSmallString(sA, 0)

Definition at line 2009 of file libsheepyObjectTest.c.

◆ fp

fp = fopen("../textTest.null", "r")

Definition at line 2195 of file libsheepyObjectTest.c.

◆ su

sUndefinedt * su = (sUndefinedt *) toSmallt((baset *)u)

Definition at line 2224 of file libsheepyObjectTest.c.

◆ sa

sArrayPushTiny & sa = (sArrayt *) toSmallt((baset *)a)

Definition at line 2238 of file libsheepyObjectTest.c.

◆ sd

sDictPushTiny & sd = (sDictt *) toSmallt((baset *)d)

Definition at line 2255 of file libsheepyObjectTest.c.

◆ so

smallt* so = toSmallt((baset *)j)

Definition at line 2264 of file libsheepyObjectTest.c.

◆ sb

END_TEST sBoolt* sb = allocSBool(true)

Definition at line 2278 of file libsheepyObjectTest.c.

◆ sc

sContainert* sc = allocSContainer(strdup("sheepy"))

Definition at line 2283 of file libsheepyObjectTest.c.

◆ sD

sDoublet* sD = allocSDouble(10)

Definition at line 2289 of file libsheepyObjectTest.c.

◆ D

smallDoublet* D = (smallDoublet *) toBaset((smallt *)sD)

Definition at line 2290 of file libsheepyObjectTest.c.

◆ si

si = allocSInt(10)

Definition at line 2294 of file libsheepyObjectTest.c.

◆ ss

ss = allocSStringTiny("sheepy")

Definition at line 2299 of file libsheepyObjectTest.c.

◆ a

smallArrayt* a = (smallArrayt *) toBaset((smallt *)sa)

Definition at line 2316 of file libsheepyObjectTest.c.

◆ d

smallDictt* d = (smallDictt *) toBaset((smallt *)sd)

Definition at line 2328 of file libsheepyObjectTest.c.

Macros

Functions

Variables

Macro Definition Documentation

◆ UNUSED

Function Documentation

◆ createSmallDict()

◆ ck_assert_str_eq() [1/113]

◆ createAllocateSmallDict() [1/4]

◆ ck_assert_str_eq() [2/113]

◆ ck_assert_str_eq() [3/113]

◆ free() [1/7]

◆ createAllocateSmallBool() [1/2]

◆ set() [1/55]

◆ set() [2/55]

◆ finishO() [1/32]

◆ ck_assert_ptr_ne() [1/4]

◆ ck_assert() [1/30]

◆ finishO() [2/32]

◆ terminateO() [1/27]

◆ createAllocateUndefined() [1/4]

◆ set() [3/55]

◆ finishO() [3/32]

◆ createAllocateSmallString() [1/7]

◆ set() [4/55]

◆ set() [5/55]

◆ finishO() [4/32]

◆ ck_assert_str_eq() [4/113]

◆ sFree() [1/5]

◆ dispose() [1/2]

◆ ck_assert_uint_eq() [1/33]

◆ terminateO() [2/27]

◆ smashO() [1/4]

◆ smashO() [2/4]

◆ ck_assert_ptr_eq() [1/25]

◆ set() [6/55]

◆ set() [7/55]

◆ ck_assert_uint_eq() [2/33]

◆ ck_assert_ptr_eq() [2/25]

◆ ck_assert_ptr_eq() [3/25]

◆ del() [1/13]

◆ del() [2/13]

◆ del() [3/13]

◆ ck_assert() [2/30]

◆ ck_assert() [3/30]

◆ ck_assert() [4/30]

◆ ck_assert_uint_eq() [3/33]

◆ ck_assert_str_eq() [5/113]

◆ ck_assert_str_eq() [6/113]

◆ listFreeS() [1/3]

◆ ck_assert_ptr_eq() [4/25]

◆ ck_assert_str_eq() [7/113]

◆ ck_assert_ptr_eq() [5/25]

◆ set() [8/55]

◆ set() [9/55]

◆ finishO() [5/32]

◆ ck_assert_str_eq() [8/113]

◆ merge() [1/2]

◆ ck_assert_str_eq() [9/113]

◆ merge() [2/2]

◆ set() [10/55]

◆ append() [1/4]

◆ ck_assert_str_eq() [10/113]

◆ append() [2/4]

◆ ck_assert_uint_eq() [4/33]

◆ empty()

◆ set() [11/55]

◆ set() [12/55]

◆ set() [13/55]

◆ set() [14/55]

◆ del() [4/13]

◆ ck_assert_str_eq() [11/113]

◆ ck_assert_ptr_eq() [6/25]

◆ ck_assert_ptr_eq() [7/25]

◆ ck_assert_uint_eq() [5/33]

◆ ck_assert() [5/30]

◆ ck_assert() [6/30]

◆ ck_assert_str_eq() [12/113]

◆ terminateO() [3/27]

◆ ck_assert_ptr_eq() [8/25]