Changeset 858fc90 in mainline for uspace/srv/net/self_test.c


Ignore:
Timestamp:
2010-03-15T19:35:25Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
6092b56e
Parents:
92307f1 (diff), 4684368 (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 bzr://bzr.helenos.org/head.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/self_test.c

    r92307f1 r858fc90  
    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
    71         INT_MAP_DECLARE( int_map, int );
    72 
    73         INT_MAP_IMPLEMENT( int_map, int );
     87        INT_MAP_DECLARE(int_map, int);
     88
     89        INT_MAP_IMPLEMENT(int_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_CHAR_MAP
     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        }
     150
     151#endif
     152
     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        }
    74273
    75274#endif
    76275
    77276#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 
    93 int self_test( void ){
    94         int error = 0;
    95         int * x, * y, * z, * u, * v, * w;
     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
     329#if NET_SELF_TEST_INT_MAP
     330        int_map_t im;
     331
     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));
     338
     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);
     374        printf("\n\tdestroy");
     375        int_map_destroy(&im);
     376        TEST("count -1", int_map_count(&im), -1);
     377        printf("\nOK");
     378
     379        if(error){
     380                return EINVAL;
     381        }
     382
     383#endif
    96384
    97385#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 
     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);
     391        printf("\nOK");
    373392#endif
    374393
Note: See TracChangeset for help on using the changeset viewer.