Line data Source code
1 : #include "test.h"
2 :
3 0 : int list_str_free(void *member) {
4 0 : char *str = member;
5 0 : if (str != NULL)
6 0 : free(str);
7 0 : return 1;
8 : }
9 :
10 2 : TEST(list_add_null) {
11 2 : mlist_t *ptr = NULL;
12 2 : void *null = NULL;
13 :
14 2 : list_add(ptr, null, 0);
15 2 : TEST_ASSERT((ptr == NULL), "Returned pointer is not null.");
16 2 : return TEST_SUCCESS;
17 : }
18 :
19 2 : TEST(list_add_member) {
20 2 : mlist_t *ptr = NULL;
21 2 : char test[] = "Hello !\n";
22 :
23 2 : list_add(ptr, test, sizeof(test));
24 2 : TEST_ASSERT(!strcmp(ptr->member, "Hello !\n"), "Member have an unexpected value.");
25 2 : TEST_ASSERT((ptr->size == sizeof(test)), "Size is wrong");
26 2 : list_free(ptr, NULL);
27 2 : return TEST_SUCCESS;
28 : }
29 :
30 2 : TEST(list_add_member_head_list) {
31 2 : mlist_t *ptr = NULL;
32 2 : char test[] = "Hello !\n";
33 2 : char test2[] = "Hello2 !\n";
34 :
35 2 : list_add(ptr, test, sizeof(test));
36 2 : list_add(ptr, test2, sizeof(test2));
37 2 : TEST_ASSERT(!strcmp(ptr->member, "Hello !\n"), "Head of the list is a wrong pointer.");
38 2 : TEST_ASSERT(!ptr->prev, "Head of the list prev pointer is not null");
39 2 : list_free(ptr, NULL);
40 2 : return TEST_SUCCESS;
41 : }
42 :
43 2 : TEST(list_add_member_test_multiples) {
44 2 : mlist_t *ptr = NULL;
45 2 : char test[] = "Hello !\n";
46 2 : char test2[] = "Hello2 !\n";
47 :
48 2 : list_add(ptr, test, sizeof(test));
49 2 : list_add(ptr, test2, sizeof(test2));
50 2 : TEST_ASSERT(!strcmp(ptr->next->member, "Hello2 !\n"), "Member have an unexpected value.");
51 2 : TEST_ASSERT(!strcmp(ptr->next->prev->member, "Hello !\n"), "Member have an unexpected value.");
52 2 : TEST_ASSERT((ptr->next->head == ptr), "Head pointer is not right");
53 2 : list_free(ptr, NULL);
54 2 : return TEST_SUCCESS;
55 : }
56 :
57 2 : TEST(list_for_each) {
58 2 : mlist_t *ptr = NULL, *tmp;
59 2 : char test[] = "Hello !\n";
60 2 : char test2[] = "Hello2 !\n";
61 2 : char test3[] = "Hello3 !\n";
62 : char *s_tmp;
63 2 : size_t i = 0;
64 :
65 2 : list_add(ptr, test, sizeof(test));
66 2 : list_add(ptr, test2, sizeof(test2));
67 2 : list_add(ptr, test3, sizeof(test3));
68 8 : list_for_each(ptr, tmp, s_tmp) {
69 6 : switch (i) {
70 6 : case 0: TEST_ASSERT(s_tmp, "Hello !\n"); break;
71 0 : case 1: TEST_ASSERT(s_tmp, "Hello2 !\n"); break;
72 0 : case 2: TEST_ASSERT(s_tmp, "Hello3 !\n"); break;
73 0 : case 3: TEST_ASSERT(0, "list_for_each too many iterations.");
74 : }
75 : }
76 2 : list_free(ptr, NULL);
77 2 : return TEST_SUCCESS;
78 : }
79 :
80 2 : TEST(list_tail) {
81 2 : mlist_t *ptr = NULL, *tmp;
82 2 : char test[] = "Hello !\n";
83 2 : char test2[] = "Hello2 !\n";
84 2 : char test3[] = "Hello3 !\n";
85 :
86 2 : tmp = list_tail(ptr);
87 2 : TEST_ASSERT(!tmp, "Pointer is not null.");
88 2 : list_add(ptr, test, sizeof(test));
89 2 : list_add(ptr, test2, sizeof(test2));
90 2 : list_add(ptr, test3, sizeof(test3));
91 2 : tmp = list_tail(ptr);
92 2 : TEST_ASSERT(!strcmp(tmp->member, "Hello3 !\n"), "Tail is wrong.");
93 2 : list_free(ptr, NULL);
94 2 : return TEST_SUCCESS;
95 : }
96 :
97 2 : TEST(list_add_after) {
98 2 : mlist_t *ptr = NULL, *tmp;
99 2 : char test[] = "Hello !\n";
100 2 : char test2[] = "Hello2 !\n";
101 2 : char test3[] = "Hello3 !\n";
102 2 : char test4[] = "Hello2.5 !\n";
103 2 : char test5[] = "Hello4 !\n";
104 :
105 2 : list_add(ptr, test, sizeof(test));
106 2 : list_add(ptr, test2, sizeof(test2));
107 2 : list_add(ptr, test3, sizeof(test3));
108 2 : list_add_after(ptr, ptr->next, test4, sizeof(test4));
109 2 : TEST_ASSERT(!strcmp(ptr->member, "Hello !\n"), "Head is wrong.");
110 2 : TEST_ASSERT(!strcmp(ptr->next->member, "Hello2 !\n"), "Order is wrong.");
111 2 : TEST_ASSERT(!strcmp(ptr->next->next->member, "Hello2.5 !\n"), "Order is wrong.");
112 2 : TEST_ASSERT(!strcmp(ptr->next->next->next->member, "Hello3 !\n"), "Order is wrong.");
113 2 : tmp = list_tail(ptr);
114 2 : list_add_after(ptr, tmp, test5, sizeof(test5));
115 2 : tmp = list_tail(ptr);
116 2 : TEST_ASSERT(!strcmp(tmp->member, "Hello4 !\n"), "Order is wrong.");
117 2 : TEST_ASSERT(!tmp->next, "Next pointer is wrong.");
118 2 : list_free(ptr, NULL);
119 2 : ptr = NULL;
120 2 : list_add_after(ptr, NULL, test, sizeof(test));
121 2 : TEST_ASSERT(!strcmp(ptr->member, "Hello !\n"), "Head is wrong.");
122 2 : list_free(ptr, NULL);
123 2 : return TEST_SUCCESS;
124 : }
125 :
126 2 : TEST(list_add_before) {
127 2 : mlist_t *ptr = NULL, *tmp;
128 2 : char test[] = "Hello !\n";
129 2 : char test2[] = "Hello2 !\n";
130 2 : char test3[] = "Hello3 !\n";
131 2 : char test4[] = "Hello2.5 !\n";
132 2 : char test5[] = "Hello4 !\n";
133 :
134 2 : list_add(ptr, test, sizeof(test));
135 2 : list_add(ptr, test2, sizeof(test2));
136 2 : list_add(ptr, test3, sizeof(test3));
137 2 : list_add_before(ptr, ptr->next, test4, sizeof(test4));
138 2 : TEST_ASSERT(!strcmp(ptr->member, "Hello !\n"), "Head is wrong.");
139 2 : TEST_ASSERT(!strcmp(ptr->next->member, "Hello2.5 !\n"), "Order is wrong.");
140 2 : TEST_ASSERT(!strcmp(ptr->next->next->member, "Hello2 !\n"), "Order is wrong.");
141 2 : TEST_ASSERT(!strcmp(ptr->next->next->next->member, "Hello3 !\n"), "Order is wrong.");
142 2 : list_add_before(ptr, ptr, test5, sizeof(test5));
143 2 : tmp = ptr->head;
144 2 : TEST_ASSERT(!strcmp(tmp->member, "Hello4 !\n"), "Order is wrong.");
145 2 : TEST_ASSERT(!tmp->prev, "Next pointer is wrong.");
146 2 : list_free(ptr, NULL);
147 2 : ptr = NULL;
148 2 : list_add_before(ptr, ptr, test, sizeof(test));
149 2 : TEST_ASSERT(!strcmp(ptr->member, "Hello !\n"), "Head is wrong.");
150 2 : list_add_before(ptr, NULL, test2, sizeof(test2));
151 2 : TEST_ASSERT(!strcmp(ptr->next->member, "Hello2 !\n"), "Tail is wrong.");
152 2 : list_free(ptr, NULL);
153 2 : return TEST_SUCCESS;
154 : }
155 :
156 2 : TEST(list_for_each_rev) {
157 2 : mlist_t *ptr = NULL, *tmp;
158 2 : char test[] = "Hello !\n";
159 2 : char test2[] = "Hello2 !\n";
160 2 : char test3[] = "Hello3 !\n";
161 : char *s_tmp;
162 2 : size_t i = 0;
163 :
164 2 : list_add(ptr, test, sizeof(test));
165 2 : list_add(ptr, test2, sizeof(test2));
166 2 : list_add(ptr, test3, sizeof(test3));
167 6 : list_for_each_rev(ptr, tmp, s_tmp) {
168 4 : switch (i) {
169 4 : case 0: TEST_ASSERT(s_tmp, "Hello3 !\n"); break;
170 0 : case 1: TEST_ASSERT(s_tmp, "Hello2 !\n"); break;
171 0 : case 2: TEST_ASSERT(s_tmp, "Hello !\n"); break;
172 0 : case 3: TEST_ASSERT(0, "list_for_each too many iterations.");
173 : }
174 : }
175 2 : list_free(ptr, NULL);
176 2 : return TEST_SUCCESS;
177 : }
178 :
179 2 : TEST(list_size) {
180 2 : mlist_t *ptr = NULL;
181 2 : char test[] = "Hello !\n";
182 2 : char test2[] = "Hello2 !\n";
183 2 : char test3[] = "Hello3 !\n";
184 :
185 2 : list_add(ptr, test, sizeof(test));
186 2 : list_add(ptr, test2, sizeof(test2));
187 2 : list_add(ptr, test3, sizeof(test3));
188 2 : TEST_ASSERT(list_size(ptr) == 3, "Size is wrong.");
189 2 : list_free(ptr, NULL);
190 2 : ptr = NULL;
191 2 : TEST_ASSERT(list_size(ptr) == 0, "Size is wrong.");
192 2 : return TEST_SUCCESS;
193 : }
194 :
195 12 : int callback_list_free(void *ptr) {
196 : static bool passed = false;
197 :
198 : (void)ptr;
199 12 : if (!passed) {
200 2 : passed = true;
201 2 : return 0;
202 : }
203 10 : return 1;
204 : }
205 :
206 2 : TEST(list_free) {
207 2 : mlist_t *ptr = NULL;
208 2 : char test[] = "Toto";
209 :
210 2 : list_add(ptr, test, sizeof(test));
211 2 : list_add(ptr, test, sizeof(test));
212 2 : list_add(ptr, test, sizeof(test));
213 2 : list_add(ptr, test, sizeof(test));
214 2 : list_add(ptr, test, sizeof(test));
215 2 : list_free(ptr, &callback_list_free);
216 2 : list_free(ptr, &callback_list_free);
217 2 : return TEST_SUCCESS;
218 : }
219 :
220 2 : int callback_list_free_2(void *ptr) {
221 2 : free(ptr);
222 2 : printf("Sup ?!\n");
223 2 : return 1;
224 : }
225 :
226 2 : TEST(list_remove) {
227 2 : mlist_t *ptr = NULL;
228 2 : char test[] = "Hello !\n";
229 2 : char test2[] = "Hello2 !\n";
230 2 : char test3[] = "Hello3 !\n";
231 2 : char test4[] = "Hello4 !\n";
232 :
233 2 : list_add(ptr, test, sizeof(test));
234 2 : list_add(ptr, test2, sizeof(test2));
235 2 : list_add(ptr, test3, sizeof(test3));
236 :
237 2 : list_del(ptr, test2, sizeof(test2), NULL);
238 2 : TEST_ASSERT(strcmp(ptr->next->member, test3) == 0, "List order is wrong");
239 2 : list_add(ptr, test3, sizeof(test3));
240 :
241 2 : list_del(ptr, test, sizeof(test), &callback_list_free_2);
242 2 : TEST_ASSERT(strcmp(ptr->member, test3) == 0, "List order is wrong");
243 :
244 2 : list_del(ptr, test4, sizeof(test4), NULL);
245 2 : TEST_ASSERT(strcmp(ptr->member, test3) == 0, "List order is wrong");
246 :
247 2 : list_free(ptr, NULL);
248 2 : ptr = NULL;
249 2 : list_del(ptr, test, sizeof(test), NULL);
250 2 : return TEST_SUCCESS;
251 : }
252 :
253 2 : void register_list_tests(void) {
254 2 : reg_test("mlist", list_add_null);
255 2 : reg_test("mlist", list_add_member);
256 2 : reg_test("mlist", list_add_member_head_list);
257 2 : reg_test("mlist", list_add_member_test_multiples);
258 2 : reg_test("mlist", list_for_each);
259 2 : reg_test("mlist", list_tail);
260 2 : reg_test("mlist", list_add_after);
261 2 : reg_test("mlist", list_add_before);
262 2 : reg_test("mlist", list_for_each_rev);
263 2 : reg_test("mlist", list_size);
264 2 : reg_test("mlist", list_free);
265 2 : reg_test("mlist", list_remove);
266 2 : }
|
