1.1 --- a/tests/test_list.cpp Fri Jan 12 20:13:13 2024 +0100
1.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000
1.3 @@ -1,852 +0,0 @@
1.4 -/*
1.5 - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
1.6 - *
1.7 - * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.
1.8 - *
1.9 - * Redistribution and use in source and binary forms, with or without
1.10 - * modification, are permitted provided that the following conditions are met:
1.11 - *
1.12 - * 1. Redistributions of source code must retain the above copyright
1.13 - * notice, this list of conditions and the following disclaimer.
1.14 - *
1.15 - * 2. Redistributions in binary form must reproduce the above copyright
1.16 - * notice, this list of conditions and the following disclaimer in the
1.17 - * documentation and/or other materials provided with the distribution.
1.18 - *
1.19 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
1.20 - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
1.21 - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
1.22 - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
1.23 - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
1.24 - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
1.25 - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
1.26 - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
1.27 - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
1.28 - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
1.29 - * POSSIBILITY OF SUCH DAMAGE.
1.30 - */
1.31 -
1.32 -#include "cx/linked_list.h"
1.33 -#include "cx/array_list.h"
1.34 -#include "cx/utils.h"
1.35 -#include "cx/compare.h"
1.36 -#include "util_allocator.h"
1.37 -
1.38 -#include <gtest/gtest.h>
1.39 -#include <array>
1.40 -#include <vector>
1.41 -#include <unordered_set>
1.42 -#include <algorithm>
1.43 -
1.44 -
1.45 -class HighLevelTest : public ::testing::Test {
1.46 - mutable std::unordered_set<CxList *> lists;
1.47 -protected:
1.48 - CxTestingAllocator testingAllocator;
1.49 -
1.50 - void TearDown() override {
1.51 - for (auto &&l: lists) cxListDestroy(l);
1.52 - CX_TEST_ASSERT(testingAllocator.verify());
1.53 - }
1.54 -
1.55 - static constexpr size_t testdata_len = 250;
1.56 - int_test_data<testdata_len> testdata;
1.57 -
1.58 - auto autofree(CxList *list) const -> CxList * {
1.59 - if (list != NULL) lists.insert(list);
1.60 - return list;
1.61 - }
1.62 -
1.63 - auto linkedListFromTestData() const -> CxList * {
1.64 - auto list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int)));
1.65 - cxListAddArray(list, testdata.data.data(), testdata_len);
1.66 - return list;
1.67 - }
1.68 -
1.69 - auto pointerLinkedListFromTestData() const -> CxList * {
1.70 - auto list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS));
1.71 - // note: cannot use cxListAddArray() because we don't have a list of pointers
1.72 - cx_for_n(i, testdata_len) cxListAdd(list, &testdata.data[i]);
1.73 - return list;
1.74 - }
1.75 -
1.76 - auto arrayListFromTestData() const -> CxList * {
1.77 - auto list = autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, sizeof(int), testdata_len));
1.78 - cxListAddArray(list, testdata.data.data(), testdata_len);
1.79 - return list;
1.80 - }
1.81 -
1.82 - auto pointerArrayListFromTestData() const -> CxList * {
1.83 - auto list = autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS, 256));
1.84 - // note: cannot use cxListAddArray() because we don't have a list of pointers
1.85 - cx_for_n(i, testdata_len) cxListAdd(list, &testdata.data[i]);
1.86 - return list;
1.87 - }
1.88 -
1.89 - void verifyAdd(
1.90 - CxList *list,
1.91 - bool as_pointer
1.92 - ) {
1.93 - auto len = testdata_len;
1.94 - cx_for_n (i, len) EXPECT_EQ(cxListAdd(list, &testdata.data[i]), 0);
1.95 - CX_TEST_ASSERT(cxListSize(list) == len);
1.96 - cx_for_n (i, len) EXPECT_EQ(*(int *) cxListAt(list, i), testdata.data[i]);
1.97 - cx_for_n (i, len) ++testdata.data[i];
1.98 - if (as_pointer) {
1.99 - cx_for_n (i, len) EXPECT_EQ(*(int *) cxListAt(list, i), testdata.data[i]);
1.100 - } else {
1.101 - cx_for_n (i, len) EXPECT_EQ(*(int *) cxListAt(list, i), testdata.data[i] - 1);
1.102 - }
1.103 - }
1.104 -
1.105 - static void verifyInsert(CxList *list) {
1.106 - int a = 5, b = 47, c = 13, d = 42;
1.107 -
1.108 - EXPECT_NE(cxListInsert(list, 1, &a), 0);
1.109 - EXPECT_EQ(cxListSize(list), 0);
1.110 - EXPECT_EQ(cxListInsert(list, 0, &a), 0);
1.111 - EXPECT_EQ(cxListSize(list), 1);
1.112 - EXPECT_EQ(cxListInsert(list, 0, &b), 0);
1.113 - EXPECT_EQ(cxListSize(list), 2);
1.114 - EXPECT_EQ(cxListInsert(list, 1, &c), 0);
1.115 - EXPECT_EQ(cxListSize(list), 3);
1.116 - EXPECT_EQ(cxListInsert(list, 3, &d), 0);
1.117 -
1.118 - CX_TEST_ASSERT(cxListSize(list) == 4);
1.119 -
1.120 - EXPECT_EQ(*(int *) cxListAt(list, 0), 47);
1.121 - EXPECT_EQ(*(int *) cxListAt(list, 1), 13);
1.122 - EXPECT_EQ(*(int *) cxListAt(list, 2), 5);
1.123 - EXPECT_EQ(*(int *) cxListAt(list, 3), 42);
1.124 - }
1.125 -
1.126 - static void verifyInsertArray(
1.127 - CxList *list,
1.128 - bool pointers = false
1.129 - ) {
1.130 - int a[5] = {5, 47, 11, 13, 42};
1.131 - int b[5] = {9, 18, 72, 50, 7};
1.132 - int *aptr[5];
1.133 - int *bptr[5];
1.134 - cx_for_n(i, 5) {
1.135 - aptr[i] = &a[i];
1.136 - bptr[i] = &b[i];
1.137 - }
1.138 -
1.139 - size_t inserted;
1.140 -
1.141 - if (pointers) {
1.142 - inserted = cxListInsertArray(list, 0, aptr, 5);
1.143 - } else {
1.144 - inserted = cxListInsertArray(list, 0, a, 5);
1.145 - }
1.146 - CX_TEST_ASSERT(inserted == 5);
1.147 - EXPECT_EQ(*(int *) cxListAt(list, 0), 5);
1.148 - EXPECT_EQ(*(int *) cxListAt(list, 1), 47);
1.149 - EXPECT_EQ(*(int *) cxListAt(list, 2), 11);
1.150 - EXPECT_EQ(*(int *) cxListAt(list, 3), 13);
1.151 - EXPECT_EQ(*(int *) cxListAt(list, 4), 42);
1.152 - if (pointers) {
1.153 - inserted = cxListInsertArray(list, 3, bptr, 5);
1.154 - } else {
1.155 - inserted = cxListInsertArray(list, 3, b, 5);
1.156 - }
1.157 - CX_TEST_ASSERT(inserted == 5);
1.158 - EXPECT_EQ(*(int *) cxListAt(list, 0), 5);
1.159 - EXPECT_EQ(*(int *) cxListAt(list, 1), 47);
1.160 - EXPECT_EQ(*(int *) cxListAt(list, 2), 11);
1.161 - EXPECT_EQ(*(int *) cxListAt(list, 3), 9);
1.162 - EXPECT_EQ(*(int *) cxListAt(list, 4), 18);
1.163 - EXPECT_EQ(*(int *) cxListAt(list, 5), 72);
1.164 - EXPECT_EQ(*(int *) cxListAt(list, 6), 50);
1.165 - EXPECT_EQ(*(int *) cxListAt(list, 7), 7);
1.166 - EXPECT_EQ(*(int *) cxListAt(list, 8), 13);
1.167 - EXPECT_EQ(*(int *) cxListAt(list, 9), 42);
1.168 - }
1.169 -
1.170 - void verifyRemove(CxList *list) const {
1.171 - EXPECT_EQ(cxListRemove(list, 2), 0);
1.172 - EXPECT_EQ(cxListRemove(list, 4), 0);
1.173 - EXPECT_EQ(cxListSize(list), testdata_len - 2);
1.174 - EXPECT_EQ(*(int *) cxListAt(list, 0), testdata.data[0]);
1.175 - EXPECT_EQ(*(int *) cxListAt(list, 1), testdata.data[1]);
1.176 - EXPECT_EQ(*(int *) cxListAt(list, 2), testdata.data[3]);
1.177 - EXPECT_EQ(*(int *) cxListAt(list, 3), testdata.data[4]);
1.178 - EXPECT_EQ(*(int *) cxListAt(list, 4), testdata.data[6]);
1.179 -
1.180 - EXPECT_EQ(cxListRemove(list, 0), 0);
1.181 - EXPECT_EQ(cxListSize(list), testdata_len - 3);
1.182 - EXPECT_EQ(*(int *) cxListAt(list, 0), testdata.data[1]);
1.183 - EXPECT_EQ(*(int *) cxListAt(list, 1), testdata.data[3]);
1.184 -
1.185 - EXPECT_NE(cxListRemove(list, testdata_len), 0);
1.186 - }
1.187 -
1.188 - void verifyFindRemove(CxList *list) const {
1.189 - size_t exp = rand() % testdata_len; // NOLINT(cert-msc50-cpp)
1.190 - int val = testdata.data[exp];
1.191 - // randomly picked number could occur earlier in list - find first position
1.192 - cx_for_n (i, exp) {
1.193 - if (testdata.data[i] == val) {
1.194 - exp = i;
1.195 - break;
1.196 - }
1.197 - }
1.198 - EXPECT_EQ(cxListSize(list), testdata_len);
1.199 - EXPECT_EQ(cxListFind(list, &val), exp);
1.200 - EXPECT_EQ(cxListFindRemove(list, &val), exp);
1.201 - EXPECT_EQ(cxListSize(list), testdata_len - 1);
1.202 - EXPECT_NE(cxListFind(list, &val), exp);
1.203 -
1.204 - int notinlist = -1;
1.205 - EXPECT_LT(cxListFindRemove(list, ¬inlist), 0);
1.206 - EXPECT_EQ(cxListSize(list), testdata_len - 1);
1.207 - }
1.208 -
1.209 - static void verifyClear(CxList *list) {
1.210 - cxListClear(list);
1.211 - EXPECT_EQ(0, cxListSize(list));
1.212 - }
1.213 -
1.214 - static unsigned destr_test_ctr;
1.215 - static int destr_last_value;
1.216 -
1.217 - static void simple_destr_test_fun(void *data) {
1.218 - auto ptr = (int *) data;
1.219 - destr_last_value = *ptr;
1.220 - *ptr = destr_last_value + 1;
1.221 - destr_test_ctr++;
1.222 - }
1.223 -
1.224 - static void advanced_destr_test_fun(
1.225 - [[maybe_unused]] void *u,
1.226 - void *data
1.227 - ) {
1.228 - simple_destr_test_fun(data);
1.229 - }
1.230 -
1.231 - void verifyAnyDestructor(CxList *list) {
1.232 - int off = cxListIsStoringPointers(list) ? 1 : 0;
1.233 -
1.234 - cxListRemove(list, 15);
1.235 - EXPECT_EQ(1, destr_test_ctr);
1.236 - EXPECT_EQ(testdata.data[15], destr_last_value + off);
1.237 - EXPECT_EQ(testdata_len - destr_test_ctr, cxListSize(list));
1.238 - cxListRemove(list, 47);
1.239 - EXPECT_EQ(2, destr_test_ctr);
1.240 - EXPECT_EQ(testdata.data[48], destr_last_value + off);
1.241 - EXPECT_EQ(testdata_len - destr_test_ctr, cxListSize(list));
1.242 -
1.243 - auto iter = cxListMutIteratorAt(list, 7);
1.244 - cxIteratorNext(iter);
1.245 - EXPECT_EQ(2, destr_test_ctr);
1.246 - EXPECT_EQ(testdata.data[48], destr_last_value + off);
1.247 - EXPECT_EQ(testdata_len - destr_test_ctr, cxListSize(list));
1.248 - cxIteratorFlagRemoval(iter);
1.249 - cxIteratorNext(iter);
1.250 - EXPECT_EQ(3, destr_test_ctr);
1.251 - EXPECT_EQ(testdata.data[8], destr_last_value + off);
1.252 - EXPECT_EQ(testdata_len - destr_test_ctr, cxListSize(list));
1.253 -
1.254 - iter = cxListMutBackwardsIteratorAt(list, 5);
1.255 - cxIteratorNext(iter);
1.256 - EXPECT_EQ(3, destr_test_ctr);
1.257 - EXPECT_EQ(testdata.data[8], destr_last_value + off);
1.258 - EXPECT_EQ(testdata_len - destr_test_ctr, cxListSize(list));
1.259 - cxIteratorFlagRemoval(iter);
1.260 - cxIteratorNext(iter);
1.261 - EXPECT_EQ(4, destr_test_ctr);
1.262 - EXPECT_EQ(testdata.data[4], destr_last_value + off);
1.263 - EXPECT_EQ(testdata_len - destr_test_ctr, cxListSize(list));
1.264 -
1.265 - cxListClear(list);
1.266 - EXPECT_EQ(testdata_len, destr_test_ctr);
1.267 - EXPECT_EQ(testdata.data[testdata_len - 1], destr_last_value + off);
1.268 - }
1.269 -
1.270 - void verifySimpleDestructor(CxList *list) {
1.271 - destr_test_ctr = 0;
1.272 - list->simple_destructor = simple_destr_test_fun;
1.273 - verifyAnyDestructor(list);
1.274 - }
1.275 -
1.276 - void verifyAdvancedDestructor(CxList *list) {
1.277 - destr_test_ctr = 0;
1.278 - list->advanced_destructor = advanced_destr_test_fun;
1.279 - verifyAnyDestructor(list);
1.280 - }
1.281 -
1.282 - static void verifySwap(CxList *list) {
1.283 - CX_TEST_ASSERT(cxListSize(list) == 0);
1.284 -
1.285 - int original[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
1.286 - int swapped[16] = {8, 4, 14, 3, 1, 5, 9, 12, 0, 6, 11, 10, 7, 15, 2, 13};
1.287 -
1.288 - // we have to add the items one by one, because it could be a pointer list
1.289 - cx_for_n(i, 16) {
1.290 - cxListAdd(list, &original[i]);
1.291 - }
1.292 -
1.293 - int result;
1.294 -
1.295 - // execute the test two times with different item sizes
1.296 - result = cxListSwap(list, 1, 4);
1.297 - EXPECT_EQ(0, result);
1.298 - result = cxListSwap(list, 2, 14);
1.299 - EXPECT_EQ(0, result);
1.300 - result = cxListSwap(list, 9, 6);
1.301 - EXPECT_EQ(0, result);
1.302 - result = cxListSwap(list, 3, 3);
1.303 - EXPECT_EQ(0, result);
1.304 - result = cxListSwap(list, 10, 11);
1.305 - EXPECT_EQ(0, result);
1.306 - result = cxListSwap(list, 8, 0);
1.307 - EXPECT_EQ(0, result);
1.308 - result = cxListSwap(list, 7, 12);
1.309 - EXPECT_EQ(0, result);
1.310 - result = cxListSwap(list, 13, 15);
1.311 - EXPECT_EQ(0, result);
1.312 -
1.313 - result = cxListSwap(list, 5, 16);
1.314 - CX_TEST_ASSERT(0 != result);
1.315 - result = cxListSwap(list, 16, 6);
1.316 - CX_TEST_ASSERT(0 != result);
1.317 - result = cxListSwap(list, 16, 17);
1.318 - CX_TEST_ASSERT(0 != result);
1.319 -
1.320 - auto iter = cxListIterator(list);
1.321 - cx_foreach(int*, e, iter) {
1.322 - EXPECT_EQ(*e, swapped[iter.index]);
1.323 - }
1.324 - iter = cxListBackwardsIterator(list);
1.325 - cx_foreach(int*, e, iter) {
1.326 - EXPECT_EQ(*e, swapped[iter.index]);
1.327 - }
1.328 - }
1.329 -
1.330 - void verifyAt(CxList *list) const {
1.331 - auto len = testdata_len;
1.332 - EXPECT_EQ(cxListSize(list), len);
1.333 - cx_for_n (i, len) {
1.334 - EXPECT_EQ(*(int *) cxListAt(list, i), testdata.data[i]);
1.335 - }
1.336 - EXPECT_EQ(cxListAt(list, cxListSize(list)), NULL);
1.337 - }
1.338 -
1.339 - void verifyFind(CxList *list) const {
1.340 - cx_for_n (attempt, 25) {
1.341 - size_t exp = rand() % testdata_len; // NOLINT(cert-msc50-cpp)
1.342 - int val = testdata.data[exp];
1.343 - // randomly picked number could occur earlier in list - find first position
1.344 - cx_for_n (i, exp) {
1.345 - if (testdata.data[i] == val) {
1.346 - exp = i;
1.347 - break;
1.348 - }
1.349 - }
1.350 - EXPECT_EQ(cxListFind(list, &val), exp);
1.351 - }
1.352 -
1.353 - int notinlist = -1;
1.354 - EXPECT_LT(cxListFind(list, ¬inlist), 0);
1.355 - }
1.356 -
1.357 - void verifySort(CxList *list) const {
1.358 - std::array<int, testdata_len> expected{};
1.359 - std::partial_sort_copy(testdata.data.begin(), testdata.data.end(), expected.begin(), expected.end());
1.360 - cxListSort(list);
1.361 - cx_for_n (i, testdata_len) CX_TEST_ASSERT(*(int *) cxListAt(list, i) == expected[i]);
1.362 - }
1.363 -
1.364 - void verifyIterator(CxList *list) const {
1.365 - auto iter = cxListIterator(list);
1.366 - size_t i = 0;
1.367 - cx_foreach(int*, x, iter) {
1.368 - CX_TEST_ASSERT(i == iter.index);
1.369 - EXPECT_EQ(*x, testdata.data[iter.index]);
1.370 - i++;
1.371 - }
1.372 - CX_TEST_ASSERT(i == cxListSize(list));
1.373 - iter = cxListBackwardsIterator(list);
1.374 - cx_foreach(int*, x, iter) {
1.375 - CX_TEST_ASSERT(i - 1 == iter.index);
1.376 - EXPECT_EQ(*x, testdata.data[iter.index]);
1.377 - i--;
1.378 - }
1.379 - CX_TEST_ASSERT(i == 0);
1.380 - auto len = testdata_len;
1.381 - i = len / 2;
1.382 - auto mut_iter = cxListMutIteratorAt(list, i);
1.383 - size_t j = 0;
1.384 - cx_foreach(int*, x, mut_iter) {
1.385 - CX_TEST_ASSERT(mut_iter.index == len / 2 + j / 2);
1.386 - CX_TEST_ASSERT(*x == testdata.data[i]);
1.387 - if (i % 2 == 1) cxIteratorFlagRemoval(mut_iter);
1.388 - i++;
1.389 - j++;
1.390 - }
1.391 - CX_TEST_ASSERT(i == len);
1.392 - i = len / 2;
1.393 - j = 0;
1.394 - mut_iter = cxListMutBackwardsIteratorAt(list, i - 1);
1.395 - cx_foreach(int*, x, mut_iter) {
1.396 - CX_TEST_ASSERT(mut_iter.index == len / 2 - 1 - j);
1.397 - CX_TEST_ASSERT(*x == testdata.data[i - 1]);
1.398 - if (i % 2 == 0) cxIteratorFlagRemoval(mut_iter);
1.399 - i--;
1.400 - j++;
1.401 - }
1.402 - CX_TEST_ASSERT(i == 0);
1.403 - CX_TEST_ASSERT(cxListSize(list) == len / 2);
1.404 - cx_for_n(j, len / 2) ASSERT_EQ(*(int *) cxListAt(list, j), testdata.data[j * 2]);
1.405 - }
1.406 -
1.407 - static void verifyInsertViaIterator(CxList *list) {
1.408 - int newdata[] = {10, 20, 30, 40, 50};
1.409 -
1.410 - auto iter = cxListMutIteratorAt(list, 2);
1.411 - CX_TEST_ASSERT(cxIteratorValid(iter));
1.412 - EXPECT_EQ(iter.index, 2);
1.413 - EXPECT_EQ(*(int *) cxIteratorCurrent(iter), 2);
1.414 - cxListInsertAfter(&iter, &newdata[0]);
1.415 - CX_TEST_ASSERT(cxIteratorValid(iter));
1.416 - EXPECT_EQ(iter.index, 2);
1.417 - EXPECT_EQ(*(int *) cxIteratorCurrent(iter), 2);
1.418 - cxListInsertBefore(&iter, &newdata[1]);
1.419 - CX_TEST_ASSERT(cxIteratorValid(iter));
1.420 - EXPECT_EQ(iter.index, 3);
1.421 - EXPECT_EQ(*(int *) cxIteratorCurrent(iter), 2);
1.422 -
1.423 - iter = cxListMutIterator(list);
1.424 - cxListInsertBefore(&iter, &newdata[2]);
1.425 - CX_TEST_ASSERT(cxIteratorValid(iter));
1.426 - EXPECT_EQ(iter.index, 1);
1.427 - EXPECT_EQ(*(int *) cxIteratorCurrent(iter), 0);
1.428 - iter = cxListMutIteratorAt(list, cxListSize(list));
1.429 - cxListInsertBefore(&iter, &newdata[3]);
1.430 - CX_TEST_ASSERT(!cxIteratorValid(iter));
1.431 - EXPECT_EQ(iter.index, 9);
1.432 - iter = cxListMutIteratorAt(list, cxListSize(list));
1.433 - cxListInsertAfter(&iter, &newdata[4]);
1.434 - CX_TEST_ASSERT(!cxIteratorValid(iter));
1.435 - EXPECT_EQ(iter.index, 10);
1.436 -
1.437 - int expdata[] = {30, 0, 1, 20, 2, 10, 3, 4, 40, 50};
1.438 - cx_for_n (j, 10) EXPECT_EQ(*(int *) cxListAt(list, j), expdata[j]);
1.439 - }
1.440 -
1.441 - void verifyReverse(CxList *list) const {
1.442 - cxListReverse(list);
1.443 - cx_for_n(i, testdata_len) {
1.444 - ASSERT_EQ(*(int *) cxListAt(list, i), testdata.data[testdata_len - 1 - i]);
1.445 - }
1.446 - }
1.447 -
1.448 - static void verifyCompare(
1.449 - CxList *left,
1.450 - CxList *right
1.451 - ) {
1.452 - EXPECT_EQ(cxListCompare(left, right), 0);
1.453 - int x = 42;
1.454 - cxListAdd(left, &x);
1.455 - ASSERT_GT(cxListSize(left), cxListSize(right));
1.456 - EXPECT_GT(cxListCompare(left, right), 0);
1.457 - EXPECT_LT(cxListCompare(right, left), 0);
1.458 - cxListAdd(right, &x);
1.459 - CX_TEST_ASSERT(cxListSize(left) == cxListSize(right));
1.460 - EXPECT_EQ(cxListCompare(left, right), 0);
1.461 - int a = 5, b = 10;
1.462 - cxListInsert(left, 15, &a);
1.463 - cxListInsert(right, 15, &b);
1.464 - CX_TEST_ASSERT(cxListSize(left) == cxListSize(right));
1.465 - EXPECT_LT(cxListCompare(left, right), 0);
1.466 - EXPECT_GT(cxListCompare(right, left), 0);
1.467 - *(int *) cxListAt(left, 15) = 10;
1.468 - EXPECT_EQ(cxListCompare(left, right), 0);
1.469 - }
1.470 -};
1.471 -
1.472 -unsigned HighLevelTest::destr_test_ctr = 0;
1.473 -int HighLevelTest::destr_last_value = 0;
1.474 -
1.475 -class LinkedList : public HighLevelTest {
1.476 -};
1.477 -
1.478 -class PointerLinkedList : public HighLevelTest {
1.479 -};
1.480 -
1.481 -class ArrayList : public HighLevelTest {
1.482 -};
1.483 -
1.484 -class PointerArrayList : public HighLevelTest {
1.485 -};
1.486 -
1.487 -
1.488 -TEST_F(LinkedList, cxListAdd) {
1.489 - auto list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int)));
1.490 - verifyAdd(list, false);
1.491 -}
1.492 -
1.493 -TEST_F(PointerLinkedList, cxListAdd) {
1.494 - auto list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS));
1.495 - verifyAdd(list, true);
1.496 -}
1.497 -
1.498 -TEST_F(ArrayList, cxListAdd) {
1.499 - auto list = autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, sizeof(int), 8));
1.500 - verifyAdd(list, false);
1.501 -}
1.502 -
1.503 -TEST_F(PointerArrayList, cxListAdd) {
1.504 - auto list = autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS, 8));
1.505 - verifyAdd(list, true);
1.506 -}
1.507 -
1.508 -TEST_F(LinkedList, cxListInsert) {
1.509 - verifyInsert(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int))));
1.510 -}
1.511 -
1.512 -TEST_F(PointerLinkedList, cxListInsert) {
1.513 - verifyInsert(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS)));
1.514 -}
1.515 -
1.516 -TEST_F(ArrayList, cxListInsert) {
1.517 - verifyInsert(autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, sizeof(int), 2)));
1.518 -}
1.519 -
1.520 -TEST_F(PointerArrayList, cxListInsert) {
1.521 - verifyInsert(autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS, 2)));
1.522 -}
1.523 -
1.524 -TEST_F(LinkedList, cxListInsertArray) {
1.525 - verifyInsertArray(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int))));
1.526 -}
1.527 -
1.528 -TEST_F(PointerLinkedList, cxListInsertArray) {
1.529 - verifyInsertArray(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS)), true);
1.530 -}
1.531 -
1.532 -TEST_F(ArrayList, cxListInsertArray) {
1.533 - verifyInsertArray(autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, sizeof(int), 4)));
1.534 -}
1.535 -
1.536 -TEST_F(PointerArrayList, cxListInsertArray) {
1.537 - verifyInsertArray(autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS, 4)), true);
1.538 -}
1.539 -
1.540 -TEST_F(LinkedList, cxListRemove) {
1.541 - verifyRemove(linkedListFromTestData());
1.542 -}
1.543 -
1.544 -TEST_F(PointerLinkedList, cxListRemove) {
1.545 - verifyRemove(pointerLinkedListFromTestData());
1.546 -}
1.547 -
1.548 -TEST_F(ArrayList, cxListRemove) {
1.549 - verifyRemove(arrayListFromTestData());
1.550 -}
1.551 -
1.552 -TEST_F(PointerArrayList, cxListRemove) {
1.553 - verifyRemove(pointerArrayListFromTestData());
1.554 -}
1.555 -
1.556 -TEST_F(LinkedList, cxListFindRemove) {
1.557 - verifyFindRemove(linkedListFromTestData());
1.558 -}
1.559 -
1.560 -TEST_F(PointerLinkedList, cxListFindRemove) {
1.561 - verifyFindRemove(pointerLinkedListFromTestData());
1.562 -}
1.563 -
1.564 -TEST_F(ArrayList, cxListFindRemove) {
1.565 - verifyFindRemove(arrayListFromTestData());
1.566 -}
1.567 -
1.568 -TEST_F(PointerArrayList, cxListFindRemove) {
1.569 - verifyFindRemove(pointerArrayListFromTestData());
1.570 -}
1.571 -
1.572 -TEST_F(LinkedList, cxListClear) {
1.573 - verifyClear(linkedListFromTestData());
1.574 -}
1.575 -
1.576 -TEST_F(PointerLinkedList, cxListClear) {
1.577 - verifyClear(pointerLinkedListFromTestData());
1.578 -}
1.579 -
1.580 -TEST_F(ArrayList, cxListClear) {
1.581 - verifyClear(arrayListFromTestData());
1.582 -}
1.583 -
1.584 -TEST_F(PointerArrayList, cxListClear) {
1.585 - verifyClear(pointerArrayListFromTestData());
1.586 -}
1.587 -
1.588 -TEST_F(LinkedList, cxListSwap) {
1.589 - verifySwap(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int))));
1.590 -}
1.591 -
1.592 -TEST_F(PointerLinkedList, cxListSwap) {
1.593 - verifySwap(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS)));
1.594 -}
1.595 -
1.596 -TEST_F(ArrayList, cxListSwap) {
1.597 - verifySwap(autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, sizeof(int), 16)));
1.598 -}
1.599 -
1.600 -TEST_F(PointerArrayList, cxListSwap) {
1.601 - verifySwap(autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS, 16)));
1.602 -}
1.603 -
1.604 -TEST_F(LinkedList, cxListSwapNoSBO) {
1.605 - CX_DISABLE_LINKED_LIST_SWAP_SBO = true;
1.606 - verifySwap(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int))));
1.607 - CX_DISABLE_LINKED_LIST_SWAP_SBO = false;
1.608 -}
1.609 -
1.610 -TEST_F(PointerLinkedList, cxListSwapNoSBO) {
1.611 - CX_DISABLE_LINKED_LIST_SWAP_SBO = true;
1.612 - verifySwap(autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS)));
1.613 - CX_DISABLE_LINKED_LIST_SWAP_SBO = false;
1.614 -}
1.615 -
1.616 -TEST_F(LinkedList, cxListAt) {
1.617 - verifyAt(linkedListFromTestData());
1.618 -}
1.619 -
1.620 -TEST_F(PointerLinkedList, cxListAt) {
1.621 - verifyAt(pointerLinkedListFromTestData());
1.622 -}
1.623 -
1.624 -TEST_F(ArrayList, cxListAt) {
1.625 - verifyAt(arrayListFromTestData());
1.626 -}
1.627 -
1.628 -TEST_F(PointerArrayList, cxListAt) {
1.629 - verifyAt(pointerArrayListFromTestData());
1.630 -}
1.631 -
1.632 -TEST_F(LinkedList, cxListFind) {
1.633 - verifyFind(linkedListFromTestData());
1.634 -}
1.635 -
1.636 -TEST_F(PointerLinkedList, cxListFind) {
1.637 - verifyFind(pointerLinkedListFromTestData());
1.638 -}
1.639 -
1.640 -TEST_F(ArrayList, cxListFind) {
1.641 - verifyFind(arrayListFromTestData());
1.642 -}
1.643 -
1.644 -TEST_F(PointerArrayList, cxListFind) {
1.645 - verifyFind(pointerArrayListFromTestData());
1.646 -}
1.647 -
1.648 -TEST_F(LinkedList, cxListSort) {
1.649 - verifySort(linkedListFromTestData());
1.650 -}
1.651 -
1.652 -TEST_F(PointerLinkedList, cxListSort) {
1.653 - verifySort(pointerLinkedListFromTestData());
1.654 -}
1.655 -
1.656 -TEST_F(ArrayList, cxListSort) {
1.657 - verifySort(arrayListFromTestData());
1.658 -}
1.659 -
1.660 -TEST_F(PointerArrayList, cxListSort) {
1.661 - verifySort(pointerArrayListFromTestData());
1.662 -}
1.663 -
1.664 -TEST_F(LinkedList, Iterator) {
1.665 - verifyIterator(linkedListFromTestData());
1.666 -}
1.667 -
1.668 -TEST_F(PointerLinkedList, Iterator) {
1.669 - verifyIterator(pointerLinkedListFromTestData());
1.670 -}
1.671 -
1.672 -TEST_F(ArrayList, Iterator) {
1.673 - verifyIterator(arrayListFromTestData());
1.674 -}
1.675 -
1.676 -TEST_F(PointerArrayList, Iterator) {
1.677 - verifyIterator(pointerArrayListFromTestData());
1.678 -}
1.679 -
1.680 -TEST_F(LinkedList, InsertViaIterator) {
1.681 - int fivenums[] = {0, 1, 2, 3, 4, 5};
1.682 - CxList *list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int)));
1.683 - cxListAddArray(list, fivenums, 5);
1.684 - verifyInsertViaIterator(list);
1.685 -}
1.686 -
1.687 -TEST_F(PointerLinkedList, InsertViaIterator) {
1.688 - int fivenums[] = {0, 1, 2, 3, 4, 5};
1.689 - auto list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS));
1.690 - // note: cannot use cxListAddArray() because we don't have a list of pointers
1.691 - cx_for_n(i, 5) cxListAdd(list, &fivenums[i]);
1.692 - verifyInsertViaIterator(list);
1.693 -}
1.694 -
1.695 -TEST_F(ArrayList, InsertViaIterator) {
1.696 - int fivenums[] = {0, 1, 2, 3, 4, 5};
1.697 - auto list = autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, sizeof(int), 4));
1.698 - cxListAddArray(list, fivenums, 5);
1.699 - verifyInsertViaIterator(list);
1.700 -}
1.701 -
1.702 -TEST_F(PointerArrayList, InsertViaIterator) {
1.703 - int fivenums[] = {0, 1, 2, 3, 4, 5};
1.704 - auto list = autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, CX_STORE_POINTERS, 4));
1.705 - // note: cannot use cxListAddArray() because we don't have a list of pointers
1.706 - cx_for_n(i, 5) cxListAdd(list, &fivenums[i]);
1.707 - verifyInsertViaIterator(list);
1.708 -}
1.709 -
1.710 -TEST_F(LinkedList, cxListReverse) {
1.711 - verifyReverse(linkedListFromTestData());
1.712 -}
1.713 -
1.714 -TEST_F(PointerLinkedList, cxListReverse) {
1.715 - verifyReverse(pointerLinkedListFromTestData());
1.716 -}
1.717 -
1.718 -TEST_F(ArrayList, cxListReverse) {
1.719 - verifyReverse(arrayListFromTestData());
1.720 -}
1.721 -
1.722 -TEST_F(PointerArrayList, cxListReverse) {
1.723 - verifyReverse(pointerArrayListFromTestData());
1.724 -}
1.725 -
1.726 -TEST_F(LinkedList, cxListCompare) {
1.727 - auto left = linkedListFromTestData();
1.728 - auto right = linkedListFromTestData();
1.729 - verifyCompare(left, right);
1.730 -}
1.731 -
1.732 -TEST_F(LinkedList, cxListCompareWithPtrList) {
1.733 - auto left = linkedListFromTestData();
1.734 - auto right = pointerLinkedListFromTestData();
1.735 - verifyCompare(left, right);
1.736 -}
1.737 -
1.738 -TEST_F(LinkedList, cxListCompareWithArrayList) {
1.739 - auto left = linkedListFromTestData();
1.740 - auto right = arrayListFromTestData();
1.741 - verifyCompare(left, right);
1.742 -}
1.743 -
1.744 -TEST_F(LinkedList, cxListCompareWithPtrArrayList) {
1.745 - auto left = linkedListFromTestData();
1.746 - auto right = pointerArrayListFromTestData();
1.747 - verifyCompare(left, right);
1.748 -}
1.749 -
1.750 -TEST_F(PointerLinkedList, cxListCompare) {
1.751 - auto left = pointerLinkedListFromTestData();
1.752 - auto right = pointerLinkedListFromTestData();
1.753 - verifyCompare(left, right);
1.754 -}
1.755 -
1.756 -TEST_F(PointerLinkedList, cxListCompareWithNormalList) {
1.757 - auto left = pointerLinkedListFromTestData();
1.758 - auto right = linkedListFromTestData();
1.759 - verifyCompare(left, right);
1.760 -}
1.761 -
1.762 -TEST_F(PointerLinkedList, cxListCompareWithArrayList) {
1.763 - auto left = pointerLinkedListFromTestData();
1.764 - auto right = arrayListFromTestData();
1.765 - verifyCompare(left, right);
1.766 -}
1.767 -
1.768 -TEST_F(PointerLinkedList, cxListCompareWithPtrArrayList) {
1.769 - auto left = pointerLinkedListFromTestData();
1.770 - auto right = pointerArrayListFromTestData();
1.771 - verifyCompare(left, right);
1.772 -}
1.773 -
1.774 -TEST_F(ArrayList, cxListCompare) {
1.775 - auto left = arrayListFromTestData();
1.776 - auto right = arrayListFromTestData();
1.777 - verifyCompare(left, right);
1.778 -}
1.779 -
1.780 -TEST_F(ArrayList, cxListCompareWithPtrList) {
1.781 - auto left = arrayListFromTestData();
1.782 - auto right = pointerLinkedListFromTestData();
1.783 - verifyCompare(left, right);
1.784 -}
1.785 -
1.786 -TEST_F(ArrayList, cxListCompareWithNormalList) {
1.787 - auto left = arrayListFromTestData();
1.788 - auto right = linkedListFromTestData();
1.789 - verifyCompare(left, right);
1.790 -}
1.791 -
1.792 -TEST_F(ArrayList, cxListCompareWithPtrArrayList) {
1.793 - auto left = arrayListFromTestData();
1.794 - auto right = pointerArrayListFromTestData();
1.795 - verifyCompare(left, right);
1.796 -}
1.797 -
1.798 -TEST_F(PointerArrayList, cxListCompare) {
1.799 - auto left = pointerArrayListFromTestData();
1.800 - auto right = pointerArrayListFromTestData();
1.801 - verifyCompare(left, right);
1.802 -}
1.803 -
1.804 -TEST_F(PointerArrayList, cxListCompareWithPtrList) {
1.805 - auto left = pointerArrayListFromTestData();
1.806 - auto right = pointerLinkedListFromTestData();
1.807 - verifyCompare(left, right);
1.808 -}
1.809 -
1.810 -TEST_F(PointerArrayList, cxListCompareWithNormalList) {
1.811 - auto left = pointerArrayListFromTestData();
1.812 - auto right = linkedListFromTestData();
1.813 - verifyCompare(left, right);
1.814 -}
1.815 -
1.816 -TEST_F(PointerArrayList, cxListCompareWithNormalArrayList) {
1.817 - auto left = pointerArrayListFromTestData();
1.818 - auto right = arrayListFromTestData();
1.819 - verifyCompare(left, right);
1.820 -}
1.821 -
1.822 -TEST_F(LinkedList, SimpleDestructor) {
1.823 - verifySimpleDestructor(linkedListFromTestData());
1.824 -}
1.825 -
1.826 -TEST_F(PointerLinkedList, SimpleDestructor) {
1.827 - verifySimpleDestructor(pointerLinkedListFromTestData());
1.828 -}
1.829 -
1.830 -TEST_F(ArrayList, SimpleDestructor) {
1.831 - verifySimpleDestructor(arrayListFromTestData());
1.832 -}
1.833 -
1.834 -TEST_F(PointerArrayList, SimpleDestructor) {
1.835 - verifySimpleDestructor(pointerArrayListFromTestData());
1.836 -}
1.837 -
1.838 -TEST_F(LinkedList, AdvancedDestructor) {
1.839 - verifyAdvancedDestructor(linkedListFromTestData());
1.840 -}
1.841 -
1.842 -TEST_F(PointerLinkedList, AdvancedDestructor) {
1.843 - verifyAdvancedDestructor(pointerLinkedListFromTestData());
1.844 -}
1.845 -
1.846 -TEST_F(ArrayList, AdvancedDestructor) {
1.847 - verifyAdvancedDestructor(arrayListFromTestData());
1.848 -}
1.849 -
1.850 -TEST_F(PointerArrayList, AdvancedDestructor) {
1.851 - verifyAdvancedDestructor(pointerArrayListFromTestData());
1.852 -}
1.853 -
1.854 -
1.855 -
