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