X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/2993b7a4e92f65c6308a8a2997a32c4d5198ddd0..c20d392fa3f8d901885cb8c04d37230b4bdf1ef2:/src/dynar_unit.c diff --git a/src/dynar_unit.c b/src/dynar_unit.c index 6791935093..f520530744 100644 --- a/src/dynar_unit.c +++ b/src/dynar_unit.c @@ -8,7 +8,7 @@ /* GENERATED FILE, DO NOT EDIT */ /*******************************/ -#line 716 "xbt/dynar.c" +#line 753 "xbt/dynar.c" #define NB_ELEM 5000 @@ -28,13 +28,13 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers") xbt_dynar_foreach(d, cursor, i) { xbt_assert0(0, "Damnit, there is something in the empty dynar"); } - xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ - xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ - /* in your code is naturally the way to go outside a regression test */ + xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ + xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ + /* in your code is naturally the way to go outside a regression test */ xbt_test_add1 - ("==== Push %d int, set them again 3 times, traverse them, shift them", - NB_ELEM); + ("==== Push %d int, set them again 3 times, traverse them, shift them", + NB_ELEM); /* Populate_ints [doxygen cruft] */ /* 1. Populate the dynar */ d = xbt_dynar_new(sizeof(int), NULL); @@ -92,9 +92,9 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers") } /* 5. Free the resources */ - xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ - xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ - /* in your code is naturally the way to go outside a regression test */ + xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ + xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ + /* in your code is naturally the way to go outside a regression test */ xbt_test_add1("==== Unshift/pop %d int", NB_ELEM); d = xbt_dynar_new(sizeof(int), NULL); @@ -109,25 +109,25 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers") i, cpt); xbt_test_log2("Pop %d, length=%lu", cpt, xbt_dynar_length(d)); } - xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ - xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ - /* in your code is naturally the way to go outside a regression test */ + xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ + xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ + /* in your code is naturally the way to go outside a regression test */ xbt_test_add1 - ("==== Push %d int, insert 1000 int in the middle, shift everything", - NB_ELEM); + ("==== Push %d int, insert 1000 int in the middle, shift everything", + NB_ELEM); d = xbt_dynar_new(sizeof(int), NULL); for (cpt = 0; cpt < NB_ELEM; cpt++) { xbt_dynar_push_as(d, int, cpt); DEBUG2("Push %d, length=%lu", cpt, xbt_dynar_length(d)); } - for (cpt = 0; cpt < 1000; cpt++) { - xbt_dynar_insert_at_as(d, 2500, int, cpt); + for (cpt = 0; cpt < NB_ELEM/5; cpt++) { + xbt_dynar_insert_at_as(d, NB_ELEM/2, int, cpt); DEBUG2("Push %d, length=%lu", cpt, xbt_dynar_length(d)); } - for (cpt = 0; cpt < 2500; cpt++) { + for (cpt = 0; cpt < NB_ELEM/2; cpt++) { xbt_dynar_shift(d, &i); xbt_test_assert2(i == cpt, "The retrieved value is not the same than the injected one at the begining (%d!=%d)", @@ -146,11 +146,12 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers") "The retrieved value is not the same than the injected one at the end (%d!=%d)", i, cpt); } - xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ - xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ - /* in your code is naturally the way to go outside a regression test */ + xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ + xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ + /* in your code is naturally the way to go outside a regression test */ - xbt_test_add1("==== Push %d int, remove 2000-4000. free the rest", NB_ELEM); + xbt_test_add1("==== Push %d int, remove 2000-4000. free the rest", + NB_ELEM); d = xbt_dynar_new(sizeof(int), NULL); for (cpt = 0; cpt < NB_ELEM; cpt++) xbt_dynar_push_as(d, int, cpt); @@ -161,9 +162,82 @@ XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers") "Remove a bad value. Got %d, expected %d", i, cpt); DEBUG2("remove %d, length=%lu", cpt, xbt_dynar_length(d)); } - xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ - xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ - /* in your code is naturally the way to go outside a regression test */ + xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ + xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ + /* in your code is naturally the way to go outside a regression test */ +} + +/*******************************************************************************/ +/*******************************************************************************/ +/*******************************************************************************/ +XBT_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dynar_remove functions") +{ + xbt_dynar_t d = xbt_dynar_new(sizeof(int), NULL); + unsigned int cursor,cpt; + + xbt_test_add1("==== Insert %d int, traverse them, remove them",NB_ELEM); + /* Populate_ints [doxygen cruft] */ + /* 1. Populate the dynar */ + for (cpt = 0; cpt < NB_ELEM; cpt++) { + xbt_dynar_insert_at(d, cpt, &cpt); + xbt_test_log2("Push %d, length=%lu", cpt, xbt_dynar_length(d)); + } + + /* 3. Traverse the dynar */ + xbt_dynar_foreach(d, cursor, cpt) { + xbt_test_assert2(cursor == cpt, + "The retrieved value is not the same than the injected one (%d!=%d)", + cursor, cpt); + } + /* end_of_traversal */ + + /* Re-fill with the same values using set_as (and re-verify) */ + for (cpt = 0; cpt < NB_ELEM; cpt++) + xbt_dynar_set_as(d, cpt, int, cpt); + xbt_dynar_foreach(d, cursor, cpt) + xbt_test_assert2(cursor == cpt, + "The retrieved value is not the same than the injected one (%d!=%d)", + cursor, cpt); + + for (cpt = 0; cpt < NB_ELEM; cpt++) { + int val; + xbt_dynar_remove_at(d,0,&val); + xbt_test_assert2(cpt == val, + "The retrieved value is not the same than the injected one (%d!=%d)", + cursor, cpt); + } + xbt_test_assert1(xbt_dynar_length(d) == 0, + "There is still %lu elements in the dynar after removing everything", + xbt_dynar_length(d)); + xbt_dynar_free(&d); + + /* ********************* */ + xbt_test_add1("==== Insert %d int in reverse order, traverse them, remove them",NB_ELEM); + d = xbt_dynar_new(sizeof(int), NULL); + for (cpt = NB_ELEM-1; cpt >=0; cpt--) { + xbt_dynar_replace(d, cpt, &cpt); + xbt_test_log2("Push %d, length=%lu", cpt, xbt_dynar_length(d)); + } + + /* 3. Traverse the dynar */ + xbt_dynar_foreach(d, cursor, cpt) { + xbt_test_assert2(cursor == cpt, + "The retrieved value is not the same than the injected one (%d!=%d)", + cursor, cpt); + } + /* end_of_traversal */ + + for (cpt =NB_ELEM-1; cpt >=0; cpt--) { + int val; + xbt_dynar_remove_at(d,xbt_dynar_length(d)-1,&val); + xbt_test_assert2(cpt == val, + "The retrieved value is not the same than the injected one (%d!=%d)", + cursor, cpt); + } + xbt_test_assert1(xbt_dynar_length(d) == 0, + "There is still %lu elements in the dynar after removing everything", + xbt_dynar_length(d)); + xbt_dynar_free(&d); } /*******************************************************************************/ @@ -179,11 +253,12 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles") xbt_test_add0("==== Traverse the empty dynar"); d = xbt_dynar_new(sizeof(int), NULL); xbt_dynar_foreach(d, cursor, cpt) { - xbt_test_assert0(FALSE, "Damnit, there is something in the empty dynar"); + xbt_test_assert0(FALSE, + "Damnit, there is something in the empty dynar"); } - xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ - xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ - /* in your code is naturally the way to go outside a regression test */ + xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ + xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ + /* in your code is naturally the way to go outside a regression test */ xbt_test_add0("==== Push/shift 5000 doubles"); d = xbt_dynar_new(sizeof(double), NULL); @@ -204,9 +279,9 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles") "The retrieved value is not the same than the injected one (%f!=%f)", d1, d2); } - xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ - xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ - /* in your code is naturally the way to go outside a regression test */ + xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ + xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ + /* in your code is naturally the way to go outside a regression test */ xbt_test_add0("==== Unshift/pop 5000 doubles"); d = xbt_dynar_new(sizeof(double), NULL); @@ -221,14 +296,14 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles") "The retrieved value is not the same than the injected one (%f!=%f)", d1, d2); } - xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ - xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ - /* in your code is naturally the way to go outside a regression test */ + xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ + xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ + /* in your code is naturally the way to go outside a regression test */ xbt_test_add0 - ("==== Push 5000 doubles, insert 1000 doubles in the middle, shift everything"); + ("==== Push 5000 doubles, insert 1000 doubles in the middle, shift everything"); d = xbt_dynar_new(sizeof(double), NULL); for (cpt = 0; cpt < 5000; cpt++) { d1 = (double) cpt; @@ -261,9 +336,9 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles") "The retrieved value is not the same than the injected one at the end (%f!=%f)", d1, d2); } - xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ - xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ - /* in your code is naturally the way to go outside a regression test */ + xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ + xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ + /* in your code is naturally the way to go outside a regression test */ xbt_test_add0("==== Push 5000 double, remove 2000-4000. free the rest"); @@ -278,9 +353,9 @@ XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles") xbt_test_assert2(d1 == d2, "Remove a bad value. Got %f, expected %f", d2, d1); } - xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ - xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ - /* in your code is naturally the way to go outside a regression test */ + xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ + xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ + /* in your code is naturally the way to go outside a regression test */ } @@ -300,11 +375,12 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings") xbt_test_add0("==== Traverse the empty dynar"); d = xbt_dynar_new(sizeof(char *), &xbt_free_ref); xbt_dynar_foreach(d, iter, s1) { - xbt_test_assert0(FALSE, "Damnit, there is something in the empty dynar"); + xbt_test_assert0(FALSE, + "Damnit, there is something in the empty dynar"); } - xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ - xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ - /* in your code is naturally the way to go outside a regression test */ + xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ + xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ + /* in your code is naturally the way to go outside a regression test */ xbt_test_add1("==== Push %d strings, set them again 3 times, shift them", NB_ELEM); @@ -339,9 +415,9 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings") buf, s2); free(s2); } - xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ - xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ - /* in your code is naturally the way to go outside a regression test */ + xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ + xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ + /* in your code is naturally the way to go outside a regression test */ xbt_test_add1("==== Unshift, traverse and pop %d strings", NB_ELEM); d = xbt_dynar_new(sizeof(char **), &xbt_free_ref); @@ -367,14 +443,14 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings") free(s2); } /* 4. Free the resources */ - xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ - xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ - /* in your code is naturally the way to go outside a regression test */ + xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ + xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ + /* in your code is naturally the way to go outside a regression test */ xbt_test_add2 - ("==== Push %d strings, insert %d strings in the middle, shift everything", - NB_ELEM, NB_ELEM / 5); + ("==== Push %d strings, insert %d strings in the middle, shift everything", + NB_ELEM, NB_ELEM / 5); d = xbt_dynar_new(sizeof(char *), &xbt_free_ref); for (cpt = 0; cpt < NB_ELEM; cpt++) { sprintf(buf, "%d", cpt); @@ -411,13 +487,13 @@ XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings") buf, s2); free(s2); } - xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ - xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ - /* in your code is naturally the way to go outside a regression test */ + xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */ + xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing it only once */ + /* in your code is naturally the way to go outside a regression test */ - xbt_test_add3("==== Push %d strings, remove %d-%d. free the rest", NB_ELEM, - 2 * (NB_ELEM / 5), 4 * (NB_ELEM / 5)); + xbt_test_add3("==== Push %d strings, remove %d-%d. free the rest", + NB_ELEM, 2 * (NB_ELEM / 5), 4 * (NB_ELEM / 5)); d = xbt_dynar_new(sizeof(char *), &xbt_free_ref); for (cpt = 0; cpt < NB_ELEM; cpt++) { sprintf(buf, "%d", cpt); @@ -471,7 +547,7 @@ static void poper_f(void *a) } -XBT_TEST_UNIT("synchronized int", test_dynar_sync_int,"Synchronized dynars of integers") +XBT_TEST_UNIT("synchronized int", test_dynar_sync_int, "Synchronized dynars of integers") { /* Vars_decl [doxygen cruft] */ xbt_dynar_t d; @@ -479,8 +555,8 @@ XBT_TEST_UNIT("synchronized int", test_dynar_sync_int,"Synchronized dynars of in xbt_test_add0("==== Have a pusher and a popper on the dynar"); d = xbt_dynar_new_sync(sizeof(int), NULL); - pusher = xbt_thread_create("pusher", pusher_f, d,0/*not joinable*/); - poper = xbt_thread_create("poper", poper_f, d,0/*not joinable*/); + pusher = xbt_thread_create("pusher", pusher_f, d, 0 /*not joinable */ ); + poper = xbt_thread_create("poper", poper_f, d, 0 /*not joinable */ ); xbt_thread_join(pusher); xbt_thread_join(poper); xbt_dynar_free(&d);