1 /*
2 * SysDB - t/unit/utils/llist_test.c
3 * Copyright (C) 2013 Sebastian 'tokkee' Harl <sh@tokkee.org>
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
17 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
19 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
28 #include "utils/llist.h"
29 #include "libsysdb_test.h"
31 #include <check.h>
33 /*
34 * private data types
35 */
37 static sdb_object_t golden_data[] = {
38 SDB_OBJECT_STATIC("abc"),
39 SDB_OBJECT_STATIC("bcd"),
40 SDB_OBJECT_STATIC("cde"),
41 SDB_OBJECT_STATIC("def"),
42 SDB_OBJECT_STATIC("efg"),
43 SDB_OBJECT_STATIC("fgh"),
44 SDB_OBJECT_STATIC("ghi")
45 };
47 static char *unused_names[] = {
48 "xyz",
49 "yza",
50 "zab"
51 };
53 static sdb_llist_t *list;
55 static void
56 setup(void)
57 {
58 list = sdb_llist_create();
59 fail_unless(list != NULL,
60 "sdb_llist_create() = NULL; expected list object");
61 } /* setup */
63 static void
64 teardown(void)
65 {
66 sdb_llist_destroy(list);
67 list = NULL;
68 } /* teardown */
70 /* populate the list with the golden data in the specified order */
71 static void
72 populate(void)
73 {
74 size_t i;
75 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
76 int check = sdb_llist_append(list, &golden_data[i]);
77 fail_unless(check == 0,
78 "sdb_llist_append(%s) = %i; expected: 0",
79 golden_data[i].name, check);
80 }
81 } /* populate */
83 START_TEST(test_clone)
84 {
85 sdb_llist_t *clone;
86 size_t i;
88 populate();
90 clone = sdb_llist_clone(list);
91 fail_unless(clone != NULL,
92 "sdb_llist_clone() = NULL; expected: cloned list object");
94 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
95 fail_unless(golden_data[i].ref_cnt == 3,
96 "sdb_llist_clone() did not take ownership");
97 }
99 sdb_llist_destroy(clone);
100 }
101 END_TEST
103 START_TEST(test_destroy)
104 {
105 size_t i;
106 populate();
107 sdb_llist_destroy(list);
108 list = NULL;
110 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
111 fail_unless(golden_data[i].ref_cnt == 1,
112 "sdb_llist_destroy() did not deref element %s",
113 golden_data[i].name);
114 }
115 }
116 END_TEST
118 START_TEST(test_clear)
119 {
120 size_t i;
121 populate();
122 sdb_llist_clear(list);
124 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
125 fail_unless(golden_data[i].ref_cnt == 1,
126 "sdb_llist_clear() did not deref element %s",
127 golden_data[i].name);
128 }
130 i = sdb_llist_len(list);
131 fail_unless(i == 0,
132 "sdb_llist_clear() left %zu elements in the list; "
133 "expected: 0", i);
134 }
135 END_TEST
137 START_TEST(test_append)
138 {
139 size_t i;
141 fail_unless(sdb_llist_len(list) == 0,
142 "sdb_llist_len(<empty list>) = %zu; expected: 0",
143 sdb_llist_len(list));
145 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
146 int check = sdb_llist_append(list, &golden_data[i]);
147 fail_unless(check == 0,
148 "sdb_llist_append(%s) = %i; expected: 0",
149 golden_data[i].name, check);
150 fail_unless(golden_data[i].ref_cnt == 2,
151 "sdb_llist_append(%s) did not take ownership",
152 golden_data[i].name);
153 fail_unless(sdb_llist_len(list) == i + 1,
154 "sdb_llist_len(<empty list>) = %zu; expected: zu",
155 sdb_llist_len(list), i + 1);
156 }
157 }
158 END_TEST
160 START_TEST(test_insert)
161 {
162 size_t i;
163 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
164 int check = sdb_llist_insert(list, &golden_data[i], 0);
165 fail_unless(check == 0,
166 "sdb_llist_insert(%s, 0) = %i; expected: 0",
167 golden_data[i].name, check);
168 fail_unless(golden_data[i].ref_cnt == 2,
169 "sdb_llist_insert(%s, 0) did not take ownership",
170 golden_data[i].name);
171 }
172 }
173 END_TEST
175 START_TEST(test_validate_insert)
176 {
177 size_t i;
178 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
179 /* none of these operations will succeed
180 * => 1 is invalid for each case */
181 int check = sdb_llist_insert(list, &golden_data[i], 1);
182 fail_unless(check == -1,
183 "sdb_llist_insert(%s, 1) = %i; expected: -1",
184 golden_data[i].name, check);
185 fail_unless(golden_data[i].ref_cnt == 1,
186 "sdb_llist_insert(%s, 1) took ownership",
187 golden_data[i].name);
188 }
189 }
190 END_TEST
192 START_TEST(test_get)
193 {
194 size_t i;
195 populate();
196 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
197 sdb_object_t *check = sdb_llist_get(list, i);
198 fail_unless(check == &golden_data[i],
199 "sdb_llist_get() = %p; expected: %p",
200 check, &golden_data[i]);
201 fail_unless(check->ref_cnt == 3,
202 "sdb_llist_get() didn't increment reference count; got: %i; "
203 "expected: 3", check->ref_cnt);
204 sdb_object_deref(check);
205 }
206 }
207 END_TEST
209 START_TEST(test_remove_by_name)
210 {
211 /* "random" indexes */
212 int indexes[] = { 4, 5, 3, 6, 2, 0, 1 };
213 size_t i;
215 populate();
217 for (i = 0; i < SDB_STATIC_ARRAY_LEN(indexes); ++i) {
218 sdb_object_t *check;
220 fail_unless((size_t)indexes[i] < SDB_STATIC_ARRAY_LEN(golden_data),
221 "INTERNAL ERROR: invalid index %i", indexes[i]);
223 check = sdb_llist_remove_by_name(list, golden_data[indexes[i]].name);
224 fail_unless(check == &golden_data[indexes[i]],
225 "sdb_llist_remove_by_name() = %p; expected: %p",
226 check, &golden_data[indexes[i]]);
227 fail_unless(check->ref_cnt == 2,
228 "sdb_llist_remove_by_name() returned unexpected reference "
229 "count; got: %i; expected: 2", check->ref_cnt);
231 check = sdb_llist_remove_by_name(list, golden_data[indexes[i]].name);
232 fail_unless(check == NULL,
233 "sdb_llist_remove_by_name() did not remove the element");
234 }
235 }
236 END_TEST
238 static int
239 dummy_lookup(const sdb_object_t __attribute__((unused)) *obj,
240 const void __attribute__((unused)) *user_data)
241 {
242 return 0;
243 } /* dummy_lookup */
245 START_TEST(test_search)
246 {
247 size_t i;
248 populate();
249 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
250 sdb_object_t *check = sdb_llist_search_by_name(list,
251 golden_data[i].name);
252 fail_unless(check == &golden_data[i],
253 "sdb_llist_search_by_name(%s) = NULL; expected: %p",
254 golden_data[i].name, &golden_data[i]);
255 }
257 for (i = 0; i < SDB_STATIC_ARRAY_LEN(unused_names); ++i) {
258 sdb_object_t *check = sdb_llist_search_by_name(list,
259 unused_names[i]);
260 fail_unless(check == NULL,
261 "sdb_llist_search_by_name(%s) = %p; expected: NULL",
262 unused_names[i], check);
263 }
265 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
266 /* dummy_lookup always return 0, thus, this will always return the
267 * first element */
268 sdb_object_t *check = sdb_llist_search(list, dummy_lookup, NULL);
269 fail_unless(check == &golden_data[i],
270 "sdb_llist_search() = %p (%s); expected: %p (%s)",
271 check, check->name, &golden_data[i], golden_data[i].name);
273 /* => remove the first element */
274 check = sdb_llist_remove(list, dummy_lookup, NULL);
275 fail_unless(check == &golden_data[i],
276 "sdb_llist_remove() = %p (%s); expected: %p (%s)",
277 check, check->name, &golden_data[i], golden_data[i].name);
278 fail_unless(check->ref_cnt == 2,
279 "sdb_llist_remove() changed reference count; got: %i; "
280 "expected: 2", check->ref_cnt);
281 }
282 /* should now be empty */
283 fail_unless(sdb_llist_len(list) == 0,
284 "Still have %i elements in the list; expected: 0",
285 sdb_llist_len(list));
286 }
287 END_TEST
289 START_TEST(test_shift)
290 {
291 size_t i;
292 populate();
293 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
294 sdb_object_t *check = sdb_llist_shift(list);
295 fail_unless(check == &golden_data[i],
296 "sdb_llist_shift() = NULL; expected: %p",
297 &golden_data[i]);
298 fail_unless(check->ref_cnt == 2,
299 "sdb_llist_shift() changed reference count; got: %i; "
300 "expected: 2", check->ref_cnt);
301 }
303 /* must be empty now */
304 fail_unless(sdb_llist_shift(list) == NULL,
305 "sdb_llist_shift() returned value; expected: NULL");
306 }
307 END_TEST
309 START_TEST(test_iter)
310 {
311 sdb_llist_iter_t *iter;
312 size_t i;
314 populate();
316 iter = sdb_llist_get_iter(list);
317 fail_unless(iter != NULL,
318 "sdb_llist_get_iter() did not return an iterator");
320 for (i = 0; i < SDB_STATIC_ARRAY_LEN(golden_data); ++i) {
321 sdb_object_t *check;
322 fail_unless(sdb_llist_iter_has_next(iter),
323 "sdb_llist_iter_has_next() = FALSE; expected: TRUE");
324 check = sdb_llist_iter_get_next(iter);
325 fail_unless(check == &golden_data[i],
326 "sdb_llist_iter_get_next() = %p; expected: %p",
327 check, &golden_data[i]);
328 }
330 fail_unless(!sdb_llist_iter_has_next(iter),
331 "sdb_llist_iter_has_next() = TRUE; expected: FALSE");
332 fail_unless(sdb_llist_iter_get_next(iter) == NULL,
333 "sdb_llist_iter_get_next() returned value; expected: NULL");
334 sdb_llist_iter_destroy(iter);
335 }
336 END_TEST
338 START_TEST(test_iter_remove)
339 {
340 sdb_llist_iter_t *iter;
341 sdb_object_t *check;
342 size_t i;
344 populate();
346 iter = sdb_llist_get_iter(list);
347 fail_unless(iter != NULL,
348 "sdb_llist_get_iter() did not return an iterator");
350 i = 0;
351 while (sdb_llist_iter_has_next(iter)) {
352 check = sdb_llist_iter_get_next(iter);
353 fail_unless(check == &golden_data[i],
354 "sdb_llist_iter_get_next() = %p; expected: %p",
355 check, &golden_data[i]);
357 sdb_llist_iter_remove_current(iter);
358 ++i;
359 }
360 sdb_llist_iter_destroy(iter);
362 fail_unless(i == (size_t)SDB_STATIC_ARRAY_LEN(golden_data),
363 "iterated for %zu steps; expected: %i",
364 i, SDB_STATIC_ARRAY_LEN(golden_data));
366 /* all elements should be removed */
367 check = sdb_llist_shift(list);
368 fail_unless(check == NULL,
369 "sdb_llist_shift() = %p; expected: NULL", check);
370 }
371 END_TEST
373 Suite *
374 util_llist_suite(void)
375 {
376 Suite *s = suite_create("utils::llist");
377 TCase *tc;
379 tc = tcase_create("core");
380 tcase_add_checked_fixture(tc, setup, teardown);
381 tcase_add_test(tc, test_clone);
382 tcase_add_test(tc, test_destroy);
383 tcase_add_test(tc, test_clear);
384 tcase_add_test(tc, test_append);
385 tcase_add_test(tc, test_insert);
386 tcase_add_test(tc, test_validate_insert);
387 tcase_add_test(tc, test_get);
388 tcase_add_test(tc, test_remove_by_name);
389 tcase_add_test(tc, test_search);
390 tcase_add_test(tc, test_shift);
391 tcase_add_test(tc, test_iter);
392 tcase_add_test(tc, test_iter_remove);
393 suite_add_tcase(s, tc);
395 return s;
396 } /* util_llist_suite */
398 /* vim: set tw=78 sw=4 ts=4 noexpandtab : */