libsheepyCSmallContainerTestMem.c (9027B)
1 #include <stdlib.h> 2 #include <stdio.h> 3 #include <string.h> 4 5 #define ck_assert_str_eq(a,b) a;b; 6 #define ck_assert_str_ne(a,b) a;b; 7 #define ck_assert_ptr_eq(a,b) a;b; 8 #define ck_assert_ptr_ne(a,b) a;b; 9 #define ck_assert_uint_eq(a,b) a;b; 10 #define ck_assert_uint_ne(a,b) a;b; 11 #define ck_assert_int_eq(a,b) a;b; 12 #define ck_assert_int_ne(a,b) a;b; 13 #define ck_assert(a) a; 14 15 16 #include "../libsheepy.h" 17 #include "../libsheepyObject.h" 18 19 #ifdef __GNUC__ 20 #define UNUSED __attribute__ ((unused)) 21 #else 22 #define UNUSED 23 #endif 24 25 // TODO redirect stderr 26 27 28 void allocSmallContainerT(void) { 29 30 smallContainert* r; 31 void *data = null; 32 33 r = allocSmallContainer(&data); 34 ck_assert_ptr_ne(r, null); 35 ck_assert_ptr_eq(getValO(r), &data); 36 terminateO(r); 37 38 } 39 40 i32 something = 123; 41 42 char *classToString(void *data) { 43 i32 *p = data; 44 ret intToS(*p); 45 } 46 47 char *objToString(void *data) { 48 i32 *p = data; 49 ret intToS(*p); 50 } 51 52 53 void toStringSmallContainerT(void) { 54 55 char* r; 56 smallContainert *self = allocSmallContainer(&something); 57 58 r = toStringO(self); 59 ck_assert_ptr_ne(r, null); 60 ck_assert_str_eq(r, "<data smallContainer>"); 61 free(r); 62 // class toString 63 something = 123; 64 setClassDataToStringO(self, classToString); 65 r = toStringO(self); 66 ck_assert_ptr_ne(r, null); 67 ck_assert_str_eq(r, "123"); 68 free(r); 69 setClassDataToStringO(self, null); 70 // object toString 71 something = 456; 72 setObjectDataToStringO(self, objToString); 73 r = toStringO(self); 74 ck_assert_ptr_ne(r, null); 75 ck_assert_str_eq(r, "456"); 76 free(r); 77 // empty smallContainer 78 freeO(self); 79 r = toStringO(self); 80 ck_assert_ptr_eq(r, null); 81 terminateO(self); 82 83 } 84 85 void* dataDuplicateSmallContainer(void *data) { 86 ret data; 87 } 88 89 void duplicateSmallContainerT(void) { 90 91 smallContainert* r; 92 smallContainert *self = allocSmallContainer(&r); 93 94 // data (&r) not duplicated 95 r = duplicateO(self); 96 ck_assert_ptr_ne(r, null); 97 ck_assert_ptr_ne(r->data, null); 98 ck_assert_ptr_eq(r->data->data, null); 99 terminateO(r); 100 // class duplicate function 101 self->f->setClassDataDuplicate(self, dataDuplicateSmallContainer); 102 r = duplicateO(self); 103 self->f->setClassDataDuplicate(self, null); 104 ck_assert_ptr_ne(r, null); 105 ck_assert_ptr_ne(r->data, null); 106 ck_assert_ptr_eq(r->data->data, &r); 107 terminateO(r); 108 // container duplicate function 109 self->f->setObjectDataDuplicate(self, dataDuplicateSmallContainer); 110 r = duplicateO(self); 111 self->f->setObjectDataDuplicate(self, null); 112 ck_assert_ptr_ne(r, null); 113 ck_assert_ptr_ne(r->data, null); 114 ck_assert_ptr_eq(r->data->data, &r); 115 terminateO(r); 116 // empty smallContainer 117 freeO(self); 118 r = duplicateO(self); 119 terminateO(r); 120 terminateO(self); 121 122 } 123 124 int freeResult = 0; 125 126 void dataFreeSmallContainer(void *data UNUSED) { 127 freeResult = 1; 128 } 129 130 void setClassDataFreeSmallContainerT(void) { 131 132 smallContainert* r; 133 smallContainert *self = allocSmallContainer(null); 134 135 freeResult = 0; 136 r = setClassDataFreeO(self, dataFreeSmallContainer); 137 ck_assert_ptr_eq(r, self); 138 ck_assert_int_eq(freeResult, 0); 139 freeO(self); 140 ck_assert_int_eq(freeResult, 1); 141 freeResult = 0; 142 // free sContainer in an array 143 setValO(self, &r); 144 createAllocateSmallArray(a); 145 a->f->pushNFreeSmallContainer(a, self); 146 terminateO(a); 147 ck_assert_int_eq(freeResult, 1); 148 freeResult = 0; 149 150 } 151 152 153 void setObjectDataFreeSmallContainerT(void) { 154 155 smallContainert* r; 156 smallContainert *self = allocSmallContainer(null); 157 158 freeResult = 0; 159 r = setObjectDataFreeO(self, dataFreeSmallContainer); 160 ck_assert_ptr_eq(r, self); 161 ck_assert_int_eq(freeResult, 0); 162 freeO(self); 163 ck_assert_int_eq(freeResult, 1); 164 freeResult = 0; 165 // free sContainer in an array without the free function in sContainer 166 setClassDataFreeO(self, NULL); 167 setValO(self, &r); 168 createAllocateSmallArray(a); 169 a->f->pushNFreeSmallContainer(a, self); 170 terminateO(a); 171 ck_assert_int_eq(freeResult, 0); 172 // free sContainer in an array with the free function in sContainer 173 self = allocSmallContainer(null); 174 r = setObjectDataFreeO(self, dataFreeSmallContainer); 175 ck_assert_ptr_eq(r, self); 176 setValO(self, &r); 177 a = allocSmallArray(); 178 a->f->pushNFreeSmallContainer(a, self); 179 terminateO(a); 180 ck_assert_int_eq(freeResult, 1); 181 freeResult = 0; 182 183 } 184 185 186 void setClassDataToStringSmallContainerT(void) { 187 188 smallContainert* r; 189 smallContainert *self = allocSmallContainer(&something); 190 191 char *s = toStringO(self); 192 ck_assert_ptr_ne(s, null); 193 ck_assert_str_eq(s, "<data smallContainer>"); 194 free(s); 195 // toString with class function 196 r = setClassDataToStringO(self, classToString); 197 ck_assert_ptr_ne(r, null); 198 something = 123; 199 s = toStringO(self); 200 ck_assert_ptr_ne(s, null); 201 ck_assert_str_eq(s, "123"); 202 free(s); 203 terminateO(self); 204 205 } 206 207 208 void setObjectDataToStringSmallContainerT(void) { 209 210 smallContainert* r; 211 smallContainert *self = allocSmallContainer(&something); 212 // remove class toString function 213 setClassDataToStringO(self, NULL); 214 215 char *s = toStringO(self); 216 ck_assert_ptr_ne(s, null); 217 ck_assert_str_eq(s, "<data smallContainer>"); 218 free(s); 219 // toString with class function 220 r = setObjectDataToStringO(self, objToString); 221 ck_assert_ptr_ne(r, null); 222 something = 123; 223 s = toStringO(self); 224 ck_assert_ptr_ne(s, null); 225 ck_assert_str_eq(s, "123"); 226 free(s); 227 terminateO(self); 228 229 } 230 231 232 void setClassDataDuplicateSmallContainerT(void) { 233 234 smallContainert* r; 235 smallContainert *self = allocSmallContainer(&r); 236 237 // data (&r) not duplicated 238 r = duplicateO(self); 239 ck_assert_ptr_ne(r, null); 240 ck_assert_ptr_ne(r->data, null); 241 ck_assert_ptr_eq(r->data->data, null); 242 terminateO(r); 243 // class duplicate function 244 r = setClassDataDuplicateO(self, dataDuplicateSmallContainer); 245 ck_assert_ptr_ne(r, null); 246 r = duplicateO(self); 247 setClassDataDuplicateO(self, null); 248 ck_assert_ptr_ne(r, null); 249 ck_assert_ptr_ne(r->data, null); 250 ck_assert_ptr_eq(r->data->data, &r); 251 terminateO(r); 252 terminateO(self); 253 254 } 255 256 257 void setObjectDataDuplicateSmallContainerT(void) { 258 259 smallContainert* r; 260 smallContainert *self = allocSmallContainer(&r); 261 262 // data (&r) not duplicated 263 r = duplicateO(self); 264 ck_assert_ptr_ne(r, null); 265 ck_assert_ptr_ne(r->data, null); 266 ck_assert_ptr_eq(r->data->data, null); 267 terminateO(r); 268 // object duplicate function 269 r = setObjectDataDuplicateO(self, dataDuplicateSmallContainer); 270 ck_assert_ptr_ne(r, null); 271 r = duplicateO(self); 272 setObjectDataDuplicateO(self, null); 273 ck_assert_ptr_ne(r, null); 274 ck_assert_ptr_ne(r->data, null); 275 ck_assert_ptr_eq(r->data->data, &r); 276 terminateO(r); 277 terminateO(self); 278 279 } 280 281 282 void smashSmallContainerT(void) { 283 284 smallContainert *self = allocSmallContainer(null); 285 286 smashO(self); 287 self = allocSmallContainer(null); 288 freeO(self); 289 smashO(self); 290 ck_assert_ptr_eq(self, null); 291 292 } 293 294 295 void getSmallContainerT(void) { 296 297 void* r; 298 smallContainert *self = allocSmallContainer(&r); 299 300 r = getValO(self); 301 ck_assert_ptr_eq(r, &r); 302 // empty smallContainer 303 freeO(self); 304 r = getValO(self); 305 ck_assert_ptr_eq(r, null); 306 terminateO(self); 307 308 } 309 310 311 void setSmallContainerT(void) { 312 313 smallContainert* r; 314 smallContainert *self = allocSmallContainer(null); 315 316 r = setValO(self, &r); 317 ck_assert_ptr_ne(r, null); 318 void *r2 = getValO(self); 319 ck_assert_ptr_eq(r2, &r); 320 terminateO(self); 321 322 } 323 324 325 void duplicateSmallContainerGT(void) { 326 327 smallContainert* r; 328 smallContainert *self = allocSmallContainer(null); 329 330 r = duplicateSmallContainerG(self); 331 ck_assert_ptr_ne(r, null); 332 ck_assert_ptr_ne(r->data, null); 333 ck_assert_ptr_eq(r->data->data, null); 334 terminateO(r); 335 terminateO(self); 336 337 } 338 339 340 void freeSmallContainerGT(void) { 341 342 smallContainert *self = allocSmallContainer(null); 343 344 freeSmallContainerG(self); 345 ck_assert_ptr_eq(self->data, null); 346 terminateO(self); 347 348 } 349 350 351 void getSmallContainerGT(void) { 352 353 void* r; 354 smallContainert *self = allocSmallContainer(&r); 355 356 r = getSmallContainerG(self, null, 0); 357 ck_assert_ptr_eq(r, &r); 358 terminateO(self); 359 360 } 361 362 363 void setSmallContainerGT(void) { 364 365 smallContainert* r; 366 smallContainert *self = allocSmallContainer(null); 367 368 r = setSmallContainerG(self, &r); 369 ck_assert_ptr_ne(r, null); 370 void *r2 = getValO(self); 371 ck_assert_ptr_eq(r2, &r); 372 terminateO(self); 373 374 } 375 376 377 378 379 380 381 int main(int n UNUSED, char**v UNUSED) { 382 // disable btrace to make the test run faster 383 btraceDisable(); 384 allocSmallContainerT(); 385 toStringSmallContainerT(); 386 duplicateSmallContainerT(); 387 setClassDataFreeSmallContainerT(); 388 setObjectDataFreeSmallContainerT(); 389 setClassDataToStringSmallContainerT(); 390 setObjectDataToStringSmallContainerT(); 391 setClassDataDuplicateSmallContainerT(); 392 setObjectDataDuplicateSmallContainerT(); 393 smashSmallContainerT(); 394 getSmallContainerT(); 395 setSmallContainerT(); 396 duplicateSmallContainerGT(); 397 freeSmallContainerGT(); 398 getSmallContainerGT(); 399 setSmallContainerGT(); 400 401 finalizeSmallDict(); 402 finalizeSmallArray(); 403 finalizeSmallJson(); 404 finalizeUndefined(); 405 finalizeSmallBytes(); 406 finalizeSmallBool(); 407 finalizeSmallContainer(); 408 finalizeSmallDouble(); 409 finalizeSmallInt(); 410 finalizeSmallString(); 411 }