Mercurial > hg > ucx / changeset

     1.1 --- a/tests/test_list.c	Tue Jan 09 21:25:08 2024 +0100
     1.2 +++ b/tests/test_list.c	Wed Jan 10 22:13:23 2024 +0100
     1.3 @@ -635,9 +635,235 @@
     1.4      cxListDestroy(al);
     1.5  }
     1.6  
     1.7 +CX_TEST(test_list_ll_create) {
     1.8 +    CxTestingAllocator talloc;
     1.9 +    cx_testing_allocator_init(&talloc);
    1.10 +    CxAllocator *alloc = &talloc.base;
    1.11 +    CX_TEST_DO {
    1.12 +        CxList *list = cxLinkedListCreate(alloc, cx_cmp_int, sizeof(int));
    1.13 +        CX_TEST_ASSERT(list != NULL);
    1.14 +        CX_TEST_ASSERT(list->item_size == sizeof(int));
    1.15 +        CX_TEST_ASSERT(list->simple_destructor == NULL);
    1.16 +        CX_TEST_ASSERT(list->advanced_destructor == NULL);
    1.17 +        CX_TEST_ASSERT(list->destructor_data == NULL);
    1.18 +        CX_TEST_ASSERT(cxListSize(list) == 0);
    1.19 +        CX_TEST_ASSERT(list->allocator == alloc);
    1.20 +        CX_TEST_ASSERT(list->cmpfunc == cx_cmp_int);
    1.21 +        CX_TEST_ASSERT(!cxListIsStoringPointers(list));
    1.22 +        cxListDestroy(list);
    1.23 +        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    1.24 +    }
    1.25 +    cx_testing_allocator_destroy(&talloc);
    1.26 +}
    1.27 +
    1.28 +CX_TEST(test_list_ll_create_simple) {
    1.29 +    CxList *list = cxLinkedListCreateSimple(sizeof(int));
    1.30 +    CX_TEST_DO {
    1.31 +        CX_TEST_ASSERT(list != NULL);
    1.32 +        CX_TEST_ASSERT(list->item_size == sizeof(int));
    1.33 +        CX_TEST_ASSERT(list->simple_destructor == NULL);
    1.34 +        CX_TEST_ASSERT(list->advanced_destructor == NULL);
    1.35 +        CX_TEST_ASSERT(list->destructor_data == NULL);
    1.36 +        CX_TEST_ASSERT(cxListSize(list) == 0);
    1.37 +        CX_TEST_ASSERT(list->allocator == cxDefaultAllocator);
    1.38 +        CX_TEST_ASSERT(list->cmpfunc == NULL);
    1.39 +        CX_TEST_ASSERT(!cxListIsStoringPointers(list));
    1.40 +    }
    1.41 +    cxListDestroy(list);
    1.42 +}
    1.43 +
    1.44 +CX_TEST(test_list_ll_store_pointers) {
    1.45 +    CxList *list = cxLinkedListCreateSimple(47);
    1.46 +    CX_TEST_DO {
    1.47 +        CX_TEST_ASSERT(!cxListIsStoringPointers(list));
    1.48 +        cxListStorePointers(list);
    1.49 +        CX_TEST_ASSERT(list->item_size == sizeof(void *));
    1.50 +        CX_TEST_ASSERT(list->cl != NULL);
    1.51 +        CX_TEST_ASSERT(list->climpl != NULL);
    1.52 +        CX_TEST_ASSERT(cxListIsStoringPointers(list));
    1.53 +        cxListStoreObjects(list);
    1.54 +        CX_TEST_ASSERT(list->cl != NULL);
    1.55 +        CX_TEST_ASSERT(list->climpl == NULL);
    1.56 +        CX_TEST_ASSERT(!cxListIsStoringPointers(list));
    1.57 +    }
    1.58 +    cxListDestroy(list);
    1.59 +}
    1.60 +
    1.61 +CX_TEST(test_list_ll_create_simple_for_pointers) {
    1.62 +    CxList *list = cxLinkedListCreateSimple(CX_STORE_POINTERS);
    1.63 +    CX_TEST_DO {
    1.64 +        CX_TEST_ASSERT(list != NULL);
    1.65 +        CX_TEST_ASSERT(list->item_size == sizeof(void*));
    1.66 +        CX_TEST_ASSERT(list->simple_destructor == NULL);
    1.67 +        CX_TEST_ASSERT(list->advanced_destructor == NULL);
    1.68 +        CX_TEST_ASSERT(list->destructor_data == NULL);
    1.69 +        CX_TEST_ASSERT(cxListSize(list) == 0);
    1.70 +        CX_TEST_ASSERT(list->allocator == cxDefaultAllocator);
    1.71 +        CX_TEST_ASSERT(list->cmpfunc == cx_cmp_ptr);
    1.72 +        CX_TEST_ASSERT(cxListIsStoringPointers(list));
    1.73 +    }
    1.74 +    cxListDestroy(list);
    1.75 +}
    1.76 +
    1.77 +CX_TEST(test_list_arl_create) {
    1.78 +    CxTestingAllocator talloc;
    1.79 +    cx_testing_allocator_init(&talloc);
    1.80 +    CxAllocator *alloc = &talloc.base;
    1.81 +    CX_TEST_DO {
    1.82 +        CxList *list = cxArrayListCreate(alloc, cx_cmp_int, sizeof(int), 8);
    1.83 +        CX_TEST_ASSERT(list != NULL);
    1.84 +        CX_TEST_ASSERT(list->item_size == sizeof(int));
    1.85 +        CX_TEST_ASSERT(list->simple_destructor == NULL);
    1.86 +        CX_TEST_ASSERT(list->advanced_destructor == NULL);
    1.87 +        CX_TEST_ASSERT(list->destructor_data == NULL);
    1.88 +        CX_TEST_ASSERT(cxListSize(list) == 0);
    1.89 +        CX_TEST_ASSERT(list->allocator == alloc);
    1.90 +        CX_TEST_ASSERT(list->cmpfunc == cx_cmp_int);
    1.91 +        CX_TEST_ASSERT(!cxListIsStoringPointers(list));
    1.92 +        cxListDestroy(list);
    1.93 +        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
    1.94 +    }
    1.95 +    cx_testing_allocator_destroy(&talloc);
    1.96 +}
    1.97 +
    1.98 +CX_TEST(test_list_arl_create_simple) {
    1.99 +    CxList *list = cxArrayListCreateSimple(sizeof(int), 8);
   1.100 +    CX_TEST_DO {
   1.101 +        CX_TEST_ASSERT(list != NULL);
   1.102 +        CX_TEST_ASSERT(list->item_size == sizeof(int));
   1.103 +        CX_TEST_ASSERT(list->simple_destructor == NULL);
   1.104 +        CX_TEST_ASSERT(list->advanced_destructor == NULL);
   1.105 +        CX_TEST_ASSERT(list->destructor_data == NULL);
   1.106 +        CX_TEST_ASSERT(cxListSize(list) == 0);
   1.107 +        CX_TEST_ASSERT(list->allocator == cxDefaultAllocator);
   1.108 +        CX_TEST_ASSERT(list->cmpfunc == NULL);
   1.109 +        CX_TEST_ASSERT(!cxListIsStoringPointers(list));
   1.110 +    }
   1.111 +    cxListDestroy(list);
   1.112 +}
   1.113 +
   1.114 +CX_TEST(test_list_arl_create_simple_for_pointers) {
   1.115 +    CxList *list = cxArrayListCreateSimple(CX_STORE_POINTERS, 8);
   1.116 +    CX_TEST_DO {
   1.117 +        CX_TEST_ASSERT(list != NULL);
   1.118 +        CX_TEST_ASSERT(list->item_size == sizeof(void*));
   1.119 +        CX_TEST_ASSERT(list->simple_destructor == NULL);
   1.120 +        CX_TEST_ASSERT(list->advanced_destructor == NULL);
   1.121 +        CX_TEST_ASSERT(list->destructor_data == NULL);
   1.122 +        CX_TEST_ASSERT(cxListSize(list) == 0);
   1.123 +        CX_TEST_ASSERT(list->allocator == cxDefaultAllocator);
   1.124 +        CX_TEST_ASSERT(list->cmpfunc == cx_cmp_ptr);
   1.125 +        CX_TEST_ASSERT(cxListIsStoringPointers(list));
   1.126 +    }
   1.127 +    cxListDestroy(list);
   1.128 +}
   1.129 +
   1.130 +static void test_fake_simple_int_destr(void *elem) {
   1.131 +    *(int *) elem = 42;
   1.132 +}
   1.133 +
   1.134 +CX_TEST(test_list_pll_destroy_no_destr) {
   1.135 +    CxTestingAllocator talloc;
   1.136 +    cx_testing_allocator_init(&talloc);
   1.137 +    CxAllocator *alloc = &talloc.base;
   1.138 +    CX_TEST_DO {
   1.139 +        void *item = cxMalloc(alloc, sizeof(int));
   1.140 +        CxList *list = cxLinkedListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS);
   1.141 +        cxListAdd(list, item);
   1.142 +        CX_TEST_ASSERT(!cx_testing_allocator_verify(&talloc));
   1.143 +        cxListDestroy(list);
   1.144 +        // item is not yet freed
   1.145 +        CX_TEST_ASSERT(!cx_testing_allocator_verify(&talloc));
   1.146 +        cxFree(alloc, item);
   1.147 +        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
   1.148 +    }
   1.149 +    cx_testing_allocator_destroy(&talloc);
   1.150 +}
   1.151 +
   1.152 +CX_TEST(test_list_pll_destroy_simple_destr) {
   1.153 +    CX_TEST_DO {
   1.154 +        int item = 0;
   1.155 +        CxList *list = cxLinkedListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS);
   1.156 +        list->simple_destructor = test_fake_simple_int_destr;
   1.157 +        cxListAdd(list, &item);
   1.158 +        cxListDestroy(list);
   1.159 +        CX_TEST_ASSERT(item == 42);
   1.160 +    }
   1.161 +}
   1.162 +
   1.163 +CX_TEST(test_list_pll_destroy_adv_destr) {
   1.164 +    CxTestingAllocator talloc;
   1.165 +    cx_testing_allocator_init(&talloc);
   1.166 +    CxAllocator *alloc = &talloc.base;
   1.167 +    CX_TEST_DO {
   1.168 +        void *item = cxMalloc(alloc, sizeof(int));
   1.169 +        CxList *list = cxLinkedListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS);
   1.170 +        list->destructor_data = alloc;
   1.171 +        list->advanced_destructor = (cx_destructor_func2) cxFree;
   1.172 +        cxListAdd(list, item);
   1.173 +        CX_TEST_ASSERT(!cx_testing_allocator_verify(&talloc));
   1.174 +        cxListDestroy(list);
   1.175 +        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
   1.176 +    }
   1.177 +    cx_testing_allocator_destroy(&talloc);
   1.178 +}
   1.179 +
   1.180 +CX_TEST(test_list_parl_destroy_no_destr) {
   1.181 +    CxTestingAllocator talloc;
   1.182 +    cx_testing_allocator_init(&talloc);
   1.183 +    CxAllocator *alloc = &talloc.base;
   1.184 +    CX_TEST_DO {
   1.185 +        void *item = cxMalloc(alloc, sizeof(int));
   1.186 +        CxList *list = cxArrayListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS, 4);
   1.187 +        cxListAdd(list, item);
   1.188 +        CX_TEST_ASSERT(!cx_testing_allocator_verify(&talloc));
   1.189 +        cxListDestroy(list);
   1.190 +        // item is not yet freed
   1.191 +        CX_TEST_ASSERT(!cx_testing_allocator_verify(&talloc));
   1.192 +        cxFree(alloc, item);
   1.193 +        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
   1.194 +    }
   1.195 +    cx_testing_allocator_destroy(&talloc);
   1.196 +}
   1.197 +
   1.198 +CX_TEST(test_list_parl_destroy_simple_destr) {
   1.199 +    CX_TEST_DO {
   1.200 +        int item = 0;
   1.201 +        CxList *list = cxArrayListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS, 4);
   1.202 +        list->simple_destructor = test_fake_simple_int_destr;
   1.203 +        cxListAdd(list, &item);
   1.204 +        cxListDestroy(list);
   1.205 +        CX_TEST_ASSERT(item == 42);
   1.206 +    }
   1.207 +}
   1.208 +
   1.209 +CX_TEST(test_list_parl_destroy_adv_destr) {
   1.210 +    CxTestingAllocator talloc;
   1.211 +    cx_testing_allocator_init(&talloc);
   1.212 +    CxAllocator *alloc = &talloc.base;
   1.213 +    CX_TEST_DO {
   1.214 +        void *item = cxMalloc(alloc, sizeof(int));
   1.215 +        CxList *list = cxArrayListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS, 4);
   1.216 +        list->destructor_data = alloc;
   1.217 +        list->advanced_destructor = (cx_destructor_func2) cxFree;
   1.218 +        cxListAdd(list, item);
   1.219 +        CX_TEST_ASSERT(!cx_testing_allocator_verify(&talloc));
   1.220 +        cxListDestroy(list);
   1.221 +        CX_TEST_ASSERT(cx_testing_allocator_verify(&talloc));
   1.222 +    }
   1.223 +    cx_testing_allocator_destroy(&talloc);
   1.224 +}
   1.225 +
   1.226  CxTestSuite *cx_test_suite_array_list(void) {
   1.227      CxTestSuite *suite = cx_test_suite_new("array_list");
   1.228  
   1.229 +    cx_test_register(suite, test_list_arl_create);
   1.230 +    cx_test_register(suite, test_list_arl_create_simple);
   1.231 +    cx_test_register(suite, test_list_arl_create_simple_for_pointers);
   1.232 +    cx_test_register(suite, test_list_parl_destroy_no_destr);
   1.233 +    cx_test_register(suite, test_list_parl_destroy_simple_destr);
   1.234 +    cx_test_register(suite, test_list_parl_destroy_adv_destr);
   1.235 +
   1.236      return suite;
   1.237  }
   1.238  
   1.239 @@ -661,6 +887,14 @@
   1.240      cx_test_register(suite, test_linked_list_sort);
   1.241      cx_test_register(suite, test_linked_list_reverse);
   1.242  
   1.243 +    cx_test_register(suite, test_list_ll_create);
   1.244 +    cx_test_register(suite, test_list_ll_create_simple);
   1.245 +    cx_test_register(suite, test_list_ll_store_pointers);
   1.246 +    cx_test_register(suite, test_list_ll_create_simple_for_pointers);
   1.247 +    cx_test_register(suite, test_list_pll_destroy_no_destr);
   1.248 +    cx_test_register(suite, test_list_pll_destroy_simple_destr);
   1.249 +    cx_test_register(suite, test_list_pll_destroy_adv_destr);
   1.250 +
   1.251      return suite;
   1.252  }
   1.253  

     2.1 --- a/tests/test_list.cpp	Tue Jan 09 21:25:08 2024 +0100
     2.2 +++ b/tests/test_list.cpp	Wed Jan 10 22:13:23 2024 +0100
     2.3 @@ -848,153 +848,5 @@
     2.4      verifyAdvancedDestructor(pointerArrayListFromTestData());
     2.5  }
     2.6  
     2.7 -TEST_F(PointerLinkedList, cxListStorePointers) {
     2.8 -    auto list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, 47));
     2.9 -    CX_TEST_ASSERT(!cxListIsStoringPointers(list));
    2.10 -    cxListStorePointers(list);
    2.11 -    EXPECT_EQ(list->item_size, sizeof(void *));
    2.12 -    CX_TEST_ASSERT(list->cl != NULL);
    2.13 -    CX_TEST_ASSERT(list->climpl != NULL);
    2.14 -    CX_TEST_ASSERT(cxListIsStoringPointers(list));
    2.15 -    cxListStoreObjects(list);
    2.16 -    CX_TEST_ASSERT(list->cl != NULL);
    2.17 -    EXPECT_EQ(list->climpl, NULL);
    2.18 -    CX_TEST_ASSERT(!cxListIsStoringPointers(list));
    2.19 -}
    2.20  
    2.21 -TEST_F(LinkedList, cxLinkedListCreate) {
    2.22 -    CxList *list = autofree(cxLinkedListCreate(&testingAllocator, cx_cmp_int, sizeof(int)));
    2.23 -    ASSERT_NE(list, NULL);
    2.24 -    EXPECT_EQ(list->item_size, sizeof(int));
    2.25 -    EXPECT_EQ(list->simple_destructor, NULL);
    2.26 -    EXPECT_EQ(list->advanced_destructor, NULL);
    2.27 -    EXPECT_EQ(list->destructor_data, NULL);
    2.28 -    EXPECT_EQ(cxListSize(list), 0);
    2.29 -    EXPECT_EQ(list->allocator, &testingAllocator);
    2.30 -    EXPECT_EQ(list->cmpfunc, cx_cmp_int);
    2.31 -    CX_TEST_ASSERT(!cxListIsStoringPointers(list));
    2.32 -}
    2.33  
    2.34 -TEST_F(LinkedList, cxLinkedListCreateSimple) {
    2.35 -    CxList *list = autofree(cxLinkedListCreateSimple(sizeof(int)));
    2.36 -    ASSERT_NE(list, NULL);
    2.37 -    EXPECT_EQ(list->item_size, sizeof(int));
    2.38 -    EXPECT_EQ(list->cmpfunc, NULL);
    2.39 -    EXPECT_EQ(list->allocator, cxDefaultAllocator);
    2.40 -    EXPECT_EQ(list->simple_destructor, NULL);
    2.41 -    EXPECT_EQ(list->advanced_destructor, NULL);
    2.42 -    EXPECT_EQ(list->destructor_data, NULL);
    2.43 -    EXPECT_EQ(cxListSize(list), 0);
    2.44 -    CX_TEST_ASSERT(!cxListIsStoringPointers(list));
    2.45 -}
    2.46 -
    2.47 -TEST_F(PointerLinkedList, cxLinkedListCreateSimpleForPointers) {
    2.48 -    CxList *list = autofree(cxLinkedListCreateSimple(CX_STORE_POINTERS));
    2.49 -    ASSERT_NE(list, NULL);
    2.50 -    EXPECT_EQ(list->item_size, sizeof(void *));
    2.51 -    EXPECT_EQ(list->cmpfunc, cx_cmp_ptr);
    2.52 -    EXPECT_EQ(list->allocator, cxDefaultAllocator);
    2.53 -    EXPECT_EQ(list->simple_destructor, NULL);
    2.54 -    EXPECT_EQ(list->advanced_destructor, NULL);
    2.55 -    EXPECT_EQ(list->destructor_data, NULL);
    2.56 -    EXPECT_EQ(cxListSize(list), 0);
    2.57 -    CX_TEST_ASSERT(cxListIsStoringPointers(list));
    2.58 -}
    2.59 -
    2.60 -TEST_F(ArrayList, cxArrayListCreate) {
    2.61 -    CxList *list = autofree(cxArrayListCreate(&testingAllocator, cx_cmp_int, sizeof(int), 8));
    2.62 -    ASSERT_NE(list, NULL);
    2.63 -    EXPECT_EQ(list->item_size, sizeof(int));
    2.64 -    EXPECT_EQ(list->simple_destructor, NULL);
    2.65 -    EXPECT_EQ(list->advanced_destructor, NULL);
    2.66 -    EXPECT_EQ(list->destructor_data, NULL);
    2.67 -    EXPECT_EQ(cxListSize(list), 0);
    2.68 -    EXPECT_EQ(list->allocator, &testingAllocator);
    2.69 -    EXPECT_EQ(list->cmpfunc, cx_cmp_int);
    2.70 -    CX_TEST_ASSERT(!cxListIsStoringPointers(list));
    2.71 -}
    2.72 -
    2.73 -TEST_F(ArrayList, cxArrayListCreateSimple) {
    2.74 -    CxList *list = autofree(cxArrayListCreateSimple(sizeof(int), 8));
    2.75 -    ASSERT_NE(list, NULL);
    2.76 -    EXPECT_EQ(list->cmpfunc, NULL);
    2.77 -    EXPECT_EQ(list->allocator, cxDefaultAllocator);
    2.78 -    EXPECT_EQ(list->item_size, sizeof(int));
    2.79 -    EXPECT_EQ(list->simple_destructor, NULL);
    2.80 -    EXPECT_EQ(list->advanced_destructor, NULL);
    2.81 -    EXPECT_EQ(list->destructor_data, NULL);
    2.82 -    EXPECT_EQ(cxListSize(list), 0);
    2.83 -    CX_TEST_ASSERT(!cxListIsStoringPointers(list));
    2.84 -}
    2.85 -
    2.86 -TEST_F(PointerArrayList, cxArrayListCreateSimpleForPointers) {
    2.87 -    CxList *list = autofree(cxArrayListCreateSimple(CX_STORE_POINTERS, 8));
    2.88 -    ASSERT_NE(list, NULL);
    2.89 -    EXPECT_EQ(list->cmpfunc, cx_cmp_ptr);
    2.90 -    EXPECT_EQ(list->allocator, cxDefaultAllocator);
    2.91 -    EXPECT_EQ(list->item_size, sizeof(void *));
    2.92 -    CX_TEST_ASSERT(cxListIsStoringPointers(list));
    2.93 -}
    2.94 -
    2.95 -TEST_F(PointerLinkedList, DestroyNoDestructor) {
    2.96 -    void *item = cxMalloc(&testingAllocator, sizeof(int));
    2.97 -    auto list = cxLinkedListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS);
    2.98 -    cxListAdd(list, item);
    2.99 -    CX_TEST_ASSERT(!testingAllocator.verify());
   2.100 -    cxListDestroy(list);
   2.101 -    CX_TEST_ASSERT(!testingAllocator.verify());
   2.102 -    cxFree(&testingAllocator, item);
   2.103 -    CX_TEST_ASSERT(testingAllocator.verify());
   2.104 -}
   2.105 -
   2.106 -TEST_F(PointerLinkedList, DestroySimpleDestructor) {
   2.107 -    int item = 0;
   2.108 -    auto list = cxLinkedListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS);
   2.109 -    list->simple_destructor = [](void *elem) { *(int *) elem = 42; };
   2.110 -    cxListAdd(list, &item);
   2.111 -    cxListDestroy(list);
   2.112 -    EXPECT_EQ(item, 42);
   2.113 -}
   2.114 -
   2.115 -TEST_F(PointerLinkedList, DestroyAdvancedDestructor) {
   2.116 -    void *item = cxMalloc(&testingAllocator, sizeof(int));
   2.117 -    auto list = cxLinkedListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS);
   2.118 -    list->destructor_data = &testingAllocator;
   2.119 -    list->advanced_destructor = (cx_destructor_func2) cxFree;
   2.120 -    cxListAdd(list, item);
   2.121 -    CX_TEST_ASSERT(!testingAllocator.verify());
   2.122 -    cxListDestroy(list);
   2.123 -    CX_TEST_ASSERT(testingAllocator.verify());
   2.124 -}
   2.125 -
   2.126 -TEST_F(PointerArrayList, DestroyNoDestructor) {
   2.127 -    void *item = cxMalloc(&testingAllocator, sizeof(int));
   2.128 -    auto list = cxArrayListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS, 4);
   2.129 -    cxListAdd(list, item);
   2.130 -    CX_TEST_ASSERT(!testingAllocator.verify());
   2.131 -    cxListDestroy(list);
   2.132 -    CX_TEST_ASSERT(!testingAllocator.verify());
   2.133 -    cxFree(&testingAllocator, item);
   2.134 -    CX_TEST_ASSERT(testingAllocator.verify());
   2.135 -}
   2.136 -
   2.137 -TEST_F(PointerArrayList, DestroySimpleDestructor) {
   2.138 -    int item = 0;
   2.139 -    auto list = cxArrayListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS, 4);
   2.140 -    list->simple_destructor = [](void *elem) { *(int *) elem = 42; };
   2.141 -    cxListAdd(list, &item);
   2.142 -    cxListDestroy(list);
   2.143 -    EXPECT_EQ(item, 42);
   2.144 -}
   2.145 -
   2.146 -TEST_F(PointerArrayList, DestroyAdvancedDestructor) {
   2.147 -    void *item = cxMalloc(&testingAllocator, sizeof(int));
   2.148 -    auto list = cxArrayListCreate(cxDefaultAllocator, cx_cmp_int, CX_STORE_POINTERS, 4);
   2.149 -    list->destructor_data = &testingAllocator;
   2.150 -    list->advanced_destructor = (cx_destructor_func2) cxFree;
   2.151 -    cxListAdd(list, item);
   2.152 -    CX_TEST_ASSERT(!testingAllocator.verify());
   2.153 -    cxListDestroy(list);
   2.154 -    CX_TEST_ASSERT(testingAllocator.verify());
   2.155 -}
   2.156 -