1.1 --- a/test/test_list.c Sat Apr 09 16:37:43 2022 +0200
1.2 +++ b/test/test_list.c Sat Apr 09 18:02:53 2022 +0200
1.3 @@ -27,6 +27,7 @@
1.4 */
1.5
1.6 #include "cx/linked_list.h"
1.7 +#include "cx/utils.h"
1.8 #include "test_config.h"
1.9 #include "util_allocator.h"
1.10
1.11 @@ -52,11 +53,11 @@
1.12 const ptrdiff_t loc_next = offsetof(struct node, next);
1.13 const ptrdiff_t loc_data = offsetof(struct node, data);
1.14
1.15 -struct node *create_test_data(
1.16 +static struct node *create_nodes_test_data(
1.17 size_t n,
1.18 int const data[]
1.19 ) {
1.20 - if (n == 0) return NULL;
1.21 + CU_ASSERT_NOT_EQUAL_FATAL(n, 0)
1.22 struct node *begin = calloc(1, sizeof(struct node));
1.23 struct node *prev = begin;
1.24 if (data) begin->data = data[0];
1.25 @@ -69,7 +70,7 @@
1.26 return begin;
1.27 }
1.28
1.29 -void destroy_test_data(struct node *begin) {
1.30 +static void destroy_nodes_test_data(struct node *begin) {
1.31 struct node *node = begin;
1.32 while (node) {
1.33 struct node *next = node->next;
1.34 @@ -78,6 +79,12 @@
1.35 }
1.36 }
1.37
1.38 +static int *create_ints_test_data(size_t len) {
1.39 + int *data = malloc(sizeof(int) * len);
1.40 + cx_for_n (i, len) data[i] = rand(); // NOLINT(cert-msc50-cpp)
1.41 + return data;
1.42 +}
1.43 +
1.44 void test_linked_list_link_unlink(void) {
1.45
1.46 struct node nd(a), nd(b), nd(c);
1.47 @@ -129,7 +136,7 @@
1.48
1.49 void test_linked_list_find(void) {
1.50 int data[] = {2, 4, 6, 8};
1.51 - void *list = create_test_data(4, data);
1.52 + void *list = create_nodes_test_data(4, data);
1.53 int s;
1.54
1.55 s = 2;
1.56 @@ -157,9 +164,9 @@
1.57 int b[] = {2, 4, 6};
1.58 int c[] = {2, 4, 6, 9};
1.59
1.60 - void *la = create_test_data(4, a);
1.61 - void *lb = create_test_data(3, b);
1.62 - void *lc = create_test_data(4, c);
1.63 + void *la = create_nodes_test_data(4, a);
1.64 + void *lb = create_nodes_test_data(3, b);
1.65 + void *lc = create_nodes_test_data(4, c);
1.66
1.67 CU_ASSERT_TRUE(0 < cx_linked_list_compare(la, lb, loc_next, loc_data,
1.68 false, cmp_int)
1.69 @@ -177,9 +184,9 @@
1.70 false, cmp_int)
1.71 )
1.72
1.73 - destroy_test_data(la);
1.74 - destroy_test_data(lb);
1.75 - destroy_test_data(lc);
1.76 + destroy_nodes_test_data(la);
1.77 + destroy_nodes_test_data(lb);
1.78 + destroy_nodes_test_data(lc);
1.79 }
1.80
1.81 void test_linked_list_add(void) {
1.82 @@ -421,35 +428,35 @@
1.83 }
1.84
1.85 void test_linked_list_first(void) {
1.86 - struct node *begin = create_test_data(3, NULL);
1.87 + struct node *begin = create_nodes_test_data(3, NULL);
1.88 CU_ASSERT_PTR_EQUAL(cx_linked_list_first(begin, loc_prev), begin)
1.89 CU_ASSERT_PTR_EQUAL(cx_linked_list_first(begin->next, loc_prev), begin)
1.90 CU_ASSERT_PTR_EQUAL(cx_linked_list_first(begin->next->next, loc_prev), begin)
1.91 - destroy_test_data(begin);
1.92 + destroy_nodes_test_data(begin);
1.93 }
1.94
1.95 void test_linked_list_last(void) {
1.96 - struct node *begin = create_test_data(3, NULL);
1.97 + struct node *begin = create_nodes_test_data(3, NULL);
1.98 struct node *end = begin->next->next;
1.99 CU_ASSERT_PTR_EQUAL(cx_linked_list_last(begin, loc_next), end)
1.100 CU_ASSERT_PTR_EQUAL(cx_linked_list_last(begin->next, loc_next), end)
1.101 CU_ASSERT_PTR_EQUAL(cx_linked_list_last(begin->next->next, loc_next), end)
1.102 - destroy_test_data(begin);
1.103 + destroy_nodes_test_data(begin);
1.104 }
1.105
1.106 void test_linked_list_prev(void) {
1.107 - struct node *begin = create_test_data(3, NULL);
1.108 + struct node *begin = create_nodes_test_data(3, NULL);
1.109 CU_ASSERT_PTR_NULL(cx_linked_list_prev(begin, loc_next, begin))
1.110 CU_ASSERT_PTR_EQUAL(cx_linked_list_prev(begin, loc_next, begin->next), begin)
1.111 CU_ASSERT_PTR_EQUAL(cx_linked_list_prev(begin, loc_next, begin->next->next), begin->next)
1.112 - destroy_test_data(begin);
1.113 + destroy_nodes_test_data(begin);
1.114 }
1.115
1.116 void test_linked_list_remove(void) {
1.117 void *begin, *end;
1.118
1.119 int data[] = {2, 4, 6};
1.120 - begin = create_test_data(3, data);
1.121 + begin = create_nodes_test_data(3, data);
1.122 struct node *first = begin;
1.123 struct node *second = first->next;
1.124 struct node *third = second->next;
1.125 @@ -483,13 +490,13 @@
1.126
1.127 CU_ASSERT_PTR_EQUAL(cx_linked_list_size(NULL, loc_next), 0)
1.128
1.129 - list = create_test_data(5, NULL);
1.130 + list = create_nodes_test_data(5, NULL);
1.131 CU_ASSERT_EQUAL(cx_linked_list_size(list, loc_next), 5)
1.132 - destroy_test_data(list);
1.133 + destroy_nodes_test_data(list);
1.134
1.135 - list = create_test_data(13, NULL);
1.136 + list = create_nodes_test_data(13, NULL);
1.137 CU_ASSERT_EQUAL(cx_linked_list_size(list, loc_next), 13)
1.138 - destroy_test_data(list);
1.139 + destroy_nodes_test_data(list);
1.140 }
1.141
1.142 void test_linked_list_sort(void) {
1.143 @@ -510,7 +517,7 @@
1.144 4016, 4085, 4121, 4254, 4319, 4366, 4459, 4514, 4681
1.145 };
1.146
1.147 - void *begin = create_test_data(100, scrambled);
1.148 + void *begin = create_nodes_test_data(100, scrambled);
1.149 void *end = cx_linked_list_last(begin, loc_next);
1.150
1.151 cx_linked_list_sort(&begin, &end, loc_prev, loc_next, loc_data,
1.152 @@ -520,7 +527,7 @@
1.153 struct node *check_last = NULL;
1.154 CU_ASSERT_PTR_NULL(check->prev)
1.155 CU_ASSERT_EQUAL(check->data, expected[0])
1.156 - for (int i = 0; i < 100; i++) {
1.157 + cx_for_n (i, 100) {
1.158 CU_ASSERT_EQUAL(check->data, expected[i])
1.159 CU_ASSERT_PTR_EQUAL(check->prev, check_last)
1.160 if (i < 99) {
1.161 @@ -532,7 +539,7 @@
1.162 CU_ASSERT_PTR_NULL(check)
1.163 CU_ASSERT_PTR_EQUAL(end, check_last)
1.164
1.165 - destroy_test_data(begin);
1.166 + destroy_nodes_test_data(begin);
1.167 }
1.168
1.169 void test_linked_list_reverse(void) {
1.170 @@ -541,8 +548,8 @@
1.171 int data[] = {2, 4, 6, 8};
1.172 int reversed[] = {8, 6, 4, 2};
1.173
1.174 - void *list = create_test_data(4, data);
1.175 - void *expected = create_test_data(4, reversed);
1.176 + void *list = create_nodes_test_data(4, data);
1.177 + void *expected = create_nodes_test_data(4, reversed);
1.178
1.179 begin = list;
1.180 end = cx_linked_list_last(list, loc_next);
1.181 @@ -553,8 +560,8 @@
1.182 CU_ASSERT_TRUE(0 == cx_linked_list_compare(begin, expected, loc_next, loc_data,
1.183 0, cmp_int))
1.184
1.185 - destroy_test_data(begin);
1.186 - destroy_test_data(expected);
1.187 + destroy_nodes_test_data(begin);
1.188 + destroy_nodes_test_data(expected);
1.189 }
1.190
1.191 static void verify_linked_list_create(CxList *list) {
1.192 @@ -582,7 +589,7 @@
1.193 int data[] = {2, 4, 5, 7, 10, 15};
1.194
1.195 CxList *expected = cxLinkedListCreate(cxTestingAllocator, cmp_int, sizeof(int));
1.196 - for (int i = 0; i < 5; i++) cxListAdd(expected, &data[i]);
1.197 + cx_for_n (i, 5) cxListAdd(expected, &data[i]);
1.198
1.199 CxList *list = cxLinkedListFromArray(cxTestingAllocator, cmp_int, sizeof(int), 5, data);
1.200
1.201 @@ -598,25 +605,15 @@
1.202 size_t len,
1.203 bool write_through
1.204 ) {
1.205 - for (size_t i = 0; i < len; i++) {
1.206 - CU_ASSERT_EQUAL(cxListAdd(list, &data[i]), 0)
1.207 - }
1.208 + cx_for_n (i, len) CU_ASSERT_EQUAL(cxListAdd(list, &data[i]), 0)
1.209 CU_ASSERT_EQUAL(list->size, len)
1.210 CU_ASSERT_TRUE(list->capacity >= list->size)
1.211 - for (size_t i = 0; i < len; i++) {
1.212 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, i), data[i])
1.213 - }
1.214 - for (size_t i = 0; i < len; i++) {
1.215 - ++data[i];
1.216 - }
1.217 + cx_for_n (i, len) CU_ASSERT_EQUAL(*(int *) cxListAt(list, i), data[i])
1.218 + cx_for_n (i, len) ++data[i];
1.219 if (write_through) {
1.220 - for (size_t i = 0; i < len; i++) {
1.221 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, i), data[i])
1.222 - }
1.223 + cx_for_n (i, len) CU_ASSERT_EQUAL(*(int *) cxListAt(list, i), data[i])
1.224 } else {
1.225 - for (size_t i = 0; i < len; i++) {
1.226 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, i), data[i] - 1)
1.227 - }
1.228 + cx_for_n (i, len) CU_ASSERT_EQUAL(*(int *) cxListAt(list, i), data[i] - 1)
1.229 }
1.230 cxListDestroy(list);
1.231 }
1.232 @@ -629,42 +626,11 @@
1.233
1.234 void test_hl_ptr_linked_list_add(void) {
1.235 CxList *list = cxPointerLinkedListCreate(cxTestingAllocator, cmp_int);
1.236 - int data[] = {5, 47, 13, 9, 18, 1, 42};
1.237 + int data[] = {5, 47, 84, 13, 9, 18, 90, 1, 42};
1.238 verify_hl_linked_list_add(list, data, sizeof(data) / sizeof(int), true);
1.239 }
1.240
1.241 -void test_hl_linked_list_insert(void) {
1.242 - int data;
1.243 - CxList *list = cxLinkedListCreate(cxTestingAllocator, cmp_int, sizeof(int));
1.244 -
1.245 - data = 5;
1.246 - CU_ASSERT_NOT_EQUAL(cxListInsert(list, 1, &data), 0)
1.247 - CU_ASSERT_EQUAL(list->size, 0)
1.248 - CU_ASSERT_EQUAL(cxListInsert(list, 0, &data), 0)
1.249 - CU_ASSERT_EQUAL(list->size, 1)
1.250 - data = 47;
1.251 - CU_ASSERT_EQUAL(cxListInsert(list, 0, &data), 0)
1.252 - CU_ASSERT_EQUAL(list->size, 2)
1.253 - data = 13;
1.254 - CU_ASSERT_EQUAL(cxListInsert(list, 1, &data), 0)
1.255 - CU_ASSERT_EQUAL(list->size, 3)
1.256 - data = 42;
1.257 - CU_ASSERT_EQUAL(cxListInsert(list, 3, &data), 0)
1.258 -
1.259 - CU_ASSERT_EQUAL(list->size, 4)
1.260 - CU_ASSERT_TRUE(list->capacity >= list->size)
1.261 -
1.262 - int exp[] = {47, 13, 5, 42};
1.263 - CxList *expected = cxLinkedListFromArray(cxTestingAllocator, cmp_int, sizeof(int), 4, exp);
1.264 - CU_ASSERT_TRUE(0 == cxListCompare(list, expected))
1.265 -
1.266 - cxListDestroy(list);
1.267 - cxListDestroy(expected);
1.268 -}
1.269 -
1.270 -void test_hl_ptr_linked_list_insert(void) {
1.271 - CxList *list = cxPointerLinkedListCreate(cxTestingAllocator, cmp_int);
1.272 -
1.273 +static void verify_hl_linked_list_insert(CxList *list) {
1.274 int a = 5, b = 47, c = 13, d = 42;
1.275
1.276 CU_ASSERT_NOT_EQUAL(cxListInsert(list, 1, &a), 0)
1.277 @@ -688,11 +654,15 @@
1.278 cxListDestroy(list);
1.279 }
1.280
1.281 -void test_hl_linked_list_remove(void) {
1.282 - int data[] = {5, 47, 42, 13};
1.283 - CxList *list = cxLinkedListFromArray(cxTestingAllocator, cmp_int,
1.284 - sizeof(int), 4, data);
1.285 +void test_hl_linked_list_insert(void) {
1.286 + verify_hl_linked_list_insert(cxLinkedListCreate(cxTestingAllocator, cmp_int, sizeof(int)));
1.287 +}
1.288
1.289 +void test_hl_ptr_linked_list_insert(void) {
1.290 + verify_hl_linked_list_insert(cxPointerLinkedListCreate(cxTestingAllocator, cmp_int));
1.291 +}
1.292 +
1.293 +static void verify_hl_linked_list_remove(CxList *list) {
1.294 CU_ASSERT_EQUAL(list->size, 4)
1.295 CU_ASSERT_TRUE(list->capacity >= list->size)
1.296
1.297 @@ -725,187 +695,131 @@
1.298 cxListDestroy(list);
1.299 }
1.300
1.301 +void test_hl_linked_list_remove(void) {
1.302 + int data[] = {5, 47, 42, 13};
1.303 + CxList *list = cxLinkedListFromArray(cxTestingAllocator, cmp_int,
1.304 + sizeof(int), 4, data);
1.305 + verify_hl_linked_list_remove(list);
1.306 +}
1.307 +
1.308 void test_hl_ptr_linked_list_remove(void) {
1.309 int a = 5, b = 47, c = 42, d = 13;
1.310 CxList *list = cxPointerLinkedListCreate(cxTestingAllocator, cmp_int);
1.311 -
1.312 cxListAdd(list, &a);
1.313 cxListAdd(list, &b);
1.314 cxListAdd(list, &c);
1.315 cxListAdd(list, &d);
1.316 + verify_hl_linked_list_remove(list);
1.317 +}
1.318
1.319 - CU_ASSERT_EQUAL(list->size, 4)
1.320 - CU_ASSERT_TRUE(list->capacity >= list->size)
1.321 -
1.322 - CU_ASSERT_NOT_EQUAL(cxListRemove(list, 4), 0)
1.323 -
1.324 - CU_ASSERT_EQUAL(cxListRemove(list, 2), 0)
1.325 - CU_ASSERT_EQUAL(list->size, 3)
1.326 - CU_ASSERT_TRUE(list->capacity >= list->size)
1.327 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 5)
1.328 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 1), 47)
1.329 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 2), 13)
1.330 -
1.331 - CU_ASSERT_EQUAL(cxListRemove(list, 0), 0)
1.332 - CU_ASSERT_EQUAL(list->size, 2)
1.333 - CU_ASSERT_TRUE(list->capacity >= list->size)
1.334 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 47)
1.335 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 1), 13)
1.336 -
1.337 - CU_ASSERT_EQUAL(cxListRemove(list, 1), 0)
1.338 - CU_ASSERT_EQUAL(list->size, 1)
1.339 - CU_ASSERT_TRUE(list->capacity >= list->size)
1.340 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 47)
1.341 -
1.342 - CU_ASSERT_EQUAL(cxListRemove(list, 0), 0)
1.343 - CU_ASSERT_EQUAL(list->size, 0)
1.344 - CU_ASSERT_TRUE(list->capacity >= list->size)
1.345 -
1.346 - CU_ASSERT_NOT_EQUAL(cxListRemove(list, 0), 0)
1.347 -
1.348 +static void verify_hl_linked_list_at(
1.349 + CxList *list,
1.350 + size_t len,
1.351 + int *data
1.352 +) {
1.353 + CU_ASSERT_EQUAL(list->size, len)
1.354 + cx_for_n (i, len) CU_ASSERT_EQUAL(*(int *) cxListAt(list, i), data[i])
1.355 + CU_ASSERT_PTR_NULL(cxListAt(list, len))
1.356 + free(data);
1.357 cxListDestroy(list);
1.358 }
1.359
1.360 void test_hl_linked_list_at(void) {
1.361 - int data[] = {5, 47, 13};
1.362 + size_t len = 100;
1.363 + int *data = create_ints_test_data(len);
1.364 CxList *list = cxLinkedListFromArray(cxTestingAllocator, cmp_int,
1.365 - sizeof(int), 3, data);
1.366 -
1.367 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 5)
1.368 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 1), 47)
1.369 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 2), 13)
1.370 - CU_ASSERT_PTR_NULL(cxListAt(list, 3))
1.371 -
1.372 - cxListDestroy(list);
1.373 + sizeof(int), len, data);
1.374 + verify_hl_linked_list_at(list, len, data);
1.375 }
1.376
1.377 void test_hl_ptr_linked_list_at(void) {
1.378 + size_t len = 250;
1.379 + int *data = create_ints_test_data(len);
1.380 CxList *list = cxPointerLinkedListCreate(cxTestingAllocator, cmp_int);
1.381 + cx_for_n (i, len) cxListAdd(list, &data[i]);
1.382 + verify_hl_linked_list_at(list, len, data);
1.383 +}
1.384
1.385 - int a = 5, b = 47, c = 13;
1.386 - cxListAdd(list, &a);
1.387 - cxListAdd(list, &b);
1.388 - cxListAdd(list, &c);
1.389 -
1.390 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 5)
1.391 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 1), 47)
1.392 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 2), 13)
1.393 - CU_ASSERT_PTR_NULL(cxListAt(list, 3))
1.394 -
1.395 +static void verify_hl_linked_list_find(
1.396 + CxList *list,
1.397 + size_t len,
1.398 + int *data
1.399 +) {
1.400 + cx_for_n (attempt, 100) {
1.401 + size_t exp = rand() % len; // NOLINT(cert-msc50-cpp)
1.402 + int val = data[exp];
1.403 + cx_for_n (i, exp) {
1.404 + if (data[i] == val) {
1.405 + exp = i;
1.406 + break;
1.407 + }
1.408 + }
1.409 + CU_ASSERT_EQUAL(cxListFind(list, &val), exp)
1.410 + }
1.411 + free(data);
1.412 cxListDestroy(list);
1.413 }
1.414
1.415 void test_hl_linked_list_find(void) {
1.416 - int data[] = {5, 47, 13};
1.417 - CxList *list = cxLinkedListFromArray(cxTestingAllocator, cmp_int,
1.418 - sizeof(int), 3, data);
1.419 - CU_ASSERT_EQUAL(list->size, 3)
1.420 - CU_ASSERT_TRUE(list->capacity >= list->size)
1.421 -
1.422 - int criteria;
1.423 -
1.424 - criteria = 5;
1.425 - CU_ASSERT_EQUAL(cxListFind(list, &criteria), 0)
1.426 - criteria = 47;
1.427 - CU_ASSERT_EQUAL(cxListFind(list, &criteria), 1)
1.428 - criteria = 13;
1.429 - CU_ASSERT_EQUAL(cxListFind(list, &criteria), 2)
1.430 - criteria = 9000;
1.431 - CU_ASSERT_EQUAL(cxListFind(list, &criteria), 3)
1.432 - criteria = -5;
1.433 - CU_ASSERT_EQUAL(cxListFind(list, &criteria), 3)
1.434 -
1.435 - cxListDestroy(list);
1.436 + size_t len = 100;
1.437 + int *data = create_ints_test_data(len);
1.438 + CxList *list = cxLinkedListFromArray(cxTestingAllocator, cmp_int, sizeof(int), len, data);
1.439 + verify_hl_linked_list_find(list, len, data);
1.440 }
1.441
1.442 void test_hl_ptr_linked_list_find(void) {
1.443 - int a = 5, b = 47, c = 13, criteria;
1.444 + size_t len = 250;
1.445 + int *data = create_ints_test_data(len);
1.446 CxList *list = cxPointerLinkedListCreate(cxTestingAllocator, cmp_int);
1.447 + cx_for_n (i, len) cxListAdd(list, &data[i]);
1.448 + verify_hl_linked_list_find(list, len, data);
1.449 +}
1.450
1.451 - cxListAdd(list, &a);
1.452 - cxListAdd(list, &b);
1.453 - cxListAdd(list, &c);
1.454 +struct sort_test_data {
1.455 + size_t len;
1.456 + int *data;
1.457 + int *sorted;
1.458 +};
1.459
1.460 - CU_ASSERT_EQUAL(list->size, 3)
1.461 - CU_ASSERT_TRUE(list->capacity >= list->size)
1.462 +static struct sort_test_data create_sort_test_data(void) {
1.463 + size_t len = 1000;
1.464 + int *data = create_ints_test_data(len);
1.465 + int *sorted = malloc(sizeof(int) * len);
1.466 + memcpy(sorted, data, sizeof(int) * len);
1.467 + qsort(sorted, len, sizeof(int), cmp_int);
1.468 + struct sort_test_data s = {len, data, sorted};
1.469 + return s;
1.470 +}
1.471
1.472 - criteria = 5;
1.473 - CU_ASSERT_EQUAL(cxListFind(list, &criteria), 0)
1.474 - criteria = 47;
1.475 - CU_ASSERT_EQUAL(cxListFind(list, &criteria), 1)
1.476 - criteria = 13;
1.477 - CU_ASSERT_EQUAL(cxListFind(list, &criteria), 2)
1.478 - criteria = 9000;
1.479 - CU_ASSERT_EQUAL(cxListFind(list, &criteria), 3)
1.480 - criteria = -5;
1.481 - CU_ASSERT_EQUAL(cxListFind(list, &criteria), 3)
1.482 - b = -5;
1.483 - CU_ASSERT_EQUAL(cxListFind(list, &criteria), 1)
1.484 +static void free_sort_test_data(struct sort_test_data s) {
1.485 + free(s.data);
1.486 + free(s.sorted);
1.487 +}
1.488
1.489 +static void verify_hl_linked_list_sort(
1.490 + CxList *list,
1.491 + struct sort_test_data td
1.492 +) {
1.493 + cxListSort(list);
1.494 + cx_for_n (i, td.len) CU_ASSERT_EQUAL_FATAL(*(int *) cxListAt(list, i), td.sorted[i])
1.495 + free_sort_test_data(td);
1.496 cxListDestroy(list);
1.497 }
1.498
1.499 void test_hl_linked_list_sort(void) {
1.500 - int expected[] = {
1.501 - 14, 30, 151, 163, 227, 300, 315, 317, 363, 398, 417, 424, 438, 446, 508, 555, 605, 713, 716, 759, 761, 880,
1.502 - 894, 1034, 1077, 1191, 1231, 1264, 1297, 1409, 1423, 1511, 1544, 1659, 1686, 1707, 1734, 1771, 1874, 1894,
1.503 - 1976, 2079, 2124, 2130, 2135, 2266, 2338, 2358, 2430, 2500, 2540, 2542, 2546, 2711, 2733, 2754, 2764, 2797,
1.504 - 2888, 2900, 3020, 3053, 3109, 3244, 3275, 3302, 3362, 3363, 3364, 3441, 3515, 3539, 3579, 3655, 3675, 3677,
1.505 - 3718, 3724, 3757, 3866, 3896, 3906, 3941, 3984, 3994, 4016, 4085, 4121, 4254, 4319, 4366, 4459, 4514, 4681,
1.506 - 4785, 4791, 4801, 4859, 4903, 4973
1.507 - };
1.508 - int scrambled[] = {
1.509 - 759, 716, 880, 761, 2358, 2542, 2500, 2540, 2546, 2711, 2430, 1707, 1874, 1771, 1894, 1734, 1976, 2079,
1.510 - 2124, 2130, 2135, 2266, 2338, 2733, 2754, 2764, 2797, 3362, 3363, 3364, 3441, 3515, 3539, 3579, 3655, 2888,
1.511 - 2900, 3020, 3053, 3109, 3244, 3275, 3302, 438, 446, 508, 555, 605, 713, 14, 30, 151, 163, 227, 300,
1.512 - 894, 1034, 1077, 1191, 1231, 1264, 1297, 1409, 1423, 1511, 1544, 1659, 1686, 315, 317, 363, 398, 417, 424,
1.513 - 3675, 3677, 3718, 3724, 3757, 3866, 3896, 3906, 3941, 3984, 3994, 4785, 4791, 4801, 4859, 4903, 4973,
1.514 - 4016, 4085, 4121, 4254, 4319, 4366, 4459, 4514, 4681
1.515 - };
1.516 - CxList *list = cxLinkedListFromArray(cxTestingAllocator, cmp_int, sizeof(int), 100, scrambled);
1.517 - CxList *exp = cxLinkedListFromArray(cxTestingAllocator, cmp_int, sizeof(int), 100, expected);
1.518 -
1.519 - cxListSort(list);
1.520 - CU_ASSERT_TRUE(0 == cxListCompare(list, exp))
1.521 -
1.522 - cxListDestroy(list);
1.523 - cxListDestroy(exp);
1.524 + struct sort_test_data td = create_sort_test_data();
1.525 + CxList *list = cxLinkedListFromArray(cxTestingAllocator, cmp_int, sizeof(int), td.len, td.data);
1.526 + verify_hl_linked_list_sort(list, td);
1.527 }
1.528
1.529 void test_hl_ptr_linked_list_sort(void) {
1.530 - int expected[] = {
1.531 - 14, 30, 151, 163, 227, 300, 315, 317, 363, 398, 417, 424, 438, 446, 508, 555, 605, 713, 716, 759, 761, 880,
1.532 - 894, 1034, 1077, 1191, 1231, 1264, 1297, 1409, 1423, 1511, 1544, 1659, 1686, 1707, 1734, 1771, 1874, 1894,
1.533 - 1976, 2079, 2124, 2130, 2135, 2266, 2338, 2358, 2430, 2500, 2540, 2542, 2546, 2711, 2733, 2754, 2764, 2797,
1.534 - 2888, 2900, 3020, 3053, 3109, 3244, 3275, 3302, 3362, 3363, 3364, 3441, 3515, 3539, 3579, 3655, 3675, 3677,
1.535 - 3718, 3724, 3757, 3866, 3896, 3906, 3941, 3984, 3994, 4016, 4085, 4121, 4254, 4319, 4366, 4459, 4514, 4681,
1.536 - 4785, 4791, 4801, 4859, 4903, 4973
1.537 - };
1.538 - int scrambled[] = {
1.539 - 759, 716, 880, 761, 2358, 2542, 2500, 2540, 2546, 2711, 2430, 1707, 1874, 1771, 1894, 1734, 1976, 2079,
1.540 - 2124, 2130, 2135, 2266, 2338, 2733, 2754, 2764, 2797, 3362, 3363, 3364, 3441, 3515, 3539, 3579, 3655, 2888,
1.541 - 2900, 3020, 3053, 3109, 3244, 3275, 3302, 438, 446, 508, 555, 605, 713, 14, 30, 151, 163, 227, 300,
1.542 - 894, 1034, 1077, 1191, 1231, 1264, 1297, 1409, 1423, 1511, 1544, 1659, 1686, 315, 317, 363, 398, 417, 424,
1.543 - 3675, 3677, 3718, 3724, 3757, 3866, 3896, 3906, 3941, 3984, 3994, 4785, 4791, 4801, 4859, 4903, 4973,
1.544 - 4016, 4085, 4121, 4254, 4319, 4366, 4459, 4514, 4681
1.545 - };
1.546 -
1.547 + struct sort_test_data td = create_sort_test_data();
1.548 CxList *list = cxPointerLinkedListCreate(cxTestingAllocator, cmp_int);
1.549 -
1.550 - for (int i = 0; i < 100; i++) {
1.551 - cxListAdd(list, &scrambled[i]);
1.552 - }
1.553 -
1.554 - cxListSort(list);
1.555 -
1.556 - for (int i = 0; i < 100; i++) {
1.557 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, i), expected[i])
1.558 - }
1.559 -
1.560 - cxListDestroy(list);
1.561 + cx_for_n (i, td.len) cxListAdd(list, &td.data[i]);
1.562 + verify_hl_linked_list_sort(list, td);
1.563 }
1.564
1.565 -void test_hl_linked_list_iterator_impl(CxList *list) {
1.566 +void verify_hl_linked_list_iterator(CxList *list) {
1.567 int i = 0;
1.568 CxIterator iter = cxListBegin(list);
1.569 cx_foreach(int*, x, iter) {
1.570 @@ -916,111 +830,75 @@
1.571 }
1.572 CU_ASSERT_EQUAL(i, 10)
1.573 CU_ASSERT_EQUAL_FATAL(list->size, 5)
1.574 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 0), 0)
1.575 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 1), 2)
1.576 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 2), 4)
1.577 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 3), 6)
1.578 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, 4), 8)
1.579 + cx_for_n(j, 5) CU_ASSERT_EQUAL(*(int *) cxListAt(list, j), (int) j * 2)
1.580 cxListDestroy(list);
1.581 }
1.582
1.583 void test_hl_linked_list_iterator(void) {
1.584 CxList *list = cxLinkedListCreate(cxTestingAllocator, cmp_int, sizeof(int));
1.585 - for (int i = 0; i < 10; i++) {
1.586 - cxListAdd(list, &i);
1.587 - }
1.588 - test_hl_linked_list_iterator_impl(list);
1.589 + cx_for_n (i, 10) cxListAdd(list, &i);
1.590 + verify_hl_linked_list_iterator(list);
1.591 }
1.592
1.593 void test_hl_ptr_linked_list_iterator(void) {
1.594 CxList *list = cxPointerLinkedListCreate(cxTestingAllocator, cmp_int);
1.595 int data[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
1.596 - for (int i = 0; i < 10; i++) {
1.597 - cxListAdd(list, &data[i]);
1.598 - }
1.599 - test_hl_linked_list_iterator_impl(list);
1.600 + cx_for_n (i, 10) cxListAdd(list, &data[i]);
1.601 + verify_hl_linked_list_iterator(list);
1.602 }
1.603
1.604 -void test_hl_linked_list_insert_via_iterator(void) {
1.605 - CxList *list = cxLinkedListCreate(cxTestingAllocator, cmp_int, sizeof(int));
1.606 - for (int i = 0; i < 5; i++) {
1.607 - cxListAdd(list, &i);
1.608 - }
1.609 +static void verify_hl_linked_list_insert_via_iterator(
1.610 + CxList *list,
1.611 + int *testdata
1.612 +) {
1.613 CxIterator iter = cxListIterator(list, 2);
1.614 CU_ASSERT_EQUAL(iter.index, 2)
1.615 CU_ASSERT_EQUAL(*(int *) cxIteratorCurrent(&iter), 2)
1.616 + size_t i = 4;
1.617
1.618 - int data = 10;
1.619 - cxListInsertAfter(&iter, &data);
1.620 + ++i;
1.621 + cxListInsertAfter(&iter, &testdata[i]);
1.622 CU_ASSERT_EQUAL(iter.index, 2)
1.623 CU_ASSERT_EQUAL(*(int *) cxIteratorCurrent(&iter), 2)
1.624 - data = 20;
1.625 - cxListInsertBefore(&iter, &data);
1.626 + ++i;
1.627 + cxListInsertBefore(&iter, &testdata[i]);
1.628 CU_ASSERT_EQUAL(iter.index, 3)
1.629 CU_ASSERT_EQUAL(*(int *) cxIteratorCurrent(&iter), 2)
1.630
1.631 - data = 30;
1.632 iter = cxListBegin(list);
1.633 - cxListInsertBefore(&iter, &data);
1.634 + ++i;
1.635 + cxListInsertBefore(&iter, &testdata[i]);
1.636 CU_ASSERT_EQUAL(iter.index, 1)
1.637 CU_ASSERT_EQUAL(*(int *) cxIteratorCurrent(&iter), 0)
1.638 - data = 40;
1.639 iter = cxListIterator(list, list->size);
1.640 - cxListInsertBefore(&iter, &data);
1.641 + ++i;
1.642 + cxListInsertBefore(&iter, &testdata[i]);
1.643 CU_ASSERT_EQUAL(iter.index, 9)
1.644 CU_ASSERT_FALSE(cxIteratorValid(&iter))
1.645 - data = 50;
1.646 iter = cxListIterator(list, list->size);
1.647 - cxListInsertAfter(&iter, &data);
1.648 + ++i;
1.649 + cxListInsertAfter(&iter, &testdata[i]);
1.650 CU_ASSERT_EQUAL(iter.index, 10)
1.651 CU_ASSERT_FALSE(cxIteratorValid(&iter))
1.652
1.653 int expdata[] = {30, 0, 1, 20, 2, 10, 3, 4, 40, 50};
1.654 - CxList *expected = cxLinkedListFromArray(cxTestingAllocator,
1.655 - cmp_int, sizeof(int), 10, expdata);
1.656 + cx_for_n (j, 10) CU_ASSERT_EQUAL(*(int *) cxListAt(list, j), expdata[j])
1.657 + cxListDestroy(list);
1.658 +}
1.659
1.660 - CU_ASSERT_EQUAL(0, cxListCompare(list, expected))
1.661 - cxListDestroy(list);
1.662 - cxListDestroy(expected);
1.663 +void test_hl_linked_list_insert_via_iterator(void) {
1.664 + int testdata[] = {0, 1, 2, 3, 4, 10, 20, 30, 40, 50};
1.665 + // only add the first five elements, the remaining five will be inserted
1.666 + CxList *list = cxLinkedListFromArray(cxTestingAllocator, cmp_int, sizeof(int), 5, testdata);
1.667 + verify_hl_linked_list_insert_via_iterator(list, testdata);
1.668 }
1.669
1.670 void test_hl_ptr_linked_list_insert_via_iterator(void) {
1.671 int testdata[] = {0, 1, 2, 3, 4, 10, 20, 30, 40, 50};
1.672 CxList *list = cxPointerLinkedListCreate(cxTestingAllocator, cmp_int);
1.673 - int i;
1.674 - for (i = 0; i < 5; i++) {
1.675 - cxListAdd(list, &testdata[i]);
1.676 - }
1.677 - CxIterator iter = cxListIterator(list, 2);
1.678 - CU_ASSERT_EQUAL(iter.index, 2)
1.679 - CU_ASSERT_EQUAL(*(int *) cxIteratorCurrent(&iter), 2)
1.680 -
1.681 - cxListInsertAfter(&iter, &testdata[i++]);
1.682 - CU_ASSERT_EQUAL(iter.index, 2)
1.683 - CU_ASSERT_EQUAL(*(int *) cxIteratorCurrent(&iter), 2)
1.684 - cxListInsertBefore(&iter, &testdata[i++]);
1.685 - CU_ASSERT_EQUAL(iter.index, 3)
1.686 - CU_ASSERT_EQUAL(*(int *) cxIteratorCurrent(&iter), 2)
1.687 -
1.688 - iter = cxListBegin(list);
1.689 - cxListInsertBefore(&iter, &testdata[i++]);
1.690 - CU_ASSERT_EQUAL(iter.index, 1)
1.691 - CU_ASSERT_EQUAL(*(int *) cxIteratorCurrent(&iter), 0)
1.692 - iter = cxListIterator(list, list->size);
1.693 - cxListInsertBefore(&iter, &testdata[i++]);
1.694 - CU_ASSERT_EQUAL(iter.index, 9)
1.695 - CU_ASSERT_FALSE(cxIteratorValid(&iter))
1.696 - iter = cxListIterator(list, list->size);
1.697 - cxListInsertAfter(&iter, &testdata[i++]);
1.698 - CU_ASSERT_EQUAL(iter.index, 10)
1.699 - CU_ASSERT_FALSE(cxIteratorValid(&iter))
1.700 -
1.701 - int expdata[] = {30, 0, 1, 20, 2, 10, 3, 4, 40, 50};
1.702 - for (i = 0; i < 10; i++) {
1.703 - CU_ASSERT_EQUAL(*(int *) cxListAt(list, i), expdata[i])
1.704 - }
1.705 -
1.706 - cxListDestroy(list);
1.707 + // only add the first five elements, the remaining five will be inserted
1.708 + cx_for_n (i, 5) cxListAdd(list, &testdata[i]);
1.709 + verify_hl_linked_list_insert_via_iterator(list, testdata);
1.710 }
1.711
1.712 static void test_setup_allocator(void) {
