comparison: test/test_list.c
test/test_list.c
- changeset 473
- 1bd4b8c28722
- parent 469
- 0458bff0b1cd
- child 474
- 9c1fccda16bc
equal
deleted
inserted
replaced
| 472:18f964adad1b | 473:1bd4b8c28722 |
|---|---|
| 126 CU_ASSERT_PTR_EQUAL(nodes[0].next, &nodes[1]) | 126 CU_ASSERT_PTR_EQUAL(nodes[0].next, &nodes[1]) |
| 127 CU_ASSERT_PTR_NULL(nodes[1].prev) | 127 CU_ASSERT_PTR_NULL(nodes[1].prev) |
| 128 } | 128 } |
| 129 | 129 |
| 130 void test_linked_list_last(void) { | 130 void test_linked_list_last(void) { |
| 131 CU_ASSERT_PTR_NULL(cx_linked_list_last(NULL, -1)) | |
| 132 CU_ASSERT_PTR_NULL(cx_linked_list_last(NULL, 0)) | 131 CU_ASSERT_PTR_NULL(cx_linked_list_last(NULL, 0)) |
| 133 | 132 |
| 134 struct node { | 133 struct node { |
| 135 int data; | 134 int data; |
| 136 void *next; | 135 void *next; |
| 142 struct node first = {1, &second}; | 141 struct node first = {1, &second}; |
| 143 | 142 |
| 144 CU_ASSERT_PTR_EQUAL(cx_linked_list_last(&first, loc), &third) | 143 CU_ASSERT_PTR_EQUAL(cx_linked_list_last(&first, loc), &third) |
| 145 CU_ASSERT_PTR_EQUAL(cx_linked_list_last(&second, loc), &third) | 144 CU_ASSERT_PTR_EQUAL(cx_linked_list_last(&second, loc), &third) |
| 146 CU_ASSERT_PTR_EQUAL(cx_linked_list_last(&third, loc), &third) | 145 CU_ASSERT_PTR_EQUAL(cx_linked_list_last(&third, loc), &third) |
| 146 } | |
| 147 | |
| 148 void test_linked_list_prev(void) { | |
| 149 struct node { | |
| 150 void *next; | |
| 151 }; | |
| 152 ptrdiff_t loc = offsetof(struct node, next); | |
| 153 | |
| 154 struct node third = {NULL}; | |
| 155 struct node second = {&third}; | |
| 156 struct node first = {&second}; | |
| 157 | |
| 158 CU_ASSERT_PTR_NULL(cx_linked_list_prev(&first, loc, &first)) | |
| 159 CU_ASSERT_PTR_EQUAL(cx_linked_list_prev(&first, loc, &second), &first) | |
| 160 CU_ASSERT_PTR_EQUAL(cx_linked_list_prev(&first, loc, &third), &second) | |
| 161 } | |
| 162 | |
| 163 void test_linked_list_remove(void) { | |
| 164 struct node { | |
| 165 void *next; | |
| 166 }; | |
| 167 struct dnode { | |
| 168 void *next; | |
| 169 void *prev; | |
| 170 }; | |
| 171 ptrdiff_t loc = offsetof(struct node, next); | |
| 172 ptrdiff_t ploc = offsetof(struct dnode, prev); | |
| 173 | |
| 174 void *begin; | |
| 175 void *end; | |
| 176 void *result; | |
| 177 | |
| 178 // single linked list | |
| 179 struct node third = {NULL}; | |
| 180 struct node second = {&third}; | |
| 181 struct node first = {&second}; | |
| 182 begin = &first; | |
| 183 | |
| 184 result = cx_linked_list_remove(&begin, NULL, -1, loc, &second); | |
| 185 CU_ASSERT_PTR_EQUAL(result, &first) | |
| 186 CU_ASSERT_PTR_EQUAL(begin, &first) | |
| 187 CU_ASSERT_PTR_EQUAL(first.next, &third) | |
| 188 CU_ASSERT_PTR_NULL(second.next) | |
| 189 CU_ASSERT_PTR_NULL(third.next) | |
| 190 | |
| 191 result = cx_linked_list_remove(&begin, NULL, -1, loc, &first); | |
| 192 CU_ASSERT_PTR_EQUAL(result, &third) | |
| 193 CU_ASSERT_PTR_EQUAL(begin, &third) | |
| 194 CU_ASSERT_PTR_NULL(first.next) | |
| 195 CU_ASSERT_PTR_NULL(third.next) | |
| 196 | |
| 197 result = cx_linked_list_remove(&begin, NULL, -1, loc, &third); | |
| 198 CU_ASSERT_PTR_NULL(result) | |
| 199 CU_ASSERT_PTR_NULL(begin) | |
| 200 CU_ASSERT_PTR_NULL(third.next) | |
| 201 | |
| 202 // doubly linked list | |
| 203 struct dnode dthird = {NULL , NULL}; | |
| 204 struct dnode dsecond = {&dthird, NULL}; | |
| 205 struct dnode dfirst = {&dsecond, NULL}; | |
| 206 dthird.prev = &dsecond; | |
| 207 dsecond.prev = &dfirst; | |
| 208 begin = &dfirst; | |
| 209 end = &dthird; | |
| 210 | |
| 211 result = cx_linked_list_remove(&begin, &end, ploc, loc, &dsecond); | |
| 212 CU_ASSERT_PTR_EQUAL(result, &dfirst) | |
| 213 CU_ASSERT_PTR_EQUAL(begin, &dfirst) | |
| 214 CU_ASSERT_PTR_EQUAL(end, &dthird) | |
| 215 CU_ASSERT_PTR_NULL(dfirst.prev) | |
| 216 CU_ASSERT_PTR_EQUAL(dfirst.next, &dthird) | |
| 217 CU_ASSERT_PTR_NULL(dsecond.prev) | |
| 218 CU_ASSERT_PTR_NULL(dsecond.next) | |
| 219 CU_ASSERT_PTR_EQUAL(dthird.prev, &dfirst) | |
| 220 CU_ASSERT_PTR_NULL(dthird.next) | |
| 221 | |
| 222 result = cx_linked_list_remove(&begin, &end, ploc, loc, &dthird); | |
| 223 CU_ASSERT_PTR_EQUAL(result, &dfirst) | |
| 224 CU_ASSERT_PTR_EQUAL(begin, &dfirst) | |
| 225 CU_ASSERT_PTR_EQUAL(end, &dfirst) | |
| 226 CU_ASSERT_PTR_NULL(dfirst.prev) | |
| 227 CU_ASSERT_PTR_NULL(dfirst.next) | |
| 228 CU_ASSERT_PTR_NULL(dthird.prev) | |
| 229 CU_ASSERT_PTR_NULL(dthird.next) | |
| 230 | |
| 231 result = cx_linked_list_remove(&begin, &end, ploc, loc, &dfirst); | |
| 232 CU_ASSERT_PTR_NULL(result) | |
| 233 CU_ASSERT_PTR_NULL(begin) | |
| 234 CU_ASSERT_PTR_NULL(end) | |
| 235 CU_ASSERT_PTR_NULL(dfirst.next) | |
| 236 CU_ASSERT_PTR_NULL(dfirst.prev) | |
| 147 } | 237 } |
| 148 | 238 |
| 149 void test_linked_list_size(void) { | 239 void test_linked_list_size(void) { |
| 150 struct node { | 240 struct node { |
| 151 void *next; | 241 void *next; |
| 207 | 297 |
| 208 CU_ASSERT_PTR_NULL(begin->prev) | 298 CU_ASSERT_PTR_NULL(begin->prev) |
| 209 CU_ASSERT_EQUAL(begin->data, expected[0]) | 299 CU_ASSERT_EQUAL(begin->data, expected[0]) |
| 210 struct node *check = begin; | 300 struct node *check = begin; |
| 211 struct node *check_last = NULL; | 301 struct node *check_last = NULL; |
| 212 for (int i = 0 ; i < 100 ; i++) { | 302 for (int i = 0; i < 100; i++) { |
| 213 CU_ASSERT_EQUAL(check->data, expected[i]) | 303 CU_ASSERT_EQUAL(check->data, expected[i]) |
| 214 CU_ASSERT_PTR_EQUAL(check->prev, check_last) | 304 CU_ASSERT_PTR_EQUAL(check->prev, check_last) |
| 215 if (i < 99) { | 305 if (i < 99) { |
| 216 CU_ASSERT_PTR_NOT_NULL(check->next) | 306 CU_ASSERT_PTR_NOT_NULL(check->next) |
| 217 } | 307 } |
| 220 } | 310 } |
| 221 CU_ASSERT_PTR_NULL(check) | 311 CU_ASSERT_PTR_NULL(check) |
| 222 CU_ASSERT_EQUAL(end->data, expected[99]) | 312 CU_ASSERT_EQUAL(end->data, expected[99]) |
| 223 } | 313 } |
| 224 | 314 |
| 315 void test_linked_list_reverse(void) { | |
| 316 struct node { | |
| 317 void *next; | |
| 318 }; | |
| 319 struct dnode { | |
| 320 void *next; | |
| 321 void *prev; | |
| 322 }; | |
| 323 ptrdiff_t loc = offsetof(struct node, next); | |
| 324 ptrdiff_t ploc = offsetof(struct dnode, prev); | |
| 325 | |
| 326 void *begin; | |
| 327 void *end; | |
| 328 | |
| 329 // single linked list | |
| 330 struct node third = {NULL}; | |
| 331 struct node second = {&third}; | |
| 332 struct node first = {&second}; | |
| 333 begin = &first; | |
| 334 | |
| 335 cx_linked_list_reverse(&begin, NULL, -1, loc); | |
| 336 CU_ASSERT_PTR_EQUAL(begin, &third) | |
| 337 CU_ASSERT_PTR_EQUAL(third.next, &second) | |
| 338 CU_ASSERT_PTR_EQUAL(second.next, &first) | |
| 339 CU_ASSERT_PTR_NULL(first.next) | |
| 340 | |
| 341 // doubly linked list | |
| 342 struct dnode dthird = {NULL , NULL}; | |
| 343 struct dnode dsecond = {&dthird, NULL}; | |
| 344 struct dnode dfirst = {&dsecond, NULL}; | |
| 345 dthird.prev = &dsecond; | |
| 346 dsecond.prev = &dfirst; | |
| 347 begin = &dfirst; | |
| 348 end = &dthird; | |
| 349 | |
| 350 cx_linked_list_reverse(&begin, &end, ploc, loc); | |
| 351 CU_ASSERT_PTR_EQUAL(begin, &dthird) | |
| 352 CU_ASSERT_PTR_EQUAL(end, &dfirst) | |
| 353 CU_ASSERT_PTR_EQUAL(dthird.next, &dsecond) | |
| 354 CU_ASSERT_PTR_EQUAL(dsecond.next, &dfirst) | |
| 355 CU_ASSERT_PTR_NULL(dfirst.next) | |
| 356 CU_ASSERT_PTR_NULL(dthird.prev) | |
| 357 CU_ASSERT_PTR_EQUAL(dsecond.prev, &dthird) | |
| 358 CU_ASSERT_PTR_EQUAL(dfirst.prev, &dsecond) | |
| 359 } | |
| 225 | 360 |
| 226 void test_hl_linked_list_create(void) { | 361 void test_hl_linked_list_create(void) { |
| 227 cxTestingAllocatorReset(); | 362 cxTestingAllocatorReset(); |
| 228 | 363 |
| 229 CxList list = cxLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int, sizeof(int)); | 364 CxList list = cxLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int, sizeof(int)); |
| 413 | 548 |
| 414 cxTestingAllocatorReset(); | 549 cxTestingAllocatorReset(); |
| 415 | 550 |
| 416 CxList list = cxLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int, sizeof(int)); | 551 CxList list = cxLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int, sizeof(int)); |
| 417 | 552 |
| 418 for (int i = 0 ; i < 100 ; i++) { | 553 for (int i = 0; i < 100; i++) { |
| 419 cxListAdd(list, &scrambled[i]); | 554 cxListAdd(list, &scrambled[i]); |
| 420 } | 555 } |
| 421 | 556 |
| 422 cxListSort(list); | 557 cxListSort(list); |
| 423 | 558 |
| 424 for (int i = 0 ; i < 100 ; i++) { | 559 for (int i = 0; i < 100; i++) { |
| 425 CU_ASSERT_EQUAL(*(int*)cxListAt(list, i), expected[i]) | 560 CU_ASSERT_EQUAL(*(int *) cxListAt(list, i), expected[i]) |
| 426 } | 561 } |
| 427 | 562 |
| 428 cxLinkedListDestroy(list); | 563 cxLinkedListDestroy(list); |
| 429 CU_ASSERT_TRUE(cxTestingAllocatorVerify()) | 564 CU_ASSERT_TRUE(cxTestingAllocatorVerify()) |
| 430 } | 565 } |
| 614 | 749 |
| 615 cxTestingAllocatorReset(); | 750 cxTestingAllocatorReset(); |
| 616 | 751 |
| 617 CxList list = cxPointerLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int); | 752 CxList list = cxPointerLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int); |
| 618 | 753 |
| 619 for (int i = 0 ; i < 100 ; i++) { | 754 for (int i = 0; i < 100; i++) { |
| 620 cxListAdd(list, &scrambled[i]); | 755 cxListAdd(list, &scrambled[i]); |
| 621 } | 756 } |
| 622 | 757 |
| 623 cxListSort(list); | 758 cxListSort(list); |
| 624 | 759 |
| 625 for (int i = 0 ; i < 100 ; i++) { | 760 for (int i = 0; i < 100; i++) { |
| 626 CU_ASSERT_EQUAL(*(int*)cxListAt(list, i), expected[i]) | 761 CU_ASSERT_EQUAL(*(int *) cxListAt(list, i), expected[i]) |
| 627 } | 762 } |
| 628 | 763 |
| 629 cxLinkedListDestroy(list); | 764 cxLinkedListDestroy(list); |
| 630 CU_ASSERT_TRUE(cxTestingAllocatorVerify()) | 765 CU_ASSERT_TRUE(cxTestingAllocatorVerify()) |
| 631 } | 766 } |
| 640 suite = CU_add_suite("low level linked list", NULL, NULL); | 775 suite = CU_add_suite("low level linked list", NULL, NULL); |
| 641 | 776 |
| 642 cu_add_test(suite, test_linked_list_at); | 777 cu_add_test(suite, test_linked_list_at); |
| 643 cu_add_test(suite, test_linked_list_add); | 778 cu_add_test(suite, test_linked_list_add); |
| 644 cu_add_test(suite, test_linked_list_last); | 779 cu_add_test(suite, test_linked_list_last); |
| 780 cu_add_test(suite, test_linked_list_prev); | |
| 781 cu_add_test(suite, test_linked_list_remove); | |
| 645 cu_add_test(suite, test_linked_list_size); | 782 cu_add_test(suite, test_linked_list_size); |
| 646 cu_add_test(suite, test_linked_list_sort); | 783 cu_add_test(suite, test_linked_list_sort); |
| 784 cu_add_test(suite, test_linked_list_reverse); | |
| 647 | 785 |
| 648 suite = CU_add_suite("high level linked list", NULL, NULL); | 786 suite = CU_add_suite("high level linked list", NULL, NULL); |
| 649 | 787 |
| 650 cu_add_test(suite, test_hl_linked_list_create); | 788 cu_add_test(suite, test_hl_linked_list_create); |
| 651 cu_add_test(suite, test_hl_linked_list_add); | 789 cu_add_test(suite, test_hl_linked_list_add); |
