Annotation of embedaddon/strongswan/src/libstrongswan/tests/suites/test_linked_list_enumerator.c, revision 1.1.1.1
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: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_linked_list_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