src/libstrongswan/tests/suites/test_linked_list_enumerator.c

   1 /*
   2  * Copyright (C) 2013 Tobias Brunner
   3  * HSR Hochschule fuer Technik Rapperswil
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2 of the License, or (at your
   8  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14  */
  15
  16 #include "test_suite.h"
  17
  18 #include <collections/linked_list.h>
  19
  20 /*******************************************************************************
  21  * test fixture
  22  */
  23
  24 static linked_list_t *list;
  25
  26 START_SETUP(setup_list)
  27 {
  28         list = linked_list_create_with_items((void*)1, (void*)2, (void*)3, (void*)4,
  29                                                                          (void*)5, NULL);
  30         ck_assert_int_eq(list->get_count(list), 5);
  31 }
  32 END_SETUP
  33
  34 START_TEARDOWN(teardown_list)
  35 {
  36         list->destroy(list);
  37 }
  38 END_TEARDOWN
  39
  40 /*******************************************************************************
  41  * enumeration
  42  */
  43
  44 START_TEST(test_enumerate)
  45 {
  46         enumerator_t *enumerator;
  47         intptr_t x;
  48         int round;
  49
  50         round = 1;
  51         enumerator = list->create_enumerator(list);
  52         while (enumerator->enumerate(enumerator, &x))
  53         {
  54                 ck_assert_int_eq(round, x);
  55                 round++;
  56         }
  57         ck_assert_int_eq(round, 6);
  58         enumerator->destroy(enumerator);
  59 }
  60 END_TEST
  61
  62 START_TEST(test_enumerate_null)
  63 {
  64         enumerator_t *enumerator;
  65         int round;
  66
  67         round = 1;
  68         enumerator = list->create_enumerator(list);
  69         while (enumerator->enumerate(enumerator, NULL))
  70         {
  71                 round++;
  72         }
  73         ck_assert_int_eq(round, 6);
  74         enumerator->destroy(enumerator);
  75 }
  76 END_TEST
  77
  78 START_TEST(test_reset_enumerator)
  79 {
  80         enumerator_t *enumerator;
  81         intptr_t x;
  82         int round;
  83
  84         enumerator = list->create_enumerator(list);
  85         while (enumerator->enumerate(enumerator, &x))
  86         {
  87         }
  88         list->reset_enumerator(list, enumerator);
  89         round = 1;
  90         while (enumerator->enumerate(enumerator, &x))
  91         {
  92                 ck_assert_int_eq(round, x);
  93                 round++;
  94         }
  95         ck_assert_int_eq(round, 6);
  96         enumerator->destroy(enumerator);
  97 }
  98 END_TEST
  99
 100 /*******************************************************************************
 101  * insert before
 102  */
 103
 104 START_TEST(test_insert_before)
 105 {
 106         enumerator_t *enumerator;
 107         intptr_t x;
 108         int round;
 109
 110         round = 1;
 111         enumerator = list->create_enumerator(list);
 112         while (enumerator->enumerate(enumerator, &x))
 113         {
 114                 ck_assert_int_eq(round, x);
 115                 round++;
 116                 if (x == _i)
 117                 {
 118                         list->insert_before(list, enumerator, (void*)6);
 119                 }
 120         }
 121         ck_assert_int_eq(list->get_count(list), 6);
 122         list->reset_enumerator(list, enumerator);
 123         round = 1;
 124         while (enumerator->enumerate(enumerator, &x))
 125         {
 126                 if (round == _i && x != _i)
 127                 {
 128                         ck_assert_int_eq(6, x);
 129                 }
 130                 else
 131                 {
 132                         ck_assert_int_eq(round, x);
 133                         round++;
 134                 }
 135         }
 136         enumerator->destroy(enumerator);
 137 }
 138 END_TEST
 139
 140 START_TEST(test_insert_before_ends)
 141 {
 142         enumerator_t *enumerator;
 143         intptr_t x;
 144         int round;
 145
 146         enumerator = list->create_enumerator(list);
 147         /* this does not change the enumerator position, which points to 1 */
 148         list->insert_before(list, enumerator, (void*)0);
 149         ck_assert_int_eq(list->get_count(list), 6);
 150         ck_assert(list->get_first(list, (void*)&x) == SUCCESS);
 151         ck_assert_int_eq(x, 0);
 152         round = 1;
 153         while (enumerator->enumerate(enumerator, &x))
 154         {
 155                 ck_assert_int_eq(round, x);
 156                 round++;
 157         }
 158         list->insert_before(list, enumerator, (void*)6);
 159         ck_assert_int_eq(list->get_count(list), 7);
 160         ck_assert(list->get_last(list, (void*)&x) == SUCCESS);
 161         ck_assert_int_eq(x, 6);
 162         ck_assert(!enumerator->enumerate(enumerator, &x));
 163         enumerator->destroy(enumerator);
 164 }
 165 END_TEST
 166
 167 START_TEST(test_insert_before_empty)
 168 {
 169         enumerator_t *enumerator;
 170         intptr_t x;
 171
 172         list->destroy(list);
 173         list = linked_list_create();
 174         enumerator = list->create_enumerator(list);
 175         list->insert_before(list, enumerator, (void*)1);
 176         ck_assert_int_eq(list->get_count(list), 1);
 177         ck_assert(list->get_first(list, (void*)&x) == SUCCESS);
 178         ck_assert_int_eq(x, 1);
 179         ck_assert(list->get_last(list, (void*)&x) == SUCCESS);
 180         ck_assert_int_eq(x, 1);
 181         ck_assert(!enumerator->enumerate(enumerator, &x));
 182         list->insert_before(list, enumerator, (void*)2);
 183         ck_assert_int_eq(list->get_count(list), 2);
 184         ck_assert(list->get_first(list, (void*)&x) == SUCCESS);
 185         ck_assert_int_eq(x, 1);
 186         ck_assert(list->get_last(list, (void*)&x) == SUCCESS);
 187         ck_assert_int_eq(x, 2);
 188         ck_assert(!enumerator->enumerate(enumerator, NULL));
 189         enumerator->destroy(enumerator);
 190 }
 191 END_TEST
 192
 193 /*******************************************************************************
 194  * remove_at
 195  */
 196
 197 START_TEST(test_remove_at)
 198 {
 199         enumerator_t *enumerator;
 200         intptr_t x;
 201         int round;
 202
 203         round = 1;
 204         enumerator = list->create_enumerator(list);
 205         while (enumerator->enumerate(enumerator, &x))
 206         {
 207                 ck_assert_int_eq(round, x);
 208                 if (round == 2)
 209                 {
 210                         list->remove_at(list, enumerator);
 211                 }
 212                 round++;
 213         }
 214         ck_assert_int_eq(list->get_count(list), 4);
 215         list->reset_enumerator(list, enumerator);
 216         round = 1;
 217         while (enumerator->enumerate(enumerator, &x))
 218         {
 219                 if (round == 2)
 220                 {       /* skip removed item */
 221                         round++;
 222                 }
 223                 ck_assert_int_eq(round, x);
 224                 round++;
 225         }
 226         enumerator->destroy(enumerator);
 227 }
 228 END_TEST
 229
 230 START_TEST(test_remove_at_multi)
 231 {
 232         enumerator_t *enumerator;
 233         intptr_t x;
 234         int round;
 235
 236         round = 1;
 237         enumerator = list->create_enumerator(list);
 238         while (enumerator->enumerate(enumerator, &x))
 239         {
 240                 ck_assert_int_eq(round, x);
 241                 if (round == 2 || round == 5)
 242                 {
 243                         list->remove_at(list, enumerator);
 244                 }
 245                 round++;
 246         }
 247         ck_assert_int_eq(list->get_count(list), 3);
 248         list->reset_enumerator(list, enumerator);
 249         round = 1;
 250         while (enumerator->enumerate(enumerator, &x))
 251         {
 252                 if (round == 2)
 253                 {       /* skip removed item */
 254                         round++;
 255                 }
 256                 ck_assert_int_eq(round, x);
 257                 list->remove_at(list, enumerator);
 258                 round++;
 259         }
 260         ck_assert_int_eq(list->get_count(list), 0);
 261         list->reset_enumerator(list, enumerator);
 262         ck_assert(!enumerator->enumerate(enumerator, &x));
 263         enumerator->destroy(enumerator);
 264 }
 265 END_TEST
 266
 267 START_TEST(test_remove_at_ends)
 268 {
 269         enumerator_t *enumerator;
 270         intptr_t x;
 271
 272         enumerator = list->create_enumerator(list);
 273         list->remove_at(list, enumerator);
 274         ck_assert_int_eq(list->get_count(list), 4);
 275         ck_assert(list->get_first(list, (void*)&x) == SUCCESS);
 276         ck_assert_int_eq(x, 2);
 277         while (enumerator->enumerate(enumerator, &x))
 278         {
 279         }
 280         list->remove_at(list, enumerator);
 281         ck_assert_int_eq(list->get_count(list), 4);
 282         ck_assert(list->get_last(list, (void*)&x) == SUCCESS);
 283         ck_assert_int_eq(x, 5);
 284         enumerator->destroy(enumerator);
 285 }
 286 END_TEST
 287
 288 START_TEST(test_insert_before_remove_at)
 289 {
 290         enumerator_t *enumerator;
 291         intptr_t x;
 292         int round;
 293
 294         round = 1;
 295         enumerator = list->create_enumerator(list);
 296         while (enumerator->enumerate(enumerator, &x))
 297         {
 298                 ck_assert_int_eq(round, x);
 299                 if (round == 2)
 300                 {       /* this replaces the current item */
 301                         list->insert_before(list, enumerator, (void*)42);
 302                         list->remove_at(list, enumerator);
 303                 }
 304                 else if (round == 4)
 305                 {       /* same here, the order of calls does not matter */
 306                         list->remove_at(list, enumerator);
 307                         list->insert_before(list, enumerator, (void*)21);
 308                 }
 309                 round++;
 310         }
 311         ck_assert_int_eq(list->get_count(list), 5);
 312         list->reset_enumerator(list, enumerator);
 313         round = 1;
 314         while (enumerator->enumerate(enumerator, &x))
 315         {
 316                 if (round == 2)
 317                 {       /* check replaced item */
 318                         ck_assert_int_eq(42, x);
 319                 }
 320                 else if (round == 4)
 321                 {       /* check replace item */
 322                         ck_assert_int_eq(21, x);
 323                 }
 324                 else
 325                 {
 326                         ck_assert_int_eq(round, x);
 327                 }
 328                 round++;
 329         }
 330         enumerator->destroy(enumerator);
 331 }
 332 END_TEST
 333
 334 /*******************************************************************************
 335  * create list from enumerator
 336  */
 337
 338 START_TEST(test_create_from_enumerator)
 339 {
 340         enumerator_t *enumerator, *enumerator_other;
 341         linked_list_t *other;
 342         intptr_t x, y;
 343         int count = 0;
 344
 345         enumerator = list->create_enumerator(list);
 346         other = linked_list_create_from_enumerator(enumerator);
 347         ck_assert_int_eq(other->get_count(list), 5);
 348
 349         enumerator = list->create_enumerator(list);
 350         enumerator_other = other->create_enumerator(other);
 351         while (enumerator->enumerate(enumerator, &x) &&
 352                    enumerator_other->enumerate(enumerator_other, &y))
 353         {
 354                 ck_assert_int_eq(x, y);
 355                 count++;
 356         }
 357         ck_assert_int_eq(count, 5);
 358         enumerator_other->destroy(enumerator_other);
 359         enumerator->destroy(enumerator);
 360         other->destroy(other);
 361 }
 362 END_TEST
 363
 364 Suite *linked_list_enumerator_suite_create()
 365 {
 366         Suite *s;
 367         TCase *tc;
 368
 369         s = suite_create("linked list and enumerators");
 370
 371         tc = tcase_create("enumerate");
 372         tcase_add_checked_fixture(tc, setup_list, teardown_list);
 373         tcase_add_test(tc, test_enumerate);
 374         tcase_add_test(tc, test_enumerate_null);
 375         tcase_add_test(tc, test_reset_enumerator);
 376         suite_add_tcase(s, tc);
 377
 378         tc = tcase_create("insert_before()");
 379         tcase_add_checked_fixture(tc, setup_list, teardown_list);
 380         tcase_add_loop_test(tc, test_insert_before, 1, 5);
 381         tcase_add_test(tc, test_insert_before_ends);
 382         tcase_add_test(tc, test_insert_before_empty);
 383         suite_add_tcase(s, tc);
 384
 385         tc = tcase_create("modify");
 386         tcase_add_checked_fixture(tc, setup_list, teardown_list);
 387         tcase_add_test(tc, test_remove_at);
 388         tcase_add_test(tc, test_remove_at_multi);
 389         tcase_add_test(tc, test_remove_at_ends);
 390         tcase_add_test(tc, test_insert_before_remove_at);
 391         suite_add_tcase(s, tc);
 392
 393         tc = tcase_create("create_from_enumerator");
 394         tcase_add_checked_fixture(tc, setup_list, teardown_list);
 395         tcase_add_test(tc, test_create_from_enumerator);
 396         suite_add_tcase(s, tc);
 397
 398         return s;
 399 }