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