Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/srv/net/self_test.c

    ra64c64d raadf01e  
    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_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
    6985#if NET_SELF_TEST_GENERIC_CHAR_MAP
    7086
     
    7288
    7389        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 
    85 #if NET_SELF_TEST_INT_MAP
    86 
    87         INT_MAP_DECLARE(int_map, int);
    88 
    89         INT_MAP_IMPLEMENT(int_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
    103112
    104113#if NET_SELF_TEST_CHAR_MAP
     
    151160#endif
    152161
    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 
    329162#if NET_SELF_TEST_INT_MAP
    330163        int_map_t im;
     
    383216#endif
    384217
    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);
     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);
    391263        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.