Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Don't use %t in log format, but %P; revalidate the output after listener introduction
[simgrid.git] / src / dynar_unit.c
1 /*******************************/
2 /* GENERATED FILE, DO NOT EDIT */
3 /*******************************/
4
5 #include <stdio.h>
6 #include "xbt.h"
7 /*******************************/
8 /* GENERATED FILE, DO NOT EDIT */
9 /*******************************/
10
11 # 719 "xbt/dynar.c" 
12
13 #define NB_ELEM 5000
14
15 XBT_LOG_EXTERNAL_CATEGORY(xbt_dyn);
16 XBT_LOG_DEFAULT_CATEGORY(xbt_dyn);
17
18 XBT_TEST_UNIT("int",test_dynar_int,"Dynars of integers") {
19    /* Vars_decl [doxygen cruft] */
20    xbt_dynar_t d;
21    int i,cpt,cursor;
22    int *iptr;
23    
24    xbt_test_add0("==== Traverse the empty dynar");
25    d=xbt_dynar_new(sizeof(int),NULL);
26    xbt_dynar_foreach(d,cursor,i){
27      xbt_assert0(0,"Damnit, there is something in the empty dynar");
28    }
29    xbt_dynar_free(&d);
30    xbt_dynar_free(&d);
31
32    xbt_test_add1("==== Push %d int, set them again 3 times, traverse them, shift them",
33         NB_ELEM);
34    /* Populate_ints [doxygen cruft] */
35    /* 1. Populate the dynar */
36    d=xbt_dynar_new(sizeof(int),NULL);
37    for (cpt=0; cpt< NB_ELEM; cpt++) {
38      xbt_dynar_push_as(d,int,cpt); /* This is faster (and possible only with scalars) */
39      /* xbt_dynar_push(d,&cpt);       This would also work */
40      xbt_test_log2("Push %d, length=%lu",cpt, xbt_dynar_length(d));
41    }
42    
43    /* 2. Traverse manually the dynar */
44    for (cursor=0; cursor< NB_ELEM; cursor++) {
45      iptr=xbt_dynar_get_ptr(d,cursor);
46      xbt_test_assert2(cursor == *iptr,
47                       "The retrieved value is not the same than the injected one (%d!=%d)",
48                       cursor,cpt);
49    }
50    
51    /* 3. Traverse the dynar using the neat macro to that extend */
52    xbt_dynar_foreach(d,cursor,cpt){
53      xbt_test_assert2(cursor == cpt,
54                       "The retrieved value is not the same than the injected one (%d!=%d)",
55                       cursor,cpt);
56    }
57    /* end_of_traversal */
58    
59    for (cpt=0; cpt< NB_ELEM; cpt++)
60      *(int*)xbt_dynar_get_ptr(d,cpt) = cpt;
61
62    for (cpt=0; cpt< NB_ELEM; cpt++) 
63      *(int*)xbt_dynar_get_ptr(d,cpt) = cpt;
64 /*     xbt_dynar_set(d,cpt,&cpt);*/
65    
66    for (cpt=0; cpt< NB_ELEM; cpt++) 
67      *(int*)xbt_dynar_get_ptr(d,cpt) = cpt;
68    
69    cpt=0;
70    xbt_dynar_foreach(d,cursor,i){
71      xbt_test_assert2(i == cpt,
72                       "The retrieved value is not the same than the injected one (%d!=%d)",
73                       i,cpt);
74      cpt++;
75    }
76    xbt_test_assert2(cpt == NB_ELEM,
77                     "Cannot retrieve my %d values. Last got one is %d",
78                     NB_ELEM, cpt);
79
80    /* shifting [doxygen cruft] */
81    /* 4. Shift all the values */
82    for (cpt=0; cpt< NB_ELEM; cpt++) {
83      xbt_dynar_shift(d,&i);
84      xbt_test_assert2(i == cpt,
85                       "The retrieved value is not the same than the injected one (%d!=%d)",
86                       i,cpt);
87      xbt_test_log2("Pop %d, length=%lu",cpt, xbt_dynar_length(d));
88    }
89    
90    /* 5. Free the resources */
91    xbt_dynar_free(&d);
92    xbt_dynar_free(&d);
93
94    
95    xbt_test_add1("==== Unshift/pop %d int",NB_ELEM);
96    d=xbt_dynar_new(sizeof(int),NULL);
97    for (cpt=0; cpt< NB_ELEM; cpt++) {
98      xbt_dynar_unshift(d,&cpt);
99      DEBUG2("Push %d, length=%lu",cpt, xbt_dynar_length(d));
100    }
101    for (cpt=0; cpt< NB_ELEM; cpt++) {
102      i=xbt_dynar_pop_as(d,int);
103      xbt_test_assert2(i == cpt,
104                       "The retrieved value is not the same than the injected one (%d!=%d)",
105                       i,cpt);
106      xbt_test_log2("Pop %d, length=%lu",cpt, xbt_dynar_length(d));
107    }
108    xbt_dynar_free(&d);
109    xbt_dynar_free(&d);
110
111    
112    xbt_test_add1("==== Push %d int, insert 1000 int in the middle, shift everything",NB_ELEM);
113    d=xbt_dynar_new(sizeof(int),NULL);
114    for (cpt=0; cpt< NB_ELEM; cpt++) {
115      xbt_dynar_push_as(d,int,cpt);
116      DEBUG2("Push %d, length=%lu",cpt, xbt_dynar_length(d));
117    }
118    for (cpt=0; cpt< 1000; cpt++) {
119      xbt_dynar_insert_at_as(d,2500,int,cpt);
120      DEBUG2("Push %d, length=%lu",cpt, xbt_dynar_length(d));
121    }
122
123    for (cpt=0; cpt< 2500; cpt++) {
124      xbt_dynar_shift(d,&i);
125      xbt_test_assert2(i == cpt,
126              "The retrieved value is not the same than the injected one at the begining (%d!=%d)",
127                i,cpt);
128      DEBUG2("Pop %d, length=%lu",cpt, xbt_dynar_length(d));
129    }
130    for (cpt=999; cpt>=0; cpt--) {
131      xbt_dynar_shift(d,&i);
132      xbt_test_assert2(i == cpt,
133            "The retrieved value is not the same than the injected one in the middle (%d!=%d)",
134                       i,cpt);
135    }
136    for (cpt=2500; cpt< NB_ELEM; cpt++) {
137      xbt_dynar_shift(d,&i);
138       xbt_test_assert2(i == cpt,
139            "The retrieved value is not the same than the injected one at the end (%d!=%d)",
140                        i,cpt);
141    }
142    xbt_dynar_free(&d);
143    xbt_dynar_free(&d);
144
145
146    xbt_test_add1("==== Push %d int, remove 2000-4000. free the rest",NB_ELEM);
147    d=xbt_dynar_new(sizeof(int),NULL);
148    for (cpt=0; cpt< NB_ELEM; cpt++) 
149      xbt_dynar_push_as(d,int,cpt);
150    
151    for (cpt=2000; cpt< 4000; cpt++) {
152      xbt_dynar_remove_at(d,2000,&i);
153      xbt_test_assert2(i == cpt,
154                       "Remove a bad value. Got %d, expected %d",
155                       i,cpt);
156      DEBUG2("remove %d, length=%lu",cpt, xbt_dynar_length(d));
157    }
158    xbt_dynar_free(&d);
159    xbt_dynar_free(&d);
160 }
161 /*******************************************************************************/
162 /*******************************************************************************/
163 /*******************************************************************************/
164 XBT_TEST_UNIT("double",test_dynar_double,"Dynars of doubles") {
165    xbt_dynar_t d;
166    int cpt,cursor;
167    double d1,d2;
168    
169    xbt_test_add0("==== Traverse the empty dynar");
170    d=xbt_dynar_new(sizeof(int),NULL);
171    xbt_dynar_foreach(d,cursor,cpt){
172      xbt_test_assert0(FALSE,
173              "Damnit, there is something in the empty dynar");
174    }
175    xbt_dynar_free(&d);
176    xbt_dynar_free(&d);
177
178    xbt_test_add0("==== Push/shift 5000 doubles");
179    d=xbt_dynar_new(sizeof(double),NULL);
180    for (cpt=0; cpt< 5000; cpt++) {
181      d1=(double)cpt;
182      xbt_dynar_push(d,&d1);
183    }
184    xbt_dynar_foreach(d,cursor,d2){
185      d1=(double)cursor;
186      xbt_test_assert2(d1 == d2,
187            "The retrieved value is not the same than the injected one (%f!=%f)",
188                   d1,d2);
189    }
190    for (cpt=0; cpt< 5000; cpt++) {
191      d1=(double)cpt;
192      xbt_dynar_shift(d,&d2);
193      xbt_test_assert2(d1 == d2,
194            "The retrieved value is not the same than the injected one (%f!=%f)",
195                   d1,d2);
196    }
197    xbt_dynar_free(&d);
198    xbt_dynar_free(&d);
199
200
201    xbt_test_add0("==== Unshift/pop 5000 doubles");
202    d=xbt_dynar_new(sizeof(double),NULL);
203    for (cpt=0; cpt< 5000; cpt++) {
204      d1=(double)cpt;
205      xbt_dynar_unshift(d,&d1);
206    }
207    for (cpt=0; cpt< 5000; cpt++) {
208      d1=(double)cpt;
209      xbt_dynar_pop(d,&d2);
210      xbt_test_assert2 (d1 == d2,
211            "The retrieved value is not the same than the injected one (%f!=%f)",
212                    d1,d2);
213    }
214    xbt_dynar_free(&d);
215    xbt_dynar_free(&d);
216
217
218
219    xbt_test_add0("==== Push 5000 doubles, insert 1000 doubles in the middle, shift everything");
220    d=xbt_dynar_new(sizeof(double),NULL);
221    for (cpt=0; cpt< 5000; cpt++) {
222      d1=(double)cpt;
223      xbt_dynar_push(d,&d1);
224    }
225    for (cpt=0; cpt< 1000; cpt++) {
226      d1=(double)cpt;
227      xbt_dynar_insert_at(d,2500,&d1);
228    }
229
230    for (cpt=0; cpt< 2500; cpt++) {
231      d1=(double)cpt;
232      xbt_dynar_shift(d,&d2);
233      xbt_test_assert2(d1 == d2,
234            "The retrieved value is not the same than the injected one at the begining (%f!=%f)",
235                   d1,d2);
236      DEBUG2("Pop %d, length=%lu",cpt, xbt_dynar_length(d));
237    }
238    for (cpt=999; cpt>=0; cpt--) {
239      d1=(double)cpt;
240      xbt_dynar_shift(d,&d2);
241      xbt_test_assert2 (d1 == d2,
242            "The retrieved value is not the same than the injected one in the middle (%f!=%f)",
243                    d1,d2);
244    }
245    for (cpt=2500; cpt< 5000; cpt++) {
246      d1=(double)cpt;
247      xbt_dynar_shift(d,&d2);
248      xbt_test_assert2 (d1 == d2,
249            "The retrieved value is not the same than the injected one at the end (%f!=%f)",
250                    d1,d2);
251    }
252    xbt_dynar_free(&d);
253    xbt_dynar_free(&d);
254
255
256    xbt_test_add0("==== Push 5000 double, remove 2000-4000. free the rest");
257    d=xbt_dynar_new(sizeof(double),NULL);
258    for (cpt=0; cpt< 5000; cpt++) {
259      d1=(double)cpt;
260      xbt_dynar_push(d,&d1);
261    }
262    for (cpt=2000; cpt< 4000; cpt++) {
263      d1=(double)cpt;
264      xbt_dynar_remove_at(d,2000,&d2);
265      xbt_test_assert2 (d1 == d2,
266            "Remove a bad value. Got %f, expected %f",
267                d2,d1);
268    }
269    xbt_dynar_free(&d);
270    xbt_dynar_free(&d);
271 }
272
273
274 /* doxygen_string_cruft */
275
276 /* The function we will use to free the data */
277 static void free_string(void *d){
278   free(*(void**)d);
279 }
280
281 /*******************************************************************************/
282 /*******************************************************************************/
283 /*******************************************************************************/
284 XBT_TEST_UNIT("string",test_dynar_string,"Dyars of strings") {
285    xbt_dynar_t d;
286    int cpt;
287    char buf[1024];
288    char *s1,*s2;
289    
290    xbt_test_add0("==== Traverse the empty dynar");
291    d=xbt_dynar_new(sizeof(char *),&free_string);
292    xbt_dynar_foreach(d,cpt,s1){
293      xbt_test_assert0(FALSE,
294                   "Damnit, there is something in the empty dynar");
295    }
296    xbt_dynar_free(&d);
297    xbt_dynar_free(&d);
298
299    xbt_test_add1("==== Push %d strings, set them again 3 times, shift them",NB_ELEM);
300    /* Populate_str [doxygen cruft] */
301    d=xbt_dynar_new(sizeof(char*),&free_string);
302    /* 1. Populate the dynar */
303    for (cpt=0; cpt< NB_ELEM; cpt++) {
304      sprintf(buf,"%d",cpt);
305      s1=strdup(buf);
306      xbt_dynar_push(d,&s1);
307    }
308    for (cpt=0; cpt< NB_ELEM; cpt++) {
309      sprintf(buf,"%d",cpt);
310      s1=strdup(buf);
311      xbt_dynar_replace(d,cpt,&s1);
312    }
313    for (cpt=0; cpt< NB_ELEM; cpt++) {
314      sprintf(buf,"%d",cpt);
315      s1=strdup(buf);
316      xbt_dynar_replace(d,cpt,&s1);
317    }
318    for (cpt=0; cpt< NB_ELEM; cpt++) {
319      sprintf(buf,"%d",cpt);
320      s1=strdup(buf);
321      xbt_dynar_replace(d,cpt,&s1);
322    }
323    for (cpt=0; cpt< NB_ELEM; cpt++) {
324      sprintf(buf,"%d",cpt);
325      xbt_dynar_shift(d,&s2);
326      xbt_test_assert2 (!strcmp(buf,s2),
327             "The retrieved value is not the same than the injected one (%s!=%s)",
328                    buf,s2);
329      free(s2);
330    }
331    xbt_dynar_free(&d);
332    xbt_dynar_free(&d);
333
334
335    xbt_test_add1("==== Unshift, traverse and pop %d strings",NB_ELEM);
336    d=xbt_dynar_new(sizeof(char**),&free_string);
337    for (cpt=0; cpt< NB_ELEM; cpt++) {
338      sprintf(buf,"%d",cpt);
339      s1=strdup(buf);
340      xbt_dynar_unshift(d,&s1);
341    }
342    /* 2. Traverse the dynar with the macro */
343    xbt_dynar_foreach(d,cpt,s1) {
344      sprintf(buf,"%d",NB_ELEM - cpt -1);
345      xbt_test_assert2 (!strcmp(buf,s1),
346            "The retrieved value is not the same than the injected one (%s!=%s)",
347                buf,s1);
348    }
349    /* 3. Traverse the dynar with the macro */
350    for (cpt=0; cpt< NB_ELEM; cpt++) {
351      sprintf(buf,"%d",cpt);
352      xbt_dynar_pop(d,&s2);
353      xbt_test_assert2 (!strcmp(buf,s2),
354            "The retrieved value is not the same than the injected one (%s!=%s)",
355                buf,s2);
356      free(s2);
357    }
358    /* 4. Free the resources */
359    xbt_dynar_free(&d);
360    xbt_dynar_free(&d);
361
362
363    xbt_test_add2("==== Push %d strings, insert %d strings in the middle, shift everything",NB_ELEM,NB_ELEM/5);
364    d=xbt_dynar_new(sizeof(char*),&free_string);
365    for (cpt=0; cpt< NB_ELEM; cpt++) {
366      sprintf(buf,"%d",cpt);
367      s1=strdup(buf);
368      xbt_dynar_push(d,&s1);
369    }
370    for (cpt=0; cpt< NB_ELEM/5; cpt++) {
371      sprintf(buf,"%d",cpt);
372      s1=strdup(buf);
373      xbt_dynar_insert_at(d,NB_ELEM/2,&s1);
374    }
375
376    for (cpt=0; cpt< NB_ELEM/2; cpt++) {
377      sprintf(buf,"%d",cpt);
378      xbt_dynar_shift(d,&s2);
379      xbt_test_assert2(!strcmp(buf,s2),
380            "The retrieved value is not the same than the injected one at the begining (%s!=%s)",
381                buf,s2);
382       free(s2);
383    }
384    for (cpt=(NB_ELEM/5)-1; cpt>=0; cpt--) {
385      sprintf(buf,"%d",cpt);
386      xbt_dynar_shift(d,&s2);
387      xbt_test_assert2 (!strcmp(buf,s2),
388            "The retrieved value is not the same than the injected one in the middle (%s!=%s)",
389                buf,s2);
390      free(s2);
391    }
392    for (cpt=NB_ELEM/2; cpt< NB_ELEM; cpt++) {
393      sprintf(buf,"%d",cpt);
394      xbt_dynar_shift(d,&s2);
395      xbt_test_assert2 (!strcmp(buf,s2),
396            "The retrieved value is not the same than the injected one at the end (%s!=%s)",
397                buf,s2);
398      free(s2);
399    }
400    xbt_dynar_free(&d);
401    xbt_dynar_free(&d);
402
403
404    xbt_test_add3("==== Push %d strings, remove %d-%d. free the rest",NB_ELEM,2*(NB_ELEM/5),4*(NB_ELEM/5));
405    d=xbt_dynar_new(sizeof(char*),&free_string);
406    for (cpt=0; cpt< NB_ELEM; cpt++) {
407      sprintf(buf,"%d",cpt);
408      s1=strdup(buf);
409      xbt_dynar_push(d,&s1);
410    }
411    for (cpt=2*(NB_ELEM/5); cpt< 4*(NB_ELEM/5); cpt++) {
412      sprintf(buf,"%d",cpt);
413      xbt_dynar_remove_at(d,2*(NB_ELEM/5),&s2);
414      xbt_test_assert2(!strcmp(buf,s2),
415                   "Remove a bad value. Got %s, expected %s",
416                   s2,buf);
417       free(s2);
418    }
419    xbt_dynar_free(&d); /* end_of_doxygen */
420 }
421
422
423 /*******************************************************************************/
424 /*******************************************************************************/
425 /*******************************************************************************/
426 #include "xbt/synchro.h"
427 static void pusher_f(void *a) {
428    xbt_dynar_t d=(xbt_dynar_t)a;
429    int i;
430    for (i=0; i<500; i++) {
431       xbt_dynar_push(d,&i);
432    }
433 }
434 static void poper_f(void *a) {
435    xbt_dynar_t d=(xbt_dynar_t)a;
436    int i;
437    int data;
438    xbt_ex_t e;
439    
440    for (i=0; i<500; i++) {
441       TRY {      
442          xbt_dynar_pop(d,&data);
443       } CATCH(e) {
444          if (e.category == bound_error) {
445             xbt_ex_free(e);
446             i--;
447          } else {
448             RETHROW;
449          }
450       }
451    }
452 }
453
454    
455 XBT_TEST_UNIT("synchronized int",test_dynar_sync_int,"Synchronized dynars of integers") {
456    /* Vars_decl [doxygen cruft] */
457    xbt_dynar_t d;
458    xbt_thread_t pusher,poper;
459    
460    xbt_test_add0("==== Have a pusher and a popper on the dynar");
461    d=xbt_dynar_new_sync(sizeof(int),NULL);
462    pusher = xbt_thread_create(pusher_f,d);
463    poper = xbt_thread_create(poper_f,d);
464    xbt_thread_join(pusher);
465    xbt_thread_join(poper);
466    xbt_dynar_free(&d);
467 }
468
469 /*******************************/
470 /* GENERATED FILE, DO NOT EDIT */
471 /*******************************/
472