ims_ipsec_pcscf: fixed possible use of uninitialized value in ipsec_forward()
[sip-router] / src / modules / ims_ipsec_pcscf / spi_list_tests.c
1 /*
2  * IMS IPSEC PCSCF module
3  *
4  * Copyright (C) 2018 Tsvetomir Dimitrov
5  *
6  * This file is part of Kamailio, a free SIP server.
7  *
8  * Kamailio is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version
12  *
13  * Kamailio is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
21  *
22  */
23
24 #ifdef _IPSEC_SPI_LIST_TEST
25
26 #include "spi_list.h"
27 #include <stdio.h>
28
29 void iterate(spi_list_t* list)
30 {
31     spi_node_t* n = list->head;
32     printf("HEAD: %d TAIL: %d; [", list->head->id, list->tail->id);
33
34     while(n) {
35         printf("%d ", n->id);
36         n = n->next;
37     }
38     printf("]\n");
39 }
40
41 void check(spi_list_t* list, int* exp, int len, const char* func_name)
42 {
43     //Special case for empty list
44     if(len == 0) {
45         if(list->head != NULL) {
46             printf("%s: Empty list but head is not NULL.\n", func_name);
47             return;
48         }
49
50         if(list->tail != NULL) {
51             printf("%s: Empty list, but tail is not NULL\n", func_name);
52             return;
53         }
54
55         goto success;
56     }
57
58     //Check head
59     if(exp[0] != list->head->id) {
60         printf("%s failed. Expected head: %d; Actual head: %d\n", func_name, exp[0], list->head->id);
61         return;
62     }
63
64     //Check list contents
65     spi_node_t* n = list->head;
66     int i;
67     for(i = 0; i < len; i++) {
68         if(exp[i] != n->id) {
69             printf("%s failed. list[%d] == %d; exp[%d] == %d\n", func_name, i, n->id, i, exp[i]);
70             return;
71         }
72         n = n->next;
73     }
74
75     //Check tail
76     if(exp[len-1] != list->tail->id) {
77         printf("%s failed. Expected tail: %d; Actual tail: %d\n", func_name, exp[len-1], list->tail->id);
78         return;
79     }
80
81 success:
82     printf("%s: OK\n", func_name);
83 }
84
85 void case1() // One element list
86 {
87     spi_list_t list = create_list();
88
89     int exp[] = {1};
90
91     spi_add(&list, 1);
92
93     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
94
95     destroy_list(list);
96 }
97
98 void case2() // Two element list
99 {
100     spi_list_t list = create_list();
101
102     int exp[] = {1, 2};
103
104     spi_add(&list, 1);
105     spi_add(&list, 2);
106
107     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
108
109     destroy_list(list);
110 }
111
112 void case3() // Three element list
113 {
114     spi_list_t list = create_list();
115
116     int exp[] = {1, 2, 3};
117
118     spi_add(&list, 1);
119     spi_add(&list, 2);
120     spi_add(&list, 3);
121
122     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
123
124     destroy_list(list);
125 }
126
127 void case4() // Delete head
128 {
129     spi_list_t list = create_list();
130
131     int exp[] = {2, 3};
132
133     spi_add(&list, 1);
134     spi_add(&list, 2);
135     spi_add(&list, 3);
136
137     spi_remove(&list, 1);
138
139     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
140
141     destroy_list(list);
142 }
143
144
145 void case5() // Delete tail
146 {
147     spi_list_t list = create_list();
148
149     int exp[] = {1, 2 };
150
151     spi_add(&list, 1);
152     spi_add(&list, 2);
153     spi_add(&list, 3);
154
155     spi_remove(&list, 3);
156
157     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
158
159     destroy_list(list);
160 }
161
162 void case6() // Delete between
163 {
164     spi_list_t list = create_list();
165
166     int exp[] = {1, 3 };
167
168     spi_add(&list, 1);
169     spi_add(&list, 2);
170     spi_add(&list, 3);
171
172     spi_remove(&list, 2);
173
174     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
175
176     destroy_list(list);
177 }
178
179 void case7() // Out of order add
180 {
181     spi_list_t list = create_list();
182
183     int exp[] = {1, 2, 3};
184
185     spi_add(&list, 2);
186     spi_add(&list, 1);
187     spi_add(&list, 3);
188
189     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
190
191     destroy_list(list);
192 }
193
194 void case8() //Random operations
195 {
196     spi_list_t list = create_list();
197
198     int exp[] = {1, 4, 6};
199
200     spi_add(&list, 2);
201     spi_add(&list, 1);
202     spi_add(&list, 3);
203
204     spi_remove(&list, 2);
205     spi_add(&list, 4);
206     spi_add(&list, 6);
207     spi_remove(&list, 3);
208
209     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
210
211     destroy_list(list);
212 }
213
214 void case9() // Empty list
215 {
216     spi_list_t list = create_list();
217
218     int exp[] = {};
219
220     spi_add(&list, 2);
221     spi_add(&list, 1);
222     spi_add(&list, 3);
223
224     spi_remove(&list, 1);
225     spi_remove(&list, 2);
226     spi_remove(&list, 3);
227
228     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
229
230     destroy_list(list);
231 }
232
233
234 void case10() //No duplicates
235 {
236     spi_list_t list = create_list();
237
238     int exp[] = {1,2,3};
239
240     spi_add(&list, 1);
241     spi_add(&list, 2);
242     spi_add(&list, 2);
243     spi_add(&list, 2);
244     spi_add(&list, 3);
245
246     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
247
248     destroy_list(list);
249 }
250
251 void case11() //No duplicates
252 {
253     spi_list_t list = create_list();
254
255     int exp[] = {1,2,3};
256
257     spi_add(&list, 1);
258     spi_add(&list, 2);
259     spi_add(&list, 3);
260     spi_add(&list, 3);
261     spi_add(&list, 3);
262
263     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
264
265     destroy_list(list);
266 }
267
268 void case12() //No duplicates
269 {
270     spi_list_t list = create_list();
271
272     int exp[] = {1,2,3};
273
274     spi_add(&list, 1);
275     spi_add(&list, 1);
276     spi_add(&list, 2);
277     spi_add(&list, 3);
278
279     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
280
281     destroy_list(list);
282 }
283
284 void case13() //No duplicates
285 {
286     spi_list_t list = create_list();
287
288     int exp[] = {1,2,3};
289
290     spi_add(&list, 1);
291     spi_add(&list, 2);
292     spi_add(&list, 3);
293     spi_add(&list, 1);
294
295     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
296
297     destroy_list(list);
298 }
299
300 void case14()
301 {
302     spi_list_t list = create_list();
303     spi_add(&list, 1);
304     spi_add(&list, 2);
305
306     if(spi_in_list(&list, 1) != 1) {
307         printf("%s: failed. 1 is in list, but spi_in_list() returns false.\n", __func__);
308         return;
309     }
310
311     if(spi_in_list(&list, 3) != 0) {
312         printf("%s: failed. 3 is not in list, but spi_in_list() returns true.\n", __func__);
313         return;
314     }
315
316     printf("%s: OK\n", __func__);
317
318     destroy_list(list);
319 }
320
321
322 int main()
323 {
324
325     case1();
326     case2();
327     case3();
328     case4();
329     case5();
330     case6();
331     case7();
332     case8();
333     case9();
334     case10();
335     case11();
336     case12();
337     case13();
338     case14();
339
340     return 0;
341 }
342
343 #endif