Debian Codegraph @

third_party/c-list/src/test-basic.c

raw
1 /*
2 * Tests for basic functionality
3 * This contains basic, deterministic tests for list behavior, API
4 * functionality, and usage.
5 */
6
7 #undef NDEBUG
8 #include <assert.h>
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12 #include "c-list.h"
13
14 static void assert_list_integrity(CList *list) {
15 CList *iter;
16
17 iter = list;
18 do {
19 assert(iter->next->prev == iter);
20 assert(iter->prev->next == iter);
21
22 iter = iter->next;
23 } while (iter != list);
24 }
25
26 static void test_iterators(void) {
27 CList *iter, *safe, a, b, list = C_LIST_INIT(list);
28 unsigned int i;
29
30 assert(!c_list_first(&list));
31 assert(!c_list_last(&list));
32
33 /* link @a and verify iterators see just it */
34
35 c_list_link_tail(&list, &a);
36 assert(c_list_is_linked(&a));
37 assert(c_list_first(&list) == &a);
38 assert(c_list_last(&list) == &a);
39
40 i = 0;
41 c_list_for_each(iter, &list) {
42 assert(iter == &a);
43 ++i;
44 }
45 assert(i == 1);
46
47 i = 0;
48 iter = NULL;
49 c_list_for_each_continue(iter, &list) {
50 assert(iter == &a);
51 ++i;
52 }
53 assert(i == 1);
54
55 i = 0;
56 iter = &a;
57 c_list_for_each_continue(iter, &list)
58 ++i;
59 assert(i == 0);
60
61 /* link @b as well and verify iterators again */
62
63 c_list_link_tail(&list, &b);
64 assert(c_list_is_linked(&a));
65 assert(c_list_is_linked(&b));
66
67 i = 0;
68 c_list_for_each(iter, &list) {
69 assert((i == 0 && iter == &a) ||
70 (i == 1 && iter == &b));
71 ++i;
72 }
73 assert(i == 2);
74
75 i = 0;
76 iter = NULL;
77 c_list_for_each_continue(iter, &list) {
78 assert((i == 0 && iter == &a) ||
79 (i == 1 && iter == &b));
80 ++i;
81 }
82 assert(i == 2);
83
84 i = 0;
85 iter = &a;
86 c_list_for_each_continue(iter, &list) {
87 assert(iter == &b);
88 ++i;
89 }
90 assert(i == 1);
91
92 i = 0;
93 iter = &b;
94 c_list_for_each_continue(iter, &list)
95 ++i;
96 assert(i == 0);
97
98 /* verify safe-iterator while removing elements */
99
100 i = 0;
101 c_list_for_each_safe(iter, safe, &list) {
102 assert(iter == &a || iter == &b);
103 c_list_unlink_stale(iter);
104 ++i;
105 }
106 assert(i == 2);
107
108 assert(c_list_is_empty(&list));
109
110 /* link both and verify *_unlink() iterators */
111
112 c_list_link_tail(&list, &a);
113 c_list_link_tail(&list, &b);
114
115 i = 0;
116 c_list_for_each_safe_unlink(iter, safe, &list) {
117 assert(iter == &a || iter == &b);
118 assert(!c_list_is_linked(iter));
119 ++i;
120 }
121 assert(i == 2);
122
123 assert(c_list_is_empty(&list));
124 }
125
126 static void test_swap(void) {
127 CList list1 = (CList)C_LIST_INIT(list1);
128 CList list2 = (CList)C_LIST_INIT(list2);
129 CList list;
130
131 c_list_swap(&list1, &list2);
132
133 assert(list1.prev == list1.next && list1.prev == &list1);
134 assert(list2.prev == list2.next && list2.prev == &list2);
135
136 c_list_link_tail(&list1, &list);
137
138 assert(c_list_first(&list1) == &list);
139 assert(c_list_last(&list1) == &list);
140 assert(list.next == &list1);
141 assert(list.prev == &list1);
142
143 c_list_swap(&list1, &list2);
144
145 assert(c_list_first(&list2) == &list);
146 assert(c_list_last(&list2) == &list);
147 assert(list.next == &list2);
148 assert(list.prev == &list2);
149
150 assert(list1.prev == list1.next && list1.prev == &list1);
151 }
152
153 static void test_splice(void) {
154 CList target = (CList)C_LIST_INIT(target);
155 CList source = (CList)C_LIST_INIT(source);
156 CList e1, e2;
157
158 c_list_link_tail(&source, &e1);
159
160 c_list_splice(&target, &source);
161 assert(c_list_first(&target) == &e1);
162 assert(c_list_last(&target) == &e1);
163
164 source = (CList)C_LIST_INIT(source);
165
166 c_list_link_tail(&source, &e2);
167
168 c_list_splice(&target, &source);
169 assert(c_list_first(&target) == &e1);
170 assert(c_list_last(&target) == &e2);
171 }
172
173 static void test_split(void) {
174 CList e1, e2;
175
176 /* split empty list */
177 {
178 CList source = C_LIST_INIT(source), target;
179
180 c_list_split(&source, &source, &target);
181 assert(c_list_is_empty(&source));
182 assert(c_list_is_empty(&target));
183 assert_list_integrity(&source);
184 assert_list_integrity(&target);
185 }
186
187 /* split 1-element list excluding the element */
188 {
189 CList source = C_LIST_INIT(source), target;
190
191 c_list_link_tail(&source, &e1);
192 c_list_split(&source, &source, &target);
193 assert(!c_list_is_empty(&source));
194 assert(c_list_is_empty(&target));
195 assert_list_integrity(&source);
196 assert_list_integrity(&target);
197 }
198
199 /* split 1-element list including the element */
200 {
201 CList source = C_LIST_INIT(source), target;
202
203 c_list_link_tail(&source, &e1);
204 c_list_split(&source, &e1, &target);
205 assert(c_list_is_empty(&source));
206 assert(!c_list_is_empty(&target));
207 assert_list_integrity(&source);
208 assert_list_integrity(&target);
209 }
210
211 /* split 2-element list excluding the elements */
212 {
213 CList source = C_LIST_INIT(source), target;
214
215 c_list_link_tail(&source, &e1);
216 c_list_link_tail(&source, &e2);
217 c_list_split(&source, &source, &target);
218 assert(!c_list_is_empty(&source));
219 assert(c_list_is_empty(&target));
220 assert_list_integrity(&source);
221 assert_list_integrity(&target);
222 }
223
224 /* split 2-element list including one element */
225 {
226 CList source = C_LIST_INIT(source), target;
227
228 c_list_link_tail(&source, &e1);
229 c_list_link_tail(&source, &e2);
230 c_list_split(&source, &e2, &target);
231 assert(!c_list_is_empty(&source));
232 assert(!c_list_is_empty(&target));
233 assert_list_integrity(&source);
234 assert_list_integrity(&target);
235 }
236
237 /* split 2-element list including both elements */
238 {
239 CList source = C_LIST_INIT(source), target;
240
241 c_list_link_tail(&source, &e1);
242 c_list_link_tail(&source, &e2);
243 c_list_split(&source, &e1, &target);
244 assert(c_list_is_empty(&source));
245 assert(!c_list_is_empty(&target));
246 assert_list_integrity(&source);
247 assert_list_integrity(&target);
248 }
249 }
250
251
252 static void test_flush(void) {
253 CList e1 = C_LIST_INIT(e1), e2 = C_LIST_INIT(e2);
254 CList list1 = C_LIST_INIT(list1), list2 = C_LIST_INIT(list2);
255
256 c_list_link_tail(&list2, &e1);
257 c_list_link_tail(&list2, &e2);
258
259 assert(c_list_is_linked(&e1));
260 assert(c_list_is_linked(&e2));
261
262 c_list_flush(&list1);
263 c_list_flush(&list2);
264
265 assert(!c_list_is_linked(&e1));
266 assert(!c_list_is_linked(&e2));
267 }
268
269 static void test_macros(void) {
270 /* Verify `c_list_entry()` evaluates arguments only once. */
271 {
272 struct TestList {
273 int a;
274 CList link;
275 int b;
276 } list = { .link = C_LIST_INIT(list.link) };
277 CList *p[2] = { &list.link, NULL };
278 unsigned int i = 0;
279
280 assert(i == 0);
281 assert(c_list_entry(p[i++], struct TestList, link) == &list);
282 assert(i == 1);
283 }
284 }
285
286 #if defined(__GNUC__) || defined(__clang__)
287 static void test_gnu(void) {
288 CList e1 = C_LIST_INIT(e1), e2 = C_LIST_INIT(e2);
289
290 /* Test `c_list_flush()` in combination with cleanup attributes. */
291 {
292 __attribute((cleanup(c_list_flush))) CList list1 = C_LIST_INIT(list1);
293 __attribute((cleanup(c_list_flush))) CList list2 = C_LIST_INIT(list2);
294
295 c_list_link_tail(&list2, &e1);
296 c_list_link_tail(&list2, &e2);
297
298 assert(c_list_is_linked(&e1));
299 assert(c_list_is_linked(&e2));
300 }
301
302 assert(!c_list_is_linked(&e1));
303 assert(!c_list_is_linked(&e2));
304 }
305 #else
306 static void test_gnu(void) {
307 }
308 #endif
309
310 int main(void) {
311 test_iterators();
312 test_swap();
313 test_splice();
314 test_split();
315 test_flush();
316 test_macros();
317 test_gnu();
318 return 0;
319 }