1d02acd5b763123ae365f4e185c676dd6c35453d
[ccan] / ccan / list / test / run.c
1 #include <ccan/list/list.h>
2 #include <ccan/tap/tap.h>
3 #include <ccan/list/list.c>
4 #include "helper.h"
5
6 struct parent {
7         const char *name;
8         struct list_head children;
9         unsigned int num_children;
10 };
11
12 struct child {
13         const char *name;
14         struct list_node list;
15 };
16
17 static LIST_HEAD(static_list);
18
19 int main(int argc, char *argv[])
20 {
21         struct parent parent;
22         struct child c1, c2, c3, *c, *n;
23         unsigned int i;
24         struct list_head list = LIST_HEAD_INIT(list);
25         opaque_t *q, *nq;
26         struct list_head opaque_list = LIST_HEAD_INIT(opaque_list);
27
28         plan_tests(65);
29         /* Test LIST_HEAD, LIST_HEAD_INIT, list_empty and check_list */
30         ok1(list_empty(&static_list));
31         ok1(list_check(&static_list, NULL));
32         ok1(list_empty(&list));
33         ok1(list_check(&list, NULL));
34
35         parent.num_children = 0;
36         list_head_init(&parent.children);
37         /* Test list_head_init */
38         ok1(list_empty(&parent.children));
39         ok1(list_check(&parent.children, NULL));
40
41         c2.name = "c2";
42         list_add(&parent.children, &c2.list);
43         /* Test list_add and !list_empty. */
44         ok1(!list_empty(&parent.children));
45         ok1(c2.list.next == &parent.children.n);
46         ok1(c2.list.prev == &parent.children.n);
47         ok1(parent.children.n.next == &c2.list);
48         ok1(parent.children.n.prev == &c2.list);
49         /* Test list_check */
50         ok1(list_check(&parent.children, NULL));
51
52         c1.name = "c1";
53         list_add(&parent.children, &c1.list);
54         /* Test list_add and !list_empty. */
55         ok1(!list_empty(&parent.children));
56         ok1(c2.list.next == &parent.children.n);
57         ok1(c2.list.prev == &c1.list);
58         ok1(parent.children.n.next == &c1.list);
59         ok1(parent.children.n.prev == &c2.list);
60         ok1(c1.list.next == &c2.list);
61         ok1(c1.list.prev == &parent.children.n);
62         /* Test list_check */
63         ok1(list_check(&parent.children, NULL));
64
65         c3.name = "c3";
66         list_add_tail(&parent.children, &c3.list);
67         /* Test list_add_tail and !list_empty. */
68         ok1(!list_empty(&parent.children));
69         ok1(parent.children.n.next == &c1.list);
70         ok1(parent.children.n.prev == &c3.list);
71         ok1(c1.list.next == &c2.list);
72         ok1(c1.list.prev == &parent.children.n);
73         ok1(c2.list.next == &c3.list);
74         ok1(c2.list.prev == &c1.list);
75         ok1(c3.list.next == &parent.children.n);
76         ok1(c3.list.prev == &c2.list);
77         /* Test list_check */
78         ok1(list_check(&parent.children, NULL));
79
80         /* Test list_check_node */
81         ok1(list_check_node(&c1.list, NULL));
82         ok1(list_check_node(&c2.list, NULL));
83         ok1(list_check_node(&c3.list, NULL));
84
85         /* Test list_top */
86         ok1(list_top(&parent.children, struct child, list) == &c1);
87
88         /* Test list_tail */
89         ok1(list_tail(&parent.children, struct child, list) == &c3);
90
91         /* Test list_for_each. */
92         i = 0;
93         list_for_each(&parent.children, c, list) {
94                 switch (i++) {
95                 case 0:
96                         ok1(c == &c1);
97                         break;
98                 case 1:
99                         ok1(c == &c2);
100                         break;
101                 case 2:
102                         ok1(c == &c3);
103                         break;
104                 }
105                 if (i > 2)
106                         break;
107         }
108         ok1(i == 3);
109
110         /* Test list_for_each_rev. */
111         i = 0;
112         list_for_each_rev(&parent.children, c, list) {
113                 switch (i++) {
114                 case 0:
115                         ok1(c == &c3);
116                         break;
117                 case 1:
118                         ok1(c == &c2);
119                         break;
120                 case 2:
121                         ok1(c == &c1);
122                         break;
123                 }
124                 if (i > 2)
125                         break;
126         }
127         ok1(i == 3);
128
129         /* Test list_for_each_safe, list_del and list_del_from. */
130         i = 0;
131         list_for_each_safe(&parent.children, c, n, list) {
132                 switch (i++) {
133                 case 0:
134                         ok1(c == &c1);  
135                         list_del(&c->list);
136                         break;
137                 case 1:
138                         ok1(c == &c2);
139                         list_del_from(&parent.children, &c->list);
140                         break;
141                 case 2:
142                         ok1(c == &c3);
143                         list_del_from(&parent.children, &c->list);
144                         break;
145                 }
146                 ok1(list_check(&parent.children, NULL));
147                 if (i > 2)
148                         break;
149         }
150         ok1(i == 3);
151         ok1(list_empty(&parent.children));
152
153         /* Test list_for_each_off. */
154         list_add_tail(&opaque_list,
155                       (struct list_node *)create_opaque_blob());
156         list_add_tail(&opaque_list,
157                       (struct list_node *)create_opaque_blob());
158         list_add_tail(&opaque_list,
159                       (struct list_node *)create_opaque_blob());
160
161         i = 0;
162
163         list_for_each_off(&opaque_list, q, 0) {
164           i++;
165           ok1(if_blobs_know_the_secret(q));
166         }
167         ok1(i == 3);
168
169         /* Test list_for_each_safe_off, list_del_off and list_del_from_off. */
170         i = 0;
171         list_for_each_safe_off(&opaque_list, q, nq, 0) {
172                 switch (i++) {
173                 case 0:
174                         ok1(if_blobs_know_the_secret(q));
175                         list_del_off(q, 0);
176                         destroy_opaque_blob(q);
177                         break;
178                 case 1:
179                         ok1(if_blobs_know_the_secret(q));
180                         list_del_from_off(&opaque_list, q, 0);
181                         destroy_opaque_blob(q);
182                         break;
183                 case 2:
184                         ok1(c == &c3);
185                         list_del_from_off(&opaque_list, q, 0);
186                         destroy_opaque_blob(q);
187                         break;
188                 }
189                 ok1(list_check(&opaque_list, NULL));
190                 if (i > 2)
191                         break;
192         }
193         ok1(i == 3);
194         ok1(list_empty(&opaque_list));
195
196         /* Test list_top/list_tail on empty list. */
197         ok1(list_top(&parent.children, struct child, list) == NULL);
198         ok1(list_tail(&parent.children, struct child, list) == NULL);
199         return exit_status();
200 }