Annotation of embedaddon/strongswan/src/libstrongswan/tests/suites/test_enumerator.c, revision 1.1
1.1 ! misho 1: /*
! 2: * Copyright (C) 2013 Tobias Brunner
! 3: * Copyright (C) 2007 Martin Willi
! 4: * HSR 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: CALLBACK(filter, bool,
! 108: int *data, enumerator_t *orig, va_list args)
! 109: {
! 110: int *item, *vo, *wo, *xo, *yo, *zo;
! 111:
! 112: VA_ARGS_VGET(args, vo, wo, xo, yo, zo);
! 113:
! 114: if (orig->enumerate(orig, &item))
! 115: {
! 116: int val = *item;
! 117: *vo = val++;
! 118: *wo = val++;
! 119: *xo = val++;
! 120: *yo = val++;
! 121: *zo = val++;
! 122: fail_if(data != (void*)101, "data does not match '101' in filter function");
! 123: return TRUE;
! 124: }
! 125: return FALSE;
! 126: }
! 127:
! 128: CALLBACK(filter_odd, bool,
! 129: void *data, enumerator_t *orig, va_list args)
! 130: {
! 131: int *item, *out;
! 132:
! 133: VA_ARGS_VGET(args, out);
! 134:
! 135: fail_if(data != (void*)101, "data does not match '101' in filter function");
! 136:
! 137: while (orig->enumerate(orig, &item))
! 138: {
! 139: if (*item % 2 == 0)
! 140: {
! 141: *out = *item;
! 142: return TRUE;
! 143: }
! 144: }
! 145: return FALSE;
! 146: }
! 147:
! 148: START_TEST(test_filtered)
! 149: {
! 150: int data[5] = {1,2,3,4,5}, round, v, w, x, y, z;
! 151: linked_list_t *list;
! 152: enumerator_t *enumerator;
! 153:
! 154: list = linked_list_create_with_items(&data[0], &data[1], &data[2], &data[3],
! 155: &data[4], NULL);
! 156:
! 157: round = 1;
! 158: enumerator = enumerator_create_filter(list->create_enumerator(list),
! 159: filter, (void*)101, destroy_data);
! 160: while (enumerator->enumerate(enumerator, &v, &w, &x, &y, &z))
! 161: {
! 162: ck_assert_int_eq(v, round);
! 163: ck_assert_int_eq(w, round + 1);
! 164: ck_assert_int_eq(x, round + 2);
! 165: ck_assert_int_eq(y, round + 3);
! 166: ck_assert_int_eq(z, round + 4);
! 167: round++;
! 168: }
! 169: enumerator->destroy(enumerator);
! 170: ck_assert_int_eq(round, 6);
! 171:
! 172: list->destroy(list);
! 173: }
! 174: END_TEST
! 175:
! 176: START_TEST(test_filtered_filter)
! 177: {
! 178: int data[5] = {1,2,3,4,5}, count, x;
! 179: linked_list_t *list;
! 180: enumerator_t *enumerator;
! 181:
! 182: list = linked_list_create_with_items(&data[0], &data[1], &data[2], &data[3],
! 183: &data[4], NULL);
! 184:
! 185: count = 0;
! 186: /* should also work without destructor, so set this manually */
! 187: destroy_data_called = 1;
! 188: enumerator = enumerator_create_filter(list->create_enumerator(list),
! 189: filter_odd, (void*)101, NULL);
! 190: while (enumerator->enumerate(enumerator, &x))
! 191: {
! 192: ck_assert(x % 2 == 0);
! 193: count++;
! 194: }
! 195: enumerator->destroy(enumerator);
! 196: ck_assert_int_eq(count, 2);
! 197:
! 198: list->destroy(list);
! 199: }
! 200: END_TEST
! 201:
! 202: /*******************************************************************************
! 203: * nested test
! 204: */
! 205:
! 206: static enumerator_t* create_inner(linked_list_t *outer, void *data)
! 207: {
! 208: fail_if(data != (void*)101, "data does not match '101' in nested constr.");
! 209: return outer->create_enumerator(outer);
! 210: }
! 211:
! 212: static enumerator_t* create_inner_null(void *outer, void *data)
! 213: {
! 214: ck_assert(outer == (void*)1);
! 215: fail_if(data != (void*)101, "data does not match '101' in nested constr.");
! 216: return NULL;
! 217: }
! 218:
! 219: START_TEST(test_nested)
! 220: {
! 221: linked_list_t *list, *l1, *l2, *l3;
! 222: enumerator_t *enumerator;
! 223: intptr_t x;
! 224: int round;
! 225:
! 226: l1 = linked_list_create_with_items((void*)1, (void*)2, NULL);
! 227: l2 = linked_list_create();
! 228: l3 = linked_list_create_with_items((void*)3, (void*)4, (void*)5, NULL);
! 229: list = linked_list_create_with_items(l1, l2, l3, NULL);
! 230:
! 231: round = 1;
! 232: enumerator = enumerator_create_nested(list->create_enumerator(list),
! 233: (void*)create_inner, (void*)101, destroy_data);
! 234: while (enumerator->enumerate(enumerator, &x))
! 235: {
! 236: ck_assert_int_eq(round, x);
! 237: round++;
! 238: }
! 239: enumerator->destroy(enumerator);
! 240: ck_assert_int_eq(round, 6);
! 241:
! 242: list->destroy(list);
! 243: l1->destroy(l1);
! 244: l2->destroy(l2);
! 245: l3->destroy(l3);
! 246: }
! 247: END_TEST
! 248:
! 249: START_TEST(test_nested_reset)
! 250: {
! 251: linked_list_t *list, *l1, *l2, *l3;
! 252: enumerator_t *outer, *enumerator;
! 253: intptr_t x;
! 254: int count = 0;
! 255:
! 256: l1 = linked_list_create_with_items((void*)1, (void*)2, NULL);
! 257: l2 = linked_list_create();
! 258: l3 = linked_list_create_with_items((void*)3, (void*)4, (void*)5, NULL);
! 259: list = linked_list_create_with_items(l1, l2, l3, NULL);
! 260:
! 261: outer = list->create_enumerator(list);
! 262: enumerator = enumerator_create_nested(outer, (void*)create_inner,
! 263: (void*)101, destroy_data);
! 264: while (enumerator->enumerate(enumerator, &x))
! 265: {
! 266: count++;
! 267: }
! 268: ck_assert_int_eq(count, 5);
! 269:
! 270: list->reset_enumerator(list, outer);
! 271: ck_assert(enumerator->enumerate(enumerator, &x));
! 272: ck_assert_int_eq(x, 1);
! 273: enumerator->destroy(enumerator);
! 274:
! 275: list->destroy(list);
! 276: l1->destroy(l1);
! 277: l2->destroy(l2);
! 278: l3->destroy(l3);
! 279: }
! 280: END_TEST
! 281:
! 282: START_TEST(test_nested_empty)
! 283: {
! 284: linked_list_t *list;
! 285: enumerator_t *enumerator;
! 286: intptr_t x;
! 287: int count;
! 288:
! 289: list = linked_list_create();
! 290: count = 0;
! 291: enumerator = enumerator_create_nested(list->create_enumerator(list),
! 292: (void*)create_inner, (void*)101, destroy_data);
! 293: while (enumerator->enumerate(enumerator, &x))
! 294: {
! 295: count++;
! 296: }
! 297: enumerator->destroy(enumerator);
! 298: ck_assert_int_eq(count, 0);
! 299:
! 300: list->destroy(list);
! 301: }
! 302: END_TEST
! 303:
! 304: START_TEST(test_nested_null)
! 305: {
! 306: linked_list_t *list;
! 307: enumerator_t *enumerator;
! 308: intptr_t x;
! 309: int count;
! 310:
! 311: list = linked_list_create_with_items((void*)1, NULL);
! 312:
! 313: count = 0;
! 314: /* should also work without destructor, so set this manually */
! 315: destroy_data_called = 1;
! 316: enumerator = enumerator_create_nested(list->create_enumerator(list),
! 317: (void*)create_inner_null, (void*)101, NULL);
! 318: while (enumerator->enumerate(enumerator, &x))
! 319: {
! 320: count++;
! 321: }
! 322: enumerator->destroy(enumerator);
! 323: ck_assert_int_eq(count, 0);
! 324:
! 325: list->destroy(list);
! 326: }
! 327: END_TEST
! 328:
! 329: /*******************************************************************************
! 330: * cleaner test
! 331: */
! 332:
! 333: START_TEST(test_cleaner)
! 334: {
! 335: enumerator_t *enumerator;
! 336: linked_list_t *list;
! 337: intptr_t x;
! 338: int round;
! 339:
! 340: list = linked_list_create_with_items((void*)1, (void*)2, NULL);
! 341:
! 342: round = 1;
! 343: enumerator = enumerator_create_cleaner(list->create_enumerator(list),
! 344: destroy_data, (void*)101);
! 345: while (enumerator->enumerate(enumerator, &x))
! 346: {
! 347: ck_assert_int_eq(round, x);
! 348: round++;
! 349: }
! 350: ck_assert_int_eq(round, 3);
! 351: enumerator->destroy(enumerator);
! 352: list->destroy(list);
! 353: }
! 354: END_TEST
! 355:
! 356: /*******************************************************************************
! 357: * single test
! 358: */
! 359:
! 360: static void single_cleanup(void *data)
! 361: {
! 362: ck_assert_int_eq((intptr_t)data, 1);
! 363: }
! 364:
! 365: static void do_test_single(enumerator_t *enumerator)
! 366: {
! 367: intptr_t x;
! 368:
! 369: ck_assert(enumerator->enumerate(enumerator, &x));
! 370: ck_assert_int_eq(x, 1);
! 371: ck_assert(!enumerator->enumerate(enumerator, &x));
! 372: enumerator->destroy(enumerator);
! 373: }
! 374:
! 375: START_TEST(test_single)
! 376: {
! 377: enumerator_t *enumerator;
! 378:
! 379: enumerator = enumerator_create_single((void*)1, NULL);
! 380: do_test_single(enumerator);
! 381: }
! 382: END_TEST
! 383:
! 384: START_TEST(test_single_cleanup)
! 385: {
! 386: enumerator_t *enumerator;
! 387:
! 388: enumerator = enumerator_create_single((void*)1, single_cleanup);
! 389: do_test_single(enumerator);
! 390: }
! 391: END_TEST
! 392:
! 393: Suite *enumerator_suite_create()
! 394: {
! 395: Suite *s;
! 396: TCase *tc;
! 397:
! 398: s = suite_create("enumerator");
! 399:
! 400: tc = tcase_create("tokens");
! 401: tcase_add_loop_test(tc, test_token, 0, countof(token_tests));
! 402: suite_add_tcase(s, tc);
! 403:
! 404: tc = tcase_create("filtered");
! 405: tcase_add_checked_fixture(tc, setup_destroy_data, teardown_destroy_data);
! 406: tcase_add_test(tc, test_filtered);
! 407: tcase_add_test(tc, test_filtered_filter);
! 408: suite_add_tcase(s, tc);
! 409:
! 410: tc = tcase_create("nested");
! 411: tcase_add_checked_fixture(tc, setup_destroy_data, teardown_destroy_data);
! 412: tcase_add_test(tc, test_nested);
! 413: tcase_add_test(tc, test_nested_reset);
! 414: tcase_add_test(tc, test_nested_empty);
! 415: tcase_add_test(tc, test_nested_null);
! 416: suite_add_tcase(s, tc);
! 417:
! 418: tc = tcase_create("cleaner");
! 419: tcase_add_checked_fixture(tc, setup_destroy_data, teardown_destroy_data);
! 420: tcase_add_test(tc, test_cleaner);
! 421: suite_add_tcase(s, tc);
! 422:
! 423: tc = tcase_create("single");
! 424: tcase_add_test(tc, test_single);
! 425: tcase_add_test(tc, test_single_cleanup);
! 426: suite_add_tcase(s, tc);
! 427:
! 428: return s;
! 429: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_enumerator.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / tests / suites