Return to test_linked_list_enumerator.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / tests / suites |
1.1 misho 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: }