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