unit-tests: Move test suites to its own subfolder
[strongswan.git] / src / libstrongswan / tests / suites / test_linked_list.c
1 /*
2 * Copyright (C) 2013 Tobias Brunner
3 * 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 static bool match_a_b(void *item, void *a, void *b)
187 {
188 ck_assert(a == (void*)1);
189 ck_assert(b == (void*)2);
190 return item == a || item == b;
191 }
192
193 START_TEST(test_find)
194 {
195 void *a = (void*)1, *b = (void*)2;
196
197 ck_assert(list->find_first(list, NULL, &a) == NOT_FOUND);
198 list->insert_last(list, a);
199 ck_assert(list->find_first(list, NULL, &a) == SUCCESS);
200 ck_assert(list->find_first(list, NULL, &b) == NOT_FOUND);
201 list->insert_last(list, b);
202 ck_assert(list->find_first(list, NULL, &a) == SUCCESS);
203 ck_assert(list->find_first(list, NULL, &b) == SUCCESS);
204
205 ck_assert(list->find_first(list, NULL, NULL) == NOT_FOUND);
206 }
207 END_TEST
208
209 START_TEST(test_find_callback)
210 {
211 void *a = (void*)1, *b = (void*)2, *x = NULL;
212
213 ck_assert(list->find_first(list, (linked_list_match_t)match_a_b, &x, a, b) == NOT_FOUND);
214 list->insert_last(list, a);
215 ck_assert(list->find_first(list, (linked_list_match_t)match_a, NULL, a) == SUCCESS);
216 x = NULL;
217 ck_assert(list->find_first(list, (linked_list_match_t)match_a, &x, a) == SUCCESS);
218 ck_assert(a == x);
219 ck_assert(list->find_first(list, (linked_list_match_t)match_b, &x, b) == NOT_FOUND);
220 ck_assert(a == x);
221 x = NULL;
222 ck_assert(list->find_first(list, (linked_list_match_t)match_a_b, &x, a, b) == SUCCESS);
223 ck_assert(a == x);
224
225 list->insert_last(list, b);
226 ck_assert(list->find_first(list, (linked_list_match_t)match_a, &x, a) == SUCCESS);
227 ck_assert(a == x);
228 ck_assert(list->find_first(list, (linked_list_match_t)match_b, &x, b) == SUCCESS);
229 ck_assert(b == x);
230 x = NULL;
231 ck_assert(list->find_first(list, (linked_list_match_t)match_a_b, &x, a, b) == SUCCESS);
232 ck_assert(a == x);
233 }
234 END_TEST
235
236 /*******************************************************************************
237 * invoke
238 */
239
240 typedef struct invoke_t invoke_t;
241
242 struct invoke_t {
243 int val;
244 void (*invoke)(invoke_t *item, void *a, void *b, void *c, void *d, int *sum);
245 };
246
247 static void invoke(intptr_t item, void *a, void *b, void *c, void *d, int *sum)
248 {
249 ck_assert(a == (void*)1);
250 ck_assert(b == (void*)2);
251 ck_assert(c == (void*)3);
252 ck_assert(d == (void*)4);
253 *sum += item;
254 }
255
256 static void invoke_offset(invoke_t *item, void *a, void *b, void *c, void *d, int *sum)
257 {
258 invoke(item->val, a, b, c, d, sum);
259 }
260
261 START_TEST(test_invoke_function)
262 {
263 int sum = 0;
264
265 list->insert_last(list, (void*)1);
266 list->insert_last(list, (void*)2);
267 list->insert_last(list, (void*)3);
268 list->insert_last(list, (void*)4);
269 list->insert_last(list, (void*)5);
270 list->invoke_function(list, (linked_list_invoke_t)invoke, 1, 2, 3, 4, &sum);
271 ck_assert_int_eq(sum, 15);
272 }
273 END_TEST
274
275 START_TEST(test_invoke_offset)
276 {
277 invoke_t items[] = {
278 { .val = 1, .invoke = invoke_offset, },
279 { .val = 2, .invoke = invoke_offset, },
280 { .val = 3, .invoke = invoke_offset, },
281 { .val = 4, .invoke = invoke_offset, },
282 { .val = 5, .invoke = invoke_offset, },
283 };
284 int i, sum = 0;
285
286 for (i = 0; i < countof(items); i++)
287 {
288 list->insert_last(list, &items[i]);
289 }
290 list->invoke_offset(list, offsetof(invoke_t, invoke), 1, 2, 3, 4, &sum);
291 ck_assert_int_eq(sum, 15);
292 }
293 END_TEST
294
295 /*******************************************************************************
296 * clone
297 */
298
299 typedef struct clone_t clone_t;
300
301 struct clone_t {
302 void *val;
303 void *(*clone)(clone_t *item);
304 };
305
306 static void *clone(clone_t *item)
307 {
308 return item->val;
309 }
310
311 static void test_clone(linked_list_t *list)
312 {
313 intptr_t x;
314 int round = 1;
315
316 ck_assert_int_eq(list->get_count(list), 5);
317 while (list->remove_first(list, (void*)&x) == SUCCESS)
318 {
319 ck_assert_int_eq(round, x);
320 round++;
321 }
322 ck_assert_int_eq(round, 6);
323 }
324
325 START_TEST(test_clone_offset)
326 {
327 linked_list_t *other;
328 clone_t items[] = {
329 { .val = (void*)1, .clone = clone, },
330 { .val = (void*)2, .clone = clone, },
331 { .val = (void*)3, .clone = clone, },
332 { .val = (void*)4, .clone = clone, },
333 { .val = (void*)5, .clone = clone, },
334 };
335 int i;
336
337 for (i = 0; i < countof(items); i++)
338 {
339 list->insert_last(list, &items[i]);
340 }
341 other = list->clone_offset(list, offsetof(clone_t, clone));
342 test_clone(other);
343 other->destroy(other);
344 }
345 END_TEST
346
347 Suite *linked_list_suite_create()
348 {
349 Suite *s;
350 TCase *tc;
351
352 s = suite_create("linked list");
353
354 tc = tcase_create("insert/get");
355 tcase_add_checked_fixture(tc, setup_list, teardown_list);
356 tcase_add_test(tc, test_insert_first);
357 tcase_add_test(tc, test_insert_last);
358 suite_add_tcase(s, tc);
359
360 tc = tcase_create("remove");
361 tcase_add_checked_fixture(tc, setup_list, teardown_list);
362 tcase_add_test(tc, test_remove_first);
363 tcase_add_test(tc, test_remove_last);
364 tcase_add_test(tc, test_remove);
365 tcase_add_test(tc, test_remove_callback);
366 suite_add_tcase(s, tc);
367
368 tc = tcase_create("find");
369 tcase_add_checked_fixture(tc, setup_list, teardown_list);
370 tcase_add_test(tc, test_find);
371 tcase_add_test(tc, test_find_callback);
372 suite_add_tcase(s, tc);
373
374 tc = tcase_create("invoke");
375 tcase_add_checked_fixture(tc, setup_list, teardown_list);
376 tcase_add_test(tc, test_invoke_function);
377 tcase_add_test(tc, test_invoke_offset);
378 suite_add_tcase(s, tc);
379
380 tc = tcase_create("clone");
381 tcase_add_checked_fixture(tc, setup_list, teardown_list);
382 tcase_add_test(tc, test_clone_offset);
383 suite_add_tcase(s, tc);
384
385 return s;
386 }