source: mainline/uspace/srv/net/self_test.c@ a8a13d0

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since a8a13d0 was aadf01e, checked in by Lukas Mejdrech <lukasmejdrech@…>, 16 years ago

Coding style (no functional change)
  • Property mode set to 100644
File size: 13.5 KB
Line 
1/*
2 * Copyright (c) 2009 Lukas Mejdrech
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * - Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * - Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * - The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29/** @addtogroup net
30 * @{
31 */
32
33/** @file
34 * Self tests implementation.
35 */
36
37#include "configuration.h"
38
39#if NET_SELF_TEST
40
41#include <errno.h>
42#include <malloc.h>
43#include <stdio.h>
44
45#include "include/checksum.h"
46#include "structures/int_map.h"
47#include "structures/char_map.h"
48#include "structures/generic_char_map.h"
49#include "structures/measured_strings.h"
50#include "structures/dynamic_fifo.h"
51
52#include "self_test.h"
53
54/** Tests the function, compares the result and remembers if the result differs.
55 * @param[in] name The test name.
56 * @param[in] function_call The function to be called and checked.
57 * @param[in] result The expected result.
58 */
59#define TEST(name, function_call, result); { \
60 printf("\n\t%s", (name)); \
61 if((function_call) != (result)){ \
62 printf("\tERROR\n"); \
63 error = 1; \
64 }else{ \
65 printf("\tOK\n"); \
66 } \
67}
68
69#if NET_SELF_TEST_INT_MAP
70
71 INT_MAP_DECLARE(int_map, int);
72
73 INT_MAP_IMPLEMENT(int_map, int);
74
75#endif
76
77#if NET_SELF_TEST_GENERIC_FIELD
78
79 GENERIC_FIELD_DECLARE(int_field, int)
80
81 GENERIC_FIELD_IMPLEMENT(int_field, int)
82
83#endif
84
85#if NET_SELF_TEST_GENERIC_CHAR_MAP
86
87 GENERIC_CHAR_MAP_DECLARE(int_char_map, int)
88
89 GENERIC_CHAR_MAP_IMPLEMENT(int_char_map, int)
90
91#endif
92
93int self_test(void){
94 int error;
95 int * x;
96 int * y;
97 int * z;
98 int * u;
99 int * v;
100 int * w;
101
102 error = 0;
103
104#if NET_SELF_TEST_MEASURED_STRINGS
105 measured_string_ref string;
106
107 printf("\nMeasured strings test");
108 string = measured_string_create_bulk("I am a measured string!", 0);
109 printf("\n%x, %s at %x of %d", string, string->value, string->value, string->length);
110 printf("\nOK");
111#endif
112
113#if NET_SELF_TEST_CHAR_MAP
114 char_map_t cm;
115
116 printf("\nChar map test");
117 TEST("update ucho 3 einval", char_map_update(&cm, "ucho", 0, 3), EINVAL);
118 TEST("initialize", char_map_initialize(&cm), EOK);
119 TEST("exclude bla null", char_map_exclude(&cm, "bla", 0), CHAR_MAP_NULL);
120 TEST("find bla null", char_map_find(&cm, "bla", 0), CHAR_MAP_NULL);
121 TEST("add bla 1 eok", char_map_add(&cm, "bla", 0, 1), EOK);
122 TEST("find bla 1", char_map_find(&cm, "bla", 0), 1);
123 TEST("add bla 10 eexists", char_map_add(&cm, "bla", 0, 10), EEXISTS);
124 TEST("update bla 2 eok", char_map_update(&cm, "bla", 0, 2), EOK);
125 TEST("find bla 2", char_map_find(&cm, "bla", 0), 2);
126 TEST("update ucho 2 eok", char_map_update(&cm, "ucho", 0, 2), EOK);
127 TEST("exclude bla 2", char_map_exclude(&cm, "bla", 0), 2);
128 TEST("exclude bla null", char_map_exclude(&cm, "bla", 0), CHAR_MAP_NULL);
129 TEST("find ucho 2", char_map_find(&cm, "ucho", 0), 2);
130 TEST("update ucho 3 eok", char_map_update(&cm, "ucho", 0, 3), EOK);
131 TEST("find ucho 3", char_map_find(&cm, "ucho", 0), 3);
132 TEST("add blabla 5 eok", char_map_add(&cm, "blabla", 0, 5), EOK);
133 TEST("find blabla 5", char_map_find(&cm, "blabla", 0), 5);
134 TEST("add bla 6 eok", char_map_add(&cm, "bla", 0, 6), EOK);
135 TEST("find bla 6", char_map_find(&cm, "bla", 0), 6);
136 TEST("exclude bla 6", char_map_exclude(&cm, "bla", 0), 6);
137 TEST("find bla null", char_map_find(&cm, "bla", 0), CHAR_MAP_NULL);
138 TEST("find blabla 5", char_map_find(&cm, "blabla", 0), 5);
139 TEST("add auto 7 eok", char_map_add(&cm, "auto", 0, 7), EOK);
140 TEST("find auto 7", char_map_find(&cm, "auto", 0), 7);
141 TEST("add kara 8 eok", char_map_add(&cm, "kara", 0, 8), EOK);
142 TEST("find kara 8", char_map_find(&cm, "kara", 0), 8);
143 TEST("add nic 9 eok", char_map_add(&cm, "nic", 0, 9), EOK);
144 TEST("find nic 9", char_map_find(&cm, "nic", 0), 9);
145 TEST("find blabla 5", char_map_find(&cm, "blabla", 0), 5);
146 TEST("add micnicnic 5 9 eok", char_map_add(&cm, "micnicnic", 5, 9), EOK);
147 TEST("find micni 9", char_map_find(&cm, "micni", 0), 9);
148 TEST("find micnicn 5 9", char_map_find(&cm, "micnicn", 5), 9);
149 TEST("add 10.0.2.2 4 15 eok", char_map_add(&cm, "\x10\x0\x2\x2", 4, 15), EOK);
150 TEST("find 10.0.2.2 4 15", char_map_find(&cm, "\x10\x0\x2\x2", 4), 15);
151 printf("\n\tdestroy");
152 char_map_destroy(&cm);
153 TEST("update ucho 3 einval", char_map_update(&cm, "ucho", 0, 3), EINVAL);
154 printf("\nOK");
155
156 if(error){
157 return EINVAL;
158 }
159
160#endif
161
162#if NET_SELF_TEST_INT_MAP
163 int_map_t im;
164
165 x = (int *) malloc(sizeof(int));
166 y = (int *) malloc(sizeof(int));
167 z = (int *) malloc(sizeof(int));
168 u = (int *) malloc(sizeof(int));
169 v = (int *) malloc(sizeof(int));
170 w = (int *) malloc(sizeof(int));
171
172 im.magic = 0;
173 printf("\nInt map test");
174 TEST("add 1 x einval", int_map_add(&im, 1, x), EINVAL);
175 TEST("count -1", int_map_count(&im), -1);
176 TEST("initialize", int_map_initialize(&im), EOK);
177 TEST("count 0", int_map_count(&im), 0);
178 TEST("find 1 null", int_map_find(&im, 1), NULL);
179 TEST("add 1 x 0", int_map_add(&im, 1, x), 0);
180 TEST("find 1 x", int_map_find(&im, 1), x);
181 int_map_exclude(&im, 1);
182 TEST("find 1 null", int_map_find(&im, 1), NULL);
183 TEST("add 1 y 1", int_map_add(&im, 1, y), 1);
184 TEST("find 1 y", int_map_find(&im, 1), y);
185 TEST("add 4 z 2", int_map_add(&im, 4, z), 2);
186 TEST("get 2 z", int_map_get_index(&im, 2), z);
187 TEST("find 4 z", int_map_find(&im, 4), z);
188 TEST("find 1 y", int_map_find(&im, 1), y);
189 TEST("count 3", int_map_count(&im), 3);
190 TEST("add 2 u 3", int_map_add(&im, 2, u), 3);
191 TEST("find 2 u", int_map_find(&im, 2), u);
192 TEST("add 3 v 4", int_map_add(&im, 3, v), 4);
193 TEST("find 3 v", int_map_find(&im, 3), v);
194 TEST("get 4 v", int_map_get_index(&im, 4), v);
195 TEST("add 6 w 5", int_map_add(&im, 6, w), 5);
196 TEST("find 6 w", int_map_find(&im, 6), w);
197 TEST("count 6", int_map_count(&im), 6);
198 int_map_exclude(&im, 1);
199 TEST("find 1 null", int_map_find(&im, 1), NULL);
200 TEST("find 2 u", int_map_find(&im, 2), u);
201 int_map_exclude(&im, 7);
202 TEST("find 2 u", int_map_find(&im, 2), u);
203 TEST("find 6 w", int_map_find(&im, 6), w);
204 int_map_exclude_index(&im, 4);
205 TEST("get 4 null", int_map_get_index(&im, 4), NULL);
206 TEST("find 3 null", int_map_find(&im, 3), NULL);
207 printf("\n\tdestroy");
208 int_map_destroy(&im);
209 TEST("count -1", int_map_count(&im), -1);
210 printf("\nOK");
211
212 if(error){
213 return EINVAL;
214 }
215
216#endif
217
218#if NET_SELF_TEST_GENERIC_FIELD
219 int_field_t gf;
220
221 x = (int *) malloc(sizeof(int));
222 y = (int *) malloc(sizeof(int));
223 z = (int *) malloc(sizeof(int));
224 u = (int *) malloc(sizeof(int));
225 v = (int *) malloc(sizeof(int));
226 w = (int *) malloc(sizeof(int));
227
228 gf.magic = 0;
229 printf("\nGeneric field test");
230 TEST("add x einval", int_field_add(&gf, x), EINVAL);
231 TEST("count -1", int_field_count(&gf), -1);
232 TEST("initialize", int_field_initialize(&gf), EOK);
233 TEST("count 0", int_field_count(&gf), 0);
234 TEST("get 1 null", int_field_get_index(&gf, 1), NULL);
235 TEST("add x 0", int_field_add(&gf, x), 0);
236 TEST("get 0 x", int_field_get_index(&gf, 0), x);
237 int_field_exclude_index(&gf, 0);
238 TEST("get 0 null", int_field_get_index(&gf, 0), NULL);
239 TEST("add y 1", int_field_add(&gf, y), 1);
240 TEST("get 1 y", int_field_get_index(&gf, 1), y);
241 TEST("add z 2", int_field_add(&gf, z), 2);
242 TEST("get 2 z", int_field_get_index(&gf, 2), z);
243 TEST("get 1 y", int_field_get_index(&gf, 1), y);
244 TEST("count 3", int_field_count(&gf), 3);
245 TEST("add u 3", int_field_add(&gf, u), 3);
246 TEST("get 3 u", int_field_get_index(&gf, 3), u);
247 TEST("add v 4", int_field_add(&gf, v), 4);
248 TEST("get 4 v", int_field_get_index(&gf, 4), v);
249 TEST("add w 5", int_field_add(&gf, w), 5);
250 TEST("get 5 w", int_field_get_index(&gf, 5), w);
251 TEST("count 6", int_field_count(&gf), 6);
252 int_field_exclude_index(&gf, 1);
253 TEST("get 1 null", int_field_get_index(&gf, 1), NULL);
254 TEST("get 3 u", int_field_get_index(&gf, 3), u);
255 int_field_exclude_index(&gf, 7);
256 TEST("get 3 u", int_field_get_index(&gf, 3), u);
257 TEST("get 5 w", int_field_get_index(&gf, 5), w);
258 int_field_exclude_index(&gf, 4);
259 TEST("get 4 null", int_field_get_index(&gf, 4), NULL);
260 printf("\n\tdestroy");
261 int_field_destroy(&gf);
262 TEST("count -1", int_field_count(&gf), -1);
263 printf("\nOK");
264
265 if(error){
266 return EINVAL;
267 }
268
269#endif
270
271#if NET_SELF_TEST_GENERIC_CHAR_MAP
272 int_char_map_t icm;
273
274 x = (int *) malloc(sizeof(int));
275 y = (int *) malloc(sizeof(int));
276 z = (int *) malloc(sizeof(int));
277 u = (int *) malloc(sizeof(int));
278 v = (int *) malloc(sizeof(int));
279 w = (int *) malloc(sizeof(int));
280
281 icm.magic = 0;
282 printf("\nGeneric char map test");
283 TEST("add ucho z einval", int_char_map_add(&icm, "ucho", 0, z), EINVAL);
284 TEST("initialize", int_char_map_initialize(&icm), EOK);
285 printf("\n\texclude bla null");
286 int_char_map_exclude(&icm, "bla", 0);
287 TEST("find bla null", int_char_map_find(&icm, "bla", 0), NULL);
288 TEST("add bla x eok", int_char_map_add(&icm, "bla", 0, x), EOK);
289 TEST("find bla x", int_char_map_find(&icm, "bla", 0), x);
290 TEST("add bla y eexists", int_char_map_add(&icm, "bla", 0, y), EEXISTS);
291 printf("\n\texclude bla y");
292 int_char_map_exclude(&icm, "bla", 0);
293 printf("\n\texclude bla null");
294 int_char_map_exclude(&icm, "bla", 0);
295 TEST("add blabla v eok", int_char_map_add(&icm, "blabla", 0, v), EOK);
296 TEST("find blabla v", int_char_map_find(&icm, "blabla", 0), v);
297 TEST("add bla w eok", int_char_map_add(&icm, "bla", 0, w), EOK);
298 TEST("find bla w", int_char_map_find(&icm, "bla", 0), w);
299 printf("\n\texclude bla");
300 int_char_map_exclude(&icm, "bla", 0);
301 TEST("find bla null", int_char_map_find(&icm, "bla", 0), NULL);
302 TEST("find blabla v", int_char_map_find(&icm, "blabla", 0), v);
303 TEST("add auto u eok", int_char_map_add(&icm, "auto", 0, u), EOK);
304 TEST("find auto u", int_char_map_find(&icm, "auto", 0), u);
305 printf("\n\tdestroy");
306 int_char_map_destroy(&icm);
307 TEST("add ucho z einval", int_char_map_add(&icm, "ucho", 0, z), EINVAL);
308 printf("\nOK");
309
310 if(error){
311 return EINVAL;
312 }
313
314#endif
315
316#if NET_SELF_TEST_CRC
317 uint32_t value;
318
319 printf("\nCRC computation test");
320 value = ~ compute_crc32(~ 0, "123456789", 8 * 9);
321 TEST("123456789", value, 0xCBF43926);
322 printf("\t=> %X", value);
323 value = ~ compute_crc32(~ 0, "1", 8);
324 TEST("1", value, 0x83DCEFB7);
325 printf("\t=> %X", value);
326 value = ~ compute_crc32(~ 0, "12", 8 * 2);
327 TEST("12", value, 0x4F5344CD);
328 printf("\t=> %X", value);
329 value = ~ compute_crc32(~ 0, "123", 8 * 3);
330 TEST("123", value, 0x884863D2);
331 printf("\t=> %X", value);
332 value = ~ compute_crc32(~ 0, "1234", 8 * 4);
333 TEST("1234", value, 0x9BE3E0A3);
334 printf("\t=> %X", value);
335 value = ~ compute_crc32(~ 0, "12345678", 8 * 8);
336 TEST("12345678", value, 0x9AE0DAAF);
337 printf("\t=> %X", value);
338 value = ~ compute_crc32(~ 0, "ahoj pane", 8 * 9);
339 TEST("ahoj pane", value, 0x5FC3D706);
340 printf("\t=> %X", value);
341
342 if(error){
343 return EINVAL;
344 }
345
346#endif
347
348#if NET_SELF_TEST_DYNAMIC_FIFO
349 dyn_fifo_t fifo;
350
351 printf("\nDynamic fifo test");
352 TEST("add 1 einval", dyn_fifo_push(&fifo, 1, 0), EINVAL);
353 TEST("initialize", dyn_fifo_initialize(&fifo, 1), EOK);
354 TEST("add 1 eok", dyn_fifo_push(&fifo, 1, 0), EOK);
355 TEST("pop 1", dyn_fifo_pop(&fifo), 1);
356 TEST("pop enoent", dyn_fifo_pop(&fifo), ENOENT);
357 TEST("add 2 eok", dyn_fifo_push(&fifo, 2, 1), EOK);
358 TEST("add 3 enomem", dyn_fifo_push(&fifo, 3, 1), ENOMEM);
359 TEST("add 3 eok", dyn_fifo_push(&fifo, 3, 0), EOK);
360 TEST("pop 2", dyn_fifo_pop(&fifo), 2);
361 TEST("pop 3", dyn_fifo_pop(&fifo), 3);
362 TEST("add 4 eok", dyn_fifo_push(&fifo, 4, 2), EOK);
363 TEST("add 5 eok", dyn_fifo_push(&fifo, 5, 2), EOK);
364 TEST("add 6 enomem", dyn_fifo_push(&fifo, 6, 2), ENOMEM);
365 TEST("add 6 eok", dyn_fifo_push(&fifo, 6, 5), EOK);
366 TEST("add 7 eok", dyn_fifo_push(&fifo, 7, 5), EOK);
367 TEST("pop 4", dyn_fifo_pop(&fifo), 4);
368 TEST("pop 5", dyn_fifo_pop(&fifo), 5);
369 TEST("add 8 eok", dyn_fifo_push(&fifo, 8, 5), EOK);
370 TEST("add 9 eok", dyn_fifo_push(&fifo, 9, 5), EOK);
371 TEST("add 10 eok", dyn_fifo_push(&fifo, 10, 6), EOK);
372 TEST("add 11 eok", dyn_fifo_push(&fifo, 11, 6), EOK);
373 TEST("pop 6", dyn_fifo_pop(&fifo), 6);
374 TEST("pop 7", dyn_fifo_pop(&fifo), 7);
375 TEST("add 12 eok", dyn_fifo_push(&fifo, 12, 6), EOK);
376 TEST("add 13 eok", dyn_fifo_push(&fifo, 13, 6), EOK);
377 TEST("add 14 enomem", dyn_fifo_push(&fifo, 14, 6), ENOMEM);
378 TEST("add 14 eok", dyn_fifo_push(&fifo, 14, 8), EOK);
379 TEST("pop 8", dyn_fifo_pop(&fifo), 8);
380 TEST("pop 9", dyn_fifo_pop(&fifo), 9);
381 TEST("pop 10", dyn_fifo_pop(&fifo), 10);
382 TEST("pop 11", dyn_fifo_pop(&fifo), 11);
383 TEST("pop 12", dyn_fifo_pop(&fifo), 12);
384 TEST("pop 13", dyn_fifo_pop(&fifo), 13);
385 TEST("pop 14", dyn_fifo_pop(&fifo), 14);
386 TEST("destroy", dyn_fifo_destroy(&fifo), EOK);
387 TEST("add 15 einval", dyn_fifo_push(&fifo, 1, 0), EINVAL);
388 if(error){
389 return EINVAL;
390 }
391
392#endif
393
394 return EOK;
395}
396
397#endif
398
399/** @}
400 */
Note: See TracBrowser for help on using the repository browser.