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

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since c92a5753 was 21580dd, checked in by Lukas Mejdrech <lukas@…>, 15 years ago

Merged with network branch ​svn://svn.helenos.org/HelenOS/branches/network revision 4759; ipc_share_* and ipc_data_* changed to async_*; client connection in module.c returns on IPC_M_PHONE_HUNGUP; * Qemu scripts renamed to net-qe.*; (the dp8390 does not respond)
  • Property mode set to 100644
File size: 14.3 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 = 0;
95 int * x, * y, * z, * u, * v, * w;
96
97#if NET_SELF_TEST_MEASURED_STRINGS
98 measured_string_ref string;
99
100 printf( "\nMeasured strings test" );
101 string = measured_string_create_bulk( "I am a measured string!", 0 );
102 printf( "\n%x, %s at %x of %d", string, string->value, string->value, string->length );
103 printf( "\nOK" );
104#endif
105
106#if NET_SELF_TEST_CHAR_MAP
107 char_map_t cm;
108
109 printf( "\nChar map test" );
110 TEST( "update ucho 3 einval", char_map_update( & cm, "ucho", 0, 3 ), EINVAL );
111 TEST( "initialize", char_map_initialize( & cm ), EOK );
112 TEST( "exclude bla null", char_map_exclude( & cm, "bla", 0 ), CHAR_MAP_NULL );
113 TEST( "find bla null", char_map_find( & cm, "bla", 0 ), CHAR_MAP_NULL );
114 TEST( "add bla 1 eok", char_map_add( & cm, "bla", 0, 1 ), EOK );
115 TEST( "find bla 1", char_map_find( & cm, "bla", 0 ), 1 );
116 TEST( "add bla 10 eexists", char_map_add( & cm, "bla", 0, 10 ), EEXISTS );
117 TEST( "update bla 2 eok", char_map_update( & cm, "bla", 0, 2 ), EOK );
118 TEST( "find bla 2", char_map_find( & cm, "bla", 0 ), 2 );
119 TEST( "update ucho 2 eok", char_map_update( & cm, "ucho", 0, 2 ), EOK );
120 TEST( "exclude bla 2", char_map_exclude( & cm, "bla", 0 ), 2 );
121 TEST( "exclude bla null", char_map_exclude( & cm, "bla", 0 ), CHAR_MAP_NULL );
122 TEST( "find ucho 2", char_map_find( & cm, "ucho", 0 ), 2 );
123 TEST( "update ucho 3 eok", char_map_update( & cm, "ucho", 0, 3 ), EOK );
124 TEST( "find ucho 3", char_map_find( & cm, "ucho", 0 ), 3 );
125 TEST( "add blabla 5 eok", char_map_add( & cm, "blabla", 0, 5 ), EOK );
126 TEST( "find blabla 5", char_map_find( & cm, "blabla", 0 ), 5 );
127 TEST( "add bla 6 eok", char_map_add( & cm, "bla", 0, 6 ), EOK );
128 TEST( "find bla 6", char_map_find( & cm, "bla", 0 ), 6 );
129 TEST( "exclude bla 6", char_map_exclude( & cm, "bla", 0 ), 6 );
130 TEST( "find bla null", char_map_find( & cm, "bla", 0 ), CHAR_MAP_NULL );
131 TEST( "find blabla 5", char_map_find( & cm, "blabla", 0 ), 5 );
132 TEST( "add auto 7 eok", char_map_add( & cm, "auto", 0, 7 ), EOK );
133 TEST( "find auto 7", char_map_find( & cm, "auto", 0 ), 7 );
134 TEST( "add kara 8 eok", char_map_add( & cm, "kara", 0, 8 ), EOK );
135 TEST( "find kara 8", char_map_find( & cm, "kara", 0 ), 8 );
136 TEST( "add nic 9 eok", char_map_add( & cm, "nic", 0, 9 ), EOK );
137 TEST( "find nic 9", char_map_find( & cm, "nic", 0 ), 9 );
138 TEST( "find blabla 5", char_map_find( & cm, "blabla", 0 ), 5 );
139 TEST( "add micnicnic 5 9 eok", char_map_add( & cm, "micnicnic", 5, 9 ), EOK );
140 TEST( "find micni 9", char_map_find( & cm, "micni", 0 ), 9 );
141 TEST( "find micnicn 5 9", char_map_find( & cm, "micnicn", 5 ), 9 );
142 TEST( "add 10.0.2.2 4 15 eok", char_map_add( & cm, "\x10\x0\x2\x2", 4, 15 ), EOK );
143 TEST( "find 10.0.2.2 4 15", char_map_find( & cm, "\x10\x0\x2\x2", 4 ), 15 );
144 printf( "\n\tdestroy" );
145 char_map_destroy( & cm );
146 TEST( "update ucho 3 einval", char_map_update( & cm, "ucho", 0, 3 ), EINVAL );
147 printf( "\nOK" );
148
149 if( error ) return EINVAL;
150
151#endif
152
153#if NET_SELF_TEST_INT_MAP
154 int_map_t im;
155
156 x = ( int * ) malloc( sizeof( int ));
157 y = ( int * ) malloc( sizeof( int ));
158 z = ( int * ) malloc( sizeof( int ));
159 u = ( int * ) malloc( sizeof( int ));
160 v = ( int * ) malloc( sizeof( int ));
161 w = ( int * ) malloc( sizeof( int ));
162
163 im.magic = 0;
164 printf( "\nInt map test" );
165 TEST( "add 1 x einval", int_map_add( & im, 1, x ), EINVAL );
166 TEST( "count -1", int_map_count( & im ), -1 );
167 TEST( "initialize", int_map_initialize( & im ), EOK );
168 TEST( "count 0", int_map_count( & im ), 0 );
169 TEST( "find 1 null", int_map_find( & im, 1 ), NULL );
170 TEST( "add 1 x 0", int_map_add( & im, 1, x ), 0 );
171 TEST( "find 1 x", int_map_find( & im, 1 ), x );
172 int_map_exclude( & im, 1 );
173 TEST( "find 1 null", int_map_find( & im, 1 ), NULL );
174 TEST( "add 1 y 1", int_map_add( & im, 1, y ), 1 );
175 TEST( "find 1 y", int_map_find( & im, 1 ), y );
176 TEST( "add 4 z 2", int_map_add( & im, 4, z ), 2 );
177 TEST( "get 2 z", int_map_get_index( & im, 2 ), z );
178 TEST( "find 4 z", int_map_find( & im, 4 ), z );
179 TEST( "find 1 y", int_map_find( & im, 1 ), y );
180 TEST( "count 3", int_map_count( & im ), 3 );
181 TEST( "add 2 u 3", int_map_add( & im, 2, u ), 3 );
182 TEST( "find 2 u", int_map_find( & im, 2 ), u );
183 TEST( "add 3 v 4", int_map_add( & im, 3, v ), 4 );
184 TEST( "find 3 v", int_map_find( & im, 3 ), v );
185 TEST( "get 4 v", int_map_get_index( & im, 4 ), v );
186 TEST( "add 6 w 5", int_map_add( & im, 6, w ), 5 );
187 TEST( "find 6 w", int_map_find( & im, 6 ), w );
188 TEST( "count 6", int_map_count( & im ), 6 );
189 int_map_exclude( & im, 1 );
190 TEST( "find 1 null", int_map_find( & im, 1 ), NULL );
191 TEST( "find 2 u", int_map_find( & im, 2 ), u );
192 int_map_exclude( & im, 7 );
193 TEST( "find 2 u", int_map_find( & im, 2 ), u );
194 TEST( "find 6 w", int_map_find( & im, 6 ), w );
195 int_map_exclude_index( & im, 4 );
196 TEST( "get 4 null", int_map_get_index( & im, 4 ), NULL );
197 TEST( "find 3 null", int_map_find( & im, 3 ), NULL );
198 printf( "\n\tdestroy" );
199 int_map_destroy( & im );
200 TEST( "count -1", int_map_count( & im ), -1 );
201 printf( "\nOK" );
202
203 if( error ) return EINVAL;
204
205#endif
206
207#if NET_SELF_TEST_GENERIC_FIELD
208 int_field_t gf;
209
210 x = ( int * ) malloc( sizeof( int ));
211 y = ( int * ) malloc( sizeof( int ));
212 z = ( int * ) malloc( sizeof( int ));
213 u = ( int * ) malloc( sizeof( int ));
214 v = ( int * ) malloc( sizeof( int ));
215 w = ( int * ) malloc( sizeof( int ));
216
217 gf.magic = 0;
218 printf( "\nGeneric field test" );
219 TEST( "add x einval", int_field_add( & gf, x ), EINVAL );
220 TEST( "count -1", int_field_count( & gf ), -1 );
221 TEST( "initialize", int_field_initialize( & gf ), EOK );
222 TEST( "count 0", int_field_count( & gf ), 0 );
223 TEST( "get 1 null", int_field_get_index( & gf, 1 ), NULL );
224 TEST( "add x 0", int_field_add( & gf, x ), 0 );
225 TEST( "get 0 x", int_field_get_index( & gf, 0 ), x );
226 int_field_exclude_index( & gf, 0 );
227 TEST( "get 0 null", int_field_get_index( & gf, 0 ), NULL );
228 TEST( "add y 1", int_field_add( & gf, y ), 1 );
229 TEST( "get 1 y", int_field_get_index( & gf, 1 ), y );
230 TEST( "add z 2", int_field_add( & gf, z ), 2 );
231 TEST( "get 2 z", int_field_get_index( & gf, 2 ), z );
232 TEST( "get 1 y", int_field_get_index( & gf, 1 ), y );
233 TEST( "count 3", int_field_count( & gf ), 3 );
234 TEST( "add u 3", int_field_add( & gf, u ), 3 );
235 TEST( "get 3 u", int_field_get_index( & gf, 3 ), u );
236 TEST( "add v 4", int_field_add( & gf, v ), 4 );
237 TEST( "get 4 v", int_field_get_index( & gf, 4 ), v );
238 TEST( "add w 5", int_field_add( & gf, w ), 5 );
239 TEST( "get 5 w", int_field_get_index( & gf, 5 ), w );
240 TEST( "count 6", int_field_count( & gf ), 6 );
241 int_field_exclude_index( & gf, 1 );
242 TEST( "get 1 null", int_field_get_index( & gf, 1 ), NULL );
243 TEST( "get 3 u", int_field_get_index( & gf, 3 ), u );
244 int_field_exclude_index( & gf, 7 );
245 TEST( "get 3 u", int_field_get_index( & gf, 3 ), u );
246 TEST( "get 5 w", int_field_get_index( & gf, 5 ), w );
247 int_field_exclude_index( & gf, 4 );
248 TEST( "get 4 null", int_field_get_index( & gf, 4 ), NULL );
249 printf( "\n\tdestroy" );
250 int_field_destroy( & gf );
251 TEST( "count -1", int_field_count( & gf ), -1 );
252 printf( "\nOK" );
253
254 if( error ) return EINVAL;
255
256#endif
257
258#if NET_SELF_TEST_GENERIC_CHAR_MAP
259 int_char_map_t icm;
260
261 x = ( int * ) malloc( sizeof( int ));
262 y = ( int * ) malloc( sizeof( int ));
263 z = ( int * ) malloc( sizeof( int ));
264 u = ( int * ) malloc( sizeof( int ));
265 v = ( int * ) malloc( sizeof( int ));
266 w = ( int * ) malloc( sizeof( int ));
267
268 icm.magic = 0;
269 printf( "\nGeneric char map test" );
270 TEST( "add ucho z einval", int_char_map_add( & icm, "ucho", 0, z ), EINVAL );
271 TEST( "initialize", int_char_map_initialize( & icm ), EOK );
272 printf( "\n\texclude bla null" );
273 int_char_map_exclude( & icm, "bla", 0 );
274 TEST( "find bla null", int_char_map_find( & icm, "bla", 0 ), NULL );
275 TEST( "add bla x eok", int_char_map_add( & icm, "bla", 0, x ), EOK );
276 TEST( "find bla x", int_char_map_find( & icm, "bla", 0 ), x );
277 TEST( "add bla y eexists", int_char_map_add( & icm, "bla", 0, y ), EEXISTS );
278 printf( "\n\texclude bla y" );
279 int_char_map_exclude( & icm, "bla", 0 );
280 printf( "\n\texclude bla null" );
281 int_char_map_exclude( & icm, "bla", 0 );
282 TEST( "add blabla v eok", int_char_map_add( & icm, "blabla", 0, v ), EOK );
283 TEST( "find blabla v", int_char_map_find( & icm, "blabla", 0 ), v );
284 TEST( "add bla w eok", int_char_map_add( & icm, "bla", 0, w ), EOK );
285 TEST( "find bla w", int_char_map_find( & icm, "bla", 0 ), w );
286 printf( "\n\texclude bla" );
287 int_char_map_exclude( & icm, "bla", 0 );
288 TEST( "find bla null", int_char_map_find( & icm, "bla", 0 ), NULL );
289 TEST( "find blabla v", int_char_map_find( & icm, "blabla", 0 ), v );
290 TEST( "add auto u eok", int_char_map_add( & icm, "auto", 0, u ), EOK );
291 TEST( "find auto u", int_char_map_find( & icm, "auto", 0 ), u );
292 printf( "\n\tdestroy" );
293 int_char_map_destroy( & icm );
294 TEST( "add ucho z einval", int_char_map_add( & icm, "ucho", 0, z ), EINVAL );
295 printf( "\nOK" );
296
297 if( error ) return EINVAL;
298
299#endif
300
301#if NET_SELF_TEST_CRC
302 uint32_t value;
303
304 printf( "\nCRC computation test" );
305 value = ~ compute_crc32( ~ 0, "123456789", 8 * 9 );
306 TEST( "123456789", value, 0xCBF43926 );
307 printf( "\t=> %X", value );
308 value = ~ compute_crc32( ~ 0, "1", 8 );
309 TEST( "1", value, 0x83DCEFB7 );
310 printf( "\t=> %X", value );
311 value = ~ compute_crc32( ~ 0, "12", 8 * 2 );
312 TEST( "12", value, 0x4F5344CD );
313 printf( "\t=> %X", value );
314 value = ~ compute_crc32( ~ 0, "123", 8 * 3 );
315 TEST( "123", value, 0x884863D2 );
316 printf( "\t=> %X", value );
317 value = ~ compute_crc32( ~ 0, "1234", 8 * 4 );
318 TEST( "1234", value, 0x9BE3E0A3 );
319 printf( "\t=> %X", value );
320 value = ~ compute_crc32( ~ 0, "12345678", 8 * 8 );
321 TEST( "12345678", value, 0x9AE0DAAF );
322 printf( "\t=> %X", value );
323 value = ~ compute_crc32( ~ 0, "ahoj pane", 8 * 9 );
324 TEST( "ahoj pane", value, 0x5FC3D706 );
325 printf( "\t=> %X", value );
326
327 if( error ) return EINVAL;
328
329#endif
330
331#if NET_SELF_TEST_DYNAMIC_FIFO
332 dyn_fifo_t fifo;
333
334 printf( "\nDynamic fifo test" );
335 TEST( "add 1 einval", dyn_fifo_push( & fifo, 1, 0 ), EINVAL );
336 TEST( "initialize", dyn_fifo_initialize( & fifo, 1 ), EOK );
337 TEST( "add 1 eok", dyn_fifo_push( & fifo, 1, 0 ), EOK );
338 TEST( "pop 1", dyn_fifo_pop( & fifo ), 1 );
339 TEST( "pop enoent", dyn_fifo_pop( & fifo ), ENOENT );
340 TEST( "add 2 eok", dyn_fifo_push( & fifo, 2, 1 ), EOK );
341 TEST( "add 3 enomem", dyn_fifo_push( & fifo, 3, 1 ), ENOMEM );
342 TEST( "add 3 eok", dyn_fifo_push( & fifo, 3, 0 ), EOK );
343 TEST( "pop 2", dyn_fifo_pop( & fifo ), 2 );
344 TEST( "pop 3", dyn_fifo_pop( & fifo ), 3 );
345 TEST( "add 4 eok", dyn_fifo_push( & fifo, 4, 2 ), EOK );
346 TEST( "add 5 eok", dyn_fifo_push( & fifo, 5, 2 ), EOK );
347 TEST( "add 6 enomem", dyn_fifo_push( & fifo, 6, 2 ), ENOMEM );
348 TEST( "add 6 eok", dyn_fifo_push( & fifo, 6, 5 ), EOK );
349 TEST( "add 7 eok", dyn_fifo_push( & fifo, 7, 5 ), EOK );
350 TEST( "pop 4", dyn_fifo_pop( & fifo ), 4 );
351 TEST( "pop 5", dyn_fifo_pop( & fifo ), 5 );
352 TEST( "add 8 eok", dyn_fifo_push( & fifo, 8, 5 ), EOK );
353 TEST( "add 9 eok", dyn_fifo_push( & fifo, 9, 5 ), EOK );
354 TEST( "add 10 eok", dyn_fifo_push( & fifo, 10, 6 ), EOK );
355 TEST( "add 11 eok", dyn_fifo_push( & fifo, 11, 6 ), EOK );
356 TEST( "pop 6", dyn_fifo_pop( & fifo ), 6 );
357 TEST( "pop 7", dyn_fifo_pop( & fifo ), 7 );
358 TEST( "add 12 eok", dyn_fifo_push( & fifo, 12, 6 ), EOK );
359 TEST( "add 13 eok", dyn_fifo_push( & fifo, 13, 6 ), EOK );
360 TEST( "add 14 enomem", dyn_fifo_push( & fifo, 14, 6 ), ENOMEM );
361 TEST( "add 14 eok", dyn_fifo_push( & fifo, 14, 8 ), EOK );
362 TEST( "pop 8", dyn_fifo_pop( & fifo ), 8 );
363 TEST( "pop 9", dyn_fifo_pop( & fifo ), 9 );
364 TEST( "pop 10", dyn_fifo_pop( & fifo ), 10 );
365 TEST( "pop 11", dyn_fifo_pop( & fifo ), 11 );
366 TEST( "pop 12", dyn_fifo_pop( & fifo ), 12 );
367 TEST( "pop 13", dyn_fifo_pop( & fifo ), 13 );
368 TEST( "pop 14", dyn_fifo_pop( & fifo ), 14 );
369 TEST( "destroy", dyn_fifo_destroy( & fifo ), EOK );
370 TEST( "add 15 einval", dyn_fifo_push( & fifo, 1, 0 ), EINVAL );
371 if( error ) return EINVAL;
372
373#endif
374
375 return EOK;
376}
377
378#endif
379
380/** @}
381 */
Note: See TracBrowser for help on using the repository browser.