ucx: test/test_list.c@e075009b33b7

remove convenience macros

Users should write their own wrappers s.t. the type
information does not have to be repeated on every
call site.

     1 /*

     2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

     3  *

     4  * Copyright 2021 Mike Becker, Olaf Wintermann All rights reserved.

     5  *

     6  * Redistribution and use in source and binary forms, with or without

     7  * modification, are permitted provided that the following conditions are met:

     8  *

     9  *   1. Redistributions of source code must retain the above copyright

    10  *      notice, this list of conditions and the following disclaimer.

    11  *

    12  *   2. Redistributions in binary form must reproduce the above copyright

    13  *      notice, this list of conditions and the following disclaimer in the

    14  *      documentation and/or other materials provided with the distribution.

    15  *

    16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

    17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

    20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

    21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

    22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

    23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

    24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

    25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

    26  * POSSIBILITY OF SUCH DAMAGE.

    27  */

    29 #include "cx/linked_list.h"

    30 #include "test_config.h"

    31 #include "util_allocator.h"

    33 int cmp_int(int const *l, int const *r) {

    34     int left = *l, right = *r;

    35     return left == right ? 0 : (left < right ? -1 : 1);

    36 }

    38 void test_linked_list_at(void) {

    39     struct node {

    40         void *next;

    41         void *prev;

    42     };

    43     const ptrdiff_t loc_prev = offsetof(struct node, prev);

    44     const ptrdiff_t loc_next = offsetof(struct node, next);

    46     struct node a, b, c, d;

    47     a.prev = NULL;

    48     a.next = &b;

    49     b.prev = &a;

    50     b.next = &c;

    51     c.prev = &b;

    52     c.next = &d;

    53     d.prev = &c;

    54     d.next = NULL;

    56     CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&a, 0, loc_next, 0), &a)

    57     CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&a, 0, loc_next, 1), &b)

    58     CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&a, 0, loc_next, 2), &c)

    59     CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&a, 0, loc_next, 3), &d)

    60     CU_ASSERT_PTR_NULL(cx_linked_list_at(&a, 0, loc_next, 4))

    62     CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&b, 1, loc_prev, 0), &a)

    63     CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&b, 1, loc_next, 1), &b)

    64     CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&b, 1, loc_next, 2), &c)

    65     CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&b, 1, loc_next, 3), &d)

    66     CU_ASSERT_PTR_NULL(cx_linked_list_at(&b, 1, loc_next, 4))

    68     CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&d, 3, loc_prev, 0), &a)

    69     CU_ASSERT_PTR_EQUAL(cx_linked_list_at(&d, 3, loc_prev, 1), &b)

    70 }

    72 void test_linked_list_add(void) {

    73     struct node {

    74         void *prev;

    75         void *next;

    76     };

    78     struct node nodes[4];

    80     // test with begin, end / prev, next

    81     memset(nodes, 0, 4 * sizeof(struct node));

    82     void *begin = NULL;

    83     void *end = NULL;

    85     ptrdiff_t loc_prev = offsetof(struct node, prev);

    86     ptrdiff_t loc_next = offsetof(struct node, next);

    88     cx_linked_list_add(&begin, &end, loc_prev, loc_next, &nodes[0]);

    89     CU_ASSERT_PTR_EQUAL(begin, &nodes[0])

    90     CU_ASSERT_PTR_EQUAL(end, &nodes[0])

    91     CU_ASSERT_PTR_EQUAL(nodes[0].prev, NULL)

    92     CU_ASSERT_PTR_EQUAL(nodes[0].next, NULL)

    94     cx_linked_list_add(&begin, &end, loc_prev, loc_next, &nodes[1]);

    95     CU_ASSERT_PTR_EQUAL(begin, &nodes[0])

    96     CU_ASSERT_PTR_EQUAL(end, &nodes[1])

    97     CU_ASSERT_PTR_EQUAL(nodes[0].next, &nodes[1])

    98     CU_ASSERT_PTR_EQUAL(nodes[1].prev, &nodes[0])

   100     // test with begin only / prev, next

   101     memset(nodes, 0, 4 * sizeof(struct node));

   102     begin = NULL;

   103     end = NULL;

   105     cx_linked_list_add(&begin, NULL, loc_prev, loc_next, &nodes[0]);

   106     CU_ASSERT_PTR_EQUAL(begin, &nodes[0])

   107     cx_linked_list_add(&begin, NULL, loc_prev, loc_next, &nodes[1]);

   108     CU_ASSERT_PTR_EQUAL(begin, &nodes[0])

   109     CU_ASSERT_PTR_EQUAL(nodes[0].next, &nodes[1])

   110     CU_ASSERT_PTR_EQUAL(nodes[1].prev, &nodes[0])

   112     cx_linked_list_add(&begin, NULL, loc_prev, loc_next, &nodes[2]);

   113     CU_ASSERT_PTR_EQUAL(nodes[1].next, &nodes[2])

   114     CU_ASSERT_PTR_EQUAL(nodes[2].prev, &nodes[1])

   116     // test with begin, end / next

   117     memset(nodes, 0, 4 * sizeof(struct node));

   118     begin = NULL;

   119     end = NULL;

   121     cx_linked_list_add(&begin, &end, -1, loc_next, &nodes[0]);

   122     CU_ASSERT_PTR_EQUAL(begin, &nodes[0])

   123     CU_ASSERT_PTR_EQUAL(end, &nodes[0])

   124     cx_linked_list_add(&begin, &end, -1, loc_next, &nodes[1]);

   125     CU_ASSERT_PTR_EQUAL(end, &nodes[1])

   126     CU_ASSERT_PTR_EQUAL(nodes[0].next, &nodes[1])

   127     CU_ASSERT_PTR_NULL(nodes[1].prev)

   128 }

   130 void test_linked_list_last(void) {

   131     CU_ASSERT_PTR_NULL(cx_linked_list_last(NULL, -1))

   132     CU_ASSERT_PTR_NULL(cx_linked_list_last(NULL, 0))

   134     struct node {

   135         int data;

   136         void *next;

   137     };

   138     ptrdiff_t loc = offsetof(struct node, next);

   140     struct node third = {3, NULL};

   141     struct node second = {2, &third};

   142     struct node first = {1, &second};

   144     CU_ASSERT_PTR_EQUAL(cx_linked_list_last(&first, loc), &third)

   145     CU_ASSERT_PTR_EQUAL(cx_linked_list_last(&second, loc), &third)

   146     CU_ASSERT_PTR_EQUAL(cx_linked_list_last(&third, loc), &third)

   147 }

   150 void test_hl_linked_list_create(void) {

   151     cxTestingAllocatorReset();

   153     CxList list = cxLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int, sizeof(int));

   155     CU_ASSERT_EQUAL(list->size, 0)

   156     CU_ASSERT_EQUAL(list->capacity, (size_t) -1)

   157     CU_ASSERT_PTR_EQUAL(list->allocator, cxTestingAllocator)

   158     CU_ASSERT_EQUAL(list->itemsize, sizeof(int))

   159     CU_ASSERT_PTR_EQUAL(list->cmpfunc, cmp_int)

   161     // assume this structure for a linked list

   162     struct ll_check {

   163         cx_list_s base;

   164         void *begin;

   165         void *end;

   166     };

   168     struct ll_check *actual = (struct ll_check *) list;

   169     CU_ASSERT_PTR_NULL(actual->begin)

   170     CU_ASSERT_PTR_NULL(actual->end)

   172     cxLinkedListDestroy(list);

   174     CU_ASSERT_TRUE(cxTestingAllocatorVerify())

   175 }

   177 void test_hl_linked_list_add(void) {

   178     cxTestingAllocatorReset();

   180     int data;

   181     CxList list = cxLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int, sizeof(int));

   183     data = 5;

   184     CU_ASSERT_EQUAL(cxListAdd(list, &data), 0)

   185     data = 47;

   186     CU_ASSERT_EQUAL(cxListAdd(list, &data), 0)

   187     data = 13;

   188     CU_ASSERT_EQUAL(cxListAdd(list, &data), 0)

   190     CU_ASSERT_EQUAL(list->size, 3)

   191     CU_ASSERT_TRUE(list->capacity >= list->size)

   193     CU_ASSERT_EQUAL(*(int*)cxListAt(list, 0), 5)

   194     CU_ASSERT_EQUAL(*(int*)cxListAt(list, 1), 47)

   195     CU_ASSERT_EQUAL(*(int*)cxListAt(list, 2), 13)

   197     cxLinkedListDestroy(list);

   198     CU_ASSERT_TRUE(cxTestingAllocatorVerify())

   199 }

   201 void test_hl_linked_list_last(void) {

   202     cxTestingAllocatorReset();

   204     int data;

   205     CxList list = cxLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int, sizeof(int));

   207     CU_ASSERT_PTR_NULL(cxListLast(list))

   209     data = 5;

   210     CU_ASSERT_EQUAL(cxListAdd(list, &data), 0)

   211     CU_ASSERT_EQUAL(*(int*)cxListLast(list), 5)

   213     data = 47;

   214     CU_ASSERT_EQUAL(cxListAdd(list, &data), 0)

   215     CU_ASSERT_EQUAL(*(int*)cxListLast(list), 47)

   217     cxLinkedListDestroy(list);

   218     CU_ASSERT_TRUE(cxTestingAllocatorVerify())

   219 }

   221 void test_hl_linked_list_insert(void) {

   222     cxTestingAllocatorReset();

   224     int data;

   225     CxList list = cxLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int, sizeof(int));

   227     data = 5;

   228     CU_ASSERT_NOT_EQUAL(cxListInsert(list, 1, &data), 0)

   229     CU_ASSERT_EQUAL(list->size, 0)

   230     CU_ASSERT_EQUAL(cxListInsert(list, 0, &data), 0)

   231     CU_ASSERT_EQUAL(list->size, 1)

   232     data = 47;

   233     CU_ASSERT_EQUAL(cxListInsert(list, 0, &data), 0)

   234     CU_ASSERT_EQUAL(list->size, 2)

   235     data = 13;

   236     CU_ASSERT_EQUAL(cxListInsert(list, 1, &data), 0)

   237     CU_ASSERT_EQUAL(list->size, 3)

   238     data = 42;

   239     CU_ASSERT_EQUAL(cxListInsert(list, 3, &data), 0)

   241     CU_ASSERT_EQUAL(list->size, 4)

   242     CU_ASSERT_TRUE(list->capacity >= list->size)

   244     CU_ASSERT_EQUAL(*(int*)cxListAt(list, 0), 47)

   245     CU_ASSERT_EQUAL(*(int*)cxListAt(list, 1), 13)

   246     CU_ASSERT_EQUAL(*(int*)cxListAt(list, 2), 5)

   247     CU_ASSERT_EQUAL(*(int*)cxListAt(list, 3), 42)

   249     cxLinkedListDestroy(list);

   250     CU_ASSERT_TRUE(cxTestingAllocatorVerify())

   251 }

   253 void test_hl_linked_list_remove(void) {

   254     cxTestingAllocatorReset();

   256     int data;

   257     CxList list = cxLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int, sizeof(int));

   259     data = 5;

   260     cxListAdd(list, &data);

   261     data = 47;

   262     cxListAdd(list, &data);

   263     data = 42;

   264     cxListAdd(list, &data);

   265     data = 13;

   266     cxListAdd(list, &data);

   268     CU_ASSERT_EQUAL(list->size, 4)

   269     CU_ASSERT_TRUE(list->capacity >= list->size)

   271     CU_ASSERT_NOT_EQUAL(cxListRemove(list, 4), 0)

   273     CU_ASSERT_EQUAL(cxListRemove(list, 2), 0)

   274     CU_ASSERT_EQUAL(list->size, 3)

   275     CU_ASSERT_TRUE(list->capacity >= list->size)

   276     CU_ASSERT_EQUAL(*(int*)cxListAt(list, 0), 5)

   277     CU_ASSERT_EQUAL(*(int*)cxListAt(list, 1), 47)

   278     CU_ASSERT_EQUAL(*(int*)cxListAt(list, 2), 13)

   280     CU_ASSERT_EQUAL(cxListRemove(list, 0), 0)

   281     CU_ASSERT_EQUAL(list->size, 2)

   282     CU_ASSERT_TRUE(list->capacity >= list->size)

   283     CU_ASSERT_EQUAL(*(int*)cxListAt(list, 0), 47)

   284     CU_ASSERT_EQUAL(*(int*)cxListAt(list, 1), 13)

   286     CU_ASSERT_EQUAL(cxListRemove(list, 1), 0)

   287     CU_ASSERT_EQUAL(list->size, 1)

   288     CU_ASSERT_TRUE(list->capacity >= list->size)

   289     CU_ASSERT_EQUAL(*(int*)cxListAt(list, 0), 47)

   291     CU_ASSERT_EQUAL(cxListRemove(list, 0), 0)

   292     CU_ASSERT_EQUAL(list->size, 0)

   293     CU_ASSERT_TRUE(list->capacity >= list->size)

   295     CU_ASSERT_NOT_EQUAL(cxListRemove(list, 0), 0)

   297     cxLinkedListDestroy(list);

   298     CU_ASSERT_TRUE(cxTestingAllocatorVerify())

   299 }

   301 void test_hl_linked_list_find(void) {

   302     cxTestingAllocatorReset();

   304     int data, criteria;

   305     CxList list = cxLinkedListCreate(cxTestingAllocator, (CxListComparator) cmp_int, sizeof(int));

   307     data = 5;

   308     cxListAdd(list, &data);

   309     data = 47;

   310     cxListAdd(list, &data);

   311     data = 13;

   312     cxListAdd(list, &data);

   314     CU_ASSERT_EQUAL(list->size, 3)

   315     CU_ASSERT_TRUE(list->capacity >= list->size)

   317     criteria = 5;

   318     CU_ASSERT_EQUAL(cxListFind(list, &criteria), 0)

   319     criteria = 47;

   320     CU_ASSERT_EQUAL(cxListFind(list, &criteria), 1)

   321     criteria = 13;

   322     CU_ASSERT_EQUAL(cxListFind(list, &criteria), 2)

   323     criteria = 9000;

   324     CU_ASSERT_EQUAL(cxListFind(list, &criteria), 3)

   325     criteria = -5;

   326     CU_ASSERT_EQUAL(cxListFind(list, &criteria), 3)

   328     cxLinkedListDestroy(list);

   329     CU_ASSERT_TRUE(cxTestingAllocatorVerify())

   330 }

   332 int main() {

   333     CU_pSuite suite = NULL;

   335     if (CUE_SUCCESS != CU_initialize_registry()) {

   336         return CU_get_error();

   337     }

   339     suite = CU_add_suite("low level linked list", NULL, NULL);

   341     cu_add_test(suite, test_linked_list_at);

   342     cu_add_test(suite, test_linked_list_add);

   343     cu_add_test(suite, test_linked_list_last);

   345     suite = CU_add_suite("high level linked list", NULL, NULL);

   347     cu_add_test(suite, test_hl_linked_list_create);

   348     cu_add_test(suite, test_hl_linked_list_add);

   349     cu_add_test(suite, test_hl_linked_list_last);

   350     cu_add_test(suite, test_hl_linked_list_insert);

   351     cu_add_test(suite, test_hl_linked_list_remove);

   352     cu_add_test(suite, test_hl_linked_list_find);

   354     CU_basic_set_mode(UCX_CU_BRM);

   356     int exitcode;

   357     if (CU_basic_run_tests()) {

   358         exitcode = CU_get_error();

   359     } else {

   360         exitcode = CU_get_number_of_failures() == 0 ? 0 : 1;

   361     }

   362     CU_cleanup_registry();

   363     return exitcode;

   364 }

Mercurial > hg > ucx / file revision

test/test_list.c@e075009b33b7

test/test_list.c