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

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since a64c64d was a64c64d, checked in by Lukas Mejdrech <lukasmejdrech@…>, 15 years ago
  • code reorganization (no functional change)
  • Property mode set to 100644
File size: 13.5 KB
RevLine 
[21580dd]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 */
[a64c64d]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 } \
[21580dd]67}
68
[a64c64d]69#if NET_SELF_TEST_GENERIC_CHAR_MAP
[21580dd]70
[a64c64d]71 GENERIC_CHAR_MAP_DECLARE(int_char_map, int)
[21580dd]72
[a64c64d]73 GENERIC_CHAR_MAP_IMPLEMENT(int_char_map, int)
[21580dd]74
75#endif
76
77#if NET_SELF_TEST_GENERIC_FIELD
78
[aadf01e]79 GENERIC_FIELD_DECLARE(int_field, int)
[21580dd]80
[aadf01e]81 GENERIC_FIELD_IMPLEMENT(int_field, int)
[21580dd]82
83#endif
84
[a64c64d]85#if NET_SELF_TEST_INT_MAP
[21580dd]86
[a64c64d]87 INT_MAP_DECLARE(int_map, int);
[21580dd]88
[a64c64d]89 INT_MAP_IMPLEMENT(int_map, int);
[21580dd]90
91#endif
92
[aadf01e]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;
[21580dd]103
104#if NET_SELF_TEST_CHAR_MAP
[aadf01e]105 char_map_t cm;
106
107 printf("\nChar map test");
108 TEST("update ucho 3 einval", char_map_update(&cm, "ucho", 0, 3), EINVAL);
109 TEST("initialize", char_map_initialize(&cm), EOK);
110 TEST("exclude bla null", char_map_exclude(&cm, "bla", 0), CHAR_MAP_NULL);
111 TEST("find bla null", char_map_find(&cm, "bla", 0), CHAR_MAP_NULL);
112 TEST("add bla 1 eok", char_map_add(&cm, "bla", 0, 1), EOK);
113 TEST("find bla 1", char_map_find(&cm, "bla", 0), 1);
114 TEST("add bla 10 eexists", char_map_add(&cm, "bla", 0, 10), EEXISTS);
115 TEST("update bla 2 eok", char_map_update(&cm, "bla", 0, 2), EOK);
116 TEST("find bla 2", char_map_find(&cm, "bla", 0), 2);
117 TEST("update ucho 2 eok", char_map_update(&cm, "ucho", 0, 2), EOK);
118 TEST("exclude bla 2", char_map_exclude(&cm, "bla", 0), 2);
119 TEST("exclude bla null", char_map_exclude(&cm, "bla", 0), CHAR_MAP_NULL);
120 TEST("find ucho 2", char_map_find(&cm, "ucho", 0), 2);
121 TEST("update ucho 3 eok", char_map_update(&cm, "ucho", 0, 3), EOK);
122 TEST("find ucho 3", char_map_find(&cm, "ucho", 0), 3);
123 TEST("add blabla 5 eok", char_map_add(&cm, "blabla", 0, 5), EOK);
124 TEST("find blabla 5", char_map_find(&cm, "blabla", 0), 5);
125 TEST("add bla 6 eok", char_map_add(&cm, "bla", 0, 6), EOK);
126 TEST("find bla 6", char_map_find(&cm, "bla", 0), 6);
127 TEST("exclude bla 6", char_map_exclude(&cm, "bla", 0), 6);
128 TEST("find bla null", char_map_find(&cm, "bla", 0), CHAR_MAP_NULL);
129 TEST("find blabla 5", char_map_find(&cm, "blabla", 0), 5);
130 TEST("add auto 7 eok", char_map_add(&cm, "auto", 0, 7), EOK);
131 TEST("find auto 7", char_map_find(&cm, "auto", 0), 7);
132 TEST("add kara 8 eok", char_map_add(&cm, "kara", 0, 8), EOK);
133 TEST("find kara 8", char_map_find(&cm, "kara", 0), 8);
134 TEST("add nic 9 eok", char_map_add(&cm, "nic", 0, 9), EOK);
135 TEST("find nic 9", char_map_find(&cm, "nic", 0), 9);
136 TEST("find blabla 5", char_map_find(&cm, "blabla", 0), 5);
137 TEST("add micnicnic 5 9 eok", char_map_add(&cm, "micnicnic", 5, 9), EOK);
138 TEST("find micni 9", char_map_find(&cm, "micni", 0), 9);
139 TEST("find micnicn 5 9", char_map_find(&cm, "micnicn", 5), 9);
140 TEST("add 10.0.2.2 4 15 eok", char_map_add(&cm, "\x10\x0\x2\x2", 4, 15), EOK);
141 TEST("find 10.0.2.2 4 15", char_map_find(&cm, "\x10\x0\x2\x2", 4), 15);
142 printf("\n\tdestroy");
143 char_map_destroy(&cm);
144 TEST("update ucho 3 einval", char_map_update(&cm, "ucho", 0, 3), EINVAL);
145 printf("\nOK");
146
147 if(error){
148 return EINVAL;
149 }
[21580dd]150
151#endif
152
[a64c64d]153#if NET_SELF_TEST_CRC
154 uint32_t value;
155
156 printf("\nCRC computation test");
157 value = ~ compute_crc32(~ 0, "123456789", 8 * 9);
158 TEST("123456789", value, 0xCBF43926);
159 printf("\t=> %X", value);
160 value = ~ compute_crc32(~ 0, "1", 8);
161 TEST("1", value, 0x83DCEFB7);
162 printf("\t=> %X", value);
163 value = ~ compute_crc32(~ 0, "12", 8 * 2);
164 TEST("12", value, 0x4F5344CD);
165 printf("\t=> %X", value);
166 value = ~ compute_crc32(~ 0, "123", 8 * 3);
167 TEST("123", value, 0x884863D2);
168 printf("\t=> %X", value);
169 value = ~ compute_crc32(~ 0, "1234", 8 * 4);
170 TEST("1234", value, 0x9BE3E0A3);
171 printf("\t=> %X", value);
172 value = ~ compute_crc32(~ 0, "12345678", 8 * 8);
173 TEST("12345678", value, 0x9AE0DAAF);
174 printf("\t=> %X", value);
175 value = ~ compute_crc32(~ 0, "ahoj pane", 8 * 9);
176 TEST("ahoj pane", value, 0x5FC3D706);
177 printf("\t=> %X", value);
178
179 if(error){
180 return EINVAL;
181 }
182
183#endif
184
185#if NET_SELF_TEST_DYNAMIC_FIFO
186 dyn_fifo_t fifo;
187
188 printf("\nDynamic fifo test");
189 TEST("add 1 einval", dyn_fifo_push(&fifo, 1, 0), EINVAL);
190 TEST("initialize", dyn_fifo_initialize(&fifo, 1), EOK);
191 TEST("add 1 eok", dyn_fifo_push(&fifo, 1, 0), EOK);
192 TEST("pop 1", dyn_fifo_pop(&fifo), 1);
193 TEST("pop enoent", dyn_fifo_pop(&fifo), ENOENT);
194 TEST("add 2 eok", dyn_fifo_push(&fifo, 2, 1), EOK);
195 TEST("add 3 enomem", dyn_fifo_push(&fifo, 3, 1), ENOMEM);
196 TEST("add 3 eok", dyn_fifo_push(&fifo, 3, 0), EOK);
197 TEST("pop 2", dyn_fifo_pop(&fifo), 2);
198 TEST("pop 3", dyn_fifo_pop(&fifo), 3);
199 TEST("add 4 eok", dyn_fifo_push(&fifo, 4, 2), EOK);
200 TEST("add 5 eok", dyn_fifo_push(&fifo, 5, 2), EOK);
201 TEST("add 6 enomem", dyn_fifo_push(&fifo, 6, 2), ENOMEM);
202 TEST("add 6 eok", dyn_fifo_push(&fifo, 6, 5), EOK);
203 TEST("add 7 eok", dyn_fifo_push(&fifo, 7, 5), EOK);
204 TEST("pop 4", dyn_fifo_pop(&fifo), 4);
205 TEST("pop 5", dyn_fifo_pop(&fifo), 5);
206 TEST("add 8 eok", dyn_fifo_push(&fifo, 8, 5), EOK);
207 TEST("add 9 eok", dyn_fifo_push(&fifo, 9, 5), EOK);
208 TEST("add 10 eok", dyn_fifo_push(&fifo, 10, 6), EOK);
209 TEST("add 11 eok", dyn_fifo_push(&fifo, 11, 6), EOK);
210 TEST("pop 6", dyn_fifo_pop(&fifo), 6);
211 TEST("pop 7", dyn_fifo_pop(&fifo), 7);
212 TEST("add 12 eok", dyn_fifo_push(&fifo, 12, 6), EOK);
213 TEST("add 13 eok", dyn_fifo_push(&fifo, 13, 6), EOK);
214 TEST("add 14 enomem", dyn_fifo_push(&fifo, 14, 6), ENOMEM);
215 TEST("add 14 eok", dyn_fifo_push(&fifo, 14, 8), EOK);
216 TEST("pop 8", dyn_fifo_pop(&fifo), 8);
217 TEST("pop 9", dyn_fifo_pop(&fifo), 9);
218 TEST("pop 10", dyn_fifo_pop(&fifo), 10);
219 TEST("pop 11", dyn_fifo_pop(&fifo), 11);
220 TEST("pop 12", dyn_fifo_pop(&fifo), 12);
221 TEST("pop 13", dyn_fifo_pop(&fifo), 13);
222 TEST("pop 14", dyn_fifo_pop(&fifo), 14);
223 TEST("destroy", dyn_fifo_destroy(&fifo), EOK);
224 TEST("add 15 einval", dyn_fifo_push(&fifo, 1, 0), EINVAL);
225 if(error){
226 return EINVAL;
227 }
228
229#endif
230
231#if NET_SELF_TEST_GENERIC_CHAR_MAP
232 int_char_map_t icm;
[21580dd]233
[aadf01e]234 x = (int *) malloc(sizeof(int));
235 y = (int *) malloc(sizeof(int));
236 z = (int *) malloc(sizeof(int));
237 u = (int *) malloc(sizeof(int));
238 v = (int *) malloc(sizeof(int));
239 w = (int *) malloc(sizeof(int));
[21580dd]240
[a64c64d]241 icm.magic = 0;
242 printf("\nGeneric char map test");
243 TEST("add ucho z einval", int_char_map_add(&icm, "ucho", 0, z), EINVAL);
244 TEST("initialize", int_char_map_initialize(&icm), EOK);
245 printf("\n\texclude bla null");
246 int_char_map_exclude(&icm, "bla", 0);
247 TEST("find bla null", int_char_map_find(&icm, "bla", 0), NULL);
248 TEST("add bla x eok", int_char_map_add(&icm, "bla", 0, x), EOK);
249 TEST("find bla x", int_char_map_find(&icm, "bla", 0), x);
250 TEST("add bla y eexists", int_char_map_add(&icm, "bla", 0, y), EEXISTS);
251 printf("\n\texclude bla y");
252 int_char_map_exclude(&icm, "bla", 0);
253 printf("\n\texclude bla null");
254 int_char_map_exclude(&icm, "bla", 0);
255 TEST("add blabla v eok", int_char_map_add(&icm, "blabla", 0, v), EOK);
256 TEST("find blabla v", int_char_map_find(&icm, "blabla", 0), v);
257 TEST("add bla w eok", int_char_map_add(&icm, "bla", 0, w), EOK);
258 TEST("find bla w", int_char_map_find(&icm, "bla", 0), w);
259 printf("\n\texclude bla");
260 int_char_map_exclude(&icm, "bla", 0);
261 TEST("find bla null", int_char_map_find(&icm, "bla", 0), NULL);
262 TEST("find blabla v", int_char_map_find(&icm, "blabla", 0), v);
263 TEST("add auto u eok", int_char_map_add(&icm, "auto", 0, u), EOK);
264 TEST("find auto u", int_char_map_find(&icm, "auto", 0), u);
[aadf01e]265 printf("\n\tdestroy");
[a64c64d]266 int_char_map_destroy(&icm);
267 TEST("add ucho z einval", int_char_map_add(&icm, "ucho", 0, z), EINVAL);
[aadf01e]268 printf("\nOK");
269
270 if(error){
271 return EINVAL;
272 }
[21580dd]273
274#endif
275
276#if NET_SELF_TEST_GENERIC_FIELD
[aadf01e]277 int_field_t gf;
[21580dd]278
[aadf01e]279 x = (int *) malloc(sizeof(int));
280 y = (int *) malloc(sizeof(int));
281 z = (int *) malloc(sizeof(int));
282 u = (int *) malloc(sizeof(int));
283 v = (int *) malloc(sizeof(int));
284 w = (int *) malloc(sizeof(int));
[21580dd]285
286 gf.magic = 0;
[aadf01e]287 printf("\nGeneric field test");
288 TEST("add x einval", int_field_add(&gf, x), EINVAL);
289 TEST("count -1", int_field_count(&gf), -1);
290 TEST("initialize", int_field_initialize(&gf), EOK);
291 TEST("count 0", int_field_count(&gf), 0);
292 TEST("get 1 null", int_field_get_index(&gf, 1), NULL);
293 TEST("add x 0", int_field_add(&gf, x), 0);
294 TEST("get 0 x", int_field_get_index(&gf, 0), x);
295 int_field_exclude_index(&gf, 0);
296 TEST("get 0 null", int_field_get_index(&gf, 0), NULL);
297 TEST("add y 1", int_field_add(&gf, y), 1);
298 TEST("get 1 y", int_field_get_index(&gf, 1), y);
299 TEST("add z 2", int_field_add(&gf, z), 2);
300 TEST("get 2 z", int_field_get_index(&gf, 2), z);
301 TEST("get 1 y", int_field_get_index(&gf, 1), y);
302 TEST("count 3", int_field_count(&gf), 3);
303 TEST("add u 3", int_field_add(&gf, u), 3);
304 TEST("get 3 u", int_field_get_index(&gf, 3), u);
305 TEST("add v 4", int_field_add(&gf, v), 4);
306 TEST("get 4 v", int_field_get_index(&gf, 4), v);
307 TEST("add w 5", int_field_add(&gf, w), 5);
308 TEST("get 5 w", int_field_get_index(&gf, 5), w);
309 TEST("count 6", int_field_count(&gf), 6);
310 int_field_exclude_index(&gf, 1);
311 TEST("get 1 null", int_field_get_index(&gf, 1), NULL);
312 TEST("get 3 u", int_field_get_index(&gf, 3), u);
313 int_field_exclude_index(&gf, 7);
314 TEST("get 3 u", int_field_get_index(&gf, 3), u);
315 TEST("get 5 w", int_field_get_index(&gf, 5), w);
316 int_field_exclude_index(&gf, 4);
317 TEST("get 4 null", int_field_get_index(&gf, 4), NULL);
318 printf("\n\tdestroy");
319 int_field_destroy(&gf);
320 TEST("count -1", int_field_count(&gf), -1);
321 printf("\nOK");
322
323 if(error){
324 return EINVAL;
325 }
[21580dd]326
327#endif
328
[a64c64d]329#if NET_SELF_TEST_INT_MAP
330 int_map_t im;
[21580dd]331
[aadf01e]332 x = (int *) malloc(sizeof(int));
333 y = (int *) malloc(sizeof(int));
334 z = (int *) malloc(sizeof(int));
335 u = (int *) malloc(sizeof(int));
336 v = (int *) malloc(sizeof(int));
337 w = (int *) malloc(sizeof(int));
[21580dd]338
[a64c64d]339 im.magic = 0;
340 printf("\nInt map test");
341 TEST("add 1 x einval", int_map_add(&im, 1, x), EINVAL);
342 TEST("count -1", int_map_count(&im), -1);
343 TEST("initialize", int_map_initialize(&im), EOK);
344 TEST("count 0", int_map_count(&im), 0);
345 TEST("find 1 null", int_map_find(&im, 1), NULL);
346 TEST("add 1 x 0", int_map_add(&im, 1, x), 0);
347 TEST("find 1 x", int_map_find(&im, 1), x);
348 int_map_exclude(&im, 1);
349 TEST("find 1 null", int_map_find(&im, 1), NULL);
350 TEST("add 1 y 1", int_map_add(&im, 1, y), 1);
351 TEST("find 1 y", int_map_find(&im, 1), y);
352 TEST("add 4 z 2", int_map_add(&im, 4, z), 2);
353 TEST("get 2 z", int_map_get_index(&im, 2), z);
354 TEST("find 4 z", int_map_find(&im, 4), z);
355 TEST("find 1 y", int_map_find(&im, 1), y);
356 TEST("count 3", int_map_count(&im), 3);
357 TEST("add 2 u 3", int_map_add(&im, 2, u), 3);
358 TEST("find 2 u", int_map_find(&im, 2), u);
359 TEST("add 3 v 4", int_map_add(&im, 3, v), 4);
360 TEST("find 3 v", int_map_find(&im, 3), v);
361 TEST("get 4 v", int_map_get_index(&im, 4), v);
362 TEST("add 6 w 5", int_map_add(&im, 6, w), 5);
363 TEST("find 6 w", int_map_find(&im, 6), w);
364 TEST("count 6", int_map_count(&im), 6);
365 int_map_exclude(&im, 1);
366 TEST("find 1 null", int_map_find(&im, 1), NULL);
367 TEST("find 2 u", int_map_find(&im, 2), u);
368 int_map_exclude(&im, 7);
369 TEST("find 2 u", int_map_find(&im, 2), u);
370 TEST("find 6 w", int_map_find(&im, 6), w);
371 int_map_exclude_index(&im, 4);
372 TEST("get 4 null", int_map_get_index(&im, 4), NULL);
373 TEST("find 3 null", int_map_find(&im, 3), NULL);
[aadf01e]374 printf("\n\tdestroy");
[a64c64d]375 int_map_destroy(&im);
376 TEST("count -1", int_map_count(&im), -1);
[aadf01e]377 printf("\nOK");
378
379 if(error){
380 return EINVAL;
381 }
[21580dd]382
383#endif
384
[a64c64d]385#if NET_SELF_TEST_MEASURED_STRINGS
386 measured_string_ref string;
[21580dd]387
[a64c64d]388 printf("\nMeasured strings test");
389 string = measured_string_create_bulk("I am a measured string!", 0);
390 printf("\n%x, %s at %x of %d", string, string->value, string->value, string->length);
391 printf("\nOK");
[21580dd]392#endif
393
394 return EOK;
395}
396
397#endif
398
399/** @}
400 */
Note: See TracBrowser for help on using the repository browser.