X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/3cbf54871089cc3dc50b6832652b5765e1601039..2d37e348a09783cda723c7019640ee69de168324:/src/xbt/dynar.cpp diff --git a/src/xbt/dynar.cpp b/src/xbt/dynar.cpp index b2420dac6e..1bd60bba1e 100644 --- a/src/xbt/dynar.cpp +++ b/src/xbt/dynar.cpp @@ -1,17 +1,17 @@ /* a generic DYNamic ARray implementation. */ -/* Copyright (c) 2004-2018. The SimGrid Team. +/* Copyright (c) 2004-2019. The SimGrid Team. * All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ +#include "xbt/dynar.h" +#include "simgrid/Exception.hpp" +#include "xbt/ex.h" +#include "xbt/log.h" #include "xbt/misc.h" #include "xbt/sysdep.h" -#include "xbt/log.h" -#include "xbt/ex.h" -#include -#include "xbt/dynar.h" #include XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dyn, xbt, "Dynamic arrays"); @@ -83,8 +83,8 @@ void xbt_dynar_dump(xbt_dynar_t dynar) /** @brief Constructor * - * \param elmsize size of each element in the dynar - * \param free_f function to call each time we want to get rid of an element (or nullptr if nothing to do). + * @param elmsize size of each element in the dynar + * @param free_f function to call each time we want to get rid of an element (or nullptr if nothing to do). * * Creates a new dynar. If a free_func is provided, the elements have to be pointer of pointer. That is to say that * dynars can contain either base types (int, char, double, etc) or pointer of pointers (struct **). @@ -124,9 +124,9 @@ void xbt_dynar_free_data(xbt_dynar_t dynar) /** @brief Destructor of the structure not touching to the content * - * \param dynar poor victim + * @param dynar poor victim * - * kilkil a dynar BUT NOT its content. Ie, the array is freed, but the content is not touched (the \a free_f function + * kilkil a dynar BUT NOT its content. Ie, the array is freed, but the content is not touched (the @a free_f function * is not used) */ void xbt_dynar_free_container(xbt_dynar_t* dynar) @@ -141,7 +141,7 @@ void xbt_dynar_free_container(xbt_dynar_t* dynar) /** @brief Frees the content and set the size to 0 * - * \param dynar who to squeeze + * @param dynar who to squeeze */ void xbt_dynar_reset(xbt_dynar_t const dynar) { @@ -156,8 +156,8 @@ void xbt_dynar_reset(xbt_dynar_t const dynar) /** @brief Merge dynar d2 into d1 * - * \param d1 dynar to keep - * \param d2 dynar to merge into d1. This dynar is free at end. + * @param d1 dynar to keep + * @param d2 dynar to merge into d1. This dynar is free at end. */ void xbt_dynar_merge(xbt_dynar_t* d1, xbt_dynar_t* d2) { @@ -177,15 +177,15 @@ void xbt_dynar_merge(xbt_dynar_t* d1, xbt_dynar_t* d2) } /** - * \brief Shrink the dynar by removing empty slots at the end of the internal array - * \param dynar a dynar - * \param empty_slots_wanted number of empty slots you want to keep at the end of the internal array for further + * @brief Shrink the dynar by removing empty slots at the end of the internal array + * @param dynar a dynar + * @param empty_slots_wanted number of empty slots you want to keep at the end of the internal array for further * insertions * - * Reduces the internal array size of the dynar to the number of elements plus \a empty_slots_wanted. + * Reduces the internal array size of the dynar to the number of elements plus @a empty_slots_wanted. * After removing elements from the dynar, you can call this function to make the dynar use less memory. - * Set \a empty_slots_wanted to zero to reduce the dynar internal array as much as possible. - * Note that if \a empty_slots_wanted is greater than the array size, the internal array is expanded instead of shrunk. + * Set @a empty_slots_wanted to zero to reduce the dynar internal array as much as possible. + * Note that if @a empty_slots_wanted is greater than the array size, the internal array is expanded instead of shrunk. */ void xbt_dynar_shrink(xbt_dynar_t dynar, int empty_slots_wanted) { @@ -194,7 +194,7 @@ void xbt_dynar_shrink(xbt_dynar_t dynar, int empty_slots_wanted) /** @brief Destructor * - * \param dynar poor victim + * @param dynar poor victim * * kilkil a dynar and its content */ @@ -206,7 +206,7 @@ void xbt_dynar_free(xbt_dynar_t* dynar) } } -/** \brief free a dynar passed as void* (handy to store dynar in dynars or dict) */ +/** @brief free a dynar passed as void* (handy to store dynar in dynars or dict) */ void xbt_dynar_free_voidp(void* d) { xbt_dynar_t dynar = (xbt_dynar_t)d; @@ -215,16 +215,16 @@ void xbt_dynar_free_voidp(void* d) /** @brief Count of dynar's elements * - * \param dynar the dynar we want to mesure + * @param dynar the dynar we want to mesure */ unsigned long xbt_dynar_length(const xbt_dynar_t dynar) { return (dynar ? (unsigned long) dynar->used : (unsigned long) 0); } - /**@brief check if a dynar is empty +/**@brief check if a dynar is empty * - *\param dynar the dynat we want to check + *@param dynar the dynat we want to check */ int xbt_dynar_is_empty(const xbt_dynar_t dynar) { @@ -233,9 +233,9 @@ int xbt_dynar_is_empty(const xbt_dynar_t dynar) /** @brief Retrieve a copy of the Nth element of a dynar. * - * \param dynar information dealer - * \param idx index of the slot we want to retrieve - * \param[out] dst where to put the result to. + * @param dynar information dealer + * @param idx index of the slot we want to retrieve + * @param[out] dst where to put the result to. */ void xbt_dynar_get_cpy(const xbt_dynar_t dynar, const unsigned long idx, void* const dst) { @@ -247,11 +247,11 @@ void xbt_dynar_get_cpy(const xbt_dynar_t dynar, const unsigned long idx, void* c /** @brief Retrieve a pointer to the Nth element of a dynar. * - * \param dynar information dealer - * \param idx index of the slot we want to retrieve - * \return the \a idx-th element of \a dynar. + * @param dynar information dealer + * @param idx index of the slot we want to retrieve + * @return the @a idx-th element of @a dynar. * - * \warning The returned value is the actual content of the dynar. + * @warning The returned value is the actual content of the dynar. * Make a copy before fooling with it. */ void* xbt_dynar_get_ptr(const xbt_dynar_t dynar, const unsigned long idx) @@ -280,9 +280,9 @@ void* xbt_dynar_set_at_ptr(const xbt_dynar_t dynar, const unsigned long idx) /** @brief Set the Nth element of a dynar (expanded if needed). Previous value at this position is NOT freed * - * \param dynar information dealer - * \param idx index of the slot we want to modify - * \param src What will be feeded to the dynar + * @param dynar information dealer + * @param idx index of the slot we want to modify + * @param src What will be feeded to the dynar * * If you want to free the previous content, use xbt_dynar_replace(). */ @@ -293,9 +293,9 @@ void xbt_dynar_set(xbt_dynar_t dynar, const int idx, const void* const src) /** @brief Set the Nth element of a dynar (expanded if needed). Previous value is freed * - * \param dynar - * \param idx - * \param object + * @param dynar + * @param idx + * @param object * * Set the Nth element of a dynar, expanding the dynar if needed, AND DO free the previous value at this position. If * you don't want to free the previous content, use xbt_dynar_set(). @@ -421,7 +421,7 @@ void xbt_dynar_remove_n_at(xbt_dynar_t const dynar, const unsigned int n, const * Beware that if your dynar contains pointed values (such as strings) instead of scalar, this function compares the * pointer value, not what's pointed. The only solution to search for a pointed value is then to write the foreach loop * yourself: - * \code + * @code * signed int position = -1; * xbt_dynar_foreach(dynar, iter, elem) { * if (not memcmp(elem, searched_element, sizeof(*elem))) { @@ -429,7 +429,7 @@ void xbt_dynar_remove_n_at(xbt_dynar_t const dynar, const unsigned int n, const * break; * } * } - * \endcode + * @endcode * * Raises not_found_error if not found. If you have less than 2 millions elements, you probably want to use * #xbt_dynar_search_or_negative() instead, so that you don't have to TRY/CATCH on element not found. @@ -594,8 +594,8 @@ void xbt_dynar_cursor_rm(xbt_dynar_t dynar, unsigned int* const cursor) * } * @endverbatim * - * \param dynar the dynar to sort - * \param compar_fn comparison function of type (int (compar_fn*) (const void*) (const void*)). + * @param dynar the dynar to sort + * @param compar_fn comparison function of type (int (compar_fn*) (const void*) (const void*)). */ void xbt_dynar_sort(xbt_dynar_t dynar, int_f_cpvoid_cpvoid_t compar_fn) { @@ -616,8 +616,8 @@ xbt_dynar_t xbt_dynar_sort_strings(xbt_dynar_t dynar) /** @brief Transform a dynar into a nullptr terminated array. * - * \param dynar the dynar to transform - * \return pointer to the first element of the array + * @param dynar the dynar to transform + * @return pointer to the first element of the array * * Note: The dynar won't be usable afterwards. */ @@ -633,10 +633,10 @@ void* xbt_dynar_to_array(xbt_dynar_t dynar) /** @brief Compare two dynars * - * \param d1 first dynar to compare - * \param d2 second dynar to compare - * \param compar function to use to compare elements - * \return 0 if d1 and d2 are equal and 1 if not equal + * @param d1 first dynar to compare + * @param d2 second dynar to compare + * @param compar function to use to compare elements + * @return 0 if d1 and d2 are equal and 1 if not equal * * d1 and d2 should be dynars of pointers. The compar function takes two elements and returns 0 when they are * considered equal, and a value different of zero when they are considered different. Finally, d2 is destroyed @@ -677,435 +677,3 @@ int xbt_dynar_compare(xbt_dynar_t d1, xbt_dynar_t d2, int (*compar)(const void*, xbt_dynar_free(&d2); return 0; } - -#ifdef SIMGRID_TEST - -#define NB_ELEM 5000 - -XBT_TEST_SUITE("dynar", "Dynar data container"); -XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(xbt_dyn); - -XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers") -{ - /* Vars_decl [doxygen cruft] */ - int i; - unsigned int cursor; - - xbt_test_add("==== Traverse the empty dynar"); - xbt_dynar_t d = xbt_dynar_new(sizeof(int), nullptr); - xbt_dynar_foreach(d, cursor, i) { - xbt_die( "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_test_add("==== 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), nullptr); - for (int cpt = 0; cpt < NB_ELEM; cpt++) { - xbt_dynar_push_as(d, int, cpt); /* This is faster (and possible only with scalars) */ - /* xbt_dynar_push(d,&cpt); This would also work */ - xbt_test_log("Push %d, length=%lu", cpt, xbt_dynar_length(d)); - } - - /* 2. Traverse manually the dynar */ - for (cursor = 0; cursor < NB_ELEM; cursor++) { - int* iptr = (int*)xbt_dynar_get_ptr(d, cursor); - xbt_test_assert(cursor == (unsigned int)*iptr, "The retrieved value is not the same than the injected one (%u!=%d)", - cursor, *iptr); - } - - /* 3. Traverse the dynar using the neat macro to that extend */ - int cpt; - xbt_dynar_foreach(d, cursor, cpt) { - xbt_test_assert(cursor == (unsigned int) cpt, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt); - } - /* end_of_traversal */ - - for (int cpt = 0; cpt < NB_ELEM; cpt++) - *(int *) xbt_dynar_get_ptr(d, cpt) = cpt; - - for (int cpt = 0; cpt < NB_ELEM; cpt++) - *(int *) xbt_dynar_get_ptr(d, cpt) = cpt; - - for (int cpt = 0; cpt < NB_ELEM; cpt++) - *(int *) xbt_dynar_get_ptr(d, cpt) = cpt; - - cpt = 0; - xbt_dynar_foreach(d, cursor, i) { - xbt_test_assert(i == cpt, "The retrieved value is not the same than the injected one (%d!=%d)", i, cpt); - cpt++; - } - xbt_test_assert(cpt == NB_ELEM, "Cannot retrieve my %d values. Last got one is %d", NB_ELEM, cpt); - - /* shifting [doxygen cruft] */ - /* 4. Shift all the values */ - for (int cpt = 0; cpt < NB_ELEM; cpt++) { - xbt_dynar_shift(d, &i); - xbt_test_assert(i == cpt, "The retrieved value is not the same than the injected one (%d!=%d)", i, cpt); - xbt_test_log("Pop %d, length=%lu", cpt, xbt_dynar_length(d)); - } - - int* pi; - xbt_dynar_foreach_ptr(d, cursor, pi) { - *pi = 0; - } - xbt_dynar_foreach(d, cursor, i) { - xbt_test_assert(i == 0, "The value is not the same as the expected one."); - } - xbt_dynar_foreach_ptr(d, cursor, pi) { - *pi = 1; - } - xbt_dynar_foreach(d, cursor, i) { - xbt_test_assert(i == 1, "The value is not the same as the expected one."); - } - - /* 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_test_add("==== Unshift/pop %d int", NB_ELEM); - d = xbt_dynar_new(sizeof(int), nullptr); - for (int cpt = 0; cpt < NB_ELEM; cpt++) { - xbt_dynar_unshift(d, &cpt); - XBT_DEBUG("Push %d, length=%lu", cpt, xbt_dynar_length(d)); - } - for (int cpt = 0; cpt < NB_ELEM; cpt++) { - i = xbt_dynar_pop_as(d, int); - xbt_test_assert(i == cpt, "The retrieved value is not the same than the injected one (%d!=%d)", i, cpt); - xbt_test_log("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_test_add ("==== Push %d int, insert 1000 int in the middle, shift everything", NB_ELEM); - d = xbt_dynar_new(sizeof(int), nullptr); - for (cpt = 0; cpt < NB_ELEM; cpt++) { - xbt_dynar_push_as(d, int, cpt); - XBT_DEBUG("Push %d, length=%lu", cpt, xbt_dynar_length(d)); - } - for (cpt = 0; cpt < NB_ELEM/5; cpt++) { - xbt_dynar_insert_at_as(d, NB_ELEM/2, int, cpt); - XBT_DEBUG("Push %d, length=%lu", cpt, xbt_dynar_length(d)); - } - - for (cpt = 0; cpt < NB_ELEM/2; cpt++) { - xbt_dynar_shift(d, &i); - xbt_test_assert(i == cpt, "The retrieved value is not the same than the injected one at the begining (%d!=%d)", - i, cpt); - XBT_DEBUG("Pop %d, length=%lu", cpt, xbt_dynar_length(d)); - } - for (cpt = 999; cpt >= 0; cpt--) { - xbt_dynar_shift(d, &i); - xbt_test_assert(i == cpt, "The retrieved value is not the same than the injected one in the middle (%d!=%d)", - i, cpt); - } - for (cpt = 2500; cpt < NB_ELEM; cpt++) { - xbt_dynar_shift(d, &i); - xbt_test_assert(i == cpt, "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_test_add("==== Push %d int, remove 2000-4000. free the rest", NB_ELEM); - d = xbt_dynar_new(sizeof(int), nullptr); - for (cpt = 0; cpt < NB_ELEM; cpt++) - xbt_dynar_push_as(d, int, cpt); - - for (cpt = 2000; cpt < 4000; cpt++) { - xbt_dynar_remove_at(d, 2000, &i); - xbt_test_assert(i == cpt, "Remove a bad value. Got %d, expected %d", i, cpt); - XBT_DEBUG("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_TEST_UNIT("insert",test_dynar_insert,"Using the xbt_dynar_insert and xbt_dynar_remove functions") -{ - xbt_dynar_t d = xbt_dynar_new(sizeof(unsigned int), nullptr); - unsigned int cursor; - - xbt_test_add("==== Insert %d int, traverse them, remove them",NB_ELEM); - /* Populate_ints [doxygen cruft] */ - /* 1. Populate the dynar */ - for (int cpt = 0; cpt < NB_ELEM; cpt++) { - xbt_dynar_insert_at(d, cpt, &cpt); - xbt_test_log("Push %d, length=%lu", cpt, xbt_dynar_length(d)); - } - - /* 3. Traverse the dynar */ - int cpt; - xbt_dynar_foreach(d, cursor, cpt) { - xbt_test_assert(cursor == (unsigned int) cpt, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt); - } - /* end_of_traversal */ - - /* Re-fill with the same values using set_as (and re-verify) */ - for (int cpt = 0; cpt < NB_ELEM; cpt++) - xbt_dynar_set_as(d, cpt, int, cpt); - xbt_dynar_foreach(d, cursor, cpt) - xbt_test_assert(cursor == (unsigned int) cpt, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt); - - for (int cpt = 0; cpt < NB_ELEM; cpt++) { - int val; - xbt_dynar_remove_at(d,0,&val); - xbt_test_assert(cpt == val, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt); - } - xbt_test_assert(xbt_dynar_is_empty(d), "There is still %lu elements in the dynar after removing everything", - xbt_dynar_length(d)); - xbt_dynar_free(&d); - - /* ********************* */ - xbt_test_add("==== Insert %d int in reverse order, traverse them, remove them",NB_ELEM); - d = xbt_dynar_new(sizeof(int), nullptr); - for (int cpt = NB_ELEM - 1; cpt >= 0; cpt--) { - xbt_dynar_replace(d, cpt, &cpt); - xbt_test_log("Push %d, length=%lu", cpt, xbt_dynar_length(d)); - } - - /* 3. Traverse the dynar */ - xbt_dynar_foreach(d, cursor, cpt) { - xbt_test_assert(cursor == (unsigned) cpt, "The retrieved value is not the same than the injected one (%u!=%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_assert(cpt == val, "The retrieved value is not the same than the injected one (%u!=%d)", cursor, cpt); - } - xbt_test_assert(xbt_dynar_is_empty(d), "There is still %lu elements in the dynar after removing everything", - xbt_dynar_length(d)); - xbt_dynar_free(&d); -} - -/*******************************************************************************/ -XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles") -{ - xbt_dynar_t d; - int cpt; - unsigned int cursor; - double d1, d2; - - xbt_test_add("==== Traverse the empty dynar"); - d = xbt_dynar_new(sizeof(int), nullptr); - xbt_dynar_foreach(d, cursor, cpt) { - xbt_test_assert(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_test_add("==== Push/shift 5000 doubles"); - d = xbt_dynar_new(sizeof(double), nullptr); - for (cpt = 0; cpt < 5000; cpt++) { - d1 = (double) cpt; - xbt_dynar_push(d, &d1); - } - xbt_dynar_foreach(d, cursor, d2) { - d1 = (double) cursor; - xbt_test_assert(d1 == d2, "The retrieved value is not the same than the injected one (%f!=%f)", d1, d2); - } - for (cpt = 0; cpt < 5000; cpt++) { - d1 = (double) cpt; - xbt_dynar_shift(d, &d2); - xbt_test_assert(d1 == d2, "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_test_add("==== Unshift/pop 5000 doubles"); - d = xbt_dynar_new(sizeof(double), nullptr); - for (cpt = 0; cpt < 5000; cpt++) { - d1 = (double) cpt; - xbt_dynar_unshift(d, &d1); - } - for (cpt = 0; cpt < 5000; cpt++) { - d1 = (double) cpt; - xbt_dynar_pop(d, &d2); - xbt_test_assert(d1 == d2, "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_test_add("==== Push 5000 doubles, insert 1000 doubles in the middle, shift everything"); - d = xbt_dynar_new(sizeof(double), nullptr); - for (cpt = 0; cpt < 5000; cpt++) { - d1 = (double) cpt; - xbt_dynar_push(d, &d1); - } - for (cpt = 0; cpt < 1000; cpt++) { - d1 = (double) cpt; - xbt_dynar_insert_at(d, 2500, &d1); - } - - for (cpt = 0; cpt < 2500; cpt++) { - d1 = (double) cpt; - xbt_dynar_shift(d, &d2); - xbt_test_assert(d1 == d2, "The retrieved value is not the same than the injected one at the begining (%f!=%f)", - d1, d2); - XBT_DEBUG("Pop %d, length=%lu", cpt, xbt_dynar_length(d)); - } - for (cpt = 999; cpt >= 0; cpt--) { - d1 = (double) cpt; - xbt_dynar_shift(d, &d2); - xbt_test_assert(d1 == d2, "The retrieved value is not the same than the injected one in the middle (%f!=%f)", - d1, d2); - } - for (cpt = 2500; cpt < 5000; cpt++) { - d1 = (double) cpt; - xbt_dynar_shift(d, &d2); - xbt_test_assert(d1 == d2, "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_test_add("==== Push 5000 double, remove 2000-4000. free the rest"); - d = xbt_dynar_new(sizeof(double), nullptr); - for (cpt = 0; cpt < 5000; cpt++) { - d1 = (double) cpt; - xbt_dynar_push(d, &d1); - } - for (cpt = 2000; cpt < 4000; cpt++) { - d1 = (double) cpt; - xbt_dynar_remove_at(d, 2000, &d2); - xbt_test_assert(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 */ -} - -/* doxygen_string_cruft */ - -/*******************************************************************************/ -XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings") -{ - unsigned int iter; - char buf[1024]; - char *s1, *s2; - - xbt_test_add("==== Traverse the empty dynar"); - xbt_dynar_t d = xbt_dynar_new(sizeof(char*), &xbt_free_ref); - xbt_dynar_foreach(d, iter, s1) { - xbt_test_assert(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_test_add("==== Push %d strings, set them again 3 times, shift them", NB_ELEM); - /* Populate_str [doxygen cruft] */ - d = xbt_dynar_new(sizeof(char *), &xbt_free_ref); - /* 1. Populate the dynar */ - for (int cpt = 0; cpt < NB_ELEM; cpt++) { - snprintf(buf,1023, "%d", cpt); - s1 = xbt_strdup(buf); - xbt_dynar_push(d, &s1); - } - for (int i = 0 ; i < 3 ; i++) { - for (int cpt = 0; cpt < NB_ELEM; cpt++) { - snprintf(buf,1023, "%d", cpt); - s1 = xbt_strdup(buf); - xbt_dynar_replace(d, cpt, &s1); - } - } - for (int cpt = 0; cpt < NB_ELEM; cpt++) { - snprintf(buf,1023, "%d", cpt); - xbt_dynar_shift(d, &s2); - xbt_test_assert(not strcmp(buf, s2), "The retrieved value is not the same than the injected one (%s!=%s)", buf, s2); - xbt_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_test_add("==== Unshift, traverse and pop %d strings", NB_ELEM); - d = xbt_dynar_new(sizeof(char **), &xbt_free_ref); - for (int cpt = 0; cpt < NB_ELEM; cpt++) { - snprintf(buf,1023, "%d", cpt); - s1 = xbt_strdup(buf); - xbt_dynar_unshift(d, &s1); - } - /* 2. Traverse the dynar with the macro */ - xbt_dynar_foreach(d, iter, s1) { - snprintf(buf,1023, "%u", NB_ELEM - iter - 1); - xbt_test_assert(not strcmp(buf, s1), "The retrieved value is not the same than the injected one (%s!=%s)", buf, s1); - } - /* 3. Traverse the dynar with the macro */ - for (int cpt = 0; cpt < NB_ELEM; cpt++) { - snprintf(buf,1023, "%d", cpt); - xbt_dynar_pop(d, &s2); - xbt_test_assert(not strcmp(buf, s2), "The retrieved value is not the same than the injected one (%s!=%s)", buf, s2); - xbt_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_test_add("==== 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 (int cpt = 0; cpt < NB_ELEM; cpt++) { - snprintf(buf,1023, "%d", cpt); - s1 = xbt_strdup(buf); - xbt_dynar_push(d, &s1); - } - for (int cpt = 0; cpt < NB_ELEM / 5; cpt++) { - snprintf(buf,1023, "%d", cpt); - s1 = xbt_strdup(buf); - xbt_dynar_insert_at(d, NB_ELEM / 2, &s1); - } - - for (int cpt = 0; cpt < NB_ELEM / 2; cpt++) { - snprintf(buf,1023, "%d", cpt); - xbt_dynar_shift(d, &s2); - xbt_test_assert(not strcmp(buf, s2), - "The retrieved value is not the same than the injected one at the begining (%s!=%s)", buf, s2); - xbt_free(s2); - } - for (int cpt = (NB_ELEM / 5) - 1; cpt >= 0; cpt--) { - snprintf(buf,1023, "%d", cpt); - xbt_dynar_shift(d, &s2); - xbt_test_assert(not strcmp(buf, s2), - "The retrieved value is not the same than the injected one in the middle (%s!=%s)", buf, s2); - xbt_free(s2); - } - for (int cpt = NB_ELEM / 2; cpt < NB_ELEM; cpt++) { - snprintf(buf,1023, "%d", cpt); - xbt_dynar_shift(d, &s2); - xbt_test_assert(not strcmp(buf, s2), - "The retrieved value is not the same than the injected one at the end (%s!=%s)", buf, s2); - xbt_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_test_add("==== 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 (int cpt = 0; cpt < NB_ELEM; cpt++) { - snprintf(buf,1023, "%d", cpt); - s1 = xbt_strdup(buf); - xbt_dynar_push(d, &s1); - } - for (int cpt = 2 * (NB_ELEM / 5); cpt < 4 * (NB_ELEM / 5); cpt++) { - snprintf(buf,1023, "%d", cpt); - xbt_dynar_remove_at(d, 2 * (NB_ELEM / 5), &s2); - xbt_test_assert(not strcmp(buf, s2), "Remove a bad value. Got %s, expected %s", s2, buf); - xbt_free(s2); - } - xbt_dynar_free(&d); /* end_of_doxygen */ -} -#endif /* SIMGRID_TEST */