ims_ipsec_pcscf: sec-agree implementation for IMS
[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
96 void case2() // Two element list
97 {
98     spi_list_t list = create_list();
99
100     int exp[] = {1, 2};
101
102     spi_add(&list, 1);
103     spi_add(&list, 2);
104
105     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
106 }
107
108 void case3() // Three element list
109 {
110     spi_list_t list = create_list();
111
112     int exp[] = {1, 2, 3};
113
114     spi_add(&list, 1);
115     spi_add(&list, 2);
116     spi_add(&list, 3);
117
118     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
119 }
120
121 void case4() // Delete head
122 {
123     spi_list_t list = create_list();
124
125     int exp[] = {2, 3};
126
127     spi_add(&list, 1);
128     spi_add(&list, 2);
129     spi_add(&list, 3);
130
131     spi_remove(&list, 1);
132
133     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
134 }
135
136
137 void case5() // Delete tail
138 {
139     spi_list_t list = create_list();
140
141     int exp[] = {1, 2 };
142
143     spi_add(&list, 1);
144     spi_add(&list, 2);
145     spi_add(&list, 3);
146
147     spi_remove(&list, 3);
148
149     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
150 }
151
152 void case6() // Delete between
153 {
154     spi_list_t list = create_list();
155
156     int exp[] = {1, 3 };
157
158     spi_add(&list, 1);
159     spi_add(&list, 2);
160     spi_add(&list, 3);
161
162     spi_remove(&list, 2);
163
164     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
165 }
166
167 void case7() // Out of order add
168 {
169     spi_list_t list = create_list();
170
171     int exp[] = {1, 2, 3};
172
173     spi_add(&list, 2);
174     spi_add(&list, 1);
175     spi_add(&list, 3);
176
177     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
178 }
179
180 void case8() //Random operations
181 {
182     spi_list_t list = create_list();
183
184     int exp[] = {1, 4, 6};
185
186     spi_add(&list, 2);
187     spi_add(&list, 1);
188     spi_add(&list, 3);
189
190     spi_remove(&list, 2);
191     spi_add(&list, 4);
192     spi_add(&list, 6);
193     spi_remove(&list, 3);
194
195     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
196 }
197
198 void case9() // Empty list
199 {
200     spi_list_t list = create_list();
201
202     int exp[] = {};
203
204     spi_add(&list, 2);
205     spi_add(&list, 1);
206     spi_add(&list, 3);
207
208     spi_remove(&list, 1);
209     spi_remove(&list, 2);
210     spi_remove(&list, 3);
211
212     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
213 }
214
215
216 void case10() //No duplicates
217 {
218     spi_list_t list = create_list();
219
220     int exp[] = {1,2,3};
221
222     spi_add(&list, 1);
223     spi_add(&list, 2);
224     spi_add(&list, 2);
225     spi_add(&list, 2);
226     spi_add(&list, 3);
227
228     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
229 }
230
231 void case11() //No duplicates
232 {
233     spi_list_t list = create_list();
234
235     int exp[] = {1,2,3};
236
237     spi_add(&list, 1);
238     spi_add(&list, 2);
239     spi_add(&list, 3);
240     spi_add(&list, 3);
241     spi_add(&list, 3);
242
243     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
244 }
245
246 void case12() //No duplicates
247 {
248     spi_list_t list = create_list();
249
250     int exp[] = {1,2,3};
251
252     spi_add(&list, 1);
253     spi_add(&list, 1);
254     spi_add(&list, 2);
255     spi_add(&list, 3);
256
257     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
258 }
259
260 void case13() //No duplicates
261 {
262     spi_list_t list = create_list();
263
264     int exp[] = {1,2,3};
265
266     spi_add(&list, 1);
267     spi_add(&list, 2);
268     spi_add(&list, 3);
269     spi_add(&list, 1);
270
271     check(&list, exp, sizeof(exp)/sizeof(int), __func__);
272 }
273
274 void case14()
275 {
276     spi_list_t list = create_list();
277     spi_add(&list, 1);
278     spi_add(&list, 2);
279
280     if(spi_in_list(&list, 1) != 1) {
281         printf("%s: failed. 1 is in list, but spi_in_list() returns false.\n", __func__);
282         return;
283     }
284
285     if(spi_in_list(&list, 3) != 0) {
286         printf("%s: failed. 3 is not in list, but spi_in_list() returns true.\n", __func__);
287         return;
288     }
289
290     printf("%s: OK\n", __func__);
291 }
292
293
294 int main()
295 {
296
297     case1();
298     case2();
299     case3();
300     case4();
301     case5();
302     case6();
303     case7();
304     case8();
305     case9();
306     case10();
307     case11();
308     case12();
309     case13();
310     case14();
311
312     return 0;
313 }
314
315 #endif