ucx: tests/test_iterator.c@b2bc48c2b251

     1 /*

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

     3  *

     4  * Copyright 2024 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/test.h"

    31 #include "cx/iterator.h"

    33 CX_TEST(test_iterator_create) {

    34     size_t size = 20;

    35     unsigned array[size];

    36     for (unsigned i = 0 ; i < size ; i++) array[i] = i;

    38     CxMutIterator iter = cxIterator(array, sizeof(unsigned), size, false);

    39     CX_TEST_DO {

    40         CX_TEST_ASSERT(iter.index == 0);

    41         CX_TEST_ASSERT(iter.elem_size == sizeof(unsigned));

    42         CX_TEST_ASSERT(iter.elem_count == size);

    43         CX_TEST_ASSERT(iter.src_handle == array);

    44         CX_TEST_ASSERT(iter.elem_handle == &array[0]);

    45         CX_TEST_ASSERT(cxIteratorValid(iter));

    46     }

    47 }

    49 CX_TEST(test_iterator_create_null) {

    50     CxMutIterator iter = cxIterator(NULL, sizeof(unsigned), 47, false);

    51     CX_TEST_DO {

    52         CX_TEST_ASSERT(iter.index == 0);

    53         CX_TEST_ASSERT(iter.elem_size == sizeof(unsigned));

    54         CX_TEST_ASSERT(iter.elem_count == 0);

    55         CX_TEST_ASSERT(iter.src_handle == NULL);

    56         CX_TEST_ASSERT(iter.elem_handle == NULL);

    57         CX_TEST_ASSERT(!cxIteratorValid(iter));

    58     }

    59 }

    61 CX_TEST(test_iterator_iterate) {

    62     size_t size = 20;

    63     unsigned array[size];

    64     for (unsigned i = 0 ; i < size ; i++) array[i] = i;

    66     CxMutIterator iter = cxIterator(array, sizeof(unsigned), size, false);

    67     CX_TEST_DO {

    68         unsigned expected = 0;

    69         cx_foreach(unsigned *, e, iter) {

    70             CX_TEST_ASSERT(iter.index == expected);

    71             CX_TEST_ASSERT(*e == expected);

    72             CX_TEST_ASSERT(iter.elem_size == sizeof(unsigned));

    73             CX_TEST_ASSERT(iter.elem_count == size);

    74             CX_TEST_ASSERT(iter.src_handle == array);

    75             CX_TEST_ASSERT(iter.elem_handle == &array[expected]);

    76             expected++;

    77         }

    78         CX_TEST_ASSERT(expected == size);

    79     }

    80 }

    82 CX_TEST(test_iterator_with_slow_remove) {

    83     size_t size = 20;

    84     unsigned array[size];

    85     for (unsigned i = 0 ; i < size ; i++) array[i] = i;

    87     size_t elem_counts[] = {

    88             20, 20, 19, 19, 18, 18, 17, 17, 16, 16,

    89             15, 15, 14, 14, 13, 13, 12, 12, 11, 11

    90     };

    91     size_t indices[] = {

    92             0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5,

    93             6, 6, 7, 7, 8, 8, 9, 9, 10

    94     };

    95     unsigned expected_result[] = {

    96             0, 2, 4, 6, 8, 10, 12, 14, 16, 18

    97     };

    99     CxMutIterator iter = cxIterator(array, sizeof(unsigned), size, true);

   100     CX_TEST_DO {

   101         unsigned expected = 0;

   102         cx_foreach(unsigned *, e, iter) {

   103             CX_TEST_ASSERT(*e == expected);

   104             CX_TEST_ASSERT(iter.index == indices[expected]);

   105             CX_TEST_ASSERT(iter.elem_size == sizeof(unsigned));

   106             CX_TEST_ASSERT(iter.elem_count == elem_counts[expected]);

   107             CX_TEST_ASSERT(iter.src_handle == array);

   108             CX_TEST_ASSERT(iter.elem_handle == &array[indices[expected]]);

   109             expected++;

   110             if (expected % 2 == 0) {

   111                 cxIteratorFlagRemoval(iter);

   112             }

   113         }

   114         CX_TEST_ASSERT(expected == 20);

   115         CX_TEST_ASSERT(iter.index == 10);

   116         CX_TEST_ASSERT(iter.elem_count == 10);

   117         for (unsigned i = 0 ; i < 9 ; i++) {

   118             CX_TEST_ASSERT(array[i] == expected_result[i]);

   119         }

   120     }

   121 }

   123 CX_TEST(test_iterator_with_fast_remove) {

   124     size_t size = 20;

   125     unsigned array[size];

   126     for (unsigned i = 0 ; i < size ; i++) array[i] = i;

   128     size_t elem_counts[] = {

   129             20, 20, 19, 19, 18, 18, 17, 17, 16, 16,

   130             15, 15, 14, 14, 13, 13, 12, 12, 11, 11

   131     };

   132     size_t indices[] = {

   133             0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5,

   134             6, 6, 7, 7, 8, 8, 9, 9, 10

   135     };

   136     unsigned expected_result[] = {

   137             0, 19, 18, 17, 16, 15, 14, 13, 12, 11

   138     };

   139     unsigned expected_visits[] = {

   140             0, 1, 19, 2, 18, 3, 17, 4, 16, 5,

   141             15, 6, 14, 7, 13, 8, 12, 9, 11, 10

   142     };

   144     CxMutIterator iter = cxIterator(array, sizeof(unsigned), size, false);

   145     CX_TEST_DO {

   146         unsigned expected = 0;

   147         cx_foreach(unsigned *, e, iter) {

   148             CX_TEST_ASSERT(*e == expected_visits[expected]);

   149             CX_TEST_ASSERT(iter.index == indices[expected]);

   150             CX_TEST_ASSERT(iter.elem_size == sizeof(unsigned));

   151             CX_TEST_ASSERT(iter.elem_count == elem_counts[expected]);

   152             CX_TEST_ASSERT(iter.src_handle == array);

   153             CX_TEST_ASSERT(iter.elem_handle == &array[indices[expected]]);

   154             expected++;

   155             if (expected % 2 == 0) {

   156                 cxIteratorFlagRemoval(iter);

   157             }

   158         }

   159         CX_TEST_ASSERT(expected == 20);

   160         CX_TEST_ASSERT(iter.index == 10);

   161         CX_TEST_ASSERT(iter.elem_count == 10);

   162         for (unsigned i = 0 ; i < 9 ; i++) {

   163             CX_TEST_ASSERT(array[i] == expected_result[i]);

   164         }

   165     }

   166 }

   168 CxTestSuite *cx_test_suite_iterator(void) {

   169     CxTestSuite *suite = cx_test_suite_new("iterator");

   171     cx_test_register(suite, test_iterator_create);

   172     cx_test_register(suite, test_iterator_iterate);

   173     cx_test_register(suite, test_iterator_with_slow_remove);

   174     cx_test_register(suite, test_iterator_with_fast_remove);

   176     return suite;

   177 }

Mercurial > hg > ucx / file revision