tests/vectortests.c

   1 /**
   2  * A sequence of tests of the vector.h functions.
   3  */
   4
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include <vector.h>
   8
   9 #define OUT(...) fprintf( stderr, __VA_ARGS__ )
  10
  11 // dump an item; return 0 to stop
  12 static void itemdump(const vector_index index,const void *slot) {
  13     if ( slot ) {
  14         OUT ( "[%ld] %s\n", index, (const char*) slot );
  15     }
  16 }
  17
  18 // pretend-reclaim item and return data (as int)
  19 static int itemreclaim(vector *pv,vector_index index,void *item,void *data) {
  20     int r = data? 1 : 0;
  21     OUT( "reclaim [%ld] (%p) => %d\n", index, item, r );
  22     return r;
  23 }
  24
  25 // Compare two items strings, or nulls
  26 static int itemcmp(const void *a,const void *b) {
  27     return a? ( b? strcmp( (char*)b, (char*)a ) : 1 ) : ( b? -1 : 0 );
  28 }
  29
  30 // Iterator function
  31 static int itemiter(vector_index index,void *item,void *data) {
  32     char *s = "";
  33     if ( item ) {
  34         s = (char*) item;
  35     }
  36     OUT( "[%ld] %p %s\n", index, item, s );
  37     return ( index < 12 ) == 0;
  38 }
  39
  40 // check if item before, at or after the key
  41 int itemfind(const void *key, const void *item) {
  42     char *a = (char*) key;
  43     size_t an = a? strlen( a ) : 0;
  44     char *b = (char*) item;
  45     size_t bn = b? strlen( b ) : 0;
  46     OUT( "itemfind %p \"%s\" %p \"%s\"\n",
  47          a, a? a : "(null)", b, b? b : "(null)" );
  48     return strncmp( a, b, (an<bn)? an : bn );
  49 }
  50
  51 // Dump a vector with a header line
  52 static void my_vector_dump(
  53     vector *vp,
  54     void (*itemdump)(const vector_index index,const void *slot) )
  55 {
  56     OUT( "vector %p has %ld slots\n", vp, vector_size(vp) );
  57     vector_dump( vp, itemdump );
  58 }
  59
  60 static char *item25 = "this is first item";
  61 static char *item75 = "this is second item";
  62
  63 int main(int argc,char **argv) {
  64     int variant = 0;
  65     for ( ; variant < 4; variant++ ) {
  66         OUT( "variant = %d ========================\n", variant );
  67         vector v = { variant, 100, 0 }; // Create an empty vector of 100 slots.
  68
  69         //OUT( "VECTOR_LEVEL_BITS = %d\n", VECTOR_LEVEL_BITS );
  70         //OUT( "sizeof( vector_index ) = %ld\n", sizeof( vector_index ) );
  71         //OUT( "VECTOR_INDEX_BITS - %ld\n", VECTOR_INDEX_BITS );
  72         //OUT( "VECTOR_INDEX_FIELDS = %ld\n", VECTOR_INDEX_FIELDS );
  73         OUT( "VECTOR_SLOTS = %ld\n", VECTOR_SLOTS( &v ) );
  74         // OUT( "sizeof( vector_page ) = %ld\n", sizeof( vector_page ) );
  75         OUT( "sizeof( vector ) = %ld\n", sizeof( vector ) );
  76
  77         void ** slot;
  78         void *item;
  79         int i;
  80
  81         OUT( "vector v has 100 empty slots\n" );
  82
  83         // void vector_dump(vector *pv,
  84         //        int (*itemdump)(const vector_index ,const void *));
  85         // void **vector_next_used(vector *pv,vector_index *index);
  86         my_vector_dump( &v, itemdump );
  87
  88         //void vector_set(vector *pv,vector_index index,void *value);
  89         item = item25;
  90         vector_set( &v, 25, item );
  91         OUT( "assigned 25 to %p %s\n", item, (char*)item );
  92
  93         // void **vector_prev_used(vector *pv,vector_index *index);
  94         int t0[6] = { 0, 25, 50, 99, 100, 1000 };
  95         OUT( "vector_next_used:\n" );
  96         for ( i = 0; i < 6; i++ ) {
  97             vector_index index = t0[i];
  98             slot = vector_next_used( &v, &index );
  99             OUT( " [%d] => [%ld] %p\n", t0[i], index, slot? *slot : 0 );
 100         }
 101
 102         OUT( "vector_prev_used:\n" );
 103         for ( i = 0; i < 6; i++ ) {
 104             vector_index index = t0[i];
 105             slot = vector_prev_used( &v, &index );
 106             OUT( " [%d] => [%ld] %p\n", t0[i], index, slot? *slot : 0 );
 107         }
 108
 109         item = item75;
 110         vector_set( &v, 75, item );
 111         OUT( "assigned 75 to %p %s\n", item, (char*)item );
 112
 113         my_vector_dump( &v, itemdump );
 114
 115         OUT( "vector_next_used:\n" );
 116         for ( i = 0; i < 6; i++ ) {
 117             vector_index index = t0[i];
 118             slot = vector_next_used( &v, &index );
 119             OUT( " [%d] => [%ld] %p\n", t0[i], index, slot? *slot : 0 );
 120         }
 121
 122         OUT( "vector_prev_used:\n" );
 123         for ( i = 0; i < 6; i++ ) {
 124             vector_index index = t0[i];
 125             slot = vector_prev_used( &v, &index );
 126             OUT( " [%d] => [%ld] %p\n", t0[i], index, slot? *slot : 0 );
 127         }
 128
 129         OUT( "shrinking the vector:\n" );
 130         // int vector_resize(
 131         //     vector *pv, vector_index new_size,
 132         //     int (*reclaim)(vector *pv,vector_index index,
 133         //                    void *item, void *data),
 134         //     void *data );
 135         i = vector_resize( &v, 50, itemreclaim, (void*)1 );
 136         OUT( "shrink to 50 (reclaim refused) = %d\n", i );
 137
 138
 139         i = vector_resize( &v, 50, itemreclaim, (void*)0 );
 140         OUT( "shrink to 50 (accept reclaim) = %d\n", i );
 141
 142         i = vector_resize( &v, 508, 0, 0 );
 143         OUT( "grow to 508 (no reclaim) = %d\n", i );
 144
 145         // void **vector_entry(vector *pv,vector_index index);
 146 #define SLOTSTR(slot) (slot? ((*slot)? *slot : "(nil)") : "(unassigned)" )
 147         slot = vector_entry( &v, 24 );
 148         itemdump( 24, SLOTSTR(slot) );
 149
 150         slot = vector_entry( &v, 25 );
 151         itemdump( 25, SLOTSTR(slot) );
 152
 153         slot = vector_entry( &v, 300 );
 154         itemdump( 300, SLOTSTR( slot ) );
 155
 156         //#define vector_size(pv) ((vector_index) (pv)->size)
 157         OUT( "vector size: %ld\n", vector_size( &v ) );
 158
 159         // void *vector_get(vector *pv,vector_index index);
 160         // void *vector_get_set(vector *pv,vector_index index,void *value);
 161         item = vector_get( &v, 25 );
 162         OUT( "old item 25 is %p %s\n", item, (char*)item );
 163         item = "another value";
 164         OUT( "new item 25 is %p %s\n", item, (char*)item );
 165         item = vector_get_set( &v, 25, item );
 166         OUT( "got item 25 as %p %s\n", item, (char*)item );
 167         item = vector_get( &v, 25 );
 168         OUT( "now item 25 is %p %s\n", item, (char*)item );
 169
 170         // void vector_append(vector *pv,void *value);
 171         item = "the very last item";
 172         OUT( "appending %p %s\n", item, (char*)item );
 173         vector_append( &v, item );
 174
 175         OUT( "vector size: %ld\n", vector_size( &v ) );
 176         my_vector_dump( &v, itemdump );
 177
 178         vector v2 = { variant, 200, 0 };
 179         // void vector_copy(
 180         //        vector *dst,vector_index di,
 181         //        vector *src,vector_index si,
 182         //        vector_index n);
 183         vector_copy( &v2, 20, &v, 10, 20 );
 184         my_vector_dump( &v2, itemdump );
 185
 186         vector_resize( &v2, 0, itemreclaim, 0 ); // Reset vector v2
 187         my_vector_dump( &v2, itemdump );
 188
 189         vector_append( &v2, "9 the very last item" );
 190         vector_append( &v2, "3 the very last item" );
 191         vector_append( &v2, "4 the very last item" );
 192         vector_append( &v2, "6 the very last item" );
 193         vector_append( &v2, "5 the very last item" );
 194         vector_resize( &v2, vector_size( &v2 ) + 3, 0, 0 );
 195         vector_append( &v2, "2 the very last item" );
 196         vector_append( &v2, "8 the very last item" );
 197         vector_append( &v2, "1 the very last item" );
 198         vector_append( &v2, 0 );
 199         vector_append( &v2, "7 the very last item" );
 200         vector_append( &v2, "0 the very last item" );
 201         my_vector_dump( &v2, itemdump );
 202
 203         // void vector_qsort(vector*,int (*compar)(const void *,const void *));
 204         OUT( "sorted:" );
 205         vector_qsort( &v2, itemcmp );
 206         my_vector_dump( &v2, itemdump );
 207
 208         // void vector_iterate(vector *pv,
 209         //          vector_index start,
 210         //          int (*itemfn)(vector_index,void *item,void *data),
 211         //          void *data);
 212         OUT( "showing all slots\n" );
 213         vector_iterate( &v2, 4, itemiter, 0 );
 214
 215         // void *vector_bsearch(vector *pv,vector_index *index,const void *key,
 216         //           int (*compare)(const void *key, const void *item));
 217         char *pfx[5] = { "4", "9", "0", "3", "10" };
 218         for ( i = 0; i < ( sizeof( pfx ) / sizeof( char* ) ); i++ ) {
 219             char *prefix = pfx[i];
 220             vector_index index = 0;
 221             OUT( "lookup prefix \"%s\":\n", prefix );
 222             item = vector_bsearch( &v2, &index, prefix, itemfind );
 223             OUT( "[%ld] %p %s\n", index, item,
 224                  ( item? (char*)item : "(null)" ) );
 225         }
 226
 227         // Clear out the vectors
 228         (void) vector_resize( &v, 0, itemreclaim, (void*)0 );
 229         (void) vector_resize( &v2, 0, itemreclaim, (void*)0 );
 230     }
 231     return 0;
 232 }