changeset
complete migration of list tests - fixes #342
Fri, 12 Jan 2024 20:24:29 +0100
- author
- Mike Becker <universe@uap-core.de>
- date
- Fri, 12 Jan 2024 20:24:29 +0100
- changeset 803
- 0711d869ce4d
- parent 802
- 30473af255b4
- child 804
- 5136f2fc32ec
complete migration of list tests - fixes #342
| tests/test_list.c | file | annotate | diff | comparison | revisions | |
| tests/test_list.cpp | file | annotate | diff | comparison | revisions |
1.1 --- a/tests/test_list.c Fri Jan 12 20:13:13 2024 +0100 1.2 +++ b/tests/test_list.c Fri Jan 12 20:24:29 2024 +0100 1.3 @@ -29,6 +29,7 @@ 1.4 #include "cx/test.h" 1.5 #include "util_allocator.h" 1.6 #include "cx/compare.h" 1.7 +#include "cx/utils.h" 1.8 1.9 #include "cx/array_list.h" 1.10 #include "cx/linked_list.h" 1.11 @@ -854,6 +855,491 @@ 1.12 cx_testing_allocator_destroy(&talloc); 1.13 } 1.14 1.15 +#define set_up_combo \ 1.16 + CxTestingAllocator talloc; \ 1.17 + cx_testing_allocator_init(&talloc); \ 1.18 + CxAllocator *alloc = &talloc.base; \ 1.19 + CX_TEST_DO { 1.20 +#define tear_down_combo \ 1.21 + cxListDestroy(list); \ 1.22 + CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));\ 1.23 + } \ 1.24 + cx_testing_allocator_destroy(&talloc); 1.25 +#define roll_out_test_combos(name, body) \ 1.26 +static CX_TEST_SUBROUTINE(test_list_verify_##name, CxList *list, \ 1.27 + __attribute__((__unused__)) bool isptrlist, \ 1.28 + __attribute__((__unused__)) bool islinkedlist) body \ 1.29 +CX_TEST(test_list_ll_##name) { \ 1.30 + set_up_combo \ 1.31 + CxList *list = cxLinkedListCreate(alloc, cx_cmp_int, sizeof(int)); \ 1.32 + CX_TEST_CALL_SUBROUTINE(test_list_verify_##name, list, false, true); \ 1.33 + tear_down_combo \ 1.34 +} \ 1.35 +CX_TEST(test_list_arl_##name) { \ 1.36 + set_up_combo \ 1.37 + CxList *list = cxArrayListCreate(alloc, cx_cmp_int, sizeof(int), 8); \ 1.38 + CX_TEST_CALL_SUBROUTINE(test_list_verify_##name, list, false, false); \ 1.39 + tear_down_combo \ 1.40 +} \ 1.41 +CX_TEST(test_list_pll_##name) { \ 1.42 + set_up_combo \ 1.43 + CxList *list = cxLinkedListCreate(alloc, cx_cmp_int, CX_STORE_POINTERS); \ 1.44 + CX_TEST_CALL_SUBROUTINE(test_list_verify_##name, list, true, true); \ 1.45 + tear_down_combo \ 1.46 +} \ 1.47 +CX_TEST(test_list_parl_##name) { \ 1.48 + set_up_combo \ 1.49 + CxList *list = cxArrayListCreate(alloc, cx_cmp_int, CX_STORE_POINTERS, 8); \ 1.50 + CX_TEST_CALL_SUBROUTINE(test_list_verify_##name, list, true, false); \ 1.51 + tear_down_combo \ 1.52 +} 1.53 +#define array_init(...) {__VA_ARGS__} 1.54 + 1.55 +static inline int *int_test_data_added_to_list(CxList *list, bool isptrlist, size_t len) { 1.56 + int *testdata = int_test_data(len); 1.57 + if (isptrlist) { 1.58 + cx_for_n(i, len) { 1.59 + cxListAdd(list, &testdata[i]); 1.60 + } 1.61 + } else { 1.62 + cxListAddArray(list, testdata, len); 1.63 + } 1.64 + return testdata; 1.65 +} 1.66 + 1.67 +roll_out_test_combos(add, { 1.68 + const size_t len = 250; 1.69 + int *testdata = int_test_data(len); 1.70 + cx_for_n (i, len) CX_TEST_ASSERT(cxListAdd(list, &testdata[i]) == 0); 1.71 + CX_TEST_ASSERT(cxListSize(list) == len); 1.72 + cx_for_n (i, len) CX_TEST_ASSERT(*(int *) cxListAt(list, i) == testdata[i]); 1.73 + cx_for_n (i, len) ++testdata[i]; 1.74 + if (isptrlist) { 1.75 + cx_for_n (i, len) CX_TEST_ASSERT(*(int *) cxListAt(list, i) == testdata[i]); 1.76 + } else { 1.77 + cx_for_n (i, len) CX_TEST_ASSERT(*(int *) cxListAt(list, i) == testdata[i] - 1); 1.78 + } 1.79 + free(testdata); 1.80 +}) 1.81 + 1.82 +roll_out_test_combos(insert, { 1.83 + int a = 5; 1.84 + int b = 47; 1.85 + int c = 13; 1.86 + int d = 42; 1.87 + CX_TEST_ASSERT(cxListInsert(list, 1, &a) != 0); 1.88 + CX_TEST_ASSERT(cxListSize(list) == 0); 1.89 + CX_TEST_ASSERT(cxListInsert(list, 0, &a) == 0); 1.90 + CX_TEST_ASSERT(cxListSize(list) == 1); 1.91 + CX_TEST_ASSERT(cxListInsert(list, 0, &b) == 0); 1.92 + CX_TEST_ASSERT(cxListSize(list) == 2); 1.93 + CX_TEST_ASSERT(cxListInsert(list, 1, &c) == 0); 1.94 + CX_TEST_ASSERT(cxListSize(list) == 3); 1.95 + CX_TEST_ASSERT(cxListInsert(list, 3, &d) == 0); 1.96 + CX_TEST_ASSERT(cxListSize(list) == 4); 1.97 + CX_TEST_ASSERT(*(int *) cxListAt(list, 0) == 47); 1.98 + CX_TEST_ASSERT(*(int *) cxListAt(list, 1) == 13); 1.99 + CX_TEST_ASSERT(*(int *) cxListAt(list, 2) == 5); 1.100 + CX_TEST_ASSERT(*(int *) cxListAt(list, 3) == 42); 1.101 +}) 1.102 + 1.103 +roll_out_test_combos(insert_array, { 1.104 + int a[5] = array_init(5, 47, 11, 13, 42); 1.105 + int b[5] = array_init(9, 18, 72, 50, 7); 1.106 + int *aptr[5]; 1.107 + int *bptr[5]; 1.108 + cx_for_n(i, 5) { 1.109 + aptr[i] = &a[i]; 1.110 + bptr[i] = &b[i]; 1.111 + } 1.112 + 1.113 + size_t inserted; 1.114 + 1.115 + if (isptrlist) { 1.116 + inserted = cxListInsertArray(list, 0, aptr, 5); 1.117 + } else { 1.118 + inserted = cxListInsertArray(list, 0, a, 5); 1.119 + } 1.120 + CX_TEST_ASSERT(inserted == 5); 1.121 + CX_TEST_ASSERT(*(int *) cxListAt(list, 0) == 5); 1.122 + CX_TEST_ASSERT(*(int *) cxListAt(list, 1) == 47); 1.123 + CX_TEST_ASSERT(*(int *) cxListAt(list, 2) == 11); 1.124 + CX_TEST_ASSERT(*(int *) cxListAt(list, 3) == 13); 1.125 + CX_TEST_ASSERT(*(int *) cxListAt(list, 4) == 42); 1.126 + if (isptrlist) { 1.127 + inserted = cxListInsertArray(list, 3, bptr, 5); 1.128 + } else { 1.129 + inserted = cxListInsertArray(list, 3, b, 5); 1.130 + } 1.131 + CX_TEST_ASSERT(inserted == 5); 1.132 + CX_TEST_ASSERT(*(int *) cxListAt(list, 0) == 5); 1.133 + CX_TEST_ASSERT(*(int *) cxListAt(list, 1) == 47); 1.134 + CX_TEST_ASSERT(*(int *) cxListAt(list, 2) == 11); 1.135 + CX_TEST_ASSERT(*(int *) cxListAt(list, 3) == 9); 1.136 + CX_TEST_ASSERT(*(int *) cxListAt(list, 4) == 18); 1.137 + CX_TEST_ASSERT(*(int *) cxListAt(list, 5) == 72); 1.138 + CX_TEST_ASSERT(*(int *) cxListAt(list, 6) == 50); 1.139 + CX_TEST_ASSERT(*(int *) cxListAt(list, 7) == 7); 1.140 + CX_TEST_ASSERT(*(int *) cxListAt(list, 8) == 13); 1.141 + CX_TEST_ASSERT(*(int *) cxListAt(list, 9) == 42); 1.142 +}) 1.143 + 1.144 +roll_out_test_combos(remove, { 1.145 + const size_t testdata_len = 32; 1.146 + int *testdata = int_test_data_added_to_list(list, isptrlist, testdata_len); 1.147 + 1.148 + CX_TEST_ASSERT(cxListRemove(list, 2) == 0); 1.149 + CX_TEST_ASSERT(cxListRemove(list, 4) == 0); 1.150 + CX_TEST_ASSERT(cxListSize(list) == testdata_len - 2); 1.151 + CX_TEST_ASSERT(*(int *) cxListAt(list, 0) == testdata[0]); 1.152 + CX_TEST_ASSERT(*(int *) cxListAt(list, 1) == testdata[1]); 1.153 + CX_TEST_ASSERT(*(int *) cxListAt(list, 2) == testdata[3]); 1.154 + CX_TEST_ASSERT(*(int *) cxListAt(list, 3) == testdata[4]); 1.155 + CX_TEST_ASSERT(*(int *) cxListAt(list, 4) == testdata[6]); 1.156 + CX_TEST_ASSERT(cxListRemove(list, 0) == 0); 1.157 + CX_TEST_ASSERT(cxListSize(list) == testdata_len - 3); 1.158 + CX_TEST_ASSERT(*(int *) cxListAt(list, 0) == testdata[1]); 1.159 + CX_TEST_ASSERT(*(int *) cxListAt(list, 1) == testdata[3]); 1.160 + CX_TEST_ASSERT(cxListRemove(list, testdata_len) != 0); 1.161 + free(testdata); 1.162 +}) 1.163 + 1.164 +roll_out_test_combos(find_remove, { 1.165 + const size_t testdata_len = 250; 1.166 + int *testdata = int_test_data_added_to_list(list, isptrlist, testdata_len); 1.167 + 1.168 + int exp = rand() % testdata_len; // NOLINT(cert-msc50-cpp) 1.169 + int val = testdata[exp]; 1.170 + // randomly picked number could occur earlier in list - find first position 1.171 + for (int i = 0 ; i < exp ; i++) { 1.172 + if (testdata[i] == val) { 1.173 + exp = i; 1.174 + break; 1.175 + } 1.176 + } 1.177 + CX_TEST_ASSERT(cxListSize(list) == testdata_len); 1.178 + CX_TEST_ASSERT(cxListFind(list, &val) == exp); 1.179 + CX_TEST_ASSERT(cxListFindRemove(list, &val) == exp); 1.180 + CX_TEST_ASSERT(cxListSize(list) == testdata_len - 1); 1.181 + CX_TEST_ASSERT(cxListFind(list, &val) != exp); 1.182 + 1.183 + int notinlist = -1; 1.184 + CX_TEST_ASSERT(cxListFindRemove(list, ¬inlist) < 0); 1.185 + CX_TEST_ASSERT(cxListSize(list) == testdata_len - 1); 1.186 + 1.187 + free(testdata); 1.188 +}) 1.189 + 1.190 +roll_out_test_combos(clear, { 1.191 + int *testdata = int_test_data_added_to_list(list, isptrlist, 8); 1.192 + CX_TEST_ASSERT(cxListSize(list) > 0); 1.193 + cxListClear(list); 1.194 + CX_TEST_ASSERT(cxListSize(list) == 0); 1.195 + free(testdata); 1.196 +}) 1.197 + 1.198 +roll_out_test_combos(at, { 1.199 + size_t len = 128; 1.200 + int *testdata = int_test_data_added_to_list(list, isptrlist, 128); 1.201 + CX_TEST_ASSERT(cxListSize(list) == len); 1.202 + cx_for_n (i, len) { 1.203 + CX_TEST_ASSERT(*(int *) cxListAt(list, i) == testdata[i]); 1.204 + } 1.205 + CX_TEST_ASSERT(cxListAt(list, cxListSize(list)) == NULL); 1.206 + free(testdata); 1.207 +}) 1.208 + 1.209 +roll_out_test_combos(swap, { 1.210 + int original[16] = array_init(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15); 1.211 + int swapped[16] = array_init(8, 4, 14, 3, 1, 5, 9, 12, 0, 6, 11, 10, 7, 15, 2, 13); 1.212 + 1.213 + cx_for_n(i, 16) { 1.214 + cxListAdd(list, &original[i]); 1.215 + } 1.216 + 1.217 + CX_TEST_ASSERT(0 == cxListSwap(list, 1, 4)); 1.218 + CX_TEST_ASSERT(0 == cxListSwap(list, 2, 14)); 1.219 + CX_TEST_ASSERT(0 == cxListSwap(list, 9, 6)); 1.220 + CX_TEST_ASSERT(0 == cxListSwap(list, 3, 3)); 1.221 + CX_TEST_ASSERT(0 == cxListSwap(list, 10, 11)); 1.222 + CX_TEST_ASSERT(0 == cxListSwap(list, 8, 0)); 1.223 + CX_TEST_ASSERT(0 == cxListSwap(list, 7, 12)); 1.224 + CX_TEST_ASSERT(0 == cxListSwap(list, 13, 15)); 1.225 + 1.226 + CX_TEST_ASSERT(0 != cxListSwap(list, 5, 16)); 1.227 + CX_TEST_ASSERT(0 != cxListSwap(list, 16, 6)); 1.228 + CX_TEST_ASSERT(0 != cxListSwap(list, 16, 17)); 1.229 + 1.230 + CxIterator iter = cxListIterator(list); 1.231 + cx_foreach(int*, e, iter) { 1.232 + CX_TEST_ASSERT(*e == swapped[iter.index]); 1.233 + } 1.234 + iter = cxListBackwardsIterator(list); 1.235 + cx_foreach(int*, e, iter) { 1.236 + CX_TEST_ASSERT(*e == swapped[iter.index]); 1.237 + } 1.238 +}) 1.239 + 1.240 +roll_out_test_combos(swap_no_sbo, { 1.241 + if (islinkedlist) { 1.242 + CX_DISABLE_LINKED_LIST_SWAP_SBO = true; 1.243 + CX_TEST_CALL_SUBROUTINE(test_list_verify_swap, list, isptrlist, true); 1.244 + CX_DISABLE_LINKED_LIST_SWAP_SBO = false; 1.245 + } else { 1.246 + // TODO: currently, SBO for swap operation cannot be disabled for array lists 1.247 + CX_TEST_ASSERT(true); 1.248 + } 1.249 +}) 1.250 + 1.251 +roll_out_test_combos(find, { 1.252 + const size_t testdata_len = 500; 1.253 + int *testdata = int_test_data_added_to_list(list, isptrlist, testdata_len); 1.254 + 1.255 + cx_for_n (attempt, 25) { 1.256 + int exp = rand() % testdata_len; // NOLINT(cert-msc50-cpp) 1.257 + int val = testdata[exp]; 1.258 + // randomly picked number could occur earlier in list - find first position 1.259 + for (int i = 0 ; i < exp ; i++) { 1.260 + if (testdata[i] == val) { 1.261 + exp = i; 1.262 + break; 1.263 + } 1.264 + } 1.265 + CX_TEST_ASSERT(cxListFind(list, &val) == exp); 1.266 + } 1.267 + 1.268 + int notinlist = -1; 1.269 + CX_TEST_ASSERT(cxListFind(list, ¬inlist) < 0); 1.270 + 1.271 + free(testdata); 1.272 +}) 1.273 + 1.274 +roll_out_test_combos(sort, { 1.275 + const size_t testdata_len = 250; 1.276 + int *testdata = int_test_data_added_to_list(list, isptrlist, testdata_len); 1.277 + int *expected = malloc(testdata_len*sizeof(int)); 1.278 + memcpy(expected, testdata, testdata_len*sizeof(int)); 1.279 + qsort(expected, testdata_len, sizeof(int), cx_cmp_int); 1.280 + 1.281 + cxListSort(list); 1.282 + cx_for_n (i, testdata_len) CX_TEST_ASSERT(*(int *) cxListAt(list, i) == expected[i]); 1.283 + 1.284 + free(expected); 1.285 + free(testdata); 1.286 +}) 1.287 + 1.288 +roll_out_test_combos(reverse, { 1.289 + const size_t testdata_len = 50; 1.290 + int *testdata = int_test_data_added_to_list(list, isptrlist, testdata_len); 1.291 + cxListReverse(list); 1.292 + cx_for_n(i, testdata_len) { 1.293 + CX_TEST_ASSERT(*(int *) cxListAt(list, i) == testdata[testdata_len - 1 - i]); 1.294 + } 1.295 + free(testdata); 1.296 +}) 1.297 + 1.298 +roll_out_test_combos(iterator, { 1.299 + const size_t len = 50; 1.300 + int *testdata = int_test_data_added_to_list(list, isptrlist, len); 1.301 + 1.302 + CxIterator iter = cxListIterator(list); 1.303 + size_t i = 0; 1.304 + cx_foreach(int*, x, iter) { 1.305 + CX_TEST_ASSERT(i == iter.index); 1.306 + CX_TEST_ASSERT(*x == testdata[iter.index]); 1.307 + i++; 1.308 + } 1.309 + CX_TEST_ASSERT(i == cxListSize(list)); 1.310 + iter = cxListBackwardsIterator(list); 1.311 + cx_foreach(int*, x, iter) { 1.312 + CX_TEST_ASSERT(i - 1 == iter.index); 1.313 + CX_TEST_ASSERT(*x == testdata[iter.index]); 1.314 + i--; 1.315 + } 1.316 + CX_TEST_ASSERT(i == 0); 1.317 + i = len / 2; 1.318 + CxMutIterator mut_iter = cxListMutIteratorAt(list, i); 1.319 + size_t j = 0; 1.320 + cx_foreach(int*, x, mut_iter) { 1.321 + CX_TEST_ASSERT(mut_iter.index == len / 2 + j / 2); 1.322 + CX_TEST_ASSERT(*x == testdata[i]); 1.323 + if (i % 2 == 1) cxIteratorFlagRemoval(mut_iter); 1.324 + i++; 1.325 + j++; 1.326 + } 1.327 + CX_TEST_ASSERT(i == len); 1.328 + i = len / 2; 1.329 + j = 0; 1.330 + mut_iter = cxListMutBackwardsIteratorAt(list, i - 1); 1.331 + cx_foreach(int*, x, mut_iter) { 1.332 + CX_TEST_ASSERT(mut_iter.index == len / 2 - 1 - j); 1.333 + CX_TEST_ASSERT(*x == testdata[i - 1]); 1.334 + if (i % 2 == 0) cxIteratorFlagRemoval(mut_iter); 1.335 + i--; 1.336 + j++; 1.337 + } 1.338 + CX_TEST_ASSERT(i == 0); 1.339 + CX_TEST_ASSERT(cxListSize(list) == len / 2); 1.340 + cx_for_n(k, len / 2) CX_TEST_ASSERT(*(int *) cxListAt(list, k) == testdata[k * 2]); 1.341 + 1.342 + free(testdata); 1.343 +}) 1.344 + 1.345 +roll_out_test_combos(insert_with_iterator, { 1.346 + int fivenums[] = array_init(0, 1, 2, 3, 4); 1.347 + cx_for_n(i, 5) cxListAdd(list, &fivenums[i]); 1.348 + int newdata[] = array_init(10, 20, 30, 40, 50); 1.349 + 1.350 + CxMutIterator iter = cxListMutIteratorAt(list, 2); 1.351 + CX_TEST_ASSERT(cxIteratorValid(iter)); 1.352 + CX_TEST_ASSERT(iter.index == 2); 1.353 + CX_TEST_ASSERT(*(int *) cxIteratorCurrent(iter) == 2); 1.354 + cxListInsertAfter(&iter, &newdata[0]); 1.355 + CX_TEST_ASSERT(cxIteratorValid(iter)); 1.356 + CX_TEST_ASSERT(iter.index == 2); 1.357 + CX_TEST_ASSERT(*(int *) cxIteratorCurrent(iter) == 2); 1.358 + cxListInsertBefore(&iter, &newdata[1]); 1.359 + CX_TEST_ASSERT(cxIteratorValid(iter)); 1.360 + CX_TEST_ASSERT(iter.index == 3); 1.361 + CX_TEST_ASSERT(*(int *) cxIteratorCurrent(iter) == 2); 1.362 + 1.363 + iter = cxListMutIterator(list); 1.364 + cxListInsertBefore(&iter, &newdata[2]); 1.365 + CX_TEST_ASSERT(cxIteratorValid(iter)); 1.366 + CX_TEST_ASSERT(iter.index == 1); 1.367 + CX_TEST_ASSERT(*(int *) cxIteratorCurrent(iter) == 0); 1.368 + iter = cxListMutIteratorAt(list, cxListSize(list)); 1.369 + cxListInsertBefore(&iter, &newdata[3]); 1.370 + CX_TEST_ASSERT(!cxIteratorValid(iter)); 1.371 + CX_TEST_ASSERT(iter.index == 9); 1.372 + iter = cxListMutIteratorAt(list, cxListSize(list)); 1.373 + cxListInsertAfter(&iter, &newdata[4]); 1.374 + CX_TEST_ASSERT(!cxIteratorValid(iter)); 1.375 + CX_TEST_ASSERT(iter.index == 10); 1.376 + 1.377 + int expdata[] = array_init(30, 0, 1, 20, 2, 10, 3, 4, 40, 50); 1.378 + cx_for_n (j, 10) CX_TEST_ASSERT(*(int *) cxListAt(list, j) == expdata[j]); 1.379 +}) 1.380 + 1.381 +static CX_TEST_SUBROUTINE(test_list_verify_compare, CxList *left, CxList *right) { 1.382 + CX_TEST_ASSERTM(cxListCompare(left, right) == 0, "lists don't start identical"); 1.383 + int x = 42; 1.384 + cxListAdd(left, &x); 1.385 + CX_TEST_ASSERT(cxListSize(left) > cxListSize(right)); 1.386 + CX_TEST_ASSERT(cxListCompare(left, right) > 0); 1.387 + CX_TEST_ASSERT(cxListCompare(right, left) < 0); 1.388 + cxListAdd(right, &x); 1.389 + CX_TEST_ASSERT(cxListSize(left) == cxListSize(right)); 1.390 + CX_TEST_ASSERT(cxListCompare(left, right) == 0); 1.391 + int a = 5, b = 10; 1.392 + cxListInsert(left, 15, &a); 1.393 + cxListInsert(right, 15, &b); 1.394 + CX_TEST_ASSERT(cxListSize(left) == cxListSize(right)); 1.395 + CX_TEST_ASSERT(cxListCompare(left, right) < 0); 1.396 + CX_TEST_ASSERT(cxListCompare(right, left) > 0); 1.397 + *(int *) cxListAt(left, 15) = 10; 1.398 + CX_TEST_ASSERT(cxListCompare(left, right) == 0); 1.399 +} 1.400 + 1.401 +#define roll_out_compare_tests(suffix, otherctr) \ 1.402 +roll_out_test_combos(compare_##suffix, { \ 1.403 + const size_t len = 47; \ 1.404 + int *testdata = int_test_data_added_to_list(list, isptrlist, len); \ 1.405 + CxList *other = otherctr; \ 1.406 + cx_for_n(i, len) cxListAdd(other, &testdata[i]); \ 1.407 + CX_TEST_CALL_SUBROUTINE(test_list_verify_compare, list, other); \ 1.408 + cxListDestroy(other); \ 1.409 + free(testdata); \ 1.410 +}) 1.411 + 1.412 +roll_out_compare_tests( 1.413 + ll, cxLinkedListCreate(cxDefaultAllocator, cx_cmp_int, sizeof(int)) 1.414 +) 1.415 + 1.416 +roll_out_compare_tests( 1.417 + pll, cxLinkedListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS) 1.418 +) 1.419 + 1.420 +roll_out_compare_tests( 1.421 + arl, cxArrayListCreate(cxDefaultAllocator, cx_cmp_int, sizeof(int), 50) 1.422 +) 1.423 + 1.424 +roll_out_compare_tests( 1.425 + parl, cxArrayListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS, 50) 1.426 +) 1.427 + 1.428 +static unsigned destr_test_ctr; 1.429 +static int destr_last_value; 1.430 + 1.431 +static void simple_destr_test_fun(void *data) { 1.432 + int *ptr = data; 1.433 + destr_last_value = *ptr; 1.434 + *ptr = destr_last_value + 1; 1.435 + destr_test_ctr++; 1.436 +} 1.437 + 1.438 +static void advanced_destr_test_fun(__attribute__((__unused__)) void *u, void *data) { 1.439 + simple_destr_test_fun(data); 1.440 +} 1.441 + 1.442 +static CX_TEST_SUBROUTINE(test_list_verify_destructor, CxList *list, 1.443 + int const *testdata, size_t testdata_len) { 1.444 + destr_test_ctr = 0; 1.445 + 1.446 + int off = cxListIsStoringPointers(list) ? 1 : 0; 1.447 + 1.448 + cxListRemove(list, 15); 1.449 + CX_TEST_ASSERT(1 == destr_test_ctr); 1.450 + CX_TEST_ASSERT(testdata[15] == destr_last_value + off); 1.451 + CX_TEST_ASSERT(testdata_len - destr_test_ctr == cxListSize(list)); 1.452 + cxListRemove(list, 47); 1.453 + CX_TEST_ASSERT(2 == destr_test_ctr); 1.454 + CX_TEST_ASSERT(testdata[48] == destr_last_value + off); 1.455 + CX_TEST_ASSERT(testdata_len - destr_test_ctr == cxListSize(list)); 1.456 + 1.457 + CxMutIterator iter = cxListMutIteratorAt(list, 7); 1.458 + cxIteratorNext(iter); 1.459 + CX_TEST_ASSERT(2 == destr_test_ctr); 1.460 + CX_TEST_ASSERT(testdata[48] == destr_last_value + off); 1.461 + CX_TEST_ASSERT(testdata_len - destr_test_ctr == cxListSize(list)); 1.462 + cxIteratorFlagRemoval(iter); 1.463 + cxIteratorNext(iter); 1.464 + CX_TEST_ASSERT(3 == destr_test_ctr); 1.465 + CX_TEST_ASSERT(testdata[8] == destr_last_value + off); 1.466 + CX_TEST_ASSERT(testdata_len - destr_test_ctr == cxListSize(list)); 1.467 + 1.468 + iter = cxListMutBackwardsIteratorAt(list, 5); 1.469 + cxIteratorNext(iter); 1.470 + CX_TEST_ASSERT(3 == destr_test_ctr); 1.471 + CX_TEST_ASSERT(testdata[8] == destr_last_value + off); 1.472 + CX_TEST_ASSERT(testdata_len - destr_test_ctr == cxListSize(list)); 1.473 + cxIteratorFlagRemoval(iter); 1.474 + cxIteratorNext(iter); 1.475 + CX_TEST_ASSERT(4 == destr_test_ctr); 1.476 + CX_TEST_ASSERT(testdata[4] == destr_last_value + off); 1.477 + CX_TEST_ASSERT(testdata_len - destr_test_ctr == cxListSize(list)); 1.478 + 1.479 + cxListClear(list); 1.480 + CX_TEST_ASSERT(testdata_len == destr_test_ctr); 1.481 + CX_TEST_ASSERT(testdata[testdata_len - 1] == destr_last_value + off); 1.482 +} 1.483 + 1.484 +roll_out_test_combos(simple_destr, { 1.485 + const size_t len = 60; 1.486 + int *testdata = int_test_data_added_to_list(list, isptrlist, len); 1.487 + list->simple_destructor = simple_destr_test_fun; 1.488 + CX_TEST_CALL_SUBROUTINE(test_list_verify_destructor, list, testdata, len); 1.489 + free(testdata); 1.490 +}) 1.491 + 1.492 +roll_out_test_combos(advanced_destr, { 1.493 + const size_t len = 75; 1.494 + int *testdata = int_test_data_added_to_list(list, isptrlist, len); 1.495 + list->advanced_destructor = advanced_destr_test_fun; 1.496 + CX_TEST_CALL_SUBROUTINE(test_list_verify_destructor, list, testdata, len); 1.497 + free(testdata); 1.498 +}) 1.499 + 1.500 CxTestSuite *cx_test_suite_array_list(void) { 1.501 CxTestSuite *suite = cx_test_suite_new("array_list"); 1.502 1.503 @@ -864,6 +1350,47 @@ 1.504 cx_test_register(suite, test_list_parl_destroy_simple_destr); 1.505 cx_test_register(suite, test_list_parl_destroy_adv_destr); 1.506 1.507 + cx_test_register(suite, test_list_arl_add); 1.508 + cx_test_register(suite, test_list_parl_add); 1.509 + cx_test_register(suite, test_list_arl_insert); 1.510 + cx_test_register(suite, test_list_parl_insert); 1.511 + cx_test_register(suite, test_list_arl_insert_array); 1.512 + cx_test_register(suite, test_list_parl_insert_array); 1.513 + cx_test_register(suite, test_list_arl_remove); 1.514 + cx_test_register(suite, test_list_parl_remove); 1.515 + cx_test_register(suite, test_list_arl_find_remove); 1.516 + cx_test_register(suite, test_list_parl_find_remove); 1.517 + cx_test_register(suite, test_list_arl_clear); 1.518 + cx_test_register(suite, test_list_parl_clear); 1.519 + cx_test_register(suite, test_list_arl_at); 1.520 + cx_test_register(suite, test_list_parl_at); 1.521 + cx_test_register(suite, test_list_arl_swap); 1.522 + cx_test_register(suite, test_list_parl_swap); 1.523 + cx_test_register(suite, test_list_arl_swap_no_sbo); 1.524 + cx_test_register(suite, test_list_parl_swap_no_sbo); 1.525 + cx_test_register(suite, test_list_arl_find); 1.526 + cx_test_register(suite, test_list_parl_find); 1.527 + cx_test_register(suite, test_list_arl_sort); 1.528 + cx_test_register(suite, test_list_parl_sort); 1.529 + cx_test_register(suite, test_list_arl_reverse); 1.530 + cx_test_register(suite, test_list_parl_reverse); 1.531 + cx_test_register(suite, test_list_arl_iterator); 1.532 + cx_test_register(suite, test_list_parl_iterator); 1.533 + cx_test_register(suite, test_list_arl_insert_with_iterator); 1.534 + cx_test_register(suite, test_list_parl_insert_with_iterator); 1.535 + cx_test_register(suite, test_list_arl_compare_ll); 1.536 + cx_test_register(suite, test_list_arl_compare_arl); 1.537 + cx_test_register(suite, test_list_arl_compare_pll); 1.538 + cx_test_register(suite, test_list_arl_compare_parl); 1.539 + cx_test_register(suite, test_list_parl_compare_ll); 1.540 + cx_test_register(suite, test_list_parl_compare_arl); 1.541 + cx_test_register(suite, test_list_parl_compare_pll); 1.542 + cx_test_register(suite, test_list_parl_compare_parl); 1.543 + cx_test_register(suite, test_list_arl_simple_destr); 1.544 + cx_test_register(suite, test_list_parl_simple_destr); 1.545 + cx_test_register(suite, test_list_arl_advanced_destr); 1.546 + cx_test_register(suite, test_list_parl_advanced_destr); 1.547 + 1.548 return suite; 1.549 } 1.550 1.551 @@ -895,6 +1422,47 @@ 1.552 cx_test_register(suite, test_list_pll_destroy_simple_destr); 1.553 cx_test_register(suite, test_list_pll_destroy_adv_destr); 1.554 1.555 + cx_test_register(suite, test_list_ll_add); 1.556 + cx_test_register(suite, test_list_pll_add); 1.557 + cx_test_register(suite, test_list_ll_insert); 1.558 + cx_test_register(suite, test_list_pll_insert); 1.559 + cx_test_register(suite, test_list_ll_insert_array); 1.560 + cx_test_register(suite, test_list_pll_insert_array); 1.561 + cx_test_register(suite, test_list_ll_remove); 1.562 + cx_test_register(suite, test_list_pll_remove); 1.563 + cx_test_register(suite, test_list_ll_find_remove); 1.564 + cx_test_register(suite, test_list_pll_find_remove); 1.565 + cx_test_register(suite, test_list_ll_clear); 1.566 + cx_test_register(suite, test_list_pll_clear); 1.567 + cx_test_register(suite, test_list_ll_at); 1.568 + cx_test_register(suite, test_list_pll_at); 1.569 + cx_test_register(suite, test_list_ll_swap); 1.570 + cx_test_register(suite, test_list_pll_swap); 1.571 + cx_test_register(suite, test_list_ll_swap_no_sbo); 1.572 + cx_test_register(suite, test_list_pll_swap_no_sbo); 1.573 + cx_test_register(suite, test_list_ll_find); 1.574 + cx_test_register(suite, test_list_pll_find); 1.575 + cx_test_register(suite, test_list_ll_sort); 1.576 + cx_test_register(suite, test_list_pll_sort); 1.577 + cx_test_register(suite, test_list_ll_reverse); 1.578 + cx_test_register(suite, test_list_pll_reverse); 1.579 + cx_test_register(suite, test_list_ll_iterator); 1.580 + cx_test_register(suite, test_list_pll_iterator); 1.581 + cx_test_register(suite, test_list_ll_insert_with_iterator); 1.582 + cx_test_register(suite, test_list_pll_insert_with_iterator); 1.583 + cx_test_register(suite, test_list_ll_compare_ll); 1.584 + cx_test_register(suite, test_list_ll_compare_arl); 1.585 + cx_test_register(suite, test_list_ll_compare_pll); 1.586 + cx_test_register(suite, test_list_ll_compare_parl); 1.587 + cx_test_register(suite, test_list_pll_compare_ll); 1.588 + cx_test_register(suite, test_list_pll_compare_arl); 1.589 + cx_test_register(suite, test_list_pll_compare_pll); 1.590 + cx_test_register(suite, test_list_pll_compare_parl); 1.591 + cx_test_register(suite, test_list_ll_simple_destr); 1.592 + cx_test_register(suite, test_list_pll_simple_destr); 1.593 + cx_test_register(suite, test_list_ll_advanced_destr); 1.594 + cx_test_register(suite, test_list_pll_advanced_destr); 1.595 + 1.596 return suite; 1.597 } 1.598
2.1 --- a/tests/test_list.cpp Fri Jan 12 20:13:13 2024 +0100 2.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 2.3 @@ -1,852 +0,0 @@ 2.4 -/* 2.5 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. 2.6 - * 2.7 - * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved. 2.8 - * 2.9 - * Redistribution and use in source and binary forms, with or without 2.10 - * modification, are permitted provided that the following conditions are met: 2.11 - * 2.12 - * 1. Redistributions of source code must retain the above copyright 2.13 - * notice, this list of conditions and the following disclaimer. 2.14 - * 2.15 - * 2. Redistributions in binary form must reproduce the above copyright 2.16 - * notice, this list of conditions and the following disclaimer in the 2.17 - * documentation and/or other materials provided with the distribution. 2.18 - * 2.19 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 2.20 - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 2.21 - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 2.22 - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 2.23 - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 2.24 - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 2.25 - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 2.26 - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 2.27 - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 2.28 - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 2.29 - * POSSIBILITY OF SUCH DAMAGE. 2.30 - */ 2.31 - 2.32 -#include "cx/linked_list.h" 2.33 -#include "cx/array_list.h" 2.34 -#include "cx/utils.h" 2.35 -#include "cx/compare.h" 2.36 -#include "util_allocator.h" 2.37 - 2.38 -#include <gtest/gtest.h> 2.39 -#include <array> 2.40 -#include <vector> 2.41 -#include <unordered_set> 2.42 -#include <algorithm> 2.43 - 2.44 - 2.45 -class HighLevelTest : public ::testing::Test { 2.46 - mutable std::unordered_set<CxList *> lists; 2.47 -protected: 2.48 - CxTestingAllocator testingAllocator; 2.49 - 2.50 - void TearDown() override { 2.51 - for (auto &&l: lists) cxListDestroy(l); 2.52 - CX_TEST_ASSERT(testingAllocator.verify()); 2.53 - } 2.54 - 2.55 - static constexpr size_t testdata_len = 250; 2.56 - int_test_data<testdata_len> testdata; 2.57 - 2.58 - auto autofree(CxList *list) const -> CxList * { 2.59 - if (list != NULL) lists.insert(list); 2.60 - return list; 2.61 - } 2.62 - 2.63 - auto linkedListFromTestData() const -> CxList * { 2.64 - auto list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int))); 2.65 - cxListAddArray(list, testdata.data.data(), testdata_len); 2.66 - return list; 2.67 - } 2.68 - 2.69 - auto pointerLinkedListFromTestData() const -> CxList * { 2.70 - auto list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS)); 2.71 - // note: cannot use cxListAddArray() because we don't have a list of pointers 2.72 - cx_for_n(i, testdata_len) cxListAdd(list, &testdata.data[i]); 2.73 - return list; 2.74 - } 2.75 - 2.76 - auto arrayListFromTestData() const -> CxList * { 2.77 - auto list = autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, sizeof(int), testdata_len)); 2.78 - cxListAddArray(list, testdata.data.data(), testdata_len); 2.79 - return list; 2.80 - } 2.81 - 2.82 - auto pointerArrayListFromTestData() const -> CxList * { 2.83 - auto list = autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS, 256)); 2.84 - // note: cannot use cxListAddArray() because we don't have a list of pointers 2.85 - cx_for_n(i, testdata_len) cxListAdd(list, &testdata.data[i]); 2.86 - return list; 2.87 - } 2.88 - 2.89 - void verifyAdd( 2.90 - CxList *list, 2.91 - bool as_pointer 2.92 - ) { 2.93 - auto len = testdata_len; 2.94 - cx_for_n (i, len) EXPECT_EQ(cxListAdd(list, &testdata.data[i]), 0); 2.95 - CX_TEST_ASSERT(cxListSize(list) == len); 2.96 - cx_for_n (i, len) EXPECT_EQ(*(int *) cxListAt(list, i), testdata.data[i]); 2.97 - cx_for_n (i, len) ++testdata.data[i]; 2.98 - if (as_pointer) { 2.99 - cx_for_n (i, len) EXPECT_EQ(*(int *) cxListAt(list, i), testdata.data[i]); 2.100 - } else { 2.101 - cx_for_n (i, len) EXPECT_EQ(*(int *) cxListAt(list, i), testdata.data[i] - 1); 2.102 - } 2.103 - } 2.104 - 2.105 - static void verifyInsert(CxList *list) { 2.106 - int a = 5, b = 47, c = 13, d = 42; 2.107 - 2.108 - EXPECT_NE(cxListInsert(list, 1, &a), 0); 2.109 - EXPECT_EQ(cxListSize(list), 0); 2.110 - EXPECT_EQ(cxListInsert(list, 0, &a), 0); 2.111 - EXPECT_EQ(cxListSize(list), 1); 2.112 - EXPECT_EQ(cxListInsert(list, 0, &b), 0); 2.113 - EXPECT_EQ(cxListSize(list), 2); 2.114 - EXPECT_EQ(cxListInsert(list, 1, &c), 0); 2.115 - EXPECT_EQ(cxListSize(list), 3); 2.116 - EXPECT_EQ(cxListInsert(list, 3, &d), 0); 2.117 - 2.118 - CX_TEST_ASSERT(cxListSize(list) == 4); 2.119 - 2.120 - EXPECT_EQ(*(int *) cxListAt(list, 0), 47); 2.121 - EXPECT_EQ(*(int *) cxListAt(list, 1), 13); 2.122 - EXPECT_EQ(*(int *) cxListAt(list, 2), 5); 2.123 - EXPECT_EQ(*(int *) cxListAt(list, 3), 42); 2.124 - } 2.125 - 2.126 - static void verifyInsertArray( 2.127 - CxList *list, 2.128 - bool pointers = false 2.129 - ) { 2.130 - int a[5] = {5, 47, 11, 13, 42}; 2.131 - int b[5] = {9, 18, 72, 50, 7}; 2.132 - int *aptr[5]; 2.133 - int *bptr[5]; 2.134 - cx_for_n(i, 5) { 2.135 - aptr[i] = &a[i]; 2.136 - bptr[i] = &b[i]; 2.137 - } 2.138 - 2.139 - size_t inserted; 2.140 - 2.141 - if (pointers) { 2.142 - inserted = cxListInsertArray(list, 0, aptr, 5); 2.143 - } else { 2.144 - inserted = cxListInsertArray(list, 0, a, 5); 2.145 - } 2.146 - CX_TEST_ASSERT(inserted == 5); 2.147 - EXPECT_EQ(*(int *) cxListAt(list, 0), 5); 2.148 - EXPECT_EQ(*(int *) cxListAt(list, 1), 47); 2.149 - EXPECT_EQ(*(int *) cxListAt(list, 2), 11); 2.150 - EXPECT_EQ(*(int *) cxListAt(list, 3), 13); 2.151 - EXPECT_EQ(*(int *) cxListAt(list, 4), 42); 2.152 - if (pointers) { 2.153 - inserted = cxListInsertArray(list, 3, bptr, 5); 2.154 - } else { 2.155 - inserted = cxListInsertArray(list, 3, b, 5); 2.156 - } 2.157 - CX_TEST_ASSERT(inserted == 5); 2.158 - EXPECT_EQ(*(int *) cxListAt(list, 0), 5); 2.159 - EXPECT_EQ(*(int *) cxListAt(list, 1), 47); 2.160 - EXPECT_EQ(*(int *) cxListAt(list, 2), 11); 2.161 - EXPECT_EQ(*(int *) cxListAt(list, 3), 9); 2.162 - EXPECT_EQ(*(int *) cxListAt(list, 4), 18); 2.163 - EXPECT_EQ(*(int *) cxListAt(list, 5), 72); 2.164 - EXPECT_EQ(*(int *) cxListAt(list, 6), 50); 2.165 - EXPECT_EQ(*(int *) cxListAt(list, 7), 7); 2.166 - EXPECT_EQ(*(int *) cxListAt(list, 8), 13); 2.167 - EXPECT_EQ(*(int *) cxListAt(list, 9), 42); 2.168 - } 2.169 - 2.170 - void verifyRemove(CxList *list) const { 2.171 - EXPECT_EQ(cxListRemove(list, 2), 0); 2.172 - EXPECT_EQ(cxListRemove(list, 4), 0); 2.173 - EXPECT_EQ(cxListSize(list), testdata_len - 2); 2.174 - EXPECT_EQ(*(int *) cxListAt(list, 0), testdata.data[0]); 2.175 - EXPECT_EQ(*(int *) cxListAt(list, 1), testdata.data[1]); 2.176 - EXPECT_EQ(*(int *) cxListAt(list, 2), testdata.data[3]); 2.177 - EXPECT_EQ(*(int *) cxListAt(list, 3), testdata.data[4]); 2.178 - EXPECT_EQ(*(int *) cxListAt(list, 4), testdata.data[6]); 2.179 - 2.180 - EXPECT_EQ(cxListRemove(list, 0), 0); 2.181 - EXPECT_EQ(cxListSize(list), testdata_len - 3); 2.182 - EXPECT_EQ(*(int *) cxListAt(list, 0), testdata.data[1]); 2.183 - EXPECT_EQ(*(int *) cxListAt(list, 1), testdata.data[3]); 2.184 - 2.185 - EXPECT_NE(cxListRemove(list, testdata_len), 0); 2.186 - } 2.187 - 2.188 - void verifyFindRemove(CxList *list) const { 2.189 - size_t exp = rand() % testdata_len; // NOLINT(cert-msc50-cpp) 2.190 - int val = testdata.data[exp]; 2.191 - // randomly picked number could occur earlier in list - find first position 2.192 - cx_for_n (i, exp) { 2.193 - if (testdata.data[i] == val) { 2.194 - exp = i; 2.195 - break; 2.196 - } 2.197 - } 2.198 - EXPECT_EQ(cxListSize(list), testdata_len); 2.199 - EXPECT_EQ(cxListFind(list, &val), exp); 2.200 - EXPECT_EQ(cxListFindRemove(list, &val), exp); 2.201 - EXPECT_EQ(cxListSize(list), testdata_len - 1); 2.202 - EXPECT_NE(cxListFind(list, &val), exp); 2.203 - 2.204 - int notinlist = -1; 2.205 - EXPECT_LT(cxListFindRemove(list, ¬inlist), 0); 2.206 - EXPECT_EQ(cxListSize(list), testdata_len - 1); 2.207 - } 2.208 - 2.209 - static void verifyClear(CxList *list) { 2.210 - cxListClear(list); 2.211 - EXPECT_EQ(0, cxListSize(list)); 2.212 - } 2.213 - 2.214 - static unsigned destr_test_ctr; 2.215 - static int destr_last_value; 2.216 - 2.217 - static void simple_destr_test_fun(void *data) { 2.218 - auto ptr = (int *) data; 2.219 - destr_last_value = *ptr; 2.220 - *ptr = destr_last_value + 1; 2.221 - destr_test_ctr++; 2.222 - } 2.223 - 2.224 - static void advanced_destr_test_fun( 2.225 - [[maybe_unused]] void *u, 2.226 - void *data 2.227 - ) { 2.228 - simple_destr_test_fun(data); 2.229 - } 2.230 - 2.231 - void verifyAnyDestructor(CxList *list) { 2.232 - int off = cxListIsStoringPointers(list) ? 1 : 0; 2.233 - 2.234 - cxListRemove(list, 15); 2.235 - EXPECT_EQ(1, destr_test_ctr); 2.236 - EXPECT_EQ(testdata.data[15], destr_last_value + off); 2.237 - EXPECT_EQ(testdata_len - destr_test_ctr, cxListSize(list)); 2.238 - cxListRemove(list, 47); 2.239 - EXPECT_EQ(2, destr_test_ctr); 2.240 - EXPECT_EQ(testdata.data[48], destr_last_value + off); 2.241 - EXPECT_EQ(testdata_len - destr_test_ctr, cxListSize(list)); 2.242 - 2.243 - auto iter = cxListMutIteratorAt(list, 7); 2.244 - cxIteratorNext(iter); 2.245 - EXPECT_EQ(2, destr_test_ctr); 2.246 - EXPECT_EQ(testdata.data[48], destr_last_value + off); 2.247 - EXPECT_EQ(testdata_len - destr_test_ctr, cxListSize(list)); 2.248 - cxIteratorFlagRemoval(iter); 2.249 - cxIteratorNext(iter); 2.250 - EXPECT_EQ(3, destr_test_ctr); 2.251 - EXPECT_EQ(testdata.data[8], destr_last_value + off); 2.252 - EXPECT_EQ(testdata_len - destr_test_ctr, cxListSize(list)); 2.253 - 2.254 - iter = cxListMutBackwardsIteratorAt(list, 5); 2.255 - cxIteratorNext(iter); 2.256 - EXPECT_EQ(3, destr_test_ctr); 2.257 - EXPECT_EQ(testdata.data[8], destr_last_value + off); 2.258 - EXPECT_EQ(testdata_len - destr_test_ctr, cxListSize(list)); 2.259 - cxIteratorFlagRemoval(iter); 2.260 - cxIteratorNext(iter); 2.261 - EXPECT_EQ(4, destr_test_ctr); 2.262 - EXPECT_EQ(testdata.data[4], destr_last_value + off); 2.263 - EXPECT_EQ(testdata_len - destr_test_ctr, cxListSize(list)); 2.264 - 2.265 - cxListClear(list); 2.266 - EXPECT_EQ(testdata_len, destr_test_ctr); 2.267 - EXPECT_EQ(testdata.data[testdata_len - 1], destr_last_value + off); 2.268 - } 2.269 - 2.270 - void verifySimpleDestructor(CxList *list) { 2.271 - destr_test_ctr = 0; 2.272 - list->simple_destructor = simple_destr_test_fun; 2.273 - verifyAnyDestructor(list); 2.274 - } 2.275 - 2.276 - void verifyAdvancedDestructor(CxList *list) { 2.277 - destr_test_ctr = 0; 2.278 - list->advanced_destructor = advanced_destr_test_fun; 2.279 - verifyAnyDestructor(list); 2.280 - } 2.281 - 2.282 - static void verifySwap(CxList *list) { 2.283 - CX_TEST_ASSERT(cxListSize(list) == 0); 2.284 - 2.285 - int original[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; 2.286 - int swapped[16] = {8, 4, 14, 3, 1, 5, 9, 12, 0, 6, 11, 10, 7, 15, 2, 13}; 2.287 - 2.288 - // we have to add the items one by one, because it could be a pointer list 2.289 - cx_for_n(i, 16) { 2.290 - cxListAdd(list, &original[i]); 2.291 - } 2.292 - 2.293 - int result; 2.294 - 2.295 - // execute the test two times with different item sizes 2.296 - result = cxListSwap(list, 1, 4); 2.297 - EXPECT_EQ(0, result); 2.298 - result = cxListSwap(list, 2, 14); 2.299 - EXPECT_EQ(0, result); 2.300 - result = cxListSwap(list, 9, 6); 2.301 - EXPECT_EQ(0, result); 2.302 - result = cxListSwap(list, 3, 3); 2.303 - EXPECT_EQ(0, result); 2.304 - result = cxListSwap(list, 10, 11); 2.305 - EXPECT_EQ(0, result); 2.306 - result = cxListSwap(list, 8, 0); 2.307 - EXPECT_EQ(0, result); 2.308 - result = cxListSwap(list, 7, 12); 2.309 - EXPECT_EQ(0, result); 2.310 - result = cxListSwap(list, 13, 15); 2.311 - EXPECT_EQ(0, result); 2.312 - 2.313 - result = cxListSwap(list, 5, 16); 2.314 - CX_TEST_ASSERT(0 != result); 2.315 - result = cxListSwap(list, 16, 6); 2.316 - CX_TEST_ASSERT(0 != result); 2.317 - result = cxListSwap(list, 16, 17); 2.318 - CX_TEST_ASSERT(0 != result); 2.319 - 2.320 - auto iter = cxListIterator(list); 2.321 - cx_foreach(int*, e, iter) { 2.322 - EXPECT_EQ(*e, swapped[iter.index]); 2.323 - } 2.324 - iter = cxListBackwardsIterator(list); 2.325 - cx_foreach(int*, e, iter) { 2.326 - EXPECT_EQ(*e, swapped[iter.index]); 2.327 - } 2.328 - } 2.329 - 2.330 - void verifyAt(CxList *list) const { 2.331 - auto len = testdata_len; 2.332 - EXPECT_EQ(cxListSize(list), len); 2.333 - cx_for_n (i, len) { 2.334 - EXPECT_EQ(*(int *) cxListAt(list, i), testdata.data[i]); 2.335 - } 2.336 - EXPECT_EQ(cxListAt(list, cxListSize(list)), NULL); 2.337 - } 2.338 - 2.339 - void verifyFind(CxList *list) const { 2.340 - cx_for_n (attempt, 25) { 2.341 - size_t exp = rand() % testdata_len; // NOLINT(cert-msc50-cpp) 2.342 - int val = testdata.data[exp]; 2.343 - // randomly picked number could occur earlier in list - find first position 2.344 - cx_for_n (i, exp) { 2.345 - if (testdata.data[i] == val) { 2.346 - exp = i; 2.347 - break; 2.348 - } 2.349 - } 2.350 - EXPECT_EQ(cxListFind(list, &val), exp); 2.351 - } 2.352 - 2.353 - int notinlist = -1; 2.354 - EXPECT_LT(cxListFind(list, ¬inlist), 0); 2.355 - } 2.356 - 2.357 - void verifySort(CxList *list) const { 2.358 - std::array<int, testdata_len> expected{}; 2.359 - std::partial_sort_copy(testdata.data.begin(), testdata.data.end(), expected.begin(), expected.end()); 2.360 - cxListSort(list); 2.361 - cx_for_n (i, testdata_len) CX_TEST_ASSERT(*(int *) cxListAt(list, i) == expected[i]); 2.362 - } 2.363 - 2.364 - void verifyIterator(CxList *list) const { 2.365 - auto iter = cxListIterator(list); 2.366 - size_t i = 0; 2.367 - cx_foreach(int*, x, iter) { 2.368 - CX_TEST_ASSERT(i == iter.index); 2.369 - EXPECT_EQ(*x, testdata.data[iter.index]); 2.370 - i++; 2.371 - } 2.372 - CX_TEST_ASSERT(i == cxListSize(list)); 2.373 - iter = cxListBackwardsIterator(list); 2.374 - cx_foreach(int*, x, iter) { 2.375 - CX_TEST_ASSERT(i - 1 == iter.index); 2.376 - EXPECT_EQ(*x, testdata.data[iter.index]); 2.377 - i--; 2.378 - } 2.379 - CX_TEST_ASSERT(i == 0); 2.380 - auto len = testdata_len; 2.381 - i = len / 2; 2.382 - auto mut_iter = cxListMutIteratorAt(list, i); 2.383 - size_t j = 0; 2.384 - cx_foreach(int*, x, mut_iter) { 2.385 - CX_TEST_ASSERT(mut_iter.index == len / 2 + j / 2); 2.386 - CX_TEST_ASSERT(*x == testdata.data[i]); 2.387 - if (i % 2 == 1) cxIteratorFlagRemoval(mut_iter); 2.388 - i++; 2.389 - j++; 2.390 - } 2.391 - CX_TEST_ASSERT(i == len); 2.392 - i = len / 2; 2.393 - j = 0; 2.394 - mut_iter = cxListMutBackwardsIteratorAt(list, i - 1); 2.395 - cx_foreach(int*, x, mut_iter) { 2.396 - CX_TEST_ASSERT(mut_iter.index == len / 2 - 1 - j); 2.397 - CX_TEST_ASSERT(*x == testdata.data[i - 1]); 2.398 - if (i % 2 == 0) cxIteratorFlagRemoval(mut_iter); 2.399 - i--; 2.400 - j++; 2.401 - } 2.402 - CX_TEST_ASSERT(i == 0); 2.403 - CX_TEST_ASSERT(cxListSize(list) == len / 2); 2.404 - cx_for_n(j, len / 2) ASSERT_EQ(*(int *) cxListAt(list, j), testdata.data[j * 2]); 2.405 - } 2.406 - 2.407 - static void verifyInsertViaIterator(CxList *list) { 2.408 - int newdata[] = {10, 20, 30, 40, 50}; 2.409 - 2.410 - auto iter = cxListMutIteratorAt(list, 2); 2.411 - CX_TEST_ASSERT(cxIteratorValid(iter)); 2.412 - EXPECT_EQ(iter.index, 2); 2.413 - EXPECT_EQ(*(int *) cxIteratorCurrent(iter), 2); 2.414 - cxListInsertAfter(&iter, &newdata[0]); 2.415 - CX_TEST_ASSERT(cxIteratorValid(iter)); 2.416 - EXPECT_EQ(iter.index, 2); 2.417 - EXPECT_EQ(*(int *) cxIteratorCurrent(iter), 2); 2.418 - cxListInsertBefore(&iter, &newdata[1]); 2.419 - CX_TEST_ASSERT(cxIteratorValid(iter)); 2.420 - EXPECT_EQ(iter.index, 3); 2.421 - EXPECT_EQ(*(int *) cxIteratorCurrent(iter), 2); 2.422 - 2.423 - iter = cxListMutIterator(list); 2.424 - cxListInsertBefore(&iter, &newdata[2]); 2.425 - CX_TEST_ASSERT(cxIteratorValid(iter)); 2.426 - EXPECT_EQ(iter.index, 1); 2.427 - EXPECT_EQ(*(int *) cxIteratorCurrent(iter), 0); 2.428 - iter = cxListMutIteratorAt(list, cxListSize(list)); 2.429 - cxListInsertBefore(&iter, &newdata[3]); 2.430 - CX_TEST_ASSERT(!cxIteratorValid(iter)); 2.431 - EXPECT_EQ(iter.index, 9); 2.432 - iter = cxListMutIteratorAt(list, cxListSize(list)); 2.433 - cxListInsertAfter(&iter, &newdata[4]); 2.434 - CX_TEST_ASSERT(!cxIteratorValid(iter)); 2.435 - EXPECT_EQ(iter.index, 10); 2.436 - 2.437 - int expdata[] = {30, 0, 1, 20, 2, 10, 3, 4, 40, 50}; 2.438 - cx_for_n (j, 10) EXPECT_EQ(*(int *) cxListAt(list, j), expdata[j]); 2.439 - } 2.440 - 2.441 - void verifyReverse(CxList *list) const { 2.442 - cxListReverse(list); 2.443 - cx_for_n(i, testdata_len) { 2.444 - ASSERT_EQ(*(int *) cxListAt(list, i), testdata.data[testdata_len - 1 - i]); 2.445 - } 2.446 - } 2.447 - 2.448 - static void verifyCompare( 2.449 - CxList *left, 2.450 - CxList *right 2.451 - ) { 2.452 - EXPECT_EQ(cxListCompare(left, right), 0); 2.453 - int x = 42; 2.454 - cxListAdd(left, &x); 2.455 - ASSERT_GT(cxListSize(left), cxListSize(right)); 2.456 - EXPECT_GT(cxListCompare(left, right), 0); 2.457 - EXPECT_LT(cxListCompare(right, left), 0); 2.458 - cxListAdd(right, &x); 2.459 - CX_TEST_ASSERT(cxListSize(left) == cxListSize(right)); 2.460 - EXPECT_EQ(cxListCompare(left, right), 0); 2.461 - int a = 5, b = 10; 2.462 - cxListInsert(left, 15, &a); 2.463 - cxListInsert(right, 15, &b); 2.464 - CX_TEST_ASSERT(cxListSize(left) == cxListSize(right)); 2.465 - EXPECT_LT(cxListCompare(left, right), 0); 2.466 - EXPECT_GT(cxListCompare(right, left), 0); 2.467 - *(int *) cxListAt(left, 15) = 10; 2.468 - EXPECT_EQ(cxListCompare(left, right), 0); 2.469 - } 2.470 -}; 2.471 - 2.472 -unsigned HighLevelTest::destr_test_ctr = 0; 2.473 -int HighLevelTest::destr_last_value = 0; 2.474 - 2.475 -class LinkedList : public HighLevelTest { 2.476 -}; 2.477 - 2.478 -class PointerLinkedList : public HighLevelTest { 2.479 -}; 2.480 - 2.481 -class ArrayList : public HighLevelTest { 2.482 -}; 2.483 - 2.484 -class PointerArrayList : public HighLevelTest { 2.485 -}; 2.486 - 2.487 - 2.488 -TEST_F(LinkedList, cxListAdd) { 2.489 - auto list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int))); 2.490 - verifyAdd(list, false); 2.491 -} 2.492 - 2.493 -TEST_F(PointerLinkedList, cxListAdd) { 2.494 - auto list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS)); 2.495 - verifyAdd(list, true); 2.496 -} 2.497 - 2.498 -TEST_F(ArrayList, cxListAdd) { 2.499 - auto list = autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, sizeof(int), 8)); 2.500 - verifyAdd(list, false); 2.501 -} 2.502 - 2.503 -TEST_F(PointerArrayList, cxListAdd) { 2.504 - auto list = autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS, 8)); 2.505 - verifyAdd(list, true); 2.506 -} 2.507 - 2.508 -TEST_F(LinkedList, cxListInsert) { 2.509 - verifyInsert(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int)))); 2.510 -} 2.511 - 2.512 -TEST_F(PointerLinkedList, cxListInsert) { 2.513 - verifyInsert(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS))); 2.514 -} 2.515 - 2.516 -TEST_F(ArrayList, cxListInsert) { 2.517 - verifyInsert(autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, sizeof(int), 2))); 2.518 -} 2.519 - 2.520 -TEST_F(PointerArrayList, cxListInsert) { 2.521 - verifyInsert(autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS, 2))); 2.522 -} 2.523 - 2.524 -TEST_F(LinkedList, cxListInsertArray) { 2.525 - verifyInsertArray(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int)))); 2.526 -} 2.527 - 2.528 -TEST_F(PointerLinkedList, cxListInsertArray) { 2.529 - verifyInsertArray(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS)), true); 2.530 -} 2.531 - 2.532 -TEST_F(ArrayList, cxListInsertArray) { 2.533 - verifyInsertArray(autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, sizeof(int), 4))); 2.534 -} 2.535 - 2.536 -TEST_F(PointerArrayList, cxListInsertArray) { 2.537 - verifyInsertArray(autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS, 4)), true); 2.538 -} 2.539 - 2.540 -TEST_F(LinkedList, cxListRemove) { 2.541 - verifyRemove(linkedListFromTestData()); 2.542 -} 2.543 - 2.544 -TEST_F(PointerLinkedList, cxListRemove) { 2.545 - verifyRemove(pointerLinkedListFromTestData()); 2.546 -} 2.547 - 2.548 -TEST_F(ArrayList, cxListRemove) { 2.549 - verifyRemove(arrayListFromTestData()); 2.550 -} 2.551 - 2.552 -TEST_F(PointerArrayList, cxListRemove) { 2.553 - verifyRemove(pointerArrayListFromTestData()); 2.554 -} 2.555 - 2.556 -TEST_F(LinkedList, cxListFindRemove) { 2.557 - verifyFindRemove(linkedListFromTestData()); 2.558 -} 2.559 - 2.560 -TEST_F(PointerLinkedList, cxListFindRemove) { 2.561 - verifyFindRemove(pointerLinkedListFromTestData()); 2.562 -} 2.563 - 2.564 -TEST_F(ArrayList, cxListFindRemove) { 2.565 - verifyFindRemove(arrayListFromTestData()); 2.566 -} 2.567 - 2.568 -TEST_F(PointerArrayList, cxListFindRemove) { 2.569 - verifyFindRemove(pointerArrayListFromTestData()); 2.570 -} 2.571 - 2.572 -TEST_F(LinkedList, cxListClear) { 2.573 - verifyClear(linkedListFromTestData()); 2.574 -} 2.575 - 2.576 -TEST_F(PointerLinkedList, cxListClear) { 2.577 - verifyClear(pointerLinkedListFromTestData()); 2.578 -} 2.579 - 2.580 -TEST_F(ArrayList, cxListClear) { 2.581 - verifyClear(arrayListFromTestData()); 2.582 -} 2.583 - 2.584 -TEST_F(PointerArrayList, cxListClear) { 2.585 - verifyClear(pointerArrayListFromTestData()); 2.586 -} 2.587 - 2.588 -TEST_F(LinkedList, cxListSwap) { 2.589 - verifySwap(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int)))); 2.590 -} 2.591 - 2.592 -TEST_F(PointerLinkedList, cxListSwap) { 2.593 - verifySwap(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS))); 2.594 -} 2.595 - 2.596 -TEST_F(ArrayList, cxListSwap) { 2.597 - verifySwap(autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, sizeof(int), 16))); 2.598 -} 2.599 - 2.600 -TEST_F(PointerArrayList, cxListSwap) { 2.601 - verifySwap(autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS, 16))); 2.602 -} 2.603 - 2.604 -TEST_F(LinkedList, cxListSwapNoSBO) { 2.605 - CX_DISABLE_LINKED_LIST_SWAP_SBO = true; 2.606 - verifySwap(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int)))); 2.607 - CX_DISABLE_LINKED_LIST_SWAP_SBO = false; 2.608 -} 2.609 - 2.610 -TEST_F(PointerLinkedList, cxListSwapNoSBO) { 2.611 - CX_DISABLE_LINKED_LIST_SWAP_SBO = true; 2.612 - verifySwap(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS))); 2.613 - CX_DISABLE_LINKED_LIST_SWAP_SBO = false; 2.614 -} 2.615 - 2.616 -TEST_F(LinkedList, cxListAt) { 2.617 - verifyAt(linkedListFromTestData()); 2.618 -} 2.619 - 2.620 -TEST_F(PointerLinkedList, cxListAt) { 2.621 - verifyAt(pointerLinkedListFromTestData()); 2.622 -} 2.623 - 2.624 -TEST_F(ArrayList, cxListAt) { 2.625 - verifyAt(arrayListFromTestData()); 2.626 -} 2.627 - 2.628 -TEST_F(PointerArrayList, cxListAt) { 2.629 - verifyAt(pointerArrayListFromTestData()); 2.630 -} 2.631 - 2.632 -TEST_F(LinkedList, cxListFind) { 2.633 - verifyFind(linkedListFromTestData()); 2.634 -} 2.635 - 2.636 -TEST_F(PointerLinkedList, cxListFind) { 2.637 - verifyFind(pointerLinkedListFromTestData()); 2.638 -} 2.639 - 2.640 -TEST_F(ArrayList, cxListFind) { 2.641 - verifyFind(arrayListFromTestData()); 2.642 -} 2.643 - 2.644 -TEST_F(PointerArrayList, cxListFind) { 2.645 - verifyFind(pointerArrayListFromTestData()); 2.646 -} 2.647 - 2.648 -TEST_F(LinkedList, cxListSort) { 2.649 - verifySort(linkedListFromTestData()); 2.650 -} 2.651 - 2.652 -TEST_F(PointerLinkedList, cxListSort) { 2.653 - verifySort(pointerLinkedListFromTestData()); 2.654 -} 2.655 - 2.656 -TEST_F(ArrayList, cxListSort) { 2.657 - verifySort(arrayListFromTestData()); 2.658 -} 2.659 - 2.660 -TEST_F(PointerArrayList, cxListSort) { 2.661 - verifySort(pointerArrayListFromTestData()); 2.662 -} 2.663 - 2.664 -TEST_F(LinkedList, Iterator) { 2.665 - verifyIterator(linkedListFromTestData()); 2.666 -} 2.667 - 2.668 -TEST_F(PointerLinkedList, Iterator) { 2.669 - verifyIterator(pointerLinkedListFromTestData()); 2.670 -} 2.671 - 2.672 -TEST_F(ArrayList, Iterator) { 2.673 - verifyIterator(arrayListFromTestData()); 2.674 -} 2.675 - 2.676 -TEST_F(PointerArrayList, Iterator) { 2.677 - verifyIterator(pointerArrayListFromTestData()); 2.678 -} 2.679 - 2.680 -TEST_F(LinkedList, InsertViaIterator) { 2.681 - int fivenums[] = {0, 1, 2, 3, 4, 5}; 2.682 - CxList *list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int))); 2.683 - cxListAddArray(list, fivenums, 5); 2.684 - verifyInsertViaIterator(list); 2.685 -} 2.686 - 2.687 -TEST_F(PointerLinkedList, InsertViaIterator) { 2.688 - int fivenums[] = {0, 1, 2, 3, 4, 5}; 2.689 - auto list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS)); 2.690 - // note: cannot use cxListAddArray() because we don't have a list of pointers 2.691 - cx_for_n(i, 5) cxListAdd(list, &fivenums[i]); 2.692 - verifyInsertViaIterator(list); 2.693 -} 2.694 - 2.695 -TEST_F(ArrayList, InsertViaIterator) { 2.696 - int fivenums[] = {0, 1, 2, 3, 4, 5}; 2.697 - auto list = autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, sizeof(int), 4)); 2.698 - cxListAddArray(list, fivenums, 5); 2.699 - verifyInsertViaIterator(list); 2.700 -} 2.701 - 2.702 -TEST_F(PointerArrayList, InsertViaIterator) { 2.703 - int fivenums[] = {0, 1, 2, 3, 4, 5}; 2.704 - auto list = autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS, 4)); 2.705 - // note: cannot use cxListAddArray() because we don't have a list of pointers 2.706 - cx_for_n(i, 5) cxListAdd(list, &fivenums[i]); 2.707 - verifyInsertViaIterator(list); 2.708 -} 2.709 - 2.710 -TEST_F(LinkedList, cxListReverse) { 2.711 - verifyReverse(linkedListFromTestData()); 2.712 -} 2.713 - 2.714 -TEST_F(PointerLinkedList, cxListReverse) { 2.715 - verifyReverse(pointerLinkedListFromTestData()); 2.716 -} 2.717 - 2.718 -TEST_F(ArrayList, cxListReverse) { 2.719 - verifyReverse(arrayListFromTestData()); 2.720 -} 2.721 - 2.722 -TEST_F(PointerArrayList, cxListReverse) { 2.723 - verifyReverse(pointerArrayListFromTestData()); 2.724 -} 2.725 - 2.726 -TEST_F(LinkedList, cxListCompare) { 2.727 - auto left = linkedListFromTestData(); 2.728 - auto right = linkedListFromTestData(); 2.729 - verifyCompare(left, right); 2.730 -} 2.731 - 2.732 -TEST_F(LinkedList, cxListCompareWithPtrList) { 2.733 - auto left = linkedListFromTestData(); 2.734 - auto right = pointerLinkedListFromTestData(); 2.735 - verifyCompare(left, right); 2.736 -} 2.737 - 2.738 -TEST_F(LinkedList, cxListCompareWithArrayList) { 2.739 - auto left = linkedListFromTestData(); 2.740 - auto right = arrayListFromTestData(); 2.741 - verifyCompare(left, right); 2.742 -} 2.743 - 2.744 -TEST_F(LinkedList, cxListCompareWithPtrArrayList) { 2.745 - auto left = linkedListFromTestData(); 2.746 - auto right = pointerArrayListFromTestData(); 2.747 - verifyCompare(left, right); 2.748 -} 2.749 - 2.750 -TEST_F(PointerLinkedList, cxListCompare) { 2.751 - auto left = pointerLinkedListFromTestData(); 2.752 - auto right = pointerLinkedListFromTestData(); 2.753 - verifyCompare(left, right); 2.754 -} 2.755 - 2.756 -TEST_F(PointerLinkedList, cxListCompareWithNormalList) { 2.757 - auto left = pointerLinkedListFromTestData(); 2.758 - auto right = linkedListFromTestData(); 2.759 - verifyCompare(left, right); 2.760 -} 2.761 - 2.762 -TEST_F(PointerLinkedList, cxListCompareWithArrayList) { 2.763 - auto left = pointerLinkedListFromTestData(); 2.764 - auto right = arrayListFromTestData(); 2.765 - verifyCompare(left, right); 2.766 -} 2.767 - 2.768 -TEST_F(PointerLinkedList, cxListCompareWithPtrArrayList) { 2.769 - auto left = pointerLinkedListFromTestData(); 2.770 - auto right = pointerArrayListFromTestData(); 2.771 - verifyCompare(left, right); 2.772 -} 2.773 - 2.774 -TEST_F(ArrayList, cxListCompare) { 2.775 - auto left = arrayListFromTestData(); 2.776 - auto right = arrayListFromTestData(); 2.777 - verifyCompare(left, right); 2.778 -} 2.779 - 2.780 -TEST_F(ArrayList, cxListCompareWithPtrList) { 2.781 - auto left = arrayListFromTestData(); 2.782 - auto right = pointerLinkedListFromTestData(); 2.783 - verifyCompare(left, right); 2.784 -} 2.785 - 2.786 -TEST_F(ArrayList, cxListCompareWithNormalList) { 2.787 - auto left = arrayListFromTestData(); 2.788 - auto right = linkedListFromTestData(); 2.789 - verifyCompare(left, right); 2.790 -} 2.791 - 2.792 -TEST_F(ArrayList, cxListCompareWithPtrArrayList) { 2.793 - auto left = arrayListFromTestData(); 2.794 - auto right = pointerArrayListFromTestData(); 2.795 - verifyCompare(left, right); 2.796 -} 2.797 - 2.798 -TEST_F(PointerArrayList, cxListCompare) { 2.799 - auto left = pointerArrayListFromTestData(); 2.800 - auto right = pointerArrayListFromTestData(); 2.801 - verifyCompare(left, right); 2.802 -} 2.803 - 2.804 -TEST_F(PointerArrayList, cxListCompareWithPtrList) { 2.805 - auto left = pointerArrayListFromTestData(); 2.806 - auto right = pointerLinkedListFromTestData(); 2.807 - verifyCompare(left, right); 2.808 -} 2.809 - 2.810 -TEST_F(PointerArrayList, cxListCompareWithNormalList) { 2.811 - auto left = pointerArrayListFromTestData(); 2.812 - auto right = linkedListFromTestData(); 2.813 - verifyCompare(left, right); 2.814 -} 2.815 - 2.816 -TEST_F(PointerArrayList, cxListCompareWithNormalArrayList) { 2.817 - auto left = pointerArrayListFromTestData(); 2.818 - auto right = arrayListFromTestData(); 2.819 - verifyCompare(left, right); 2.820 -} 2.821 - 2.822 -TEST_F(LinkedList, SimpleDestructor) { 2.823 - verifySimpleDestructor(linkedListFromTestData()); 2.824 -} 2.825 - 2.826 -TEST_F(PointerLinkedList, SimpleDestructor) { 2.827 - verifySimpleDestructor(pointerLinkedListFromTestData()); 2.828 -} 2.829 - 2.830 -TEST_F(ArrayList, SimpleDestructor) { 2.831 - verifySimpleDestructor(arrayListFromTestData()); 2.832 -} 2.833 - 2.834 -TEST_F(PointerArrayList, SimpleDestructor) { 2.835 - verifySimpleDestructor(pointerArrayListFromTestData()); 2.836 -} 2.837 - 2.838 -TEST_F(LinkedList, AdvancedDestructor) { 2.839 - verifyAdvancedDestructor(linkedListFromTestData()); 2.840 -} 2.841 - 2.842 -TEST_F(PointerLinkedList, AdvancedDestructor) { 2.843 - verifyAdvancedDestructor(pointerLinkedListFromTestData()); 2.844 -} 2.845 - 2.846 -TEST_F(ArrayList, AdvancedDestructor) { 2.847 - verifyAdvancedDestructor(arrayListFromTestData()); 2.848 -} 2.849 - 2.850 -TEST_F(PointerArrayList, AdvancedDestructor) { 2.851 - verifyAdvancedDestructor(pointerArrayListFromTestData()); 2.852 -} 2.853 - 2.854 - 2.855 -
