Mercurial > hg > ucx / file comparison

comparison: test/array_tests.c

test/array_tests.c

changeset 369
28a8ccc442b0
parent 366
41a7cef34c19
equal deleted inserted replaced
368:97c53f7ef5e4 369:28a8ccc442b0
210 UCX_TEST_END 210 UCX_TEST_END
211 211
212 ucx_array_free(array); 212 ucx_array_free(array);
213 } 213 }
214 214
215 UCX_TEST(test_ucx_array_append) {
216 UcxArray *array = ucx_array_new(16, sizeof(int));
217 int *elements;
218
219 ucx_array_append(array, 42);
220 UCX_TEST_BEGIN
221
222 elements = array->data;
223 UCX_TEST_ASSERT(elements[0] == 42, "failed");
224
225 ucx_array_append(array, 13);
226 ucx_array_append(array, 37);
227
228 elements = array->data;
229 UCX_TEST_ASSERT(array->size == 3, "incorrect size after append");
230 UCX_TEST_ASSERT(elements[1] == 13, "failed");
231 UCX_TEST_ASSERT(elements[2] == 37, "failed");
232 UCX_TEST_ASSERT(elements[0] == 42,
233 "append corrupted previously inserted data");
234
235 UCX_TEST_END
236
237 ucx_array_destroy(array);
238 }
239
240 UCX_TEST(test_ucx_array_append_struct) {
241 struct teststruct {
242 unsigned long long x;
243 unsigned long long y;
244 unsigned long long z;
245 };
246
247 UcxArray *array = ucx_array_new(16, sizeof(struct teststruct));
248 struct teststruct *elements;
249
250 struct teststruct data;
251 data.x = 13; data.y = 37; data.z = 47;
252
253 ucx_array_append(array, data);
254 UCX_TEST_BEGIN
255
256 elements = array->data;
257 UCX_TEST_ASSERT(elements[0].x == 13, "failed");
258 UCX_TEST_ASSERT(elements[0].y == 37, "failed");
259 UCX_TEST_ASSERT(elements[0].z == 47, "failed");
260
261 data.x = 0; data.y = 8; data.z = 15;
262 ucx_array_append(array, data);
263
264 elements = array->data;
265 UCX_TEST_ASSERT(array->size == 2, "incorrect size after append");
266 UCX_TEST_ASSERT(elements[1].x == 0, "failed");
267 UCX_TEST_ASSERT(elements[1].y == 8, "failed");
268 UCX_TEST_ASSERT(elements[1].z == 15, "failed");
269
270 UCX_TEST_ASSERT(elements[0].x == 13,
271 "append corrupted previously inserted data");
272 UCX_TEST_ASSERT(elements[0].y == 37,
273 "append corrupted previously inserted data");
274 UCX_TEST_ASSERT(elements[0].z == 47,
275 "append corrupted previously inserted data");
276
277 UCX_TEST_END
278
279 ucx_array_destroy(array);
280 }
281
282 UCX_TEST(test_ucx_array_prepend) {
283 int *elems;
284 UcxArray *array = ucx_array_new(16, sizeof(int));
285
286 ucx_array_prepend(array, 42);
287 UCX_TEST_BEGIN
288
289 elems = array->data;
290 UCX_TEST_ASSERT(elems[0] == 42, "failed");
291
292 ucx_array_prepend(array, 37);
293 ucx_array_prepend(array, 13);
294
295 elems = array->data;
296 UCX_TEST_ASSERT(array->size == 3, "incorrect size after prepend");
297 UCX_TEST_ASSERT(elems[0] == 13, "failed");
298 UCX_TEST_ASSERT(elems[1] == 37, "failed");
299 UCX_TEST_ASSERT(elems[2] == 42,
300 "prepend corrupted previously inserted data");
301
302 UCX_TEST_END
303
304 ucx_array_free(array);
305 }
306
307 UCX_TEST(test_ucx_array_set) {
308 int *elems;
309 UcxArray *array = ucx_array_new(16, sizeof(int));
310
311 UCX_TEST_BEGIN
312
313 ucx_array_set(array, 7, 42);
314
315 elems = array->data;
316 UCX_TEST_ASSERT(elems[7] == 42, "failed");
317 UCX_TEST_ASSERT(array->size == 8, "array not resized on set");
318 UCX_TEST_ASSERT(array->capacity == 16, "capacity changed unnecessarily");
319
320 ucx_array_set(array, 27, 13);
321 ucx_array_set(array, 28, 37);
322
323 elems = array->data;
324 UCX_TEST_ASSERT(elems[27] == 13, "failed");
325 UCX_TEST_ASSERT(elems[28] == 37, "failed");
326 UCX_TEST_ASSERT(array->size == 29, "array not resized on set");
327 UCX_TEST_ASSERT(array->capacity == 32, "capacity not grown");
328
329 UCX_TEST_END
330
331 ucx_array_free(array);
332 }
333 215
334 UCX_TEST(test_ucx_array_equals) { 216 UCX_TEST(test_ucx_array_equals) {
335 UcxArray *a1 = ucx_array_new(16, sizeof(int32_t)); 217 UcxArray *a1 = ucx_array_new(16, sizeof(int32_t));
336 UcxArray *a2 = ucx_array_new(16, sizeof(int32_t)); 218 UcxArray *a2 = ucx_array_new(16, sizeof(int32_t));
337 UcxArray *a3 = ucx_array_new(16, sizeof(int64_t)); 219 UcxArray *a3 = ucx_array_new(16, sizeof(int64_t));
641 ucx_array_free(expectedrev); 523 ucx_array_free(expectedrev);
642 ucx_array_free(expected); 524 ucx_array_free(expected);
643 ucx_array_free(array); 525 ucx_array_free(array);
644 } 526 }
645 527
646 UCX_TEST(test_ucx_array_autogrow) {
647 int *elems;
648 UcxArray *array = ucx_array_new(4, sizeof(int));
649 array->size = 3;
650 elems = array->data;
651 elems[0] = 47;
652 elems[1] = 11;
653 int x = 5;
654
655 UCX_TEST_BEGIN
656
657 void* oldptr = array->data;
658
659 ucx_array_append(array, 5);
660 UCX_TEST_ASSERT(array->capacity == 4 && array->data == oldptr,
661 "array should not grow too early");
662 ucx_array_append(array, 5);
663 elems = array->data;
664 UCX_TEST_ASSERT(array->capacity == 8, "array did not grow");
665 UCX_TEST_ASSERT(array->size == 5, "incorrect size after grow");
666 UCX_TEST_ASSERT(elems[3] == 5 && elems[4] == 5, "corrupt data");
667
668 UCX_TEST_END
669 ucx_array_free(array);
670 }
671
672 UCX_TEST(test_ucx_array_shrink) { 528 UCX_TEST(test_ucx_array_shrink) {
673 UcxArray *array = ucx_array_new(16, sizeof(int)); 529 UcxArray *array = ucx_array_new(16, sizeof(int));
674 array->size = 4; 530 array->size = 4;
675 531
676 UCX_TEST_BEGIN 532 UCX_TEST_BEGIN
711 567
712 UCX_TEST_END 568 UCX_TEST_END
713 ucx_array_free(array); 569 ucx_array_free(array);
714 } 570 }
715 571
572 UCX_TEST(test_ucx_array_grow) {
573 UcxArray *array = ucx_array_new(16, sizeof(int));
574 array->size = 12;
575
576 UCX_TEST_BEGIN
577
578 UCX_TEST_ASSERT(!ucx_array_grow(array, 4), "failed");
579 UCX_TEST_ASSERT(array->capacity == 16, "shall be noop if contents fit");
580 /* subsequent calls shall also be noops */
581 UCX_TEST_ASSERT(!ucx_array_grow(array, 4), "failed");
582 UCX_TEST_ASSERT(array->capacity == 16, "shall be noop if contents fit");
583
584 UCX_TEST_ASSERT(!ucx_array_grow(array, 6), "failed");
585 UCX_TEST_ASSERT(array->capacity == 18, "incorrect capacity after grow");
586
587 UCX_TEST_END
588 ucx_array_free(array);
589 }
590
716 UCX_TEST(test_ucx_array_util_set) { 591 UCX_TEST(test_ucx_array_util_set) {
717 size_t capacity = 16; 592 size_t capacity = 16;
718 int* array = malloc(sizeof(int)*capacity); 593 int* array = malloc(sizeof(int)*capacity);
719 594 int x;
720 UCX_TEST_BEGIN 595
721 596 UCX_TEST_BEGIN
722 UCX_ARRAY_UTIL_SET(&array, &capacity, 7, 42); 597
598 x = 42;
599 ucx_array_util_set(&array, &capacity, sizeof(int), 7, &x);
723 600
724 UCX_TEST_ASSERT(array[7] == 42, "failed"); 601 UCX_TEST_ASSERT(array[7] == 42, "failed");
725 UCX_TEST_ASSERT(capacity == 16, "capacity changed unnecessarily"); 602 UCX_TEST_ASSERT(capacity == 16, "capacity changed unnecessarily");
726 603
727 UCX_ARRAY_UTIL_SET(&array, &capacity, 37, 13); 604 x = 13;
728 UCX_ARRAY_UTIL_SET(&array, &capacity, 38, 37); 605 ucx_array_util_set(&array, &capacity, sizeof(int), 37, &x);
606 x = 37;
607 ucx_array_util_set(&array, &capacity, sizeof(int), 38, &x);
729 608
730 UCX_TEST_ASSERT(array[37] == 13, "failed"); 609 UCX_TEST_ASSERT(array[37] == 13, "failed");
731 UCX_TEST_ASSERT(array[38] == 37, "failed"); 610 UCX_TEST_ASSERT(array[38] == 37, "failed");
732 UCX_TEST_ASSERT(capacity == 64, "capacity not grown"); 611 UCX_TEST_ASSERT(capacity == 64, "capacity not grown");
733 612
734 UCX_TEST_END 613 UCX_TEST_END
735 614
736 free(array); 615 free(array);
737 } 616 }
617
618
619 UCX_TEST(test_ucx_array_util_setptr) {
620 size_t capacity = 16;
621 double** array = malloc(sizeof(double*)*capacity);
622 double x, y, z;
623
624 UCX_TEST_BEGIN
625
626 ucx_array_util_setptr(&array, &capacity, 7, &x);
627
628 UCX_TEST_ASSERT(array[7] == &x, "failed");
629 UCX_TEST_ASSERT(capacity == 16, "capacity changed unnecessarily");
630
631 ucx_array_util_setptr(&array, &capacity, 37, &y);
632 ucx_array_util_setptr(&array, &capacity, 38, &z);
633
634 UCX_TEST_ASSERT(array[37] == &y, "failed");
635 UCX_TEST_ASSERT(array[38] == &z, "failed");
636 UCX_TEST_ASSERT(capacity == 64, "capacity not grown");
637
638 UCX_TEST_END
639
640 free(array);
641 }
642

Mercurial Repository: ucx

mercurial