Annotation of embedaddon/strongswan/src/libstrongswan/tests/suites/test_linked_list.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: void *x = NULL;
29:
30: list = linked_list_create();
31: ck_assert_int_eq(list->get_count(list), 0);
32: ck_assert(list->get_first(list, &x) == NOT_FOUND);
33: ck_assert(list->get_last(list, &x) == NOT_FOUND);
34: }
35: END_SETUP
36:
37: START_TEARDOWN(teardown_list)
38: {
39: list->destroy(list);
40: }
41: END_TEARDOWN
42:
43: /*******************************************************************************
44: * insert first/last
45: */
46:
47: START_TEST(test_insert_first)
48: {
49: void *a = (void*)1, *b = (void*)2, *x = NULL;
50:
51: list->insert_first(list, a);
52: ck_assert_int_eq(list->get_count(list), 1);
53: ck_assert(list->get_first(list, &x) == SUCCESS);
54: ck_assert(x == a);
55: ck_assert(list->get_last(list, &x) == SUCCESS);
56: ck_assert(x == a);
57:
58: list->insert_first(list, b);
59: ck_assert_int_eq(list->get_count(list), 2);
60: ck_assert(list->get_first(list, &x) == SUCCESS);
61: ck_assert(x == b);
62: ck_assert(list->get_last(list, &x) == SUCCESS);
63: ck_assert(x == a);
64: }
65: END_TEST
66:
67: START_TEST(test_insert_last)
68: {
69: void *a = (void*)1, *b = (void*)2, *x = NULL;
70:
71: list->insert_last(list, a);
72: ck_assert_int_eq(list->get_count(list), 1);
73: ck_assert(list->get_first(list, &x) == SUCCESS);
74: ck_assert(x == a);
75: ck_assert(list->get_last(list, &x) == SUCCESS);
76: ck_assert(x == a);
77:
78: list->insert_last(list, b);
79: ck_assert_int_eq(list->get_count(list), 2);
80: ck_assert(list->get_first(list, &x) == SUCCESS);
81: ck_assert(x == a);
82: ck_assert(list->get_last(list, &x) == SUCCESS);
83: ck_assert(x == b);
84: }
85: END_TEST
86:
87: /*******************************************************************************
88: * remove first/last
89: */
90:
91: START_TEST(test_remove_first)
92: {
93: void *a = (void*)1, *b = (void*)2, *x = NULL;
94:
95: list->insert_first(list, a);
96: list->insert_first(list, b);
97: ck_assert(list->remove_first(list, &x) == SUCCESS);
98: ck_assert_int_eq(list->get_count(list), 1);
99: ck_assert(x == b);
100: ck_assert(list->remove_first(list, &x) == SUCCESS);
101: ck_assert_int_eq(list->get_count(list), 0);
102: ck_assert(x == a);
103: ck_assert(list->remove_first(list, &x) == NOT_FOUND);
104: ck_assert(list->remove_last(list, &x) == NOT_FOUND);
105: }
106: END_TEST
107:
108: START_TEST(test_remove_last)
109: {
110: void *a = (void*)1, *b = (void*)2, *x = NULL;
111:
112: list->insert_first(list, a);
113: list->insert_first(list, b);
114: ck_assert(list->remove_last(list, &x) == SUCCESS);
115: ck_assert_int_eq(list->get_count(list), 1);
116: ck_assert(x == a);
117: ck_assert(list->remove_last(list, &x) == SUCCESS);
118: ck_assert_int_eq(list->get_count(list), 0);
119: ck_assert(x == b);
120: ck_assert(list->remove_first(list, &x) == NOT_FOUND);
121: ck_assert(list->remove_last(list, &x) == NOT_FOUND);
122: }
123: END_TEST
124:
125: /*******************************************************************************
126: * helper function for remove and find tests
127: */
128:
129: static bool match_a(void *item, void *a)
130: {
131: ck_assert(a == (void*)1);
132: return item == a;
133: }
134:
135: static bool match_b(void *item, void *b)
136: {
137: ck_assert(b == (void*)2);
138: return item == b;
139: }
140:
141: /*******************************************************************************
142: * remove
143: */
144:
145: START_TEST(test_remove)
146: {
147: void *a = (void*)1, *b = (void*)2;
148:
149: list->insert_first(list, a);
150: ck_assert(list->remove(list, a, NULL) == 1);
151: ck_assert_int_eq(list->get_count(list), 0);
152:
153: list->insert_last(list, a);
154: list->insert_last(list, a);
155: list->insert_last(list, a);
156: list->insert_last(list, b);
157: ck_assert(list->remove(list, a, NULL) == 3);
158: ck_assert(list->remove(list, a, NULL) == 0);
159: ck_assert_int_eq(list->get_count(list), 1);
160: ck_assert(list->remove(list, b, NULL) == 1);
161: ck_assert(list->remove(list, b, NULL) == 0);
162: }
163: END_TEST
164:
165: START_TEST(test_remove_callback)
166: {
167: void *a = (void*)1, *b = (void*)2;
168:
169: list->insert_last(list, a);
170: list->insert_last(list, b);
171: list->insert_last(list, a);
172: list->insert_last(list, b);
173: ck_assert(list->remove(list, a, match_a) == 2);
174: ck_assert(list->remove(list, a, match_a) == 0);
175: ck_assert_int_eq(list->get_count(list), 2);
176: ck_assert(list->remove(list, b, match_b) == 2);
177: ck_assert(list->remove(list, b, match_b) == 0);
178: ck_assert_int_eq(list->get_count(list), 0);
179: }
180: END_TEST
181:
182: /*******************************************************************************
183: * find
184: */
185:
186: CALLBACK(find_a_b, bool,
187: void *item, va_list args)
188: {
189: void *a, *b;
190:
191: VA_ARGS_VGET(args, a, b);
192: ck_assert(a == (void*)1);
193: ck_assert(b == (void*)2);
194: return item == a || item == b;
195: }
196:
197: CALLBACK(find_a, bool,
198: void *item, va_list args)
199: {
200: void *a;
201:
202: VA_ARGS_VGET(args, a);
203: return match_a(item, a);
204: }
205:
206: CALLBACK(find_b, bool,
207: void *item, va_list args)
208: {
209: void *b;
210:
211: VA_ARGS_VGET(args, b);
212: return match_b(item, b);
213: }
214:
215: START_TEST(test_find)
216: {
217: void *a = (void*)1, *b = (void*)2;
218:
219: ck_assert(!list->find_first(list, NULL, &a));
220: list->insert_last(list, a);
221: ck_assert(list->find_first(list, NULL, &a));
222: ck_assert(!list->find_first(list, NULL, &b));
223: list->insert_last(list, b);
224: ck_assert(list->find_first(list, NULL, &a));
225: ck_assert(list->find_first(list, NULL, &b));
226:
227: ck_assert(!list->find_first(list, NULL, NULL));
228: }
229: END_TEST
230:
231: START_TEST(test_find_callback)
232: {
233: void *a = (void*)1, *b = (void*)2, *x = NULL;
234:
235: ck_assert(!list->find_first(list, find_a_b, &x, a, b));
236: list->insert_last(list, a);
237: ck_assert(list->find_first(list, find_a, NULL, a));
238: x = NULL;
239: ck_assert(list->find_first(list, find_a, &x, a));
240: ck_assert(a == x);
241: ck_assert(!list->find_first(list, find_b, &x, b));
242: ck_assert(a == x);
243: x = NULL;
244: ck_assert(list->find_first(list, find_a_b, &x, a, b));
245: ck_assert(a == x);
246:
247: list->insert_last(list, b);
248: ck_assert(list->find_first(list, find_a, &x, a));
249: ck_assert(a == x);
250: ck_assert(list->find_first(list, find_b, &x, b));
251: ck_assert(b == x);
252: x = NULL;
253: ck_assert(list->find_first(list, find_a_b, &x, a, b));
254: ck_assert(a == x);
255: }
256: END_TEST
257:
258: CALLBACK(find_args, bool,
259: void *item, va_list args)
260: {
261: uint64_t d, e;
262: level_t c;
263: int *a, b;
264:
265: VA_ARGS_VGET(args, a, b, c, d, e);
266: ck_assert_int_eq(*a, 1);
267: ck_assert_int_eq(b, 2);
268: ck_assert_int_eq(c, LEVEL_PRIVATE);
269: ck_assert_int_eq(d, UINT64_MAX);
270: ck_assert_int_eq(e, UINT64_MAX-1);
271: return item == a;
272: }
273:
274: START_TEST(test_find_callback_args)
275: {
276: int a = 1, b = 2, *x;
277: uint64_t d = UINT64_MAX;
278:
279: list->insert_last(list, &a);
280: ck_assert(list->find_first(list, find_args, (void**)&x, &a, b,
281: LEVEL_PRIVATE, d, UINT64_MAX-1));
282: ck_assert_int_eq(a, *x);
283: }
284: END_TEST
285:
286: /*******************************************************************************
287: * invoke
288: */
289:
290: typedef struct invoke_t invoke_t;
291:
292: struct invoke_t {
293: int val;
294: void (*invoke)(invoke_t *item);
295: };
296:
297: CALLBACK(invoke, void,
298: intptr_t item, va_list args)
299: {
300: void *a, *b, *c, *d;
301: int *sum;
302:
303: VA_ARGS_VGET(args, a, b, c, d, sum);
304: ck_assert_int_eq((uintptr_t)a, 1);
305: ck_assert_int_eq((uintptr_t)b, 2);
306: ck_assert_int_eq((uintptr_t)c, 3);
307: ck_assert_int_eq((uintptr_t)d, 4);
308: *sum += item;
309: }
310:
311: static void invoke_offset(invoke_t *item)
312: {
313: item->val++;
314: }
315:
316: START_TEST(test_invoke_function)
317: {
318: int sum = 0;
319:
320: list->insert_last(list, (void*)1);
321: list->insert_last(list, (void*)2);
322: list->insert_last(list, (void*)3);
323: list->insert_last(list, (void*)4);
324: list->insert_last(list, (void*)5);
325: list->invoke_function(list, invoke, (uintptr_t)1, (uintptr_t)2,
326: (uintptr_t)3, (uintptr_t)4, &sum);
327: ck_assert_int_eq(sum, 15);
328: }
329: END_TEST
330:
331: START_TEST(test_invoke_offset)
332: {
333: invoke_t items[] = {
334: { .val = 1, .invoke = invoke_offset, },
335: { .val = 2, .invoke = invoke_offset, },
336: { .val = 3, .invoke = invoke_offset, },
337: { .val = 4, .invoke = invoke_offset, },
338: { .val = 5, .invoke = invoke_offset, },
339: }, *item;
340: int i;
341:
342: for (i = 0; i < countof(items); i++)
343: {
344: list->insert_last(list, &items[i]);
345: }
346: list->invoke_offset(list, offsetof(invoke_t, invoke));
347: i = 2;
348: while (list->remove_first(list, (void**)&item) == SUCCESS)
349: {
350: ck_assert_int_eq(item->val, i++);
351: }
352: }
353: END_TEST
354:
355: /*******************************************************************************
356: * clone
357: */
358:
359: typedef struct clone_t clone_t;
360:
361: struct clone_t {
362: void *val;
363: void *(*clone)(clone_t *item);
364: };
365:
366: static void *clonefn(clone_t *item)
367: {
368: return item->val;
369: }
370:
371: static void test_clone(linked_list_t *list)
372: {
373: intptr_t x;
374: int round = 1;
375:
376: ck_assert_int_eq(list->get_count(list), 5);
377: while (list->remove_first(list, (void*)&x) == SUCCESS)
378: {
379: ck_assert_int_eq(round, x);
380: round++;
381: }
382: ck_assert_int_eq(round, 6);
383: }
384:
385: START_TEST(test_clone_offset)
386: {
387: linked_list_t *other;
388: clone_t items[] = {
389: { .val = (void*)1, .clone = clonefn, },
390: { .val = (void*)2, .clone = clonefn, },
391: { .val = (void*)3, .clone = clonefn, },
392: { .val = (void*)4, .clone = clonefn, },
393: { .val = (void*)5, .clone = clonefn, },
394: };
395: int i;
396:
397: for (i = 0; i < countof(items); i++)
398: {
399: list->insert_last(list, &items[i]);
400: }
401: other = list->clone_offset(list, offsetof(clone_t, clone));
402: test_clone(other);
403: other->destroy(other);
404: }
405: END_TEST
406:
407:
408: /*******************************************************************************
409: * equals
410: */
411:
412: typedef struct equals_t equals_t;
413:
414: struct equals_t {
415: int val;
416: bool (*equals)(equals_t *a, equals_t *b);
417: };
418:
419: static bool equalsfn(equals_t *a, equals_t *b)
420: {
421: return a->val == b->val;
422: }
423:
424: START_TEST(test_equals_offset)
425: {
426: linked_list_t *other;
427: equals_t *x, items[] = {
428: { .val = 1, .equals = equalsfn, },
429: { .val = 2, .equals = equalsfn, },
430: { .val = 3, .equals = equalsfn, },
431: { .val = 4, .equals = equalsfn, },
432: { .val = 5, .equals = equalsfn, },
433: };
434: int i;
435:
436: for (i = 0; i < countof(items); i++)
437: {
438: list->insert_last(list, &items[i]);
439: }
440: ck_assert(list->equals_offset(list, list, offsetof(equals_t, equals)));
441: other = linked_list_create_from_enumerator(list->create_enumerator(list));
442: ck_assert(list->equals_offset(list, other, offsetof(equals_t, equals)));
443: other->remove_last(other, (void**)&x);
444: ck_assert(!list->equals_offset(list, other, offsetof(equals_t, equals)));
445: list->remove_last(list, (void**)&x);
446: ck_assert(list->equals_offset(list, other, offsetof(equals_t, equals)));
447: other->remove_first(other, (void**)&x);
448: ck_assert(!list->equals_offset(list, other, offsetof(equals_t, equals)));
449: list->remove_first(list, (void**)&x);
450: ck_assert(list->equals_offset(list, other, offsetof(equals_t, equals)));
451: while (list->remove_first(list, (void**)&x) == SUCCESS);
452: while (other->remove_first(other, (void**)&x) == SUCCESS);
453: ck_assert(list->equals_offset(list, other, offsetof(equals_t, equals)));
454: other->destroy(other);
455: }
456: END_TEST
457:
458: START_TEST(test_equals_function)
459: {
460: linked_list_t *other;
461: equals_t *x, items[] = {
462: { .val = 1, },
463: { .val = 2, },
464: { .val = 3, },
465: { .val = 4, },
466: { .val = 5, },
467: };
468: int i;
469:
470: for (i = 0; i < countof(items); i++)
471: {
472: list->insert_last(list, &items[i]);
473: }
474: ck_assert(list->equals_function(list, list, (void*)equalsfn));
475: other = linked_list_create_from_enumerator(list->create_enumerator(list));
476: ck_assert(list->equals_function(list, other, (void*)equalsfn));
477: other->remove_last(other, (void**)&x);
478: ck_assert(!list->equals_function(list, other, (void*)equalsfn));
479: list->remove_last(list, (void**)&x);
480: ck_assert(list->equals_function(list, other, (void*)equalsfn));
481: other->remove_first(other, (void**)&x);
482: ck_assert(!list->equals_function(list, other, (void*)equalsfn));
483: list->remove_first(list, (void**)&x);
484: ck_assert(list->equals_function(list, other, (void*)equalsfn));
485: while (list->remove_first(list, (void**)&x) == SUCCESS);
486: while (other->remove_first(other, (void**)&x) == SUCCESS);
487: ck_assert(list->equals_function(list, other, (void*)equalsfn));
488: other->destroy(other);
489: }
490: END_TEST
491:
492: Suite *linked_list_suite_create()
493: {
494: Suite *s;
495: TCase *tc;
496:
497: s = suite_create("linked list");
498:
499: tc = tcase_create("insert/get");
500: tcase_add_checked_fixture(tc, setup_list, teardown_list);
501: tcase_add_test(tc, test_insert_first);
502: tcase_add_test(tc, test_insert_last);
503: suite_add_tcase(s, tc);
504:
505: tc = tcase_create("remove");
506: tcase_add_checked_fixture(tc, setup_list, teardown_list);
507: tcase_add_test(tc, test_remove_first);
508: tcase_add_test(tc, test_remove_last);
509: tcase_add_test(tc, test_remove);
510: tcase_add_test(tc, test_remove_callback);
511: suite_add_tcase(s, tc);
512:
513: tc = tcase_create("find");
514: tcase_add_checked_fixture(tc, setup_list, teardown_list);
515: tcase_add_test(tc, test_find);
516: tcase_add_test(tc, test_find_callback);
517: tcase_add_test(tc, test_find_callback_args);
518: suite_add_tcase(s, tc);
519:
520: tc = tcase_create("invoke");
521: tcase_add_checked_fixture(tc, setup_list, teardown_list);
522: tcase_add_test(tc, test_invoke_function);
523: tcase_add_test(tc, test_invoke_offset);
524: suite_add_tcase(s, tc);
525:
526: tc = tcase_create("clone");
527: tcase_add_checked_fixture(tc, setup_list, teardown_list);
528: tcase_add_test(tc, test_clone_offset);
529: suite_add_tcase(s, tc);
530:
531: tc = tcase_create("equals");
532: tcase_add_checked_fixture(tc, setup_list, teardown_list);
533: tcase_add_test(tc, test_equals_offset);
534: tcase_add_test(tc, test_equals_function);
535: suite_add_tcase(s, tc);
536:
537: return s;
538: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_linked_list.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