src/libstrongswan/tests/test_enumerator.c

   1 /*
   2  * Copyright (C) 2013 Tobias Brunner
   3  * Copyright (C) 2007 Martin Willi
   4  * Hochschule fuer Technik Rapperswil
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2 of the License, or (at your
   9  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * for more details.
  15  */
  16
  17 #include "test_suite.h"
  18
  19 #include <collections/enumerator.h>
  20 #include <collections/linked_list.h>
  21
  22 /*******************************************************************************
  23  * token test
  24  */
  25
  26 static const char *token_results1[] = { "abc", "cde", "efg" };
  27 static const char *token_results2[] = { "a", "b", "c" };
  28
  29 static struct {
  30         char *string;
  31         char *sep;
  32         char *trim;
  33         const char **results;
  34 } token_tests[] = {
  35         {"abc, cde, efg", ",", " ", token_results1},
  36         {" abc 1:2 cde;3  4efg5.  ", ":;.,", " 12345", token_results1},
  37         {"abc.cde,efg", ",.", "", token_results1},
  38         {"  abc   cde  efg  ", " ", " ", token_results1},
  39         {"a'abc' c 'cde' cefg", " ", " abcd", token_results1},
  40         {"'abc' abc 'cde'd 'efg'", " ", " abcd", token_results1},
  41
  42         {"a, b, c", ",", " ", token_results2},
  43         {"a,b,c", ",", " ", token_results2},
  44         {" a 1:2 b;3  4c5.  ", ":;.,", " 12345", token_results2},
  45         {"a.b,c", ",.", "", token_results2},
  46         {"  a   b  c  ", " ", " ", token_results2},
  47 };
  48
  49 START_TEST(test_token)
  50 {
  51         enumerator_t *enumerator;
  52         const char **results;
  53         char *token;
  54         int tok = 0;
  55
  56         enumerator = enumerator_create_token(token_tests[_i].string,
  57                                                                         token_tests[_i].sep, token_tests[_i].trim);
  58         results = token_tests[_i].results;
  59         while (enumerator->enumerate(enumerator, &token))
  60         {
  61                 switch (tok)
  62                 {
  63                         case 0:
  64                         case 1:
  65                         case 2:
  66                                 ck_assert_str_eq(token, results[tok]);
  67                                 break;
  68                         default:
  69                                 fail("unexpected token '%s'", token);
  70                 }
  71                 tok++;
  72         }
  73         fail_if(tok != 3, "not enough tokens (%d) extracted from '%s'",
  74                         tok, token_tests[_i].string);
  75         enumerator->destroy(enumerator);
  76 }
  77 END_TEST
  78
  79 /*******************************************************************************
  80  * utilities for filtered, nested and cleaner tests
  81  */
  82
  83 static int destroy_data_called;
  84
  85 START_SETUP(setup_destroy_data)
  86 {
  87         destroy_data_called = 0;
  88 }
  89 END_SETUP
  90
  91 START_TEARDOWN(teardown_destroy_data)
  92 {
  93         ck_assert_int_eq(destroy_data_called, 1);
  94 }
  95 END_TEARDOWN
  96
  97 static void destroy_data(void *data)
  98 {
  99         fail_if(data != (void*)101, "data does not match '101' in destructor");
 100         destroy_data_called++;
 101 }
 102
 103 /*******************************************************************************
 104  * filtered test
 105  */
 106
 107 static bool filter(void *data, int *v, int *vo, int *w, int *wo,
 108                                    int *x, int *xo, int *y, int *yo, int *z, int *zo)
 109 {
 110         int val = *v;
 111
 112         *vo = val++;
 113         *wo = val++;
 114         *xo = val++;
 115         *yo = val++;
 116         *zo = val++;
 117         fail_if(data != (void*)101, "data does not match '101' in filter function");
 118         return TRUE;
 119 }
 120
 121 static bool filter_odd(void *data, int *item, int *out)
 122 {
 123         fail_if(data != (void*)101, "data does not match '101' in filter function");
 124         *out = *item;
 125         return *item % 2 == 0;
 126 }
 127
 128 START_TEST(test_filtered)
 129 {
 130         int round, v, w, x, y, z;
 131         linked_list_t *list;
 132         enumerator_t *enumerator;
 133
 134         list = linked_list_create_with_items((void*)1, (void*)2, (void*)3, (void*)4,
 135                                                                                  (void*)5, NULL);
 136
 137         round = 1;
 138         enumerator = enumerator_create_filter(list->create_enumerator(list),
 139                                                                         (void*)filter, (void*)101, destroy_data);
 140         while (enumerator->enumerate(enumerator, &v, &w, &x, &y, &z))
 141         {
 142                 ck_assert_int_eq(v, round);
 143                 ck_assert_int_eq(w, round + 1);
 144                 ck_assert_int_eq(x, round + 2);
 145                 ck_assert_int_eq(y, round + 3);
 146                 ck_assert_int_eq(z, round + 4);
 147                 round++;
 148         }
 149         enumerator->destroy(enumerator);
 150         ck_assert_int_eq(round, 6);
 151
 152         list->destroy(list);
 153 }
 154 END_TEST
 155
 156 START_TEST(test_filtered_filter)
 157 {
 158         int count, x;
 159         linked_list_t *list;
 160         enumerator_t *enumerator;
 161
 162         list = linked_list_create_with_items((void*)1, (void*)2, (void*)3, (void*)4,
 163                                                                                  (void*)5, NULL);
 164
 165         count = 0;
 166         /* should also work without destructor, so set this manually */
 167         destroy_data_called = 1;
 168         enumerator = enumerator_create_filter(list->create_enumerator(list),
 169                                                                                  (void*)filter_odd, (void*)101, NULL);
 170         while (enumerator->enumerate(enumerator, &x))
 171         {
 172                 ck_assert(x % 2 == 0);
 173                 count++;
 174         }
 175         enumerator->destroy(enumerator);
 176         ck_assert_int_eq(count, 2);
 177
 178         list->destroy(list);
 179 }
 180 END_TEST
 181
 182 /*******************************************************************************
 183  * nested test
 184  */
 185
 186 static enumerator_t* create_inner(linked_list_t *outer, void *data)
 187 {
 188         fail_if(data != (void*)101, "data does not match '101' in nested constr.");
 189         return outer->create_enumerator(outer);
 190 }
 191
 192 static enumerator_t* create_inner_null(void *outer, void *data)
 193 {
 194         ck_assert(outer == (void*)1);
 195         fail_if(data != (void*)101, "data does not match '101' in nested constr.");
 196         return NULL;
 197 }
 198
 199 START_TEST(test_nested)
 200 {
 201         linked_list_t *list, *l1, *l2, *l3;
 202         enumerator_t *enumerator;
 203         intptr_t x;
 204         int round;
 205
 206         l1 = linked_list_create_with_items((void*)1, (void*)2, NULL);
 207         l2 = linked_list_create();
 208         l3 = linked_list_create_with_items((void*)3, (void*)4, (void*)5, NULL);
 209         list = linked_list_create_with_items(l1, l2, l3, NULL);
 210
 211         round = 1;
 212         enumerator = enumerator_create_nested(list->create_enumerator(list),
 213                                                                 (void*)create_inner, (void*)101, destroy_data);
 214         while (enumerator->enumerate(enumerator, &x))
 215         {
 216                 ck_assert_int_eq(round, x);
 217                 round++;
 218         }
 219         enumerator->destroy(enumerator);
 220         ck_assert_int_eq(round, 6);
 221
 222         list->destroy(list);
 223         l1->destroy(l1);
 224         l2->destroy(l2);
 225         l3->destroy(l3);
 226 }
 227 END_TEST
 228
 229 START_TEST(test_nested_reset)
 230 {
 231         linked_list_t *list, *l1, *l2, *l3;
 232         enumerator_t *outer, *enumerator;
 233         intptr_t x;
 234         int count = 0;
 235
 236         l1 = linked_list_create_with_items((void*)1, (void*)2, NULL);
 237         l2 = linked_list_create();
 238         l3 = linked_list_create_with_items((void*)3, (void*)4, (void*)5, NULL);
 239         list = linked_list_create_with_items(l1, l2, l3, NULL);
 240
 241         outer = list->create_enumerator(list);
 242         enumerator = enumerator_create_nested(outer, (void*)create_inner,
 243                                                                                  (void*)101, destroy_data);
 244         while (enumerator->enumerate(enumerator, &x))
 245         {
 246                 count++;
 247         }
 248         ck_assert_int_eq(count, 5);
 249
 250         list->reset_enumerator(list, outer);
 251         ck_assert(enumerator->enumerate(enumerator, &x));
 252         ck_assert_int_eq(x, 1);
 253         enumerator->destroy(enumerator);
 254
 255         list->destroy(list);
 256         l1->destroy(l1);
 257         l2->destroy(l2);
 258         l3->destroy(l3);
 259 }
 260 END_TEST
 261
 262 START_TEST(test_nested_empty)
 263 {
 264         linked_list_t *list;
 265         enumerator_t *enumerator;
 266         intptr_t x;
 267         int count;
 268
 269         list = linked_list_create();
 270         count = 0;
 271         enumerator = enumerator_create_nested(list->create_enumerator(list),
 272                                                                 (void*)create_inner, (void*)101, destroy_data);
 273         while (enumerator->enumerate(enumerator, &x))
 274         {
 275                 count++;
 276         }
 277         enumerator->destroy(enumerator);
 278         ck_assert_int_eq(count, 0);
 279
 280         list->destroy(list);
 281 }
 282 END_TEST
 283
 284 START_TEST(test_nested_null)
 285 {
 286         linked_list_t *list;
 287         enumerator_t *enumerator;
 288         intptr_t x;
 289         int count;
 290
 291         list = linked_list_create_with_items((void*)1, NULL);
 292
 293         count = 0;
 294         /* should also work without destructor, so set this manually */
 295         destroy_data_called = 1;
 296         enumerator = enumerator_create_nested(list->create_enumerator(list),
 297                                                                         (void*)create_inner_null, (void*)101, NULL);
 298         while (enumerator->enumerate(enumerator, &x))
 299         {
 300                 count++;
 301         }
 302         enumerator->destroy(enumerator);
 303         ck_assert_int_eq(count, 0);
 304
 305         list->destroy(list);
 306 }
 307 END_TEST
 308
 309 /*******************************************************************************
 310  * cleaner test
 311  */
 312
 313 START_TEST(test_cleaner)
 314 {
 315         enumerator_t *enumerator;
 316         linked_list_t *list;
 317         intptr_t x;
 318         int round;
 319
 320         list = linked_list_create_with_items((void*)1, (void*)2, NULL);
 321
 322         round = 1;
 323         enumerator = enumerator_create_cleaner(list->create_enumerator(list),
 324                                                                                    destroy_data, (void*)101);
 325         while (enumerator->enumerate(enumerator, &x))
 326         {
 327                 ck_assert_int_eq(round, x);
 328                 round++;
 329         }
 330         ck_assert_int_eq(round, 3);
 331         enumerator->destroy(enumerator);
 332         list->destroy(list);
 333 }
 334 END_TEST
 335
 336 /*******************************************************************************
 337  * single test
 338  */
 339
 340 static void single_cleanup(void *data)
 341 {
 342         ck_assert_int_eq((intptr_t)data, 1);
 343 }
 344
 345 static void do_test_single(enumerator_t *enumerator)
 346 {
 347         intptr_t x;
 348
 349         ck_assert(enumerator->enumerate(enumerator, &x));
 350         ck_assert_int_eq(x, 1);
 351         ck_assert(!enumerator->enumerate(enumerator, &x));
 352         enumerator->destroy(enumerator);
 353 }
 354
 355 START_TEST(test_single)
 356 {
 357         enumerator_t *enumerator;
 358
 359         enumerator = enumerator_create_single((void*)1, NULL);
 360         do_test_single(enumerator);
 361 }
 362 END_TEST
 363
 364 START_TEST(test_single_cleanup)
 365 {
 366         enumerator_t *enumerator;
 367
 368         enumerator = enumerator_create_single((void*)1, single_cleanup);
 369         do_test_single(enumerator);
 370 }
 371 END_TEST
 372
 373 Suite *enumerator_suite_create()
 374 {
 375         Suite *s;
 376         TCase *tc;
 377
 378         s = suite_create("enumerator");
 379
 380         tc = tcase_create("tokens");
 381         tcase_add_loop_test(tc, test_token, 0, countof(token_tests));
 382         suite_add_tcase(s, tc);
 383
 384         tc = tcase_create("filtered");
 385         tcase_add_checked_fixture(tc, setup_destroy_data, teardown_destroy_data);
 386         tcase_add_test(tc, test_filtered);
 387         tcase_add_test(tc, test_filtered_filter);
 388         suite_add_tcase(s, tc);
 389
 390         tc = tcase_create("nested");
 391         tcase_add_checked_fixture(tc, setup_destroy_data, teardown_destroy_data);
 392         tcase_add_test(tc, test_nested);
 393         tcase_add_test(tc, test_nested_reset);
 394         tcase_add_test(tc, test_nested_empty);
 395         tcase_add_test(tc, test_nested_null);
 396         suite_add_tcase(s, tc);
 397
 398         tc = tcase_create("cleaner");
 399         tcase_add_checked_fixture(tc, setup_destroy_data, teardown_destroy_data);
 400         tcase_add_test(tc, test_cleaner);
 401         suite_add_tcase(s, tc);
 402
 403         tc = tcase_create("single");
 404         tcase_add_test(tc, test_single);
 405         tcase_add_test(tc, test_single_cleanup);
 406         suite_add_tcase(s, tc);
 407
 408         return s;
 409 }