1 /*******************************/
2 /* GENERATED FILE, DO NOT EDIT */
3 /*******************************/
7 /*******************************/
8 /* GENERATED FILE, DO NOT EDIT */
9 /*******************************/
11 #line 753 "xbt/dynar.c"
15 XBT_LOG_EXTERNAL_CATEGORY(xbt_dyn);
16 XBT_LOG_DEFAULT_CATEGORY(xbt_dyn);
18 XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
20 /* Vars_decl [doxygen cruft] */
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");
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 */
36 ("==== Push %d int, set them again 3 times, traverse them, shift them",
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));
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)",
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)",
61 /* end_of_traversal */
63 for (cpt = 0; cpt < NB_ELEM; cpt++)
64 *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
66 for (cpt = 0; cpt < NB_ELEM; cpt++)
67 *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
68 /* xbt_dynar_set(d,cpt,&cpt); */
70 for (cpt = 0; cpt < NB_ELEM; cpt++)
71 *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
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)",
80 xbt_test_assert2(cpt == NB_ELEM,
81 "Cannot retrieve my %d values. Last got one is %d",
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)",
91 xbt_test_log2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
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 */
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));
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)",
110 xbt_test_log2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
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 */
118 ("==== Push %d int, insert 1000 int in the middle, shift everything",
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));
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));
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)",
135 DEBUG2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
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)",
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)",
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 */
153 xbt_test_add1("==== Push %d int, remove 2000-4000. free the rest",
155 d = xbt_dynar_new(sizeof(int), NULL);
156 for (cpt = 0; cpt < NB_ELEM; cpt++)
157 xbt_dynar_push_as(d, int, cpt);
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));
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 */
170 /*******************************************************************************/
171 /*******************************************************************************/
172 /*******************************************************************************/
173 XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dynar_remove functions")
175 xbt_dynar_t d = xbt_dynar_new(sizeof(int), NULL);
176 unsigned int cursor,cpt;
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));
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)",
192 /* end_of_traversal */
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)",
202 for (cpt = 0; cpt < NB_ELEM; cpt++) {
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)",
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));
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));
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)",
228 /* end_of_traversal */
230 for (cpt =NB_ELEM-1; cpt >=0; cpt--) {
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)",
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));
243 /*******************************************************************************/
244 /*******************************************************************************/
245 /*******************************************************************************/
246 XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
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");
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 */
263 xbt_test_add0("==== Push/shift 5000 doubles");
264 d = xbt_dynar_new(sizeof(double), NULL);
265 for (cpt = 0; cpt < 5000; cpt++) {
267 xbt_dynar_push(d, &d1);
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)",
275 for (cpt = 0; cpt < 5000; 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)",
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 */
286 xbt_test_add0("==== Unshift/pop 5000 doubles");
287 d = xbt_dynar_new(sizeof(double), NULL);
288 for (cpt = 0; cpt < 5000; cpt++) {
290 xbt_dynar_unshift(d, &d1);
292 for (cpt = 0; cpt < 5000; 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)",
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 */
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++) {
310 xbt_dynar_push(d, &d1);
312 for (cpt = 0; cpt < 1000; cpt++) {
314 xbt_dynar_insert_at(d, 2500, &d1);
317 for (cpt = 0; cpt < 2500; 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)",
323 DEBUG2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
325 for (cpt = 999; cpt >= 0; 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)",
332 for (cpt = 2500; cpt < 5000; 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)",
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 */
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++) {
348 xbt_dynar_push(d, &d1);
350 for (cpt = 2000; cpt < 4000; 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);
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 */
362 /* doxygen_string_cruft */
364 /*******************************************************************************/
365 /*******************************************************************************/
366 /*******************************************************************************/
367 XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
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");
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 */
385 xbt_test_add1("==== Push %d strings, set them again 3 times, shift them",
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);
393 xbt_dynar_push(d, &s1);
395 for (cpt = 0; cpt < NB_ELEM; cpt++) {
396 sprintf(buf, "%d", cpt);
398 xbt_dynar_replace(d, cpt, &s1);
400 for (cpt = 0; cpt < NB_ELEM; cpt++) {
401 sprintf(buf, "%d", cpt);
403 xbt_dynar_replace(d, cpt, &s1);
405 for (cpt = 0; cpt < NB_ELEM; cpt++) {
406 sprintf(buf, "%d", cpt);
408 xbt_dynar_replace(d, cpt, &s1);
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)",
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 */
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);
427 xbt_dynar_unshift(d, &s1);
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)",
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)",
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 */
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);
458 xbt_dynar_push(d, &s1);
460 for (cpt = 0; cpt < NB_ELEM / 5; cpt++) {
461 sprintf(buf, "%d", cpt);
463 xbt_dynar_insert_at(d, NB_ELEM / 2, &s1);
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)",
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)",
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)",
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 */
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);
501 xbt_dynar_push(d, &s1);
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);
510 xbt_dynar_free(&d); /* end_of_doxygen */
514 /*******************************************************************************/
515 /*******************************************************************************/
516 /*******************************************************************************/
517 #include "xbt/synchro.h"
518 static void pusher_f(void *a)
520 xbt_dynar_t d = (xbt_dynar_t) a;
522 for (i = 0; i < 500; i++) {
523 xbt_dynar_push(d, &i);
527 static void poper_f(void *a)
529 xbt_dynar_t d = (xbt_dynar_t) a;
534 for (i = 0; i < 500; i++) {
536 xbt_dynar_pop(d, &data);
539 if (e.category == bound_error) {
550 XBT_TEST_UNIT("synchronized int", test_dynar_sync_int, "Synchronized dynars of integers")
552 /* Vars_decl [doxygen cruft] */
554 xbt_thread_t pusher, poper;
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);
565 /*******************************/
566 /* GENERATED FILE, DO NOT EDIT */
567 /*******************************/