1.1 --- a/test/test_list.c Mon Dec 27 17:16:32 2021 +0100
1.2 +++ b/test/test_list.c Tue Dec 28 14:16:04 2021 +0100
1.3 @@ -30,20 +30,55 @@
1.4 #include "test_config.h"
1.5 #include "util_allocator.h"
1.6
1.7 -int cmp_int(int const *l, int const *r) {
1.8 +int cmp_int(
1.9 + int const *l,
1.10 + int const *r
1.11 +) {
1.12 int left = *l, right = *r;
1.13 return left == right ? 0 : (left < right ? -1 : 1);
1.14 }
1.15
1.16 +struct node {
1.17 + struct node *next;
1.18 + struct node *prev;
1.19 + int data;
1.20 +};
1.21 +
1.22 +#define nd(name) name = {0}
1.23 +
1.24 +const ptrdiff_t loc_prev = offsetof(struct node, prev);
1.25 +const ptrdiff_t loc_next = offsetof(struct node, next);
1.26 +const ptrdiff_t loc_data = offsetof(struct node, data);
1.27 +
1.28 +struct node *create_test_data(
1.29 + size_t n,
1.30 + const int data[]
1.31 +) {
1.32 + if (n == 0) return NULL;
1.33 + struct node *begin = calloc(1, sizeof(struct node));
1.34 + struct node *prev = begin;
1.35 + if (data) begin->data = data[0];
1.36 + for (size_t i = 1; i < n; i++) {
1.37 + struct node *node = calloc(1, sizeof(struct node));
1.38 + if (data) node->data = data[i];
1.39 + cx_linked_list_link(prev, node, loc_prev, loc_next);
1.40 + prev = node;
1.41 + }
1.42 + return begin;
1.43 +}
1.44 +
1.45 +void destroy_test_data(struct node *begin) {
1.46 + struct node *node = begin;
1.47 + while (node) {
1.48 + struct node *next = node->next;
1.49 + free(node);
1.50 + node = next;
1.51 + }
1.52 +}
1.53 +
1.54 void test_linked_list_link_unlink(void) {
1.55 - struct node {
1.56 - void *next;
1.57 - void *prev;
1.58 - };
1.59 - const ptrdiff_t loc_prev = offsetof(struct node, prev);
1.60 - const ptrdiff_t loc_next = offsetof(struct node, next);
1.61
1.62 - struct node a = {NULL, NULL}, b = {NULL, NULL};
1.63 + struct node nd(a), nd(b), nd(c);
1.64
1.65 cx_linked_list_link(&a, &b, loc_prev, loc_next);
1.66 CU_ASSERT_PTR_NULL(a.prev)
1.67 @@ -57,7 +92,6 @@
1.68 CU_ASSERT_PTR_NULL(b.prev)
1.69 CU_ASSERT_PTR_NULL(b.next)
1.70
1.71 - struct node c = {NULL, NULL};
1.72 cx_linked_list_link(&b, &c, loc_prev, loc_next);
1.73 cx_linked_list_link(&a, &b, loc_prev, loc_next);
1.74 cx_linked_list_unlink(&b, &c, loc_prev, loc_next);
1.75 @@ -70,22 +104,10 @@
1.76 }
1.77
1.78 void test_linked_list_at(void) {
1.79 - struct node {
1.80 - void *next;
1.81 - void *prev;
1.82 - };
1.83 - const ptrdiff_t loc_prev = offsetof(struct node, prev);
1.84 - const ptrdiff_t loc_next = offsetof(struct node, next);
1.85 -
1.86 - struct node a, b, c, d;
1.87 - a.prev = NULL;
1.88 - a.next = &b;
1.89 - b.prev = &a;
1.90 - b.next = &c;
1.91 - c.prev = &b;
1.92 - c.next = &d;
1.93 - d.prev = &c;
1.94 - d.next = NULL;
1.95 + struct node nd(a), nd(b), nd(c), nd(d);
1.96 + cx_linked_list_link(&a, &b, loc_prev, loc_next);
1.97 + cx_linked_list_link(&b, &c, loc_prev, loc_next);
1.98 + cx_linked_list_link(&c, &d, loc_prev, loc_next);
1.99
1.100 CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&a, 0, loc_next, 0), &a)
1.101 CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&a, 0, loc_next, 1), &b)
1.102 @@ -103,21 +125,43 @@
1.103 CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&d, 3, loc_prev, 1), &b)
1.104 }
1.105
1.106 +void test_linked_list_compare(void) {
1.107 + int a[] = {2, 4, 6, 8};
1.108 + int b[] = {2, 4, 6};
1.109 + int c[] = {2, 4, 6, 9};
1.110 +
1.111 + void *la = create_test_data(4, a);
1.112 + void *lb = create_test_data(3, b);
1.113 + void *lc = create_test_data(4, c);
1.114 +
1.115 + CU_ASSERT_TRUE(0 < cx_linked_list_compare(la, lb, loc_next, loc_data,
1.116 + 0, (CxListComparator) cmp_int)
1.117 + )
1.118 + CU_ASSERT_TRUE(0 > cx_linked_list_compare(lb, la, loc_next, loc_data,
1.119 + 0, (CxListComparator) cmp_int)
1.120 + )
1.121 + CU_ASSERT_TRUE(0 < cx_linked_list_compare(lc, la, loc_next, loc_data,
1.122 + 0, (CxListComparator) cmp_int)
1.123 + )
1.124 + CU_ASSERT_TRUE(0 > cx_linked_list_compare(la, lc, loc_next, loc_data,
1.125 + 0, (CxListComparator) cmp_int)
1.126 + )
1.127 + CU_ASSERT_TRUE(0 == cx_linked_list_compare(la, la, loc_next, loc_data,
1.128 + 0, (CxListComparator) cmp_int)
1.129 + )
1.130 +
1.131 + destroy_test_data(la);
1.132 + destroy_test_data(lb);
1.133 + destroy_test_data(lc);
1.134 +}
1.135 +
1.136 void test_linked_list_add(void) {
1.137 - struct node {
1.138 - void *prev;
1.139 - void *next;
1.140 - };
1.141 -
1.142 struct node nodes[4];
1.143 + void *begin, *end;
1.144
1.145 // test with begin, end / prev, next
1.146 memset(nodes, 0, 4 * sizeof(struct node));
1.147 - void *begin = NULL;
1.148 - void *end = NULL;
1.149 -
1.150 - ptrdiff_t loc_prev = offsetof(struct node, prev);
1.151 - ptrdiff_t loc_next = offsetof(struct node, next);
1.152 + begin = end = NULL;
1.153
1.154 cx_linked_list_add(&begin, &end, loc_prev, loc_next, &nodes[0]);
1.155 CU_ASSERT_PTR_EQUAL(begin, &nodes[0])
1.156 @@ -133,8 +177,7 @@
1.157
1.158 // test with begin only / prev, next
1.159 memset(nodes, 0, 4 * sizeof(struct node));
1.160 - begin = NULL;
1.161 - end = NULL;
1.162 + begin = end = NULL;
1.163
1.164 cx_linked_list_add(&begin, NULL, loc_prev, loc_next, &nodes[0]);
1.165 CU_ASSERT_PTR_EQUAL(begin, &nodes[0])
1.166 @@ -149,8 +192,7 @@
1.167
1.168 // test with end only / prev, next
1.169 memset(nodes, 0, 4 * sizeof(struct node));
1.170 - begin = NULL;
1.171 - end = NULL;
1.172 + begin = end = NULL;
1.173
1.174 cx_linked_list_add(NULL, &end, loc_prev, loc_next, &nodes[0]);
1.175 CU_ASSERT_PTR_EQUAL(end, &nodes[0])
1.176 @@ -166,8 +208,7 @@
1.177
1.178 // test with begin, end / next
1.179 memset(nodes, 0, 4 * sizeof(struct node));
1.180 - begin = NULL;
1.181 - end = NULL;
1.182 + begin = end = NULL;
1.183
1.184 cx_linked_list_add(&begin, &end, -1, loc_next, &nodes[0]);
1.185 CU_ASSERT_PTR_EQUAL(begin, &nodes[0])
1.186 @@ -179,20 +220,12 @@
1.187 }
1.188
1.189 void test_linked_list_prepend(void) {
1.190 - struct node {
1.191 - void *prev;
1.192 - void *next;
1.193 - };
1.194 -
1.195 struct node nodes[4];
1.196 + void *begin, *end;
1.197
1.198 // test with begin, end / prev, next
1.199 memset(nodes, 0, 4 * sizeof(struct node));
1.200 - void *begin = NULL;
1.201 - void *end = NULL;
1.202 -
1.203 - ptrdiff_t loc_prev = offsetof(struct node, prev);
1.204 - ptrdiff_t loc_next = offsetof(struct node, next);
1.205 + begin = end = NULL;
1.206
1.207 cx_linked_list_prepend(&begin, &end, loc_prev, loc_next, &nodes[0]);
1.208 CU_ASSERT_PTR_EQUAL(begin, &nodes[0])
1.209 @@ -208,8 +241,7 @@
1.210
1.211 // test with begin only / prev, next
1.212 memset(nodes, 0, 4 * sizeof(struct node));
1.213 - begin = NULL;
1.214 - end = NULL;
1.215 + begin = end = NULL;
1.216
1.217 cx_linked_list_prepend(&begin, NULL, loc_prev, loc_next, &nodes[0]);
1.218 CU_ASSERT_PTR_EQUAL(begin, &nodes[0])
1.219 @@ -225,8 +257,7 @@
1.220
1.221 // test with end only / prev, next
1.222 memset(nodes, 0, 4 * sizeof(struct node));
1.223 - begin = NULL;
1.224 - end = NULL;
1.225 + begin = end = NULL;
1.226
1.227 cx_linked_list_prepend(NULL, &end, loc_prev, loc_next, &nodes[0]);
1.228 CU_ASSERT_PTR_EQUAL(end, &nodes[0])
1.229 @@ -242,8 +273,7 @@
1.230
1.231 // test with begin, end / next
1.232 memset(nodes, 0, 4 * sizeof(struct node));
1.233 - begin = NULL;
1.234 - end = NULL;
1.235 + begin = end = NULL;
1.236
1.237 cx_linked_list_prepend(&begin, &end, -1, loc_next, &nodes[0]);
1.238 CU_ASSERT_PTR_EQUAL(begin, &nodes[0])
1.239 @@ -259,13 +289,6 @@
1.240 }
1.241
1.242 void test_linked_list_insert(void) {
1.243 - struct node {
1.244 - void *prev;
1.245 - void *next;
1.246 - };
1.247 - ptrdiff_t loc_prev = offsetof(struct node, prev);
1.248 - ptrdiff_t loc_next = offsetof(struct node, next);
1.249 -
1.250 struct node nodes[4];
1.251 void *begin, *end;
1.252
1.253 @@ -317,13 +340,6 @@
1.254 }
1.255
1.256 void test_linked_list_insert_chain(void) {
1.257 - struct node {
1.258 - void *prev;
1.259 - void *next;
1.260 - };
1.261 - ptrdiff_t loc_prev = offsetof(struct node, prev);
1.262 - ptrdiff_t loc_next = offsetof(struct node, next);
1.263 -
1.264 struct node nodes[5];
1.265 void *begin, *end;
1.266
1.267 @@ -378,138 +394,78 @@
1.268 }
1.269
1.270 void test_linked_list_first(void) {
1.271 - struct node {
1.272 - int data;
1.273 - void *prev;
1.274 - };
1.275 - ptrdiff_t loc = offsetof(struct node, prev);
1.276 -
1.277 - struct node first = {1, NULL};
1.278 - struct node second = {2, &first};
1.279 - struct node third = {3, &second};
1.280 -
1.281 - CU_ASSERT_PTR_EQUAL(cx_linked_list_first(&first, loc), &first)
1.282 - CU_ASSERT_PTR_EQUAL(cx_linked_list_first(&second, loc), &first)
1.283 - CU_ASSERT_PTR_EQUAL(cx_linked_list_first(&third, loc), &first)
1.284 + struct node *begin = create_test_data(3, NULL);
1.285 + CU_ASSERT_PTR_EQUAL(cx_linked_list_first(begin, loc_prev), begin)
1.286 + CU_ASSERT_PTR_EQUAL(cx_linked_list_first(begin->next, loc_prev), begin)
1.287 + CU_ASSERT_PTR_EQUAL(cx_linked_list_first(begin->next->next, loc_prev), begin)
1.288 + destroy_test_data(begin);
1.289 }
1.290
1.291 void test_linked_list_last(void) {
1.292 - struct node {
1.293 - int data;
1.294 - void *next;
1.295 - };
1.296 - ptrdiff_t loc = offsetof(struct node, next);
1.297 -
1.298 - struct node third = {3, NULL};
1.299 - struct node second = {2, &third};
1.300 - struct node first = {1, &second};
1.301 -
1.302 - CU_ASSERT_PTR_EQUAL(cx_linked_list_last(&first, loc), &third)
1.303 - CU_ASSERT_PTR_EQUAL(cx_linked_list_last(&second, loc), &third)
1.304 - CU_ASSERT_PTR_EQUAL(cx_linked_list_last(&third, loc), &third)
1.305 + struct node *begin = create_test_data(3, NULL);
1.306 + struct node *end = begin->next->next;
1.307 + CU_ASSERT_PTR_EQUAL(cx_linked_list_last(begin, loc_next), end)
1.308 + CU_ASSERT_PTR_EQUAL(cx_linked_list_last(begin->next, loc_next), end)
1.309 + CU_ASSERT_PTR_EQUAL(cx_linked_list_last(begin->next->next, loc_next), end)
1.310 + destroy_test_data(begin);
1.311 }
1.312
1.313 void test_linked_list_prev(void) {
1.314 - struct node {
1.315 - void *next;
1.316 - };
1.317 - ptrdiff_t loc = offsetof(struct node, next);
1.318 -
1.319 - struct node third = {NULL};
1.320 - struct node second = {&third};
1.321 - struct node first = {&second};
1.322 -
1.323 - CU_ASSERT_PTR_NULL(cx_linked_list_prev(&first, loc, &first))
1.324 - CU_ASSERT_PTR_EQUAL(cx_linked_list_prev(&first, loc, &second), &first)
1.325 - CU_ASSERT_PTR_EQUAL(cx_linked_list_prev(&first, loc, &third), &second)
1.326 + struct node *begin = create_test_data(3, NULL);
1.327 + CU_ASSERT_PTR_NULL(cx_linked_list_prev(begin, loc_next, begin))
1.328 + CU_ASSERT_PTR_EQUAL(cx_linked_list_prev(begin, loc_next, begin->next), begin)
1.329 + CU_ASSERT_PTR_EQUAL(cx_linked_list_prev(begin, loc_next, begin->next->next), begin->next)
1.330 + destroy_test_data(begin);
1.331 }
1.332
1.333 void test_linked_list_remove(void) {
1.334 - struct node {
1.335 - void *next;
1.336 - };
1.337 - struct dnode {
1.338 - void *next;
1.339 - void *prev;
1.340 - };
1.341 - ptrdiff_t loc = offsetof(struct node, next);
1.342 - ptrdiff_t ploc = offsetof(struct dnode, prev);
1.343 + void *begin, *end;
1.344
1.345 - void *begin;
1.346 - void *end;
1.347 + int data[] = {2, 4, 6};
1.348 + begin = create_test_data(3, data);
1.349 + struct node *first = begin;
1.350 + struct node *second = first->next;
1.351 + struct node *third = second->next;
1.352 + end = third;
1.353
1.354 - // single linked list
1.355 - struct node third = {NULL};
1.356 - struct node second = {&third};
1.357 - struct node first = {&second};
1.358 - begin = &first;
1.359 + cx_linked_list_remove(&begin, &end, loc_prev, loc_next, second);
1.360 + CU_ASSERT_PTR_EQUAL(begin, first)
1.361 + CU_ASSERT_PTR_EQUAL(end, third)
1.362 + CU_ASSERT_PTR_NULL(first->prev)
1.363 + CU_ASSERT_PTR_EQUAL(first->next, third)
1.364 + CU_ASSERT_PTR_EQUAL(third->prev, first)
1.365 + CU_ASSERT_PTR_NULL(third->next)
1.366
1.367 - cx_linked_list_remove(&begin, NULL, -1, loc, &second);
1.368 - CU_ASSERT_PTR_EQUAL(begin, &first)
1.369 - CU_ASSERT_PTR_EQUAL(first.next, &third)
1.370 - CU_ASSERT_PTR_NULL(third.next)
1.371 + cx_linked_list_remove(&begin, &end, loc_prev, loc_next, third);
1.372 + CU_ASSERT_PTR_EQUAL(begin, first)
1.373 + CU_ASSERT_PTR_EQUAL(end, first)
1.374 + CU_ASSERT_PTR_NULL(first->prev)
1.375 + CU_ASSERT_PTR_NULL(first->next)
1.376
1.377 - cx_linked_list_remove(&begin, NULL, -1, loc, &first);
1.378 - CU_ASSERT_PTR_EQUAL(begin, &third)
1.379 - CU_ASSERT_PTR_NULL(third.next)
1.380 -
1.381 - cx_linked_list_remove(&begin, NULL, -1, loc, &third);
1.382 - CU_ASSERT_PTR_NULL(begin)
1.383 -
1.384 - // doubly linked list
1.385 - struct dnode dthird = {NULL , NULL};
1.386 - struct dnode dsecond = {&dthird, NULL};
1.387 - struct dnode dfirst = {&dsecond, NULL};
1.388 - dthird.prev = &dsecond;
1.389 - dsecond.prev = &dfirst;
1.390 - begin = &dfirst;
1.391 - end = &dthird;
1.392 -
1.393 - cx_linked_list_remove(&begin, &end, ploc, loc, &dsecond);
1.394 - CU_ASSERT_PTR_EQUAL(begin, &dfirst)
1.395 - CU_ASSERT_PTR_EQUAL(end, &dthird)
1.396 - CU_ASSERT_PTR_NULL(dfirst.prev)
1.397 - CU_ASSERT_PTR_EQUAL(dfirst.next, &dthird)
1.398 - CU_ASSERT_PTR_EQUAL(dthird.prev, &dfirst)
1.399 - CU_ASSERT_PTR_NULL(dthird.next)
1.400 -
1.401 - cx_linked_list_remove(&begin, &end, ploc, loc, &dthird);
1.402 - CU_ASSERT_PTR_EQUAL(begin, &dfirst)
1.403 - CU_ASSERT_PTR_EQUAL(end, &dfirst)
1.404 - CU_ASSERT_PTR_NULL(dfirst.prev)
1.405 - CU_ASSERT_PTR_NULL(dfirst.next)
1.406 -
1.407 - cx_linked_list_remove(&begin, &end, ploc, loc, &dfirst);
1.408 + cx_linked_list_remove(&begin, &end, loc_prev, loc_next, first);
1.409 CU_ASSERT_PTR_NULL(begin)
1.410 CU_ASSERT_PTR_NULL(end)
1.411 +
1.412 + free(first);
1.413 + free(second);
1.414 + free(third);
1.415 }
1.416
1.417 void test_linked_list_size(void) {
1.418 - struct node {
1.419 - void *next;
1.420 - };
1.421 - ptrdiff_t loc = offsetof(struct node, next);
1.422 + struct node *list;
1.423
1.424 - struct node first = {NULL};
1.425 - struct node second = {NULL};
1.426 - struct node third = {NULL};
1.427 + CU_ASSERT_PTR_EQUAL(cx_linked_list_size(NULL, loc_next), 0)
1.428
1.429 - CU_ASSERT_PTR_EQUAL(cx_linked_list_size(NULL, loc), 0)
1.430 - CU_ASSERT_PTR_EQUAL(cx_linked_list_size(&first, loc), 1)
1.431 - first.next = &second;
1.432 - CU_ASSERT_PTR_EQUAL(cx_linked_list_size(&first, loc), 2)
1.433 - second.next = &third;
1.434 - CU_ASSERT_PTR_EQUAL(cx_linked_list_size(&first, loc), 3)
1.435 - CU_ASSERT_PTR_EQUAL(cx_linked_list_size(&second, loc), 2)
1.436 + list = create_test_data(5, NULL);
1.437 + CU_ASSERT_EQUAL(cx_linked_list_size(list, loc_next), 5)
1.438 + destroy_test_data(list);
1.439 +
1.440 + list = create_test_data(13, NULL);
1.441 + CU_ASSERT_EQUAL(cx_linked_list_size(list, loc_next), 13)
1.442 + destroy_test_data(list);
1.443 }
1.444
1.445 void test_linked_list_sort(void) {
1.446 - struct node {
1.447 - void *prev;
1.448 - void *next;
1.449 - int data;
1.450 - };
1.451 -
1.452 int expected[] = {
1.453 14, 30, 151, 163, 227, 300, 315, 317, 363, 398, 417, 424, 438, 446, 508, 555, 605, 713, 716, 759, 761, 880,
1.454 894, 1034, 1077, 1191, 1231, 1264, 1297, 1409, 1423, 1511, 1544, 1659, 1686, 1707, 1734, 1771, 1874, 1894,
1.455 @@ -527,26 +483,16 @@
1.456 4016, 4085, 4121, 4254, 4319, 4366, 4459, 4514, 4681
1.457 };
1.458
1.459 - struct node *nodes = calloc(100, sizeof(struct node));
1.460 - for (int i = 0; i < 100; i++) {
1.461 - nodes[i].prev = i == 0 ? NULL : &nodes[i - 1];
1.462 - nodes[i].next = i == 99 ? NULL : &nodes[i + 1];
1.463 - nodes[i].data = scrambled[i];
1.464 - }
1.465 + void *begin = create_test_data(100, scrambled);
1.466 + void *end = cx_linked_list_last(begin, loc_next);
1.467
1.468 - struct node *begin = &nodes[0];
1.469 - struct node *end = &nodes[99];
1.470 -
1.471 - cx_linked_list_sort((void **) &begin, (void **) &end,
1.472 - offsetof(struct node, prev),
1.473 - offsetof(struct node, next),
1.474 - offsetof(struct node, data),
1.475 + cx_linked_list_sort(&begin, &end, loc_prev, loc_next, loc_data,
1.476 0, (CxListComparator) cmp_int);
1.477
1.478 - CU_ASSERT_PTR_NULL(begin->prev)
1.479 - CU_ASSERT_EQUAL(begin->data, expected[0])
1.480 struct node *check = begin;
1.481 struct node *check_last = NULL;
1.482 + CU_ASSERT_PTR_NULL(check->prev)
1.483 + CU_ASSERT_EQUAL(check->data, expected[0])
1.484 for (int i = 0; i < 100; i++) {
1.485 CU_ASSERT_EQUAL(check->data, expected[i])
1.486 CU_ASSERT_PTR_EQUAL(check->prev, check_last)
1.487 @@ -557,53 +503,31 @@
1.488 check = check->next;
1.489 }
1.490 CU_ASSERT_PTR_NULL(check)
1.491 - CU_ASSERT_EQUAL(end->data, expected[99])
1.492 + CU_ASSERT_PTR_EQUAL(end, check_last)
1.493 +
1.494 + destroy_test_data(begin);
1.495 }
1.496
1.497 void test_linked_list_reverse(void) {
1.498 - struct node {
1.499 - void *next;
1.500 - };
1.501 - struct dnode {
1.502 - void *next;
1.503 - void *prev;
1.504 - };
1.505 - ptrdiff_t loc = offsetof(struct node, next);
1.506 - ptrdiff_t ploc = offsetof(struct dnode, prev);
1.507 + void *begin, *end;
1.508
1.509 - void *begin;
1.510 - void *end;
1.511 + int data[] = {2, 4, 6, 8};
1.512 + int reversed[] = {8, 6, 4, 2};
1.513
1.514 - // single linked list
1.515 - struct node third = {NULL};
1.516 - struct node second = {&third};
1.517 - struct node first = {&second};
1.518 - begin = &first;
1.519 + void *list = create_test_data(4, data);
1.520 + void *expected = create_test_data(4, reversed);
1.521
1.522 - cx_linked_list_reverse(&begin, NULL, -1, loc);
1.523 - CU_ASSERT_PTR_EQUAL(begin, &third)
1.524 - CU_ASSERT_PTR_EQUAL(third.next, &second)
1.525 - CU_ASSERT_PTR_EQUAL(second.next, &first)
1.526 - CU_ASSERT_PTR_NULL(first.next)
1.527 + begin = list;
1.528 + end = cx_linked_list_last(list, loc_next);
1.529
1.530 - // doubly linked list
1.531 - struct dnode dthird = {NULL , NULL};
1.532 - struct dnode dsecond = {&dthird, NULL};
1.533 - struct dnode dfirst = {&dsecond, NULL};
1.534 - dthird.prev = &dsecond;
1.535 - dsecond.prev = &dfirst;
1.536 - begin = &dfirst;
1.537 - end = &dthird;
1.538 + cx_linked_list_reverse(&begin, &end, loc_prev, loc_next);
1.539 + CU_ASSERT_PTR_EQUAL(end, list)
1.540 + CU_ASSERT_PTR_EQUAL(begin, cx_linked_list_first(end, loc_prev))
1.541 + CU_ASSERT_TRUE(0 == cx_linked_list_compare(begin, expected, loc_next, loc_data,
1.542 + 0, (CxListComparator) cmp_int))
1.543
1.544 - cx_linked_list_reverse(&begin, &end, ploc, loc);
1.545 - CU_ASSERT_PTR_EQUAL(begin, &dthird)
1.546 - CU_ASSERT_PTR_EQUAL(end, &dfirst)
1.547 - CU_ASSERT_PTR_EQUAL(dthird.next, &dsecond)
1.548 - CU_ASSERT_PTR_EQUAL(dsecond.next, &dfirst)
1.549 - CU_ASSERT_PTR_NULL(dfirst.next)
1.550 - CU_ASSERT_PTR_NULL(dthird.prev)
1.551 - CU_ASSERT_PTR_EQUAL(dsecond.prev, &dthird)
1.552 - CU_ASSERT_PTR_EQUAL(dfirst.prev, &dsecond)
1.553 + destroy_test_data(begin);
1.554 + destroy_test_data(expected);
1.555 }
1.556
1.557 void test_hl_linked_list_create(void) {
1.558 @@ -1028,6 +952,7 @@
1.559
1.560 cu_add_test(suite, test_linked_list_link_unlink);
1.561 cu_add_test(suite, test_linked_list_at);
1.562 + cu_add_test(suite, test_linked_list_compare);
1.563 cu_add_test(suite, test_linked_list_prepend);
1.564 cu_add_test(suite, test_linked_list_add);
1.565 cu_add_test(suite, test_linked_list_insert);
