Changeset 60ab6c3 in mainline for uspace/srv/net/self_test.c


Ignore:
Timestamp:
2010-03-10T05:46:54Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
5782081
Parents:
71b00dcc (diff), b48ebd19 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge from lp:~lukasmejdrech/helenos/network.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/self_test.c

    r71b00dcc r60ab6c3  
    5757 *  @param[in] result The expected result.
    5858 */
    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         }                                                                                               \
     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        }                                                                                                                                               \
    6767}
    6868
     69#if NET_SELF_TEST_GENERIC_CHAR_MAP
     70
     71        GENERIC_CHAR_MAP_DECLARE(int_char_map, int)
     72
     73        GENERIC_CHAR_MAP_IMPLEMENT(int_char_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
    6985#if NET_SELF_TEST_INT_MAP
    7086
    … …  
    7288
    7389        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)
    9090
    9191#endif
    … …  
    101101
    102102        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
    112103
    113104#if NET_SELF_TEST_CHAR_MAP
    … …  
    160151#endif
    161152
     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;
     233
     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));
     240
     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);
     265        printf("\n\tdestroy");
     266        int_char_map_destroy(&icm);
     267        TEST("add ucho z einval", int_char_map_add(&icm, "ucho", 0, z), EINVAL);
     268        printf("\nOK");
     269
     270        if(error){
     271                return EINVAL;
     272        }
     273
     274#endif
     275
     276#if NET_SELF_TEST_GENERIC_FIELD
     277        int_field_t gf;
     278
     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));
     285
     286        gf.magic = 0;
     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        }
     326
     327#endif
     328
    162329#if NET_SELF_TEST_INT_MAP
    163330        int_map_t im;
    … …  
    216383#endif
    217384
    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);
     385#if NET_SELF_TEST_MEASURED_STRINGS
     386        measured_string_ref string;
     387
     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);
    263391        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 
    392392#endif
    393393
Note: See TracChangeset for help on using the changeset viewer.