Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Fix compilation warnings in the dynar test
[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 #line 753 "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 {
20   /* Vars_decl [doxygen cruft] */
21   xbt_dynar_t d;
22   int i, cpt;
23   unsigned int cursor;
24   int *iptr;
25
26   xbt_test_add0("==== Traverse the empty dynar");
27   d = xbt_dynar_new(sizeof(int), NULL);
28   xbt_dynar_foreach(d, cursor, i) {
29     xbt_assert0(0, "Damnit, there is something in the empty dynar");
30   }
31   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
32   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
33   /* in your code is naturally the way to go outside a regression test */
34
35   xbt_test_add1
36       ("==== Push %d int, set them again 3 times, traverse them, shift them",
37        NB_ELEM);
38   /* Populate_ints [doxygen cruft] */
39   /* 1. Populate the dynar */
40   d = xbt_dynar_new(sizeof(int), NULL);
41   for (cpt = 0; cpt < NB_ELEM; cpt++) {
42     xbt_dynar_push_as(d, int, cpt);     /* This is faster (and possible only with scalars) */
43     /* xbt_dynar_push(d,&cpt);       This would also work */
44     xbt_test_log2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
45   }
46
47   /* 2. Traverse manually the dynar */
48   for (cursor = 0; cursor < NB_ELEM; cursor++) {
49     iptr = xbt_dynar_get_ptr(d, cursor);
50     xbt_test_assert2(cursor == *iptr,
51                      "The retrieved value is not the same than the injected one (%d!=%d)",
52                      cursor, cpt);
53   }
54
55   /* 3. Traverse the dynar using the neat macro to that extend */
56   xbt_dynar_foreach(d, cursor, cpt) {
57     xbt_test_assert2(cursor == cpt,
58                      "The retrieved value is not the same than the injected one (%d!=%d)",
59                      cursor, cpt);
60   }
61   /* end_of_traversal */
62
63   for (cpt = 0; cpt < NB_ELEM; cpt++)
64     *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
65
66   for (cpt = 0; cpt < NB_ELEM; cpt++)
67     *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
68   /*     xbt_dynar_set(d,cpt,&cpt); */
69
70   for (cpt = 0; cpt < NB_ELEM; cpt++)
71     *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
72
73   cpt = 0;
74   xbt_dynar_foreach(d, cursor, i) {
75     xbt_test_assert2(i == cpt,
76                      "The retrieved value is not the same than the injected one (%d!=%d)",
77                      i, cpt);
78     cpt++;
79   }
80   xbt_test_assert2(cpt == NB_ELEM,
81                    "Cannot retrieve my %d values. Last got one is %d",
82                    NB_ELEM, cpt);
83
84   /* shifting [doxygen cruft] */
85   /* 4. Shift all the values */
86   for (cpt = 0; cpt < NB_ELEM; cpt++) {
87     xbt_dynar_shift(d, &i);
88     xbt_test_assert2(i == cpt,
89                      "The retrieved value is not the same than the injected one (%d!=%d)",
90                      i, cpt);
91     xbt_test_log2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
92   }
93
94   /* 5. Free the resources */
95   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
96   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
97   /* in your code is naturally the way to go outside a regression test */
98
99   xbt_test_add1("==== Unshift/pop %d int", NB_ELEM);
100   d = xbt_dynar_new(sizeof(int), NULL);
101   for (cpt = 0; cpt < NB_ELEM; cpt++) {
102     xbt_dynar_unshift(d, &cpt);
103     DEBUG2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
104   }
105   for (cpt = 0; cpt < NB_ELEM; cpt++) {
106     i = xbt_dynar_pop_as(d, int);
107     xbt_test_assert2(i == cpt,
108                      "The retrieved value is not the same than the injected one (%d!=%d)",
109                      i, cpt);
110     xbt_test_log2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
111   }
112   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
113   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
114   /* in your code is naturally the way to go outside a regression test */
115
116
117   xbt_test_add1
118       ("==== Push %d int, insert 1000 int in the middle, shift everything",
119        NB_ELEM);
120   d = xbt_dynar_new(sizeof(int), NULL);
121   for (cpt = 0; cpt < NB_ELEM; cpt++) {
122     xbt_dynar_push_as(d, int, cpt);
123     DEBUG2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
124   }
125   for (cpt = 0; cpt < NB_ELEM/5; cpt++) {
126     xbt_dynar_insert_at_as(d, NB_ELEM/2, int, cpt);
127     DEBUG2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
128   }
129
130   for (cpt = 0; cpt < NB_ELEM/2; 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 at the begining (%d!=%d)",
134                      i, cpt);
135     DEBUG2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
136   }
137   for (cpt = 999; cpt >= 0; cpt--) {
138     xbt_dynar_shift(d, &i);
139     xbt_test_assert2(i == cpt,
140                      "The retrieved value is not the same than the injected one in the middle (%d!=%d)",
141                      i, cpt);
142   }
143   for (cpt = 2500; cpt < NB_ELEM; cpt++) {
144     xbt_dynar_shift(d, &i);
145     xbt_test_assert2(i == cpt,
146                      "The retrieved value is not the same than the injected one at the end (%d!=%d)",
147                      i, cpt);
148   }
149   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
150   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
151   /* in your code is naturally the way to go outside a regression test */
152
153   xbt_test_add1("==== Push %d int, remove 2000-4000. free the rest",
154                 NB_ELEM);
155   d = xbt_dynar_new(sizeof(int), NULL);
156   for (cpt = 0; cpt < NB_ELEM; cpt++)
157     xbt_dynar_push_as(d, int, cpt);
158
159   for (cpt = 2000; cpt < 4000; cpt++) {
160     xbt_dynar_remove_at(d, 2000, &i);
161     xbt_test_assert2(i == cpt,
162                      "Remove a bad value. Got %d, expected %d", i, cpt);
163     DEBUG2("remove %d, length=%lu", cpt, xbt_dynar_length(d));
164   }
165   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
166   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
167   /* in your code is naturally the way to go outside a regression test */
168 }
169
170 /*******************************************************************************/
171 /*******************************************************************************/
172 /*******************************************************************************/
173 XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dynar_remove functions")
174 {
175   xbt_dynar_t d = xbt_dynar_new(sizeof(int), NULL);
176   unsigned int cursor,cpt;
177
178   xbt_test_add1("==== Insert %d int, traverse them, remove them",NB_ELEM);
179   /* Populate_ints [doxygen cruft] */
180   /* 1. Populate the dynar */
181   for (cpt = 0; cpt < NB_ELEM; cpt++) {
182     xbt_dynar_insert_at(d, cpt, &cpt);
183     xbt_test_log2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
184   }
185
186   /* 3. Traverse the dynar */
187   xbt_dynar_foreach(d, cursor, cpt) {
188     xbt_test_assert2(cursor == cpt,
189                      "The retrieved value is not the same than the injected one (%d!=%d)",
190                      cursor, cpt);
191   }
192   /* end_of_traversal */
193
194   /* Re-fill with the same values using set_as (and re-verify) */
195   for (cpt = 0; cpt < NB_ELEM; cpt++)
196     xbt_dynar_set_as(d, cpt, int, cpt);
197   xbt_dynar_foreach(d, cursor, cpt)
198     xbt_test_assert2(cursor == cpt,
199                      "The retrieved value is not the same than the injected one (%d!=%d)",
200                      cursor, cpt);
201
202   for (cpt = 0; cpt < NB_ELEM; cpt++) {
203     int val;
204     xbt_dynar_remove_at(d,0,&val);
205     xbt_test_assert2(cpt == val,
206                      "The retrieved value is not the same than the injected one (%d!=%d)",
207                      cursor, cpt);
208   }
209   xbt_test_assert1(xbt_dynar_length(d) == 0,
210                    "There is still %lu elements in the dynar after removing everything",
211                    xbt_dynar_length(d));
212   xbt_dynar_free(&d);
213
214   /* ********************* */
215   xbt_test_add1("==== Insert %d int in reverse order, traverse them, remove them",NB_ELEM);
216   d = xbt_dynar_new(sizeof(int), NULL);
217   for (cpt = NB_ELEM-1; cpt >=0; cpt--) {
218     xbt_dynar_replace(d, cpt, &cpt);
219     xbt_test_log2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
220   }
221
222   /* 3. Traverse the dynar */
223   xbt_dynar_foreach(d, cursor, cpt) {
224     xbt_test_assert2(cursor == cpt,
225                      "The retrieved value is not the same than the injected one (%d!=%d)",
226                      cursor, cpt);
227   }
228   /* end_of_traversal */
229
230   for (cpt =NB_ELEM-1; cpt >=0; cpt--) {
231     int val;
232     xbt_dynar_remove_at(d,xbt_dynar_length(d)-1,&val);
233     xbt_test_assert2(cpt == val,
234                      "The retrieved value is not the same than the injected one (%d!=%d)",
235                      cursor, cpt);
236   }
237   xbt_test_assert1(xbt_dynar_length(d) == 0,
238                    "There is still %lu elements in the dynar after removing everything",
239                    xbt_dynar_length(d));
240   xbt_dynar_free(&d);
241 }
242
243 /*******************************************************************************/
244 /*******************************************************************************/
245 /*******************************************************************************/
246 XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
247 {
248   xbt_dynar_t d;
249   int cpt;
250   unsigned int cursor;
251   double d1, d2;
252
253   xbt_test_add0("==== Traverse the empty dynar");
254   d = xbt_dynar_new(sizeof(int), NULL);
255   xbt_dynar_foreach(d, cursor, cpt) {
256     xbt_test_assert0(FALSE,
257                      "Damnit, there is something in the empty dynar");
258   }
259   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
260   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
261   /* in your code is naturally the way to go outside a regression test */
262
263   xbt_test_add0("==== Push/shift 5000 doubles");
264   d = xbt_dynar_new(sizeof(double), NULL);
265   for (cpt = 0; cpt < 5000; cpt++) {
266     d1 = (double) cpt;
267     xbt_dynar_push(d, &d1);
268   }
269   xbt_dynar_foreach(d, cursor, d2) {
270     d1 = (double) cursor;
271     xbt_test_assert2(d1 == d2,
272                      "The retrieved value is not the same than the injected one (%f!=%f)",
273                      d1, d2);
274   }
275   for (cpt = 0; cpt < 5000; cpt++) {
276     d1 = (double) cpt;
277     xbt_dynar_shift(d, &d2);
278     xbt_test_assert2(d1 == d2,
279                      "The retrieved value is not the same than the injected one (%f!=%f)",
280                      d1, d2);
281   }
282   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
283   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
284   /* in your code is naturally the way to go outside a regression test */
285
286   xbt_test_add0("==== Unshift/pop 5000 doubles");
287   d = xbt_dynar_new(sizeof(double), NULL);
288   for (cpt = 0; cpt < 5000; cpt++) {
289     d1 = (double) cpt;
290     xbt_dynar_unshift(d, &d1);
291   }
292   for (cpt = 0; cpt < 5000; cpt++) {
293     d1 = (double) cpt;
294     xbt_dynar_pop(d, &d2);
295     xbt_test_assert2(d1 == d2,
296                      "The retrieved value is not the same than the injected one (%f!=%f)",
297                      d1, d2);
298   }
299   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
300   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
301   /* in your code is naturally the way to go outside a regression test */
302
303
304
305   xbt_test_add0
306       ("==== Push 5000 doubles, insert 1000 doubles in the middle, shift everything");
307   d = xbt_dynar_new(sizeof(double), NULL);
308   for (cpt = 0; cpt < 5000; cpt++) {
309     d1 = (double) cpt;
310     xbt_dynar_push(d, &d1);
311   }
312   for (cpt = 0; cpt < 1000; cpt++) {
313     d1 = (double) cpt;
314     xbt_dynar_insert_at(d, 2500, &d1);
315   }
316
317   for (cpt = 0; cpt < 2500; cpt++) {
318     d1 = (double) cpt;
319     xbt_dynar_shift(d, &d2);
320     xbt_test_assert2(d1 == d2,
321                      "The retrieved value is not the same than the injected one at the begining (%f!=%f)",
322                      d1, d2);
323     DEBUG2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
324   }
325   for (cpt = 999; cpt >= 0; cpt--) {
326     d1 = (double) cpt;
327     xbt_dynar_shift(d, &d2);
328     xbt_test_assert2(d1 == d2,
329                      "The retrieved value is not the same than the injected one in the middle (%f!=%f)",
330                      d1, d2);
331   }
332   for (cpt = 2500; cpt < 5000; cpt++) {
333     d1 = (double) cpt;
334     xbt_dynar_shift(d, &d2);
335     xbt_test_assert2(d1 == d2,
336                      "The retrieved value is not the same than the injected one at the end (%f!=%f)",
337                      d1, d2);
338   }
339   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
340   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
341   /* in your code is naturally the way to go outside a regression test */
342
343
344   xbt_test_add0("==== Push 5000 double, remove 2000-4000. free the rest");
345   d = xbt_dynar_new(sizeof(double), NULL);
346   for (cpt = 0; cpt < 5000; cpt++) {
347     d1 = (double) cpt;
348     xbt_dynar_push(d, &d1);
349   }
350   for (cpt = 2000; cpt < 4000; cpt++) {
351     d1 = (double) cpt;
352     xbt_dynar_remove_at(d, 2000, &d2);
353     xbt_test_assert2(d1 == d2,
354                      "Remove a bad value. Got %f, expected %f", d2, d1);
355   }
356   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
357   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
358   /* in your code is naturally the way to go outside a regression test */
359 }
360
361
362 /* doxygen_string_cruft */
363
364 /*******************************************************************************/
365 /*******************************************************************************/
366 /*******************************************************************************/
367 XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
368 {
369   xbt_dynar_t d;
370   int cpt;
371   unsigned int iter;
372   char buf[1024];
373   char *s1, *s2;
374
375   xbt_test_add0("==== Traverse the empty dynar");
376   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
377   xbt_dynar_foreach(d, iter, s1) {
378     xbt_test_assert0(FALSE,
379                      "Damnit, there is something in the empty dynar");
380   }
381   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
382   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
383   /* in your code is naturally the way to go outside a regression test */
384
385   xbt_test_add1("==== Push %d strings, set them again 3 times, shift them",
386                 NB_ELEM);
387   /* Populate_str [doxygen cruft] */
388   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
389   /* 1. Populate the dynar */
390   for (cpt = 0; cpt < NB_ELEM; cpt++) {
391     sprintf(buf, "%d", cpt);
392     s1 = strdup(buf);
393     xbt_dynar_push(d, &s1);
394   }
395   for (cpt = 0; cpt < NB_ELEM; cpt++) {
396     sprintf(buf, "%d", cpt);
397     s1 = strdup(buf);
398     xbt_dynar_replace(d, cpt, &s1);
399   }
400   for (cpt = 0; cpt < NB_ELEM; cpt++) {
401     sprintf(buf, "%d", cpt);
402     s1 = strdup(buf);
403     xbt_dynar_replace(d, cpt, &s1);
404   }
405   for (cpt = 0; cpt < NB_ELEM; cpt++) {
406     sprintf(buf, "%d", cpt);
407     s1 = strdup(buf);
408     xbt_dynar_replace(d, cpt, &s1);
409   }
410   for (cpt = 0; cpt < NB_ELEM; cpt++) {
411     sprintf(buf, "%d", cpt);
412     xbt_dynar_shift(d, &s2);
413     xbt_test_assert2(!strcmp(buf, s2),
414                      "The retrieved value is not the same than the injected one (%s!=%s)",
415                      buf, s2);
416     free(s2);
417   }
418   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
419   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
420   /* in your code is naturally the way to go outside a regression test */
421
422   xbt_test_add1("==== Unshift, traverse and pop %d strings", NB_ELEM);
423   d = xbt_dynar_new(sizeof(char **), &xbt_free_ref);
424   for (cpt = 0; cpt < NB_ELEM; cpt++) {
425     sprintf(buf, "%d", cpt);
426     s1 = strdup(buf);
427     xbt_dynar_unshift(d, &s1);
428   }
429   /* 2. Traverse the dynar with the macro */
430   xbt_dynar_foreach(d, iter, s1) {
431     sprintf(buf, "%d", NB_ELEM - iter - 1);
432     xbt_test_assert2(!strcmp(buf, s1),
433                      "The retrieved value is not the same than the injected one (%s!=%s)",
434                      buf, s1);
435   }
436   /* 3. Traverse the dynar with the macro */
437   for (cpt = 0; cpt < NB_ELEM; cpt++) {
438     sprintf(buf, "%d", cpt);
439     xbt_dynar_pop(d, &s2);
440     xbt_test_assert2(!strcmp(buf, s2),
441                      "The retrieved value is not the same than the injected one (%s!=%s)",
442                      buf, s2);
443     free(s2);
444   }
445   /* 4. Free the resources */
446   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
447   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
448   /* in your code is naturally the way to go outside a regression test */
449
450
451   xbt_test_add2
452       ("==== Push %d strings, insert %d strings in the middle, shift everything",
453        NB_ELEM, NB_ELEM / 5);
454   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
455   for (cpt = 0; cpt < NB_ELEM; cpt++) {
456     sprintf(buf, "%d", cpt);
457     s1 = strdup(buf);
458     xbt_dynar_push(d, &s1);
459   }
460   for (cpt = 0; cpt < NB_ELEM / 5; cpt++) {
461     sprintf(buf, "%d", cpt);
462     s1 = strdup(buf);
463     xbt_dynar_insert_at(d, NB_ELEM / 2, &s1);
464   }
465
466   for (cpt = 0; cpt < NB_ELEM / 2; cpt++) {
467     sprintf(buf, "%d", cpt);
468     xbt_dynar_shift(d, &s2);
469     xbt_test_assert2(!strcmp(buf, s2),
470                      "The retrieved value is not the same than the injected one at the begining (%s!=%s)",
471                      buf, s2);
472     free(s2);
473   }
474   for (cpt = (NB_ELEM / 5) - 1; cpt >= 0; cpt--) {
475     sprintf(buf, "%d", cpt);
476     xbt_dynar_shift(d, &s2);
477     xbt_test_assert2(!strcmp(buf, s2),
478                      "The retrieved value is not the same than the injected one in the middle (%s!=%s)",
479                      buf, s2);
480     free(s2);
481   }
482   for (cpt = NB_ELEM / 2; cpt < NB_ELEM; cpt++) {
483     sprintf(buf, "%d", cpt);
484     xbt_dynar_shift(d, &s2);
485     xbt_test_assert2(!strcmp(buf, s2),
486                      "The retrieved value is not the same than the injected one at the end (%s!=%s)",
487                      buf, s2);
488     free(s2);
489   }
490   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
491   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
492   /* in your code is naturally the way to go outside a regression test */
493
494
495   xbt_test_add3("==== Push %d strings, remove %d-%d. free the rest",
496                 NB_ELEM, 2 * (NB_ELEM / 5), 4 * (NB_ELEM / 5));
497   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
498   for (cpt = 0; cpt < NB_ELEM; cpt++) {
499     sprintf(buf, "%d", cpt);
500     s1 = strdup(buf);
501     xbt_dynar_push(d, &s1);
502   }
503   for (cpt = 2 * (NB_ELEM / 5); cpt < 4 * (NB_ELEM / 5); cpt++) {
504     sprintf(buf, "%d", cpt);
505     xbt_dynar_remove_at(d, 2 * (NB_ELEM / 5), &s2);
506     xbt_test_assert2(!strcmp(buf, s2),
507                      "Remove a bad value. Got %s, expected %s", s2, buf);
508     free(s2);
509   }
510   xbt_dynar_free(&d);           /* end_of_doxygen */
511 }
512
513
514 /*******************************************************************************/
515 /*******************************************************************************/
516 /*******************************************************************************/
517 #include "xbt/synchro.h"
518 static void pusher_f(void *a)
519 {
520   xbt_dynar_t d = (xbt_dynar_t) a;
521   int i;
522   for (i = 0; i < 500; i++) {
523     xbt_dynar_push(d, &i);
524   }
525 }
526
527 static void poper_f(void *a)
528 {
529   xbt_dynar_t d = (xbt_dynar_t) a;
530   int i;
531   int data;
532   xbt_ex_t e;
533
534   for (i = 0; i < 500; i++) {
535     TRY {
536       xbt_dynar_pop(d, &data);
537     }
538     CATCH(e) {
539       if (e.category == bound_error) {
540         xbt_ex_free(e);
541         i--;
542       } else {
543         RETHROW;
544       }
545     }
546   }
547 }
548
549
550 XBT_TEST_UNIT("synchronized int", test_dynar_sync_int, "Synchronized dynars of integers")
551 {
552   /* Vars_decl [doxygen cruft] */
553   xbt_dynar_t d;
554   xbt_thread_t pusher, poper;
555
556   xbt_test_add0("==== Have a pusher and a popper on the dynar");
557   d = xbt_dynar_new_sync(sizeof(int), NULL);
558   pusher = xbt_thread_create("pusher", pusher_f, d, 0 /*not joinable */ );
559   poper = xbt_thread_create("poper", poper_f, d, 0 /*not joinable */ );
560   xbt_thread_join(pusher);
561   xbt_thread_join(poper);
562   xbt_dynar_free(&d);
563 }
564
565 /*******************************/
566 /* GENERATED FILE, DO NOT EDIT */
567 /*******************************/
568